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
24 from novaclient.exceptions import BadRequest
26 from snaps import file_utils
27 from snaps.openstack import create_network, create_router
28 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
29 from snaps.openstack.create_image import OpenStackImage, ImageSettings
30 from snaps.openstack.create_instance import (
31 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings,
32 VmInstanceSettingsError, FloatingIpSettingsError)
33 from snaps.openstack.create_keypairs import OpenStackKeypair, KeypairSettings
34 from snaps.openstack.create_network import (
35 OpenStackNetwork, PortSettings, NetworkSettings, SubnetSettings)
36 from snaps.openstack.create_router import OpenStackRouter, RouterSettings
37 from snaps.openstack.create_security_group import (
38 SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
40 from snaps.openstack.create_volume import OpenStackVolume, VolumeSettings
41 from snaps.openstack.tests import openstack_tests, validation_utils
42 from snaps.openstack.tests.os_source_file_test import (
43 OSIntegrationTestCase, OSComponentTestCase)
44 from snaps.openstack.utils import nova_utils
46 __author__ = 'spisarski'
50 logger = logging.getLogger('create_instance_tests')
53 class VmInstanceSettingsUnitTests(unittest.TestCase):
55 Tests the construction of the VmInstanceSettings class
58 def test_no_params(self):
59 with self.assertRaises(VmInstanceSettingsError):
62 def test_empty_config(self):
63 with self.assertRaises(VmInstanceSettingsError):
64 VmInstanceSettings(config=dict())
66 def test_name_only(self):
67 with self.assertRaises(VmInstanceSettingsError):
68 VmInstanceSettings(name='foo')
70 def test_config_with_name_only(self):
71 with self.assertRaises(VmInstanceSettingsError):
72 VmInstanceSettings(config={'name': 'foo'})
74 def test_name_flavor_only(self):
75 with self.assertRaises(VmInstanceSettingsError):
76 VmInstanceSettings(name='foo', flavor='bar')
78 def test_config_with_name_flavor_only(self):
79 with self.assertRaises(VmInstanceSettingsError):
80 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
82 def test_name_flavor_port_only(self):
83 port_settings = PortSettings(name='foo-port', network_name='bar-net')
84 settings = VmInstanceSettings(name='foo', flavor='bar',
85 port_settings=[port_settings])
86 self.assertEqual('foo', settings.name)
87 self.assertEqual('bar', settings.flavor)
88 self.assertEqual(1, len(settings.port_settings))
89 self.assertEqual('foo-port', settings.port_settings[0].name)
90 self.assertEqual('bar-net', settings.port_settings[0].network_name)
91 self.assertEqual(0, len(settings.security_group_names))
92 self.assertEqual(0, len(settings.floating_ip_settings))
93 self.assertIsNone(settings.sudo_user)
94 self.assertEqual(900, settings.vm_boot_timeout)
95 self.assertEqual(300, settings.vm_delete_timeout)
96 self.assertEqual(180, settings.ssh_connect_timeout)
97 self.assertIsNone(settings.availability_zone)
98 self.assertIsNone(settings.volume_names)
100 def test_config_with_name_flavor_port_only(self):
101 port_settings = PortSettings(name='foo-port', network_name='bar-net')
102 settings = VmInstanceSettings(
103 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
104 self.assertEqual('foo', settings.name)
105 self.assertEqual('bar', settings.flavor)
106 self.assertEqual(1, len(settings.port_settings))
107 self.assertEqual('foo-port', settings.port_settings[0].name)
108 self.assertEqual('bar-net', settings.port_settings[0].network_name)
109 self.assertEqual(0, len(settings.security_group_names))
110 self.assertEqual(0, len(settings.floating_ip_settings))
111 self.assertIsNone(settings.sudo_user)
112 self.assertEqual(900, settings.vm_boot_timeout)
113 self.assertEqual(300, settings.vm_delete_timeout)
114 self.assertEqual(180, settings.ssh_connect_timeout)
115 self.assertIsNone(settings.availability_zone)
116 self.assertIsNone(settings.volume_names)
119 port_settings = PortSettings(name='foo-port', network_name='bar-net')
120 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
121 router_name='foo-bar-router')
123 settings = VmInstanceSettings(
124 name='foo', flavor='bar', port_settings=[port_settings],
125 security_group_names=['sec_grp_1'],
126 floating_ip_settings=[fip_settings], sudo_user='joe',
127 vm_boot_timeout=999, vm_delete_timeout=333,
128 ssh_connect_timeout=111, availability_zone='server name',
129 volume_names=['vol1'])
130 self.assertEqual('foo', settings.name)
131 self.assertEqual('bar', settings.flavor)
132 self.assertEqual(1, len(settings.port_settings))
133 self.assertEqual('foo-port', settings.port_settings[0].name)
134 self.assertEqual('bar-net', settings.port_settings[0].network_name)
135 self.assertEqual(1, len(settings.security_group_names))
136 self.assertEqual('sec_grp_1', settings.security_group_names[0])
137 self.assertEqual(1, len(settings.floating_ip_settings))
138 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
139 self.assertEqual('bar-port',
140 settings.floating_ip_settings[0].port_name)
141 self.assertEqual('foo-bar-router',
142 settings.floating_ip_settings[0].router_name)
143 self.assertEqual('joe', settings.sudo_user)
144 self.assertEqual(999, settings.vm_boot_timeout)
145 self.assertEqual(333, settings.vm_delete_timeout)
146 self.assertEqual(111, settings.ssh_connect_timeout)
147 self.assertEqual('server name', settings.availability_zone)
148 self.assertEqual('vol1', settings.volume_names[0])
150 def test_config_all(self):
151 port_settings = PortSettings(name='foo-port', network_name='bar-net')
152 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
153 router_name='foo-bar-router')
155 settings = VmInstanceSettings(
156 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
157 'security_group_names': ['sec_grp_1'],
158 'floating_ips': [fip_settings], 'sudo_user': 'joe',
159 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
160 'ssh_connect_timeout': 111, 'availability_zone': 'server name',
161 'volume_names': ['vol2']})
162 self.assertEqual('foo', settings.name)
163 self.assertEqual('bar', settings.flavor)
164 self.assertEqual(1, len(settings.port_settings))
165 self.assertEqual('foo-port', settings.port_settings[0].name)
166 self.assertEqual('bar-net', settings.port_settings[0].network_name)
167 self.assertEqual(1, len(settings.security_group_names))
168 self.assertEqual(1, len(settings.floating_ip_settings))
169 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
170 self.assertEqual('bar-port',
171 settings.floating_ip_settings[0].port_name)
172 self.assertEqual('foo-bar-router',
173 settings.floating_ip_settings[0].router_name)
174 self.assertEqual('joe', settings.sudo_user)
175 self.assertEqual(999, settings.vm_boot_timeout)
176 self.assertEqual(333, settings.vm_delete_timeout)
177 self.assertEqual(111, settings.ssh_connect_timeout)
178 self.assertEqual('server name', settings.availability_zone)
179 self.assertEqual('vol2', settings.volume_names[0])
182 class FloatingIpSettingsUnitTests(unittest.TestCase):
184 Tests the construction of the FloatingIpSettings class
187 def test_no_params(self):
188 with self.assertRaises(FloatingIpSettingsError):
191 def test_empty_config(self):
192 with self.assertRaises(FloatingIpSettingsError):
193 FloatingIpSettings(**dict())
195 def test_name_only(self):
196 with self.assertRaises(FloatingIpSettingsError):
197 FloatingIpSettings(name='foo')
199 def test_config_with_name_only(self):
200 with self.assertRaises(FloatingIpSettingsError):
201 FloatingIpSettings(**{'name': 'foo'})
203 def test_name_port_only(self):
204 with self.assertRaises(FloatingIpSettingsError):
205 FloatingIpSettings(name='foo', port_name='bar')
207 def test_config_with_name_port_only(self):
208 with self.assertRaises(FloatingIpSettingsError):
209 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
211 def test_name_router_only(self):
212 with self.assertRaises(FloatingIpSettingsError):
213 FloatingIpSettings(name='foo', router_name='bar')
215 def test_config_with_name_router_only(self):
216 with self.assertRaises(FloatingIpSettingsError):
217 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
219 def test_name_port_router_name_only(self):
220 settings = FloatingIpSettings(name='foo', port_name='foo-port',
221 router_name='bar-router')
222 self.assertEqual('foo', settings.name)
223 self.assertEqual('foo-port', settings.port_name)
224 self.assertIsNone(settings.port_id)
225 self.assertEqual('bar-router', settings.router_name)
226 self.assertIsNone(settings.subnet_name)
227 self.assertTrue(settings.provisioning)
229 def test_name_port_router_id_only(self):
230 settings = FloatingIpSettings(name='foo', port_id='foo-port',
231 router_name='bar-router')
232 self.assertEqual('foo', settings.name)
233 self.assertEqual('foo-port', settings.port_id)
234 self.assertIsNone(settings.port_name)
235 self.assertEqual('bar-router', settings.router_name)
236 self.assertIsNone(settings.subnet_name)
237 self.assertTrue(settings.provisioning)
239 def test_config_with_name_port_router_only(self):
240 settings = FloatingIpSettings(
241 **{'name': 'foo', 'port_name': 'foo-port',
242 'router_name': 'bar-router'})
243 self.assertEqual('foo', settings.name)
244 self.assertEqual('foo-port', settings.port_name)
245 self.assertIsNone(settings.port_id)
246 self.assertEqual('bar-router', settings.router_name)
247 self.assertIsNone(settings.subnet_name)
248 self.assertTrue(settings.provisioning)
251 settings = FloatingIpSettings(name='foo', port_name='foo-port',
252 router_name='bar-router',
253 subnet_name='bar-subnet',
255 self.assertEqual('foo', settings.name)
256 self.assertEqual('foo-port', settings.port_name)
257 self.assertIsNone(settings.port_id)
258 self.assertEqual('bar-router', settings.router_name)
259 self.assertEqual('bar-subnet', settings.subnet_name)
260 self.assertFalse(settings.provisioning)
262 def test_config_all(self):
263 settings = FloatingIpSettings(
264 **{'name': 'foo', 'port_name': 'foo-port',
265 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
266 'provisioning': False})
267 self.assertEqual('foo', settings.name)
268 self.assertEqual('foo-port', settings.port_name)
269 self.assertIsNone(settings.port_id)
270 self.assertEqual('bar-router', settings.router_name)
271 self.assertEqual('bar-subnet', settings.subnet_name)
272 self.assertFalse(settings.provisioning)
275 class SimpleHealthCheck(OSIntegrationTestCase):
277 Test for the CreateInstance class with a single NIC/Port with Floating IPs
282 Instantiates the CreateImage object that is responsible for downloading
283 and creating an OS image file
286 super(self.__class__, self).__start__()
288 self.nova = nova_utils.nova_client(self.os_creds)
289 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
290 self.vm_inst_name = guid + '-inst'
291 self.port_1_name = guid + 'port-1'
293 # Initialize for tearDown()
294 self.image_creator = None
295 self.network_creator = None
296 self.flavor_creator = None
297 self.inst_creator = None
299 self.priv_net_config = openstack_tests.get_priv_net_config(
300 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
301 self.port_settings = PortSettings(
302 name=self.port_1_name,
303 network_name=self.priv_net_config.network_settings.name)
306 # Set the default image settings, then set any custom parameters sent
308 os_image_settings = openstack_tests.cirros_image_settings(
309 name=guid + '-image', image_metadata=self.image_metadata)
312 self.image_creator = OpenStackImage(self.os_creds,
314 self.image_creator.create()
317 self.network_creator = OpenStackNetwork(
318 self.os_creds, self.priv_net_config.network_settings)
319 self.network_creator.create()
322 self.flavor_creator = OpenStackFlavor(
324 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
325 vcpus=1, metadata=self.flavor_metadata))
326 self.flavor_creator.create()
327 except Exception as e:
333 Cleans the created object
335 if self.inst_creator:
337 self.inst_creator.clean()
338 except Exception as e:
340 'Unexpected exception cleaning VM instance with message'
343 if self.network_creator:
345 self.network_creator.clean()
346 except Exception as e:
348 'Unexpected exception cleaning network with message - %s',
351 if self.flavor_creator:
353 self.flavor_creator.clean()
354 except Exception as e:
356 'Unexpected exception cleaning flavor with message - %s',
359 if self.image_creator and not self.image_creator.image_settings.exists:
361 self.image_creator.clean()
362 except Exception as e:
364 'Unexpected exception cleaning image with message - %s',
367 super(self.__class__, self).__clean__()
369 def test_check_vm_ip_dhcp(self):
371 Tests the creation of an OpenStack instance with a single port and
372 ensures that it's assigned IP address is the actual.
374 instance_settings = VmInstanceSettings(
375 name=self.vm_inst_name,
376 flavor=self.flavor_creator.flavor_settings.name,
377 port_settings=[self.port_settings])
379 self.inst_creator = OpenStackVmInstance(
380 self.os_creds, instance_settings,
381 self.image_creator.image_settings)
382 self.inst_creator.create()
384 ip = self.inst_creator.get_port_ip(self.port_settings.name)
385 self.assertIsNotNone(ip)
387 self.assertTrue(self.inst_creator.vm_active(block=True))
389 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
392 class CreateInstanceSimpleTests(OSIntegrationTestCase):
394 Simple instance creation tests without any other objects
399 Instantiates the CreateImage object that is responsible for downloading
400 and creating an OS image file
403 super(self.__class__, self).__start__()
405 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
406 self.vm_inst_name = guid + '-inst'
407 self.nova = nova_utils.nova_client(self.os_creds)
408 os_image_settings = openstack_tests.cirros_image_settings(
409 name=guid + '-image', image_metadata=self.image_metadata)
411 net_config = openstack_tests.get_priv_net_config(
412 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
413 router_name=guid + '-pub-router', external_net=self.ext_net_name)
415 # Initialize for tearDown()
416 self.image_creator = None
417 self.flavor_creator = None
419 self.network_creator = None
420 self.inst_creator = None
424 self.image_creator = OpenStackImage(self.os_creds,
426 self.image_creator.create()
429 self.flavor_creator = OpenStackFlavor(
431 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
432 vcpus=2, metadata=self.flavor_metadata))
433 self.flavor_creator.create()
436 self.network_creator = OpenStackNetwork(
437 self.os_creds, net_config.network_settings)
438 self.network_creator.create()
440 self.port_settings = PortSettings(
442 network_name=net_config.network_settings.name)
444 except Exception as e:
450 Cleans the created object
452 if self.inst_creator:
454 self.inst_creator.clean()
455 except Exception as e:
457 'Unexpected exception cleaning VM instance with message '
460 if self.flavor_creator:
462 self.flavor_creator.clean()
463 except Exception as e:
465 'Unexpected exception cleaning flavor with message - %s',
468 if self.network_creator:
470 self.network_creator.clean()
471 except Exception as e:
473 'Unexpected exception cleaning network with message - %s',
476 if self.image_creator and not self.image_creator.image_settings.exists:
478 self.image_creator.clean()
479 except Exception as e:
481 'Unexpected exception cleaning image with message - %s', e)
483 super(self.__class__, self).__clean__()
485 def test_create_delete_instance(self):
487 Tests the creation of an OpenStack instance with a single port with a
488 static IP without a Floating IP.
490 instance_settings = VmInstanceSettings(
491 name=self.vm_inst_name,
492 flavor=self.flavor_creator.flavor_settings.name,
493 port_settings=[self.port_settings])
495 self.inst_creator = OpenStackVmInstance(
496 self.os_creds, instance_settings,
497 self.image_creator.image_settings)
499 vm_inst = self.inst_creator.create()
500 self.assertIsNotNone(nova_utils.get_server(
501 self.nova, vm_inst_settings=instance_settings))
504 nova_utils.delete_vm_instance(self.nova, vm_inst)
506 self.assertTrue(self.inst_creator.vm_deleted(block=True))
507 self.assertIsNone(nova_utils.get_server(
508 self.nova, vm_inst_settings=instance_settings))
510 # Exception should not be thrown
511 self.inst_creator.clean()
514 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
516 Test for the CreateInstance class with a single NIC/Port with Floating IPs
521 Instantiates the CreateImage object that is responsible for downloading
522 and creating an OS image file within OpenStack
524 super(self.__class__, self).__start__()
526 self.nova = nova_utils.nova_client(self.os_creds)
527 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
528 self.keypair_priv_filepath = 'tmp/' + guid
529 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
530 self.keypair_name = guid + '-kp'
531 self.vm_inst_name = guid + '-inst'
532 self.port_1_name = guid + 'port-1'
533 self.port_2_name = guid + 'port-2'
534 self.floating_ip_name = guid + 'fip1'
536 # Initialize for tearDown()
537 self.image_creator = None
538 self.network_creator = None
539 self.router_creator = None
540 self.flavor_creator = None
541 self.keypair_creator = None
542 self.sec_grp_creator = None
543 self.inst_creators = list()
545 self.pub_net_config = openstack_tests.get_pub_net_config(
546 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
547 router_name=guid + '-pub-router', external_net=self.ext_net_name)
548 os_image_settings = openstack_tests.cirros_image_settings(
549 name=guid + '-image', image_metadata=self.image_metadata)
552 self.image_creator = OpenStackImage(self.os_creds,
554 self.image_creator.create()
557 self.network_creator = OpenStackNetwork(
558 self.os_creds, self.pub_net_config.network_settings)
559 self.network_creator.create()
562 self.router_creator = OpenStackRouter(
563 self.os_creds, self.pub_net_config.router_settings)
564 self.router_creator.create()
567 self.flavor_creator = OpenStackFlavor(
569 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
570 vcpus=2, metadata=self.flavor_metadata))
571 self.flavor_creator.create()
573 self.keypair_creator = OpenStackKeypair(
574 self.os_creds, KeypairSettings(
575 name=self.keypair_name,
576 public_filepath=self.keypair_pub_filepath,
577 private_filepath=self.keypair_priv_filepath))
578 self.keypair_creator.create()
580 sec_grp_name = guid + '-sec-grp'
581 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
582 direction=Direction.ingress,
583 protocol=Protocol.icmp)
584 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
585 direction=Direction.ingress,
586 protocol=Protocol.tcp,
589 self.sec_grp_creator = OpenStackSecurityGroup(
591 SecurityGroupSettings(name=sec_grp_name,
592 rule_settings=[rule1, rule2]))
593 self.sec_grp_creator.create()
594 except Exception as e:
600 Cleans the created object
602 for inst_creator in self.inst_creators:
605 except Exception as e:
607 'Unexpected exception cleaning VM instance with message '
610 if self.keypair_creator:
612 self.keypair_creator.clean()
613 except Exception as e:
615 'Unexpected exception cleaning keypair with message - %s',
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(block=True)
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 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
705 floating_ip_settings=[FloatingIpSettings(
706 name=self.floating_ip_name, port_name=self.port_1_name,
707 router_name=self.pub_net_config.router_settings.name)])
709 inst_creator = OpenStackVmInstance(
710 self.os_creds, instance_settings,
711 self.image_creator.image_settings,
712 keypair_settings=self.keypair_creator.keypair_settings)
713 self.inst_creators.append(inst_creator)
714 vm_inst = inst_creator.create()
715 self.assertIsNotNone(vm_inst)
717 self.assertTrue(inst_creator.vm_active(block=True))
719 ip = inst_creator.get_port_ip(port_settings.name)
720 self.assertTrue(check_dhcp_lease(inst_creator, ip))
722 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
724 self.assertTrue(validate_ssh_client(inst_creator))
726 def test_ssh_client_fip_after_active(self):
728 Tests the ability to access a VM via SSH and a floating IP when it has
729 been assigned prior to being active.
731 port_settings = PortSettings(
732 name=self.port_1_name,
733 network_name=self.pub_net_config.network_settings.name)
735 instance_settings = VmInstanceSettings(
736 name=self.vm_inst_name,
737 flavor=self.flavor_creator.flavor_settings.name,
738 port_settings=[port_settings],
739 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
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 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
761 self.assertTrue(validate_ssh_client(inst_creator))
763 def test_ssh_client_fip_second_creator(self):
765 Tests the ability to access a VM via SSH and a floating IP via a
766 creator that is identical to the original creator.
768 port_settings = PortSettings(
769 name=self.port_1_name,
770 network_name=self.pub_net_config.network_settings.name)
772 instance_settings = VmInstanceSettings(
773 name=self.vm_inst_name,
774 flavor=self.flavor_creator.flavor_settings.name,
775 port_settings=[port_settings],
776 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
777 floating_ip_settings=[FloatingIpSettings(
778 name=self.floating_ip_name, port_name=self.port_1_name,
779 router_name=self.pub_net_config.router_settings.name)])
781 inst_creator = OpenStackVmInstance(
782 self.os_creds, instance_settings,
783 self.image_creator.image_settings,
784 keypair_settings=self.keypair_creator.keypair_settings)
785 self.inst_creators.append(inst_creator)
787 # block=True will force the create() method to block until the
788 vm_inst = inst_creator.create(block=True)
789 self.assertIsNotNone(vm_inst)
791 self.assertTrue(inst_creator.vm_active(block=True))
793 ip = inst_creator.get_port_ip(port_settings.name)
794 self.assertTrue(check_dhcp_lease(inst_creator, ip))
796 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
798 self.assertTrue(validate_ssh_client(inst_creator))
800 inst_creator2 = OpenStackVmInstance(
801 self.os_creds, instance_settings,
802 self.image_creator.image_settings,
803 keypair_settings=self.keypair_creator.keypair_settings)
804 inst_creator2.create()
805 self.assertTrue(validate_ssh_client(inst_creator2))
808 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
810 Test for the CreateInstance class with a single NIC/Port with Floating IPs
815 Instantiates the CreateImage object that is responsible for downloading
816 and creating an OS image file within OpenStack
818 super(self.__class__, self).__start__()
820 self.nova = nova_utils.nova_client(self.os_creds)
821 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
822 self.keypair_priv_filepath = 'tmp/' + self.guid
823 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
824 self.keypair_name = self.guid + '-kp'
825 self.vm_inst_name = self.guid + '-inst'
826 self.port1_name = self.guid + 'port1'
827 self.port2_name = self.guid + 'port2'
829 # Initialize for tearDown()
830 self.image_creator = None
831 self.network_creator = None
832 self.router_creator = None
833 self.flavor_creator = None
834 self.keypair_creator = None
835 self.sec_grp_creator = None
836 self.inst_creator = None
838 os_image_settings = openstack_tests.cirros_image_settings(
839 name=self.guid + '-image', image_metadata=self.image_metadata)
841 self.image_creator = OpenStackImage(
842 self.os_creds, os_image_settings)
843 self.image_creator.create()
845 self.flavor_creator = OpenStackFlavor(
848 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
849 metadata=self.flavor_metadata))
850 self.flavor_creator.create()
852 self.keypair_creator = OpenStackKeypair(
853 self.os_creds, KeypairSettings(
854 name=self.keypair_name,
855 public_filepath=self.keypair_pub_filepath,
856 private_filepath=self.keypair_priv_filepath))
857 self.keypair_creator.create()
859 sec_grp_name = self.guid + '-sec-grp'
860 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
861 direction=Direction.ingress,
862 protocol=Protocol.icmp)
863 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
864 direction=Direction.ingress,
865 protocol=Protocol.tcp,
868 self.sec_grp_creator = OpenStackSecurityGroup(
870 SecurityGroupSettings(name=sec_grp_name,
871 rule_settings=[rule1, rule2]))
872 self.sec_grp_creator.create()
873 except Exception as e:
879 Cleans the created object
881 if self.inst_creator:
883 self.inst_creator.clean()
884 except Exception as e:
886 'Unexpected exception cleaning VM instance with message '
889 if self.keypair_creator:
891 self.keypair_creator.clean()
892 except Exception as e:
894 'Unexpected exception cleaning keypair with message - %s',
897 if self.flavor_creator:
899 self.flavor_creator.clean()
900 except Exception as e:
902 'Unexpected exception cleaning flavor with message - %s',
905 if self.sec_grp_creator:
907 self.sec_grp_creator.clean()
908 except Exception as e:
910 'Unexpected exception cleaning security group with message'
913 if self.router_creator:
915 self.router_creator.clean()
916 except Exception as e:
918 'Unexpected exception cleaning router with message - %s',
921 if self.network_creator:
923 self.network_creator.clean()
924 except Exception as e:
926 'Unexpected exception cleaning network with message - %s',
929 if self.image_creator and not self.image_creator.image_settings.exists:
931 self.image_creator.clean()
932 except Exception as e:
934 'Unexpected exception cleaning image with message - %s', e)
936 super(self.__class__, self).__clean__()
938 def test_v4fip_v6overlay(self):
940 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
941 network when the external network does not have an IPv6 subnet.
943 subnet_settings = SubnetSettings(
944 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
946 network_settings = NetworkSettings(
947 name=self.guid + '-net', subnet_settings=[subnet_settings])
948 router_settings = RouterSettings(
949 name=self.guid + '-router', external_gateway=self.ext_net_name,
950 internal_subnets=[subnet_settings.name])
953 self.network_creator = OpenStackNetwork(
954 self.os_creds, network_settings)
955 self.network_creator.create()
958 self.router_creator = OpenStackRouter(
959 self.os_creds, router_settings)
960 self.router_creator.create()
962 port_settings = PortSettings(
963 name=self.port1_name, network_name=network_settings.name)
965 instance_settings = VmInstanceSettings(
966 name=self.vm_inst_name,
967 flavor=self.flavor_creator.flavor_settings.name,
968 port_settings=[port_settings],
969 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
970 floating_ip_settings=[FloatingIpSettings(
971 name='fip1', port_name=self.port1_name,
972 router_name=router_settings.name)])
974 self.inst_creator = OpenStackVmInstance(
975 self.os_creds, instance_settings,
976 self.image_creator.image_settings,
977 keypair_settings=self.keypair_creator.keypair_settings)
979 with self.assertRaises(BadRequest):
980 self.inst_creator.create(block=True)
982 def test_fip_v4and6_overlay(self):
984 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
985 network when the external network does not have an IPv6 subnet.
987 subnet4_settings = SubnetSettings(
988 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
990 subnet6_settings = SubnetSettings(
991 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
993 network_settings = NetworkSettings(
994 name=self.guid + '-net',
995 subnet_settings=[subnet4_settings, subnet6_settings])
996 router_settings = RouterSettings(
997 name=self.guid + '-router', external_gateway=self.ext_net_name,
998 internal_subnets=[subnet4_settings.name])
1001 self.network_creator = OpenStackNetwork(
1002 self.os_creds, network_settings)
1003 self.network_creator.create()
1006 self.router_creator = OpenStackRouter(
1007 self.os_creds, router_settings)
1008 self.router_creator.create()
1010 port_settings = PortSettings(
1011 name=self.port1_name, network_name=network_settings.name)
1013 instance_settings = VmInstanceSettings(
1014 name=self.vm_inst_name,
1015 flavor=self.flavor_creator.flavor_settings.name,
1016 port_settings=[port_settings],
1017 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1018 floating_ip_settings=[FloatingIpSettings(
1019 name='fip1', port_name=self.port1_name,
1020 router_name=router_settings.name)])
1022 self.inst_creator = OpenStackVmInstance(
1023 self.os_creds, instance_settings,
1024 self.image_creator.image_settings,
1025 keypair_settings=self.keypair_creator.keypair_settings)
1027 self.inst_creator.create(block=True)
1028 ssh_client = self.inst_creator.ssh_client()
1029 self.assertIsNotNone(ssh_client)
1032 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1034 Test for the CreateInstance class with a single NIC/Port where mac and IP
1035 values are manually set
1040 Instantiates the CreateImage object that is responsible for downloading
1041 and creating an OS image file within OpenStack
1043 super(self.__class__, self).__start__()
1045 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1046 self.vm_inst_name = guid + '-inst'
1047 self.port_1_name = guid + 'port-1'
1048 self.port_2_name = guid + 'port-2'
1049 self.floating_ip_name = guid + 'fip1'
1051 # Initialize for tearDown()
1052 self.image_creator = None
1053 self.network_creator = None
1054 self.flavor_creator = None
1055 self.inst_creator = None
1057 self.net_config = openstack_tests.get_priv_net_config(
1058 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1059 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1060 os_image_settings = openstack_tests.cirros_image_settings(
1061 name=guid + '-image', image_metadata=self.image_metadata)
1065 self.image_creator = OpenStackImage(self.os_creds,
1067 self.image_creator.create()
1070 self.network_creator = OpenStackNetwork(
1071 self.os_creds, self.net_config.network_settings)
1072 self.network_creator.create()
1075 self.flavor_creator = OpenStackFlavor(
1076 self.admin_os_creds,
1077 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
1078 vcpus=2, metadata=self.flavor_metadata))
1079 self.flavor_creator.create()
1080 except Exception as e:
1086 Cleans the created object
1088 if self.inst_creator:
1090 self.inst_creator.clean()
1091 except Exception as e:
1093 'Unexpected exception cleaning VM instance with message '
1096 if self.flavor_creator:
1098 self.flavor_creator.clean()
1099 except Exception as e:
1101 'Unexpected exception cleaning flavor with message - %s',
1104 if self.network_creator:
1106 self.network_creator.clean()
1107 except Exception as e:
1109 'Unexpected exception cleaning network with message - %s',
1112 if self.image_creator and not self.image_creator.image_settings.exists:
1114 self.image_creator.clean()
1115 except Exception as e:
1117 'Unexpected exception cleaning image with message - %s', e)
1119 super(self.__class__, self).__clean__()
1121 def test_set_custom_valid_ip_one_subnet(self):
1123 Tests the creation of an OpenStack instance with a single port with a
1124 static IP on a network with one subnet.
1127 sub_settings = self.net_config.network_settings.subnet_settings
1128 port_settings = PortSettings(
1129 name=self.port_1_name,
1130 network_name=self.net_config.network_settings.name,
1131 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1133 instance_settings = VmInstanceSettings(
1134 name=self.vm_inst_name,
1135 flavor=self.flavor_creator.flavor_settings.name,
1136 port_settings=[port_settings])
1138 self.inst_creator = OpenStackVmInstance(
1139 self.os_creds, instance_settings,
1140 self.image_creator.image_settings)
1141 self.inst_creator.create(block=True)
1143 self.assertEqual(ip, self.inst_creator.get_port_ip(
1145 subnet_name=self.net_config.network_settings.subnet_settings[
1148 def test_set_custom_invalid_ip_one_subnet(self):
1150 Tests the creation of an OpenStack instance with a single port with a
1151 static IP on a network with one subnet.
1154 sub_settings = self.net_config.network_settings.subnet_settings
1155 port_settings = PortSettings(
1156 name=self.port_1_name,
1157 network_name=self.net_config.network_settings.name,
1158 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1160 instance_settings = VmInstanceSettings(
1161 name=self.vm_inst_name,
1162 flavor=self.flavor_creator.flavor_settings.name,
1163 port_settings=[port_settings])
1165 self.inst_creator = OpenStackVmInstance(
1166 self.os_creds, instance_settings,
1167 self.image_creator.image_settings)
1169 with self.assertRaises(InvalidIpForSubnetClient):
1170 self.inst_creator.create()
1172 def test_set_custom_valid_mac(self):
1174 Tests the creation of an OpenStack instance with a single port where
1175 the MAC address is assigned.
1177 mac_addr = '0a:1b:2c:3d:4e:5f'
1178 port_settings = PortSettings(
1179 name=self.port_1_name,
1180 network_name=self.net_config.network_settings.name,
1181 mac_address=mac_addr)
1183 instance_settings = VmInstanceSettings(
1184 name=self.vm_inst_name,
1185 flavor=self.flavor_creator.flavor_settings.name,
1186 port_settings=[port_settings])
1188 self.inst_creator = OpenStackVmInstance(
1189 self.os_creds, instance_settings,
1190 self.image_creator.image_settings)
1191 self.inst_creator.create(block=True)
1193 self.assertEqual(mac_addr,
1194 self.inst_creator.get_port_mac(self.port_1_name))
1196 def test_set_custom_invalid_mac(self):
1198 Tests the creation of an OpenStack instance with a single port where an
1199 invalid MAC address value is being
1200 assigned. This should raise an Exception
1202 port_settings = PortSettings(
1203 name=self.port_1_name,
1204 network_name=self.net_config.network_settings.name,
1207 instance_settings = VmInstanceSettings(
1208 name=self.vm_inst_name,
1209 flavor=self.flavor_creator.flavor_settings.name,
1210 port_settings=[port_settings])
1212 self.inst_creator = OpenStackVmInstance(
1213 self.os_creds, instance_settings,
1214 self.image_creator.image_settings)
1216 with self.assertRaises(Exception):
1217 self.inst_creator.create()
1219 def test_set_custom_mac_and_ip(self):
1221 Tests the creation of an OpenStack instance with a single port where
1222 the IP and MAC address is assigned.
1225 mac_addr = '0a:1b:2c:3d:4e:5f'
1226 sub_settings = self.net_config.network_settings.subnet_settings
1227 port_settings = PortSettings(
1228 name=self.port_1_name,
1229 network_name=self.net_config.network_settings.name,
1230 mac_address=mac_addr,
1231 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1233 instance_settings = VmInstanceSettings(
1234 name=self.vm_inst_name,
1235 flavor=self.flavor_creator.flavor_settings.name,
1236 port_settings=[port_settings])
1238 self.inst_creator = OpenStackVmInstance(
1239 self.os_creds, instance_settings,
1240 self.image_creator.image_settings)
1241 self.inst_creator.create(block=True)
1243 self.assertEqual(ip, self.inst_creator.get_port_ip(
1245 subnet_name=self.net_config.network_settings.subnet_settings[
1247 self.assertEqual(mac_addr,
1248 self.inst_creator.get_port_mac(self.port_1_name))
1250 def test_set_allowed_address_pairs(self):
1252 Tests the creation of an OpenStack instance with a single port where
1253 max_allowed_address_pair is set.
1256 mac_addr = '0a:1b:2c:3d:4e:5f'
1257 pair = {'ip_address': ip, 'mac_address': mac_addr}
1258 port_settings = PortSettings(
1259 name=self.port_1_name,
1260 network_name=self.net_config.network_settings.name,
1261 allowed_address_pairs=[pair])
1263 instance_settings = VmInstanceSettings(
1264 name=self.vm_inst_name,
1265 flavor=self.flavor_creator.flavor_settings.name,
1266 port_settings=[port_settings])
1268 self.inst_creator = OpenStackVmInstance(
1269 self.os_creds, instance_settings,
1270 self.image_creator.image_settings)
1271 self.inst_creator.create(block=True)
1273 port = self.inst_creator.get_port_by_name(port_settings.name)
1274 self.assertIsNotNone(port)
1275 self.assertIsNotNone(port.allowed_address_pairs)
1276 self.assertEqual(1, len(port.allowed_address_pairs))
1277 validation_utils.objects_equivalent(pair,
1278 port.allowed_address_pairs[0])
1280 def test_set_allowed_address_pairs_bad_mac(self):
1282 Tests the creation of an OpenStack instance with a single port where
1283 max_allowed_address_pair is set with an invalid MAC address.
1287 pair = {'ip_address': ip, 'mac_address': mac_addr}
1289 pairs.add((ip, mac_addr))
1290 port_settings = PortSettings(
1291 name=self.port_1_name,
1292 network_name=self.net_config.network_settings.name,
1293 allowed_address_pairs=[pair])
1295 instance_settings = VmInstanceSettings(
1296 name=self.vm_inst_name,
1297 flavor=self.flavor_creator.flavor_settings.name,
1298 port_settings=[port_settings])
1300 self.inst_creator = OpenStackVmInstance(
1301 self.os_creds, instance_settings,
1302 self.image_creator.image_settings)
1303 with self.assertRaises(Exception):
1304 self.inst_creator.create()
1306 def test_set_allowed_address_pairs_bad_ip(self):
1308 Tests the creation of an OpenStack instance with a single port where
1309 max_allowed_address_pair is set with an invalid MAC address.
1312 mac_addr = '0a:1b:2c:3d:4e:5f'
1313 pair = {'ip_address': ip, 'mac_address': mac_addr}
1315 pairs.add((ip, mac_addr))
1316 port_settings = PortSettings(
1317 name=self.port_1_name,
1318 network_name=self.net_config.network_settings.name,
1319 allowed_address_pairs=[pair])
1321 instance_settings = VmInstanceSettings(
1322 name=self.vm_inst_name,
1323 flavor=self.flavor_creator.flavor_settings.name,
1324 port_settings=[port_settings])
1326 self.inst_creator = OpenStackVmInstance(
1327 self.os_creds, instance_settings,
1328 self.image_creator.image_settings)
1329 with self.assertRaises(Exception):
1330 self.inst_creator.create()
1333 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1335 Test for the CreateInstance where one VM is deployed to each compute node
1340 Instantiates the CreateImage object that is responsible for downloading
1341 and creating an OS image file within OpenStack
1343 super(self.__class__, self).__start__()
1345 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1346 self.vm_inst_name = guid + '-inst'
1347 self.port_base_name = guid + 'port'
1349 # Initialize for tearDown()
1350 self.image_creator = None
1351 self.flavor_creator = None
1352 self.network_creator = None
1353 self.inst_creators = list()
1355 self.priv_net_config = openstack_tests.get_priv_net_config(
1356 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1358 os_image_settings = openstack_tests.cirros_image_settings(
1359 name=guid + '-image', image_metadata=self.image_metadata)
1363 self.network_creator = OpenStackNetwork(
1364 self.admin_os_creds, self.priv_net_config.network_settings)
1365 self.network_creator.create()
1368 self.flavor_creator = OpenStackFlavor(
1369 self.admin_os_creds,
1370 FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1,
1371 vcpus=1, metadata=self.flavor_metadata))
1372 self.flavor_creator.create()
1375 self.image_creator = OpenStackImage(self.os_creds,
1377 self.image_creator.create()
1379 except Exception as e:
1385 Cleans the created object
1387 for inst_creator in self.inst_creators:
1389 inst_creator.clean()
1390 except Exception as e:
1392 'Unexpected exception cleaning VM instance with message '
1395 if self.flavor_creator:
1397 self.flavor_creator.clean()
1398 except Exception as e:
1400 'Unexpected exception cleaning flavor with message - %s',
1403 if self.network_creator:
1405 self.network_creator.clean()
1406 except Exception as e:
1408 'Unexpected exception cleaning network with message - %s',
1411 if self.image_creator and not self.image_creator.image_settings.exists:
1413 self.image_creator.clean()
1414 except Exception as e:
1416 'Unexpected exception cleaning image with message - %s', e)
1418 super(self.__class__, self).__clean__()
1420 def test_deploy_vm_to_each_compute_node(self):
1422 Tests the creation of OpenStack VM instances to each compute node.
1424 from snaps.openstack.utils import nova_utils
1425 nova = nova_utils.nova_client(self.admin_os_creds)
1426 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1428 # Create Instance on each server/zone
1430 for zone in zone_hosts:
1431 inst_name = self.vm_inst_name + '-' + zone
1433 port_settings = PortSettings(
1434 name=self.port_base_name + '-' + str(ctr),
1435 network_name=self.priv_net_config.network_settings.name)
1437 instance_settings = VmInstanceSettings(
1439 flavor=self.flavor_creator.flavor_settings.name,
1440 availability_zone=zone,
1441 port_settings=[port_settings])
1442 inst_creator = OpenStackVmInstance(
1443 self.admin_os_creds, instance_settings,
1444 self.image_creator.image_settings)
1445 self.inst_creators.append(inst_creator)
1446 inst_creator.create()
1448 # Validate instances to ensure they've been deployed to the correct
1451 for zone in zone_hosts:
1452 creator = self.inst_creators[index]
1453 self.assertTrue(creator.vm_active(block=True))
1454 info = creator.get_vm_info()
1455 deployed_zone = info['OS-EXT-AZ:availability_zone']
1456 deployed_host = info['OS-EXT-SRV-ATTR:host']
1457 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1461 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1463 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1465 These tests require a Centos image
1470 Instantiates the CreateImage object that is responsible for downloading
1471 and creating an OS image file within OpenStack
1473 super(self.__class__, self).__start__()
1475 self.nova = nova_utils.nova_client(self.os_creds)
1477 # Initialize for tearDown()
1478 self.image_creator = None
1479 self.network_creators = list()
1480 self.router_creators = list()
1481 self.flavor_creator = None
1482 self.keypair_creator = None
1483 self.sec_grp_creator = None
1484 self.inst_creator = None
1486 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1487 self.keypair_priv_filepath = 'tmp/' + self.guid
1488 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1489 self.keypair_name = self.guid + '-kp'
1490 self.vm_inst_name = self.guid + '-inst'
1491 self.port_1_name = self.guid + '-port-1'
1492 self.port_2_name = self.guid + '-port-2'
1493 self.floating_ip_name = self.guid + 'fip1'
1494 self.priv_net_config = openstack_tests.get_priv_net_config(
1495 net_name=self.guid + '-priv-net',
1496 subnet_name=self.guid + '-priv-subnet',
1497 router_name=self.guid + '-priv-router',
1498 external_net=self.ext_net_name)
1499 self.pub_net_config = openstack_tests.get_pub_net_config(
1500 net_name=self.guid + '-pub-net',
1501 subnet_name=self.guid + '-pub-subnet',
1502 router_name=self.guid + '-pub-router',
1503 external_net=self.ext_net_name)
1505 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1506 os_image_settings = openstack_tests.centos_image_settings(
1507 name=image_name, image_metadata=self.image_metadata)
1511 self.image_creator = OpenStackImage(self.os_creds,
1513 self.image_creator.create()
1515 # First network is public
1516 self.network_creators.append(OpenStackNetwork(
1517 self.os_creds, self.pub_net_config.network_settings))
1518 # Second network is private
1519 self.network_creators.append(OpenStackNetwork(
1520 self.os_creds, self.priv_net_config.network_settings))
1521 for network_creator in self.network_creators:
1522 network_creator.create()
1524 self.router_creators.append(OpenStackRouter(
1525 self.os_creds, self.pub_net_config.router_settings))
1526 self.router_creators.append(OpenStackRouter(
1527 self.os_creds, self.priv_net_config.router_settings))
1530 for router_creator in self.router_creators:
1531 router_creator.create()
1534 self.flavor_creator = OpenStackFlavor(
1535 self.admin_os_creds,
1536 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
1538 metadata=self.flavor_metadata))
1539 self.flavor_creator.create()
1542 self.keypair_creator = OpenStackKeypair(
1543 self.os_creds, KeypairSettings(
1544 name=self.keypair_name,
1545 public_filepath=self.keypair_pub_filepath,
1546 private_filepath=self.keypair_priv_filepath))
1547 self.keypair_creator.create()
1549 sec_grp_name = self.guid + '-sec-grp'
1550 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1551 direction=Direction.ingress,
1552 protocol=Protocol.icmp)
1553 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1554 direction=Direction.ingress,
1555 protocol=Protocol.tcp,
1558 self.sec_grp_creator = OpenStackSecurityGroup(
1560 SecurityGroupSettings(name=sec_grp_name,
1561 rule_settings=[rule1, rule2]))
1562 self.sec_grp_creator.create()
1569 Cleans the created objects
1571 if self.inst_creator:
1573 self.inst_creator.clean()
1574 except Exception as e:
1576 'Unexpected exception cleaning VM instance with message '
1579 if self.keypair_creator:
1581 self.keypair_creator.clean()
1582 except Exception as e:
1584 'Unexpected exception cleaning keypair with message - %s',
1587 if self.flavor_creator:
1589 self.flavor_creator.clean()
1590 except Exception as e:
1592 'Unexpected exception cleaning flavor with message - %s',
1595 for router_creator in self.router_creators:
1597 router_creator.clean()
1598 except Exception as e:
1600 'Unexpected exception cleaning router with message - %s',
1603 for network_creator in self.network_creators:
1605 network_creator.clean()
1606 except Exception as e:
1608 'Unexpected exception cleaning network with message - %s',
1611 if self.sec_grp_creator:
1613 self.sec_grp_creator.clean()
1614 except Exception as e:
1616 'Unexpected exception cleaning security group with message'
1619 if self.image_creator and not self.image_creator.image_settings.exists:
1621 self.image_creator.clean()
1622 except Exception as e:
1624 'Unexpected exception cleaning image with message - %s', e)
1626 super(self.__class__, self).__clean__()
1628 def test_dual_ports_dhcp(self):
1630 Tests the creation of an OpenStack instance with a dual ports/NICs with
1632 NOTE: This test and any others that call ansible will most likely fail
1633 unless you do one of two things:
1634 1. Have a ~/.ansible.cfg (or alternate means) to
1635 set host_key_checking = False
1636 2. Set the following environment variable in your executing shell:
1637 ANSIBLE_HOST_KEY_CHECKING=False
1638 Should this not be performed, the creation of the host ssh key will
1639 cause your ansible calls to fail.
1641 # Create ports/NICs for instance
1644 for network_creator in self.network_creators:
1645 ports_settings.append(PortSettings(
1646 name=self.guid + '-port-' + str(ctr),
1647 network_name=network_creator.network_settings.name))
1651 instance_settings = VmInstanceSettings(
1652 name=self.vm_inst_name,
1653 flavor=self.flavor_creator.flavor_settings.name,
1654 port_settings=ports_settings,
1655 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1656 floating_ip_settings=[FloatingIpSettings(
1657 name=self.floating_ip_name, port_name=self.port_1_name,
1658 router_name=self.pub_net_config.router_settings.name)])
1660 self.inst_creator = OpenStackVmInstance(
1661 self.os_creds, instance_settings,
1662 self.image_creator.image_settings,
1663 keypair_settings=self.keypair_creator.keypair_settings)
1665 vm_inst = self.inst_creator.create(block=True)
1667 self.assertEqual(vm_inst.id, self.inst_creator.get_vm_inst().id)
1669 # Effectively blocks until VM has been properly activated
1670 self.assertTrue(self.inst_creator.vm_active(block=True))
1672 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1673 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1675 # Effectively blocks until VM's ssh port has been opened
1676 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1678 self.assertEqual(0, self.inst_creator.config_nics())
1681 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1683 Tests that include, add, and remove security groups from VM instances
1688 Instantiates the CreateImage object that is responsible for downloading
1689 and creating an OS image file within OpenStack
1691 super(self.__class__, self).__start__()
1693 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1694 self.vm_inst_name = self.guid + '-inst'
1695 self.nova = nova_utils.nova_client(self.os_creds)
1696 os_image_settings = openstack_tests.cirros_image_settings(
1697 name=self.guid + '-image', image_metadata=self.image_metadata)
1699 self.vm_inst_name = self.guid + '-inst'
1700 self.port_1_name = self.guid + 'port-1'
1701 self.port_2_name = self.guid + 'port-2'
1702 self.floating_ip_name = self.guid + 'fip1'
1704 net_config = openstack_tests.get_priv_net_config(
1705 net_name=self.guid + '-pub-net',
1706 subnet_name=self.guid + '-pub-subnet',
1707 router_name=self.guid + '-pub-router',
1708 external_net=self.ext_net_name)
1710 # Initialize for tearDown()
1711 self.image_creator = None
1712 self.flavor_creator = None
1713 self.network_creator = None
1714 self.router_creator = None
1715 self.inst_creator = None
1716 self.sec_grp_creators = list()
1720 self.image_creator = OpenStackImage(self.os_creds,
1722 self.image_creator.create()
1725 self.network_creator = OpenStackNetwork(
1726 self.os_creds, net_config.network_settings)
1727 self.network_creator.create()
1730 self.flavor_creator = OpenStackFlavor(
1731 self.admin_os_creds,
1732 FlavorSettings(name=self.guid + '-flavor-name', ram=256,
1734 metadata=self.flavor_metadata))
1735 self.flavor_creator.create()
1737 self.port_settings = PortSettings(
1738 name=self.guid + '-port',
1739 network_name=net_config.network_settings.name)
1740 except Exception as e:
1746 Cleans the created object
1748 if self.inst_creator:
1750 self.inst_creator.clean()
1751 except Exception as e:
1753 'Unexpected exception cleaning VM instance with message -'
1756 for sec_grp_creator in self.sec_grp_creators:
1758 sec_grp_creator.clean()
1759 except Exception as e:
1761 'Unexpected exception cleaning security group with message'
1764 if self.flavor_creator:
1766 self.flavor_creator.clean()
1767 except Exception as e:
1769 'Unexpected exception cleaning flavor with message - %s',
1772 if self.network_creator:
1774 self.network_creator.clean()
1775 except Exception as e:
1777 'Unexpected exception cleaning network with message - %s',
1780 if self.image_creator and not self.image_creator.image_settings.exists:
1782 self.image_creator.clean()
1783 except Exception as e:
1785 'Unexpected exception cleaning image with message - %s', e)
1787 super(self.__class__, self).__clean__()
1789 def test_add_security_group(self):
1791 Tests the addition of a security group created after the instance.
1794 instance_settings = VmInstanceSettings(
1795 name=self.vm_inst_name,
1796 flavor=self.flavor_creator.flavor_settings.name,
1797 port_settings=[self.port_settings])
1798 self.inst_creator = OpenStackVmInstance(
1799 self.os_creds, instance_settings,
1800 self.image_creator.image_settings)
1801 vm_inst = self.inst_creator.create(block=True)
1802 self.assertIsNotNone(vm_inst)
1804 # Create security group object to add to instance
1805 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1806 description='hello group')
1807 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1809 sec_grp = sec_grp_creator.create()
1810 self.sec_grp_creators.append(sec_grp_creator)
1812 # Check that group has not been added
1813 self.assertFalse(inst_has_sec_grp(
1814 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1816 # Add security group to instance after activated
1817 self.inst_creator.add_security_group(sec_grp)
1819 # Validate that security group has been added
1820 self.assertTrue(inst_has_sec_grp(
1821 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1823 def test_add_invalid_security_group(self):
1825 Tests the addition of a security group that no longer exists.
1828 instance_settings = VmInstanceSettings(
1829 name=self.vm_inst_name,
1830 flavor=self.flavor_creator.flavor_settings.name,
1831 port_settings=[self.port_settings])
1832 self.inst_creator = OpenStackVmInstance(
1833 self.os_creds, instance_settings,
1834 self.image_creator.image_settings)
1835 vm_inst = self.inst_creator.create(block=True)
1836 self.assertIsNotNone(vm_inst)
1838 # Create security group object to add to instance
1839 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1840 description='hello group')
1841 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1843 sec_grp = sec_grp_creator.create()
1844 sec_grp_creator.clean()
1845 self.sec_grp_creators.append(sec_grp_creator)
1847 # Check that group has not been added
1848 self.assertFalse(inst_has_sec_grp(
1849 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1851 # Add security group to instance after activated
1852 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1854 # Validate that security group has been added
1855 self.assertFalse(inst_has_sec_grp(
1856 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1858 def test_remove_security_group(self):
1860 Tests the removal of a security group created before and added to the
1863 # Create security group object to add to instance
1864 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1865 description='hello group')
1866 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1868 sec_grp = sec_grp_creator.create()
1869 self.sec_grp_creators.append(sec_grp_creator)
1872 instance_settings = VmInstanceSettings(
1873 name=self.vm_inst_name,
1874 flavor=self.flavor_creator.flavor_settings.name,
1875 security_group_names=[sec_grp_settings.name],
1876 port_settings=[self.port_settings])
1877 self.inst_creator = OpenStackVmInstance(
1878 self.os_creds, instance_settings,
1879 self.image_creator.image_settings)
1880 vm_inst = self.inst_creator.create(block=True)
1881 self.assertIsNotNone(vm_inst)
1883 # Check that group has been added
1884 self.assertTrue(inst_has_sec_grp(
1885 self.nova, vm_inst, sec_grp_settings.name))
1887 # Add security group to instance after activated
1888 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1890 # Validate that security group has been added
1891 self.assertFalse(inst_has_sec_grp(
1892 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1894 def test_remove_security_group_never_added(self):
1896 Tests the removal of a security group that was never added in the first
1899 # Create security group object to add to instance
1900 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1901 description='hello group')
1902 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1904 sec_grp = sec_grp_creator.create()
1905 self.sec_grp_creators.append(sec_grp_creator)
1908 instance_settings = VmInstanceSettings(
1909 name=self.vm_inst_name,
1910 flavor=self.flavor_creator.flavor_settings.name,
1911 port_settings=[self.port_settings])
1912 self.inst_creator = OpenStackVmInstance(
1913 self.os_creds, instance_settings,
1914 self.image_creator.image_settings)
1915 vm_inst = self.inst_creator.create(block=True)
1916 self.assertIsNotNone(vm_inst)
1918 # Check that group has been added
1919 self.assertFalse(inst_has_sec_grp(
1920 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1922 # Add security group to instance after activated
1923 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1925 # Validate that security group has been added
1926 self.assertFalse(inst_has_sec_grp(
1927 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1929 def test_add_same_security_group(self):
1931 Tests the addition of a security group created before add added to the
1934 # Create security group object to add to instance
1935 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1936 description='hello group')
1937 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1939 sec_grp = sec_grp_creator.create()
1940 self.sec_grp_creators.append(sec_grp_creator)
1943 instance_settings = VmInstanceSettings(
1944 name=self.vm_inst_name,
1945 flavor=self.flavor_creator.flavor_settings.name,
1946 security_group_names=[sec_grp_settings.name],
1947 port_settings=[self.port_settings])
1948 self.inst_creator = OpenStackVmInstance(
1949 self.os_creds, instance_settings,
1950 self.image_creator.image_settings)
1951 vm_inst = self.inst_creator.create(block=True)
1952 self.assertIsNotNone(vm_inst)
1954 # Check that group has been added
1955 self.assertTrue(inst_has_sec_grp(
1956 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1958 # Add security group to instance after activated
1959 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1961 # Validate that security group has been added
1962 self.assertTrue(inst_has_sec_grp(
1963 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1966 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1968 Returns true if instance has a security group of a given name
1969 :param nova: the nova client
1970 :param vm_inst: the VmInst domain object
1971 :param sec_grp_name: the name of the security group to validate
1974 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1975 for name in sec_grp_names:
1976 if sec_grp_name == name:
1981 def validate_ssh_client(instance_creator):
1983 Returns True if instance_creator returns an SSH client that is valid
1984 :param instance_creator: the object responsible for creating the VM
1988 ssh_active = instance_creator.vm_ssh_active(block=True)
1991 ssh_client = instance_creator.ssh_client()
1994 out = ssh_client.exec_command('pwd')[1]
1995 channel = out.channel
1996 in_buffer = channel.in_buffer
1997 pwd_out = in_buffer.read(1024)
1998 if not pwd_out or len(pwd_out) < 10:
2009 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
2011 Test for the CreateInstance class for creating an image from a 3-part image
2016 Instantiates the CreateImage object that is responsible for downloading
2017 and creating an OS image file within OpenStack
2019 super(self.__class__, self).__start__()
2021 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2022 self.image_name = guid
2023 self.vm_inst_name = guid + '-inst'
2024 self.nova = nova_utils.nova_client(self.os_creds)
2026 net_config = openstack_tests.get_priv_net_config(
2027 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2028 router_name=guid + '-pub-router', external_net=self.ext_net_name)
2030 # Initialize for tearDown()
2031 self.image_creator = None
2032 self.network_creator = None
2033 self.flavor_creator = None
2034 self.inst_creator = None
2037 if self.image_metadata and 'disk_file' in self.image_metadata:
2038 metadata = self.image_metadata
2039 elif self.image_metadata and 'cirros' in self.image_metadata \
2040 and 'disk_file' in self.image_metadata['cirros']:
2041 metadata = self.image_metadata['cirros']
2044 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
2046 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
2048 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
2050 image_settings = openstack_tests.cirros_image_settings(
2051 name=self.image_name,
2052 image_metadata=metadata)
2054 if not image_settings.ramdisk_image_settings or not \
2055 image_settings.kernel_image_settings:
2057 '3 Part image will not be tested. Image metadata has '
2058 'overridden this functionality')
2060 self.image_creator = OpenStackImage(self.os_creds, image_settings)
2061 self.image_creator.create()
2064 self.flavor_creator = OpenStackFlavor(
2065 self.admin_os_creds,
2066 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
2067 vcpus=2, metadata=self.flavor_metadata))
2068 self.flavor_creator.create()
2071 self.network_creator = OpenStackNetwork(
2072 self.os_creds, net_config.network_settings)
2073 self.network_creator.create()
2075 self.port_settings = PortSettings(
2076 name=guid + '-port',
2077 network_name=net_config.network_settings.name)
2078 except Exception as e:
2084 Cleans the created object
2086 if self.inst_creator:
2088 self.inst_creator.clean()
2089 except Exception as e:
2091 'Unexpected exception cleaning VM instance with message -'
2094 if self.flavor_creator:
2096 self.flavor_creator.clean()
2097 except Exception as e:
2099 'Unexpected exception cleaning flavor with message - %s',
2102 if self.network_creator:
2104 self.network_creator.clean()
2105 except Exception as e:
2107 'Unexpected exception cleaning network with message - %s',
2110 if self.image_creator and not self.image_creator.image_settings.exists:
2112 self.image_creator.clean()
2113 except Exception as e:
2115 'Unexpected exception cleaning image with message - %s', e)
2117 super(self.__class__, self).__clean__()
2119 def test_create_instance_from_three_part_image(self):
2121 Tests the creation of an OpenStack instance from a 3-part image.
2123 instance_settings = VmInstanceSettings(
2124 name=self.vm_inst_name,
2125 flavor=self.flavor_creator.flavor_settings.name,
2126 port_settings=[self.port_settings])
2128 # The last created image is the main image from which we create the
2130 self.inst_creator = OpenStackVmInstance(
2131 self.os_creds, instance_settings,
2132 self.image_creator.image_settings)
2134 vm_inst = self.inst_creator.create()
2135 self.assertIsNotNone(vm_inst)
2136 self.assertTrue(self.inst_creator.vm_active(block=True))
2139 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2141 Tests the custom image_metadata that can be set by clients for handling
2142 images differently than the default behavior of the existing tests
2143 primarily for offline testing
2148 Instantiates the CreateImage object that is responsible for downloading
2149 and creating an OS image file within OpenStack
2151 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2153 self.tmpDir = 'tmp/' + str(self.guid)
2154 if not os.path.exists(self.tmpDir):
2155 os.makedirs(self.tmpDir)
2157 self.image_name = self.guid + '-image'
2158 self.vm_inst_name = self.guid + '-inst'
2159 self.port_1_name = self.guid + 'port-1'
2161 # Initialize for tearDown()
2162 self.image_creator = None
2163 self.network_creator = None
2164 self.flavor_creator = None
2165 self.inst_creator = None
2167 self.priv_net_config = openstack_tests.get_priv_net_config(
2168 net_name=self.guid + '-priv-net',
2169 subnet_name=self.guid + '-priv-subnet')
2170 self.port_settings = PortSettings(
2171 name=self.port_1_name,
2172 network_name=self.priv_net_config.network_settings.name)
2175 # Download image file
2176 self.image_file = file_utils.download(
2177 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2180 self.network_creator = OpenStackNetwork(
2181 self.os_creds, self.priv_net_config.network_settings)
2182 self.network_creator.create()
2185 self.flavor_creator = OpenStackFlavor(
2188 name=self.guid + '-flavor-name', ram=256, disk=10,
2190 self.flavor_creator.create()
2191 except Exception as e:
2197 Cleans the created object
2199 if self.inst_creator:
2201 self.inst_creator.clean()
2202 except Exception as e:
2204 'Unexpected exception cleaning VM instance with message - '
2207 if self.network_creator:
2209 self.network_creator.clean()
2210 except Exception as e:
2212 'Unexpected exception cleaning network with message - %s',
2215 if self.flavor_creator:
2217 self.flavor_creator.clean()
2218 except Exception as e:
2220 'Unexpected exception cleaning flavor with message - %s',
2223 if self.image_creator:
2225 self.image_creator.clean()
2226 except Exception as e:
2228 'Unexpected exception cleaning image with message - %s', e)
2230 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2231 shutil.rmtree(self.tmpDir)
2233 def test_inst_from_file_image_simple_flat(self):
2235 Creates a VM instance from a locally sourced file image using simply
2236 the 'disk_file' attribute vs. using the 'config' option which
2237 completely overrides all image settings
2240 metadata = {'disk_file': self.image_file.name}
2242 os_image_settings = openstack_tests.cirros_image_settings(
2243 name=self.image_name, image_metadata=metadata)
2244 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2245 self.assertEqual(openstack_tests.CIRROS_USER,
2246 os_image_settings.image_user)
2247 self.assertIsNone(os_image_settings.url)
2248 self.assertFalse(os_image_settings.exists)
2249 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2250 os_image_settings.format)
2252 self.assertIsNone(os_image_settings.kernel_image_settings)
2253 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2255 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2256 self.image_creator.create()
2258 instance_settings = VmInstanceSettings(
2259 name=self.vm_inst_name,
2260 flavor=self.flavor_creator.flavor_settings.name,
2261 port_settings=[self.port_settings])
2262 self.inst_creator = OpenStackVmInstance(
2263 self.os_creds, instance_settings,
2264 self.image_creator.image_settings)
2265 self.inst_creator.create()
2267 self.assertTrue(self.inst_creator.vm_active(block=True))
2269 def test_inst_from_file_image_simple_nested(self):
2271 Creates a VM instance from a locally sourced file image using simply
2272 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2273 which completely overrides all image settings
2276 metadata = {'cirros': {'disk_file': self.image_file.name}}
2278 os_image_settings = openstack_tests.cirros_image_settings(
2279 name=self.image_name, image_metadata=metadata)
2280 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2281 self.assertEqual(openstack_tests.CIRROS_USER,
2282 os_image_settings.image_user)
2283 self.assertIsNone(os_image_settings.url)
2284 self.assertFalse(os_image_settings.exists)
2285 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2286 os_image_settings.format)
2288 self.assertIsNone(os_image_settings.kernel_image_settings)
2289 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2291 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2292 self.image_creator.create()
2294 instance_settings = VmInstanceSettings(
2295 name=self.vm_inst_name,
2296 flavor=self.flavor_creator.flavor_settings.name,
2297 port_settings=[self.port_settings])
2298 self.inst_creator = OpenStackVmInstance(
2299 self.os_creds, instance_settings,
2300 self.image_creator.image_settings)
2301 self.inst_creator.create()
2303 self.assertTrue(self.inst_creator.vm_active(block=True))
2305 def test_inst_from_existing(self):
2307 Creates a VM instance from a image creator that has been configured to
2308 use an existing image
2311 os_image_settings = openstack_tests.cirros_image_settings(
2312 name=self.image_name)
2313 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2314 self.image_creator.create()
2316 image_settings = self.image_creator.image_settings
2317 test_image_creator = OpenStackImage(
2319 ImageSettings(name=image_settings.name,
2320 image_user=image_settings.image_user,
2322 test_image_creator.create()
2323 self.assertEqual(self.image_creator.get_image().id,
2324 test_image_creator.get_image().id)
2326 instance_settings = VmInstanceSettings(
2327 name=self.vm_inst_name,
2328 flavor=self.flavor_creator.flavor_settings.name,
2329 port_settings=[self.port_settings])
2330 self.inst_creator = OpenStackVmInstance(
2331 self.os_creds, instance_settings,
2332 test_image_creator.image_settings)
2333 self.inst_creator.create()
2335 self.assertTrue(self.inst_creator.vm_active(block=True))
2337 def test_inst_from_file_image_complex(self):
2339 Creates a VM instance from a locally sourced file image by overriding
2340 the default settings by using a dict() that can be read in by
2345 os_image_settings = openstack_tests.cirros_image_settings(
2346 name=self.image_name)
2347 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2348 self.image_creator.create()
2353 'name': os_image_settings.name,
2354 'image_user': os_image_settings.image_user,
2356 test_image_settings = openstack_tests.cirros_image_settings(
2357 image_metadata=metadata)
2358 test_image = OpenStackImage(self.os_creds, test_image_settings)
2361 instance_settings = VmInstanceSettings(
2362 name=self.vm_inst_name,
2363 flavor=self.flavor_creator.flavor_settings.name,
2364 port_settings=[self.port_settings])
2365 self.inst_creator = OpenStackVmInstance(self.os_creds,
2367 test_image_settings)
2368 self.inst_creator.create()
2370 self.assertTrue(self.inst_creator.vm_active(block=True))
2372 def test_inst_from_file_3part_image_complex(self):
2374 Creates a VM instance from a locally sourced file image by overriding
2375 the default settings by using a dict() that can be read in by
2380 kernel_file = file_utils.download(
2381 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2382 ramdisk_file = file_utils.download(
2383 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2388 'name': self.image_name,
2389 'image_user': openstack_tests.CIRROS_USER,
2390 'image_file': self.image_file.name,
2391 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2392 'kernel_image_settings': {
2393 'name': self.image_name + '-kernel',
2394 'image_user': openstack_tests.CIRROS_USER,
2395 'image_file': kernel_file.name,
2396 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2397 'ramdisk_image_settings': {
2398 'name': self.image_name + '-ramdisk',
2399 'image_user': openstack_tests.CIRROS_USER,
2400 'image_file': ramdisk_file.name,
2401 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2403 os_image_settings = openstack_tests.cirros_image_settings(
2404 name=self.image_name, image_metadata=metadata)
2405 self.assertEqual(self.image_name, os_image_settings.name)
2406 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2407 self.assertEqual(openstack_tests.CIRROS_USER,
2408 os_image_settings.image_user)
2409 self.assertIsNone(os_image_settings.url)
2410 self.assertFalse(os_image_settings.exists)
2411 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2412 os_image_settings.format)
2414 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2415 self.assertEqual(self.image_name + '-kernel',
2416 os_image_settings.kernel_image_settings.name)
2417 self.assertEqual(kernel_file.name,
2418 os_image_settings.kernel_image_settings.image_file)
2419 self.assertEqual(openstack_tests.CIRROS_USER,
2420 os_image_settings.kernel_image_settings.image_user)
2421 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2422 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2423 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2424 os_image_settings.kernel_image_settings.format)
2426 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2427 self.assertEqual(self.image_name + '-ramdisk',
2428 os_image_settings.ramdisk_image_settings.name)
2429 self.assertEqual(ramdisk_file.name,
2430 os_image_settings.ramdisk_image_settings.image_file)
2431 self.assertEqual(openstack_tests.CIRROS_USER,
2432 os_image_settings.ramdisk_image_settings.image_user)
2433 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2434 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2435 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2436 os_image_settings.ramdisk_image_settings.format)
2438 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2439 self.image_creator.create()
2441 instance_settings = VmInstanceSettings(
2442 name=self.vm_inst_name,
2443 flavor=self.flavor_creator.flavor_settings.name,
2444 port_settings=[self.port_settings])
2445 self.inst_creator = OpenStackVmInstance(
2446 self.os_creds, instance_settings,
2447 self.image_creator.image_settings)
2448 self.inst_creator.create()
2450 self.assertTrue(self.inst_creator.vm_active(block=True))
2452 def test_inst_from_file_3part_image_simple_flat(self):
2454 Creates a VM instance from a 3-part image locally sourced from file
2455 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2456 attributes vs. using the 'config' option which completely overrides all
2460 kernel_file = file_utils.download(
2461 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2462 ramdisk_file = file_utils.download(
2463 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2465 metadata = {'disk_file': self.image_file.name,
2466 'kernel_file': kernel_file.name,
2467 'ramdisk_file': ramdisk_file.name}
2469 os_image_settings = openstack_tests.cirros_image_settings(
2470 name=self.image_name, image_metadata=metadata)
2472 self.assertEqual(self.image_name, os_image_settings.name)
2473 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2474 self.assertEqual(openstack_tests.CIRROS_USER,
2475 os_image_settings.image_user)
2476 self.assertIsNone(os_image_settings.url)
2477 self.assertFalse(os_image_settings.exists)
2478 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2479 os_image_settings.format)
2481 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2482 self.assertEqual(self.image_name + '-kernel',
2483 os_image_settings.kernel_image_settings.name)
2484 self.assertEqual(kernel_file.name,
2485 os_image_settings.kernel_image_settings.image_file)
2486 self.assertEqual(openstack_tests.CIRROS_USER,
2487 os_image_settings.kernel_image_settings.image_user)
2488 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2489 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2490 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2491 os_image_settings.kernel_image_settings.format)
2493 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2494 self.assertEqual(self.image_name + '-ramdisk',
2495 os_image_settings.ramdisk_image_settings.name)
2496 self.assertEqual(ramdisk_file.name,
2497 os_image_settings.ramdisk_image_settings.image_file)
2498 self.assertEqual(openstack_tests.CIRROS_USER,
2499 os_image_settings.ramdisk_image_settings.image_user)
2500 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2501 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2502 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2503 os_image_settings.ramdisk_image_settings.format)
2505 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2506 self.image_creator.create()
2508 self.assertIsNotNone(self.image_creator.get_kernel_image())
2509 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2511 instance_settings = VmInstanceSettings(
2512 name=self.vm_inst_name,
2513 flavor=self.flavor_creator.flavor_settings.name,
2514 port_settings=[self.port_settings])
2515 self.inst_creator = OpenStackVmInstance(
2516 self.os_creds, instance_settings,
2517 self.image_creator.image_settings)
2518 self.inst_creator.create()
2520 self.assertTrue(self.inst_creator.vm_active(block=True))
2522 def test_inst_from_file_3part_image_simple_nested(self):
2524 Creates a VM instance from a 3-part image locally sourced from file
2525 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2526 attributes under 'cirros' vs. using the 'config' option which
2527 completely overrides all image settings
2530 kernel_file = file_utils.download(
2531 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2532 ramdisk_file = file_utils.download(
2533 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2535 metadata = {'cirros': {'disk_file': self.image_file.name,
2536 'kernel_file': kernel_file.name,
2537 'ramdisk_file': ramdisk_file.name}}
2539 os_image_settings = openstack_tests.cirros_image_settings(
2540 name=self.image_name, image_metadata=metadata)
2542 self.assertEqual(self.image_name, os_image_settings.name)
2543 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2544 self.assertEqual(openstack_tests.CIRROS_USER,
2545 os_image_settings.image_user)
2546 self.assertIsNone(os_image_settings.url)
2547 self.assertFalse(os_image_settings.exists)
2548 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2549 os_image_settings.format)
2551 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2552 self.assertEqual(self.image_name + '-kernel',
2553 os_image_settings.kernel_image_settings.name)
2554 self.assertEqual(kernel_file.name,
2555 os_image_settings.kernel_image_settings.image_file)
2556 self.assertEqual(openstack_tests.CIRROS_USER,
2557 os_image_settings.kernel_image_settings.image_user)
2558 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2559 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2560 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2561 os_image_settings.kernel_image_settings.format)
2563 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2564 self.assertEqual(self.image_name + '-ramdisk',
2565 os_image_settings.ramdisk_image_settings.name)
2566 self.assertEqual(ramdisk_file.name,
2567 os_image_settings.ramdisk_image_settings.image_file)
2568 self.assertEqual(openstack_tests.CIRROS_USER,
2569 os_image_settings.ramdisk_image_settings.image_user)
2570 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2571 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2572 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2573 os_image_settings.ramdisk_image_settings.format)
2575 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2576 self.image_creator.create()
2578 self.assertIsNotNone(self.image_creator.get_kernel_image())
2579 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2581 instance_settings = VmInstanceSettings(
2582 name=self.vm_inst_name,
2583 flavor=self.flavor_creator.flavor_settings.name,
2584 port_settings=[self.port_settings])
2585 self.inst_creator = OpenStackVmInstance(
2586 self.os_creds, instance_settings,
2587 self.image_creator.image_settings)
2588 self.inst_creator.create()
2590 self.assertTrue(self.inst_creator.vm_active(block=True))
2592 def test_inst_from_file_3part_image_existing(self):
2594 Creates a VM instance from a 3-part image that is existing
2597 kernel_file = file_utils.download(
2598 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2599 ramdisk_file = file_utils.download(
2600 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2602 metadata = {'cirros': {'disk_file': self.image_file.name,
2603 'kernel_file': kernel_file.name,
2604 'ramdisk_file': ramdisk_file.name}}
2606 os_image_settings = openstack_tests.cirros_image_settings(
2607 name=self.image_name, image_metadata=metadata)
2608 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2609 self.image_creator.create()
2611 image_settings = self.image_creator.image_settings
2612 test_image_creator = OpenStackImage(
2614 ImageSettings(name=image_settings.name,
2615 image_user=image_settings.image_user,
2617 test_image_creator.create()
2618 self.assertEqual(self.image_creator.get_image().id,
2619 test_image_creator.get_image().id)
2621 instance_settings = VmInstanceSettings(
2622 name=self.vm_inst_name,
2623 flavor=self.flavor_creator.flavor_settings.name,
2624 port_settings=[self.port_settings])
2625 self.inst_creator = OpenStackVmInstance(
2626 self.os_creds, instance_settings,
2627 test_image_creator.image_settings)
2628 self.inst_creator.create()
2630 self.assertTrue(self.inst_creator.vm_active(block=True))
2633 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2635 Tests the ability of two VMs to communicate when attached to separate
2636 private networks that are tied together with a router.
2641 Instantiates the CreateImage object that is responsible for downloading
2642 and creating an OS image file within OpenStack
2644 super(self.__class__, self).__start__()
2646 cidr1 = '10.200.201.0/24'
2647 cidr2 = '10.200.202.0/24'
2648 static_gateway_ip1 = '10.200.201.1'
2649 static_gateway_ip2 = '10.200.202.1'
2650 self.ip1 = '10.200.201.5'
2651 self.ip2 = '10.200.202.5'
2653 self.nova = nova_utils.nova_client(self.os_creds)
2655 # Initialize for tearDown()
2656 self.image_creator = None
2657 self.network_creators = list()
2658 self.router_creator = None
2659 self.flavor_creator = None
2660 self.sec_grp_creator = None
2661 self.inst_creators = list()
2663 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2664 self.vm_inst1_name = self.guid + '-inst1'
2665 self.vm_inst2_name = self.guid + '-inst2'
2666 self.port_1_name = self.guid + '-vm1-port'
2667 self.port_2_name = self.guid + '-vm2-port'
2668 self.net_config_1 = NetworkSettings(
2669 name=self.guid + '-net1',
2671 create_network.SubnetSettings(
2672 cidr=cidr1, name=self.guid + '-subnet1',
2673 gateway_ip=static_gateway_ip1)])
2674 self.net_config_2 = NetworkSettings(
2675 name=self.guid + '-net2',
2677 create_network.SubnetSettings(
2678 cidr=cidr2, name=self.guid + '-subnet2',
2679 gateway_ip=static_gateway_ip2)])
2681 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2682 os_image_settings = openstack_tests.cirros_image_settings(
2683 name=image_name, image_metadata=self.image_metadata)
2687 self.image_creator = OpenStackImage(self.os_creds,
2689 self.image_creator.create()
2691 # First network is public
2692 self.network_creators.append(OpenStackNetwork(
2693 self.os_creds, self.net_config_1))
2694 # Second network is private
2695 self.network_creators.append(OpenStackNetwork(
2696 self.os_creds, self.net_config_2))
2697 for network_creator in self.network_creators:
2698 network_creator.create()
2701 create_network.PortSettings(
2702 name=self.guid + '-router-port1',
2705 self.net_config_1.subnet_settings[0].name,
2706 'ip': static_gateway_ip1
2708 network_name=self.net_config_1.name,
2709 project_name=self.os_creds.project_name),
2710 create_network.PortSettings(
2711 name=self.guid + '-router-port2',
2714 self.net_config_2.subnet_settings[0].name,
2715 'ip': static_gateway_ip2
2717 network_name=self.net_config_2.name,
2718 project_name=self.os_creds.project_name)]
2720 router_settings = RouterSettings(name=self.guid + '-pub-router',
2721 port_settings=port_settings)
2722 self.router_creator = create_router.OpenStackRouter(
2723 self.os_creds, router_settings)
2724 self.router_creator.create()
2727 self.flavor_creator = OpenStackFlavor(
2728 self.admin_os_creds,
2729 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
2731 metadata=self.flavor_metadata))
2732 self.flavor_creator.create()
2734 sec_grp_name = self.guid + '-sec-grp'
2735 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
2736 direction=Direction.ingress,
2737 protocol=Protocol.icmp)
2738 self.sec_grp_creator = OpenStackSecurityGroup(
2740 SecurityGroupSettings(name=sec_grp_name,
2741 rule_settings=[rule1]))
2742 self.sec_grp_creator.create()
2749 Cleans the created objects
2751 for inst_creator in self.inst_creators:
2753 inst_creator.clean()
2754 except Exception as e:
2756 'Unexpected exception cleaning VM instance with message '
2759 if self.flavor_creator:
2761 self.flavor_creator.clean()
2762 except Exception as e:
2764 'Unexpected exception cleaning flavor with message - %s',
2767 if self.router_creator:
2769 self.router_creator.clean()
2770 except Exception as e:
2772 'Unexpected exception cleaning router with message - %s',
2775 for network_creator in self.network_creators:
2777 network_creator.clean()
2778 except Exception as e:
2780 'Unexpected exception cleaning network with message - %s',
2783 if self.sec_grp_creator:
2785 self.sec_grp_creator.clean()
2786 except Exception as e:
2788 'Unexpected exception cleaning security group with message'
2791 if self.image_creator and not self.image_creator.image_settings.exists:
2793 self.image_creator.clean()
2794 except Exception as e:
2796 'Unexpected exception cleaning image with message - %s', e)
2798 super(self.__class__, self).__clean__()
2800 def test_ping_via_router(self):
2802 Tests the creation of two OpenStack instances with one port on
2803 different private networks wit a router in between to ensure that they
2807 # Create ports/NICs for instance
2810 for network_creator in self.network_creators:
2811 ports_settings.append(PortSettings(
2812 name=self.guid + '-port-' + str(ctr),
2813 network_name=network_creator.network_settings.name))
2816 # Configure instances
2817 instance1_settings = VmInstanceSettings(
2818 name=self.vm_inst1_name,
2819 flavor=self.flavor_creator.flavor_settings.name,
2820 userdata=_get_ping_userdata(self.ip2),
2821 port_settings=[PortSettings(
2822 name=self.port_1_name,
2825 self.net_config_1.subnet_settings[0].name,
2828 network_name=self.network_creators[0].network_settings.name)])
2829 instance2_settings = VmInstanceSettings(
2830 name=self.vm_inst2_name,
2831 flavor=self.flavor_creator.flavor_settings.name,
2832 userdata=_get_ping_userdata(self.ip1),
2833 port_settings=[PortSettings(
2834 name=self.port_2_name,
2837 self.net_config_2.subnet_settings[0].name,
2840 network_name=self.network_creators[1].network_settings.name)])
2843 self.inst_creators.append(OpenStackVmInstance(
2844 self.os_creds, instance1_settings,
2845 self.image_creator.image_settings))
2846 self.inst_creators.append(OpenStackVmInstance(
2847 self.os_creds, instance2_settings,
2848 self.image_creator.image_settings))
2850 for inst_creator in self.inst_creators:
2851 inst_creator.create(block=True)
2853 # Check for DHCP lease
2854 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2855 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2857 # Effectively blocks until VM has been properly activated
2858 self.assertTrue(check_ping(self.inst_creators[0]))
2859 self.assertTrue(check_ping(self.inst_creators[1]))
2862 class CreateInstanceVolumeTests(OSIntegrationTestCase):
2864 Simple instance creation with an attached volume
2869 Instantiates the CreateImage object that is responsible for downloading
2870 and creating an OS image file
2873 super(self.__class__, self).__start__()
2875 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2876 self.vm_inst_name = guid + '-inst'
2877 self.nova = nova_utils.nova_client(self.os_creds)
2878 os_image_settings = openstack_tests.cirros_image_settings(
2879 name=guid + '-image', image_metadata=self.image_metadata)
2881 net_config = openstack_tests.get_priv_net_config(
2882 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2883 router_name=guid + '-pub-router', external_net=self.ext_net_name)
2885 self.volume_settings1 = VolumeSettings(
2886 name=self.__class__.__name__ + '-' + str(guid) + '-1')
2887 self.volume_settings2 = VolumeSettings(
2888 name=self.__class__.__name__ + '-' + str(guid) + '-2')
2890 # Initialize for tearDown()
2891 self.image_creator = None
2892 self.flavor_creator = None
2894 self.network_creator = None
2895 self.inst_creator = None
2896 self.volume_creator1 = None
2897 self.volume_creator2 = None
2901 self.image_creator = OpenStackImage(self.os_creds,
2903 self.image_creator.create()
2906 self.flavor_creator = OpenStackFlavor(
2907 self.admin_os_creds,
2908 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=1,
2909 vcpus=2, metadata=self.flavor_metadata))
2910 self.flavor_creator.create()
2913 self.network_creator = OpenStackNetwork(
2914 self.os_creds, net_config.network_settings)
2915 self.network_creator.create()
2917 self.port_settings = PortSettings(
2918 name=guid + '-port',
2919 network_name=net_config.network_settings.name)
2921 self.volume_creator1 = OpenStackVolume(
2922 self.os_creds, self.volume_settings1)
2923 self.volume_creator1.create(block=True)
2925 self.volume_creator2 = OpenStackVolume(
2926 self.os_creds, self.volume_settings2)
2927 self.volume_creator2.create(block=True)
2929 except Exception as e:
2935 Cleans the created object
2937 if self.inst_creator:
2939 self.inst_creator.clean()
2940 except Exception as e:
2942 'Unexpected exception cleaning VM instance with message '
2945 if self.flavor_creator:
2947 self.flavor_creator.clean()
2948 except Exception as e:
2950 'Unexpected exception cleaning flavor with message - %s',
2953 if self.network_creator:
2955 self.network_creator.clean()
2956 except Exception as e:
2958 'Unexpected exception cleaning network with message - %s',
2961 if self.volume_creator2:
2963 self.volume_creator2.clean()
2964 except Exception as e:
2966 'Unexpected exception cleaning volume with message - %s',
2969 if self.volume_creator1:
2971 self.volume_creator1.clean()
2972 except Exception as e:
2974 'Unexpected exception cleaning volume with message - %s',
2977 if self.image_creator and not self.image_creator.image_settings.exists:
2979 self.image_creator.clean()
2980 except Exception as e:
2982 'Unexpected exception cleaning image with message - %s', e)
2984 super(self.__class__, self).__clean__()
2986 def test_create_instance_with_one_volume(self):
2988 Tests the creation of an OpenStack instance with a single volume.
2990 instance_settings = VmInstanceSettings(
2991 name=self.vm_inst_name,
2992 flavor=self.flavor_creator.flavor_settings.name,
2993 port_settings=[self.port_settings],
2994 volume_names=[self.volume_settings1.name])
2996 self.inst_creator = OpenStackVmInstance(
2997 self.os_creds, instance_settings,
2998 self.image_creator.image_settings)
3000 vm_inst = self.inst_creator.create(block=True)
3001 self.assertIsNotNone(nova_utils.get_server(
3002 self.nova, vm_inst_settings=instance_settings))
3004 self.assertIsNotNone(vm_inst)
3005 self.assertEqual(1, len(vm_inst.volume_ids))
3006 self.assertEqual(self.volume_creator1.get_volume().id,
3007 vm_inst.volume_ids[0]['id'])
3009 def test_create_instance_with_two_volumes(self):
3011 Tests the creation of an OpenStack instance with a single volume.
3013 instance_settings = VmInstanceSettings(
3014 name=self.vm_inst_name,
3015 flavor=self.flavor_creator.flavor_settings.name,
3016 port_settings=[self.port_settings],
3017 volume_names=[self.volume_settings1.name,
3018 self.volume_settings2.name])
3020 self.inst_creator = OpenStackVmInstance(
3021 self.os_creds, instance_settings,
3022 self.image_creator.image_settings)
3024 vm_inst = self.inst_creator.create(block=True)
3025 self.assertIsNotNone(nova_utils.get_server(
3026 self.nova, vm_inst_settings=instance_settings))
3028 self.assertIsNotNone(vm_inst)
3029 self.assertEqual(2, len(vm_inst.volume_ids))
3030 self.assertEqual(self.volume_creator1.get_volume().id,
3031 vm_inst.volume_ids[0]['id'])
3032 self.assertEqual(self.volume_creator2.get_volume().id,
3033 vm_inst.volume_ids[1]['id'])
3036 def check_dhcp_lease(inst_creator, ip, timeout=160):
3038 Returns true if the expected DHCP lease has been acquired
3039 :param inst_creator: the SNAPS OpenStackVmInstance object
3040 :param ip: the IP address to look for
3041 :param timeout: how long to query for IP address
3045 start_time = time.time()
3047 logger.info("Looking for IP %s in the console log" % ip)
3049 while timeout > time.time() - start_time:
3050 output = inst_creator.get_console_output()
3051 full_log = full_log + output
3052 if re.search(ip, output):
3053 logger.info('DHCP lease obtained logged in console')
3058 logger.error('Full console output -\n' + full_log)
3060 logger.debug('Full console output -\n' + full_log)
3065 def _get_ping_userdata(test_ip):
3067 Returns the post VM creation script to be added into the VM's userdata
3068 :param test_ip: the IP value to substitute into the script
3069 :return: the bash script contents
3072 return ("#!/bin/sh\n\n"
3074 " ping -c 1 %s 2>&1 >/dev/null\n"
3076 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3077 " echo 'vPing OK'\n"
3080 " echo 'vPing KO'\n"
3087 def check_ping(vm_creator, timeout=160):
3089 Check for VM for ping result
3093 while tries < timeout:
3095 p_console = vm_creator.get_console_output()
3096 if "vPing OK" in p_console:
3098 elif "failed to read iid from metadata" in p_console or tries > 5: