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.config.volume import VolumeConfig
28 from snaps.config.router import RouterConfig
29 from snaps.config.keypair import KeypairConfig
30 from snaps.openstack import create_network, create_router
31 from snaps.config.flavor import FlavorConfig
32 from snaps.openstack.create_flavor import OpenStackFlavor
33 from snaps.config.image import ImageConfig
34 from snaps.openstack.create_image import OpenStackImage
35 from snaps.openstack.create_instance import (
36 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings,
37 VmInstanceSettingsError, FloatingIpSettingsError)
38 from snaps.openstack.create_keypairs import OpenStackKeypair
39 from snaps.openstack.create_network import (
40 OpenStackNetwork, PortSettings, NetworkSettings, SubnetSettings)
41 from snaps.openstack.create_router import OpenStackRouter
42 from snaps.openstack.create_security_group import (
43 SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
45 from snaps.openstack.create_volume import OpenStackVolume
46 from snaps.openstack.tests import openstack_tests, validation_utils
47 from snaps.openstack.tests.os_source_file_test import (
48 OSIntegrationTestCase, OSComponentTestCase)
49 from snaps.openstack.utils import nova_utils
51 __author__ = 'spisarski'
55 logger = logging.getLogger('create_instance_tests')
58 class VmInstanceSettingsUnitTests(unittest.TestCase):
60 Tests the construction of the VmInstanceSettings class
63 def test_no_params(self):
64 with self.assertRaises(VmInstanceSettingsError):
67 def test_empty_config(self):
68 with self.assertRaises(VmInstanceSettingsError):
69 VmInstanceSettings(config=dict())
71 def test_name_only(self):
72 with self.assertRaises(VmInstanceSettingsError):
73 VmInstanceSettings(name='foo')
75 def test_config_with_name_only(self):
76 with self.assertRaises(VmInstanceSettingsError):
77 VmInstanceSettings(config={'name': 'foo'})
79 def test_name_flavor_only(self):
80 with self.assertRaises(VmInstanceSettingsError):
81 VmInstanceSettings(name='foo', flavor='bar')
83 def test_config_with_name_flavor_only(self):
84 with self.assertRaises(VmInstanceSettingsError):
85 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
87 def test_name_flavor_port_only(self):
88 port_settings = PortSettings(name='foo-port', network_name='bar-net')
89 settings = VmInstanceSettings(name='foo', flavor='bar',
90 port_settings=[port_settings])
91 self.assertEqual('foo', settings.name)
92 self.assertEqual('bar', settings.flavor)
93 self.assertEqual(1, len(settings.port_settings))
94 self.assertEqual('foo-port', settings.port_settings[0].name)
95 self.assertEqual('bar-net', settings.port_settings[0].network_name)
96 self.assertEqual(0, len(settings.security_group_names))
97 self.assertEqual(0, len(settings.floating_ip_settings))
98 self.assertIsNone(settings.sudo_user)
99 self.assertEqual(900, settings.vm_boot_timeout)
100 self.assertEqual(300, settings.vm_delete_timeout)
101 self.assertEqual(180, settings.ssh_connect_timeout)
102 self.assertIsNone(settings.availability_zone)
103 self.assertIsNone(settings.volume_names)
105 def test_config_with_name_flavor_port_only(self):
106 port_settings = PortSettings(name='foo-port', network_name='bar-net')
107 settings = VmInstanceSettings(
108 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
109 self.assertEqual('foo', settings.name)
110 self.assertEqual('bar', settings.flavor)
111 self.assertEqual(1, len(settings.port_settings))
112 self.assertEqual('foo-port', settings.port_settings[0].name)
113 self.assertEqual('bar-net', settings.port_settings[0].network_name)
114 self.assertEqual(0, len(settings.security_group_names))
115 self.assertEqual(0, len(settings.floating_ip_settings))
116 self.assertIsNone(settings.sudo_user)
117 self.assertEqual(900, settings.vm_boot_timeout)
118 self.assertEqual(300, settings.vm_delete_timeout)
119 self.assertEqual(180, settings.ssh_connect_timeout)
120 self.assertIsNone(settings.availability_zone)
121 self.assertIsNone(settings.volume_names)
124 port_settings = PortSettings(name='foo-port', network_name='bar-net')
125 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
126 router_name='foo-bar-router')
128 settings = VmInstanceSettings(
129 name='foo', flavor='bar', port_settings=[port_settings],
130 security_group_names=['sec_grp_1'],
131 floating_ip_settings=[fip_settings], sudo_user='joe',
132 vm_boot_timeout=999, vm_delete_timeout=333,
133 ssh_connect_timeout=111, availability_zone='server name',
134 volume_names=['vol1'])
135 self.assertEqual('foo', settings.name)
136 self.assertEqual('bar', settings.flavor)
137 self.assertEqual(1, len(settings.port_settings))
138 self.assertEqual('foo-port', settings.port_settings[0].name)
139 self.assertEqual('bar-net', settings.port_settings[0].network_name)
140 self.assertEqual(1, len(settings.security_group_names))
141 self.assertEqual('sec_grp_1', settings.security_group_names[0])
142 self.assertEqual(1, len(settings.floating_ip_settings))
143 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
144 self.assertEqual('bar-port',
145 settings.floating_ip_settings[0].port_name)
146 self.assertEqual('foo-bar-router',
147 settings.floating_ip_settings[0].router_name)
148 self.assertEqual('joe', settings.sudo_user)
149 self.assertEqual(999, settings.vm_boot_timeout)
150 self.assertEqual(333, settings.vm_delete_timeout)
151 self.assertEqual(111, settings.ssh_connect_timeout)
152 self.assertEqual('server name', settings.availability_zone)
153 self.assertEqual('vol1', settings.volume_names[0])
155 def test_config_all(self):
156 port_settings = PortSettings(name='foo-port', network_name='bar-net')
157 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
158 router_name='foo-bar-router')
160 settings = VmInstanceSettings(
161 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
162 'security_group_names': ['sec_grp_1'],
163 'floating_ips': [fip_settings], 'sudo_user': 'joe',
164 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
165 'ssh_connect_timeout': 111, 'availability_zone': 'server name',
166 'volume_names': ['vol2']})
167 self.assertEqual('foo', settings.name)
168 self.assertEqual('bar', settings.flavor)
169 self.assertEqual(1, len(settings.port_settings))
170 self.assertEqual('foo-port', settings.port_settings[0].name)
171 self.assertEqual('bar-net', settings.port_settings[0].network_name)
172 self.assertEqual(1, len(settings.security_group_names))
173 self.assertEqual(1, len(settings.floating_ip_settings))
174 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
175 self.assertEqual('bar-port',
176 settings.floating_ip_settings[0].port_name)
177 self.assertEqual('foo-bar-router',
178 settings.floating_ip_settings[0].router_name)
179 self.assertEqual('joe', settings.sudo_user)
180 self.assertEqual(999, settings.vm_boot_timeout)
181 self.assertEqual(333, settings.vm_delete_timeout)
182 self.assertEqual(111, settings.ssh_connect_timeout)
183 self.assertEqual('server name', settings.availability_zone)
184 self.assertEqual('vol2', settings.volume_names[0])
187 class FloatingIpSettingsUnitTests(unittest.TestCase):
189 Tests the construction of the FloatingIpSettings class
192 def test_no_params(self):
193 with self.assertRaises(FloatingIpSettingsError):
196 def test_empty_config(self):
197 with self.assertRaises(FloatingIpSettingsError):
198 FloatingIpSettings(**dict())
200 def test_name_only(self):
201 with self.assertRaises(FloatingIpSettingsError):
202 FloatingIpSettings(name='foo')
204 def test_config_with_name_only(self):
205 with self.assertRaises(FloatingIpSettingsError):
206 FloatingIpSettings(**{'name': 'foo'})
208 def test_name_port_only(self):
209 with self.assertRaises(FloatingIpSettingsError):
210 FloatingIpSettings(name='foo', port_name='bar')
212 def test_config_with_name_port_only(self):
213 with self.assertRaises(FloatingIpSettingsError):
214 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
216 def test_name_router_only(self):
217 with self.assertRaises(FloatingIpSettingsError):
218 FloatingIpSettings(name='foo', router_name='bar')
220 def test_config_with_name_router_only(self):
221 with self.assertRaises(FloatingIpSettingsError):
222 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
224 def test_name_port_router_name_only(self):
225 settings = FloatingIpSettings(name='foo', port_name='foo-port',
226 router_name='bar-router')
227 self.assertEqual('foo', settings.name)
228 self.assertEqual('foo-port', settings.port_name)
229 self.assertIsNone(settings.port_id)
230 self.assertEqual('bar-router', settings.router_name)
231 self.assertIsNone(settings.subnet_name)
232 self.assertTrue(settings.provisioning)
234 def test_name_port_router_id_only(self):
235 settings = FloatingIpSettings(name='foo', port_id='foo-port',
236 router_name='bar-router')
237 self.assertEqual('foo', settings.name)
238 self.assertEqual('foo-port', settings.port_id)
239 self.assertIsNone(settings.port_name)
240 self.assertEqual('bar-router', settings.router_name)
241 self.assertIsNone(settings.subnet_name)
242 self.assertTrue(settings.provisioning)
244 def test_config_with_name_port_router_only(self):
245 settings = FloatingIpSettings(
246 **{'name': 'foo', 'port_name': 'foo-port',
247 'router_name': 'bar-router'})
248 self.assertEqual('foo', settings.name)
249 self.assertEqual('foo-port', settings.port_name)
250 self.assertIsNone(settings.port_id)
251 self.assertEqual('bar-router', settings.router_name)
252 self.assertIsNone(settings.subnet_name)
253 self.assertTrue(settings.provisioning)
256 settings = FloatingIpSettings(name='foo', port_name='foo-port',
257 router_name='bar-router',
258 subnet_name='bar-subnet',
260 self.assertEqual('foo', settings.name)
261 self.assertEqual('foo-port', settings.port_name)
262 self.assertIsNone(settings.port_id)
263 self.assertEqual('bar-router', settings.router_name)
264 self.assertEqual('bar-subnet', settings.subnet_name)
265 self.assertFalse(settings.provisioning)
267 def test_config_all(self):
268 settings = FloatingIpSettings(
269 **{'name': 'foo', 'port_name': 'foo-port',
270 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
271 'provisioning': False})
272 self.assertEqual('foo', settings.name)
273 self.assertEqual('foo-port', settings.port_name)
274 self.assertIsNone(settings.port_id)
275 self.assertEqual('bar-router', settings.router_name)
276 self.assertEqual('bar-subnet', settings.subnet_name)
277 self.assertFalse(settings.provisioning)
280 class SimpleHealthCheck(OSIntegrationTestCase):
282 Test for the CreateInstance class with a single NIC/Port with Floating IPs
287 Instantiates the CreateImage object that is responsible for downloading
288 and creating an OS image file
291 super(self.__class__, self).__start__()
293 self.nova = nova_utils.nova_client(self.os_creds)
294 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
295 self.vm_inst_name = guid + '-inst'
296 self.port_1_name = guid + 'port-1'
298 # Initialize for tearDown()
299 self.image_creator = None
300 self.network_creator = None
301 self.flavor_creator = None
302 self.inst_creator = None
304 self.priv_net_config = openstack_tests.get_priv_net_config(
305 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
306 self.port_settings = PortSettings(
307 name=self.port_1_name,
308 network_name=self.priv_net_config.network_settings.name)
311 # Set the default image settings, then set any custom parameters sent
313 os_image_settings = openstack_tests.cirros_image_settings(
314 name=guid + '-image', image_metadata=self.image_metadata)
317 self.image_creator = OpenStackImage(self.os_creds,
319 self.image_creator.create()
322 self.network_creator = OpenStackNetwork(
323 self.os_creds, self.priv_net_config.network_settings)
324 self.network_creator.create()
327 self.flavor_creator = OpenStackFlavor(
329 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
330 vcpus=1, metadata=self.flavor_metadata))
331 self.flavor_creator.create()
332 except Exception as e:
338 Cleans the created object
340 if self.inst_creator:
342 self.inst_creator.clean()
343 except Exception as e:
345 'Unexpected exception cleaning VM instance with message'
348 if self.network_creator:
350 self.network_creator.clean()
351 except Exception as e:
353 'Unexpected exception cleaning network with message - %s',
356 if self.flavor_creator:
358 self.flavor_creator.clean()
359 except Exception as e:
361 'Unexpected exception cleaning flavor with message - %s',
364 if self.image_creator and not self.image_creator.image_settings.exists:
366 self.image_creator.clean()
367 except Exception as e:
369 'Unexpected exception cleaning image with message - %s',
372 super(self.__class__, self).__clean__()
374 def test_check_vm_ip_dhcp(self):
376 Tests the creation of an OpenStack instance with a single port and
377 ensures that it's assigned IP address is the actual.
379 instance_settings = VmInstanceSettings(
380 name=self.vm_inst_name,
381 flavor=self.flavor_creator.flavor_settings.name,
382 port_settings=[self.port_settings])
384 self.inst_creator = OpenStackVmInstance(
385 self.os_creds, instance_settings,
386 self.image_creator.image_settings)
387 self.inst_creator.create()
389 ip = self.inst_creator.get_port_ip(self.port_settings.name)
390 self.assertIsNotNone(ip)
392 self.assertTrue(self.inst_creator.vm_active(block=True))
394 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
397 class CreateInstanceSimpleTests(OSIntegrationTestCase):
399 Simple instance creation tests without any other objects
404 Instantiates the CreateImage object that is responsible for downloading
405 and creating an OS image file
408 super(self.__class__, self).__start__()
410 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
411 self.vm_inst_name = guid + '-inst'
412 self.nova = nova_utils.nova_client(self.os_creds)
413 os_image_settings = openstack_tests.cirros_image_settings(
414 name=guid + '-image', image_metadata=self.image_metadata)
416 net_config = openstack_tests.get_priv_net_config(
417 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
418 router_name=guid + '-pub-router', external_net=self.ext_net_name)
420 # Initialize for tearDown()
421 self.image_creator = None
422 self.flavor_creator = None
424 self.network_creator = None
425 self.inst_creator = None
429 self.image_creator = OpenStackImage(self.os_creds,
431 self.image_creator.create()
434 self.flavor_creator = OpenStackFlavor(
436 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
437 vcpus=2, metadata=self.flavor_metadata))
438 self.flavor_creator.create()
441 self.network_creator = OpenStackNetwork(
442 self.os_creds, net_config.network_settings)
443 self.network_creator.create()
445 self.port_settings = PortSettings(
447 network_name=net_config.network_settings.name)
449 except Exception as e:
455 Cleans the created object
457 if self.inst_creator:
459 self.inst_creator.clean()
460 except Exception as e:
462 'Unexpected exception cleaning VM instance with message '
465 if self.flavor_creator:
467 self.flavor_creator.clean()
468 except Exception as e:
470 'Unexpected exception cleaning flavor with message - %s',
473 if self.network_creator:
475 self.network_creator.clean()
476 except Exception as e:
478 'Unexpected exception cleaning network with message - %s',
481 if self.image_creator and not self.image_creator.image_settings.exists:
483 self.image_creator.clean()
484 except Exception as e:
486 'Unexpected exception cleaning image with message - %s', e)
488 super(self.__class__, self).__clean__()
490 def test_create_delete_instance(self):
492 Tests the creation of an OpenStack instance with a single port with a
493 static IP without a Floating IP.
495 instance_settings = VmInstanceSettings(
496 name=self.vm_inst_name,
497 flavor=self.flavor_creator.flavor_settings.name,
498 port_settings=[self.port_settings])
500 self.inst_creator = OpenStackVmInstance(
501 self.os_creds, instance_settings,
502 self.image_creator.image_settings)
504 vm_inst = self.inst_creator.create()
505 self.assertIsNotNone(nova_utils.get_server(
506 self.nova, vm_inst_settings=instance_settings))
509 nova_utils.delete_vm_instance(self.nova, vm_inst)
511 self.assertTrue(self.inst_creator.vm_deleted(block=True))
512 self.assertIsNone(nova_utils.get_server(
513 self.nova, vm_inst_settings=instance_settings))
515 # Exception should not be thrown
516 self.inst_creator.clean()
519 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
521 Test for the CreateInstance class with a single NIC/Port with Floating IPs
526 Instantiates the CreateImage object that is responsible for downloading
527 and creating an OS image file within OpenStack
529 super(self.__class__, self).__start__()
531 self.nova = nova_utils.nova_client(self.os_creds)
532 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
533 self.keypair_priv_filepath = 'tmp/' + guid
534 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
535 self.keypair_name = guid + '-kp'
536 self.vm_inst_name = guid + '-inst'
537 self.port_1_name = guid + 'port-1'
538 self.port_2_name = guid + 'port-2'
539 self.floating_ip_name = guid + 'fip1'
541 # Initialize for tearDown()
542 self.image_creator = None
543 self.network_creator = None
544 self.router_creator = None
545 self.flavor_creator = None
546 self.keypair_creator = None
547 self.sec_grp_creator = None
548 self.inst_creators = list()
550 self.pub_net_config = openstack_tests.get_pub_net_config(
551 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
552 router_name=guid + '-pub-router', external_net=self.ext_net_name)
553 os_image_settings = openstack_tests.cirros_image_settings(
554 name=guid + '-image', image_metadata=self.image_metadata)
557 self.image_creator = OpenStackImage(self.os_creds,
559 self.image_creator.create()
562 self.network_creator = OpenStackNetwork(
563 self.os_creds, self.pub_net_config.network_settings)
564 self.network_creator.create()
567 self.router_creator = OpenStackRouter(
568 self.os_creds, self.pub_net_config.router_settings)
569 self.router_creator.create()
572 self.flavor_creator = OpenStackFlavor(
574 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
575 vcpus=2, metadata=self.flavor_metadata))
576 self.flavor_creator.create()
578 self.keypair_creator = OpenStackKeypair(
579 self.os_creds, KeypairConfig(
580 name=self.keypair_name,
581 public_filepath=self.keypair_pub_filepath,
582 private_filepath=self.keypair_priv_filepath))
583 self.keypair_creator.create()
585 sec_grp_name = guid + '-sec-grp'
586 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
587 direction=Direction.ingress,
588 protocol=Protocol.icmp)
589 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
590 direction=Direction.ingress,
591 protocol=Protocol.tcp,
594 self.sec_grp_creator = OpenStackSecurityGroup(
596 SecurityGroupSettings(name=sec_grp_name,
597 rule_settings=[rule1, rule2]))
598 self.sec_grp_creator.create()
599 except Exception as e:
605 Cleans the created object
607 for inst_creator in self.inst_creators:
610 except Exception as e:
612 'Unexpected exception cleaning VM instance with message '
615 if self.keypair_creator:
617 self.keypair_creator.clean()
618 except Exception as e:
620 'Unexpected exception cleaning keypair with message - %s',
623 if self.flavor_creator:
625 self.flavor_creator.clean()
626 except Exception as e:
628 'Unexpected exception cleaning flavor with message - %s',
631 if self.sec_grp_creator:
633 self.sec_grp_creator.clean()
634 except Exception as e:
636 'Unexpected exception cleaning security group with message'
639 if self.router_creator:
641 self.router_creator.clean()
642 except Exception as e:
644 'Unexpected exception cleaning router with message - %s',
647 if self.network_creator:
649 self.network_creator.clean()
650 except Exception as e:
652 'Unexpected exception cleaning network with message - %s',
655 if self.image_creator and not self.image_creator.image_settings.exists:
657 self.image_creator.clean()
658 except Exception as e:
660 'Unexpected exception cleaning image with message - %s', e)
662 super(self.__class__, self).__clean__()
664 def test_single_port_static(self):
666 Tests the creation of an OpenStack instance with a single port with a
667 static IP without a Floating IP.
670 sub_settings = self.pub_net_config.network_settings.subnet_settings
671 port_settings = PortSettings(
672 name=self.port_1_name,
673 network_name=self.pub_net_config.network_settings.name,
675 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
677 instance_settings = VmInstanceSettings(
678 name=self.vm_inst_name,
679 flavor=self.flavor_creator.flavor_settings.name,
680 port_settings=[port_settings],
681 floating_ip_settings=[FloatingIpSettings(
682 name=self.floating_ip_name, port_name=self.port_1_name,
683 router_name=self.pub_net_config.router_settings.name)])
685 inst_creator = OpenStackVmInstance(
686 self.os_creds, instance_settings,
687 self.image_creator.image_settings,
688 keypair_settings=self.keypair_creator.keypair_settings)
689 self.inst_creators.append(inst_creator)
690 vm_inst = inst_creator.create(block=True)
692 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
693 self.assertTrue(inst_creator.vm_active(block=True))
694 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
696 def test_ssh_client_fip_before_active(self):
698 Tests the ability to access a VM via SSH and a floating IP when it has
699 been assigned prior to being active.
701 port_settings = PortSettings(
702 name=self.port_1_name,
703 network_name=self.pub_net_config.network_settings.name)
705 instance_settings = VmInstanceSettings(
706 name=self.vm_inst_name,
707 flavor=self.flavor_creator.flavor_settings.name,
708 port_settings=[port_settings],
709 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
710 floating_ip_settings=[FloatingIpSettings(
711 name=self.floating_ip_name, port_name=self.port_1_name,
712 router_name=self.pub_net_config.router_settings.name)])
714 inst_creator = OpenStackVmInstance(
715 self.os_creds, instance_settings,
716 self.image_creator.image_settings,
717 keypair_settings=self.keypair_creator.keypair_settings)
718 self.inst_creators.append(inst_creator)
719 vm_inst = inst_creator.create()
720 self.assertIsNotNone(vm_inst)
722 self.assertTrue(inst_creator.vm_active(block=True))
724 ip = inst_creator.get_port_ip(port_settings.name)
725 self.assertTrue(check_dhcp_lease(inst_creator, ip))
727 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
729 self.assertTrue(validate_ssh_client(inst_creator))
731 def test_ssh_client_fip_after_active(self):
733 Tests the ability to access a VM via SSH and a floating IP when it has
734 been assigned prior to being active.
736 port_settings = PortSettings(
737 name=self.port_1_name,
738 network_name=self.pub_net_config.network_settings.name)
740 instance_settings = VmInstanceSettings(
741 name=self.vm_inst_name,
742 flavor=self.flavor_creator.flavor_settings.name,
743 port_settings=[port_settings],
744 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
745 floating_ip_settings=[FloatingIpSettings(
746 name=self.floating_ip_name, port_name=self.port_1_name,
747 router_name=self.pub_net_config.router_settings.name)])
749 inst_creator = OpenStackVmInstance(
750 self.os_creds, instance_settings,
751 self.image_creator.image_settings,
752 keypair_settings=self.keypair_creator.keypair_settings)
753 self.inst_creators.append(inst_creator)
755 # block=True will force the create() method to block until the
756 vm_inst = inst_creator.create(block=True)
757 self.assertIsNotNone(vm_inst)
759 self.assertTrue(inst_creator.vm_active(block=True))
761 ip = inst_creator.get_port_ip(port_settings.name)
762 self.assertTrue(check_dhcp_lease(inst_creator, ip))
764 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
766 self.assertTrue(validate_ssh_client(inst_creator))
768 def test_ssh_client_fip_second_creator(self):
770 Tests the ability to access a VM via SSH and a floating IP via a
771 creator that is identical to the original creator.
773 port_settings = PortSettings(
774 name=self.port_1_name,
775 network_name=self.pub_net_config.network_settings.name)
777 instance_settings = VmInstanceSettings(
778 name=self.vm_inst_name,
779 flavor=self.flavor_creator.flavor_settings.name,
780 port_settings=[port_settings],
781 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
782 floating_ip_settings=[FloatingIpSettings(
783 name=self.floating_ip_name, port_name=self.port_1_name,
784 router_name=self.pub_net_config.router_settings.name)])
786 inst_creator = OpenStackVmInstance(
787 self.os_creds, instance_settings,
788 self.image_creator.image_settings,
789 keypair_settings=self.keypair_creator.keypair_settings)
790 self.inst_creators.append(inst_creator)
792 # block=True will force the create() method to block until the
793 vm_inst = inst_creator.create(block=True)
794 self.assertIsNotNone(vm_inst)
796 self.assertTrue(inst_creator.vm_active(block=True))
798 ip = inst_creator.get_port_ip(port_settings.name)
799 self.assertTrue(check_dhcp_lease(inst_creator, ip))
801 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
803 self.assertTrue(validate_ssh_client(inst_creator))
805 inst_creator2 = OpenStackVmInstance(
806 self.os_creds, instance_settings,
807 self.image_creator.image_settings,
808 keypair_settings=self.keypair_creator.keypair_settings)
809 inst_creator2.create()
810 self.assertTrue(validate_ssh_client(inst_creator2))
813 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
815 Test for the CreateInstance class with a single NIC/Port with Floating IPs
820 Instantiates the CreateImage object that is responsible for downloading
821 and creating an OS image file within OpenStack
823 super(self.__class__, self).__start__()
825 self.nova = nova_utils.nova_client(self.os_creds)
826 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
827 self.keypair_priv_filepath = 'tmp/' + self.guid
828 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
829 self.keypair_name = self.guid + '-kp'
830 self.vm_inst_name = self.guid + '-inst'
831 self.port1_name = self.guid + 'port1'
832 self.port2_name = self.guid + 'port2'
834 # Initialize for tearDown()
835 self.image_creator = None
836 self.network_creator = None
837 self.router_creator = None
838 self.flavor_creator = None
839 self.keypair_creator = None
840 self.sec_grp_creator = None
841 self.inst_creator = None
843 os_image_settings = openstack_tests.cirros_image_settings(
844 name=self.guid + '-image', image_metadata=self.image_metadata)
846 self.image_creator = OpenStackImage(
847 self.os_creds, os_image_settings)
848 self.image_creator.create()
850 self.flavor_creator = OpenStackFlavor(
853 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
854 metadata=self.flavor_metadata))
855 self.flavor_creator.create()
857 self.keypair_creator = OpenStackKeypair(
858 self.os_creds, KeypairConfig(
859 name=self.keypair_name,
860 public_filepath=self.keypair_pub_filepath,
861 private_filepath=self.keypair_priv_filepath))
862 self.keypair_creator.create()
864 sec_grp_name = self.guid + '-sec-grp'
865 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
866 direction=Direction.ingress,
867 protocol=Protocol.icmp)
868 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
869 direction=Direction.ingress,
870 protocol=Protocol.tcp,
873 self.sec_grp_creator = OpenStackSecurityGroup(
875 SecurityGroupSettings(name=sec_grp_name,
876 rule_settings=[rule1, rule2]))
877 self.sec_grp_creator.create()
878 except Exception as e:
884 Cleans the created object
886 if self.inst_creator:
888 self.inst_creator.clean()
889 except Exception as e:
891 'Unexpected exception cleaning VM instance with message '
894 if self.keypair_creator:
896 self.keypair_creator.clean()
897 except Exception as e:
899 'Unexpected exception cleaning keypair with message - %s',
902 if self.flavor_creator:
904 self.flavor_creator.clean()
905 except Exception as e:
907 'Unexpected exception cleaning flavor with message - %s',
910 if self.sec_grp_creator:
912 self.sec_grp_creator.clean()
913 except Exception as e:
915 'Unexpected exception cleaning security group with message'
918 if self.router_creator:
920 self.router_creator.clean()
921 except Exception as e:
923 'Unexpected exception cleaning router with message - %s',
926 if self.network_creator:
928 self.network_creator.clean()
929 except Exception as e:
931 'Unexpected exception cleaning network with message - %s',
934 if self.image_creator and not self.image_creator.image_settings.exists:
936 self.image_creator.clean()
937 except Exception as e:
939 'Unexpected exception cleaning image with message - %s', e)
941 super(self.__class__, self).__clean__()
943 def test_v4fip_v6overlay(self):
945 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
946 network when the external network does not have an IPv6 subnet.
948 subnet_settings = SubnetSettings(
949 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
951 network_settings = NetworkSettings(
952 name=self.guid + '-net', subnet_settings=[subnet_settings])
953 router_settings = RouterConfig(
954 name=self.guid + '-router', external_gateway=self.ext_net_name,
955 internal_subnets=[subnet_settings.name])
958 self.network_creator = OpenStackNetwork(
959 self.os_creds, network_settings)
960 self.network_creator.create()
963 self.router_creator = OpenStackRouter(
964 self.os_creds, router_settings)
965 self.router_creator.create()
967 port_settings = PortSettings(
968 name=self.port1_name, network_name=network_settings.name)
970 instance_settings = VmInstanceSettings(
971 name=self.vm_inst_name,
972 flavor=self.flavor_creator.flavor_settings.name,
973 port_settings=[port_settings],
974 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
975 floating_ip_settings=[FloatingIpSettings(
976 name='fip1', port_name=self.port1_name,
977 router_name=router_settings.name)])
979 self.inst_creator = OpenStackVmInstance(
980 self.os_creds, instance_settings,
981 self.image_creator.image_settings,
982 keypair_settings=self.keypair_creator.keypair_settings)
984 with self.assertRaises(BadRequest):
985 self.inst_creator.create(block=True)
987 def test_fip_v4and6_overlay(self):
989 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
990 network when the external network does not have an IPv6 subnet.
992 subnet4_settings = SubnetSettings(
993 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
995 subnet6_settings = SubnetSettings(
996 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
998 network_settings = NetworkSettings(
999 name=self.guid + '-net',
1000 subnet_settings=[subnet4_settings, subnet6_settings])
1001 router_settings = RouterConfig(
1002 name=self.guid + '-router', external_gateway=self.ext_net_name,
1003 internal_subnets=[subnet4_settings.name])
1006 self.network_creator = OpenStackNetwork(
1007 self.os_creds, network_settings)
1008 self.network_creator.create()
1011 self.router_creator = OpenStackRouter(
1012 self.os_creds, router_settings)
1013 self.router_creator.create()
1015 port_settings = PortSettings(
1016 name=self.port1_name, network_name=network_settings.name)
1018 instance_settings = VmInstanceSettings(
1019 name=self.vm_inst_name,
1020 flavor=self.flavor_creator.flavor_settings.name,
1021 port_settings=[port_settings],
1022 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1023 floating_ip_settings=[FloatingIpSettings(
1024 name='fip1', port_name=self.port1_name,
1025 router_name=router_settings.name)])
1027 self.inst_creator = OpenStackVmInstance(
1028 self.os_creds, instance_settings,
1029 self.image_creator.image_settings,
1030 keypair_settings=self.keypair_creator.keypair_settings)
1032 self.inst_creator.create(block=True)
1033 ssh_client = self.inst_creator.ssh_client()
1034 self.assertIsNotNone(ssh_client)
1037 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1039 Test for the CreateInstance class with a single NIC/Port where mac and IP
1040 values are manually set
1045 Instantiates the CreateImage object that is responsible for downloading
1046 and creating an OS image file within OpenStack
1048 super(self.__class__, self).__start__()
1050 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1051 self.vm_inst_name = guid + '-inst'
1052 self.port_1_name = guid + 'port-1'
1053 self.port_2_name = guid + 'port-2'
1054 self.floating_ip_name = guid + 'fip1'
1056 # Initialize for tearDown()
1057 self.image_creator = None
1058 self.network_creator = None
1059 self.flavor_creator = None
1060 self.inst_creator = None
1062 self.net_config = openstack_tests.get_priv_net_config(
1063 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1064 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1065 os_image_settings = openstack_tests.cirros_image_settings(
1066 name=guid + '-image', image_metadata=self.image_metadata)
1070 self.image_creator = OpenStackImage(self.os_creds,
1072 self.image_creator.create()
1075 self.network_creator = OpenStackNetwork(
1076 self.os_creds, self.net_config.network_settings)
1077 self.network_creator.create()
1080 self.flavor_creator = OpenStackFlavor(
1081 self.admin_os_creds,
1082 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1083 vcpus=2, metadata=self.flavor_metadata))
1084 self.flavor_creator.create()
1085 except Exception as e:
1091 Cleans the created object
1093 if self.inst_creator:
1095 self.inst_creator.clean()
1096 except Exception as e:
1098 'Unexpected exception cleaning VM instance with message '
1101 if self.flavor_creator:
1103 self.flavor_creator.clean()
1104 except Exception as e:
1106 'Unexpected exception cleaning flavor with message - %s',
1109 if self.network_creator:
1111 self.network_creator.clean()
1112 except Exception as e:
1114 'Unexpected exception cleaning network with message - %s',
1117 if self.image_creator and not self.image_creator.image_settings.exists:
1119 self.image_creator.clean()
1120 except Exception as e:
1122 'Unexpected exception cleaning image with message - %s', e)
1124 super(self.__class__, self).__clean__()
1126 def test_set_custom_valid_ip_one_subnet(self):
1128 Tests the creation of an OpenStack instance with a single port with a
1129 static IP on a network with one subnet.
1132 sub_settings = self.net_config.network_settings.subnet_settings
1133 port_settings = PortSettings(
1134 name=self.port_1_name,
1135 network_name=self.net_config.network_settings.name,
1136 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1138 instance_settings = VmInstanceSettings(
1139 name=self.vm_inst_name,
1140 flavor=self.flavor_creator.flavor_settings.name,
1141 port_settings=[port_settings])
1143 self.inst_creator = OpenStackVmInstance(
1144 self.os_creds, instance_settings,
1145 self.image_creator.image_settings)
1146 self.inst_creator.create(block=True)
1148 self.assertEqual(ip, self.inst_creator.get_port_ip(
1150 subnet_name=self.net_config.network_settings.subnet_settings[
1153 def test_set_custom_invalid_ip_one_subnet(self):
1155 Tests the creation of an OpenStack instance with a single port with a
1156 static IP on a network with one subnet.
1159 sub_settings = self.net_config.network_settings.subnet_settings
1160 port_settings = PortSettings(
1161 name=self.port_1_name,
1162 network_name=self.net_config.network_settings.name,
1163 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1165 instance_settings = VmInstanceSettings(
1166 name=self.vm_inst_name,
1167 flavor=self.flavor_creator.flavor_settings.name,
1168 port_settings=[port_settings])
1170 self.inst_creator = OpenStackVmInstance(
1171 self.os_creds, instance_settings,
1172 self.image_creator.image_settings)
1174 with self.assertRaises(InvalidIpForSubnetClient):
1175 self.inst_creator.create()
1177 def test_set_custom_valid_mac(self):
1179 Tests the creation of an OpenStack instance with a single port where
1180 the MAC address is assigned.
1182 mac_addr = '0a:1b:2c:3d:4e:5f'
1183 port_settings = PortSettings(
1184 name=self.port_1_name,
1185 network_name=self.net_config.network_settings.name,
1186 mac_address=mac_addr)
1188 instance_settings = VmInstanceSettings(
1189 name=self.vm_inst_name,
1190 flavor=self.flavor_creator.flavor_settings.name,
1191 port_settings=[port_settings])
1193 self.inst_creator = OpenStackVmInstance(
1194 self.os_creds, instance_settings,
1195 self.image_creator.image_settings)
1196 self.inst_creator.create(block=True)
1198 self.assertEqual(mac_addr,
1199 self.inst_creator.get_port_mac(self.port_1_name))
1201 def test_set_custom_invalid_mac(self):
1203 Tests the creation of an OpenStack instance with a single port where an
1204 invalid MAC address value is being
1205 assigned. This should raise an Exception
1207 port_settings = PortSettings(
1208 name=self.port_1_name,
1209 network_name=self.net_config.network_settings.name,
1212 instance_settings = VmInstanceSettings(
1213 name=self.vm_inst_name,
1214 flavor=self.flavor_creator.flavor_settings.name,
1215 port_settings=[port_settings])
1217 self.inst_creator = OpenStackVmInstance(
1218 self.os_creds, instance_settings,
1219 self.image_creator.image_settings)
1221 with self.assertRaises(Exception):
1222 self.inst_creator.create()
1224 def test_set_custom_mac_and_ip(self):
1226 Tests the creation of an OpenStack instance with a single port where
1227 the IP and MAC address is assigned.
1230 mac_addr = '0a:1b:2c:3d:4e:5f'
1231 sub_settings = self.net_config.network_settings.subnet_settings
1232 port_settings = PortSettings(
1233 name=self.port_1_name,
1234 network_name=self.net_config.network_settings.name,
1235 mac_address=mac_addr,
1236 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1238 instance_settings = VmInstanceSettings(
1239 name=self.vm_inst_name,
1240 flavor=self.flavor_creator.flavor_settings.name,
1241 port_settings=[port_settings])
1243 self.inst_creator = OpenStackVmInstance(
1244 self.os_creds, instance_settings,
1245 self.image_creator.image_settings)
1246 self.inst_creator.create(block=True)
1248 self.assertEqual(ip, self.inst_creator.get_port_ip(
1250 subnet_name=self.net_config.network_settings.subnet_settings[
1252 self.assertEqual(mac_addr,
1253 self.inst_creator.get_port_mac(self.port_1_name))
1255 def test_set_allowed_address_pairs(self):
1257 Tests the creation of an OpenStack instance with a single port where
1258 max_allowed_address_pair is set.
1261 mac_addr = '0a:1b:2c:3d:4e:5f'
1262 pair = {'ip_address': ip, 'mac_address': mac_addr}
1263 port_settings = PortSettings(
1264 name=self.port_1_name,
1265 network_name=self.net_config.network_settings.name,
1266 allowed_address_pairs=[pair])
1268 instance_settings = VmInstanceSettings(
1269 name=self.vm_inst_name,
1270 flavor=self.flavor_creator.flavor_settings.name,
1271 port_settings=[port_settings])
1273 self.inst_creator = OpenStackVmInstance(
1274 self.os_creds, instance_settings,
1275 self.image_creator.image_settings)
1276 self.inst_creator.create(block=True)
1278 port = self.inst_creator.get_port_by_name(port_settings.name)
1279 self.assertIsNotNone(port)
1280 self.assertIsNotNone(port.allowed_address_pairs)
1281 self.assertEqual(1, len(port.allowed_address_pairs))
1282 validation_utils.objects_equivalent(pair,
1283 port.allowed_address_pairs[0])
1285 def test_set_allowed_address_pairs_bad_mac(self):
1287 Tests the creation of an OpenStack instance with a single port where
1288 max_allowed_address_pair is set with an invalid MAC address.
1292 pair = {'ip_address': ip, 'mac_address': mac_addr}
1294 pairs.add((ip, mac_addr))
1295 port_settings = PortSettings(
1296 name=self.port_1_name,
1297 network_name=self.net_config.network_settings.name,
1298 allowed_address_pairs=[pair])
1300 instance_settings = VmInstanceSettings(
1301 name=self.vm_inst_name,
1302 flavor=self.flavor_creator.flavor_settings.name,
1303 port_settings=[port_settings])
1305 self.inst_creator = OpenStackVmInstance(
1306 self.os_creds, instance_settings,
1307 self.image_creator.image_settings)
1308 with self.assertRaises(Exception):
1309 self.inst_creator.create()
1311 def test_set_allowed_address_pairs_bad_ip(self):
1313 Tests the creation of an OpenStack instance with a single port where
1314 max_allowed_address_pair is set with an invalid MAC address.
1317 mac_addr = '0a:1b:2c:3d:4e:5f'
1318 pair = {'ip_address': ip, 'mac_address': mac_addr}
1320 pairs.add((ip, mac_addr))
1321 port_settings = PortSettings(
1322 name=self.port_1_name,
1323 network_name=self.net_config.network_settings.name,
1324 allowed_address_pairs=[pair])
1326 instance_settings = VmInstanceSettings(
1327 name=self.vm_inst_name,
1328 flavor=self.flavor_creator.flavor_settings.name,
1329 port_settings=[port_settings])
1331 self.inst_creator = OpenStackVmInstance(
1332 self.os_creds, instance_settings,
1333 self.image_creator.image_settings)
1334 with self.assertRaises(Exception):
1335 self.inst_creator.create()
1338 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1340 Test for the CreateInstance where one VM is deployed to each compute node
1345 Instantiates the CreateImage object that is responsible for downloading
1346 and creating an OS image file within OpenStack
1348 super(self.__class__, self).__start__()
1350 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1351 self.vm_inst_name = guid + '-inst'
1352 self.port_base_name = guid + 'port'
1354 # Initialize for tearDown()
1355 self.image_creator = None
1356 self.flavor_creator = None
1357 self.network_creator = None
1358 self.inst_creators = list()
1360 self.priv_net_config = openstack_tests.get_priv_net_config(
1361 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1363 os_image_settings = openstack_tests.cirros_image_settings(
1364 name=guid + '-image', image_metadata=self.image_metadata)
1368 self.network_creator = OpenStackNetwork(
1369 self.admin_os_creds, self.priv_net_config.network_settings)
1370 self.network_creator.create()
1373 self.flavor_creator = OpenStackFlavor(
1374 self.admin_os_creds,
1375 FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
1376 vcpus=1, metadata=self.flavor_metadata))
1377 self.flavor_creator.create()
1380 self.image_creator = OpenStackImage(self.os_creds,
1382 self.image_creator.create()
1384 except Exception as e:
1390 Cleans the created object
1392 for inst_creator in self.inst_creators:
1394 inst_creator.clean()
1395 except Exception as e:
1397 'Unexpected exception cleaning VM instance with message '
1400 if self.flavor_creator:
1402 self.flavor_creator.clean()
1403 except Exception as e:
1405 'Unexpected exception cleaning flavor with message - %s',
1408 if self.network_creator:
1410 self.network_creator.clean()
1411 except Exception as e:
1413 'Unexpected exception cleaning network with message - %s',
1416 if self.image_creator and not self.image_creator.image_settings.exists:
1418 self.image_creator.clean()
1419 except Exception as e:
1421 'Unexpected exception cleaning image with message - %s', e)
1423 super(self.__class__, self).__clean__()
1425 def test_deploy_vm_to_each_compute_node(self):
1427 Tests the creation of OpenStack VM instances to each compute node.
1429 from snaps.openstack.utils import nova_utils
1430 nova = nova_utils.nova_client(self.admin_os_creds)
1431 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1433 # Create Instance on each server/zone
1435 for zone in zone_hosts:
1436 inst_name = self.vm_inst_name + '-' + zone
1438 port_settings = PortSettings(
1439 name=self.port_base_name + '-' + str(ctr),
1440 network_name=self.priv_net_config.network_settings.name)
1442 instance_settings = VmInstanceSettings(
1444 flavor=self.flavor_creator.flavor_settings.name,
1445 availability_zone=zone,
1446 port_settings=[port_settings])
1447 inst_creator = OpenStackVmInstance(
1448 self.admin_os_creds, instance_settings,
1449 self.image_creator.image_settings)
1450 self.inst_creators.append(inst_creator)
1451 inst_creator.create()
1453 # Validate instances to ensure they've been deployed to the correct
1456 for zone in zone_hosts:
1457 creator = self.inst_creators[index]
1458 self.assertTrue(creator.vm_active(block=True))
1459 info = creator.get_vm_info()
1460 deployed_zone = info['OS-EXT-AZ:availability_zone']
1461 deployed_host = info['OS-EXT-SRV-ATTR:host']
1462 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1466 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1468 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1470 These tests require a Centos image
1475 Instantiates the CreateImage object that is responsible for downloading
1476 and creating an OS image file within OpenStack
1478 super(self.__class__, self).__start__()
1480 self.nova = nova_utils.nova_client(self.os_creds)
1482 # Initialize for tearDown()
1483 self.image_creator = None
1484 self.network_creators = list()
1485 self.router_creators = list()
1486 self.flavor_creator = None
1487 self.keypair_creator = None
1488 self.sec_grp_creator = None
1489 self.inst_creator = None
1491 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1492 self.keypair_priv_filepath = 'tmp/' + self.guid
1493 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1494 self.keypair_name = self.guid + '-kp'
1495 self.vm_inst_name = self.guid + '-inst'
1496 self.port_1_name = self.guid + '-port-1'
1497 self.port_2_name = self.guid + '-port-2'
1498 self.floating_ip_name = self.guid + 'fip1'
1499 self.priv_net_config = openstack_tests.get_priv_net_config(
1500 net_name=self.guid + '-priv-net',
1501 subnet_name=self.guid + '-priv-subnet',
1502 router_name=self.guid + '-priv-router',
1503 external_net=self.ext_net_name)
1504 self.pub_net_config = openstack_tests.get_pub_net_config(
1505 net_name=self.guid + '-pub-net',
1506 subnet_name=self.guid + '-pub-subnet',
1507 router_name=self.guid + '-pub-router',
1508 external_net=self.ext_net_name)
1510 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1511 os_image_settings = openstack_tests.centos_image_settings(
1512 name=image_name, image_metadata=self.image_metadata)
1516 self.image_creator = OpenStackImage(self.os_creds,
1518 self.image_creator.create()
1520 # First network is public
1521 self.network_creators.append(OpenStackNetwork(
1522 self.os_creds, self.pub_net_config.network_settings))
1523 # Second network is private
1524 self.network_creators.append(OpenStackNetwork(
1525 self.os_creds, self.priv_net_config.network_settings))
1526 for network_creator in self.network_creators:
1527 network_creator.create()
1529 self.router_creators.append(OpenStackRouter(
1530 self.os_creds, self.pub_net_config.router_settings))
1531 self.router_creators.append(OpenStackRouter(
1532 self.os_creds, self.priv_net_config.router_settings))
1535 for router_creator in self.router_creators:
1536 router_creator.create()
1539 self.flavor_creator = OpenStackFlavor(
1540 self.admin_os_creds,
1541 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
1543 metadata=self.flavor_metadata))
1544 self.flavor_creator.create()
1547 self.keypair_creator = OpenStackKeypair(
1548 self.os_creds, KeypairConfig(
1549 name=self.keypair_name,
1550 public_filepath=self.keypair_pub_filepath,
1551 private_filepath=self.keypair_priv_filepath))
1552 self.keypair_creator.create()
1554 sec_grp_name = self.guid + '-sec-grp'
1555 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1556 direction=Direction.ingress,
1557 protocol=Protocol.icmp)
1558 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1559 direction=Direction.ingress,
1560 protocol=Protocol.tcp,
1563 self.sec_grp_creator = OpenStackSecurityGroup(
1565 SecurityGroupSettings(name=sec_grp_name,
1566 rule_settings=[rule1, rule2]))
1567 self.sec_grp_creator.create()
1574 Cleans the created objects
1576 if self.inst_creator:
1578 self.inst_creator.clean()
1579 except Exception as e:
1581 'Unexpected exception cleaning VM instance with message '
1584 if self.keypair_creator:
1586 self.keypair_creator.clean()
1587 except Exception as e:
1589 'Unexpected exception cleaning keypair with message - %s',
1592 if self.flavor_creator:
1594 self.flavor_creator.clean()
1595 except Exception as e:
1597 'Unexpected exception cleaning flavor with message - %s',
1600 for router_creator in self.router_creators:
1602 router_creator.clean()
1603 except Exception as e:
1605 'Unexpected exception cleaning router with message - %s',
1608 for network_creator in self.network_creators:
1610 network_creator.clean()
1611 except Exception as e:
1613 'Unexpected exception cleaning network with message - %s',
1616 if self.sec_grp_creator:
1618 self.sec_grp_creator.clean()
1619 except Exception as e:
1621 'Unexpected exception cleaning security group with message'
1624 if self.image_creator and not self.image_creator.image_settings.exists:
1626 self.image_creator.clean()
1627 except Exception as e:
1629 'Unexpected exception cleaning image with message - %s', e)
1631 super(self.__class__, self).__clean__()
1633 def test_dual_ports_dhcp(self):
1635 Tests the creation of an OpenStack instance with a dual ports/NICs with
1637 NOTE: This test and any others that call ansible will most likely fail
1638 unless you do one of two things:
1639 1. Have a ~/.ansible.cfg (or alternate means) to
1640 set host_key_checking = False
1641 2. Set the following environment variable in your executing shell:
1642 ANSIBLE_HOST_KEY_CHECKING=False
1643 Should this not be performed, the creation of the host ssh key will
1644 cause your ansible calls to fail.
1646 # Create ports/NICs for instance
1649 for network_creator in self.network_creators:
1650 ports_settings.append(PortSettings(
1651 name=self.guid + '-port-' + str(ctr),
1652 network_name=network_creator.network_settings.name))
1656 instance_settings = VmInstanceSettings(
1657 name=self.vm_inst_name,
1658 flavor=self.flavor_creator.flavor_settings.name,
1659 port_settings=ports_settings,
1660 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1661 floating_ip_settings=[FloatingIpSettings(
1662 name=self.floating_ip_name, port_name=self.port_1_name,
1663 router_name=self.pub_net_config.router_settings.name)])
1665 self.inst_creator = OpenStackVmInstance(
1666 self.os_creds, instance_settings,
1667 self.image_creator.image_settings,
1668 keypair_settings=self.keypair_creator.keypair_settings)
1670 vm_inst = self.inst_creator.create(block=True)
1672 self.assertEqual(vm_inst.id, self.inst_creator.get_vm_inst().id)
1674 # Effectively blocks until VM has been properly activated
1675 self.assertTrue(self.inst_creator.vm_active(block=True))
1677 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1678 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1680 # Effectively blocks until VM's ssh port has been opened
1681 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1683 self.assertEqual(0, self.inst_creator.config_nics())
1686 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1688 Tests that include, add, and remove security groups from VM instances
1693 Instantiates the CreateImage object that is responsible for downloading
1694 and creating an OS image file within OpenStack
1696 super(self.__class__, self).__start__()
1698 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1699 self.vm_inst_name = self.guid + '-inst'
1700 self.nova = nova_utils.nova_client(self.os_creds)
1701 os_image_settings = openstack_tests.cirros_image_settings(
1702 name=self.guid + '-image', image_metadata=self.image_metadata)
1704 self.vm_inst_name = self.guid + '-inst'
1705 self.port_1_name = self.guid + 'port-1'
1706 self.port_2_name = self.guid + 'port-2'
1707 self.floating_ip_name = self.guid + 'fip1'
1709 net_config = openstack_tests.get_priv_net_config(
1710 net_name=self.guid + '-pub-net',
1711 subnet_name=self.guid + '-pub-subnet',
1712 router_name=self.guid + '-pub-router',
1713 external_net=self.ext_net_name)
1715 # Initialize for tearDown()
1716 self.image_creator = None
1717 self.flavor_creator = None
1718 self.network_creator = None
1719 self.router_creator = None
1720 self.inst_creator = None
1721 self.sec_grp_creators = list()
1725 self.image_creator = OpenStackImage(self.os_creds,
1727 self.image_creator.create()
1730 self.network_creator = OpenStackNetwork(
1731 self.os_creds, net_config.network_settings)
1732 self.network_creator.create()
1735 self.flavor_creator = OpenStackFlavor(
1736 self.admin_os_creds,
1737 FlavorConfig(name=self.guid + '-flavor-name', ram=256,
1739 metadata=self.flavor_metadata))
1740 self.flavor_creator.create()
1742 self.port_settings = PortSettings(
1743 name=self.guid + '-port',
1744 network_name=net_config.network_settings.name)
1745 except Exception as e:
1751 Cleans the created object
1753 if self.inst_creator:
1755 self.inst_creator.clean()
1756 except Exception as e:
1758 'Unexpected exception cleaning VM instance with message -'
1761 for sec_grp_creator in self.sec_grp_creators:
1763 sec_grp_creator.clean()
1764 except Exception as e:
1766 'Unexpected exception cleaning security group with message'
1769 if self.flavor_creator:
1771 self.flavor_creator.clean()
1772 except Exception as e:
1774 'Unexpected exception cleaning flavor with message - %s',
1777 if self.network_creator:
1779 self.network_creator.clean()
1780 except Exception as e:
1782 'Unexpected exception cleaning network with message - %s',
1785 if self.image_creator and not self.image_creator.image_settings.exists:
1787 self.image_creator.clean()
1788 except Exception as e:
1790 'Unexpected exception cleaning image with message - %s', e)
1792 super(self.__class__, self).__clean__()
1794 def test_add_security_group(self):
1796 Tests the addition of a security group created after the instance.
1799 instance_settings = VmInstanceSettings(
1800 name=self.vm_inst_name,
1801 flavor=self.flavor_creator.flavor_settings.name,
1802 port_settings=[self.port_settings])
1803 self.inst_creator = OpenStackVmInstance(
1804 self.os_creds, instance_settings,
1805 self.image_creator.image_settings)
1806 vm_inst = self.inst_creator.create(block=True)
1807 self.assertIsNotNone(vm_inst)
1809 # Create security group object to add to instance
1810 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1811 description='hello group')
1812 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1814 sec_grp = sec_grp_creator.create()
1815 self.sec_grp_creators.append(sec_grp_creator)
1817 # Check that group has not been added
1818 self.assertFalse(inst_has_sec_grp(
1819 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1821 # Add security group to instance after activated
1822 self.inst_creator.add_security_group(sec_grp)
1824 # Validate that security group has been added
1825 self.assertTrue(inst_has_sec_grp(
1826 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1828 def test_add_invalid_security_group(self):
1830 Tests the addition of a security group that no longer exists.
1833 instance_settings = VmInstanceSettings(
1834 name=self.vm_inst_name,
1835 flavor=self.flavor_creator.flavor_settings.name,
1836 port_settings=[self.port_settings])
1837 self.inst_creator = OpenStackVmInstance(
1838 self.os_creds, instance_settings,
1839 self.image_creator.image_settings)
1840 vm_inst = self.inst_creator.create(block=True)
1841 self.assertIsNotNone(vm_inst)
1843 # Create security group object to add to instance
1844 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1845 description='hello group')
1846 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1848 sec_grp = sec_grp_creator.create()
1849 sec_grp_creator.clean()
1850 self.sec_grp_creators.append(sec_grp_creator)
1852 # Check that group has not been added
1853 self.assertFalse(inst_has_sec_grp(
1854 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1856 # Add security group to instance after activated
1857 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1859 # Validate that security group has been added
1860 self.assertFalse(inst_has_sec_grp(
1861 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1863 def test_remove_security_group(self):
1865 Tests the removal of a security group created before and added to the
1868 # Create security group object to add to instance
1869 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1870 description='hello group')
1871 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1873 sec_grp = sec_grp_creator.create()
1874 self.sec_grp_creators.append(sec_grp_creator)
1877 instance_settings = VmInstanceSettings(
1878 name=self.vm_inst_name,
1879 flavor=self.flavor_creator.flavor_settings.name,
1880 security_group_names=[sec_grp_settings.name],
1881 port_settings=[self.port_settings])
1882 self.inst_creator = OpenStackVmInstance(
1883 self.os_creds, instance_settings,
1884 self.image_creator.image_settings)
1885 vm_inst = self.inst_creator.create(block=True)
1886 self.assertIsNotNone(vm_inst)
1888 # Check that group has been added
1889 self.assertTrue(inst_has_sec_grp(
1890 self.nova, vm_inst, sec_grp_settings.name))
1892 # Add security group to instance after activated
1893 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1895 # Validate that security group has been added
1896 self.assertFalse(inst_has_sec_grp(
1897 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1899 def test_remove_security_group_never_added(self):
1901 Tests the removal of a security group that was never added in the first
1904 # Create security group object to add to instance
1905 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1906 description='hello group')
1907 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1909 sec_grp = sec_grp_creator.create()
1910 self.sec_grp_creators.append(sec_grp_creator)
1913 instance_settings = VmInstanceSettings(
1914 name=self.vm_inst_name,
1915 flavor=self.flavor_creator.flavor_settings.name,
1916 port_settings=[self.port_settings])
1917 self.inst_creator = OpenStackVmInstance(
1918 self.os_creds, instance_settings,
1919 self.image_creator.image_settings)
1920 vm_inst = self.inst_creator.create(block=True)
1921 self.assertIsNotNone(vm_inst)
1923 # Check that group has been added
1924 self.assertFalse(inst_has_sec_grp(
1925 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1927 # Add security group to instance after activated
1928 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1930 # Validate that security group has been added
1931 self.assertFalse(inst_has_sec_grp(
1932 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1934 def test_add_same_security_group(self):
1936 Tests the addition of a security group created before add added to the
1939 # Create security group object to add to instance
1940 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1941 description='hello group')
1942 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1944 sec_grp = sec_grp_creator.create()
1945 self.sec_grp_creators.append(sec_grp_creator)
1948 instance_settings = VmInstanceSettings(
1949 name=self.vm_inst_name,
1950 flavor=self.flavor_creator.flavor_settings.name,
1951 security_group_names=[sec_grp_settings.name],
1952 port_settings=[self.port_settings])
1953 self.inst_creator = OpenStackVmInstance(
1954 self.os_creds, instance_settings,
1955 self.image_creator.image_settings)
1956 vm_inst = self.inst_creator.create(block=True)
1957 self.assertIsNotNone(vm_inst)
1959 # Check that group has been added
1960 self.assertTrue(inst_has_sec_grp(
1961 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1963 # Add security group to instance after activated
1964 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1966 # Validate that security group has been added
1967 self.assertTrue(inst_has_sec_grp(
1968 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1971 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1973 Returns true if instance has a security group of a given name
1974 :param nova: the nova client
1975 :param vm_inst: the VmInst domain object
1976 :param sec_grp_name: the name of the security group to validate
1979 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1980 for name in sec_grp_names:
1981 if sec_grp_name == name:
1986 def validate_ssh_client(instance_creator):
1988 Returns True if instance_creator returns an SSH client that is valid
1989 :param instance_creator: the object responsible for creating the VM
1993 ssh_active = instance_creator.vm_ssh_active(block=True)
1996 ssh_client = instance_creator.ssh_client()
1999 out = ssh_client.exec_command('pwd')[1]
2000 channel = out.channel
2001 in_buffer = channel.in_buffer
2002 pwd_out = in_buffer.read(1024)
2003 if not pwd_out or len(pwd_out) < 10:
2014 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
2016 Test for the CreateInstance class for creating an image from a 3-part image
2021 Instantiates the CreateImage object that is responsible for downloading
2022 and creating an OS image file within OpenStack
2024 super(self.__class__, self).__start__()
2026 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2027 self.image_name = guid
2028 self.vm_inst_name = guid + '-inst'
2029 self.nova = nova_utils.nova_client(self.os_creds)
2031 net_config = openstack_tests.get_priv_net_config(
2032 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2033 router_name=guid + '-pub-router', external_net=self.ext_net_name)
2035 # Initialize for tearDown()
2036 self.image_creator = None
2037 self.network_creator = None
2038 self.flavor_creator = None
2039 self.inst_creator = None
2042 if self.image_metadata and 'disk_file' in self.image_metadata:
2043 metadata = self.image_metadata
2044 elif self.image_metadata and 'cirros' in self.image_metadata \
2045 and 'disk_file' in self.image_metadata['cirros']:
2046 metadata = self.image_metadata['cirros']
2049 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
2051 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
2053 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
2055 image_settings = openstack_tests.cirros_image_settings(
2056 name=self.image_name,
2057 image_metadata=metadata)
2059 if not image_settings.ramdisk_image_settings or not \
2060 image_settings.kernel_image_settings:
2062 '3 Part image will not be tested. Image metadata has '
2063 'overridden this functionality')
2065 self.image_creator = OpenStackImage(self.os_creds, image_settings)
2066 self.image_creator.create()
2069 self.flavor_creator = OpenStackFlavor(
2070 self.admin_os_creds,
2071 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
2072 vcpus=2, metadata=self.flavor_metadata))
2073 self.flavor_creator.create()
2076 self.network_creator = OpenStackNetwork(
2077 self.os_creds, net_config.network_settings)
2078 self.network_creator.create()
2080 self.port_settings = PortSettings(
2081 name=guid + '-port',
2082 network_name=net_config.network_settings.name)
2083 except Exception as e:
2089 Cleans the created object
2091 if self.inst_creator:
2093 self.inst_creator.clean()
2094 except Exception as e:
2096 'Unexpected exception cleaning VM instance with message -'
2099 if self.flavor_creator:
2101 self.flavor_creator.clean()
2102 except Exception as e:
2104 'Unexpected exception cleaning flavor with message - %s',
2107 if self.network_creator:
2109 self.network_creator.clean()
2110 except Exception as e:
2112 'Unexpected exception cleaning network with message - %s',
2115 if self.image_creator and not self.image_creator.image_settings.exists:
2117 self.image_creator.clean()
2118 except Exception as e:
2120 'Unexpected exception cleaning image with message - %s', e)
2122 super(self.__class__, self).__clean__()
2124 def test_create_instance_from_three_part_image(self):
2126 Tests the creation of an OpenStack instance from a 3-part image.
2128 instance_settings = VmInstanceSettings(
2129 name=self.vm_inst_name,
2130 flavor=self.flavor_creator.flavor_settings.name,
2131 port_settings=[self.port_settings])
2133 # The last created image is the main image from which we create the
2135 self.inst_creator = OpenStackVmInstance(
2136 self.os_creds, instance_settings,
2137 self.image_creator.image_settings)
2139 vm_inst = self.inst_creator.create()
2140 self.assertIsNotNone(vm_inst)
2141 self.assertTrue(self.inst_creator.vm_active(block=True))
2144 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2146 Tests the custom image_metadata that can be set by clients for handling
2147 images differently than the default behavior of the existing tests
2148 primarily for offline testing
2153 Instantiates the CreateImage object that is responsible for downloading
2154 and creating an OS image file within OpenStack
2156 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2158 self.tmpDir = 'tmp/' + str(self.guid)
2159 if not os.path.exists(self.tmpDir):
2160 os.makedirs(self.tmpDir)
2162 self.image_name = self.guid + '-image'
2163 self.vm_inst_name = self.guid + '-inst'
2164 self.port_1_name = self.guid + 'port-1'
2166 # Initialize for tearDown()
2167 self.image_creator = None
2168 self.network_creator = None
2169 self.flavor_creator = None
2170 self.inst_creator = None
2172 self.priv_net_config = openstack_tests.get_priv_net_config(
2173 net_name=self.guid + '-priv-net',
2174 subnet_name=self.guid + '-priv-subnet')
2175 self.port_settings = PortSettings(
2176 name=self.port_1_name,
2177 network_name=self.priv_net_config.network_settings.name)
2180 # Download image file
2181 self.image_file = file_utils.download(
2182 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2185 self.network_creator = OpenStackNetwork(
2186 self.os_creds, self.priv_net_config.network_settings)
2187 self.network_creator.create()
2190 self.flavor_creator = OpenStackFlavor(
2193 name=self.guid + '-flavor-name', ram=256, disk=10,
2195 self.flavor_creator.create()
2196 except Exception as e:
2202 Cleans the created object
2204 if self.inst_creator:
2206 self.inst_creator.clean()
2207 except Exception as e:
2209 'Unexpected exception cleaning VM instance with message - '
2212 if self.network_creator:
2214 self.network_creator.clean()
2215 except Exception as e:
2217 'Unexpected exception cleaning network with message - %s',
2220 if self.flavor_creator:
2222 self.flavor_creator.clean()
2223 except Exception as e:
2225 'Unexpected exception cleaning flavor with message - %s',
2228 if self.image_creator:
2230 self.image_creator.clean()
2231 except Exception as e:
2233 'Unexpected exception cleaning image with message - %s', e)
2235 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2236 shutil.rmtree(self.tmpDir)
2238 def test_inst_from_file_image_simple_flat(self):
2240 Creates a VM instance from a locally sourced file image using simply
2241 the 'disk_file' attribute vs. using the 'config' option which
2242 completely overrides all image settings
2245 metadata = {'disk_file': self.image_file.name}
2247 os_image_settings = openstack_tests.cirros_image_settings(
2248 name=self.image_name, image_metadata=metadata)
2249 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2250 self.assertEqual(openstack_tests.CIRROS_USER,
2251 os_image_settings.image_user)
2252 self.assertIsNone(os_image_settings.url)
2253 self.assertFalse(os_image_settings.exists)
2254 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2255 os_image_settings.format)
2257 self.assertIsNone(os_image_settings.kernel_image_settings)
2258 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2260 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2261 self.image_creator.create()
2263 instance_settings = VmInstanceSettings(
2264 name=self.vm_inst_name,
2265 flavor=self.flavor_creator.flavor_settings.name,
2266 port_settings=[self.port_settings])
2267 self.inst_creator = OpenStackVmInstance(
2268 self.os_creds, instance_settings,
2269 self.image_creator.image_settings)
2270 self.inst_creator.create()
2272 self.assertTrue(self.inst_creator.vm_active(block=True))
2274 def test_inst_from_file_image_simple_nested(self):
2276 Creates a VM instance from a locally sourced file image using simply
2277 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2278 which completely overrides all image settings
2281 metadata = {'cirros': {'disk_file': self.image_file.name}}
2283 os_image_settings = openstack_tests.cirros_image_settings(
2284 name=self.image_name, image_metadata=metadata)
2285 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2286 self.assertEqual(openstack_tests.CIRROS_USER,
2287 os_image_settings.image_user)
2288 self.assertIsNone(os_image_settings.url)
2289 self.assertFalse(os_image_settings.exists)
2290 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2291 os_image_settings.format)
2293 self.assertIsNone(os_image_settings.kernel_image_settings)
2294 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2296 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2297 self.image_creator.create()
2299 instance_settings = VmInstanceSettings(
2300 name=self.vm_inst_name,
2301 flavor=self.flavor_creator.flavor_settings.name,
2302 port_settings=[self.port_settings])
2303 self.inst_creator = OpenStackVmInstance(
2304 self.os_creds, instance_settings,
2305 self.image_creator.image_settings)
2306 self.inst_creator.create()
2308 self.assertTrue(self.inst_creator.vm_active(block=True))
2310 def test_inst_from_existing(self):
2312 Creates a VM instance from a image creator that has been configured to
2313 use an existing image
2316 os_image_settings = openstack_tests.cirros_image_settings(
2317 name=self.image_name)
2318 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2319 self.image_creator.create()
2321 image_settings = self.image_creator.image_settings
2322 test_image_creator = OpenStackImage(
2325 name=image_settings.name, image_user=image_settings.image_user,
2327 test_image_creator.create()
2328 self.assertEqual(self.image_creator.get_image().id,
2329 test_image_creator.get_image().id)
2331 instance_settings = VmInstanceSettings(
2332 name=self.vm_inst_name,
2333 flavor=self.flavor_creator.flavor_settings.name,
2334 port_settings=[self.port_settings])
2335 self.inst_creator = OpenStackVmInstance(
2336 self.os_creds, instance_settings,
2337 test_image_creator.image_settings)
2338 self.inst_creator.create()
2340 self.assertTrue(self.inst_creator.vm_active(block=True))
2342 def test_inst_from_file_image_complex(self):
2344 Creates a VM instance from a locally sourced file image by overriding
2345 the default settings by using a dict() that can be read in by
2350 os_image_settings = openstack_tests.cirros_image_settings(
2351 name=self.image_name)
2352 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2353 self.image_creator.create()
2358 'name': os_image_settings.name,
2359 'image_user': os_image_settings.image_user,
2361 test_image_settings = openstack_tests.cirros_image_settings(
2362 image_metadata=metadata)
2363 test_image = OpenStackImage(self.os_creds, test_image_settings)
2366 instance_settings = VmInstanceSettings(
2367 name=self.vm_inst_name,
2368 flavor=self.flavor_creator.flavor_settings.name,
2369 port_settings=[self.port_settings])
2370 self.inst_creator = OpenStackVmInstance(self.os_creds,
2372 test_image_settings)
2373 self.inst_creator.create()
2375 self.assertTrue(self.inst_creator.vm_active(block=True))
2377 def test_inst_from_file_3part_image_complex(self):
2379 Creates a VM instance from a locally sourced file image by overriding
2380 the default settings by using a dict() that can be read in by
2385 kernel_file = file_utils.download(
2386 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2387 ramdisk_file = file_utils.download(
2388 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2393 'name': self.image_name,
2394 'image_user': openstack_tests.CIRROS_USER,
2395 'image_file': self.image_file.name,
2396 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2397 'kernel_image_settings': {
2398 'name': self.image_name + '-kernel',
2399 'image_user': openstack_tests.CIRROS_USER,
2400 'image_file': kernel_file.name,
2401 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2402 'ramdisk_image_settings': {
2403 'name': self.image_name + '-ramdisk',
2404 'image_user': openstack_tests.CIRROS_USER,
2405 'image_file': ramdisk_file.name,
2406 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2408 os_image_settings = openstack_tests.cirros_image_settings(
2409 name=self.image_name, image_metadata=metadata)
2410 self.assertEqual(self.image_name, os_image_settings.name)
2411 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2412 self.assertEqual(openstack_tests.CIRROS_USER,
2413 os_image_settings.image_user)
2414 self.assertIsNone(os_image_settings.url)
2415 self.assertFalse(os_image_settings.exists)
2416 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2417 os_image_settings.format)
2419 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2420 self.assertEqual(self.image_name + '-kernel',
2421 os_image_settings.kernel_image_settings.name)
2422 self.assertEqual(kernel_file.name,
2423 os_image_settings.kernel_image_settings.image_file)
2424 self.assertEqual(openstack_tests.CIRROS_USER,
2425 os_image_settings.kernel_image_settings.image_user)
2426 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2427 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2428 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2429 os_image_settings.kernel_image_settings.format)
2431 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2432 self.assertEqual(self.image_name + '-ramdisk',
2433 os_image_settings.ramdisk_image_settings.name)
2434 self.assertEqual(ramdisk_file.name,
2435 os_image_settings.ramdisk_image_settings.image_file)
2436 self.assertEqual(openstack_tests.CIRROS_USER,
2437 os_image_settings.ramdisk_image_settings.image_user)
2438 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2439 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2440 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2441 os_image_settings.ramdisk_image_settings.format)
2443 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2444 self.image_creator.create()
2446 instance_settings = VmInstanceSettings(
2447 name=self.vm_inst_name,
2448 flavor=self.flavor_creator.flavor_settings.name,
2449 port_settings=[self.port_settings])
2450 self.inst_creator = OpenStackVmInstance(
2451 self.os_creds, instance_settings,
2452 self.image_creator.image_settings)
2453 self.inst_creator.create()
2455 self.assertTrue(self.inst_creator.vm_active(block=True))
2457 def test_inst_from_file_3part_image_simple_flat(self):
2459 Creates a VM instance from a 3-part image locally sourced from file
2460 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2461 attributes vs. using the 'config' option which completely overrides all
2465 kernel_file = file_utils.download(
2466 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2467 ramdisk_file = file_utils.download(
2468 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2470 metadata = {'disk_file': self.image_file.name,
2471 'kernel_file': kernel_file.name,
2472 'ramdisk_file': ramdisk_file.name}
2474 os_image_settings = openstack_tests.cirros_image_settings(
2475 name=self.image_name, image_metadata=metadata)
2477 self.assertEqual(self.image_name, os_image_settings.name)
2478 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2479 self.assertEqual(openstack_tests.CIRROS_USER,
2480 os_image_settings.image_user)
2481 self.assertIsNone(os_image_settings.url)
2482 self.assertFalse(os_image_settings.exists)
2483 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2484 os_image_settings.format)
2486 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2487 self.assertEqual(self.image_name + '-kernel',
2488 os_image_settings.kernel_image_settings.name)
2489 self.assertEqual(kernel_file.name,
2490 os_image_settings.kernel_image_settings.image_file)
2491 self.assertEqual(openstack_tests.CIRROS_USER,
2492 os_image_settings.kernel_image_settings.image_user)
2493 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2494 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2495 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2496 os_image_settings.kernel_image_settings.format)
2498 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2499 self.assertEqual(self.image_name + '-ramdisk',
2500 os_image_settings.ramdisk_image_settings.name)
2501 self.assertEqual(ramdisk_file.name,
2502 os_image_settings.ramdisk_image_settings.image_file)
2503 self.assertEqual(openstack_tests.CIRROS_USER,
2504 os_image_settings.ramdisk_image_settings.image_user)
2505 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2506 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2507 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2508 os_image_settings.ramdisk_image_settings.format)
2510 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2511 self.image_creator.create()
2513 self.assertIsNotNone(self.image_creator.get_kernel_image())
2514 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2516 instance_settings = VmInstanceSettings(
2517 name=self.vm_inst_name,
2518 flavor=self.flavor_creator.flavor_settings.name,
2519 port_settings=[self.port_settings])
2520 self.inst_creator = OpenStackVmInstance(
2521 self.os_creds, instance_settings,
2522 self.image_creator.image_settings)
2523 self.inst_creator.create()
2525 self.assertTrue(self.inst_creator.vm_active(block=True))
2527 def test_inst_from_file_3part_image_simple_nested(self):
2529 Creates a VM instance from a 3-part image locally sourced from file
2530 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2531 attributes under 'cirros' vs. using the 'config' option which
2532 completely overrides all image settings
2535 kernel_file = file_utils.download(
2536 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2537 ramdisk_file = file_utils.download(
2538 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2540 metadata = {'cirros': {'disk_file': self.image_file.name,
2541 'kernel_file': kernel_file.name,
2542 'ramdisk_file': ramdisk_file.name}}
2544 os_image_settings = openstack_tests.cirros_image_settings(
2545 name=self.image_name, image_metadata=metadata)
2547 self.assertEqual(self.image_name, os_image_settings.name)
2548 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2549 self.assertEqual(openstack_tests.CIRROS_USER,
2550 os_image_settings.image_user)
2551 self.assertIsNone(os_image_settings.url)
2552 self.assertFalse(os_image_settings.exists)
2553 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2554 os_image_settings.format)
2556 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2557 self.assertEqual(self.image_name + '-kernel',
2558 os_image_settings.kernel_image_settings.name)
2559 self.assertEqual(kernel_file.name,
2560 os_image_settings.kernel_image_settings.image_file)
2561 self.assertEqual(openstack_tests.CIRROS_USER,
2562 os_image_settings.kernel_image_settings.image_user)
2563 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2564 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2565 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2566 os_image_settings.kernel_image_settings.format)
2568 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2569 self.assertEqual(self.image_name + '-ramdisk',
2570 os_image_settings.ramdisk_image_settings.name)
2571 self.assertEqual(ramdisk_file.name,
2572 os_image_settings.ramdisk_image_settings.image_file)
2573 self.assertEqual(openstack_tests.CIRROS_USER,
2574 os_image_settings.ramdisk_image_settings.image_user)
2575 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2576 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2577 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2578 os_image_settings.ramdisk_image_settings.format)
2580 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2581 self.image_creator.create()
2583 self.assertIsNotNone(self.image_creator.get_kernel_image())
2584 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2586 instance_settings = VmInstanceSettings(
2587 name=self.vm_inst_name,
2588 flavor=self.flavor_creator.flavor_settings.name,
2589 port_settings=[self.port_settings])
2590 self.inst_creator = OpenStackVmInstance(
2591 self.os_creds, instance_settings,
2592 self.image_creator.image_settings)
2593 self.inst_creator.create()
2595 self.assertTrue(self.inst_creator.vm_active(block=True))
2597 def test_inst_from_file_3part_image_existing(self):
2599 Creates a VM instance from a 3-part image that is existing
2602 kernel_file = file_utils.download(
2603 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2604 ramdisk_file = file_utils.download(
2605 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2607 metadata = {'cirros': {'disk_file': self.image_file.name,
2608 'kernel_file': kernel_file.name,
2609 'ramdisk_file': ramdisk_file.name}}
2611 os_image_settings = openstack_tests.cirros_image_settings(
2612 name=self.image_name, image_metadata=metadata)
2613 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2614 self.image_creator.create()
2616 image_settings = self.image_creator.image_settings
2617 test_image_creator = OpenStackImage(
2620 name=image_settings.name, image_user=image_settings.image_user,
2622 test_image_creator.create()
2623 self.assertEqual(self.image_creator.get_image().id,
2624 test_image_creator.get_image().id)
2626 instance_settings = VmInstanceSettings(
2627 name=self.vm_inst_name,
2628 flavor=self.flavor_creator.flavor_settings.name,
2629 port_settings=[self.port_settings])
2630 self.inst_creator = OpenStackVmInstance(
2631 self.os_creds, instance_settings,
2632 test_image_creator.image_settings)
2633 self.inst_creator.create()
2635 self.assertTrue(self.inst_creator.vm_active(block=True))
2638 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2640 Tests the ability of two VMs to communicate when attached to separate
2641 private networks that are tied together with a router.
2646 Instantiates the CreateImage object that is responsible for downloading
2647 and creating an OS image file within OpenStack
2649 super(self.__class__, self).__start__()
2651 cidr1 = '10.200.201.0/24'
2652 cidr2 = '10.200.202.0/24'
2653 static_gateway_ip1 = '10.200.201.1'
2654 static_gateway_ip2 = '10.200.202.1'
2655 self.ip1 = '10.200.201.5'
2656 self.ip2 = '10.200.202.5'
2658 self.nova = nova_utils.nova_client(self.os_creds)
2660 # Initialize for tearDown()
2661 self.image_creator = None
2662 self.network_creators = list()
2663 self.router_creator = None
2664 self.flavor_creator = None
2665 self.sec_grp_creator = None
2666 self.inst_creators = list()
2668 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2669 self.vm_inst1_name = self.guid + '-inst1'
2670 self.vm_inst2_name = self.guid + '-inst2'
2671 self.port_1_name = self.guid + '-vm1-port'
2672 self.port_2_name = self.guid + '-vm2-port'
2673 self.net_config_1 = NetworkSettings(
2674 name=self.guid + '-net1',
2676 create_network.SubnetSettings(
2677 cidr=cidr1, name=self.guid + '-subnet1',
2678 gateway_ip=static_gateway_ip1)])
2679 self.net_config_2 = NetworkSettings(
2680 name=self.guid + '-net2',
2682 create_network.SubnetSettings(
2683 cidr=cidr2, name=self.guid + '-subnet2',
2684 gateway_ip=static_gateway_ip2)])
2686 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2687 os_image_settings = openstack_tests.cirros_image_settings(
2688 name=image_name, image_metadata=self.image_metadata)
2692 self.image_creator = OpenStackImage(self.os_creds,
2694 self.image_creator.create()
2696 # First network is public
2697 self.network_creators.append(OpenStackNetwork(
2698 self.os_creds, self.net_config_1))
2699 # Second network is private
2700 self.network_creators.append(OpenStackNetwork(
2701 self.os_creds, self.net_config_2))
2702 for network_creator in self.network_creators:
2703 network_creator.create()
2706 create_network.PortSettings(
2707 name=self.guid + '-router-port1',
2710 self.net_config_1.subnet_settings[0].name,
2711 'ip': static_gateway_ip1
2713 network_name=self.net_config_1.name,
2714 project_name=self.os_creds.project_name),
2715 create_network.PortSettings(
2716 name=self.guid + '-router-port2',
2719 self.net_config_2.subnet_settings[0].name,
2720 'ip': static_gateway_ip2
2722 network_name=self.net_config_2.name,
2723 project_name=self.os_creds.project_name)]
2725 router_settings = RouterConfig(
2726 name=self.guid + '-pub-router', port_settings=port_settings)
2727 self.router_creator = create_router.OpenStackRouter(
2728 self.os_creds, router_settings)
2729 self.router_creator.create()
2732 self.flavor_creator = OpenStackFlavor(
2733 self.admin_os_creds,
2734 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
2736 metadata=self.flavor_metadata))
2737 self.flavor_creator.create()
2739 sec_grp_name = self.guid + '-sec-grp'
2740 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
2741 direction=Direction.ingress,
2742 protocol=Protocol.icmp)
2743 self.sec_grp_creator = OpenStackSecurityGroup(
2745 SecurityGroupSettings(name=sec_grp_name,
2746 rule_settings=[rule1]))
2747 self.sec_grp_creator.create()
2754 Cleans the created objects
2756 for inst_creator in self.inst_creators:
2758 inst_creator.clean()
2759 except Exception as e:
2761 'Unexpected exception cleaning VM instance with message '
2764 if self.flavor_creator:
2766 self.flavor_creator.clean()
2767 except Exception as e:
2769 'Unexpected exception cleaning flavor with message - %s',
2772 if self.router_creator:
2774 self.router_creator.clean()
2775 except Exception as e:
2777 'Unexpected exception cleaning router with message - %s',
2780 for network_creator in self.network_creators:
2782 network_creator.clean()
2783 except Exception as e:
2785 'Unexpected exception cleaning network with message - %s',
2788 if self.sec_grp_creator:
2790 self.sec_grp_creator.clean()
2791 except Exception as e:
2793 'Unexpected exception cleaning security group with message'
2796 if self.image_creator and not self.image_creator.image_settings.exists:
2798 self.image_creator.clean()
2799 except Exception as e:
2801 'Unexpected exception cleaning image with message - %s', e)
2803 super(self.__class__, self).__clean__()
2805 def test_ping_via_router(self):
2807 Tests the creation of two OpenStack instances with one port on
2808 different private networks wit a router in between to ensure that they
2812 # Create ports/NICs for instance
2815 for network_creator in self.network_creators:
2816 ports_settings.append(PortSettings(
2817 name=self.guid + '-port-' + str(ctr),
2818 network_name=network_creator.network_settings.name))
2821 # Configure instances
2822 instance1_settings = VmInstanceSettings(
2823 name=self.vm_inst1_name,
2824 flavor=self.flavor_creator.flavor_settings.name,
2825 userdata=_get_ping_userdata(self.ip2),
2826 port_settings=[PortSettings(
2827 name=self.port_1_name,
2830 self.net_config_1.subnet_settings[0].name,
2833 network_name=self.network_creators[0].network_settings.name)])
2834 instance2_settings = VmInstanceSettings(
2835 name=self.vm_inst2_name,
2836 flavor=self.flavor_creator.flavor_settings.name,
2837 userdata=_get_ping_userdata(self.ip1),
2838 port_settings=[PortSettings(
2839 name=self.port_2_name,
2842 self.net_config_2.subnet_settings[0].name,
2845 network_name=self.network_creators[1].network_settings.name)])
2848 self.inst_creators.append(OpenStackVmInstance(
2849 self.os_creds, instance1_settings,
2850 self.image_creator.image_settings))
2851 self.inst_creators.append(OpenStackVmInstance(
2852 self.os_creds, instance2_settings,
2853 self.image_creator.image_settings))
2855 for inst_creator in self.inst_creators:
2856 inst_creator.create(block=True)
2858 # Check for DHCP lease
2859 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2860 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2862 # Effectively blocks until VM has been properly activated
2863 self.assertTrue(check_ping(self.inst_creators[0]))
2864 self.assertTrue(check_ping(self.inst_creators[1]))
2867 class CreateInstanceVolumeTests(OSIntegrationTestCase):
2869 Simple instance creation with an attached volume
2874 Instantiates the CreateImage object that is responsible for downloading
2875 and creating an OS image file
2878 super(self.__class__, self).__start__()
2880 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2881 self.vm_inst_name = guid + '-inst'
2882 self.nova = nova_utils.nova_client(self.os_creds)
2883 os_image_settings = openstack_tests.cirros_image_settings(
2884 name=guid + '-image', image_metadata=self.image_metadata)
2886 net_config = openstack_tests.get_priv_net_config(
2887 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2888 router_name=guid + '-pub-router', external_net=self.ext_net_name)
2890 self.volume_settings1 = VolumeConfig(
2891 name=self.__class__.__name__ + '-' + str(guid) + '-1')
2892 self.volume_settings2 = VolumeConfig(
2893 name=self.__class__.__name__ + '-' + str(guid) + '-2')
2895 # Initialize for tearDown()
2896 self.image_creator = None
2897 self.flavor_creator = None
2899 self.network_creator = None
2900 self.inst_creator = None
2901 self.volume_creator1 = None
2902 self.volume_creator2 = None
2906 self.image_creator = OpenStackImage(self.os_creds,
2908 self.image_creator.create()
2911 self.flavor_creator = OpenStackFlavor(
2912 self.admin_os_creds,
2913 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
2914 vcpus=2, metadata=self.flavor_metadata))
2915 self.flavor_creator.create()
2918 self.network_creator = OpenStackNetwork(
2919 self.os_creds, net_config.network_settings)
2920 self.network_creator.create()
2922 self.port_settings = PortSettings(
2923 name=guid + '-port',
2924 network_name=net_config.network_settings.name)
2926 self.volume_creator1 = OpenStackVolume(
2927 self.os_creds, self.volume_settings1)
2928 self.volume_creator1.create(block=True)
2930 self.volume_creator2 = OpenStackVolume(
2931 self.os_creds, self.volume_settings2)
2932 self.volume_creator2.create(block=True)
2934 except Exception as e:
2940 Cleans the created object
2942 if self.inst_creator:
2944 self.inst_creator.clean()
2945 except Exception as e:
2947 'Unexpected exception cleaning VM instance with message '
2950 if self.flavor_creator:
2952 self.flavor_creator.clean()
2953 except Exception as e:
2955 'Unexpected exception cleaning flavor with message - %s',
2958 if self.network_creator:
2960 self.network_creator.clean()
2961 except Exception as e:
2963 'Unexpected exception cleaning network with message - %s',
2966 if self.volume_creator2:
2968 self.volume_creator2.clean()
2969 except Exception as e:
2971 'Unexpected exception cleaning volume with message - %s',
2974 if self.volume_creator1:
2976 self.volume_creator1.clean()
2977 except Exception as e:
2979 'Unexpected exception cleaning volume with message - %s',
2982 if self.image_creator and not self.image_creator.image_settings.exists:
2984 self.image_creator.clean()
2985 except Exception as e:
2987 'Unexpected exception cleaning image with message - %s', e)
2989 super(self.__class__, self).__clean__()
2991 def test_create_instance_with_one_volume(self):
2993 Tests the creation of an OpenStack instance with a single volume.
2995 instance_settings = VmInstanceSettings(
2996 name=self.vm_inst_name,
2997 flavor=self.flavor_creator.flavor_settings.name,
2998 port_settings=[self.port_settings],
2999 volume_names=[self.volume_settings1.name])
3001 self.inst_creator = OpenStackVmInstance(
3002 self.os_creds, instance_settings,
3003 self.image_creator.image_settings)
3005 vm_inst = self.inst_creator.create(block=True)
3006 self.assertIsNotNone(nova_utils.get_server(
3007 self.nova, vm_inst_settings=instance_settings))
3009 self.assertIsNotNone(vm_inst)
3010 self.assertEqual(1, len(vm_inst.volume_ids))
3011 self.assertEqual(self.volume_creator1.get_volume().id,
3012 vm_inst.volume_ids[0]['id'])
3014 def test_create_instance_with_two_volumes(self):
3016 Tests the creation of an OpenStack instance with a single volume.
3018 instance_settings = VmInstanceSettings(
3019 name=self.vm_inst_name,
3020 flavor=self.flavor_creator.flavor_settings.name,
3021 port_settings=[self.port_settings],
3022 volume_names=[self.volume_settings1.name,
3023 self.volume_settings2.name])
3025 self.inst_creator = OpenStackVmInstance(
3026 self.os_creds, instance_settings,
3027 self.image_creator.image_settings)
3029 vm_inst = self.inst_creator.create(block=True)
3030 self.assertIsNotNone(nova_utils.get_server(
3031 self.nova, vm_inst_settings=instance_settings))
3033 self.assertIsNotNone(vm_inst)
3034 self.assertEqual(2, len(vm_inst.volume_ids))
3035 self.assertEqual(self.volume_creator1.get_volume().id,
3036 vm_inst.volume_ids[0]['id'])
3037 self.assertEqual(self.volume_creator2.get_volume().id,
3038 vm_inst.volume_ids[1]['id'])
3041 def check_dhcp_lease(inst_creator, ip, timeout=160):
3043 Returns true if the expected DHCP lease has been acquired
3044 :param inst_creator: the SNAPS OpenStackVmInstance object
3045 :param ip: the IP address to look for
3046 :param timeout: how long to query for IP address
3050 start_time = time.time()
3052 logger.info("Looking for IP %s in the console log" % ip)
3054 while timeout > time.time() - start_time:
3055 output = inst_creator.get_console_output()
3056 full_log = full_log + output
3057 if re.search(ip, output):
3058 logger.info('DHCP lease obtained logged in console')
3063 logger.error('Full console output -\n' + full_log)
3065 logger.debug('Full console output -\n' + full_log)
3070 def _get_ping_userdata(test_ip):
3072 Returns the post VM creation script to be added into the VM's userdata
3073 :param test_ip: the IP value to substitute into the script
3074 :return: the bash script contents
3077 return ("#!/bin/sh\n\n"
3079 " ping -c 1 %s 2>&1 >/dev/null\n"
3081 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3082 " echo 'vPing OK'\n"
3085 " echo 'vPing KO'\n"
3092 def check_ping(vm_creator, timeout=160):
3094 Check for VM for ping result
3098 while tries < timeout:
3100 p_console = vm_creator.get_console_output()
3101 if "vPing OK" in p_console:
3103 elif "failed to read iid from metadata" in p_console or tries > 5: