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 (
24 InvalidIpForSubnetClient, 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, keystone_utils, neutron_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, self.os_session)
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 Setup the objects required for the test
416 super(self.__class__, self).__start__()
418 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
419 self.vm_inst_name = self.guid + '-inst'
420 self.nova = nova_utils.nova_client(self.os_creds)
421 self.neutron = neutron_utils.neutron_client(self.os_creds)
422 os_image_settings = openstack_tests.cirros_image_settings(
423 name=self.guid + '-image', image_metadata=self.image_metadata)
425 # Initialize for tearDown()
426 self.image_creator = None
427 self.flavor_creator = None
429 self.network_creator = None
430 self.inst_creator = None
434 self.image_creator = OpenStackImage(self.os_creds,
436 self.image_creator.create()
439 self.flavor_creator = OpenStackFlavor(
441 FlavorConfig(name=self.guid + '-flavor-name', ram=256, disk=10,
442 vcpus=2, metadata=self.flavor_metadata))
443 self.flavor_creator.create()
444 self.network_creator = None
445 except Exception as e:
451 Cleans the created object
453 if self.inst_creator:
455 self.inst_creator.clean()
456 except Exception as e:
458 'Unexpected exception cleaning VM instance with message '
461 if self.flavor_creator:
463 self.flavor_creator.clean()
464 except Exception as e:
466 'Unexpected exception cleaning flavor with message - %s',
469 if self.network_creator:
471 self.network_creator.clean()
472 except Exception as e:
474 'Unexpected exception cleaning network with message - %s',
477 if self.image_creator and not self.image_creator.image_settings.exists:
479 self.image_creator.clean()
480 except Exception as e:
482 'Unexpected exception cleaning image with message - %s', e)
484 super(self.__class__, self).__clean__()
486 def test_create_delete_instance(self):
488 Tests the creation of an OpenStack instance with a single port with a
489 static IP without a Floating IP.
492 net_config = openstack_tests.get_priv_net_config(
493 net_name=self.guid + '-pub-net',
494 subnet_name=self.guid + '-pub-subnet',
495 router_name=self.guid + '-pub-router',
496 external_net=self.ext_net_name,
497 netconf_override=self.netconf_override)
498 self.network_creator = OpenStackNetwork(
499 self.os_creds, net_config.network_settings)
500 self.network_creator.create()
502 self.port_settings = PortConfig(
503 name=self.guid + '-port',
504 network_name=net_config.network_settings.name)
506 instance_settings = VmInstanceConfig(
507 name=self.vm_inst_name,
508 flavor=self.flavor_creator.flavor_settings.name,
509 port_settings=[self.port_settings])
511 self.inst_creator = OpenStackVmInstance(
512 self.os_creds, instance_settings,
513 self.image_creator.image_settings)
515 vm_inst = self.inst_creator.create(block=True)
516 vm_inst_get = nova_utils.get_server(
517 self.nova, self.neutron, self.keystone,
518 vm_inst_settings=instance_settings)
519 self.assertEqual(vm_inst, vm_inst_get)
521 self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
522 self.assertIsNone(self.inst_creator.get_vm_inst().compute_host)
525 nova_utils.delete_vm_instance(self.nova, vm_inst)
527 self.assertTrue(self.inst_creator.vm_deleted(block=True))
528 self.assertIsNone(nova_utils.get_server(
529 self.nova, self.neutron, self.keystone,
530 vm_inst_settings=instance_settings))
532 # Exception should not be thrown
533 self.inst_creator.clean()
535 def test_create_admin_instance(self):
537 Tests the creation of an OpenStack instance with a single port with a
538 static IP without a Floating IP.
541 net_config = openstack_tests.get_priv_net_config(
542 net_name=self.guid + '-pub-net',
543 subnet_name=self.guid + '-pub-subnet',
544 router_name=self.guid + '-pub-router',
545 external_net=self.ext_net_name,
546 netconf_override=self.netconf_override)
547 self.network_creator = OpenStackNetwork(
548 self.admin_os_creds, net_config.network_settings)
549 self.network_creator.create()
551 self.port_settings = PortConfig(
552 name=self.guid + '-port',
553 network_name=net_config.network_settings.name)
555 instance_settings = VmInstanceConfig(
556 name=self.vm_inst_name,
557 flavor=self.flavor_creator.flavor_settings.name,
558 port_settings=[self.port_settings])
560 self.inst_creator = OpenStackVmInstance(
561 self.admin_os_creds, instance_settings,
562 self.image_creator.image_settings)
564 admin_nova = nova_utils.nova_client(self.admin_os_creds)
565 admin_neutron = neutron_utils.neutron_client(self.admin_os_creds)
566 admin_key = keystone_utils.keystone_client(self.admin_os_creds)
567 vm_inst = self.inst_creator.create(block=True)
569 self.assertIsNotNone(vm_inst)
570 vm_inst_get = nova_utils.get_server(
571 admin_nova, admin_neutron, admin_key,
572 vm_inst_settings=instance_settings)
573 self.assertEqual(vm_inst, vm_inst_get)
575 self.assertIsNone(nova_utils.get_server(
576 self.nova, self.neutron, self.keystone,
577 vm_inst_settings=instance_settings))
579 self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
580 self.assertIsNotNone(self.inst_creator.get_vm_inst().compute_host)
583 class CreateInstanceExternalNetTests(OSIntegrationTestCase):
585 Simple instance creation tests where the network is external
590 Instantiates the CreateImage object that is responsible for downloading
591 and creating an OS image file
594 super(self.__class__, self).__start__()
596 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
597 self.vm_inst_name = guid + '-inst'
598 self.nova = nova_utils.nova_client(self.admin_os_creds)
599 self.neutron = neutron_utils.neutron_client(self.admin_os_creds)
600 os_image_settings = openstack_tests.cirros_image_settings(
601 name=guid + '-image', image_metadata=self.image_metadata)
603 # Initialize for tearDown()
604 self.image_creator = None
605 self.flavor_creator = None
606 self.inst_creator = None
610 self.image_creator = OpenStackImage(self.os_creds,
612 self.image_creator.create()
615 self.flavor_creator = OpenStackFlavor(
617 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
618 vcpus=2, metadata=self.flavor_metadata))
619 self.flavor_creator.create()
621 self.port_settings = PortConfig(
623 network_name=self.ext_net_name)
625 except Exception as e:
631 Cleans the created object
633 if self.inst_creator:
635 self.inst_creator.clean()
636 except Exception as e:
638 'Unexpected exception cleaning VM instance with message '
641 if self.flavor_creator:
643 self.flavor_creator.clean()
644 except Exception as e:
646 'Unexpected exception cleaning flavor with message - %s',
649 if self.image_creator and not self.image_creator.image_settings.exists:
651 self.image_creator.clean()
652 except Exception as e:
654 'Unexpected exception cleaning image with message - %s', e)
656 super(self.__class__, self).__clean__()
658 def test_create_instance_public_net(self):
660 Tests the creation of an OpenStack instance with a single port to
661 the external network.
663 instance_settings = VmInstanceConfig(
664 name=self.vm_inst_name,
665 flavor=self.flavor_creator.flavor_settings.name,
666 port_settings=[self.port_settings])
668 self.inst_creator = OpenStackVmInstance(
669 self.admin_os_creds, instance_settings,
670 self.image_creator.image_settings)
672 vm_inst = self.inst_creator.create(block=True)
673 vm_inst_get = nova_utils.get_server(
674 self.nova, self.neutron, self.keystone,
675 vm_inst_settings=instance_settings)
676 self.assertEqual(vm_inst, vm_inst_get)
677 ip = self.inst_creator.get_port_ip(self.port_settings.name)
679 check_dhcp_lease(self.inst_creator, ip)
682 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
684 Test for the CreateInstance class with a single NIC/Port with Floating IPs
689 Instantiates the CreateImage object that is responsible for downloading
690 and creating an OS image file within OpenStack
692 super(self.__class__, self).__start__()
694 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
695 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
696 self.keypair_priv_filepath = 'tmp/' + guid
697 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
698 self.keypair_name = guid + '-kp'
699 self.vm_inst_name = guid + '-inst'
700 self.port_1_name = guid + 'port-1'
701 self.port_2_name = guid + 'port-2'
702 self.floating_ip_name = guid + 'fip1'
704 # Initialize for tearDown()
705 self.image_creator = None
706 self.network_creator = None
707 self.router_creator = None
708 self.flavor_creator = None
709 self.keypair_creator = None
710 self.sec_grp_creator = None
711 self.inst_creators = list()
713 self.pub_net_config = openstack_tests.get_pub_net_config(
714 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
715 router_name=guid + '-pub-router', external_net=self.ext_net_name,
716 netconf_override=self.netconf_override)
717 os_image_settings = openstack_tests.cirros_image_settings(
718 name=guid + '-image', image_metadata=self.image_metadata)
721 self.image_creator = OpenStackImage(self.os_creds,
723 self.image_creator.create()
726 self.network_creator = OpenStackNetwork(
727 self.os_creds, self.pub_net_config.network_settings)
728 self.network_creator.create()
731 self.router_creator = OpenStackRouter(
732 self.os_creds, self.pub_net_config.router_settings)
733 self.router_creator.create()
736 self.flavor_creator = OpenStackFlavor(
738 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
739 vcpus=2, metadata=self.flavor_metadata))
740 self.flavor_creator.create()
742 self.keypair_creator = OpenStackKeypair(
743 self.os_creds, KeypairConfig(
744 name=self.keypair_name,
745 public_filepath=self.keypair_pub_filepath,
746 private_filepath=self.keypair_priv_filepath))
747 self.keypair_creator.create()
749 sec_grp_name = guid + '-sec-grp'
750 rule1 = SecurityGroupRuleConfig(
751 sec_grp_name=sec_grp_name, direction=Direction.ingress,
752 protocol=Protocol.icmp)
753 rule2 = SecurityGroupRuleConfig(
754 sec_grp_name=sec_grp_name, direction=Direction.ingress,
755 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
756 self.sec_grp_creator = OpenStackSecurityGroup(
759 name=sec_grp_name, rule_settings=[rule1, rule2]))
760 self.sec_grp_creator.create()
761 except Exception as e:
767 Cleans the created object
769 for inst_creator in self.inst_creators:
772 except Exception as e:
774 'Unexpected exception cleaning VM instance with message '
777 if self.keypair_creator:
779 self.keypair_creator.clean()
780 except Exception as e:
782 'Unexpected exception cleaning keypair with message - %s',
785 if self.flavor_creator:
787 self.flavor_creator.clean()
788 except Exception as e:
790 'Unexpected exception cleaning flavor with message - %s',
793 if self.sec_grp_creator:
795 self.sec_grp_creator.clean()
796 except Exception as e:
798 'Unexpected exception cleaning security group with message'
801 if self.router_creator:
803 self.router_creator.clean()
804 except Exception as e:
806 'Unexpected exception cleaning router with message - %s',
809 if self.network_creator:
811 self.network_creator.clean()
812 except Exception as e:
814 'Unexpected exception cleaning network with message - %s',
817 if self.image_creator and not self.image_creator.image_settings.exists:
819 self.image_creator.clean()
820 except Exception as e:
822 'Unexpected exception cleaning image with message - %s', e)
824 super(self.__class__, self).__clean__()
826 def test_single_port_static(self):
828 Tests the creation of an OpenStack instance with a single port with a
829 static IP without a Floating IP.
832 sub_settings = self.pub_net_config.network_settings.subnet_settings
833 port_settings = PortConfig(
834 name=self.port_1_name,
835 network_name=self.pub_net_config.network_settings.name,
837 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
839 instance_settings = VmInstanceConfig(
840 name=self.vm_inst_name,
841 flavor=self.flavor_creator.flavor_settings.name,
842 port_settings=[port_settings],
843 floating_ip_settings=[FloatingIpConfig(
844 name=self.floating_ip_name, port_name=self.port_1_name,
845 router_name=self.pub_net_config.router_settings.name)])
847 inst_creator = OpenStackVmInstance(
848 self.os_creds, instance_settings,
849 self.image_creator.image_settings,
850 keypair_settings=self.keypair_creator.keypair_settings)
851 self.inst_creators.append(inst_creator)
852 vm_inst = inst_creator.create(block=True)
854 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
855 self.assertTrue(inst_creator.vm_active(block=True))
856 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
858 def test_ssh_client_fip_before_active(self):
860 Tests the ability to access a VM via SSH and a floating IP when it has
861 been assigned prior to being active.
863 port_settings = PortConfig(
864 name=self.port_1_name,
865 network_name=self.pub_net_config.network_settings.name)
867 instance_settings = VmInstanceConfig(
868 name=self.vm_inst_name,
869 flavor=self.flavor_creator.flavor_settings.name,
870 port_settings=[port_settings],
871 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
872 floating_ip_settings=[FloatingIpConfig(
873 name=self.floating_ip_name, port_name=self.port_1_name,
874 router_name=self.pub_net_config.router_settings.name)])
876 inst_creator = OpenStackVmInstance(
877 self.os_creds, instance_settings,
878 self.image_creator.image_settings,
879 keypair_settings=self.keypair_creator.keypair_settings)
880 self.inst_creators.append(inst_creator)
881 vm_inst = inst_creator.create()
882 self.assertIsNotNone(vm_inst)
884 self.assertTrue(inst_creator.vm_active(block=True))
886 ip = inst_creator.get_port_ip(port_settings.name)
887 self.assertTrue(check_dhcp_lease(inst_creator, ip))
889 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
891 self.assertTrue(validate_ssh_client(inst_creator))
893 def test_ssh_client_fip_after_active(self):
895 Tests the ability to access a VM via SSH and a floating IP when it has
896 been assigned prior to being active.
898 port_settings = PortConfig(
899 name=self.port_1_name,
900 network_name=self.pub_net_config.network_settings.name)
902 instance_settings = VmInstanceConfig(
903 name=self.vm_inst_name,
904 flavor=self.flavor_creator.flavor_settings.name,
905 port_settings=[port_settings],
906 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
907 floating_ip_settings=[FloatingIpConfig(
908 name=self.floating_ip_name, port_name=self.port_1_name,
909 router_name=self.pub_net_config.router_settings.name)])
911 inst_creator = OpenStackVmInstance(
912 self.os_creds, instance_settings,
913 self.image_creator.image_settings,
914 keypair_settings=self.keypair_creator.keypair_settings)
915 self.inst_creators.append(inst_creator)
917 # block=True will force the create() method to block until the
918 vm_inst = inst_creator.create(block=True)
919 self.assertIsNotNone(vm_inst)
921 self.assertTrue(inst_creator.vm_active(block=True))
923 ip = inst_creator.get_port_ip(port_settings.name)
924 self.assertTrue(check_dhcp_lease(inst_creator, ip))
926 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
928 self.assertTrue(validate_ssh_client(inst_creator))
930 def test_ssh_client_fip_after_reboot(self):
932 Tests the ability to access a VM via SSH and a floating IP after it has
935 port_settings = PortConfig(
936 name=self.port_1_name,
937 network_name=self.pub_net_config.network_settings.name)
939 instance_settings = VmInstanceConfig(
940 name=self.vm_inst_name,
941 flavor=self.flavor_creator.flavor_settings.name,
942 port_settings=[port_settings],
943 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
944 floating_ip_settings=[FloatingIpConfig(
945 name=self.floating_ip_name, port_name=self.port_1_name,
946 router_name=self.pub_net_config.router_settings.name)])
948 inst_creator = OpenStackVmInstance(
949 self.os_creds, instance_settings,
950 self.image_creator.image_settings,
951 keypair_settings=self.keypair_creator.keypair_settings)
952 self.inst_creators.append(inst_creator)
954 # block=True will force the create() method to block until the
955 vm_inst = inst_creator.create(block=True)
956 self.assertIsNotNone(vm_inst)
958 self.assertTrue(inst_creator.vm_active(block=True))
960 ip = inst_creator.get_port_ip(port_settings.name)
961 self.assertTrue(check_dhcp_lease(inst_creator, ip))
963 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
965 self.assertTrue(validate_ssh_client(inst_creator))
967 # Test default reboot which should be 'SOFT'
968 inst_creator.reboot()
969 # Lag time to allow for shutdown routine to take effect
971 self.assertTrue(check_dhcp_lease(inst_creator, ip))
972 self.assertTrue(validate_ssh_client(inst_creator))
975 inst_creator.reboot(reboot_type=RebootType.soft)
977 self.assertTrue(check_dhcp_lease(inst_creator, ip))
978 self.assertTrue(validate_ssh_client(inst_creator))
981 inst_creator.reboot(reboot_type=RebootType.hard)
983 self.assertTrue(check_dhcp_lease(inst_creator, ip))
984 self.assertTrue(validate_ssh_client(inst_creator))
986 def test_ssh_client_fip_after_init(self):
988 Tests the ability to assign a floating IP to an already initialized
989 OpenStackVmInstance object. After the floating IP has been allocated
990 and assigned, this test will ensure that it can be accessed via SSH.
992 port_settings = PortConfig(
993 name=self.port_1_name,
994 network_name=self.pub_net_config.network_settings.name)
996 instance_settings = VmInstanceConfig(
997 name=self.vm_inst_name,
998 flavor=self.flavor_creator.flavor_settings.name,
999 port_settings=[port_settings],
1000 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
1002 inst_creator = OpenStackVmInstance(
1003 self.os_creds, instance_settings,
1004 self.image_creator.image_settings,
1005 keypair_settings=self.keypair_creator.keypair_settings)
1006 self.inst_creators.append(inst_creator)
1008 # block=True will force the create() method to block until the
1009 vm_inst = inst_creator.create(block=True)
1010 self.assertIsNotNone(vm_inst)
1012 self.assertTrue(inst_creator.vm_active(block=True))
1013 ip = inst_creator.get_port_ip(port_settings.name)
1014 self.assertTrue(check_dhcp_lease(inst_creator, ip))
1015 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
1017 inst_creator.add_floating_ip(FloatingIpConfig(
1018 name=self.floating_ip_name, port_name=self.port_1_name,
1019 router_name=self.pub_net_config.router_settings.name))
1021 self.assertTrue(validate_ssh_client(inst_creator))
1023 def test_ssh_client_fip_reverse_engineer(self):
1025 Tests the ability to assign a floating IP to a reverse engineered
1026 OpenStackVmInstance object. After the floating IP has been allocated
1027 and assigned, this test will ensure that it can be accessed via SSH.
1029 port_settings = PortConfig(
1030 name=self.port_1_name,
1031 network_name=self.pub_net_config.network_settings.name)
1033 instance_settings = VmInstanceConfig(
1034 name=self.vm_inst_name,
1035 flavor=self.flavor_creator.flavor_settings.name,
1036 port_settings=[port_settings],
1037 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
1039 inst_creator = OpenStackVmInstance(
1040 self.os_creds, instance_settings,
1041 self.image_creator.image_settings,
1042 keypair_settings=self.keypair_creator.keypair_settings)
1043 self.inst_creators.append(inst_creator)
1045 # block=True will force the create() method to block until the
1046 vm_inst = inst_creator.create(block=True)
1047 self.assertIsNotNone(vm_inst)
1049 self.assertTrue(inst_creator.vm_active(block=True))
1051 derived_inst_creator = create_instance.generate_creator(
1052 self.os_creds, vm_inst, self.image_creator.image_settings,
1053 self.os_creds.project_name, self.keypair_creator.keypair_settings)
1055 derived_inst_creator.add_floating_ip(FloatingIpConfig(
1056 name=self.floating_ip_name, port_name=self.port_1_name,
1057 router_name=self.pub_net_config.router_settings.name))
1058 self.inst_creators.append(derived_inst_creator)
1060 self.assertTrue(validate_ssh_client(
1061 derived_inst_creator, fip_name=self.floating_ip_name))
1063 def test_ssh_client_fip_second_creator(self):
1065 Tests the ability to access a VM via SSH and a floating IP via a
1066 creator that is identical to the original creator.
1068 port_settings = PortConfig(
1069 name=self.port_1_name,
1070 network_name=self.pub_net_config.network_settings.name)
1072 instance_settings = VmInstanceConfig(
1073 name=self.vm_inst_name,
1074 flavor=self.flavor_creator.flavor_settings.name,
1075 port_settings=[port_settings],
1076 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1077 floating_ip_settings=[FloatingIpConfig(
1078 name=self.floating_ip_name, port_name=self.port_1_name,
1079 router_name=self.pub_net_config.router_settings.name)])
1081 inst_creator = OpenStackVmInstance(
1082 self.os_creds, instance_settings,
1083 self.image_creator.image_settings,
1084 keypair_settings=self.keypair_creator.keypair_settings)
1085 self.inst_creators.append(inst_creator)
1087 # block=True will force the create() method to block until the
1088 vm_inst = inst_creator.create(block=True)
1089 self.assertIsNotNone(vm_inst)
1091 self.assertTrue(inst_creator.vm_active(block=True))
1093 ip = inst_creator.get_port_ip(port_settings.name)
1094 self.assertTrue(check_dhcp_lease(inst_creator, ip))
1096 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
1098 self.assertTrue(validate_ssh_client(inst_creator))
1100 inst_creator2 = OpenStackVmInstance(
1101 self.os_creds, instance_settings,
1102 self.image_creator.image_settings,
1103 keypair_settings=self.keypair_creator.keypair_settings)
1104 inst_creator2.create()
1105 self.assertTrue(validate_ssh_client(inst_creator2))
1108 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
1110 Test for the CreateInstance class with a single NIC/Port with Floating IPs
1115 Instantiates the CreateImage object that is responsible for downloading
1116 and creating an OS image file within OpenStack
1118 super(self.__class__, self).__start__()
1120 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
1121 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1122 self.keypair_priv_filepath = 'tmp/' + self.guid
1123 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1124 self.keypair_name = self.guid + '-kp'
1125 self.vm_inst_name = self.guid + '-inst'
1126 self.port1_name = self.guid + 'port1'
1127 self.port2_name = self.guid + 'port2'
1129 # Initialize for tearDown()
1130 self.image_creator = None
1131 self.network_creator = None
1132 self.router_creator = None
1133 self.flavor_creator = None
1134 self.keypair_creator = None
1135 self.sec_grp_creator = None
1136 self.inst_creator = None
1138 os_image_settings = openstack_tests.cirros_image_settings(
1139 name=self.guid + '-image', image_metadata=self.image_metadata)
1141 self.image_creator = OpenStackImage(
1142 self.os_creds, os_image_settings)
1143 self.image_creator.create()
1145 self.flavor_creator = OpenStackFlavor(
1146 self.admin_os_creds,
1148 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
1149 metadata=self.flavor_metadata))
1150 self.flavor_creator.create()
1152 self.keypair_creator = OpenStackKeypair(
1153 self.os_creds, KeypairConfig(
1154 name=self.keypair_name,
1155 public_filepath=self.keypair_pub_filepath,
1156 private_filepath=self.keypair_priv_filepath))
1157 self.keypair_creator.create()
1159 sec_grp_name = self.guid + '-sec-grp'
1160 rule1 = SecurityGroupRuleConfig(
1161 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1162 protocol=Protocol.icmp)
1163 rule2 = SecurityGroupRuleConfig(
1164 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1165 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
1166 self.sec_grp_creator = OpenStackSecurityGroup(
1168 SecurityGroupConfig(
1169 name=sec_grp_name, rule_settings=[rule1, rule2]))
1170 self.sec_grp_creator.create()
1171 except Exception as e:
1177 Cleans the created object
1179 if self.inst_creator:
1181 self.inst_creator.clean()
1182 except Exception as e:
1184 'Unexpected exception cleaning VM instance with message '
1187 if self.keypair_creator:
1189 self.keypair_creator.clean()
1190 except Exception as e:
1192 'Unexpected exception cleaning keypair with message - %s',
1195 if self.flavor_creator:
1197 self.flavor_creator.clean()
1198 except Exception as e:
1200 'Unexpected exception cleaning flavor with message - %s',
1203 if self.sec_grp_creator:
1205 self.sec_grp_creator.clean()
1206 except Exception as e:
1208 'Unexpected exception cleaning security group with message'
1211 if self.router_creator:
1213 self.router_creator.clean()
1214 except Exception as e:
1216 'Unexpected exception cleaning router with message - %s',
1219 if self.network_creator:
1221 self.network_creator.clean()
1222 except Exception as e:
1224 'Unexpected exception cleaning network with message - %s',
1227 if self.image_creator and not self.image_creator.image_settings.exists:
1229 self.image_creator.clean()
1230 except Exception as e:
1232 'Unexpected exception cleaning image with message - %s', e)
1234 super(self.__class__, self).__clean__()
1236 def test_v4fip_v6overlay(self):
1238 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1239 network when the external network does not have an IPv6 subnet.
1241 subnet_settings = SubnetConfig(
1242 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
1244 network_settings = NetworkConfig(
1245 name=self.guid + '-net', subnet_settings=[subnet_settings])
1246 router_settings = RouterConfig(
1247 name=self.guid + '-router', external_gateway=self.ext_net_name,
1248 internal_subnets=[subnet_settings.name])
1251 self.network_creator = OpenStackNetwork(
1252 self.os_creds, network_settings)
1253 self.network_creator.create()
1256 self.router_creator = OpenStackRouter(
1257 self.os_creds, router_settings)
1258 self.router_creator.create()
1260 port_settings = PortConfig(
1261 name=self.port1_name, network_name=network_settings.name)
1263 instance_settings = VmInstanceConfig(
1264 name=self.vm_inst_name,
1265 flavor=self.flavor_creator.flavor_settings.name,
1266 port_settings=[port_settings],
1267 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1268 floating_ip_settings=[FloatingIpConfig(
1269 name='fip1', port_name=self.port1_name,
1270 router_name=router_settings.name)])
1272 self.inst_creator = OpenStackVmInstance(
1273 self.os_creds, instance_settings,
1274 self.image_creator.image_settings,
1275 keypair_settings=self.keypair_creator.keypair_settings)
1277 with self.assertRaises(BadRequest):
1278 self.inst_creator.create(block=True)
1280 def test_fip_v4and6_overlay(self):
1282 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1283 network when the external network does not have an IPv6 subnet.
1285 subnet4_settings = SubnetConfig(
1286 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
1288 subnet6_settings = SubnetConfig(
1289 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
1291 network_settings = NetworkConfig(
1292 name=self.guid + '-net',
1293 subnet_settings=[subnet4_settings, subnet6_settings])
1294 router_settings = RouterConfig(
1295 name=self.guid + '-router', external_gateway=self.ext_net_name,
1296 internal_subnets=[subnet4_settings.name])
1299 self.network_creator = OpenStackNetwork(
1300 self.os_creds, network_settings)
1301 self.network_creator.create()
1304 self.router_creator = OpenStackRouter(
1305 self.os_creds, router_settings)
1306 self.router_creator.create()
1308 port_settings = PortConfig(
1309 name=self.port1_name, network_name=network_settings.name)
1311 instance_settings = VmInstanceConfig(
1312 name=self.vm_inst_name,
1313 flavor=self.flavor_creator.flavor_settings.name,
1314 port_settings=[port_settings],
1315 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1316 floating_ip_settings=[FloatingIpConfig(
1317 name='fip1', port_name=self.port1_name,
1318 router_name=router_settings.name)])
1320 self.inst_creator = OpenStackVmInstance(
1321 self.os_creds, instance_settings,
1322 self.image_creator.image_settings,
1323 keypair_settings=self.keypair_creator.keypair_settings)
1325 self.inst_creator.create(block=True)
1326 ssh_client = self.inst_creator.ssh_client()
1327 self.assertIsNotNone(ssh_client)
1330 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1332 Test for the CreateInstance class with a single NIC/Port where mac and IP
1333 values are manually set
1338 Instantiates the CreateImage object that is responsible for downloading
1339 and creating an OS image file within OpenStack
1341 super(self.__class__, self).__start__()
1343 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1344 self.vm_inst_name = guid + '-inst'
1345 self.port_1_name = guid + 'port-1'
1346 self.port_2_name = guid + 'port-2'
1347 self.floating_ip_name = guid + 'fip1'
1349 # Initialize for tearDown()
1350 self.image_creator = None
1351 self.network_creator = None
1352 self.flavor_creator = None
1353 self.inst_creator = None
1355 self.net_config = openstack_tests.get_priv_net_config(
1356 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1357 router_name=guid + '-pub-router', external_net=self.ext_net_name,
1358 netconf_override=self.netconf_override)
1359 os_image_settings = openstack_tests.cirros_image_settings(
1360 name=guid + '-image', image_metadata=self.image_metadata)
1364 self.image_creator = OpenStackImage(self.os_creds,
1366 self.image_creator.create()
1369 self.network_creator = OpenStackNetwork(
1370 self.os_creds, self.net_config.network_settings)
1371 self.network_creator.create()
1374 self.flavor_creator = OpenStackFlavor(
1375 self.admin_os_creds,
1376 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1377 vcpus=2, metadata=self.flavor_metadata))
1378 self.flavor_creator.create()
1379 except Exception as e:
1385 Cleans the created object
1387 if self.inst_creator:
1389 self.inst_creator.clean()
1390 except Exception as e:
1392 'Unexpected exception cleaning VM instance with message '
1395 if self.flavor_creator:
1397 self.flavor_creator.clean()
1398 except Exception as e:
1400 'Unexpected exception cleaning flavor with message - %s',
1403 if self.network_creator:
1405 self.network_creator.clean()
1406 except Exception as e:
1408 'Unexpected exception cleaning network with message - %s',
1411 if self.image_creator and not self.image_creator.image_settings.exists:
1413 self.image_creator.clean()
1414 except Exception as e:
1416 'Unexpected exception cleaning image with message - %s', e)
1418 super(self.__class__, self).__clean__()
1420 def test_set_custom_valid_ip_one_subnet(self):
1422 Tests the creation of an OpenStack instance with a single port with a
1423 static IP on a network with one subnet.
1426 sub_settings = self.net_config.network_settings.subnet_settings
1427 port_settings = PortConfig(
1428 name=self.port_1_name,
1429 network_name=self.net_config.network_settings.name,
1430 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1432 instance_settings = VmInstanceConfig(
1433 name=self.vm_inst_name,
1434 flavor=self.flavor_creator.flavor_settings.name,
1435 port_settings=[port_settings])
1437 self.inst_creator = OpenStackVmInstance(
1438 self.os_creds, instance_settings,
1439 self.image_creator.image_settings)
1440 self.inst_creator.create(block=True)
1442 self.assertEqual(ip, self.inst_creator.get_port_ip(
1444 subnet_name=self.net_config.network_settings.subnet_settings[
1447 def test_set_custom_invalid_ip_one_subnet(self):
1449 Tests the creation of an OpenStack instance with a single port with a
1450 static IP on a network with one subnet.
1453 sub_settings = self.net_config.network_settings.subnet_settings
1454 port_settings = PortConfig(
1455 name=self.port_1_name,
1456 network_name=self.net_config.network_settings.name,
1457 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1459 instance_settings = VmInstanceConfig(
1460 name=self.vm_inst_name,
1461 flavor=self.flavor_creator.flavor_settings.name,
1462 port_settings=[port_settings])
1464 self.inst_creator = OpenStackVmInstance(
1465 self.os_creds, instance_settings,
1466 self.image_creator.image_settings)
1468 with self.assertRaises(InvalidIpForSubnetClient):
1469 self.inst_creator.create()
1471 def test_set_custom_valid_mac(self):
1473 Tests the creation of an OpenStack instance with a single port where
1474 the MAC address is assigned.
1476 mac_addr = '0a:1b:2c:3d:4e:5f'
1477 port_settings = PortConfig(
1478 name=self.port_1_name,
1479 network_name=self.net_config.network_settings.name,
1480 mac_address=mac_addr)
1482 instance_settings = VmInstanceConfig(
1483 name=self.vm_inst_name,
1484 flavor=self.flavor_creator.flavor_settings.name,
1485 port_settings=[port_settings])
1487 self.inst_creator = OpenStackVmInstance(
1488 self.os_creds, instance_settings,
1489 self.image_creator.image_settings)
1490 self.inst_creator.create(block=True)
1492 self.assertEqual(mac_addr,
1493 self.inst_creator.get_port_mac(self.port_1_name))
1495 def test_set_custom_invalid_mac(self):
1497 Tests the creation of an OpenStack instance with a single port where an
1498 invalid MAC address value is being
1499 assigned. This should raise an Exception
1501 port_settings = PortConfig(
1502 name=self.port_1_name,
1503 network_name=self.net_config.network_settings.name,
1506 instance_settings = VmInstanceConfig(
1507 name=self.vm_inst_name,
1508 flavor=self.flavor_creator.flavor_settings.name,
1509 port_settings=[port_settings])
1511 self.inst_creator = OpenStackVmInstance(
1512 self.os_creds, instance_settings,
1513 self.image_creator.image_settings)
1515 with self.assertRaises(Exception):
1516 self.inst_creator.create()
1518 def test_set_custom_mac_and_ip(self):
1520 Tests the creation of an OpenStack instance with a single port where
1521 the IP and MAC address is assigned.
1524 mac_addr = '0a:1b:2c:3d:4e:5f'
1525 sub_settings = self.net_config.network_settings.subnet_settings
1526 port_settings = PortConfig(
1527 name=self.port_1_name,
1528 network_name=self.net_config.network_settings.name,
1529 mac_address=mac_addr,
1530 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1532 instance_settings = VmInstanceConfig(
1533 name=self.vm_inst_name,
1534 flavor=self.flavor_creator.flavor_settings.name,
1535 port_settings=[port_settings])
1537 self.inst_creator = OpenStackVmInstance(
1538 self.os_creds, instance_settings,
1539 self.image_creator.image_settings)
1540 self.inst_creator.create(block=True)
1542 self.assertEqual(ip, self.inst_creator.get_port_ip(
1544 subnet_name=self.net_config.network_settings.subnet_settings[
1546 self.assertEqual(mac_addr,
1547 self.inst_creator.get_port_mac(self.port_1_name))
1549 def test_set_allowed_address_pairs(self):
1551 Tests the creation of an OpenStack instance with a single port where
1552 max_allowed_address_pair is set.
1555 mac_addr = '0a:1b:2c:3d:4e:5f'
1556 pair = {'ip_address': ip, 'mac_address': mac_addr}
1557 port_settings = PortConfig(
1558 name=self.port_1_name,
1559 network_name=self.net_config.network_settings.name,
1560 allowed_address_pairs=[pair])
1562 instance_settings = VmInstanceConfig(
1563 name=self.vm_inst_name,
1564 flavor=self.flavor_creator.flavor_settings.name,
1565 port_settings=[port_settings])
1567 self.inst_creator = OpenStackVmInstance(
1568 self.os_creds, instance_settings,
1569 self.image_creator.image_settings)
1570 self.inst_creator.create(block=True)
1572 port = self.inst_creator.get_port_by_name(port_settings.name)
1573 self.assertIsNotNone(port)
1574 self.assertIsNotNone(port.allowed_address_pairs)
1575 self.assertEqual(1, len(port.allowed_address_pairs))
1576 validation_utils.objects_equivalent(pair,
1577 port.allowed_address_pairs[0])
1579 def test_set_allowed_address_pairs_bad_mac(self):
1581 Tests the creation of an OpenStack instance with a single port where
1582 max_allowed_address_pair is set with an invalid MAC address.
1586 pair = {'ip_address': ip, 'mac_address': mac_addr}
1588 pairs.add((ip, mac_addr))
1589 port_settings = PortConfig(
1590 name=self.port_1_name,
1591 network_name=self.net_config.network_settings.name,
1592 allowed_address_pairs=[pair])
1594 instance_settings = VmInstanceConfig(
1595 name=self.vm_inst_name,
1596 flavor=self.flavor_creator.flavor_settings.name,
1597 port_settings=[port_settings])
1599 self.inst_creator = OpenStackVmInstance(
1600 self.os_creds, instance_settings,
1601 self.image_creator.image_settings)
1602 with self.assertRaises(Exception):
1603 self.inst_creator.create()
1605 def test_set_allowed_address_pairs_bad_ip(self):
1607 Tests the creation of an OpenStack instance with a single port where
1608 max_allowed_address_pair is set with an invalid MAC address.
1611 mac_addr = '0a:1b:2c:3d:4e:5f'
1612 pair = {'ip_address': ip, 'mac_address': mac_addr}
1614 pairs.add((ip, mac_addr))
1615 port_settings = PortConfig(
1616 name=self.port_1_name,
1617 network_name=self.net_config.network_settings.name,
1618 allowed_address_pairs=[pair])
1620 instance_settings = VmInstanceConfig(
1621 name=self.vm_inst_name,
1622 flavor=self.flavor_creator.flavor_settings.name,
1623 port_settings=[port_settings])
1625 self.inst_creator = OpenStackVmInstance(
1626 self.os_creds, instance_settings,
1627 self.image_creator.image_settings)
1628 with self.assertRaises(Exception):
1629 self.inst_creator.create()
1632 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1634 Test for the CreateInstance where one VM is deployed to each compute node
1639 Instantiates the CreateImage object that is responsible for downloading
1640 and creating an OS image file within OpenStack
1642 super(self.__class__, self).__start__()
1644 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1645 self.vm_inst_name = guid + '-inst'
1646 self.port_base_name = guid + 'port'
1648 # Initialize for tearDown()
1649 self.image_creator = None
1650 self.flavor_creator = None
1651 self.network_creator = None
1652 self.inst_creators = list()
1654 self.priv_net_config = openstack_tests.get_priv_net_config(
1655 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet',
1656 netconf_override=self.netconf_override)
1658 os_image_settings = openstack_tests.cirros_image_settings(
1659 name=guid + '-image', image_metadata=self.image_metadata)
1663 self.network_creator = OpenStackNetwork(
1664 self.admin_os_creds, self.priv_net_config.network_settings)
1665 self.network_creator.create()
1668 self.flavor_creator = OpenStackFlavor(
1669 self.admin_os_creds,
1670 FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
1671 vcpus=1, metadata=self.flavor_metadata))
1672 self.flavor_creator.create()
1675 self.image_creator = OpenStackImage(self.os_creds,
1677 self.image_creator.create()
1679 except Exception as e:
1685 Cleans the created object
1687 for inst_creator in self.inst_creators:
1689 inst_creator.clean()
1690 except Exception as e:
1692 'Unexpected exception cleaning VM instance with message '
1695 if self.flavor_creator:
1697 self.flavor_creator.clean()
1698 except Exception as e:
1700 'Unexpected exception cleaning flavor with message - %s',
1703 if self.network_creator:
1705 self.network_creator.clean()
1706 except Exception as e:
1708 'Unexpected exception cleaning network with message - %s',
1711 if self.image_creator and not self.image_creator.image_settings.exists:
1713 self.image_creator.clean()
1714 except Exception as e:
1716 'Unexpected exception cleaning image with message - %s', e)
1718 super(self.__class__, self).__clean__()
1720 def test_deploy_vm_to_each_compute_node(self):
1722 Tests the creation of OpenStack VM instances to each compute node.
1724 from snaps.openstack.utils import nova_utils
1725 nova = nova_utils.nova_client(
1726 self.admin_os_creds, self.admin_os_session)
1727 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1729 # Create Instance on each server/zone
1731 for zone in zone_hosts:
1732 inst_name = self.vm_inst_name + '-' + zone
1734 port_settings = PortConfig(
1735 name=self.port_base_name + '-' + str(ctr),
1736 network_name=self.priv_net_config.network_settings.name)
1738 instance_settings = VmInstanceConfig(
1740 flavor=self.flavor_creator.flavor_settings.name,
1741 availability_zone=zone,
1742 port_settings=[port_settings])
1743 inst_creator = OpenStackVmInstance(
1744 self.admin_os_creds, instance_settings,
1745 self.image_creator.image_settings)
1746 self.inst_creators.append(inst_creator)
1747 inst_creator.create(block=True)
1748 avail_zone = inst_creator.get_vm_inst().availability_zone
1749 self.assertTrue(avail_zone in zone)
1750 compute_host = inst_creator.get_vm_inst().compute_host
1751 self.assertTrue(compute_host in zone)
1753 # Validate instances to ensure they've been deployed to the correct
1756 for zone in zone_hosts:
1757 creator = self.inst_creators[index]
1758 self.assertTrue(creator.vm_active(block=True))
1759 info = creator.get_vm_info()
1760 deployed_zone = info['OS-EXT-AZ:availability_zone']
1761 deployed_host = info['OS-EXT-SRV-ATTR:host']
1762 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1766 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1768 Tests that include, add, and remove security groups from VM instances
1773 Instantiates the CreateImage object that is responsible for downloading
1774 and creating an OS image file within OpenStack
1776 super(self.__class__, self).__start__()
1778 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1779 self.vm_inst_name = self.guid + '-inst'
1780 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
1781 os_image_settings = openstack_tests.cirros_image_settings(
1782 name=self.guid + '-image', image_metadata=self.image_metadata)
1784 self.vm_inst_name = self.guid + '-inst'
1785 self.port_1_name = self.guid + 'port-1'
1786 self.port_2_name = self.guid + 'port-2'
1787 self.floating_ip_name = self.guid + 'fip1'
1789 net_config = openstack_tests.get_priv_net_config(
1790 net_name=self.guid + '-pub-net',
1791 subnet_name=self.guid + '-pub-subnet',
1792 router_name=self.guid + '-pub-router',
1793 external_net=self.ext_net_name,
1794 netconf_override=self.netconf_override)
1796 # Initialize for tearDown()
1797 self.image_creator = None
1798 self.flavor_creator = None
1799 self.network_creator = None
1800 self.router_creator = None
1801 self.inst_creator = None
1802 self.sec_grp_creators = list()
1806 self.image_creator = OpenStackImage(self.os_creds,
1808 self.image_creator.create()
1811 self.network_creator = OpenStackNetwork(
1812 self.os_creds, net_config.network_settings)
1813 self.network_creator.create()
1816 self.flavor_creator = OpenStackFlavor(
1817 self.admin_os_creds,
1818 FlavorConfig(name=self.guid + '-flavor-name', ram=256,
1820 metadata=self.flavor_metadata))
1821 self.flavor_creator.create()
1823 self.port_settings = PortConfig(
1824 name=self.guid + '-port',
1825 network_name=net_config.network_settings.name)
1826 except Exception as e:
1832 Cleans the created object
1834 if self.inst_creator:
1836 self.inst_creator.clean()
1837 except Exception as e:
1839 'Unexpected exception cleaning VM instance with message -'
1842 for sec_grp_creator in self.sec_grp_creators:
1844 sec_grp_creator.clean()
1845 except Exception as e:
1847 'Unexpected exception cleaning security group with message'
1850 if self.flavor_creator:
1852 self.flavor_creator.clean()
1853 except Exception as e:
1855 'Unexpected exception cleaning flavor with message - %s',
1858 if self.network_creator:
1860 self.network_creator.clean()
1861 except Exception as e:
1863 'Unexpected exception cleaning network with message - %s',
1866 if self.image_creator and not self.image_creator.image_settings.exists:
1868 self.image_creator.clean()
1869 except Exception as e:
1871 'Unexpected exception cleaning image with message - %s', e)
1873 super(self.__class__, self).__clean__()
1875 def test_add_security_group(self):
1877 Tests the addition of a security group created after the instance.
1880 instance_settings = VmInstanceConfig(
1881 name=self.vm_inst_name,
1882 flavor=self.flavor_creator.flavor_settings.name,
1883 port_settings=[self.port_settings])
1884 self.inst_creator = OpenStackVmInstance(
1885 self.os_creds, instance_settings,
1886 self.image_creator.image_settings)
1887 vm_inst = self.inst_creator.create(block=True)
1888 self.assertIsNotNone(vm_inst)
1890 # Create security group object to add to instance
1891 sec_grp_settings = SecurityGroupConfig(
1892 name=self.guid + '-name', description='hello group')
1893 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1895 sec_grp = sec_grp_creator.create()
1896 self.sec_grp_creators.append(sec_grp_creator)
1898 # Check that group has not been added
1899 self.assertFalse(inst_has_sec_grp(
1900 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1902 # Add security group to instance after activated
1903 self.inst_creator.add_security_group(sec_grp)
1905 # Validate that security group has been added
1906 self.assertTrue(inst_has_sec_grp(
1907 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1909 def test_add_invalid_security_group(self):
1911 Tests the addition of a security group that no longer exists.
1914 instance_settings = VmInstanceConfig(
1915 name=self.vm_inst_name,
1916 flavor=self.flavor_creator.flavor_settings.name,
1917 port_settings=[self.port_settings])
1918 self.inst_creator = OpenStackVmInstance(
1919 self.os_creds, instance_settings,
1920 self.image_creator.image_settings)
1921 vm_inst = self.inst_creator.create(block=True)
1922 self.assertIsNotNone(vm_inst)
1924 # Create security group object to add to instance
1925 sec_grp_settings = SecurityGroupConfig(
1926 name=self.guid + '-name', description='hello group')
1927 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1929 sec_grp = sec_grp_creator.create()
1930 sec_grp_creator.clean()
1931 self.sec_grp_creators.append(sec_grp_creator)
1933 # Check that group has not been added
1934 self.assertFalse(inst_has_sec_grp(
1935 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1937 # Add security group to instance after activated
1938 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1940 # Validate that security group has been added
1941 self.assertFalse(inst_has_sec_grp(
1942 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1944 def test_remove_security_group(self):
1946 Tests the removal of a security group created before and added to the
1949 # Create security group object to add to instance
1950 sec_grp_settings = SecurityGroupConfig(
1951 name=self.guid + '-name', description='hello group')
1952 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1954 sec_grp = sec_grp_creator.create()
1955 self.sec_grp_creators.append(sec_grp_creator)
1958 instance_settings = VmInstanceConfig(
1959 name=self.vm_inst_name,
1960 flavor=self.flavor_creator.flavor_settings.name,
1961 security_group_names=[sec_grp_settings.name],
1962 port_settings=[self.port_settings])
1963 self.inst_creator = OpenStackVmInstance(
1964 self.os_creds, instance_settings,
1965 self.image_creator.image_settings)
1966 vm_inst = self.inst_creator.create(block=True)
1967 self.assertIsNotNone(vm_inst)
1969 # Check that group has been added
1970 self.assertTrue(inst_has_sec_grp(
1971 self.nova, vm_inst, sec_grp_settings.name))
1973 # Add security group to instance after activated
1974 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1976 # Validate that security group has been added
1977 self.assertFalse(inst_has_sec_grp(
1978 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1980 def test_remove_security_group_never_added(self):
1982 Tests the removal of a security group that was never added in the first
1985 # Create security group object to add to instance
1986 sec_grp_settings = SecurityGroupConfig(
1987 name=self.guid + '-name', description='hello group')
1988 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1990 sec_grp = sec_grp_creator.create()
1991 self.sec_grp_creators.append(sec_grp_creator)
1994 instance_settings = VmInstanceConfig(
1995 name=self.vm_inst_name,
1996 flavor=self.flavor_creator.flavor_settings.name,
1997 port_settings=[self.port_settings])
1998 self.inst_creator = OpenStackVmInstance(
1999 self.os_creds, instance_settings,
2000 self.image_creator.image_settings)
2001 vm_inst = self.inst_creator.create(block=True)
2002 self.assertIsNotNone(vm_inst)
2004 # Check that group has been added
2005 self.assertFalse(inst_has_sec_grp(
2006 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2008 # Add security group to instance after activated
2009 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
2011 # Validate that security group has been added
2012 self.assertFalse(inst_has_sec_grp(
2013 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2015 def test_add_same_security_group(self):
2017 Tests the addition of a security group created before add added to the
2020 # Create security group object to add to instance
2021 sec_grp_settings = SecurityGroupConfig(
2022 name=self.guid + '-name', description='hello group')
2023 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
2025 sec_grp = sec_grp_creator.create()
2026 self.sec_grp_creators.append(sec_grp_creator)
2029 instance_settings = VmInstanceConfig(
2030 name=self.vm_inst_name,
2031 flavor=self.flavor_creator.flavor_settings.name,
2032 security_group_names=[sec_grp_settings.name],
2033 port_settings=[self.port_settings])
2034 self.inst_creator = OpenStackVmInstance(
2035 self.os_creds, instance_settings,
2036 self.image_creator.image_settings)
2037 vm_inst = self.inst_creator.create(block=True)
2038 self.assertIsNotNone(vm_inst)
2040 # Check that group has been added
2041 self.assertTrue(inst_has_sec_grp(
2042 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2044 # Add security group to instance after activated
2045 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
2047 # Validate that security group has been added
2048 self.assertTrue(inst_has_sec_grp(
2049 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2052 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
2054 Returns true if instance has a security group of a given name
2055 :param nova: the nova client
2056 :param vm_inst: the VmInst domain object
2057 :param sec_grp_name: the name of the security group to validate
2060 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
2061 for name in sec_grp_names:
2062 if sec_grp_name == name:
2067 def validate_ssh_client(instance_creator, fip_name=None):
2069 Returns True if instance_creator returns an SSH client that is valid
2070 :param instance_creator: the object responsible for creating the VM
2072 :param fip_name: the name of the floating IP to use
2075 ssh_active = instance_creator.vm_ssh_active(block=True)
2078 ssh_client = instance_creator.ssh_client(fip_name=fip_name)
2081 out = ssh_client.exec_command('pwd')[1]
2082 channel = out.channel
2083 in_buffer = channel.in_buffer
2084 pwd_out = in_buffer.read(1024)
2085 if not pwd_out or len(pwd_out) < 10:
2096 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
2098 Test for the CreateInstance class for creating an image from a 3-part image
2103 Instantiates the CreateImage object that is responsible for downloading
2104 and creating an OS image file within OpenStack
2106 super(self.__class__, self).__start__()
2108 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2109 self.image_name = guid
2110 self.vm_inst_name = guid + '-inst'
2111 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
2113 net_config = openstack_tests.get_priv_net_config(
2114 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2115 router_name=guid + '-pub-router', external_net=self.ext_net_name,
2116 netconf_override=self.netconf_override)
2118 # Initialize for tearDown()
2119 self.image_creator = None
2120 self.network_creator = None
2121 self.flavor_creator = None
2122 self.inst_creator = None
2125 if self.image_metadata and 'disk_file' in self.image_metadata:
2126 metadata = self.image_metadata
2127 elif self.image_metadata and 'cirros' in self.image_metadata \
2128 and 'disk_file' in self.image_metadata['cirros']:
2129 metadata = self.image_metadata['cirros']
2132 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
2134 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
2136 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
2138 image_settings = openstack_tests.cirros_image_settings(
2139 name=self.image_name,
2140 image_metadata=metadata)
2142 if not image_settings.ramdisk_image_settings or not \
2143 image_settings.kernel_image_settings:
2145 '3 Part image will not be tested. Image metadata has '
2146 'overridden this functionality')
2148 self.image_creator = OpenStackImage(self.os_creds, image_settings)
2149 self.image_creator.create()
2152 self.flavor_creator = OpenStackFlavor(
2153 self.admin_os_creds,
2154 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
2155 vcpus=2, metadata=self.flavor_metadata))
2156 self.flavor_creator.create()
2159 self.network_creator = OpenStackNetwork(
2160 self.os_creds, net_config.network_settings)
2161 self.network_creator.create()
2163 self.port_settings = PortConfig(
2164 name=guid + '-port',
2165 network_name=net_config.network_settings.name)
2166 except Exception as e:
2172 Cleans the created object
2174 if self.inst_creator:
2176 self.inst_creator.clean()
2177 except Exception as e:
2179 'Unexpected exception cleaning VM instance with message -'
2182 if self.flavor_creator:
2184 self.flavor_creator.clean()
2185 except Exception as e:
2187 'Unexpected exception cleaning flavor with message - %s',
2190 if self.network_creator:
2192 self.network_creator.clean()
2193 except Exception as e:
2195 'Unexpected exception cleaning network with message - %s',
2198 if self.image_creator and not self.image_creator.image_settings.exists:
2200 self.image_creator.clean()
2201 except Exception as e:
2203 'Unexpected exception cleaning image with message - %s', e)
2205 super(self.__class__, self).__clean__()
2207 def test_create_instance_from_three_part_image(self):
2209 Tests the creation of an OpenStack instance from a 3-part image.
2211 instance_settings = VmInstanceConfig(
2212 name=self.vm_inst_name,
2213 flavor=self.flavor_creator.flavor_settings.name,
2214 port_settings=[self.port_settings])
2216 # The last created image is the main image from which we create the
2218 self.inst_creator = OpenStackVmInstance(
2219 self.os_creds, instance_settings,
2220 self.image_creator.image_settings)
2222 vm_inst = self.inst_creator.create()
2223 self.assertIsNotNone(vm_inst)
2224 self.assertTrue(self.inst_creator.vm_active(block=True))
2227 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2229 Tests the custom image_metadata that can be set by clients for handling
2230 images differently than the default behavior of the existing tests
2231 primarily for offline testing
2236 Instantiates the CreateImage object that is responsible for downloading
2237 and creating an OS image file within OpenStack
2239 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2241 self.tmpDir = 'tmp/' + str(self.guid)
2242 if not os.path.exists(self.tmpDir):
2243 os.makedirs(self.tmpDir)
2245 self.image_name = self.guid + '-image'
2246 self.vm_inst_name = self.guid + '-inst'
2247 self.port_1_name = self.guid + 'port-1'
2249 # Initialize for tearDown()
2250 self.image_creator = None
2251 self.network_creator = None
2252 self.flavor_creator = None
2253 self.inst_creator = None
2255 self.priv_net_config = openstack_tests.get_priv_net_config(
2256 net_name=self.guid + '-priv-net',
2257 subnet_name=self.guid + '-priv-subnet')
2258 self.port_settings = PortConfig(
2259 name=self.port_1_name,
2260 network_name=self.priv_net_config.network_settings.name)
2263 # Download image file
2264 self.image_file = file_utils.download(
2265 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2268 self.network_creator = OpenStackNetwork(
2269 self.os_creds, self.priv_net_config.network_settings)
2270 self.network_creator.create()
2273 self.flavor_creator = OpenStackFlavor(
2276 name=self.guid + '-flavor-name', ram=256, disk=10,
2278 self.flavor_creator.create()
2279 except Exception as e:
2285 Cleans the created object
2287 if self.inst_creator:
2289 self.inst_creator.clean()
2290 except Exception as e:
2292 'Unexpected exception cleaning VM instance with message - '
2295 if self.network_creator:
2297 self.network_creator.clean()
2298 except Exception as e:
2300 'Unexpected exception cleaning network with message - %s',
2303 if self.flavor_creator:
2305 self.flavor_creator.clean()
2306 except Exception as e:
2308 'Unexpected exception cleaning flavor with message - %s',
2311 if self.image_creator:
2313 self.image_creator.clean()
2314 except Exception as e:
2316 'Unexpected exception cleaning image with message - %s', e)
2318 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2319 shutil.rmtree(self.tmpDir)
2321 super(self.__class__, self).__clean__()
2323 def test_inst_from_file_image_simple_flat(self):
2325 Creates a VM instance from a locally sourced file image using simply
2326 the 'disk_file' attribute vs. using the 'config' option which
2327 completely overrides all image settings
2330 metadata = {'disk_file': self.image_file.name}
2332 os_image_settings = openstack_tests.cirros_image_settings(
2333 name=self.image_name, image_metadata=metadata)
2334 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2335 self.assertEqual(openstack_tests.CIRROS_USER,
2336 os_image_settings.image_user)
2337 self.assertIsNone(os_image_settings.url)
2338 self.assertFalse(os_image_settings.exists)
2339 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2340 os_image_settings.format)
2342 self.assertIsNone(os_image_settings.kernel_image_settings)
2343 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2345 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2346 self.image_creator.create()
2348 instance_settings = VmInstanceConfig(
2349 name=self.vm_inst_name,
2350 flavor=self.flavor_creator.flavor_settings.name,
2351 port_settings=[self.port_settings])
2352 self.inst_creator = OpenStackVmInstance(
2353 self.os_creds, instance_settings,
2354 self.image_creator.image_settings)
2355 self.inst_creator.create()
2357 self.assertTrue(self.inst_creator.vm_active(block=True))
2359 def test_inst_from_file_image_simple_nested(self):
2361 Creates a VM instance from a locally sourced file image using simply
2362 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2363 which completely overrides all image settings
2366 metadata = {'cirros': {'disk_file': self.image_file.name}}
2368 os_image_settings = openstack_tests.cirros_image_settings(
2369 name=self.image_name, image_metadata=metadata)
2370 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2371 self.assertEqual(openstack_tests.CIRROS_USER,
2372 os_image_settings.image_user)
2373 self.assertIsNone(os_image_settings.url)
2374 self.assertFalse(os_image_settings.exists)
2375 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2376 os_image_settings.format)
2378 self.assertIsNone(os_image_settings.kernel_image_settings)
2379 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2381 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2382 self.image_creator.create()
2384 instance_settings = VmInstanceConfig(
2385 name=self.vm_inst_name,
2386 flavor=self.flavor_creator.flavor_settings.name,
2387 port_settings=[self.port_settings])
2388 self.inst_creator = OpenStackVmInstance(
2389 self.os_creds, instance_settings,
2390 self.image_creator.image_settings)
2391 self.inst_creator.create()
2393 self.assertTrue(self.inst_creator.vm_active(block=True))
2395 def test_inst_from_existing(self):
2397 Creates a VM instance from a image creator that has been configured to
2398 use an existing image
2401 os_image_settings = openstack_tests.cirros_image_settings(
2402 name=self.image_name)
2403 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2404 self.image_creator.create()
2406 image_settings = self.image_creator.image_settings
2407 test_image_creator = OpenStackImage(
2410 name=image_settings.name, image_user=image_settings.image_user,
2412 test_image_creator.create()
2413 self.assertEqual(self.image_creator.get_image().id,
2414 test_image_creator.get_image().id)
2416 instance_settings = VmInstanceConfig(
2417 name=self.vm_inst_name,
2418 flavor=self.flavor_creator.flavor_settings.name,
2419 port_settings=[self.port_settings])
2420 self.inst_creator = OpenStackVmInstance(
2421 self.os_creds, instance_settings,
2422 test_image_creator.image_settings)
2423 self.inst_creator.create()
2425 self.assertTrue(self.inst_creator.vm_active(block=True))
2427 def test_inst_from_file_image_complex(self):
2429 Creates a VM instance from a locally sourced file image by overriding
2430 the default settings by using a dict() that can be read in by
2435 os_image_settings = openstack_tests.cirros_image_settings(
2436 name=self.image_name)
2437 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2438 self.image_creator.create()
2443 'name': os_image_settings.name,
2444 'image_user': os_image_settings.image_user,
2446 test_image_settings = openstack_tests.cirros_image_settings(
2447 image_metadata=metadata)
2448 test_image = OpenStackImage(self.os_creds, test_image_settings)
2451 instance_settings = VmInstanceConfig(
2452 name=self.vm_inst_name,
2453 flavor=self.flavor_creator.flavor_settings.name,
2454 port_settings=[self.port_settings])
2455 self.inst_creator = OpenStackVmInstance(self.os_creds,
2457 test_image_settings)
2458 self.inst_creator.create()
2460 self.assertTrue(self.inst_creator.vm_active(block=True))
2462 def test_inst_from_file_3part_image_complex(self):
2464 Creates a VM instance from a locally sourced file image by overriding
2465 the default settings by using a dict() that can be read in by
2470 kernel_file = file_utils.download(
2471 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2472 ramdisk_file = file_utils.download(
2473 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2478 'name': self.image_name,
2479 'image_user': openstack_tests.CIRROS_USER,
2480 'image_file': self.image_file.name,
2481 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2482 'kernel_image_settings': {
2483 'name': self.image_name + '-kernel',
2484 'image_user': openstack_tests.CIRROS_USER,
2485 'image_file': kernel_file.name,
2486 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2487 'ramdisk_image_settings': {
2488 'name': self.image_name + '-ramdisk',
2489 'image_user': openstack_tests.CIRROS_USER,
2490 'image_file': ramdisk_file.name,
2491 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2493 os_image_settings = openstack_tests.cirros_image_settings(
2494 name=self.image_name, image_metadata=metadata)
2495 self.assertEqual(self.image_name, os_image_settings.name)
2496 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2497 self.assertEqual(openstack_tests.CIRROS_USER,
2498 os_image_settings.image_user)
2499 self.assertIsNone(os_image_settings.url)
2500 self.assertFalse(os_image_settings.exists)
2501 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2502 os_image_settings.format)
2504 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2505 self.assertEqual(self.image_name + '-kernel',
2506 os_image_settings.kernel_image_settings.name)
2507 self.assertEqual(kernel_file.name,
2508 os_image_settings.kernel_image_settings.image_file)
2509 self.assertEqual(openstack_tests.CIRROS_USER,
2510 os_image_settings.kernel_image_settings.image_user)
2511 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2512 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2513 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2514 os_image_settings.kernel_image_settings.format)
2516 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2517 self.assertEqual(self.image_name + '-ramdisk',
2518 os_image_settings.ramdisk_image_settings.name)
2519 self.assertEqual(ramdisk_file.name,
2520 os_image_settings.ramdisk_image_settings.image_file)
2521 self.assertEqual(openstack_tests.CIRROS_USER,
2522 os_image_settings.ramdisk_image_settings.image_user)
2523 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2524 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2525 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2526 os_image_settings.ramdisk_image_settings.format)
2528 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2529 self.image_creator.create()
2531 instance_settings = VmInstanceConfig(
2532 name=self.vm_inst_name,
2533 flavor=self.flavor_creator.flavor_settings.name,
2534 port_settings=[self.port_settings])
2535 self.inst_creator = OpenStackVmInstance(
2536 self.os_creds, instance_settings,
2537 self.image_creator.image_settings)
2538 self.inst_creator.create()
2540 self.assertTrue(self.inst_creator.vm_active(block=True))
2542 def test_inst_from_file_3part_image_simple_flat(self):
2544 Creates a VM instance from a 3-part image locally sourced from file
2545 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2546 attributes vs. using the 'config' option which completely overrides all
2550 kernel_file = file_utils.download(
2551 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2552 ramdisk_file = file_utils.download(
2553 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2555 metadata = {'disk_file': self.image_file.name,
2556 'kernel_file': kernel_file.name,
2557 'ramdisk_file': ramdisk_file.name}
2559 os_image_settings = openstack_tests.cirros_image_settings(
2560 name=self.image_name, image_metadata=metadata)
2562 self.assertEqual(self.image_name, os_image_settings.name)
2563 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2564 self.assertEqual(openstack_tests.CIRROS_USER,
2565 os_image_settings.image_user)
2566 self.assertIsNone(os_image_settings.url)
2567 self.assertFalse(os_image_settings.exists)
2568 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2569 os_image_settings.format)
2571 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2572 self.assertEqual(self.image_name + '-kernel',
2573 os_image_settings.kernel_image_settings.name)
2574 self.assertEqual(kernel_file.name,
2575 os_image_settings.kernel_image_settings.image_file)
2576 self.assertEqual(openstack_tests.CIRROS_USER,
2577 os_image_settings.kernel_image_settings.image_user)
2578 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2579 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2580 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2581 os_image_settings.kernel_image_settings.format)
2583 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2584 self.assertEqual(self.image_name + '-ramdisk',
2585 os_image_settings.ramdisk_image_settings.name)
2586 self.assertEqual(ramdisk_file.name,
2587 os_image_settings.ramdisk_image_settings.image_file)
2588 self.assertEqual(openstack_tests.CIRROS_USER,
2589 os_image_settings.ramdisk_image_settings.image_user)
2590 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2591 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2592 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2593 os_image_settings.ramdisk_image_settings.format)
2595 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2596 self.image_creator.create()
2598 self.assertIsNotNone(self.image_creator.get_kernel_image())
2599 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2601 instance_settings = VmInstanceConfig(
2602 name=self.vm_inst_name,
2603 flavor=self.flavor_creator.flavor_settings.name,
2604 port_settings=[self.port_settings])
2605 self.inst_creator = OpenStackVmInstance(
2606 self.os_creds, instance_settings,
2607 self.image_creator.image_settings)
2608 self.inst_creator.create()
2610 self.assertTrue(self.inst_creator.vm_active(block=True))
2612 def test_inst_from_file_3part_image_simple_nested(self):
2614 Creates a VM instance from a 3-part image locally sourced from file
2615 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2616 attributes under 'cirros' vs. using the 'config' option which
2617 completely overrides all image settings
2620 kernel_file = file_utils.download(
2621 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2622 ramdisk_file = file_utils.download(
2623 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2625 metadata = {'cirros': {'disk_file': self.image_file.name,
2626 'kernel_file': kernel_file.name,
2627 'ramdisk_file': ramdisk_file.name}}
2629 os_image_settings = openstack_tests.cirros_image_settings(
2630 name=self.image_name, image_metadata=metadata)
2632 self.assertEqual(self.image_name, os_image_settings.name)
2633 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2634 self.assertEqual(openstack_tests.CIRROS_USER,
2635 os_image_settings.image_user)
2636 self.assertIsNone(os_image_settings.url)
2637 self.assertFalse(os_image_settings.exists)
2638 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2639 os_image_settings.format)
2641 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2642 self.assertEqual(self.image_name + '-kernel',
2643 os_image_settings.kernel_image_settings.name)
2644 self.assertEqual(kernel_file.name,
2645 os_image_settings.kernel_image_settings.image_file)
2646 self.assertEqual(openstack_tests.CIRROS_USER,
2647 os_image_settings.kernel_image_settings.image_user)
2648 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2649 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2650 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2651 os_image_settings.kernel_image_settings.format)
2653 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2654 self.assertEqual(self.image_name + '-ramdisk',
2655 os_image_settings.ramdisk_image_settings.name)
2656 self.assertEqual(ramdisk_file.name,
2657 os_image_settings.ramdisk_image_settings.image_file)
2658 self.assertEqual(openstack_tests.CIRROS_USER,
2659 os_image_settings.ramdisk_image_settings.image_user)
2660 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2661 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2662 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2663 os_image_settings.ramdisk_image_settings.format)
2665 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2666 self.image_creator.create()
2668 self.assertIsNotNone(self.image_creator.get_kernel_image())
2669 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2671 instance_settings = VmInstanceConfig(
2672 name=self.vm_inst_name,
2673 flavor=self.flavor_creator.flavor_settings.name,
2674 port_settings=[self.port_settings])
2675 self.inst_creator = OpenStackVmInstance(
2676 self.os_creds, instance_settings,
2677 self.image_creator.image_settings)
2678 self.inst_creator.create()
2680 self.assertTrue(self.inst_creator.vm_active(block=True))
2682 def test_inst_from_file_3part_image_existing(self):
2684 Creates a VM instance from a 3-part image that is existing
2687 kernel_file = file_utils.download(
2688 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2689 ramdisk_file = file_utils.download(
2690 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2692 metadata = {'cirros': {'disk_file': self.image_file.name,
2693 'kernel_file': kernel_file.name,
2694 'ramdisk_file': ramdisk_file.name}}
2696 os_image_settings = openstack_tests.cirros_image_settings(
2697 name=self.image_name, image_metadata=metadata)
2698 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2699 self.image_creator.create()
2701 image_settings = self.image_creator.image_settings
2702 test_image_creator = OpenStackImage(
2705 name=image_settings.name, image_user=image_settings.image_user,
2707 test_image_creator.create()
2708 self.assertEqual(self.image_creator.get_image().id,
2709 test_image_creator.get_image().id)
2711 instance_settings = VmInstanceConfig(
2712 name=self.vm_inst_name,
2713 flavor=self.flavor_creator.flavor_settings.name,
2714 port_settings=[self.port_settings])
2715 self.inst_creator = OpenStackVmInstance(
2716 self.os_creds, instance_settings,
2717 test_image_creator.image_settings)
2718 self.inst_creator.create()
2720 self.assertTrue(self.inst_creator.vm_active(block=True))
2723 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2725 Tests the ability of two VMs to communicate when attached to separate
2726 private networks that are tied together with a router.
2731 Instantiates the CreateImage object that is responsible for downloading
2732 and creating an OS image file within OpenStack
2734 super(self.__class__, self).__start__()
2736 cidr1 = '10.200.201.0/24'
2737 cidr2 = '10.200.202.0/24'
2738 static_gateway_ip1 = '10.200.201.1'
2739 static_gateway_ip2 = '10.200.202.1'
2740 self.ip1 = '10.200.201.5'
2741 self.ip2 = '10.200.202.5'
2743 self.nova = nova_utils.nova_client(self.os_creds, self.os_session)
2745 # Initialize for tearDown()
2746 self.image_creator = None
2747 self.network_creators = list()
2748 self.router_creator = None
2749 self.flavor_creator = None
2750 self.sec_grp_creator = None
2751 self.inst_creators = list()
2753 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2754 self.vm_inst1_name = self.guid + '-inst1'
2755 self.vm_inst2_name = self.guid + '-inst2'
2756 self.port_1_name = self.guid + '-vm1-port'
2757 self.port_2_name = self.guid + '-vm2-port'
2758 self.net_config_1 = NetworkConfig(
2759 name=self.guid + '-net1',
2761 create_network.SubnetConfig(
2762 cidr=cidr1, name=self.guid + '-subnet1',
2763 gateway_ip=static_gateway_ip1)])
2764 self.net_config_2 = NetworkConfig(
2765 name=self.guid + '-net2',
2767 create_network.SubnetConfig(
2768 cidr=cidr2, name=self.guid + '-subnet2',
2769 gateway_ip=static_gateway_ip2)])
2771 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2772 os_image_settings = openstack_tests.cirros_image_settings(
2773 name=image_name, image_metadata=self.image_metadata)
2777 self.image_creator = OpenStackImage(
2778 self.os_creds, os_image_settings)
2779 self.image_creator.create()
2781 # First network is public
2782 self.network_creators.append(OpenStackNetwork(
2783 self.os_creds, self.net_config_1))
2785 # Second network is private
2786 self.network_creators.append(OpenStackNetwork(
2787 self.os_creds, self.net_config_2))
2788 for network_creator in self.network_creators:
2789 network_creator.create()
2793 name=self.guid + '-router-port1',
2796 self.net_config_1.subnet_settings[0].name,
2797 'ip': static_gateway_ip1
2799 network_name=self.net_config_1.name),
2801 name=self.guid + '-router-port2',
2804 self.net_config_2.subnet_settings[0].name,
2805 'ip': static_gateway_ip2
2807 network_name=self.net_config_2.name)]
2809 router_settings = RouterConfig(
2810 name=self.guid + '-pub-router', port_settings=port_settings)
2811 self.router_creator = OpenStackRouter(
2812 self.os_creds, router_settings)
2813 self.router_creator.create()
2815 self.flavor_creator = OpenStackFlavor(
2816 self.admin_os_creds,
2817 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
2819 metadata=self.flavor_metadata))
2820 self.flavor_creator.create()
2822 sec_grp_name = self.guid + '-sec-grp'
2823 rule1 = SecurityGroupRuleConfig(
2824 sec_grp_name=sec_grp_name, direction=Direction.ingress,
2825 protocol=Protocol.icmp)
2826 self.sec_grp_creator = OpenStackSecurityGroup(
2828 SecurityGroupConfig(
2829 name=sec_grp_name, rule_settings=[rule1]))
2830 self.sec_grp_creator.create()
2837 Cleans the created objects
2839 for inst_creator in self.inst_creators:
2841 inst_creator.clean()
2842 except Exception as e:
2844 'Unexpected exception cleaning VM instance with message '
2847 if self.flavor_creator:
2849 self.flavor_creator.clean()
2850 except Exception as e:
2852 'Unexpected exception cleaning flavor with message - %s',
2855 if self.router_creator:
2857 self.router_creator.clean()
2858 except Exception as e:
2860 'Unexpected exception cleaning router with message - %s',
2863 for network_creator in self.network_creators:
2865 network_creator.clean()
2866 except Exception as e:
2868 'Unexpected exception cleaning network with message - %s',
2871 if self.sec_grp_creator:
2873 self.sec_grp_creator.clean()
2874 except Exception as e:
2876 'Unexpected exception cleaning security group with message'
2879 if self.image_creator and not self.image_creator.image_settings.exists:
2881 self.image_creator.clean()
2882 except Exception as e:
2884 'Unexpected exception cleaning image with message - %s', e)
2886 super(self.__class__, self).__clean__()
2888 def test_ping_via_router(self):
2890 Tests the creation of two OpenStack instances with one port on
2891 different private networks wit a router in between to ensure that they
2895 # Create ports/NICs for instance
2898 for network_creator in self.network_creators:
2899 ports_settings.append(PortConfig(
2900 name=self.guid + '-port-' + str(ctr),
2901 network_name=network_creator.network_settings.name))
2904 # Configure instances
2905 instance1_settings = VmInstanceConfig(
2906 name=self.vm_inst1_name,
2907 flavor=self.flavor_creator.flavor_settings.name,
2908 userdata=_get_ping_userdata(self.ip2),
2909 port_settings=[PortConfig(
2910 name=self.port_1_name,
2913 self.net_config_1.subnet_settings[0].name,
2916 network_name=self.network_creators[0].network_settings.name)])
2917 instance2_settings = VmInstanceConfig(
2918 name=self.vm_inst2_name,
2919 flavor=self.flavor_creator.flavor_settings.name,
2920 userdata=_get_ping_userdata(self.ip1),
2921 port_settings=[PortConfig(
2922 name=self.port_2_name,
2925 self.net_config_2.subnet_settings[0].name,
2928 network_name=self.network_creators[1].network_settings.name)])
2931 self.inst_creators.append(OpenStackVmInstance(
2932 self.os_creds, instance1_settings,
2933 self.image_creator.image_settings))
2934 self.inst_creators.append(OpenStackVmInstance(
2935 self.os_creds, instance2_settings,
2936 self.image_creator.image_settings))
2938 for inst_creator in self.inst_creators:
2939 inst_creator.create(block=True)
2941 # Check for DHCP lease
2942 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2943 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2945 # Effectively blocks until VM has been properly activated
2946 self.assertTrue(check_ping(self.inst_creators[0]))
2947 self.assertTrue(check_ping(self.inst_creators[1]))
2950 class CreateInstanceVolumeTests(OSIntegrationTestCase):
2952 Simple instance creation with an attached volume
2957 Instantiates the CreateImage object that is responsible for downloading
2958 and creating an OS image file
2961 super(self.__class__, self).__start__()
2963 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2964 self.vm_inst_name = guid + '-inst'
2965 self.nova = nova_utils.nova_client(
2966 self.os_creds, self.os_session)
2967 self.neutron = neutron_utils.neutron_client(
2968 self.os_creds, self.os_session)
2969 os_image_settings = openstack_tests.cirros_image_settings(
2970 name=guid + '-image', image_metadata=self.image_metadata)
2972 net_config = openstack_tests.get_priv_net_config(
2973 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2974 router_name=guid + '-pub-router', external_net=self.ext_net_name,
2975 netconf_override=self.netconf_override)
2977 self.volume_settings1 = VolumeConfig(
2978 name=self.__class__.__name__ + '-' + str(guid) + '-1')
2979 self.volume_settings2 = VolumeConfig(
2980 name=self.__class__.__name__ + '-' + str(guid) + '-2')
2982 # Initialize for tearDown()
2983 self.image_creator = None
2984 self.flavor_creator = None
2986 self.network_creator = None
2987 self.inst_creator = None
2988 self.volume_creator1 = None
2989 self.volume_creator2 = None
2993 self.image_creator = OpenStackImage(self.os_creds,
2995 self.image_creator.create()
2998 self.flavor_creator = OpenStackFlavor(
2999 self.admin_os_creds,
3000 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
3001 vcpus=2, metadata=self.flavor_metadata))
3002 self.flavor_creator.create()
3005 self.network_creator = OpenStackNetwork(
3006 self.os_creds, net_config.network_settings)
3007 self.network_creator.create()
3009 self.port_settings = PortConfig(
3010 name=guid + '-port',
3011 network_name=net_config.network_settings.name)
3013 self.volume_creator1 = OpenStackVolume(
3014 self.os_creds, self.volume_settings1)
3015 self.volume_creator1.create(block=True)
3017 self.volume_creator2 = OpenStackVolume(
3018 self.os_creds, self.volume_settings2)
3019 self.volume_creator2.create(block=True)
3021 except Exception as e:
3027 Cleans the created object
3029 if self.inst_creator:
3031 self.inst_creator.clean()
3032 except Exception as e:
3034 'Unexpected exception cleaning VM instance with message '
3037 if self.flavor_creator:
3039 self.flavor_creator.clean()
3040 except Exception as e:
3042 'Unexpected exception cleaning flavor with message - %s',
3045 if self.network_creator:
3047 self.network_creator.clean()
3048 except Exception as e:
3050 'Unexpected exception cleaning network with message - %s',
3053 if self.volume_creator2:
3055 self.volume_creator2.clean()
3056 except Exception as e:
3058 'Unexpected exception cleaning volume with message - %s',
3061 if self.volume_creator1:
3063 self.volume_creator1.clean()
3064 except Exception as e:
3066 'Unexpected exception cleaning volume with message - %s',
3069 if self.image_creator and not self.image_creator.image_settings.exists:
3071 self.image_creator.clean()
3072 except Exception as e:
3074 'Unexpected exception cleaning image with message - %s', e)
3076 super(self.__class__, self).__clean__()
3078 def test_create_instance_with_one_volume(self):
3080 Tests the creation of an OpenStack instance with a single volume.
3082 instance_settings = VmInstanceConfig(
3083 name=self.vm_inst_name,
3084 flavor=self.flavor_creator.flavor_settings.name,
3085 port_settings=[self.port_settings],
3086 volume_names=[self.volume_settings1.name])
3088 self.inst_creator = OpenStackVmInstance(
3089 self.os_creds, instance_settings,
3090 self.image_creator.image_settings)
3092 vm_inst = self.inst_creator.create(block=True)
3093 self.assertIsNotNone(nova_utils.get_server(
3094 self.nova, self.neutron, self.keystone,
3095 vm_inst_settings=instance_settings))
3097 self.assertIsNotNone(vm_inst)
3098 self.assertEqual(1, len(vm_inst.volume_ids))
3099 self.assertEqual(self.volume_creator1.get_volume().id,
3100 vm_inst.volume_ids[0]['id'])
3102 def test_create_instance_with_two_volumes(self):
3104 Tests the creation of an OpenStack instance with a single volume.
3106 instance_settings = VmInstanceConfig(
3107 name=self.vm_inst_name,
3108 flavor=self.flavor_creator.flavor_settings.name,
3109 port_settings=[self.port_settings],
3110 volume_names=[self.volume_settings1.name,
3111 self.volume_settings2.name])
3113 self.inst_creator = OpenStackVmInstance(
3114 self.os_creds, instance_settings,
3115 self.image_creator.image_settings)
3117 vm_inst = self.inst_creator.create(block=True)
3118 self.assertIsNotNone(nova_utils.get_server(
3119 self.nova, self.neutron, self.keystone,
3120 vm_inst_settings=instance_settings))
3122 self.assertIsNotNone(vm_inst)
3123 self.assertEqual(2, len(vm_inst.volume_ids))
3124 self.assertEqual(self.volume_creator1.get_volume().id,
3125 vm_inst.volume_ids[0]['id'])
3126 self.assertEqual(self.volume_creator2.get_volume().id,
3127 vm_inst.volume_ids[1]['id'])
3130 def check_dhcp_lease(inst_creator, ip, timeout=160):
3132 Returns true if the expected DHCP lease has been acquired
3133 :param inst_creator: the SNAPS OpenStackVmInstance object
3134 :param ip: the IP address to look for
3135 :param timeout: how long to query for IP address
3139 start_time = time.time()
3141 logger.info("Looking for IP %s in the console log" % ip)
3143 while timeout > time.time() - start_time:
3144 output = inst_creator.get_console_output()
3145 full_log = full_log + output
3146 if re.search(ip, output):
3147 logger.info('DHCP lease obtained logged in console')
3152 logger.error('Full console output -\n' + full_log)
3154 logger.debug('Full console output -\n' + full_log)
3159 def _get_ping_userdata(test_ip):
3161 Returns the post VM creation script to be added into the VM's userdata
3162 :param test_ip: the IP value to substitute into the script
3163 :return: the bash script contents
3166 return ("#!/bin/sh\n\n"
3168 " ping -c 1 %s 2>&1 >/dev/null\n"
3170 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3171 " echo 'vPing OK'\n"
3174 " echo 'vPing KO'\n"
3181 def check_ping(vm_creator, timeout=160):
3183 Check for VM for ping result
3187 while tries < timeout:
3189 p_console = vm_creator.get_console_output()
3190 if "vPing OK" in p_console:
3192 elif "failed to read iid from metadata" in p_console or tries > 5: