1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
23 from neutronclient.common.exceptions import InvalidIpForSubnetClient
25 from snaps import file_utils
26 from snaps.openstack import create_network, create_router
27 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
28 from snaps.openstack.create_image import OpenStackImage, ImageSettings
29 from snaps.openstack.create_instance import (
30 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings,
31 VmInstanceSettingsError, FloatingIpSettingsError)
32 from snaps.openstack.create_keypairs import OpenStackKeypair, KeypairSettings
33 from snaps.openstack.create_network import (
34 OpenStackNetwork, PortSettings, NetworkSettings)
35 from snaps.openstack.create_router import OpenStackRouter, RouterSettings
36 from snaps.openstack.create_security_group import (
37 SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
39 from snaps.openstack.tests import openstack_tests, validation_utils
40 from snaps.openstack.tests.os_source_file_test import (
41 OSIntegrationTestCase, OSComponentTestCase)
42 from snaps.openstack.utils import nova_utils
44 __author__ = 'spisarski'
48 logger = logging.getLogger('create_instance_tests')
51 class VmInstanceSettingsUnitTests(unittest.TestCase):
53 Tests the construction of the VmInstanceSettings class
56 def test_no_params(self):
57 with self.assertRaises(VmInstanceSettingsError):
60 def test_empty_config(self):
61 with self.assertRaises(VmInstanceSettingsError):
62 VmInstanceSettings(config=dict())
64 def test_name_only(self):
65 with self.assertRaises(VmInstanceSettingsError):
66 VmInstanceSettings(name='foo')
68 def test_config_with_name_only(self):
69 with self.assertRaises(VmInstanceSettingsError):
70 VmInstanceSettings(config={'name': 'foo'})
72 def test_name_flavor_only(self):
73 with self.assertRaises(VmInstanceSettingsError):
74 VmInstanceSettings(name='foo', flavor='bar')
76 def test_config_with_name_flavor_only(self):
77 with self.assertRaises(VmInstanceSettingsError):
78 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
80 def test_name_flavor_port_only(self):
81 port_settings = PortSettings(name='foo-port', network_name='bar-net')
82 settings = VmInstanceSettings(name='foo', flavor='bar',
83 port_settings=[port_settings])
84 self.assertEqual('foo', settings.name)
85 self.assertEqual('bar', settings.flavor)
86 self.assertEqual(1, len(settings.port_settings))
87 self.assertEqual('foo-port', settings.port_settings[0].name)
88 self.assertEqual('bar-net', settings.port_settings[0].network_name)
89 self.assertEqual(0, len(settings.security_group_names))
90 self.assertEqual(0, len(settings.floating_ip_settings))
91 self.assertIsNone(settings.sudo_user)
92 self.assertEqual(900, settings.vm_boot_timeout)
93 self.assertEqual(300, settings.vm_delete_timeout)
94 self.assertEqual(180, settings.ssh_connect_timeout)
95 self.assertIsNone(settings.availability_zone)
97 def test_config_with_name_flavor_port_only(self):
98 port_settings = PortSettings(name='foo-port', network_name='bar-net')
99 settings = VmInstanceSettings(
100 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
101 self.assertEqual('foo', settings.name)
102 self.assertEqual('bar', settings.flavor)
103 self.assertEqual(1, len(settings.port_settings))
104 self.assertEqual('foo-port', settings.port_settings[0].name)
105 self.assertEqual('bar-net', settings.port_settings[0].network_name)
106 self.assertEqual(0, len(settings.security_group_names))
107 self.assertEqual(0, len(settings.floating_ip_settings))
108 self.assertIsNone(settings.sudo_user)
109 self.assertEqual(900, settings.vm_boot_timeout)
110 self.assertEqual(300, settings.vm_delete_timeout)
111 self.assertEqual(180, settings.ssh_connect_timeout)
112 self.assertIsNone(settings.availability_zone)
115 port_settings = PortSettings(name='foo-port', network_name='bar-net')
116 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
117 router_name='foo-bar-router')
119 settings = VmInstanceSettings(name='foo', flavor='bar',
120 port_settings=[port_settings],
121 security_group_names=['sec_grp_1'],
122 floating_ip_settings=[fip_settings],
123 sudo_user='joe', vm_boot_timeout=999,
124 vm_delete_timeout=333,
125 ssh_connect_timeout=111,
126 availability_zone='server name')
127 self.assertEqual('foo', settings.name)
128 self.assertEqual('bar', settings.flavor)
129 self.assertEqual(1, len(settings.port_settings))
130 self.assertEqual('foo-port', settings.port_settings[0].name)
131 self.assertEqual('bar-net', settings.port_settings[0].network_name)
132 self.assertEqual(1, len(settings.security_group_names))
133 self.assertEqual('sec_grp_1', settings.security_group_names[0])
134 self.assertEqual(1, len(settings.floating_ip_settings))
135 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
136 self.assertEqual('bar-port',
137 settings.floating_ip_settings[0].port_name)
138 self.assertEqual('foo-bar-router',
139 settings.floating_ip_settings[0].router_name)
140 self.assertEqual('joe', settings.sudo_user)
141 self.assertEqual(999, settings.vm_boot_timeout)
142 self.assertEqual(333, settings.vm_delete_timeout)
143 self.assertEqual(111, settings.ssh_connect_timeout)
144 self.assertEqual('server name', settings.availability_zone)
146 def test_config_all(self):
147 port_settings = PortSettings(name='foo-port', network_name='bar-net')
148 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
149 router_name='foo-bar-router')
151 settings = VmInstanceSettings(
152 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
153 'security_group_names': ['sec_grp_1'],
154 'floating_ips': [fip_settings], 'sudo_user': 'joe',
155 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
156 'ssh_connect_timeout': 111, 'availability_zone': 'server name'})
157 self.assertEqual('foo', settings.name)
158 self.assertEqual('bar', settings.flavor)
159 self.assertEqual(1, len(settings.port_settings))
160 self.assertEqual('foo-port', settings.port_settings[0].name)
161 self.assertEqual('bar-net', settings.port_settings[0].network_name)
162 self.assertEqual(1, len(settings.security_group_names))
163 self.assertEqual(1, len(settings.floating_ip_settings))
164 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
165 self.assertEqual('bar-port',
166 settings.floating_ip_settings[0].port_name)
167 self.assertEqual('foo-bar-router',
168 settings.floating_ip_settings[0].router_name)
169 self.assertEqual('joe', settings.sudo_user)
170 self.assertEqual(999, settings.vm_boot_timeout)
171 self.assertEqual(333, settings.vm_delete_timeout)
172 self.assertEqual(111, settings.ssh_connect_timeout)
173 self.assertEqual('server name', settings.availability_zone)
176 class FloatingIpSettingsUnitTests(unittest.TestCase):
178 Tests the construction of the FloatingIpSettings class
181 def test_no_params(self):
182 with self.assertRaises(FloatingIpSettingsError):
185 def test_empty_config(self):
186 with self.assertRaises(FloatingIpSettingsError):
187 FloatingIpSettings(**dict())
189 def test_name_only(self):
190 with self.assertRaises(FloatingIpSettingsError):
191 FloatingIpSettings(name='foo')
193 def test_config_with_name_only(self):
194 with self.assertRaises(FloatingIpSettingsError):
195 FloatingIpSettings(**{'name': 'foo'})
197 def test_name_port_only(self):
198 with self.assertRaises(FloatingIpSettingsError):
199 FloatingIpSettings(name='foo', port_name='bar')
201 def test_config_with_name_port_only(self):
202 with self.assertRaises(FloatingIpSettingsError):
203 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
205 def test_name_router_only(self):
206 with self.assertRaises(FloatingIpSettingsError):
207 FloatingIpSettings(name='foo', router_name='bar')
209 def test_config_with_name_router_only(self):
210 with self.assertRaises(FloatingIpSettingsError):
211 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
213 def test_name_port_router_name_only(self):
214 settings = FloatingIpSettings(name='foo', port_name='foo-port',
215 router_name='bar-router')
216 self.assertEqual('foo', settings.name)
217 self.assertEqual('foo-port', settings.port_name)
218 self.assertIsNone(settings.port_id)
219 self.assertEqual('bar-router', settings.router_name)
220 self.assertIsNone(settings.subnet_name)
221 self.assertTrue(settings.provisioning)
223 def test_name_port_router_id_only(self):
224 settings = FloatingIpSettings(name='foo', port_id='foo-port',
225 router_name='bar-router')
226 self.assertEqual('foo', settings.name)
227 self.assertEqual('foo-port', settings.port_id)
228 self.assertIsNone(settings.port_name)
229 self.assertEqual('bar-router', settings.router_name)
230 self.assertIsNone(settings.subnet_name)
231 self.assertTrue(settings.provisioning)
233 def test_config_with_name_port_router_only(self):
234 settings = FloatingIpSettings(
235 **{'name': 'foo', 'port_name': 'foo-port',
236 'router_name': 'bar-router'})
237 self.assertEqual('foo', settings.name)
238 self.assertEqual('foo-port', settings.port_name)
239 self.assertIsNone(settings.port_id)
240 self.assertEqual('bar-router', settings.router_name)
241 self.assertIsNone(settings.subnet_name)
242 self.assertTrue(settings.provisioning)
245 settings = FloatingIpSettings(name='foo', port_name='foo-port',
246 router_name='bar-router',
247 subnet_name='bar-subnet',
249 self.assertEqual('foo', settings.name)
250 self.assertEqual('foo-port', settings.port_name)
251 self.assertIsNone(settings.port_id)
252 self.assertEqual('bar-router', settings.router_name)
253 self.assertEqual('bar-subnet', settings.subnet_name)
254 self.assertFalse(settings.provisioning)
256 def test_config_all(self):
257 settings = FloatingIpSettings(
258 **{'name': 'foo', 'port_name': 'foo-port',
259 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
260 'provisioning': False})
261 self.assertEqual('foo', settings.name)
262 self.assertEqual('foo-port', settings.port_name)
263 self.assertIsNone(settings.port_id)
264 self.assertEqual('bar-router', settings.router_name)
265 self.assertEqual('bar-subnet', settings.subnet_name)
266 self.assertFalse(settings.provisioning)
269 class SimpleHealthCheck(OSIntegrationTestCase):
271 Test for the CreateInstance class with a single NIC/Port with Floating IPs
276 Instantiates the CreateImage object that is responsible for downloading
277 and creating an OS image file
280 super(self.__class__, self).__start__()
282 self.nova = nova_utils.nova_client(self.os_creds)
283 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
284 self.vm_inst_name = guid + '-inst'
285 self.port_1_name = guid + 'port-1'
287 # Initialize for tearDown()
288 self.image_creator = None
289 self.network_creator = None
290 self.flavor_creator = None
291 self.inst_creator = None
293 self.priv_net_config = openstack_tests.get_priv_net_config(
294 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
295 self.port_settings = PortSettings(
296 name=self.port_1_name,
297 network_name=self.priv_net_config.network_settings.name)
300 # Set the default image settings, then set any custom parameters sent
302 os_image_settings = openstack_tests.cirros_image_settings(
303 name=guid + '-image', image_metadata=self.image_metadata)
306 self.image_creator = OpenStackImage(self.os_creds,
308 self.image_creator.create()
311 self.network_creator = OpenStackNetwork(
312 self.os_creds, self.priv_net_config.network_settings)
313 self.network_creator.create()
316 self.flavor_creator = OpenStackFlavor(
318 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
319 vcpus=1, metadata=self.flavor_metadata))
320 self.flavor_creator.create()
321 except Exception as e:
327 Cleans the created object
329 if self.inst_creator:
331 self.inst_creator.clean()
332 except Exception as e:
334 'Unexpected exception cleaning VM instance with message'
337 if self.network_creator:
339 self.network_creator.clean()
340 except Exception as e:
342 'Unexpected exception cleaning network with message - %s',
345 if self.flavor_creator:
347 self.flavor_creator.clean()
348 except Exception as e:
350 'Unexpected exception cleaning flavor with message - %s',
353 if self.image_creator and not self.image_creator.image_settings.exists:
355 self.image_creator.clean()
356 except Exception as e:
358 'Unexpected exception cleaning image with message - %s',
361 super(self.__class__, self).__clean__()
363 def test_check_vm_ip_dhcp(self):
365 Tests the creation of an OpenStack instance with a single port and
366 ensures that it's assigned IP address is the actual.
368 instance_settings = VmInstanceSettings(
369 name=self.vm_inst_name,
370 flavor=self.flavor_creator.flavor_settings.name,
371 port_settings=[self.port_settings])
373 self.inst_creator = OpenStackVmInstance(
374 self.os_creds, instance_settings,
375 self.image_creator.image_settings)
376 self.inst_creator.create()
378 ip = self.inst_creator.get_port_ip(self.port_settings.name)
379 self.assertIsNotNone(ip)
381 self.assertTrue(self.inst_creator.vm_active(block=True))
383 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
386 class CreateInstanceSimpleTests(OSIntegrationTestCase):
388 Simple instance creation tests without any other objects
393 Instantiates the CreateImage object that is responsible for downloading
394 and creating an OS image file
397 super(self.__class__, self).__start__()
399 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
400 self.vm_inst_name = guid + '-inst'
401 self.nova = nova_utils.nova_client(self.os_creds)
402 os_image_settings = openstack_tests.cirros_image_settings(
403 name=guid + '-image', image_metadata=self.image_metadata)
405 net_config = openstack_tests.get_priv_net_config(
406 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
407 router_name=guid + '-pub-router', external_net=self.ext_net_name)
409 # Initialize for tearDown()
410 self.image_creator = None
411 self.flavor_creator = None
413 self.network_creator = None
414 self.inst_creator = None
418 self.image_creator = OpenStackImage(self.os_creds,
420 self.image_creator.create()
423 self.flavor_creator = OpenStackFlavor(
425 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
426 vcpus=2, metadata=self.flavor_metadata))
427 self.flavor_creator.create()
430 self.network_creator = OpenStackNetwork(
431 self.os_creds, net_config.network_settings)
432 self.network_creator.create()
434 self.port_settings = PortSettings(
436 network_name=net_config.network_settings.name)
438 except Exception as e:
444 Cleans the created object
446 if self.inst_creator:
448 self.inst_creator.clean()
449 except Exception as e:
451 'Unexpected exception cleaning VM instance with message '
454 if self.flavor_creator:
456 self.flavor_creator.clean()
457 except Exception as e:
459 'Unexpected exception cleaning flavor with message - %s',
462 if self.network_creator:
464 self.network_creator.clean()
465 except Exception as e:
467 'Unexpected exception cleaning network with message - %s',
470 if self.image_creator and not self.image_creator.image_settings.exists:
472 self.image_creator.clean()
473 except Exception as e:
475 'Unexpected exception cleaning image with message - %s', e)
477 super(self.__class__, self).__clean__()
479 def test_create_delete_instance(self):
481 Tests the creation of an OpenStack instance with a single port with a
482 static IP without a Floating IP.
484 instance_settings = VmInstanceSettings(
485 name=self.vm_inst_name,
486 flavor=self.flavor_creator.flavor_settings.name,
487 port_settings=[self.port_settings])
489 self.inst_creator = OpenStackVmInstance(
490 self.os_creds, instance_settings,
491 self.image_creator.image_settings)
493 vm_inst = self.inst_creator.create()
494 self.assertIsNotNone(nova_utils.get_server(
495 self.nova, vm_inst_settings=instance_settings))
498 nova_utils.delete_vm_instance(self.nova, vm_inst)
500 self.assertTrue(self.inst_creator.vm_deleted(block=True))
501 self.assertIsNone(nova_utils.get_server(
502 self.nova, vm_inst_settings=instance_settings))
504 # Exception should not be thrown
505 self.inst_creator.clean()
508 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
510 Test for the CreateInstance class with a single NIC/Port with Floating IPs
515 Instantiates the CreateImage object that is responsible for downloading
516 and creating an OS image file within OpenStack
518 super(self.__class__, self).__start__()
520 self.nova = nova_utils.nova_client(self.os_creds)
521 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
522 self.keypair_priv_filepath = 'tmp/' + guid
523 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
524 self.keypair_name = guid + '-kp'
525 self.vm_inst_name = guid + '-inst'
526 self.port_1_name = guid + 'port-1'
527 self.port_2_name = guid + 'port-2'
528 self.floating_ip_name = guid + 'fip1'
530 # Initialize for tearDown()
531 self.image_creator = None
532 self.network_creator = None
533 self.router_creator = None
534 self.flavor_creator = None
535 self.keypair_creator = None
536 self.sec_grp_creator = None
537 self.inst_creators = list()
539 self.pub_net_config = openstack_tests.get_pub_net_config(
540 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
541 router_name=guid + '-pub-router', external_net=self.ext_net_name)
542 os_image_settings = openstack_tests.cirros_image_settings(
543 name=guid + '-image', image_metadata=self.image_metadata)
546 self.image_creator = OpenStackImage(self.os_creds,
548 self.image_creator.create()
551 self.network_creator = OpenStackNetwork(
552 self.os_creds, self.pub_net_config.network_settings)
553 self.network_creator.create()
556 self.router_creator = OpenStackRouter(
557 self.os_creds, self.pub_net_config.router_settings)
558 self.router_creator.create()
561 self.flavor_creator = OpenStackFlavor(
563 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
564 vcpus=2, metadata=self.flavor_metadata))
565 self.flavor_creator.create()
567 self.keypair_creator = OpenStackKeypair(
568 self.os_creds, KeypairSettings(
569 name=self.keypair_name,
570 public_filepath=self.keypair_pub_filepath,
571 private_filepath=self.keypair_priv_filepath))
572 self.keypair_creator.create()
574 sec_grp_name = guid + '-sec-grp'
575 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
576 direction=Direction.ingress,
577 protocol=Protocol.icmp)
578 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
579 direction=Direction.ingress,
580 protocol=Protocol.tcp,
583 self.sec_grp_creator = OpenStackSecurityGroup(
585 SecurityGroupSettings(name=sec_grp_name,
586 rule_settings=[rule1, rule2]))
587 self.sec_grp_creator.create()
588 except Exception as e:
594 Cleans the created object
596 for inst_creator in self.inst_creators:
599 except Exception as e:
601 'Unexpected exception cleaning VM instance with message '
604 if self.keypair_creator:
606 self.keypair_creator.clean()
607 except Exception as e:
609 'Unexpected exception cleaning keypair with message - %s',
612 if os.path.isfile(self.keypair_pub_filepath):
613 os.remove(self.keypair_pub_filepath)
615 if os.path.isfile(self.keypair_priv_filepath):
616 os.remove(self.keypair_priv_filepath)
618 if self.flavor_creator:
620 self.flavor_creator.clean()
621 except Exception as e:
623 'Unexpected exception cleaning flavor with message - %s',
626 if self.sec_grp_creator:
628 self.sec_grp_creator.clean()
629 except Exception as e:
631 'Unexpected exception cleaning security group with message'
634 if self.router_creator:
636 self.router_creator.clean()
637 except Exception as e:
639 'Unexpected exception cleaning router with message - %s',
642 if self.network_creator:
644 self.network_creator.clean()
645 except Exception as e:
647 'Unexpected exception cleaning network with message - %s',
650 if self.image_creator and not self.image_creator.image_settings.exists:
652 self.image_creator.clean()
653 except Exception as e:
655 'Unexpected exception cleaning image with message - %s', e)
657 super(self.__class__, self).__clean__()
659 def test_single_port_static(self):
661 Tests the creation of an OpenStack instance with a single port with a
662 static IP without a Floating IP.
665 sub_settings = self.pub_net_config.network_settings.subnet_settings
666 port_settings = PortSettings(
667 name=self.port_1_name,
668 network_name=self.pub_net_config.network_settings.name,
670 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
672 instance_settings = VmInstanceSettings(
673 name=self.vm_inst_name,
674 flavor=self.flavor_creator.flavor_settings.name,
675 port_settings=[port_settings],
676 floating_ip_settings=[FloatingIpSettings(
677 name=self.floating_ip_name, port_name=self.port_1_name,
678 router_name=self.pub_net_config.router_settings.name)])
680 inst_creator = OpenStackVmInstance(
681 self.os_creds, instance_settings,
682 self.image_creator.image_settings,
683 keypair_settings=self.keypair_creator.keypair_settings)
684 self.inst_creators.append(inst_creator)
685 vm_inst = inst_creator.create()
687 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
688 self.assertTrue(inst_creator.vm_active(block=True))
689 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
691 def test_ssh_client_fip_before_active(self):
693 Tests the ability to access a VM via SSH and a floating IP when it has
694 been assigned prior to being active.
696 port_settings = PortSettings(
697 name=self.port_1_name,
698 network_name=self.pub_net_config.network_settings.name)
700 instance_settings = VmInstanceSettings(
701 name=self.vm_inst_name,
702 flavor=self.flavor_creator.flavor_settings.name,
703 port_settings=[port_settings],
704 floating_ip_settings=[FloatingIpSettings(
705 name=self.floating_ip_name, port_name=self.port_1_name,
706 router_name=self.pub_net_config.router_settings.name)])
708 inst_creator = OpenStackVmInstance(
709 self.os_creds, instance_settings,
710 self.image_creator.image_settings,
711 keypair_settings=self.keypair_creator.keypair_settings)
712 self.inst_creators.append(inst_creator)
713 vm_inst = inst_creator.create()
714 self.assertIsNotNone(vm_inst)
716 self.assertTrue(inst_creator.vm_active(block=True))
718 ip = inst_creator.get_port_ip(port_settings.name)
719 self.assertTrue(check_dhcp_lease(inst_creator, ip))
721 inst_creator.add_security_group(
722 self.sec_grp_creator.get_security_group())
723 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
725 self.assertTrue(validate_ssh_client(inst_creator))
727 def test_ssh_client_fip_after_active(self):
729 Tests the ability to access a VM via SSH and a floating IP when it has
730 been assigned prior to being active.
732 port_settings = PortSettings(
733 name=self.port_1_name,
734 network_name=self.pub_net_config.network_settings.name)
736 instance_settings = VmInstanceSettings(
737 name=self.vm_inst_name,
738 flavor=self.flavor_creator.flavor_settings.name,
739 port_settings=[port_settings],
740 floating_ip_settings=[FloatingIpSettings(
741 name=self.floating_ip_name, port_name=self.port_1_name,
742 router_name=self.pub_net_config.router_settings.name)])
744 inst_creator = OpenStackVmInstance(
745 self.os_creds, instance_settings,
746 self.image_creator.image_settings,
747 keypair_settings=self.keypair_creator.keypair_settings)
748 self.inst_creators.append(inst_creator)
750 # block=True will force the create() method to block until the
751 vm_inst = inst_creator.create(block=True)
752 self.assertIsNotNone(vm_inst)
754 self.assertTrue(inst_creator.vm_active(block=True))
756 ip = inst_creator.get_port_ip(port_settings.name)
757 self.assertTrue(check_dhcp_lease(inst_creator, ip))
759 inst_creator.add_security_group(
760 self.sec_grp_creator.get_security_group())
761 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
763 self.assertTrue(validate_ssh_client(inst_creator))
765 def test_ssh_client_fip_second_creator(self):
767 Tests the ability to access a VM via SSH and a floating IP via a
768 creator that is identical to the original creator.
770 port_settings = PortSettings(
771 name=self.port_1_name,
772 network_name=self.pub_net_config.network_settings.name)
774 instance_settings = VmInstanceSettings(
775 name=self.vm_inst_name,
776 flavor=self.flavor_creator.flavor_settings.name,
777 port_settings=[port_settings],
778 floating_ip_settings=[FloatingIpSettings(
779 name=self.floating_ip_name, port_name=self.port_1_name,
780 router_name=self.pub_net_config.router_settings.name)])
782 inst_creator = OpenStackVmInstance(
783 self.os_creds, instance_settings,
784 self.image_creator.image_settings,
785 keypair_settings=self.keypair_creator.keypair_settings)
786 self.inst_creators.append(inst_creator)
788 # block=True will force the create() method to block until the
789 vm_inst = inst_creator.create(block=True)
790 self.assertIsNotNone(vm_inst)
792 self.assertTrue(inst_creator.vm_active(block=True))
794 ip = inst_creator.get_port_ip(port_settings.name)
795 self.assertTrue(check_dhcp_lease(inst_creator, ip))
797 inst_creator.add_security_group(
798 self.sec_grp_creator.get_security_group())
799 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
801 self.assertTrue(validate_ssh_client(inst_creator))
803 inst_creator2 = OpenStackVmInstance(
804 self.os_creds, instance_settings,
805 self.image_creator.image_settings,
806 keypair_settings=self.keypair_creator.keypair_settings)
807 inst_creator2.create()
808 self.assertTrue(validate_ssh_client(inst_creator2))
811 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
813 Test for the CreateInstance class with a single NIC/Port where mac and IP
814 values are manually set
819 Instantiates the CreateImage object that is responsible for downloading
820 and creating an OS image file within OpenStack
822 super(self.__class__, self).__start__()
824 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
825 self.vm_inst_name = guid + '-inst'
826 self.port_1_name = guid + 'port-1'
827 self.port_2_name = guid + 'port-2'
828 self.floating_ip_name = guid + 'fip1'
830 # Initialize for tearDown()
831 self.image_creator = None
832 self.network_creator = None
833 self.flavor_creator = None
834 self.inst_creator = None
836 self.net_config = openstack_tests.get_priv_net_config(
837 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
838 router_name=guid + '-pub-router', external_net=self.ext_net_name)
839 os_image_settings = openstack_tests.cirros_image_settings(
840 name=guid + '-image', image_metadata=self.image_metadata)
844 self.image_creator = OpenStackImage(self.os_creds,
846 self.image_creator.create()
849 self.network_creator = OpenStackNetwork(
850 self.os_creds, self.net_config.network_settings)
851 self.network_creator.create()
854 self.flavor_creator = OpenStackFlavor(
856 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
857 vcpus=2, metadata=self.flavor_metadata))
858 self.flavor_creator.create()
859 except Exception as e:
865 Cleans the created object
867 if self.inst_creator:
869 self.inst_creator.clean()
870 except Exception as e:
872 'Unexpected exception cleaning VM instance with message '
875 if self.flavor_creator:
877 self.flavor_creator.clean()
878 except Exception as e:
880 'Unexpected exception cleaning flavor with message - %s',
883 if self.network_creator:
885 self.network_creator.clean()
886 except Exception as e:
888 'Unexpected exception cleaning network with message - %s',
891 if self.image_creator and not self.image_creator.image_settings.exists:
893 self.image_creator.clean()
894 except Exception as e:
896 'Unexpected exception cleaning image with message - %s', e)
898 super(self.__class__, self).__clean__()
900 def test_set_custom_valid_ip_one_subnet(self):
902 Tests the creation of an OpenStack instance with a single port with a
903 static IP on a network with one subnet.
906 sub_settings = self.net_config.network_settings.subnet_settings
907 port_settings = PortSettings(
908 name=self.port_1_name,
909 network_name=self.net_config.network_settings.name,
910 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
912 instance_settings = VmInstanceSettings(
913 name=self.vm_inst_name,
914 flavor=self.flavor_creator.flavor_settings.name,
915 port_settings=[port_settings])
917 self.inst_creator = OpenStackVmInstance(
918 self.os_creds, instance_settings,
919 self.image_creator.image_settings)
920 self.inst_creator.create(block=True)
922 self.assertEqual(ip, self.inst_creator.get_port_ip(
924 subnet_name=self.net_config.network_settings.subnet_settings[
927 def test_set_custom_invalid_ip_one_subnet(self):
929 Tests the creation of an OpenStack instance with a single port with a
930 static IP on a network with one subnet.
933 sub_settings = self.net_config.network_settings.subnet_settings
934 port_settings = PortSettings(
935 name=self.port_1_name,
936 network_name=self.net_config.network_settings.name,
937 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
939 instance_settings = VmInstanceSettings(
940 name=self.vm_inst_name,
941 flavor=self.flavor_creator.flavor_settings.name,
942 port_settings=[port_settings])
944 self.inst_creator = OpenStackVmInstance(
945 self.os_creds, instance_settings,
946 self.image_creator.image_settings)
948 with self.assertRaises(InvalidIpForSubnetClient):
949 self.inst_creator.create()
951 def test_set_custom_valid_mac(self):
953 Tests the creation of an OpenStack instance with a single port where
954 the MAC address is assigned.
956 mac_addr = '0a:1b:2c:3d:4e:5f'
957 port_settings = PortSettings(
958 name=self.port_1_name,
959 network_name=self.net_config.network_settings.name,
960 mac_address=mac_addr)
962 instance_settings = VmInstanceSettings(
963 name=self.vm_inst_name,
964 flavor=self.flavor_creator.flavor_settings.name,
965 port_settings=[port_settings])
967 self.inst_creator = OpenStackVmInstance(
968 self.os_creds, instance_settings,
969 self.image_creator.image_settings)
970 self.inst_creator.create(block=True)
972 self.assertEqual(mac_addr,
973 self.inst_creator.get_port_mac(self.port_1_name))
975 def test_set_custom_invalid_mac(self):
977 Tests the creation of an OpenStack instance with a single port where an
978 invalid MAC address value is being
979 assigned. This should raise an Exception
981 port_settings = PortSettings(
982 name=self.port_1_name,
983 network_name=self.net_config.network_settings.name,
986 instance_settings = VmInstanceSettings(
987 name=self.vm_inst_name,
988 flavor=self.flavor_creator.flavor_settings.name,
989 port_settings=[port_settings])
991 self.inst_creator = OpenStackVmInstance(
992 self.os_creds, instance_settings,
993 self.image_creator.image_settings)
995 with self.assertRaises(Exception):
996 self.inst_creator.create()
998 def test_set_custom_mac_and_ip(self):
1000 Tests the creation of an OpenStack instance with a single port where
1001 the IP and MAC address is assigned.
1004 mac_addr = '0a:1b:2c:3d:4e:5f'
1005 sub_settings = self.net_config.network_settings.subnet_settings
1006 port_settings = PortSettings(
1007 name=self.port_1_name,
1008 network_name=self.net_config.network_settings.name,
1009 mac_address=mac_addr,
1010 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1012 instance_settings = VmInstanceSettings(
1013 name=self.vm_inst_name,
1014 flavor=self.flavor_creator.flavor_settings.name,
1015 port_settings=[port_settings])
1017 self.inst_creator = OpenStackVmInstance(
1018 self.os_creds, instance_settings,
1019 self.image_creator.image_settings)
1020 self.inst_creator.create(block=True)
1022 self.assertEqual(ip, self.inst_creator.get_port_ip(
1024 subnet_name=self.net_config.network_settings.subnet_settings[
1026 self.assertEqual(mac_addr,
1027 self.inst_creator.get_port_mac(self.port_1_name))
1029 def test_set_allowed_address_pairs(self):
1031 Tests the creation of an OpenStack instance with a single port where
1032 max_allowed_address_pair is set.
1035 mac_addr = '0a:1b:2c:3d:4e:5f'
1036 pair = {'ip_address': ip, 'mac_address': mac_addr}
1037 port_settings = PortSettings(
1038 name=self.port_1_name,
1039 network_name=self.net_config.network_settings.name,
1040 allowed_address_pairs=[pair])
1042 instance_settings = VmInstanceSettings(
1043 name=self.vm_inst_name,
1044 flavor=self.flavor_creator.flavor_settings.name,
1045 port_settings=[port_settings])
1047 self.inst_creator = OpenStackVmInstance(
1048 self.os_creds, instance_settings,
1049 self.image_creator.image_settings)
1050 self.inst_creator.create(block=True)
1052 port = self.inst_creator.get_port_by_name(port_settings.name)
1053 self.assertIsNotNone(port)
1054 self.assertIsNotNone(port.allowed_address_pairs)
1055 self.assertEqual(1, len(port.allowed_address_pairs))
1056 validation_utils.objects_equivalent(pair,
1057 port.allowed_address_pairs[0])
1059 def test_set_allowed_address_pairs_bad_mac(self):
1061 Tests the creation of an OpenStack instance with a single port where
1062 max_allowed_address_pair is set with an invalid MAC address.
1066 pair = {'ip_address': ip, 'mac_address': mac_addr}
1068 pairs.add((ip, mac_addr))
1069 port_settings = PortSettings(
1070 name=self.port_1_name,
1071 network_name=self.net_config.network_settings.name,
1072 allowed_address_pairs=[pair])
1074 instance_settings = VmInstanceSettings(
1075 name=self.vm_inst_name,
1076 flavor=self.flavor_creator.flavor_settings.name,
1077 port_settings=[port_settings])
1079 self.inst_creator = OpenStackVmInstance(
1080 self.os_creds, instance_settings,
1081 self.image_creator.image_settings)
1082 with self.assertRaises(Exception):
1083 self.inst_creator.create()
1085 def test_set_allowed_address_pairs_bad_ip(self):
1087 Tests the creation of an OpenStack instance with a single port where
1088 max_allowed_address_pair is set with an invalid MAC address.
1091 mac_addr = '0a:1b:2c:3d:4e:5f'
1092 pair = {'ip_address': ip, 'mac_address': mac_addr}
1094 pairs.add((ip, mac_addr))
1095 port_settings = PortSettings(
1096 name=self.port_1_name,
1097 network_name=self.net_config.network_settings.name,
1098 allowed_address_pairs=[pair])
1100 instance_settings = VmInstanceSettings(
1101 name=self.vm_inst_name,
1102 flavor=self.flavor_creator.flavor_settings.name,
1103 port_settings=[port_settings])
1105 self.inst_creator = OpenStackVmInstance(
1106 self.os_creds, instance_settings,
1107 self.image_creator.image_settings)
1108 with self.assertRaises(Exception):
1109 self.inst_creator.create()
1112 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1114 Test for the CreateInstance where one VM is deployed to each compute node
1119 Instantiates the CreateImage object that is responsible for downloading
1120 and creating an OS image file within OpenStack
1122 super(self.__class__, self).__start__()
1124 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1125 self.vm_inst_name = guid + '-inst'
1126 self.port_base_name = guid + 'port'
1128 # Initialize for tearDown()
1129 self.image_creator = None
1130 self.flavor_creator = None
1131 self.network_creator = None
1132 self.inst_creators = list()
1134 self.priv_net_config = openstack_tests.get_priv_net_config(
1135 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1137 os_image_settings = openstack_tests.cirros_image_settings(
1138 name=guid + '-image', image_metadata=self.image_metadata)
1142 self.network_creator = OpenStackNetwork(
1143 self.admin_os_creds, self.priv_net_config.network_settings)
1144 self.network_creator.create()
1147 self.flavor_creator = OpenStackFlavor(
1148 self.admin_os_creds,
1149 FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1,
1150 vcpus=1, metadata=self.flavor_metadata))
1151 self.flavor_creator.create()
1154 self.image_creator = OpenStackImage(self.os_creds,
1156 self.image_creator.create()
1158 except Exception as e:
1164 Cleans the created object
1166 for inst_creator in self.inst_creators:
1168 inst_creator.clean()
1169 except Exception as e:
1171 'Unexpected exception cleaning VM instance with message '
1174 if self.flavor_creator:
1176 self.flavor_creator.clean()
1177 except Exception as e:
1179 'Unexpected exception cleaning flavor with message - %s',
1182 if self.network_creator:
1184 self.network_creator.clean()
1185 except Exception as e:
1187 'Unexpected exception cleaning network with message - %s',
1190 if self.image_creator and not self.image_creator.image_settings.exists:
1192 self.image_creator.clean()
1193 except Exception as e:
1195 'Unexpected exception cleaning image with message - %s', e)
1197 super(self.__class__, self).__clean__()
1199 def test_deploy_vm_to_each_compute_node(self):
1201 Tests the creation of OpenStack VM instances to each compute node.
1203 from snaps.openstack.utils import nova_utils
1204 nova = nova_utils.nova_client(self.admin_os_creds)
1205 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1207 # Create Instance on each server/zone
1209 for zone in zone_hosts:
1210 inst_name = self.vm_inst_name + '-' + zone
1212 port_settings = PortSettings(
1213 name=self.port_base_name + '-' + str(ctr),
1214 network_name=self.priv_net_config.network_settings.name)
1216 instance_settings = VmInstanceSettings(
1218 flavor=self.flavor_creator.flavor_settings.name,
1219 availability_zone=zone,
1220 port_settings=[port_settings])
1221 inst_creator = OpenStackVmInstance(
1222 self.admin_os_creds, instance_settings,
1223 self.image_creator.image_settings)
1224 self.inst_creators.append(inst_creator)
1225 inst_creator.create()
1227 # Validate instances to ensure they've been deployed to the correct
1230 for zone in zone_hosts:
1231 creator = self.inst_creators[index]
1232 self.assertTrue(creator.vm_active(block=True))
1233 info = creator.get_vm_info()
1234 deployed_zone = info['OS-EXT-AZ:availability_zone']
1235 deployed_host = info['OS-EXT-SRV-ATTR:host']
1236 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1240 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1242 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1244 These tests require a Centos image
1249 Instantiates the CreateImage object that is responsible for downloading
1250 and creating an OS image file within OpenStack
1252 super(self.__class__, self).__start__()
1254 self.nova = nova_utils.nova_client(self.os_creds)
1256 # Initialize for tearDown()
1257 self.image_creator = None
1258 self.network_creators = list()
1259 self.router_creators = list()
1260 self.flavor_creator = None
1261 self.keypair_creator = None
1262 self.sec_grp_creator = None
1263 self.inst_creator = None
1265 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1266 self.keypair_priv_filepath = 'tmp/' + self.guid
1267 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1268 self.keypair_name = self.guid + '-kp'
1269 self.vm_inst_name = self.guid + '-inst'
1270 self.port_1_name = self.guid + '-port-1'
1271 self.port_2_name = self.guid + '-port-2'
1272 self.floating_ip_name = self.guid + 'fip1'
1273 self.priv_net_config = openstack_tests.get_priv_net_config(
1274 net_name=self.guid + '-priv-net',
1275 subnet_name=self.guid + '-priv-subnet',
1276 router_name=self.guid + '-priv-router',
1277 external_net=self.ext_net_name)
1278 self.pub_net_config = openstack_tests.get_pub_net_config(
1279 net_name=self.guid + '-pub-net',
1280 subnet_name=self.guid + '-pub-subnet',
1281 router_name=self.guid + '-pub-router',
1282 external_net=self.ext_net_name)
1284 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1285 os_image_settings = openstack_tests.centos_image_settings(
1286 name=image_name, image_metadata=self.image_metadata)
1290 self.image_creator = OpenStackImage(self.os_creds,
1292 self.image_creator.create()
1294 # First network is public
1295 self.network_creators.append(OpenStackNetwork(
1296 self.os_creds, self.pub_net_config.network_settings))
1297 # Second network is private
1298 self.network_creators.append(OpenStackNetwork(
1299 self.os_creds, self.priv_net_config.network_settings))
1300 for network_creator in self.network_creators:
1301 network_creator.create()
1303 self.router_creators.append(OpenStackRouter(
1304 self.os_creds, self.pub_net_config.router_settings))
1305 self.router_creators.append(OpenStackRouter(
1306 self.os_creds, self.priv_net_config.router_settings))
1309 for router_creator in self.router_creators:
1310 router_creator.create()
1313 self.flavor_creator = OpenStackFlavor(
1314 self.admin_os_creds,
1315 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
1317 metadata=self.flavor_metadata))
1318 self.flavor_creator.create()
1321 self.keypair_creator = OpenStackKeypair(
1322 self.os_creds, KeypairSettings(
1323 name=self.keypair_name,
1324 public_filepath=self.keypair_pub_filepath,
1325 private_filepath=self.keypair_priv_filepath))
1326 self.keypair_creator.create()
1328 sec_grp_name = self.guid + '-sec-grp'
1329 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1330 direction=Direction.ingress,
1331 protocol=Protocol.icmp)
1332 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1333 direction=Direction.ingress,
1334 protocol=Protocol.tcp,
1337 self.sec_grp_creator = OpenStackSecurityGroup(
1339 SecurityGroupSettings(name=sec_grp_name,
1340 rule_settings=[rule1, rule2]))
1341 self.sec_grp_creator.create()
1348 Cleans the created objects
1350 if self.inst_creator:
1352 self.inst_creator.clean()
1353 except Exception as e:
1355 'Unexpected exception cleaning VM instance with message '
1358 if self.keypair_creator:
1360 self.keypair_creator.clean()
1361 except Exception as e:
1363 'Unexpected exception cleaning keypair with message - %s',
1366 if os.path.isfile(self.keypair_pub_filepath):
1367 os.remove(self.keypair_pub_filepath)
1369 if os.path.isfile(self.keypair_priv_filepath):
1370 os.remove(self.keypair_priv_filepath)
1372 if self.flavor_creator:
1374 self.flavor_creator.clean()
1375 except Exception as e:
1377 'Unexpected exception cleaning flavor with message - %s',
1380 for router_creator in self.router_creators:
1382 router_creator.clean()
1383 except Exception as e:
1385 'Unexpected exception cleaning router with message - %s',
1388 for network_creator in self.network_creators:
1390 network_creator.clean()
1391 except Exception as e:
1393 'Unexpected exception cleaning network with message - %s',
1396 if self.sec_grp_creator:
1398 self.sec_grp_creator.clean()
1399 except Exception as e:
1401 'Unexpected exception cleaning security group with message'
1404 if self.image_creator and not self.image_creator.image_settings.exists:
1406 self.image_creator.clean()
1407 except Exception as e:
1409 'Unexpected exception cleaning image with message - %s', e)
1411 super(self.__class__, self).__clean__()
1413 def test_dual_ports_dhcp(self):
1415 Tests the creation of an OpenStack instance with a dual ports/NICs with
1417 NOTE: This test and any others that call ansible will most likely fail
1418 unless you do one of two things:
1419 1. Have a ~/.ansible.cfg (or alternate means) to
1420 set host_key_checking = False
1421 2. Set the following environment variable in your executing shell:
1422 ANSIBLE_HOST_KEY_CHECKING=False
1423 Should this not be performed, the creation of the host ssh key will
1424 cause your ansible calls to fail.
1426 # Create ports/NICs for instance
1429 for network_creator in self.network_creators:
1430 ports_settings.append(PortSettings(
1431 name=self.guid + '-port-' + str(ctr),
1432 network_name=network_creator.network_settings.name))
1436 instance_settings = VmInstanceSettings(
1437 name=self.vm_inst_name,
1438 flavor=self.flavor_creator.flavor_settings.name,
1439 port_settings=ports_settings,
1440 floating_ip_settings=[FloatingIpSettings(
1441 name=self.floating_ip_name, port_name=self.port_1_name,
1442 router_name=self.pub_net_config.router_settings.name)])
1444 self.inst_creator = OpenStackVmInstance(
1445 self.os_creds, instance_settings,
1446 self.image_creator.image_settings,
1447 keypair_settings=self.keypair_creator.keypair_settings)
1449 vm_inst = self.inst_creator.create(block=True)
1451 self.assertEqual(vm_inst.id, self.inst_creator.get_vm_inst().id)
1453 # Effectively blocks until VM has been properly activated
1454 self.assertTrue(self.inst_creator.vm_active(block=True))
1456 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1457 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1459 # Add security group to VM
1460 self.inst_creator.add_security_group(
1461 self.sec_grp_creator.get_security_group())
1463 # Effectively blocks until VM's ssh port has been opened
1464 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1466 self.assertEqual(0, self.inst_creator.config_nics())
1469 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1471 Tests that include, add, and remove security groups from VM instances
1476 Instantiates the CreateImage object that is responsible for downloading
1477 and creating an OS image file within OpenStack
1479 super(self.__class__, self).__start__()
1481 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1482 self.vm_inst_name = self.guid + '-inst'
1483 self.nova = nova_utils.nova_client(self.os_creds)
1484 os_image_settings = openstack_tests.cirros_image_settings(
1485 name=self.guid + '-image', image_metadata=self.image_metadata)
1487 self.vm_inst_name = self.guid + '-inst'
1488 self.port_1_name = self.guid + 'port-1'
1489 self.port_2_name = self.guid + 'port-2'
1490 self.floating_ip_name = self.guid + 'fip1'
1492 net_config = openstack_tests.get_priv_net_config(
1493 net_name=self.guid + '-pub-net',
1494 subnet_name=self.guid + '-pub-subnet',
1495 router_name=self.guid + '-pub-router',
1496 external_net=self.ext_net_name)
1498 # Initialize for tearDown()
1499 self.image_creator = None
1500 self.flavor_creator = None
1501 self.network_creator = None
1502 self.router_creator = None
1503 self.inst_creator = None
1504 self.sec_grp_creators = list()
1508 self.image_creator = OpenStackImage(self.os_creds,
1510 self.image_creator.create()
1513 self.network_creator = OpenStackNetwork(
1514 self.os_creds, net_config.network_settings)
1515 self.network_creator.create()
1518 self.flavor_creator = OpenStackFlavor(
1519 self.admin_os_creds,
1520 FlavorSettings(name=self.guid + '-flavor-name', ram=256,
1522 metadata=self.flavor_metadata))
1523 self.flavor_creator.create()
1525 self.port_settings = PortSettings(
1526 name=self.guid + '-port',
1527 network_name=net_config.network_settings.name)
1528 except Exception as e:
1534 Cleans the created object
1536 if self.inst_creator:
1538 self.inst_creator.clean()
1539 except Exception as e:
1541 'Unexpected exception cleaning VM instance with message -'
1544 for sec_grp_creator in self.sec_grp_creators:
1546 sec_grp_creator.clean()
1547 except Exception as e:
1549 'Unexpected exception cleaning security group with message'
1552 if self.flavor_creator:
1554 self.flavor_creator.clean()
1555 except Exception as e:
1557 'Unexpected exception cleaning flavor with message - %s',
1560 if self.network_creator:
1562 self.network_creator.clean()
1563 except Exception as e:
1565 'Unexpected exception cleaning network with message - %s',
1568 if self.image_creator and not self.image_creator.image_settings.exists:
1570 self.image_creator.clean()
1571 except Exception as e:
1573 'Unexpected exception cleaning image with message - %s', e)
1575 super(self.__class__, self).__clean__()
1577 def test_add_security_group(self):
1579 Tests the addition of a security group created after the instance.
1582 instance_settings = VmInstanceSettings(
1583 name=self.vm_inst_name,
1584 flavor=self.flavor_creator.flavor_settings.name,
1585 port_settings=[self.port_settings])
1586 self.inst_creator = OpenStackVmInstance(
1587 self.os_creds, instance_settings,
1588 self.image_creator.image_settings)
1589 vm_inst = self.inst_creator.create(block=True)
1590 self.assertIsNotNone(vm_inst)
1592 # Create security group object to add to instance
1593 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1594 description='hello group')
1595 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1597 sec_grp = sec_grp_creator.create()
1598 self.sec_grp_creators.append(sec_grp_creator)
1600 # Check that group has not been added
1601 self.assertFalse(inst_has_sec_grp(
1602 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1604 # Add security group to instance after activated
1605 self.inst_creator.add_security_group(sec_grp)
1607 # Validate that security group has been added
1608 self.assertTrue(inst_has_sec_grp(
1609 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1611 def test_add_invalid_security_group(self):
1613 Tests the addition of a security group that no longer exists.
1616 instance_settings = VmInstanceSettings(
1617 name=self.vm_inst_name,
1618 flavor=self.flavor_creator.flavor_settings.name,
1619 port_settings=[self.port_settings])
1620 self.inst_creator = OpenStackVmInstance(
1621 self.os_creds, instance_settings,
1622 self.image_creator.image_settings)
1623 vm_inst = self.inst_creator.create(block=True)
1624 self.assertIsNotNone(vm_inst)
1626 # Create security group object to add to instance
1627 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1628 description='hello group')
1629 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1631 sec_grp = sec_grp_creator.create()
1632 sec_grp_creator.clean()
1633 self.sec_grp_creators.append(sec_grp_creator)
1635 # Check that group has not been added
1636 self.assertFalse(inst_has_sec_grp(
1637 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1639 # Add security group to instance after activated
1640 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1642 # Validate that security group has been added
1643 self.assertFalse(inst_has_sec_grp(
1644 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1646 def test_remove_security_group(self):
1648 Tests the removal of a security group created before and added to the
1651 # Create security group object to add to instance
1652 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1653 description='hello group')
1654 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1656 sec_grp = sec_grp_creator.create()
1657 self.sec_grp_creators.append(sec_grp_creator)
1660 instance_settings = VmInstanceSettings(
1661 name=self.vm_inst_name,
1662 flavor=self.flavor_creator.flavor_settings.name,
1663 security_group_names=[sec_grp_settings.name],
1664 port_settings=[self.port_settings])
1665 self.inst_creator = OpenStackVmInstance(
1666 self.os_creds, instance_settings,
1667 self.image_creator.image_settings)
1668 vm_inst = self.inst_creator.create(block=True)
1669 self.assertIsNotNone(vm_inst)
1671 # Check that group has been added
1672 self.assertTrue(inst_has_sec_grp(
1673 self.nova, vm_inst, sec_grp_settings.name))
1675 # Add security group to instance after activated
1676 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1678 # Validate that security group has been added
1679 self.assertFalse(inst_has_sec_grp(
1680 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1682 def test_remove_security_group_never_added(self):
1684 Tests the removal of a security group that was never added in the first
1687 # Create security group object to add to instance
1688 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1689 description='hello group')
1690 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1692 sec_grp = sec_grp_creator.create()
1693 self.sec_grp_creators.append(sec_grp_creator)
1696 instance_settings = VmInstanceSettings(
1697 name=self.vm_inst_name,
1698 flavor=self.flavor_creator.flavor_settings.name,
1699 port_settings=[self.port_settings])
1700 self.inst_creator = OpenStackVmInstance(
1701 self.os_creds, instance_settings,
1702 self.image_creator.image_settings)
1703 vm_inst = self.inst_creator.create(block=True)
1704 self.assertIsNotNone(vm_inst)
1706 # Check that group has been added
1707 self.assertFalse(inst_has_sec_grp(
1708 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1710 # Add security group to instance after activated
1711 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1713 # Validate that security group has been added
1714 self.assertFalse(inst_has_sec_grp(
1715 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1717 def test_add_same_security_group(self):
1719 Tests the addition of a security group created before add added to the
1722 # Create security group object to add to instance
1723 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1724 description='hello group')
1725 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1727 sec_grp = sec_grp_creator.create()
1728 self.sec_grp_creators.append(sec_grp_creator)
1731 instance_settings = VmInstanceSettings(
1732 name=self.vm_inst_name,
1733 flavor=self.flavor_creator.flavor_settings.name,
1734 security_group_names=[sec_grp_settings.name],
1735 port_settings=[self.port_settings])
1736 self.inst_creator = OpenStackVmInstance(
1737 self.os_creds, instance_settings,
1738 self.image_creator.image_settings)
1739 vm_inst = self.inst_creator.create(block=True)
1740 self.assertIsNotNone(vm_inst)
1742 # Check that group has been added
1743 self.assertTrue(inst_has_sec_grp(
1744 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1746 # Add security group to instance after activated
1747 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1749 # Validate that security group has been added
1750 self.assertTrue(inst_has_sec_grp(
1751 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1754 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1756 Returns true if instance has a security group of a given name
1757 :param nova: the nova client
1758 :param vm_inst: the VmInst domain object
1759 :param sec_grp_name: the name of the security group to validate
1762 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1763 for name in sec_grp_names:
1764 if sec_grp_name == name:
1769 def validate_ssh_client(instance_creator):
1771 Returns True if instance_creator returns an SSH client that is valid
1772 :param instance_creator: the object responsible for creating the VM
1776 ssh_active = instance_creator.vm_ssh_active(block=True)
1779 ssh_client = instance_creator.ssh_client()
1782 out = ssh_client.exec_command('pwd')[1]
1783 channel = out.channel
1784 in_buffer = channel.in_buffer
1785 pwd_out = in_buffer.read(1024)
1786 if not pwd_out or len(pwd_out) < 10:
1797 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
1799 Test for the CreateInstance class for creating an image from a 3-part image
1804 Instantiates the CreateImage object that is responsible for downloading
1805 and creating an OS image file within OpenStack
1807 super(self.__class__, self).__start__()
1809 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1810 self.image_name = guid
1811 self.vm_inst_name = guid + '-inst'
1812 self.nova = nova_utils.nova_client(self.os_creds)
1814 net_config = openstack_tests.get_priv_net_config(
1815 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1816 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1818 # Initialize for tearDown()
1819 self.image_creator = None
1820 self.network_creator = None
1821 self.flavor_creator = None
1822 self.inst_creator = None
1825 if self.image_metadata and 'disk_file' in self.image_metadata:
1826 metadata = self.image_metadata
1827 elif self.image_metadata and 'cirros' in self.image_metadata \
1828 and 'disk_file' in self.image_metadata['cirros']:
1829 metadata = self.image_metadata['cirros']
1832 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
1834 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
1836 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
1838 image_settings = openstack_tests.cirros_image_settings(
1839 name=self.image_name,
1840 image_metadata=metadata)
1842 if not image_settings.ramdisk_image_settings or not \
1843 image_settings.kernel_image_settings:
1845 '3 Part image will not be tested. Image metadata has '
1846 'overridden this functionality')
1848 self.image_creator = OpenStackImage(self.os_creds, image_settings)
1849 self.image_creator.create()
1852 self.flavor_creator = OpenStackFlavor(
1853 self.admin_os_creds,
1854 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
1855 vcpus=2, metadata=self.flavor_metadata))
1856 self.flavor_creator.create()
1859 self.network_creator = OpenStackNetwork(
1860 self.os_creds, net_config.network_settings)
1861 self.network_creator.create()
1863 self.port_settings = PortSettings(
1864 name=guid + '-port',
1865 network_name=net_config.network_settings.name)
1866 except Exception as e:
1872 Cleans the created object
1874 if self.inst_creator:
1876 self.inst_creator.clean()
1877 except Exception as e:
1879 'Unexpected exception cleaning VM instance with message -'
1882 if self.flavor_creator:
1884 self.flavor_creator.clean()
1885 except Exception as e:
1887 'Unexpected exception cleaning flavor with message - %s',
1890 if self.network_creator:
1892 self.network_creator.clean()
1893 except Exception as e:
1895 'Unexpected exception cleaning network with message - %s',
1898 if self.image_creator and not self.image_creator.image_settings.exists:
1900 self.image_creator.clean()
1901 except Exception as e:
1903 'Unexpected exception cleaning image with message - %s', e)
1905 super(self.__class__, self).__clean__()
1907 def test_create_instance_from_three_part_image(self):
1909 Tests the creation of an OpenStack instance from a 3-part image.
1911 instance_settings = VmInstanceSettings(
1912 name=self.vm_inst_name,
1913 flavor=self.flavor_creator.flavor_settings.name,
1914 port_settings=[self.port_settings])
1916 # The last created image is the main image from which we create the
1918 self.inst_creator = OpenStackVmInstance(
1919 self.os_creds, instance_settings,
1920 self.image_creator.image_settings)
1922 vm_inst = self.inst_creator.create()
1923 self.assertIsNotNone(vm_inst)
1924 self.assertTrue(self.inst_creator.vm_active(block=True))
1927 class CreateInstanceMockOfflineTests(OSComponentTestCase):
1929 Tests the custom image_metadata that can be set by clients for handling
1930 images differently than the default behavior of the existing tests
1931 primarily for offline testing
1936 Instantiates the CreateImage object that is responsible for downloading
1937 and creating an OS image file within OpenStack
1939 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1941 self.tmpDir = 'tmp/' + str(self.guid)
1942 if not os.path.exists(self.tmpDir):
1943 os.makedirs(self.tmpDir)
1945 self.image_name = self.guid + '-image'
1946 self.vm_inst_name = self.guid + '-inst'
1947 self.port_1_name = self.guid + 'port-1'
1949 # Initialize for tearDown()
1950 self.image_creator = None
1951 self.network_creator = None
1952 self.flavor_creator = None
1953 self.inst_creator = None
1955 self.priv_net_config = openstack_tests.get_priv_net_config(
1956 net_name=self.guid + '-priv-net',
1957 subnet_name=self.guid + '-priv-subnet')
1958 self.port_settings = PortSettings(
1959 name=self.port_1_name,
1960 network_name=self.priv_net_config.network_settings.name)
1963 # Download image file
1964 self.image_file = file_utils.download(
1965 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
1968 self.network_creator = OpenStackNetwork(
1969 self.os_creds, self.priv_net_config.network_settings)
1970 self.network_creator.create()
1973 self.flavor_creator = OpenStackFlavor(
1976 name=self.guid + '-flavor-name', ram=256, disk=10,
1978 self.flavor_creator.create()
1979 except Exception as e:
1985 Cleans the created object
1987 if self.inst_creator:
1989 self.inst_creator.clean()
1990 except Exception as e:
1992 'Unexpected exception cleaning VM instance with message - '
1995 if self.network_creator:
1997 self.network_creator.clean()
1998 except Exception as e:
2000 'Unexpected exception cleaning network with message - %s',
2003 if self.flavor_creator:
2005 self.flavor_creator.clean()
2006 except Exception as e:
2008 'Unexpected exception cleaning flavor with message - %s',
2011 if self.image_creator:
2013 self.image_creator.clean()
2014 except Exception as e:
2016 'Unexpected exception cleaning image with message - %s', e)
2018 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2019 shutil.rmtree(self.tmpDir)
2021 def test_inst_from_file_image_simple_flat(self):
2023 Creates a VM instance from a locally sourced file image using simply
2024 the 'disk_file' attribute vs. using the 'config' option which
2025 completely overrides all image settings
2028 metadata = {'disk_file': self.image_file.name}
2030 os_image_settings = openstack_tests.cirros_image_settings(
2031 name=self.image_name, image_metadata=metadata)
2032 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2033 self.assertEqual(openstack_tests.CIRROS_USER,
2034 os_image_settings.image_user)
2035 self.assertIsNone(os_image_settings.url)
2036 self.assertFalse(os_image_settings.exists)
2037 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2038 os_image_settings.format)
2040 self.assertIsNone(os_image_settings.kernel_image_settings)
2041 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2043 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2044 self.image_creator.create()
2046 instance_settings = VmInstanceSettings(
2047 name=self.vm_inst_name,
2048 flavor=self.flavor_creator.flavor_settings.name,
2049 port_settings=[self.port_settings])
2050 self.inst_creator = OpenStackVmInstance(
2051 self.os_creds, instance_settings,
2052 self.image_creator.image_settings)
2053 self.inst_creator.create()
2055 self.assertTrue(self.inst_creator.vm_active(block=True))
2057 def test_inst_from_file_image_simple_nested(self):
2059 Creates a VM instance from a locally sourced file image using simply
2060 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2061 which completely overrides all image settings
2064 metadata = {'cirros': {'disk_file': self.image_file.name}}
2066 os_image_settings = openstack_tests.cirros_image_settings(
2067 name=self.image_name, image_metadata=metadata)
2068 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2069 self.assertEqual(openstack_tests.CIRROS_USER,
2070 os_image_settings.image_user)
2071 self.assertIsNone(os_image_settings.url)
2072 self.assertFalse(os_image_settings.exists)
2073 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2074 os_image_settings.format)
2076 self.assertIsNone(os_image_settings.kernel_image_settings)
2077 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2079 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2080 self.image_creator.create()
2082 instance_settings = VmInstanceSettings(
2083 name=self.vm_inst_name,
2084 flavor=self.flavor_creator.flavor_settings.name,
2085 port_settings=[self.port_settings])
2086 self.inst_creator = OpenStackVmInstance(
2087 self.os_creds, instance_settings,
2088 self.image_creator.image_settings)
2089 self.inst_creator.create()
2091 self.assertTrue(self.inst_creator.vm_active(block=True))
2093 def test_inst_from_existing(self):
2095 Creates a VM instance from a image creator that has been configured to
2096 use an existing image
2099 os_image_settings = openstack_tests.cirros_image_settings(
2100 name=self.image_name)
2101 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2102 self.image_creator.create()
2104 image_settings = self.image_creator.image_settings
2105 test_image_creator = OpenStackImage(
2107 ImageSettings(name=image_settings.name,
2108 image_user=image_settings.image_user,
2110 test_image_creator.create()
2111 self.assertEqual(self.image_creator.get_image().id,
2112 test_image_creator.get_image().id)
2114 instance_settings = VmInstanceSettings(
2115 name=self.vm_inst_name,
2116 flavor=self.flavor_creator.flavor_settings.name,
2117 port_settings=[self.port_settings])
2118 self.inst_creator = OpenStackVmInstance(
2119 self.os_creds, instance_settings,
2120 test_image_creator.image_settings)
2121 self.inst_creator.create()
2123 self.assertTrue(self.inst_creator.vm_active(block=True))
2125 def test_inst_from_file_image_complex(self):
2127 Creates a VM instance from a locally sourced file image by overriding
2128 the default settings by using a dict() that can be read in by
2133 os_image_settings = openstack_tests.cirros_image_settings(
2134 name=self.image_name)
2135 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2136 self.image_creator.create()
2141 'name': os_image_settings.name,
2142 'image_user': os_image_settings.image_user,
2144 test_image_settings = openstack_tests.cirros_image_settings(
2145 image_metadata=metadata)
2146 test_image = OpenStackImage(self.os_creds, test_image_settings)
2149 instance_settings = VmInstanceSettings(
2150 name=self.vm_inst_name,
2151 flavor=self.flavor_creator.flavor_settings.name,
2152 port_settings=[self.port_settings])
2153 self.inst_creator = OpenStackVmInstance(self.os_creds,
2155 test_image_settings)
2156 self.inst_creator.create()
2158 self.assertTrue(self.inst_creator.vm_active(block=True))
2160 def test_inst_from_file_3part_image_complex(self):
2162 Creates a VM instance from a locally sourced file image by overriding
2163 the default settings by using a dict() that can be read in by
2168 kernel_file = file_utils.download(
2169 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2170 ramdisk_file = file_utils.download(
2171 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2176 'name': self.image_name,
2177 'image_user': openstack_tests.CIRROS_USER,
2178 'image_file': self.image_file.name,
2179 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2180 'kernel_image_settings': {
2181 'name': self.image_name + '-kernel',
2182 'image_user': openstack_tests.CIRROS_USER,
2183 'image_file': kernel_file.name,
2184 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2185 'ramdisk_image_settings': {
2186 'name': self.image_name + '-ramdisk',
2187 'image_user': openstack_tests.CIRROS_USER,
2188 'image_file': ramdisk_file.name,
2189 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2191 os_image_settings = openstack_tests.cirros_image_settings(
2192 name=self.image_name, image_metadata=metadata)
2193 self.assertEqual(self.image_name, os_image_settings.name)
2194 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2195 self.assertEqual(openstack_tests.CIRROS_USER,
2196 os_image_settings.image_user)
2197 self.assertIsNone(os_image_settings.url)
2198 self.assertFalse(os_image_settings.exists)
2199 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2200 os_image_settings.format)
2202 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2203 self.assertEqual(self.image_name + '-kernel',
2204 os_image_settings.kernel_image_settings.name)
2205 self.assertEqual(kernel_file.name,
2206 os_image_settings.kernel_image_settings.image_file)
2207 self.assertEqual(openstack_tests.CIRROS_USER,
2208 os_image_settings.kernel_image_settings.image_user)
2209 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2210 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2211 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2212 os_image_settings.kernel_image_settings.format)
2214 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2215 self.assertEqual(self.image_name + '-ramdisk',
2216 os_image_settings.ramdisk_image_settings.name)
2217 self.assertEqual(ramdisk_file.name,
2218 os_image_settings.ramdisk_image_settings.image_file)
2219 self.assertEqual(openstack_tests.CIRROS_USER,
2220 os_image_settings.ramdisk_image_settings.image_user)
2221 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2222 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2223 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2224 os_image_settings.ramdisk_image_settings.format)
2226 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2227 self.image_creator.create()
2229 instance_settings = VmInstanceSettings(
2230 name=self.vm_inst_name,
2231 flavor=self.flavor_creator.flavor_settings.name,
2232 port_settings=[self.port_settings])
2233 self.inst_creator = OpenStackVmInstance(
2234 self.os_creds, instance_settings,
2235 self.image_creator.image_settings)
2236 self.inst_creator.create()
2238 self.assertTrue(self.inst_creator.vm_active(block=True))
2240 def test_inst_from_file_3part_image_simple_flat(self):
2242 Creates a VM instance from a 3-part image locally sourced from file
2243 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2244 attributes vs. using the 'config' option which completely overrides all
2248 kernel_file = file_utils.download(
2249 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2250 ramdisk_file = file_utils.download(
2251 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2253 metadata = {'disk_file': self.image_file.name,
2254 'kernel_file': kernel_file.name,
2255 'ramdisk_file': ramdisk_file.name}
2257 os_image_settings = openstack_tests.cirros_image_settings(
2258 name=self.image_name, image_metadata=metadata)
2260 self.assertEqual(self.image_name, os_image_settings.name)
2261 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2262 self.assertEqual(openstack_tests.CIRROS_USER,
2263 os_image_settings.image_user)
2264 self.assertIsNone(os_image_settings.url)
2265 self.assertFalse(os_image_settings.exists)
2266 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2267 os_image_settings.format)
2269 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2270 self.assertEqual(self.image_name + '-kernel',
2271 os_image_settings.kernel_image_settings.name)
2272 self.assertEqual(kernel_file.name,
2273 os_image_settings.kernel_image_settings.image_file)
2274 self.assertEqual(openstack_tests.CIRROS_USER,
2275 os_image_settings.kernel_image_settings.image_user)
2276 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2277 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2278 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2279 os_image_settings.kernel_image_settings.format)
2281 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2282 self.assertEqual(self.image_name + '-ramdisk',
2283 os_image_settings.ramdisk_image_settings.name)
2284 self.assertEqual(ramdisk_file.name,
2285 os_image_settings.ramdisk_image_settings.image_file)
2286 self.assertEqual(openstack_tests.CIRROS_USER,
2287 os_image_settings.ramdisk_image_settings.image_user)
2288 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2289 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2290 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2291 os_image_settings.ramdisk_image_settings.format)
2293 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2294 self.image_creator.create()
2296 self.assertIsNotNone(self.image_creator.get_kernel_image())
2297 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2299 instance_settings = VmInstanceSettings(
2300 name=self.vm_inst_name,
2301 flavor=self.flavor_creator.flavor_settings.name,
2302 port_settings=[self.port_settings])
2303 self.inst_creator = OpenStackVmInstance(
2304 self.os_creds, instance_settings,
2305 self.image_creator.image_settings)
2306 self.inst_creator.create()
2308 self.assertTrue(self.inst_creator.vm_active(block=True))
2310 def test_inst_from_file_3part_image_simple_nested(self):
2312 Creates a VM instance from a 3-part image locally sourced from file
2313 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2314 attributes under 'cirros' vs. using the 'config' option which
2315 completely overrides all image settings
2318 kernel_file = file_utils.download(
2319 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2320 ramdisk_file = file_utils.download(
2321 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2323 metadata = {'cirros': {'disk_file': self.image_file.name,
2324 'kernel_file': kernel_file.name,
2325 'ramdisk_file': ramdisk_file.name}}
2327 os_image_settings = openstack_tests.cirros_image_settings(
2328 name=self.image_name, image_metadata=metadata)
2330 self.assertEqual(self.image_name, os_image_settings.name)
2331 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2332 self.assertEqual(openstack_tests.CIRROS_USER,
2333 os_image_settings.image_user)
2334 self.assertIsNone(os_image_settings.url)
2335 self.assertFalse(os_image_settings.exists)
2336 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2337 os_image_settings.format)
2339 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2340 self.assertEqual(self.image_name + '-kernel',
2341 os_image_settings.kernel_image_settings.name)
2342 self.assertEqual(kernel_file.name,
2343 os_image_settings.kernel_image_settings.image_file)
2344 self.assertEqual(openstack_tests.CIRROS_USER,
2345 os_image_settings.kernel_image_settings.image_user)
2346 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2347 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2348 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2349 os_image_settings.kernel_image_settings.format)
2351 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2352 self.assertEqual(self.image_name + '-ramdisk',
2353 os_image_settings.ramdisk_image_settings.name)
2354 self.assertEqual(ramdisk_file.name,
2355 os_image_settings.ramdisk_image_settings.image_file)
2356 self.assertEqual(openstack_tests.CIRROS_USER,
2357 os_image_settings.ramdisk_image_settings.image_user)
2358 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2359 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2360 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2361 os_image_settings.ramdisk_image_settings.format)
2363 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2364 self.image_creator.create()
2366 self.assertIsNotNone(self.image_creator.get_kernel_image())
2367 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2369 instance_settings = VmInstanceSettings(
2370 name=self.vm_inst_name,
2371 flavor=self.flavor_creator.flavor_settings.name,
2372 port_settings=[self.port_settings])
2373 self.inst_creator = OpenStackVmInstance(
2374 self.os_creds, instance_settings,
2375 self.image_creator.image_settings)
2376 self.inst_creator.create()
2378 self.assertTrue(self.inst_creator.vm_active(block=True))
2380 def test_inst_from_file_3part_image_existing(self):
2382 Creates a VM instance from a 3-part image that is existing
2385 kernel_file = file_utils.download(
2386 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2387 ramdisk_file = file_utils.download(
2388 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2390 metadata = {'cirros': {'disk_file': self.image_file.name,
2391 'kernel_file': kernel_file.name,
2392 'ramdisk_file': ramdisk_file.name}}
2394 os_image_settings = openstack_tests.cirros_image_settings(
2395 name=self.image_name, image_metadata=metadata)
2396 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2397 self.image_creator.create()
2399 image_settings = self.image_creator.image_settings
2400 test_image_creator = OpenStackImage(
2402 ImageSettings(name=image_settings.name,
2403 image_user=image_settings.image_user,
2405 test_image_creator.create()
2406 self.assertEqual(self.image_creator.get_image().id,
2407 test_image_creator.get_image().id)
2409 instance_settings = VmInstanceSettings(
2410 name=self.vm_inst_name,
2411 flavor=self.flavor_creator.flavor_settings.name,
2412 port_settings=[self.port_settings])
2413 self.inst_creator = OpenStackVmInstance(
2414 self.os_creds, instance_settings,
2415 test_image_creator.image_settings)
2416 self.inst_creator.create()
2418 self.assertTrue(self.inst_creator.vm_active(block=True))
2421 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2423 Tests the ability of two VMs to communicate when attached to separate
2424 private networks that are tied together with a router.
2429 Instantiates the CreateImage object that is responsible for downloading
2430 and creating an OS image file within OpenStack
2432 super(self.__class__, self).__start__()
2434 cidr1 = '10.200.201.0/24'
2435 cidr2 = '10.200.202.0/24'
2436 static_gateway_ip1 = '10.200.201.1'
2437 static_gateway_ip2 = '10.200.202.1'
2438 self.ip1 = '10.200.201.5'
2439 self.ip2 = '10.200.202.5'
2441 self.nova = nova_utils.nova_client(self.os_creds)
2443 # Initialize for tearDown()
2444 self.image_creator = None
2445 self.network_creators = list()
2446 self.router_creator = None
2447 self.flavor_creator = None
2448 self.sec_grp_creator = None
2449 self.inst_creators = list()
2451 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2452 self.vm_inst1_name = self.guid + '-inst1'
2453 self.vm_inst2_name = self.guid + '-inst2'
2454 self.port_1_name = self.guid + '-vm1-port'
2455 self.port_2_name = self.guid + '-vm2-port'
2456 self.net_config_1 = NetworkSettings(
2457 name=self.guid + '-net1',
2459 create_network.SubnetSettings(
2460 cidr=cidr1, name=self.guid + '-subnet1',
2461 gateway_ip=static_gateway_ip1)])
2462 self.net_config_2 = NetworkSettings(
2463 name=self.guid + '-net2',
2465 create_network.SubnetSettings(
2466 cidr=cidr2, name=self.guid + '-subnet2',
2467 gateway_ip=static_gateway_ip2)])
2469 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2470 os_image_settings = openstack_tests.cirros_image_settings(
2471 name=image_name, image_metadata=self.image_metadata)
2475 self.image_creator = OpenStackImage(self.os_creds,
2477 self.image_creator.create()
2479 # First network is public
2480 self.network_creators.append(OpenStackNetwork(
2481 self.os_creds, self.net_config_1))
2482 # Second network is private
2483 self.network_creators.append(OpenStackNetwork(
2484 self.os_creds, self.net_config_2))
2485 for network_creator in self.network_creators:
2486 network_creator.create()
2489 create_network.PortSettings(
2490 name=self.guid + '-router-port1',
2493 self.net_config_1.subnet_settings[0].name,
2494 'ip': static_gateway_ip1
2496 network_name=self.net_config_1.name,
2497 project_name=self.os_creds.project_name),
2498 create_network.PortSettings(
2499 name=self.guid + '-router-port2',
2502 self.net_config_2.subnet_settings[0].name,
2503 'ip': static_gateway_ip2
2505 network_name=self.net_config_2.name,
2506 project_name=self.os_creds.project_name)]
2508 router_settings = RouterSettings(name=self.guid + '-pub-router',
2509 port_settings=port_settings)
2510 self.router_creator = create_router.OpenStackRouter(
2511 self.os_creds, router_settings)
2512 self.router_creator.create()
2515 self.flavor_creator = OpenStackFlavor(
2516 self.admin_os_creds,
2517 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
2519 metadata=self.flavor_metadata))
2520 self.flavor_creator.create()
2522 sec_grp_name = self.guid + '-sec-grp'
2523 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
2524 direction=Direction.ingress,
2525 protocol=Protocol.icmp)
2526 self.sec_grp_creator = OpenStackSecurityGroup(
2528 SecurityGroupSettings(name=sec_grp_name,
2529 rule_settings=[rule1]))
2530 self.sec_grp_creator.create()
2537 Cleans the created objects
2539 for inst_creator in self.inst_creators:
2541 inst_creator.clean()
2542 except Exception as e:
2544 'Unexpected exception cleaning VM instance with message '
2547 if self.flavor_creator:
2549 self.flavor_creator.clean()
2550 except Exception as e:
2552 'Unexpected exception cleaning flavor with message - %s',
2555 if self.router_creator:
2557 self.router_creator.clean()
2558 except Exception as e:
2560 'Unexpected exception cleaning router with message - %s',
2563 for network_creator in self.network_creators:
2565 network_creator.clean()
2566 except Exception as e:
2568 'Unexpected exception cleaning network with message - %s',
2571 if self.sec_grp_creator:
2573 self.sec_grp_creator.clean()
2574 except Exception as e:
2576 'Unexpected exception cleaning security group with message'
2579 if self.image_creator and not self.image_creator.image_settings.exists:
2581 self.image_creator.clean()
2582 except Exception as e:
2584 'Unexpected exception cleaning image with message - %s', e)
2586 super(self.__class__, self).__clean__()
2588 def test_ping_via_router(self):
2590 Tests the creation of two OpenStack instances with one port on
2591 different private networks wit a router in between to ensure that they
2595 # Create ports/NICs for instance
2598 for network_creator in self.network_creators:
2599 ports_settings.append(PortSettings(
2600 name=self.guid + '-port-' + str(ctr),
2601 network_name=network_creator.network_settings.name))
2604 # Configure instances
2605 instance1_settings = VmInstanceSettings(
2606 name=self.vm_inst1_name,
2607 flavor=self.flavor_creator.flavor_settings.name,
2608 userdata=_get_ping_userdata(self.ip2),
2609 port_settings=[PortSettings(
2610 name=self.port_1_name,
2613 self.net_config_1.subnet_settings[0].name,
2616 network_name=self.network_creators[0].network_settings.name)])
2617 instance2_settings = VmInstanceSettings(
2618 name=self.vm_inst2_name,
2619 flavor=self.flavor_creator.flavor_settings.name,
2620 userdata=_get_ping_userdata(self.ip1),
2621 port_settings=[PortSettings(
2622 name=self.port_2_name,
2625 self.net_config_2.subnet_settings[0].name,
2628 network_name=self.network_creators[1].network_settings.name)])
2631 self.inst_creators.append(OpenStackVmInstance(
2632 self.os_creds, instance1_settings,
2633 self.image_creator.image_settings))
2634 self.inst_creators.append(OpenStackVmInstance(
2635 self.os_creds, instance2_settings,
2636 self.image_creator.image_settings))
2638 for inst_creator in self.inst_creators:
2639 inst_creator.create(block=True)
2641 # Check for DHCP lease
2642 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2643 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2645 # Effectively blocks until VM has been properly activated
2646 self.assertTrue(check_ping(self.inst_creators[0]))
2647 self.assertTrue(check_ping(self.inst_creators[1]))
2650 def check_dhcp_lease(inst_creator, ip, timeout=160):
2652 Returns true if the expected DHCP lease has been acquired
2653 :param inst_creator: the SNAPS OpenStackVmInstance object
2654 :param ip: the IP address to look for
2655 :param timeout: how long to query for IP address
2659 start_time = time.time()
2661 logger.info("Looking for IP %s in the console log" % ip)
2663 while timeout > time.time() - start_time:
2664 output = inst_creator.get_console_output()
2665 full_log = full_log + output
2666 if re.search(ip, output):
2667 logger.info('DHCP lease obtained logged in console')
2672 logger.error('Full console output -\n' + full_log)
2674 logger.debug('Full console output -\n' + full_log)
2679 def _get_ping_userdata(test_ip):
2681 Returns the post VM creation script to be added into the VM's userdata
2682 :param test_ip: the IP value to substitute into the script
2683 :return: the bash script contents
2686 return ("#!/bin/sh\n\n"
2688 " ping -c 1 %s 2>&1 >/dev/null\n"
2690 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
2691 " echo 'vPing OK'\n"
2694 " echo 'vPing KO'\n"
2701 def check_ping(vm_creator, timeout=160):
2703 Check for VM for ping result
2707 while tries < timeout:
2709 p_console = vm_creator.get_console_output()
2710 if "vPing OK" in p_console:
2712 elif "failed to read iid from metadata" in p_console or tries > 5: