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.flavor import FlavorConfig
28 from snaps.config.image import ImageConfig
29 from snaps.config.keypair import KeypairConfig
30 from snaps.config.network import PortConfig, NetworkConfig, SubnetConfig
31 from snaps.config.router import RouterConfig
32 from snaps.config.security_group import (
33 Protocol, SecurityGroupRuleConfig, Direction, SecurityGroupConfig)
34 from snaps.config.vm_inst import (
35 VmInstanceConfig, FloatingIpConfig, VmInstanceConfigError,
36 FloatingIpConfigError)
37 from snaps.config.volume import VolumeConfig
38 from snaps.openstack import create_network, create_router, create_instance
39 from snaps.openstack.create_flavor import OpenStackFlavor
40 from snaps.openstack.create_image import OpenStackImage
41 from snaps.openstack.create_instance import (
42 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)
43 from snaps.openstack.create_keypairs import OpenStackKeypair
44 from snaps.openstack.create_network import OpenStackNetwork
45 from snaps.openstack.create_router import OpenStackRouter
46 from snaps.openstack.create_security_group import OpenStackSecurityGroup
47 from snaps.openstack.create_volume import OpenStackVolume
48 from snaps.openstack.tests import openstack_tests, validation_utils
49 from snaps.openstack.tests.os_source_file_test import (
50 OSIntegrationTestCase, OSComponentTestCase)
51 from snaps.openstack.utils import nova_utils
52 from snaps.openstack.utils.nova_utils import RebootType
53 from snaps.openstack.utils import nova_utils, settings_utils, neutron_utils
55 __author__ = 'spisarski'
59 logger = logging.getLogger('create_instance_tests')
62 class VmInstanceSettingsUnitTests(unittest.TestCase):
64 Tests the construction of the VmInstanceSettings class
67 def test_no_params(self):
68 with self.assertRaises(VmInstanceConfigError):
71 def test_empty_config(self):
72 with self.assertRaises(VmInstanceConfigError):
73 VmInstanceSettings(config=dict())
75 def test_name_only(self):
76 with self.assertRaises(VmInstanceConfigError):
77 VmInstanceSettings(name='foo')
79 def test_config_with_name_only(self):
80 with self.assertRaises(VmInstanceConfigError):
81 VmInstanceSettings(config={'name': 'foo'})
83 def test_name_flavor_only(self):
84 with self.assertRaises(VmInstanceConfigError):
85 VmInstanceSettings(name='foo', flavor='bar')
87 def test_config_with_name_flavor_only(self):
88 with self.assertRaises(VmInstanceConfigError):
89 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
91 def test_name_flavor_port_only(self):
92 port_settings = PortConfig(name='foo-port', network_name='bar-net')
93 settings = VmInstanceSettings(name='foo', flavor='bar',
94 port_settings=[port_settings])
95 self.assertEqual('foo', settings.name)
96 self.assertEqual('bar', settings.flavor)
97 self.assertEqual(1, len(settings.port_settings))
98 self.assertEqual('foo-port', settings.port_settings[0].name)
99 self.assertEqual('bar-net', settings.port_settings[0].network_name)
100 self.assertEqual(0, len(settings.security_group_names))
101 self.assertEqual(0, len(settings.floating_ip_settings))
102 self.assertIsNone(settings.sudo_user)
103 self.assertEqual(900, settings.vm_boot_timeout)
104 self.assertEqual(300, settings.vm_delete_timeout)
105 self.assertEqual(180, settings.ssh_connect_timeout)
106 self.assertIsNone(settings.availability_zone)
107 self.assertIsNone(settings.volume_names)
109 def test_config_with_name_flavor_port_only(self):
110 port_settings = PortConfig(name='foo-port', network_name='bar-net')
111 settings = VmInstanceSettings(
112 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
113 self.assertEqual('foo', settings.name)
114 self.assertEqual('bar', settings.flavor)
115 self.assertEqual(1, len(settings.port_settings))
116 self.assertEqual('foo-port', settings.port_settings[0].name)
117 self.assertEqual('bar-net', settings.port_settings[0].network_name)
118 self.assertEqual(0, len(settings.security_group_names))
119 self.assertEqual(0, len(settings.floating_ip_settings))
120 self.assertIsNone(settings.sudo_user)
121 self.assertEqual(900, settings.vm_boot_timeout)
122 self.assertEqual(300, settings.vm_delete_timeout)
123 self.assertEqual(180, settings.ssh_connect_timeout)
124 self.assertIsNone(settings.availability_zone)
125 self.assertIsNone(settings.volume_names)
128 port_settings = PortConfig(name='foo-port', network_name='bar-net')
129 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
130 router_name='foo-bar-router')
132 settings = VmInstanceSettings(
133 name='foo', flavor='bar', port_settings=[port_settings],
134 security_group_names=['sec_grp_1'],
135 floating_ip_settings=[fip_settings], sudo_user='joe',
136 vm_boot_timeout=999, vm_delete_timeout=333,
137 ssh_connect_timeout=111, availability_zone='server name',
138 volume_names=['vol1'])
139 self.assertEqual('foo', settings.name)
140 self.assertEqual('bar', settings.flavor)
141 self.assertEqual(1, len(settings.port_settings))
142 self.assertEqual('foo-port', settings.port_settings[0].name)
143 self.assertEqual('bar-net', settings.port_settings[0].network_name)
144 self.assertEqual(1, len(settings.security_group_names))
145 self.assertEqual('sec_grp_1', settings.security_group_names[0])
146 self.assertEqual(1, len(settings.floating_ip_settings))
147 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
148 self.assertEqual('bar-port',
149 settings.floating_ip_settings[0].port_name)
150 self.assertEqual('foo-bar-router',
151 settings.floating_ip_settings[0].router_name)
152 self.assertEqual('joe', settings.sudo_user)
153 self.assertEqual(999, settings.vm_boot_timeout)
154 self.assertEqual(333, settings.vm_delete_timeout)
155 self.assertEqual(111, settings.ssh_connect_timeout)
156 self.assertEqual('server name', settings.availability_zone)
157 self.assertEqual('vol1', settings.volume_names[0])
159 def test_config_all(self):
160 port_settings = PortConfig(name='foo-port', network_name='bar-net')
161 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
162 router_name='foo-bar-router')
164 settings = VmInstanceSettings(
165 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
166 'security_group_names': ['sec_grp_1'],
167 'floating_ips': [fip_settings], 'sudo_user': 'joe',
168 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
169 'ssh_connect_timeout': 111, 'availability_zone': 'server name',
170 'volume_names': ['vol2']})
171 self.assertEqual('foo', settings.name)
172 self.assertEqual('bar', settings.flavor)
173 self.assertEqual(1, len(settings.port_settings))
174 self.assertEqual('foo-port', settings.port_settings[0].name)
175 self.assertEqual('bar-net', settings.port_settings[0].network_name)
176 self.assertEqual(1, len(settings.security_group_names))
177 self.assertEqual(1, len(settings.floating_ip_settings))
178 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
179 self.assertEqual('bar-port',
180 settings.floating_ip_settings[0].port_name)
181 self.assertEqual('foo-bar-router',
182 settings.floating_ip_settings[0].router_name)
183 self.assertEqual('joe', settings.sudo_user)
184 self.assertEqual(999, settings.vm_boot_timeout)
185 self.assertEqual(333, settings.vm_delete_timeout)
186 self.assertEqual(111, settings.ssh_connect_timeout)
187 self.assertEqual('server name', settings.availability_zone)
188 self.assertEqual('vol2', settings.volume_names[0])
191 class FloatingIpSettingsUnitTests(unittest.TestCase):
193 Tests the construction of the FloatingIpSettings class
196 def test_no_params(self):
197 with self.assertRaises(FloatingIpConfigError):
200 def test_empty_config(self):
201 with self.assertRaises(FloatingIpConfigError):
202 FloatingIpSettings(**dict())
204 def test_name_only(self):
205 with self.assertRaises(FloatingIpConfigError):
206 FloatingIpSettings(name='foo')
208 def test_config_with_name_only(self):
209 with self.assertRaises(FloatingIpConfigError):
210 FloatingIpSettings(**{'name': 'foo'})
212 def test_name_port_only(self):
213 with self.assertRaises(FloatingIpConfigError):
214 FloatingIpSettings(name='foo', port_name='bar')
216 def test_config_with_name_port_only(self):
217 with self.assertRaises(FloatingIpConfigError):
218 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
220 def test_name_router_only(self):
221 with self.assertRaises(FloatingIpConfigError):
222 FloatingIpSettings(name='foo', router_name='bar')
224 def test_config_with_name_router_only(self):
225 with self.assertRaises(FloatingIpConfigError):
226 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
228 def test_name_port_router_name_only(self):
229 settings = FloatingIpSettings(name='foo', port_name='foo-port',
230 router_name='bar-router')
231 self.assertEqual('foo', settings.name)
232 self.assertEqual('foo-port', settings.port_name)
233 self.assertIsNone(settings.port_id)
234 self.assertEqual('bar-router', settings.router_name)
235 self.assertIsNone(settings.subnet_name)
236 self.assertTrue(settings.provisioning)
238 def test_name_port_router_id_only(self):
239 settings = FloatingIpSettings(name='foo', port_id='foo-port',
240 router_name='bar-router')
241 self.assertEqual('foo', settings.name)
242 self.assertEqual('foo-port', settings.port_id)
243 self.assertIsNone(settings.port_name)
244 self.assertEqual('bar-router', settings.router_name)
245 self.assertIsNone(settings.subnet_name)
246 self.assertTrue(settings.provisioning)
248 def test_config_with_name_port_router_only(self):
249 settings = FloatingIpSettings(
250 **{'name': 'foo', 'port_name': 'foo-port',
251 'router_name': 'bar-router'})
252 self.assertEqual('foo', settings.name)
253 self.assertEqual('foo-port', settings.port_name)
254 self.assertIsNone(settings.port_id)
255 self.assertEqual('bar-router', settings.router_name)
256 self.assertIsNone(settings.subnet_name)
257 self.assertTrue(settings.provisioning)
260 settings = FloatingIpSettings(name='foo', port_name='foo-port',
261 router_name='bar-router',
262 subnet_name='bar-subnet',
264 self.assertEqual('foo', settings.name)
265 self.assertEqual('foo-port', settings.port_name)
266 self.assertIsNone(settings.port_id)
267 self.assertEqual('bar-router', settings.router_name)
268 self.assertEqual('bar-subnet', settings.subnet_name)
269 self.assertFalse(settings.provisioning)
271 def test_config_all(self):
272 settings = FloatingIpSettings(
273 **{'name': 'foo', 'port_name': 'foo-port',
274 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
275 'provisioning': False})
276 self.assertEqual('foo', settings.name)
277 self.assertEqual('foo-port', settings.port_name)
278 self.assertIsNone(settings.port_id)
279 self.assertEqual('bar-router', settings.router_name)
280 self.assertEqual('bar-subnet', settings.subnet_name)
281 self.assertFalse(settings.provisioning)
284 class SimpleHealthCheck(OSIntegrationTestCase):
286 Test for the CreateInstance class with a single NIC/Port with Floating IPs
291 Instantiates the CreateImage object that is responsible for downloading
292 and creating an OS image file
295 super(self.__class__, self).__start__()
297 self.nova = nova_utils.nova_client(self.os_creds)
298 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
299 self.vm_inst_name = guid + '-inst'
300 self.port_1_name = guid + 'port-1'
302 # Initialize for tearDown()
303 self.image_creator = None
304 self.network_creator = None
305 self.flavor_creator = None
306 self.inst_creator = None
308 self.priv_net_config = openstack_tests.get_priv_net_config(
309 net_name=guid + '-priv-net',
310 subnet_name=guid + '-priv-subnet',
311 netconf_override=self.netconf_override)
312 self.port_settings = PortConfig(
313 name=self.port_1_name,
314 network_name=self.priv_net_config.network_settings.name)
317 # Set the default image settings, then set any custom parameters sent
319 os_image_settings = openstack_tests.cirros_image_settings(
320 name=guid + '-image', image_metadata=self.image_metadata)
323 self.image_creator = OpenStackImage(self.os_creds,
325 self.image_creator.create()
328 self.network_creator = OpenStackNetwork(
329 self.os_creds, self.priv_net_config.network_settings)
330 self.network_creator.create()
333 self.flavor_ram = 256
334 if (self.flavor_metadata and
335 self.flavor_metadata.get('hw:mem_page_size') == 'large'):
336 self.flavor_ram = 1024
337 self.flavor_creator = OpenStackFlavor(
339 FlavorConfig(name=guid + '-flavor-name', ram=self.flavor_ram,
340 disk=10, vcpus=1, metadata=self.flavor_metadata))
341 self.flavor_creator.create()
342 except Exception as e:
348 Cleans the created object
350 if self.inst_creator:
352 self.inst_creator.clean()
353 except Exception as e:
355 'Unexpected exception cleaning VM instance with message'
358 if self.network_creator:
360 self.network_creator.clean()
361 except Exception as e:
363 'Unexpected exception cleaning network with message - %s',
366 if self.flavor_creator:
368 self.flavor_creator.clean()
369 except Exception as e:
371 'Unexpected exception cleaning flavor with message - %s',
374 if self.image_creator and not self.image_creator.image_settings.exists:
376 self.image_creator.clean()
377 except Exception as e:
379 'Unexpected exception cleaning image with message - %s',
382 super(self.__class__, self).__clean__()
384 def test_check_vm_ip_dhcp(self):
386 Tests the creation of an OpenStack instance with a single port and
387 ensures that it's assigned IP address is the actual.
389 instance_settings = VmInstanceConfig(
390 name=self.vm_inst_name,
391 flavor=self.flavor_creator.flavor_settings.name,
392 port_settings=[self.port_settings])
394 self.inst_creator = OpenStackVmInstance(
395 self.os_creds, instance_settings,
396 self.image_creator.image_settings)
397 self.inst_creator.create()
399 ip = self.inst_creator.get_port_ip(self.port_settings.name)
400 self.assertIsNotNone(ip)
402 self.assertTrue(self.inst_creator.vm_active(block=True))
404 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
407 class CreateInstanceSimpleTests(OSIntegrationTestCase):
409 Simple instance creation tests without any other objects
414 Instantiates the CreateImage object that is responsible for downloading
415 and creating an OS image file
418 super(self.__class__, self).__start__()
420 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
421 self.vm_inst_name = guid + '-inst'
422 self.nova = nova_utils.nova_client(self.os_creds)
423 self.neutron = neutron_utils.neutron_client(self.os_creds)
424 os_image_settings = openstack_tests.cirros_image_settings(
425 name=guid + '-image', image_metadata=self.image_metadata)
427 net_config = openstack_tests.get_priv_net_config(
428 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
429 router_name=guid + '-pub-router', external_net=self.ext_net_name,
430 netconf_override=self.netconf_override)
432 # Initialize for tearDown()
433 self.image_creator = None
434 self.flavor_creator = None
436 self.network_creator = None
437 self.inst_creator = None
441 self.image_creator = OpenStackImage(self.os_creds,
443 self.image_creator.create()
446 self.flavor_creator = OpenStackFlavor(
448 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
449 vcpus=2, metadata=self.flavor_metadata))
450 self.flavor_creator.create()
453 self.network_creator = OpenStackNetwork(
454 self.os_creds, net_config.network_settings)
455 self.network_creator.create()
457 self.port_settings = PortConfig(
459 network_name=net_config.network_settings.name)
461 except Exception as e:
467 Cleans the created object
469 if self.inst_creator:
471 self.inst_creator.clean()
472 except Exception as e:
474 'Unexpected exception cleaning VM instance with message '
477 if self.flavor_creator:
479 self.flavor_creator.clean()
480 except Exception as e:
482 'Unexpected exception cleaning flavor with message - %s',
485 if self.network_creator:
487 self.network_creator.clean()
488 except Exception as e:
490 'Unexpected exception cleaning network with message - %s',
493 if self.image_creator and not self.image_creator.image_settings.exists:
495 self.image_creator.clean()
496 except Exception as e:
498 'Unexpected exception cleaning image with message - %s', e)
500 super(self.__class__, self).__clean__()
502 def test_create_delete_instance(self):
504 Tests the creation of an OpenStack instance with a single port with a
505 static IP without a Floating IP.
507 instance_settings = VmInstanceConfig(
508 name=self.vm_inst_name,
509 flavor=self.flavor_creator.flavor_settings.name,
510 port_settings=[self.port_settings])
512 self.inst_creator = OpenStackVmInstance(
513 self.os_creds, instance_settings,
514 self.image_creator.image_settings)
516 vm_inst = self.inst_creator.create()
517 self.assertIsNotNone(nova_utils.get_server(
518 self.nova, self.neutron, vm_inst_settings=instance_settings))
521 nova_utils.delete_vm_instance(self.nova, vm_inst)
523 self.assertTrue(self.inst_creator.vm_deleted(block=True))
524 self.assertIsNone(nova_utils.get_server(
525 self.nova, self.neutron, vm_inst_settings=instance_settings))
527 # Exception should not be thrown
528 self.inst_creator.clean()
531 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
533 Test for the CreateInstance class with a single NIC/Port with Floating IPs
538 Instantiates the CreateImage object that is responsible for downloading
539 and creating an OS image file within OpenStack
541 super(self.__class__, self).__start__()
543 self.nova = nova_utils.nova_client(self.os_creds)
544 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
545 self.keypair_priv_filepath = 'tmp/' + guid
546 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
547 self.keypair_name = guid + '-kp'
548 self.vm_inst_name = guid + '-inst'
549 self.port_1_name = guid + 'port-1'
550 self.port_2_name = guid + 'port-2'
551 self.floating_ip_name = guid + 'fip1'
553 # Initialize for tearDown()
554 self.image_creator = None
555 self.network_creator = None
556 self.router_creator = None
557 self.flavor_creator = None
558 self.keypair_creator = None
559 self.sec_grp_creator = None
560 self.inst_creators = list()
562 self.pub_net_config = openstack_tests.get_pub_net_config(
563 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
564 router_name=guid + '-pub-router', external_net=self.ext_net_name,
565 netconf_override=self.netconf_override)
566 os_image_settings = openstack_tests.cirros_image_settings(
567 name=guid + '-image', image_metadata=self.image_metadata)
570 self.image_creator = OpenStackImage(self.os_creds,
572 self.image_creator.create()
575 self.network_creator = OpenStackNetwork(
576 self.os_creds, self.pub_net_config.network_settings)
577 self.network_creator.create()
580 self.router_creator = OpenStackRouter(
581 self.os_creds, self.pub_net_config.router_settings)
582 self.router_creator.create()
585 self.flavor_creator = OpenStackFlavor(
587 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
588 vcpus=2, metadata=self.flavor_metadata))
589 self.flavor_creator.create()
591 self.keypair_creator = OpenStackKeypair(
592 self.os_creds, KeypairConfig(
593 name=self.keypair_name,
594 public_filepath=self.keypair_pub_filepath,
595 private_filepath=self.keypair_priv_filepath))
596 self.keypair_creator.create()
598 sec_grp_name = guid + '-sec-grp'
599 rule1 = SecurityGroupRuleConfig(
600 sec_grp_name=sec_grp_name, direction=Direction.ingress,
601 protocol=Protocol.icmp)
602 rule2 = SecurityGroupRuleConfig(
603 sec_grp_name=sec_grp_name, direction=Direction.ingress,
604 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
605 self.sec_grp_creator = OpenStackSecurityGroup(
608 name=sec_grp_name, rule_settings=[rule1, rule2]))
609 self.sec_grp_creator.create()
610 except Exception as e:
616 Cleans the created object
618 for inst_creator in self.inst_creators:
621 except Exception as e:
623 'Unexpected exception cleaning VM instance with message '
626 if self.keypair_creator:
628 self.keypair_creator.clean()
629 except Exception as e:
631 'Unexpected exception cleaning keypair with message - %s',
634 if self.flavor_creator:
636 self.flavor_creator.clean()
637 except Exception as e:
639 'Unexpected exception cleaning flavor with message - %s',
642 if self.sec_grp_creator:
644 self.sec_grp_creator.clean()
645 except Exception as e:
647 'Unexpected exception cleaning security group with message'
650 if self.router_creator:
652 self.router_creator.clean()
653 except Exception as e:
655 'Unexpected exception cleaning router with message - %s',
658 if self.network_creator:
660 self.network_creator.clean()
661 except Exception as e:
663 'Unexpected exception cleaning network with message - %s',
666 if self.image_creator and not self.image_creator.image_settings.exists:
668 self.image_creator.clean()
669 except Exception as e:
671 'Unexpected exception cleaning image with message - %s', e)
673 super(self.__class__, self).__clean__()
675 def test_single_port_static(self):
677 Tests the creation of an OpenStack instance with a single port with a
678 static IP without a Floating IP.
681 sub_settings = self.pub_net_config.network_settings.subnet_settings
682 port_settings = PortConfig(
683 name=self.port_1_name,
684 network_name=self.pub_net_config.network_settings.name,
686 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
688 instance_settings = VmInstanceConfig(
689 name=self.vm_inst_name,
690 flavor=self.flavor_creator.flavor_settings.name,
691 port_settings=[port_settings],
692 floating_ip_settings=[FloatingIpConfig(
693 name=self.floating_ip_name, port_name=self.port_1_name,
694 router_name=self.pub_net_config.router_settings.name)])
696 inst_creator = OpenStackVmInstance(
697 self.os_creds, instance_settings,
698 self.image_creator.image_settings,
699 keypair_settings=self.keypair_creator.keypair_settings)
700 self.inst_creators.append(inst_creator)
701 vm_inst = inst_creator.create(block=True)
703 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
704 self.assertTrue(inst_creator.vm_active(block=True))
705 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
707 def test_ssh_client_fip_before_active(self):
709 Tests the ability to access a VM via SSH and a floating IP when it has
710 been assigned prior to being active.
712 port_settings = PortConfig(
713 name=self.port_1_name,
714 network_name=self.pub_net_config.network_settings.name)
716 instance_settings = VmInstanceConfig(
717 name=self.vm_inst_name,
718 flavor=self.flavor_creator.flavor_settings.name,
719 port_settings=[port_settings],
720 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
721 floating_ip_settings=[FloatingIpConfig(
722 name=self.floating_ip_name, port_name=self.port_1_name,
723 router_name=self.pub_net_config.router_settings.name)])
725 inst_creator = OpenStackVmInstance(
726 self.os_creds, instance_settings,
727 self.image_creator.image_settings,
728 keypair_settings=self.keypair_creator.keypair_settings)
729 self.inst_creators.append(inst_creator)
730 vm_inst = inst_creator.create()
731 self.assertIsNotNone(vm_inst)
733 self.assertTrue(inst_creator.vm_active(block=True))
735 ip = inst_creator.get_port_ip(port_settings.name)
736 self.assertTrue(check_dhcp_lease(inst_creator, ip))
738 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
740 self.assertTrue(validate_ssh_client(inst_creator))
742 def test_ssh_client_fip_after_active(self):
744 Tests the ability to access a VM via SSH and a floating IP when it has
745 been assigned prior to being active.
747 port_settings = PortConfig(
748 name=self.port_1_name,
749 network_name=self.pub_net_config.network_settings.name)
751 instance_settings = VmInstanceConfig(
752 name=self.vm_inst_name,
753 flavor=self.flavor_creator.flavor_settings.name,
754 port_settings=[port_settings],
755 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
756 floating_ip_settings=[FloatingIpConfig(
757 name=self.floating_ip_name, port_name=self.port_1_name,
758 router_name=self.pub_net_config.router_settings.name)])
760 inst_creator = OpenStackVmInstance(
761 self.os_creds, instance_settings,
762 self.image_creator.image_settings,
763 keypair_settings=self.keypair_creator.keypair_settings)
764 self.inst_creators.append(inst_creator)
766 # block=True will force the create() method to block until the
767 vm_inst = inst_creator.create(block=True)
768 self.assertIsNotNone(vm_inst)
770 self.assertTrue(inst_creator.vm_active(block=True))
772 ip = inst_creator.get_port_ip(port_settings.name)
773 self.assertTrue(check_dhcp_lease(inst_creator, ip))
775 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
777 self.assertTrue(validate_ssh_client(inst_creator))
779 def test_ssh_client_fip_after_reboot(self):
781 Tests the ability to access a VM via SSH and a floating IP after it has
784 port_settings = PortConfig(
785 name=self.port_1_name,
786 network_name=self.pub_net_config.network_settings.name)
788 instance_settings = VmInstanceConfig(
789 name=self.vm_inst_name,
790 flavor=self.flavor_creator.flavor_settings.name,
791 port_settings=[port_settings],
792 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
793 floating_ip_settings=[FloatingIpConfig(
794 name=self.floating_ip_name, port_name=self.port_1_name,
795 router_name=self.pub_net_config.router_settings.name)])
797 inst_creator = OpenStackVmInstance(
798 self.os_creds, instance_settings,
799 self.image_creator.image_settings,
800 keypair_settings=self.keypair_creator.keypair_settings)
801 self.inst_creators.append(inst_creator)
803 # block=True will force the create() method to block until the
804 vm_inst = inst_creator.create(block=True)
805 self.assertIsNotNone(vm_inst)
807 self.assertTrue(inst_creator.vm_active(block=True))
809 ip = inst_creator.get_port_ip(port_settings.name)
810 self.assertTrue(check_dhcp_lease(inst_creator, ip))
812 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
814 self.assertTrue(validate_ssh_client(inst_creator))
816 # Test default reboot which should be 'SOFT'
817 inst_creator.reboot()
818 # Lag time to allow for shutdown routine to take effect
820 self.assertTrue(check_dhcp_lease(inst_creator, ip))
821 self.assertTrue(validate_ssh_client(inst_creator))
824 inst_creator.reboot(reboot_type=RebootType.soft)
826 self.assertTrue(check_dhcp_lease(inst_creator, ip))
827 self.assertTrue(validate_ssh_client(inst_creator))
830 inst_creator.reboot(reboot_type=RebootType.hard)
832 self.assertTrue(check_dhcp_lease(inst_creator, ip))
833 self.assertTrue(validate_ssh_client(inst_creator))
835 def test_ssh_client_fip_after_init(self):
837 Tests the ability to assign a floating IP to an already initialized
838 OpenStackVmInstance object. After the floating IP has been allocated
839 and assigned, this test will ensure that it can be accessed via SSH.
841 port_settings = PortConfig(
842 name=self.port_1_name,
843 network_name=self.pub_net_config.network_settings.name)
845 instance_settings = VmInstanceConfig(
846 name=self.vm_inst_name,
847 flavor=self.flavor_creator.flavor_settings.name,
848 port_settings=[port_settings],
849 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
851 inst_creator = OpenStackVmInstance(
852 self.os_creds, instance_settings,
853 self.image_creator.image_settings,
854 keypair_settings=self.keypair_creator.keypair_settings)
855 self.inst_creators.append(inst_creator)
857 # block=True will force the create() method to block until the
858 vm_inst = inst_creator.create(block=True)
859 self.assertIsNotNone(vm_inst)
861 self.assertTrue(inst_creator.vm_active(block=True))
862 ip = inst_creator.get_port_ip(port_settings.name)
863 self.assertTrue(check_dhcp_lease(inst_creator, ip))
864 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
866 inst_creator.add_floating_ip(FloatingIpConfig(
867 name=self.floating_ip_name, port_name=self.port_1_name,
868 router_name=self.pub_net_config.router_settings.name))
870 self.assertTrue(validate_ssh_client(inst_creator))
872 def test_ssh_client_fip_reverse_engineer(self):
874 Tests the ability to assign a floating IP to a reverse engineered
875 OpenStackVmInstance object. After the floating IP has been allocated
876 and assigned, this test will ensure that it can be accessed via SSH.
878 port_settings = PortConfig(
879 name=self.port_1_name,
880 network_name=self.pub_net_config.network_settings.name)
882 instance_settings = VmInstanceConfig(
883 name=self.vm_inst_name,
884 flavor=self.flavor_creator.flavor_settings.name,
885 port_settings=[port_settings],
886 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
888 inst_creator = OpenStackVmInstance(
889 self.os_creds, instance_settings,
890 self.image_creator.image_settings,
891 keypair_settings=self.keypair_creator.keypair_settings)
892 self.inst_creators.append(inst_creator)
894 # block=True will force the create() method to block until the
895 vm_inst = inst_creator.create(block=True)
896 self.assertIsNotNone(vm_inst)
898 self.assertTrue(inst_creator.vm_active(block=True))
900 derived_inst_creator = create_instance.generate_creator(
901 self.os_creds, vm_inst, self.image_creator.image_settings,
902 self.keypair_creator.keypair_settings)
904 derived_inst_creator.add_floating_ip(FloatingIpConfig(
905 name=self.floating_ip_name, port_name=self.port_1_name,
906 router_name=self.pub_net_config.router_settings.name))
907 self.inst_creators.append(derived_inst_creator)
909 self.assertTrue(validate_ssh_client(
910 derived_inst_creator, fip_name=self.floating_ip_name))
912 def test_ssh_client_fip_second_creator(self):
914 Tests the ability to access a VM via SSH and a floating IP via a
915 creator that is identical to the original creator.
917 port_settings = PortConfig(
918 name=self.port_1_name,
919 network_name=self.pub_net_config.network_settings.name)
921 instance_settings = VmInstanceConfig(
922 name=self.vm_inst_name,
923 flavor=self.flavor_creator.flavor_settings.name,
924 port_settings=[port_settings],
925 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
926 floating_ip_settings=[FloatingIpConfig(
927 name=self.floating_ip_name, port_name=self.port_1_name,
928 router_name=self.pub_net_config.router_settings.name)])
930 inst_creator = OpenStackVmInstance(
931 self.os_creds, instance_settings,
932 self.image_creator.image_settings,
933 keypair_settings=self.keypair_creator.keypair_settings)
934 self.inst_creators.append(inst_creator)
936 # block=True will force the create() method to block until the
937 vm_inst = inst_creator.create(block=True)
938 self.assertIsNotNone(vm_inst)
940 self.assertTrue(inst_creator.vm_active(block=True))
942 ip = inst_creator.get_port_ip(port_settings.name)
943 self.assertTrue(check_dhcp_lease(inst_creator, ip))
945 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
947 self.assertTrue(validate_ssh_client(inst_creator))
949 inst_creator2 = OpenStackVmInstance(
950 self.os_creds, instance_settings,
951 self.image_creator.image_settings,
952 keypair_settings=self.keypair_creator.keypair_settings)
953 inst_creator2.create()
954 self.assertTrue(validate_ssh_client(inst_creator2))
957 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
959 Test for the CreateInstance class with a single NIC/Port with Floating IPs
964 Instantiates the CreateImage object that is responsible for downloading
965 and creating an OS image file within OpenStack
967 super(self.__class__, self).__start__()
969 self.nova = nova_utils.nova_client(self.os_creds)
970 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
971 self.keypair_priv_filepath = 'tmp/' + self.guid
972 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
973 self.keypair_name = self.guid + '-kp'
974 self.vm_inst_name = self.guid + '-inst'
975 self.port1_name = self.guid + 'port1'
976 self.port2_name = self.guid + 'port2'
978 # Initialize for tearDown()
979 self.image_creator = None
980 self.network_creator = None
981 self.router_creator = None
982 self.flavor_creator = None
983 self.keypair_creator = None
984 self.sec_grp_creator = None
985 self.inst_creator = None
987 os_image_settings = openstack_tests.cirros_image_settings(
988 name=self.guid + '-image', image_metadata=self.image_metadata)
990 self.image_creator = OpenStackImage(
991 self.os_creds, os_image_settings)
992 self.image_creator.create()
994 self.flavor_creator = OpenStackFlavor(
997 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
998 metadata=self.flavor_metadata))
999 self.flavor_creator.create()
1001 self.keypair_creator = OpenStackKeypair(
1002 self.os_creds, KeypairConfig(
1003 name=self.keypair_name,
1004 public_filepath=self.keypair_pub_filepath,
1005 private_filepath=self.keypair_priv_filepath))
1006 self.keypair_creator.create()
1008 sec_grp_name = self.guid + '-sec-grp'
1009 rule1 = SecurityGroupRuleConfig(
1010 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1011 protocol=Protocol.icmp)
1012 rule2 = SecurityGroupRuleConfig(
1013 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1014 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
1015 self.sec_grp_creator = OpenStackSecurityGroup(
1017 SecurityGroupConfig(
1018 name=sec_grp_name, rule_settings=[rule1, rule2]))
1019 self.sec_grp_creator.create()
1020 except Exception as e:
1026 Cleans the created object
1028 if self.inst_creator:
1030 self.inst_creator.clean()
1031 except Exception as e:
1033 'Unexpected exception cleaning VM instance with message '
1036 if self.keypair_creator:
1038 self.keypair_creator.clean()
1039 except Exception as e:
1041 'Unexpected exception cleaning keypair with message - %s',
1044 if self.flavor_creator:
1046 self.flavor_creator.clean()
1047 except Exception as e:
1049 'Unexpected exception cleaning flavor with message - %s',
1052 if self.sec_grp_creator:
1054 self.sec_grp_creator.clean()
1055 except Exception as e:
1057 'Unexpected exception cleaning security group with message'
1060 if self.router_creator:
1062 self.router_creator.clean()
1063 except Exception as e:
1065 'Unexpected exception cleaning router with message - %s',
1068 if self.network_creator:
1070 self.network_creator.clean()
1071 except Exception as e:
1073 'Unexpected exception cleaning network with message - %s',
1076 if self.image_creator and not self.image_creator.image_settings.exists:
1078 self.image_creator.clean()
1079 except Exception as e:
1081 'Unexpected exception cleaning image with message - %s', e)
1083 super(self.__class__, self).__clean__()
1085 def test_v4fip_v6overlay(self):
1087 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1088 network when the external network does not have an IPv6 subnet.
1090 subnet_settings = SubnetConfig(
1091 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
1093 network_settings = NetworkConfig(
1094 name=self.guid + '-net', subnet_settings=[subnet_settings])
1095 router_settings = RouterConfig(
1096 name=self.guid + '-router', external_gateway=self.ext_net_name,
1097 internal_subnets=[subnet_settings.name])
1100 self.network_creator = OpenStackNetwork(
1101 self.os_creds, network_settings)
1102 self.network_creator.create()
1105 self.router_creator = OpenStackRouter(
1106 self.os_creds, router_settings)
1107 self.router_creator.create()
1109 port_settings = PortConfig(
1110 name=self.port1_name, network_name=network_settings.name)
1112 instance_settings = VmInstanceConfig(
1113 name=self.vm_inst_name,
1114 flavor=self.flavor_creator.flavor_settings.name,
1115 port_settings=[port_settings],
1116 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1117 floating_ip_settings=[FloatingIpConfig(
1118 name='fip1', port_name=self.port1_name,
1119 router_name=router_settings.name)])
1121 self.inst_creator = OpenStackVmInstance(
1122 self.os_creds, instance_settings,
1123 self.image_creator.image_settings,
1124 keypair_settings=self.keypair_creator.keypair_settings)
1126 with self.assertRaises(BadRequest):
1127 self.inst_creator.create(block=True)
1129 def test_fip_v4and6_overlay(self):
1131 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1132 network when the external network does not have an IPv6 subnet.
1134 subnet4_settings = SubnetConfig(
1135 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
1137 subnet6_settings = SubnetConfig(
1138 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
1140 network_settings = NetworkConfig(
1141 name=self.guid + '-net',
1142 subnet_settings=[subnet4_settings, subnet6_settings])
1143 router_settings = RouterConfig(
1144 name=self.guid + '-router', external_gateway=self.ext_net_name,
1145 internal_subnets=[subnet4_settings.name])
1148 self.network_creator = OpenStackNetwork(
1149 self.os_creds, network_settings)
1150 self.network_creator.create()
1153 self.router_creator = OpenStackRouter(
1154 self.os_creds, router_settings)
1155 self.router_creator.create()
1157 port_settings = PortConfig(
1158 name=self.port1_name, network_name=network_settings.name)
1160 instance_settings = VmInstanceConfig(
1161 name=self.vm_inst_name,
1162 flavor=self.flavor_creator.flavor_settings.name,
1163 port_settings=[port_settings],
1164 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1165 floating_ip_settings=[FloatingIpConfig(
1166 name='fip1', port_name=self.port1_name,
1167 router_name=router_settings.name)])
1169 self.inst_creator = OpenStackVmInstance(
1170 self.os_creds, instance_settings,
1171 self.image_creator.image_settings,
1172 keypair_settings=self.keypair_creator.keypair_settings)
1174 self.inst_creator.create(block=True)
1175 ssh_client = self.inst_creator.ssh_client()
1176 self.assertIsNotNone(ssh_client)
1179 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1181 Test for the CreateInstance class with a single NIC/Port where mac and IP
1182 values are manually set
1187 Instantiates the CreateImage object that is responsible for downloading
1188 and creating an OS image file within OpenStack
1190 super(self.__class__, self).__start__()
1192 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1193 self.vm_inst_name = guid + '-inst'
1194 self.port_1_name = guid + 'port-1'
1195 self.port_2_name = guid + 'port-2'
1196 self.floating_ip_name = guid + 'fip1'
1198 # Initialize for tearDown()
1199 self.image_creator = None
1200 self.network_creator = None
1201 self.flavor_creator = None
1202 self.inst_creator = None
1204 self.net_config = openstack_tests.get_priv_net_config(
1205 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1206 router_name=guid + '-pub-router', external_net=self.ext_net_name,
1207 netconf_override=self.netconf_override)
1208 os_image_settings = openstack_tests.cirros_image_settings(
1209 name=guid + '-image', image_metadata=self.image_metadata)
1213 self.image_creator = OpenStackImage(self.os_creds,
1215 self.image_creator.create()
1218 self.network_creator = OpenStackNetwork(
1219 self.os_creds, self.net_config.network_settings)
1220 self.network_creator.create()
1223 self.flavor_creator = OpenStackFlavor(
1224 self.admin_os_creds,
1225 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1226 vcpus=2, metadata=self.flavor_metadata))
1227 self.flavor_creator.create()
1228 except Exception as e:
1234 Cleans the created object
1236 if self.inst_creator:
1238 self.inst_creator.clean()
1239 except Exception as e:
1241 'Unexpected exception cleaning VM instance with message '
1244 if self.flavor_creator:
1246 self.flavor_creator.clean()
1247 except Exception as e:
1249 'Unexpected exception cleaning flavor with message - %s',
1252 if self.network_creator:
1254 self.network_creator.clean()
1255 except Exception as e:
1257 'Unexpected exception cleaning network with message - %s',
1260 if self.image_creator and not self.image_creator.image_settings.exists:
1262 self.image_creator.clean()
1263 except Exception as e:
1265 'Unexpected exception cleaning image with message - %s', e)
1267 super(self.__class__, self).__clean__()
1269 def test_set_custom_valid_ip_one_subnet(self):
1271 Tests the creation of an OpenStack instance with a single port with a
1272 static IP on a network with one subnet.
1275 sub_settings = self.net_config.network_settings.subnet_settings
1276 port_settings = PortConfig(
1277 name=self.port_1_name,
1278 network_name=self.net_config.network_settings.name,
1279 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1281 instance_settings = VmInstanceConfig(
1282 name=self.vm_inst_name,
1283 flavor=self.flavor_creator.flavor_settings.name,
1284 port_settings=[port_settings])
1286 self.inst_creator = OpenStackVmInstance(
1287 self.os_creds, instance_settings,
1288 self.image_creator.image_settings)
1289 self.inst_creator.create(block=True)
1291 self.assertEqual(ip, self.inst_creator.get_port_ip(
1293 subnet_name=self.net_config.network_settings.subnet_settings[
1296 def test_set_custom_invalid_ip_one_subnet(self):
1298 Tests the creation of an OpenStack instance with a single port with a
1299 static IP on a network with one subnet.
1302 sub_settings = self.net_config.network_settings.subnet_settings
1303 port_settings = PortConfig(
1304 name=self.port_1_name,
1305 network_name=self.net_config.network_settings.name,
1306 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1308 instance_settings = VmInstanceConfig(
1309 name=self.vm_inst_name,
1310 flavor=self.flavor_creator.flavor_settings.name,
1311 port_settings=[port_settings])
1313 self.inst_creator = OpenStackVmInstance(
1314 self.os_creds, instance_settings,
1315 self.image_creator.image_settings)
1317 with self.assertRaises(InvalidIpForSubnetClient):
1318 self.inst_creator.create()
1320 def test_set_custom_valid_mac(self):
1322 Tests the creation of an OpenStack instance with a single port where
1323 the MAC address is assigned.
1325 mac_addr = '0a:1b:2c:3d:4e:5f'
1326 port_settings = PortConfig(
1327 name=self.port_1_name,
1328 network_name=self.net_config.network_settings.name,
1329 mac_address=mac_addr)
1331 instance_settings = VmInstanceConfig(
1332 name=self.vm_inst_name,
1333 flavor=self.flavor_creator.flavor_settings.name,
1334 port_settings=[port_settings])
1336 self.inst_creator = OpenStackVmInstance(
1337 self.os_creds, instance_settings,
1338 self.image_creator.image_settings)
1339 self.inst_creator.create(block=True)
1341 self.assertEqual(mac_addr,
1342 self.inst_creator.get_port_mac(self.port_1_name))
1344 def test_set_custom_invalid_mac(self):
1346 Tests the creation of an OpenStack instance with a single port where an
1347 invalid MAC address value is being
1348 assigned. This should raise an Exception
1350 port_settings = PortConfig(
1351 name=self.port_1_name,
1352 network_name=self.net_config.network_settings.name,
1355 instance_settings = VmInstanceConfig(
1356 name=self.vm_inst_name,
1357 flavor=self.flavor_creator.flavor_settings.name,
1358 port_settings=[port_settings])
1360 self.inst_creator = OpenStackVmInstance(
1361 self.os_creds, instance_settings,
1362 self.image_creator.image_settings)
1364 with self.assertRaises(Exception):
1365 self.inst_creator.create()
1367 def test_set_custom_mac_and_ip(self):
1369 Tests the creation of an OpenStack instance with a single port where
1370 the IP and MAC address is assigned.
1373 mac_addr = '0a:1b:2c:3d:4e:5f'
1374 sub_settings = self.net_config.network_settings.subnet_settings
1375 port_settings = PortConfig(
1376 name=self.port_1_name,
1377 network_name=self.net_config.network_settings.name,
1378 mac_address=mac_addr,
1379 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1381 instance_settings = VmInstanceConfig(
1382 name=self.vm_inst_name,
1383 flavor=self.flavor_creator.flavor_settings.name,
1384 port_settings=[port_settings])
1386 self.inst_creator = OpenStackVmInstance(
1387 self.os_creds, instance_settings,
1388 self.image_creator.image_settings)
1389 self.inst_creator.create(block=True)
1391 self.assertEqual(ip, self.inst_creator.get_port_ip(
1393 subnet_name=self.net_config.network_settings.subnet_settings[
1395 self.assertEqual(mac_addr,
1396 self.inst_creator.get_port_mac(self.port_1_name))
1398 def test_set_allowed_address_pairs(self):
1400 Tests the creation of an OpenStack instance with a single port where
1401 max_allowed_address_pair is set.
1404 mac_addr = '0a:1b:2c:3d:4e:5f'
1405 pair = {'ip_address': ip, 'mac_address': mac_addr}
1406 port_settings = PortConfig(
1407 name=self.port_1_name,
1408 network_name=self.net_config.network_settings.name,
1409 allowed_address_pairs=[pair])
1411 instance_settings = VmInstanceConfig(
1412 name=self.vm_inst_name,
1413 flavor=self.flavor_creator.flavor_settings.name,
1414 port_settings=[port_settings])
1416 self.inst_creator = OpenStackVmInstance(
1417 self.os_creds, instance_settings,
1418 self.image_creator.image_settings)
1419 self.inst_creator.create(block=True)
1421 port = self.inst_creator.get_port_by_name(port_settings.name)
1422 self.assertIsNotNone(port)
1423 self.assertIsNotNone(port.allowed_address_pairs)
1424 self.assertEqual(1, len(port.allowed_address_pairs))
1425 validation_utils.objects_equivalent(pair,
1426 port.allowed_address_pairs[0])
1428 def test_set_allowed_address_pairs_bad_mac(self):
1430 Tests the creation of an OpenStack instance with a single port where
1431 max_allowed_address_pair is set with an invalid MAC address.
1435 pair = {'ip_address': ip, 'mac_address': mac_addr}
1437 pairs.add((ip, mac_addr))
1438 port_settings = PortConfig(
1439 name=self.port_1_name,
1440 network_name=self.net_config.network_settings.name,
1441 allowed_address_pairs=[pair])
1443 instance_settings = VmInstanceConfig(
1444 name=self.vm_inst_name,
1445 flavor=self.flavor_creator.flavor_settings.name,
1446 port_settings=[port_settings])
1448 self.inst_creator = OpenStackVmInstance(
1449 self.os_creds, instance_settings,
1450 self.image_creator.image_settings)
1451 with self.assertRaises(Exception):
1452 self.inst_creator.create()
1454 def test_set_allowed_address_pairs_bad_ip(self):
1456 Tests the creation of an OpenStack instance with a single port where
1457 max_allowed_address_pair is set with an invalid MAC address.
1460 mac_addr = '0a:1b:2c:3d:4e:5f'
1461 pair = {'ip_address': ip, 'mac_address': mac_addr}
1463 pairs.add((ip, mac_addr))
1464 port_settings = PortConfig(
1465 name=self.port_1_name,
1466 network_name=self.net_config.network_settings.name,
1467 allowed_address_pairs=[pair])
1469 instance_settings = VmInstanceConfig(
1470 name=self.vm_inst_name,
1471 flavor=self.flavor_creator.flavor_settings.name,
1472 port_settings=[port_settings])
1474 self.inst_creator = OpenStackVmInstance(
1475 self.os_creds, instance_settings,
1476 self.image_creator.image_settings)
1477 with self.assertRaises(Exception):
1478 self.inst_creator.create()
1481 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1483 Test for the CreateInstance where one VM is deployed to each compute node
1488 Instantiates the CreateImage object that is responsible for downloading
1489 and creating an OS image file within OpenStack
1491 super(self.__class__, self).__start__()
1493 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1494 self.vm_inst_name = guid + '-inst'
1495 self.port_base_name = guid + 'port'
1497 # Initialize for tearDown()
1498 self.image_creator = None
1499 self.flavor_creator = None
1500 self.network_creator = None
1501 self.inst_creators = list()
1503 self.priv_net_config = openstack_tests.get_priv_net_config(
1504 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet',
1505 netconf_override=self.netconf_override)
1507 os_image_settings = openstack_tests.cirros_image_settings(
1508 name=guid + '-image', image_metadata=self.image_metadata)
1512 self.network_creator = OpenStackNetwork(
1513 self.admin_os_creds, self.priv_net_config.network_settings)
1514 self.network_creator.create()
1517 self.flavor_creator = OpenStackFlavor(
1518 self.admin_os_creds,
1519 FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
1520 vcpus=1, metadata=self.flavor_metadata))
1521 self.flavor_creator.create()
1524 self.image_creator = OpenStackImage(self.os_creds,
1526 self.image_creator.create()
1528 except Exception as e:
1534 Cleans the created object
1536 for inst_creator in self.inst_creators:
1538 inst_creator.clean()
1539 except Exception as e:
1541 'Unexpected exception cleaning VM instance with message '
1544 if self.flavor_creator:
1546 self.flavor_creator.clean()
1547 except Exception as e:
1549 'Unexpected exception cleaning flavor with message - %s',
1552 if self.network_creator:
1554 self.network_creator.clean()
1555 except Exception as e:
1557 'Unexpected exception cleaning network with message - %s',
1560 if self.image_creator and not self.image_creator.image_settings.exists:
1562 self.image_creator.clean()
1563 except Exception as e:
1565 'Unexpected exception cleaning image with message - %s', e)
1567 super(self.__class__, self).__clean__()
1569 def test_deploy_vm_to_each_compute_node(self):
1571 Tests the creation of OpenStack VM instances to each compute node.
1573 from snaps.openstack.utils import nova_utils
1574 nova = nova_utils.nova_client(self.admin_os_creds)
1575 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1577 # Create Instance on each server/zone
1579 for zone in zone_hosts:
1580 inst_name = self.vm_inst_name + '-' + zone
1582 port_settings = PortConfig(
1583 name=self.port_base_name + '-' + str(ctr),
1584 network_name=self.priv_net_config.network_settings.name)
1586 instance_settings = VmInstanceConfig(
1588 flavor=self.flavor_creator.flavor_settings.name,
1589 availability_zone=zone,
1590 port_settings=[port_settings])
1591 inst_creator = OpenStackVmInstance(
1592 self.admin_os_creds, instance_settings,
1593 self.image_creator.image_settings)
1594 self.inst_creators.append(inst_creator)
1595 inst_creator.create()
1597 # Validate instances to ensure they've been deployed to the correct
1600 for zone in zone_hosts:
1601 creator = self.inst_creators[index]
1602 self.assertTrue(creator.vm_active(block=True))
1603 info = creator.get_vm_info()
1604 deployed_zone = info['OS-EXT-AZ:availability_zone']
1605 deployed_host = info['OS-EXT-SRV-ATTR:host']
1606 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1610 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1612 Tests that include, add, and remove security groups from VM instances
1617 Instantiates the CreateImage object that is responsible for downloading
1618 and creating an OS image file within OpenStack
1620 super(self.__class__, self).__start__()
1622 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1623 self.vm_inst_name = self.guid + '-inst'
1624 self.nova = nova_utils.nova_client(self.os_creds)
1625 os_image_settings = openstack_tests.cirros_image_settings(
1626 name=self.guid + '-image', image_metadata=self.image_metadata)
1628 self.vm_inst_name = self.guid + '-inst'
1629 self.port_1_name = self.guid + 'port-1'
1630 self.port_2_name = self.guid + 'port-2'
1631 self.floating_ip_name = self.guid + 'fip1'
1633 net_config = openstack_tests.get_priv_net_config(
1634 net_name=self.guid + '-pub-net',
1635 subnet_name=self.guid + '-pub-subnet',
1636 router_name=self.guid + '-pub-router',
1637 external_net=self.ext_net_name,
1638 netconf_override=self.netconf_override)
1640 # Initialize for tearDown()
1641 self.image_creator = None
1642 self.flavor_creator = None
1643 self.network_creator = None
1644 self.router_creator = None
1645 self.inst_creator = None
1646 self.sec_grp_creators = list()
1650 self.image_creator = OpenStackImage(self.os_creds,
1652 self.image_creator.create()
1655 self.network_creator = OpenStackNetwork(
1656 self.os_creds, net_config.network_settings)
1657 self.network_creator.create()
1660 self.flavor_creator = OpenStackFlavor(
1661 self.admin_os_creds,
1662 FlavorConfig(name=self.guid + '-flavor-name', ram=256,
1664 metadata=self.flavor_metadata))
1665 self.flavor_creator.create()
1667 self.port_settings = PortConfig(
1668 name=self.guid + '-port',
1669 network_name=net_config.network_settings.name)
1670 except Exception as e:
1676 Cleans the created object
1678 if self.inst_creator:
1680 self.inst_creator.clean()
1681 except Exception as e:
1683 'Unexpected exception cleaning VM instance with message -'
1686 for sec_grp_creator in self.sec_grp_creators:
1688 sec_grp_creator.clean()
1689 except Exception as e:
1691 'Unexpected exception cleaning security group with message'
1694 if self.flavor_creator:
1696 self.flavor_creator.clean()
1697 except Exception as e:
1699 'Unexpected exception cleaning flavor with message - %s',
1702 if self.network_creator:
1704 self.network_creator.clean()
1705 except Exception as e:
1707 'Unexpected exception cleaning network with message - %s',
1710 if self.image_creator and not self.image_creator.image_settings.exists:
1712 self.image_creator.clean()
1713 except Exception as e:
1715 'Unexpected exception cleaning image with message - %s', e)
1717 super(self.__class__, self).__clean__()
1719 def test_add_security_group(self):
1721 Tests the addition of a security group created after the instance.
1724 instance_settings = VmInstanceConfig(
1725 name=self.vm_inst_name,
1726 flavor=self.flavor_creator.flavor_settings.name,
1727 port_settings=[self.port_settings])
1728 self.inst_creator = OpenStackVmInstance(
1729 self.os_creds, instance_settings,
1730 self.image_creator.image_settings)
1731 vm_inst = self.inst_creator.create(block=True)
1732 self.assertIsNotNone(vm_inst)
1734 # Create security group object to add to instance
1735 sec_grp_settings = SecurityGroupConfig(
1736 name=self.guid + '-name', description='hello group')
1737 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1739 sec_grp = sec_grp_creator.create()
1740 self.sec_grp_creators.append(sec_grp_creator)
1742 # Check that group has not been added
1743 self.assertFalse(inst_has_sec_grp(
1744 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1746 # Add security group to instance after activated
1747 self.inst_creator.add_security_group(sec_grp)
1749 # Validate that security group has been added
1750 self.assertTrue(inst_has_sec_grp(
1751 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1753 def test_add_invalid_security_group(self):
1755 Tests the addition of a security group that no longer exists.
1758 instance_settings = VmInstanceConfig(
1759 name=self.vm_inst_name,
1760 flavor=self.flavor_creator.flavor_settings.name,
1761 port_settings=[self.port_settings])
1762 self.inst_creator = OpenStackVmInstance(
1763 self.os_creds, instance_settings,
1764 self.image_creator.image_settings)
1765 vm_inst = self.inst_creator.create(block=True)
1766 self.assertIsNotNone(vm_inst)
1768 # Create security group object to add to instance
1769 sec_grp_settings = SecurityGroupConfig(
1770 name=self.guid + '-name', description='hello group')
1771 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1773 sec_grp = sec_grp_creator.create()
1774 sec_grp_creator.clean()
1775 self.sec_grp_creators.append(sec_grp_creator)
1777 # Check that group has not been added
1778 self.assertFalse(inst_has_sec_grp(
1779 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1781 # Add security group to instance after activated
1782 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1784 # Validate that security group has been added
1785 self.assertFalse(inst_has_sec_grp(
1786 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1788 def test_remove_security_group(self):
1790 Tests the removal of a security group created before and added to the
1793 # Create security group object to add to instance
1794 sec_grp_settings = SecurityGroupConfig(
1795 name=self.guid + '-name', description='hello group')
1796 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1798 sec_grp = sec_grp_creator.create()
1799 self.sec_grp_creators.append(sec_grp_creator)
1802 instance_settings = VmInstanceConfig(
1803 name=self.vm_inst_name,
1804 flavor=self.flavor_creator.flavor_settings.name,
1805 security_group_names=[sec_grp_settings.name],
1806 port_settings=[self.port_settings])
1807 self.inst_creator = OpenStackVmInstance(
1808 self.os_creds, instance_settings,
1809 self.image_creator.image_settings)
1810 vm_inst = self.inst_creator.create(block=True)
1811 self.assertIsNotNone(vm_inst)
1813 # Check that group has been added
1814 self.assertTrue(inst_has_sec_grp(
1815 self.nova, vm_inst, sec_grp_settings.name))
1817 # Add security group to instance after activated
1818 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1820 # Validate that security group has been added
1821 self.assertFalse(inst_has_sec_grp(
1822 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1824 def test_remove_security_group_never_added(self):
1826 Tests the removal of a security group that was never added in the first
1829 # Create security group object to add to instance
1830 sec_grp_settings = SecurityGroupConfig(
1831 name=self.guid + '-name', description='hello group')
1832 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1834 sec_grp = sec_grp_creator.create()
1835 self.sec_grp_creators.append(sec_grp_creator)
1838 instance_settings = VmInstanceConfig(
1839 name=self.vm_inst_name,
1840 flavor=self.flavor_creator.flavor_settings.name,
1841 port_settings=[self.port_settings])
1842 self.inst_creator = OpenStackVmInstance(
1843 self.os_creds, instance_settings,
1844 self.image_creator.image_settings)
1845 vm_inst = self.inst_creator.create(block=True)
1846 self.assertIsNotNone(vm_inst)
1848 # Check that group has been added
1849 self.assertFalse(inst_has_sec_grp(
1850 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1852 # Add security group to instance after activated
1853 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1855 # Validate that security group has been added
1856 self.assertFalse(inst_has_sec_grp(
1857 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1859 def test_add_same_security_group(self):
1861 Tests the addition of a security group created before add added to the
1864 # Create security group object to add to instance
1865 sec_grp_settings = SecurityGroupConfig(
1866 name=self.guid + '-name', description='hello group')
1867 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1869 sec_grp = sec_grp_creator.create()
1870 self.sec_grp_creators.append(sec_grp_creator)
1873 instance_settings = VmInstanceConfig(
1874 name=self.vm_inst_name,
1875 flavor=self.flavor_creator.flavor_settings.name,
1876 security_group_names=[sec_grp_settings.name],
1877 port_settings=[self.port_settings])
1878 self.inst_creator = OpenStackVmInstance(
1879 self.os_creds, instance_settings,
1880 self.image_creator.image_settings)
1881 vm_inst = self.inst_creator.create(block=True)
1882 self.assertIsNotNone(vm_inst)
1884 # Check that group has been added
1885 self.assertTrue(inst_has_sec_grp(
1886 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1888 # Add security group to instance after activated
1889 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1891 # Validate that security group has been added
1892 self.assertTrue(inst_has_sec_grp(
1893 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1896 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1898 Returns true if instance has a security group of a given name
1899 :param nova: the nova client
1900 :param vm_inst: the VmInst domain object
1901 :param sec_grp_name: the name of the security group to validate
1904 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1905 for name in sec_grp_names:
1906 if sec_grp_name == name:
1911 def validate_ssh_client(instance_creator, fip_name=None):
1913 Returns True if instance_creator returns an SSH client that is valid
1914 :param instance_creator: the object responsible for creating the VM
1916 :param fip_name: the name of the floating IP to use
1919 ssh_active = instance_creator.vm_ssh_active(block=True)
1922 ssh_client = instance_creator.ssh_client(fip_name=fip_name)
1925 out = ssh_client.exec_command('pwd')[1]
1926 channel = out.channel
1927 in_buffer = channel.in_buffer
1928 pwd_out = in_buffer.read(1024)
1929 if not pwd_out or len(pwd_out) < 10:
1940 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
1942 Test for the CreateInstance class for creating an image from a 3-part image
1947 Instantiates the CreateImage object that is responsible for downloading
1948 and creating an OS image file within OpenStack
1950 super(self.__class__, self).__start__()
1952 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1953 self.image_name = guid
1954 self.vm_inst_name = guid + '-inst'
1955 self.nova = nova_utils.nova_client(self.os_creds)
1957 net_config = openstack_tests.get_priv_net_config(
1958 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1959 router_name=guid + '-pub-router', external_net=self.ext_net_name,
1960 netconf_override=self.netconf_override)
1962 # Initialize for tearDown()
1963 self.image_creator = None
1964 self.network_creator = None
1965 self.flavor_creator = None
1966 self.inst_creator = None
1969 if self.image_metadata and 'disk_file' in self.image_metadata:
1970 metadata = self.image_metadata
1971 elif self.image_metadata and 'cirros' in self.image_metadata \
1972 and 'disk_file' in self.image_metadata['cirros']:
1973 metadata = self.image_metadata['cirros']
1976 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
1978 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
1980 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
1982 image_settings = openstack_tests.cirros_image_settings(
1983 name=self.image_name,
1984 image_metadata=metadata)
1986 if not image_settings.ramdisk_image_settings or not \
1987 image_settings.kernel_image_settings:
1989 '3 Part image will not be tested. Image metadata has '
1990 'overridden this functionality')
1992 self.image_creator = OpenStackImage(self.os_creds, image_settings)
1993 self.image_creator.create()
1996 self.flavor_creator = OpenStackFlavor(
1997 self.admin_os_creds,
1998 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1999 vcpus=2, metadata=self.flavor_metadata))
2000 self.flavor_creator.create()
2003 self.network_creator = OpenStackNetwork(
2004 self.os_creds, net_config.network_settings)
2005 self.network_creator.create()
2007 self.port_settings = PortConfig(
2008 name=guid + '-port',
2009 network_name=net_config.network_settings.name)
2010 except Exception as e:
2016 Cleans the created object
2018 if self.inst_creator:
2020 self.inst_creator.clean()
2021 except Exception as e:
2023 'Unexpected exception cleaning VM instance with message -'
2026 if self.flavor_creator:
2028 self.flavor_creator.clean()
2029 except Exception as e:
2031 'Unexpected exception cleaning flavor with message - %s',
2034 if self.network_creator:
2036 self.network_creator.clean()
2037 except Exception as e:
2039 'Unexpected exception cleaning network with message - %s',
2042 if self.image_creator and not self.image_creator.image_settings.exists:
2044 self.image_creator.clean()
2045 except Exception as e:
2047 'Unexpected exception cleaning image with message - %s', e)
2049 super(self.__class__, self).__clean__()
2051 def test_create_instance_from_three_part_image(self):
2053 Tests the creation of an OpenStack instance from a 3-part image.
2055 instance_settings = VmInstanceConfig(
2056 name=self.vm_inst_name,
2057 flavor=self.flavor_creator.flavor_settings.name,
2058 port_settings=[self.port_settings])
2060 # The last created image is the main image from which we create the
2062 self.inst_creator = OpenStackVmInstance(
2063 self.os_creds, instance_settings,
2064 self.image_creator.image_settings)
2066 vm_inst = self.inst_creator.create()
2067 self.assertIsNotNone(vm_inst)
2068 self.assertTrue(self.inst_creator.vm_active(block=True))
2071 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2073 Tests the custom image_metadata that can be set by clients for handling
2074 images differently than the default behavior of the existing tests
2075 primarily for offline testing
2080 Instantiates the CreateImage object that is responsible for downloading
2081 and creating an OS image file within OpenStack
2083 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2085 self.tmpDir = 'tmp/' + str(self.guid)
2086 if not os.path.exists(self.tmpDir):
2087 os.makedirs(self.tmpDir)
2089 self.image_name = self.guid + '-image'
2090 self.vm_inst_name = self.guid + '-inst'
2091 self.port_1_name = self.guid + 'port-1'
2093 # Initialize for tearDown()
2094 self.image_creator = None
2095 self.network_creator = None
2096 self.flavor_creator = None
2097 self.inst_creator = None
2099 self.priv_net_config = openstack_tests.get_priv_net_config(
2100 net_name=self.guid + '-priv-net',
2101 subnet_name=self.guid + '-priv-subnet')
2102 self.port_settings = PortConfig(
2103 name=self.port_1_name,
2104 network_name=self.priv_net_config.network_settings.name)
2107 # Download image file
2108 self.image_file = file_utils.download(
2109 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2112 self.network_creator = OpenStackNetwork(
2113 self.os_creds, self.priv_net_config.network_settings)
2114 self.network_creator.create()
2117 self.flavor_creator = OpenStackFlavor(
2120 name=self.guid + '-flavor-name', ram=256, disk=10,
2122 self.flavor_creator.create()
2123 except Exception as e:
2129 Cleans the created object
2131 if self.inst_creator:
2133 self.inst_creator.clean()
2134 except Exception as e:
2136 'Unexpected exception cleaning VM instance with message - '
2139 if self.network_creator:
2141 self.network_creator.clean()
2142 except Exception as e:
2144 'Unexpected exception cleaning network with message - %s',
2147 if self.flavor_creator:
2149 self.flavor_creator.clean()
2150 except Exception as e:
2152 'Unexpected exception cleaning flavor with message - %s',
2155 if self.image_creator:
2157 self.image_creator.clean()
2158 except Exception as e:
2160 'Unexpected exception cleaning image with message - %s', e)
2162 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2163 shutil.rmtree(self.tmpDir)
2165 def test_inst_from_file_image_simple_flat(self):
2167 Creates a VM instance from a locally sourced file image using simply
2168 the 'disk_file' attribute vs. using the 'config' option which
2169 completely overrides all image settings
2172 metadata = {'disk_file': self.image_file.name}
2174 os_image_settings = openstack_tests.cirros_image_settings(
2175 name=self.image_name, image_metadata=metadata)
2176 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2177 self.assertEqual(openstack_tests.CIRROS_USER,
2178 os_image_settings.image_user)
2179 self.assertIsNone(os_image_settings.url)
2180 self.assertFalse(os_image_settings.exists)
2181 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2182 os_image_settings.format)
2184 self.assertIsNone(os_image_settings.kernel_image_settings)
2185 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2187 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2188 self.image_creator.create()
2190 instance_settings = VmInstanceConfig(
2191 name=self.vm_inst_name,
2192 flavor=self.flavor_creator.flavor_settings.name,
2193 port_settings=[self.port_settings])
2194 self.inst_creator = OpenStackVmInstance(
2195 self.os_creds, instance_settings,
2196 self.image_creator.image_settings)
2197 self.inst_creator.create()
2199 self.assertTrue(self.inst_creator.vm_active(block=True))
2201 def test_inst_from_file_image_simple_nested(self):
2203 Creates a VM instance from a locally sourced file image using simply
2204 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2205 which completely overrides all image settings
2208 metadata = {'cirros': {'disk_file': self.image_file.name}}
2210 os_image_settings = openstack_tests.cirros_image_settings(
2211 name=self.image_name, image_metadata=metadata)
2212 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2213 self.assertEqual(openstack_tests.CIRROS_USER,
2214 os_image_settings.image_user)
2215 self.assertIsNone(os_image_settings.url)
2216 self.assertFalse(os_image_settings.exists)
2217 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2218 os_image_settings.format)
2220 self.assertIsNone(os_image_settings.kernel_image_settings)
2221 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2223 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2224 self.image_creator.create()
2226 instance_settings = VmInstanceConfig(
2227 name=self.vm_inst_name,
2228 flavor=self.flavor_creator.flavor_settings.name,
2229 port_settings=[self.port_settings])
2230 self.inst_creator = OpenStackVmInstance(
2231 self.os_creds, instance_settings,
2232 self.image_creator.image_settings)
2233 self.inst_creator.create()
2235 self.assertTrue(self.inst_creator.vm_active(block=True))
2237 def test_inst_from_existing(self):
2239 Creates a VM instance from a image creator that has been configured to
2240 use an existing image
2243 os_image_settings = openstack_tests.cirros_image_settings(
2244 name=self.image_name)
2245 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2246 self.image_creator.create()
2248 image_settings = self.image_creator.image_settings
2249 test_image_creator = OpenStackImage(
2252 name=image_settings.name, image_user=image_settings.image_user,
2254 test_image_creator.create()
2255 self.assertEqual(self.image_creator.get_image().id,
2256 test_image_creator.get_image().id)
2258 instance_settings = VmInstanceConfig(
2259 name=self.vm_inst_name,
2260 flavor=self.flavor_creator.flavor_settings.name,
2261 port_settings=[self.port_settings])
2262 self.inst_creator = OpenStackVmInstance(
2263 self.os_creds, instance_settings,
2264 test_image_creator.image_settings)
2265 self.inst_creator.create()
2267 self.assertTrue(self.inst_creator.vm_active(block=True))
2269 def test_inst_from_file_image_complex(self):
2271 Creates a VM instance from a locally sourced file image by overriding
2272 the default settings by using a dict() that can be read in by
2277 os_image_settings = openstack_tests.cirros_image_settings(
2278 name=self.image_name)
2279 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2280 self.image_creator.create()
2285 'name': os_image_settings.name,
2286 'image_user': os_image_settings.image_user,
2288 test_image_settings = openstack_tests.cirros_image_settings(
2289 image_metadata=metadata)
2290 test_image = OpenStackImage(self.os_creds, test_image_settings)
2293 instance_settings = VmInstanceConfig(
2294 name=self.vm_inst_name,
2295 flavor=self.flavor_creator.flavor_settings.name,
2296 port_settings=[self.port_settings])
2297 self.inst_creator = OpenStackVmInstance(self.os_creds,
2299 test_image_settings)
2300 self.inst_creator.create()
2302 self.assertTrue(self.inst_creator.vm_active(block=True))
2304 def test_inst_from_file_3part_image_complex(self):
2306 Creates a VM instance from a locally sourced file image by overriding
2307 the default settings by using a dict() that can be read in by
2312 kernel_file = file_utils.download(
2313 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2314 ramdisk_file = file_utils.download(
2315 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2320 'name': self.image_name,
2321 'image_user': openstack_tests.CIRROS_USER,
2322 'image_file': self.image_file.name,
2323 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2324 'kernel_image_settings': {
2325 'name': self.image_name + '-kernel',
2326 'image_user': openstack_tests.CIRROS_USER,
2327 'image_file': kernel_file.name,
2328 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2329 'ramdisk_image_settings': {
2330 'name': self.image_name + '-ramdisk',
2331 'image_user': openstack_tests.CIRROS_USER,
2332 'image_file': ramdisk_file.name,
2333 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2335 os_image_settings = openstack_tests.cirros_image_settings(
2336 name=self.image_name, image_metadata=metadata)
2337 self.assertEqual(self.image_name, os_image_settings.name)
2338 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2339 self.assertEqual(openstack_tests.CIRROS_USER,
2340 os_image_settings.image_user)
2341 self.assertIsNone(os_image_settings.url)
2342 self.assertFalse(os_image_settings.exists)
2343 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2344 os_image_settings.format)
2346 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2347 self.assertEqual(self.image_name + '-kernel',
2348 os_image_settings.kernel_image_settings.name)
2349 self.assertEqual(kernel_file.name,
2350 os_image_settings.kernel_image_settings.image_file)
2351 self.assertEqual(openstack_tests.CIRROS_USER,
2352 os_image_settings.kernel_image_settings.image_user)
2353 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2354 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2355 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2356 os_image_settings.kernel_image_settings.format)
2358 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2359 self.assertEqual(self.image_name + '-ramdisk',
2360 os_image_settings.ramdisk_image_settings.name)
2361 self.assertEqual(ramdisk_file.name,
2362 os_image_settings.ramdisk_image_settings.image_file)
2363 self.assertEqual(openstack_tests.CIRROS_USER,
2364 os_image_settings.ramdisk_image_settings.image_user)
2365 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2366 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2367 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2368 os_image_settings.ramdisk_image_settings.format)
2370 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2371 self.image_creator.create()
2373 instance_settings = VmInstanceConfig(
2374 name=self.vm_inst_name,
2375 flavor=self.flavor_creator.flavor_settings.name,
2376 port_settings=[self.port_settings])
2377 self.inst_creator = OpenStackVmInstance(
2378 self.os_creds, instance_settings,
2379 self.image_creator.image_settings)
2380 self.inst_creator.create()
2382 self.assertTrue(self.inst_creator.vm_active(block=True))
2384 def test_inst_from_file_3part_image_simple_flat(self):
2386 Creates a VM instance from a 3-part image locally sourced from file
2387 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2388 attributes vs. using the 'config' option which completely overrides all
2392 kernel_file = file_utils.download(
2393 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2394 ramdisk_file = file_utils.download(
2395 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2397 metadata = {'disk_file': self.image_file.name,
2398 'kernel_file': kernel_file.name,
2399 'ramdisk_file': ramdisk_file.name}
2401 os_image_settings = openstack_tests.cirros_image_settings(
2402 name=self.image_name, image_metadata=metadata)
2404 self.assertEqual(self.image_name, os_image_settings.name)
2405 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2406 self.assertEqual(openstack_tests.CIRROS_USER,
2407 os_image_settings.image_user)
2408 self.assertIsNone(os_image_settings.url)
2409 self.assertFalse(os_image_settings.exists)
2410 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2411 os_image_settings.format)
2413 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2414 self.assertEqual(self.image_name + '-kernel',
2415 os_image_settings.kernel_image_settings.name)
2416 self.assertEqual(kernel_file.name,
2417 os_image_settings.kernel_image_settings.image_file)
2418 self.assertEqual(openstack_tests.CIRROS_USER,
2419 os_image_settings.kernel_image_settings.image_user)
2420 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2421 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2422 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2423 os_image_settings.kernel_image_settings.format)
2425 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2426 self.assertEqual(self.image_name + '-ramdisk',
2427 os_image_settings.ramdisk_image_settings.name)
2428 self.assertEqual(ramdisk_file.name,
2429 os_image_settings.ramdisk_image_settings.image_file)
2430 self.assertEqual(openstack_tests.CIRROS_USER,
2431 os_image_settings.ramdisk_image_settings.image_user)
2432 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2433 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2434 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2435 os_image_settings.ramdisk_image_settings.format)
2437 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2438 self.image_creator.create()
2440 self.assertIsNotNone(self.image_creator.get_kernel_image())
2441 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2443 instance_settings = VmInstanceConfig(
2444 name=self.vm_inst_name,
2445 flavor=self.flavor_creator.flavor_settings.name,
2446 port_settings=[self.port_settings])
2447 self.inst_creator = OpenStackVmInstance(
2448 self.os_creds, instance_settings,
2449 self.image_creator.image_settings)
2450 self.inst_creator.create()
2452 self.assertTrue(self.inst_creator.vm_active(block=True))
2454 def test_inst_from_file_3part_image_simple_nested(self):
2456 Creates a VM instance from a 3-part image locally sourced from file
2457 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2458 attributes under 'cirros' vs. using the 'config' option which
2459 completely overrides all image settings
2462 kernel_file = file_utils.download(
2463 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2464 ramdisk_file = file_utils.download(
2465 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2467 metadata = {'cirros': {'disk_file': self.image_file.name,
2468 'kernel_file': kernel_file.name,
2469 'ramdisk_file': ramdisk_file.name}}
2471 os_image_settings = openstack_tests.cirros_image_settings(
2472 name=self.image_name, image_metadata=metadata)
2474 self.assertEqual(self.image_name, os_image_settings.name)
2475 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2476 self.assertEqual(openstack_tests.CIRROS_USER,
2477 os_image_settings.image_user)
2478 self.assertIsNone(os_image_settings.url)
2479 self.assertFalse(os_image_settings.exists)
2480 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2481 os_image_settings.format)
2483 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2484 self.assertEqual(self.image_name + '-kernel',
2485 os_image_settings.kernel_image_settings.name)
2486 self.assertEqual(kernel_file.name,
2487 os_image_settings.kernel_image_settings.image_file)
2488 self.assertEqual(openstack_tests.CIRROS_USER,
2489 os_image_settings.kernel_image_settings.image_user)
2490 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2491 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2492 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2493 os_image_settings.kernel_image_settings.format)
2495 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2496 self.assertEqual(self.image_name + '-ramdisk',
2497 os_image_settings.ramdisk_image_settings.name)
2498 self.assertEqual(ramdisk_file.name,
2499 os_image_settings.ramdisk_image_settings.image_file)
2500 self.assertEqual(openstack_tests.CIRROS_USER,
2501 os_image_settings.ramdisk_image_settings.image_user)
2502 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2503 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2504 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2505 os_image_settings.ramdisk_image_settings.format)
2507 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2508 self.image_creator.create()
2510 self.assertIsNotNone(self.image_creator.get_kernel_image())
2511 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2513 instance_settings = VmInstanceConfig(
2514 name=self.vm_inst_name,
2515 flavor=self.flavor_creator.flavor_settings.name,
2516 port_settings=[self.port_settings])
2517 self.inst_creator = OpenStackVmInstance(
2518 self.os_creds, instance_settings,
2519 self.image_creator.image_settings)
2520 self.inst_creator.create()
2522 self.assertTrue(self.inst_creator.vm_active(block=True))
2524 def test_inst_from_file_3part_image_existing(self):
2526 Creates a VM instance from a 3-part image that is existing
2529 kernel_file = file_utils.download(
2530 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2531 ramdisk_file = file_utils.download(
2532 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2534 metadata = {'cirros': {'disk_file': self.image_file.name,
2535 'kernel_file': kernel_file.name,
2536 'ramdisk_file': ramdisk_file.name}}
2538 os_image_settings = openstack_tests.cirros_image_settings(
2539 name=self.image_name, image_metadata=metadata)
2540 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2541 self.image_creator.create()
2543 image_settings = self.image_creator.image_settings
2544 test_image_creator = OpenStackImage(
2547 name=image_settings.name, image_user=image_settings.image_user,
2549 test_image_creator.create()
2550 self.assertEqual(self.image_creator.get_image().id,
2551 test_image_creator.get_image().id)
2553 instance_settings = VmInstanceConfig(
2554 name=self.vm_inst_name,
2555 flavor=self.flavor_creator.flavor_settings.name,
2556 port_settings=[self.port_settings])
2557 self.inst_creator = OpenStackVmInstance(
2558 self.os_creds, instance_settings,
2559 test_image_creator.image_settings)
2560 self.inst_creator.create()
2562 self.assertTrue(self.inst_creator.vm_active(block=True))
2565 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2567 Tests the ability of two VMs to communicate when attached to separate
2568 private networks that are tied together with a router.
2573 Instantiates the CreateImage object that is responsible for downloading
2574 and creating an OS image file within OpenStack
2576 super(self.__class__, self).__start__()
2578 cidr1 = '10.200.201.0/24'
2579 cidr2 = '10.200.202.0/24'
2580 static_gateway_ip1 = '10.200.201.1'
2581 static_gateway_ip2 = '10.200.202.1'
2582 self.ip1 = '10.200.201.5'
2583 self.ip2 = '10.200.202.5'
2585 self.nova = nova_utils.nova_client(self.os_creds)
2587 # Initialize for tearDown()
2588 self.image_creator = None
2589 self.network_creators = list()
2590 self.router_creator = None
2591 self.flavor_creator = None
2592 self.sec_grp_creator = None
2593 self.inst_creators = list()
2595 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2596 self.vm_inst1_name = self.guid + '-inst1'
2597 self.vm_inst2_name = self.guid + '-inst2'
2598 self.port_1_name = self.guid + '-vm1-port'
2599 self.port_2_name = self.guid + '-vm2-port'
2600 self.net_config_1 = NetworkConfig(
2601 name=self.guid + '-net1',
2603 create_network.SubnetConfig(
2604 cidr=cidr1, name=self.guid + '-subnet1',
2605 gateway_ip=static_gateway_ip1)])
2606 self.net_config_2 = NetworkConfig(
2607 name=self.guid + '-net2',
2609 create_network.SubnetConfig(
2610 cidr=cidr2, name=self.guid + '-subnet2',
2611 gateway_ip=static_gateway_ip2)])
2613 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2614 os_image_settings = openstack_tests.cirros_image_settings(
2615 name=image_name, image_metadata=self.image_metadata)
2619 self.image_creator = OpenStackImage(self.os_creds,
2621 self.image_creator.create()
2623 # First network is public
2624 self.network_creators.append(OpenStackNetwork(
2625 self.os_creds, self.net_config_1))
2626 # Second network is private
2627 self.network_creators.append(OpenStackNetwork(
2628 self.os_creds, self.net_config_2))
2629 for network_creator in self.network_creators:
2630 network_creator.create()
2633 create_network.PortConfig(
2634 name=self.guid + '-router-port1',
2637 self.net_config_1.subnet_settings[0].name,
2638 'ip': static_gateway_ip1
2640 network_name=self.net_config_1.name,
2641 project_name=self.os_creds.project_name),
2642 create_network.PortConfig(
2643 name=self.guid + '-router-port2',
2646 self.net_config_2.subnet_settings[0].name,
2647 'ip': static_gateway_ip2
2649 network_name=self.net_config_2.name,
2650 project_name=self.os_creds.project_name)]
2652 router_settings = RouterConfig(
2653 name=self.guid + '-pub-router', port_settings=port_settings)
2654 self.router_creator = create_router.OpenStackRouter(
2655 self.os_creds, router_settings)
2656 self.router_creator.create()
2659 self.flavor_creator = OpenStackFlavor(
2660 self.admin_os_creds,
2661 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
2663 metadata=self.flavor_metadata))
2664 self.flavor_creator.create()
2666 sec_grp_name = self.guid + '-sec-grp'
2667 rule1 = SecurityGroupRuleConfig(
2668 sec_grp_name=sec_grp_name, direction=Direction.ingress,
2669 protocol=Protocol.icmp)
2670 self.sec_grp_creator = OpenStackSecurityGroup(
2672 SecurityGroupConfig(
2673 name=sec_grp_name, rule_settings=[rule1]))
2674 self.sec_grp_creator.create()
2681 Cleans the created objects
2683 for inst_creator in self.inst_creators:
2685 inst_creator.clean()
2686 except Exception as e:
2688 'Unexpected exception cleaning VM instance with message '
2691 if self.flavor_creator:
2693 self.flavor_creator.clean()
2694 except Exception as e:
2696 'Unexpected exception cleaning flavor with message - %s',
2699 if self.router_creator:
2701 self.router_creator.clean()
2702 except Exception as e:
2704 'Unexpected exception cleaning router with message - %s',
2707 for network_creator in self.network_creators:
2709 network_creator.clean()
2710 except Exception as e:
2712 'Unexpected exception cleaning network with message - %s',
2715 if self.sec_grp_creator:
2717 self.sec_grp_creator.clean()
2718 except Exception as e:
2720 'Unexpected exception cleaning security group with message'
2723 if self.image_creator and not self.image_creator.image_settings.exists:
2725 self.image_creator.clean()
2726 except Exception as e:
2728 'Unexpected exception cleaning image with message - %s', e)
2730 super(self.__class__, self).__clean__()
2732 def test_ping_via_router(self):
2734 Tests the creation of two OpenStack instances with one port on
2735 different private networks wit a router in between to ensure that they
2739 # Create ports/NICs for instance
2742 for network_creator in self.network_creators:
2743 ports_settings.append(PortConfig(
2744 name=self.guid + '-port-' + str(ctr),
2745 network_name=network_creator.network_settings.name))
2748 # Configure instances
2749 instance1_settings = VmInstanceConfig(
2750 name=self.vm_inst1_name,
2751 flavor=self.flavor_creator.flavor_settings.name,
2752 userdata=_get_ping_userdata(self.ip2),
2753 port_settings=[PortConfig(
2754 name=self.port_1_name,
2757 self.net_config_1.subnet_settings[0].name,
2760 network_name=self.network_creators[0].network_settings.name)])
2761 instance2_settings = VmInstanceConfig(
2762 name=self.vm_inst2_name,
2763 flavor=self.flavor_creator.flavor_settings.name,
2764 userdata=_get_ping_userdata(self.ip1),
2765 port_settings=[PortConfig(
2766 name=self.port_2_name,
2769 self.net_config_2.subnet_settings[0].name,
2772 network_name=self.network_creators[1].network_settings.name)])
2775 self.inst_creators.append(OpenStackVmInstance(
2776 self.os_creds, instance1_settings,
2777 self.image_creator.image_settings))
2778 self.inst_creators.append(OpenStackVmInstance(
2779 self.os_creds, instance2_settings,
2780 self.image_creator.image_settings))
2782 for inst_creator in self.inst_creators:
2783 inst_creator.create(block=True)
2785 # Check for DHCP lease
2786 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2787 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2789 # Effectively blocks until VM has been properly activated
2790 self.assertTrue(check_ping(self.inst_creators[0]))
2791 self.assertTrue(check_ping(self.inst_creators[1]))
2794 class CreateInstanceVolumeTests(OSIntegrationTestCase):
2796 Simple instance creation with an attached volume
2801 Instantiates the CreateImage object that is responsible for downloading
2802 and creating an OS image file
2805 super(self.__class__, self).__start__()
2807 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2808 self.vm_inst_name = guid + '-inst'
2809 self.nova = nova_utils.nova_client(self.os_creds)
2810 self.neutron = neutron_utils.neutron_client(self.os_creds)
2811 os_image_settings = openstack_tests.cirros_image_settings(
2812 name=guid + '-image', image_metadata=self.image_metadata)
2814 net_config = openstack_tests.get_priv_net_config(
2815 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2816 router_name=guid + '-pub-router', external_net=self.ext_net_name,
2817 netconf_override=self.netconf_override)
2819 self.volume_settings1 = VolumeConfig(
2820 name=self.__class__.__name__ + '-' + str(guid) + '-1')
2821 self.volume_settings2 = VolumeConfig(
2822 name=self.__class__.__name__ + '-' + str(guid) + '-2')
2824 # Initialize for tearDown()
2825 self.image_creator = None
2826 self.flavor_creator = None
2828 self.network_creator = None
2829 self.inst_creator = None
2830 self.volume_creator1 = None
2831 self.volume_creator2 = None
2835 self.image_creator = OpenStackImage(self.os_creds,
2837 self.image_creator.create()
2840 self.flavor_creator = OpenStackFlavor(
2841 self.admin_os_creds,
2842 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
2843 vcpus=2, metadata=self.flavor_metadata))
2844 self.flavor_creator.create()
2847 self.network_creator = OpenStackNetwork(
2848 self.os_creds, net_config.network_settings)
2849 self.network_creator.create()
2851 self.port_settings = PortConfig(
2852 name=guid + '-port',
2853 network_name=net_config.network_settings.name)
2855 self.volume_creator1 = OpenStackVolume(
2856 self.os_creds, self.volume_settings1)
2857 self.volume_creator1.create(block=True)
2859 self.volume_creator2 = OpenStackVolume(
2860 self.os_creds, self.volume_settings2)
2861 self.volume_creator2.create(block=True)
2863 except Exception as e:
2869 Cleans the created object
2871 if self.inst_creator:
2873 self.inst_creator.clean()
2874 except Exception as e:
2876 'Unexpected exception cleaning VM instance with message '
2879 if self.flavor_creator:
2881 self.flavor_creator.clean()
2882 except Exception as e:
2884 'Unexpected exception cleaning flavor with message - %s',
2887 if self.network_creator:
2889 self.network_creator.clean()
2890 except Exception as e:
2892 'Unexpected exception cleaning network with message - %s',
2895 if self.volume_creator2:
2897 self.volume_creator2.clean()
2898 except Exception as e:
2900 'Unexpected exception cleaning volume with message - %s',
2903 if self.volume_creator1:
2905 self.volume_creator1.clean()
2906 except Exception as e:
2908 'Unexpected exception cleaning volume with message - %s',
2911 if self.image_creator and not self.image_creator.image_settings.exists:
2913 self.image_creator.clean()
2914 except Exception as e:
2916 'Unexpected exception cleaning image with message - %s', e)
2918 super(self.__class__, self).__clean__()
2920 def test_create_instance_with_one_volume(self):
2922 Tests the creation of an OpenStack instance with a single volume.
2924 instance_settings = VmInstanceConfig(
2925 name=self.vm_inst_name,
2926 flavor=self.flavor_creator.flavor_settings.name,
2927 port_settings=[self.port_settings],
2928 volume_names=[self.volume_settings1.name])
2930 self.inst_creator = OpenStackVmInstance(
2931 self.os_creds, instance_settings,
2932 self.image_creator.image_settings)
2934 vm_inst = self.inst_creator.create(block=True)
2935 self.assertIsNotNone(nova_utils.get_server(
2936 self.nova, self.neutron, vm_inst_settings=instance_settings))
2938 self.assertIsNotNone(vm_inst)
2939 self.assertEqual(1, len(vm_inst.volume_ids))
2940 self.assertEqual(self.volume_creator1.get_volume().id,
2941 vm_inst.volume_ids[0]['id'])
2943 def test_create_instance_with_two_volumes(self):
2945 Tests the creation of an OpenStack instance with a single volume.
2947 instance_settings = VmInstanceConfig(
2948 name=self.vm_inst_name,
2949 flavor=self.flavor_creator.flavor_settings.name,
2950 port_settings=[self.port_settings],
2951 volume_names=[self.volume_settings1.name,
2952 self.volume_settings2.name])
2954 self.inst_creator = OpenStackVmInstance(
2955 self.os_creds, instance_settings,
2956 self.image_creator.image_settings)
2958 vm_inst = self.inst_creator.create(block=True)
2959 self.assertIsNotNone(nova_utils.get_server(
2960 self.nova, self.neutron, vm_inst_settings=instance_settings))
2962 self.assertIsNotNone(vm_inst)
2963 self.assertEqual(2, len(vm_inst.volume_ids))
2964 self.assertEqual(self.volume_creator1.get_volume().id,
2965 vm_inst.volume_ids[0]['id'])
2966 self.assertEqual(self.volume_creator2.get_volume().id,
2967 vm_inst.volume_ids[1]['id'])
2970 def check_dhcp_lease(inst_creator, ip, timeout=160):
2972 Returns true if the expected DHCP lease has been acquired
2973 :param inst_creator: the SNAPS OpenStackVmInstance object
2974 :param ip: the IP address to look for
2975 :param timeout: how long to query for IP address
2979 start_time = time.time()
2981 logger.info("Looking for IP %s in the console log" % ip)
2983 while timeout > time.time() - start_time:
2984 output = inst_creator.get_console_output()
2985 full_log = full_log + output
2986 if re.search(ip, output):
2987 logger.info('DHCP lease obtained logged in console')
2992 logger.error('Full console output -\n' + full_log)
2994 logger.debug('Full console output -\n' + full_log)
2999 def _get_ping_userdata(test_ip):
3001 Returns the post VM creation script to be added into the VM's userdata
3002 :param test_ip: the IP value to substitute into the script
3003 :return: the bash script contents
3006 return ("#!/bin/sh\n\n"
3008 " ping -c 1 %s 2>&1 >/dev/null\n"
3010 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3011 " echo 'vPing OK'\n"
3014 " echo 'vPing KO'\n"
3021 def check_ping(vm_creator, timeout=160):
3023 Check for VM for ping result
3027 while tries < timeout:
3029 p_console = vm_creator.get_console_output()
3030 if "vPing OK" in p_console:
3032 elif "failed to read iid from metadata" in p_console or tries > 5: