1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
23 from neutronclient.common.exceptions import InvalidIpForSubnetClient
24 from novaclient.exceptions import BadRequest
26 from snaps import file_utils
27 from snaps.config.flavor import FlavorConfig
28 from snaps.config.image import ImageConfig
29 from snaps.config.keypair import KeypairConfig
30 from snaps.config.network import PortConfig, NetworkConfig, SubnetConfig
31 from snaps.config.router import RouterConfig
32 from snaps.config.security_group import (
33 Protocol, SecurityGroupRuleConfig, Direction, SecurityGroupConfig)
34 from snaps.config.vm_inst import (
35 VmInstanceConfig, FloatingIpConfig, VmInstanceConfigError,
36 FloatingIpConfigError)
37 from snaps.config.volume import VolumeConfig
38 from snaps.openstack import create_network, create_router, create_instance
39 from snaps.openstack.create_flavor import OpenStackFlavor
40 from snaps.openstack.create_image import OpenStackImage
41 from snaps.openstack.create_instance import (
42 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)
43 from snaps.openstack.create_keypairs import OpenStackKeypair
44 from snaps.openstack.create_network import OpenStackNetwork
45 from snaps.openstack.create_router import OpenStackRouter
46 from snaps.openstack.create_security_group import OpenStackSecurityGroup
47 from snaps.openstack.create_volume import OpenStackVolume
48 from snaps.openstack.tests import openstack_tests, validation_utils
49 from snaps.openstack.tests.os_source_file_test import (
50 OSIntegrationTestCase, OSComponentTestCase)
51 from snaps.openstack.utils import nova_utils
52 from snaps.openstack.utils.nova_utils import RebootType
53 from snaps.openstack.utils import nova_utils, settings_utils, neutron_utils
55 __author__ = 'spisarski'
59 logger = logging.getLogger('create_instance_tests')
62 class VmInstanceSettingsUnitTests(unittest.TestCase):
64 Tests the construction of the VmInstanceSettings class
67 def test_no_params(self):
68 with self.assertRaises(VmInstanceConfigError):
71 def test_empty_config(self):
72 with self.assertRaises(VmInstanceConfigError):
73 VmInstanceSettings(config=dict())
75 def test_name_only(self):
76 with self.assertRaises(VmInstanceConfigError):
77 VmInstanceSettings(name='foo')
79 def test_config_with_name_only(self):
80 with self.assertRaises(VmInstanceConfigError):
81 VmInstanceSettings(config={'name': 'foo'})
83 def test_name_flavor_only(self):
84 with self.assertRaises(VmInstanceConfigError):
85 VmInstanceSettings(name='foo', flavor='bar')
87 def test_config_with_name_flavor_only(self):
88 with self.assertRaises(VmInstanceConfigError):
89 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
91 def test_name_flavor_port_only(self):
92 port_settings = PortConfig(name='foo-port', network_name='bar-net')
93 settings = VmInstanceSettings(name='foo', flavor='bar',
94 port_settings=[port_settings])
95 self.assertEqual('foo', settings.name)
96 self.assertEqual('bar', settings.flavor)
97 self.assertEqual(1, len(settings.port_settings))
98 self.assertEqual('foo-port', settings.port_settings[0].name)
99 self.assertEqual('bar-net', settings.port_settings[0].network_name)
100 self.assertEqual(0, len(settings.security_group_names))
101 self.assertEqual(0, len(settings.floating_ip_settings))
102 self.assertIsNone(settings.sudo_user)
103 self.assertEqual(900, settings.vm_boot_timeout)
104 self.assertEqual(300, settings.vm_delete_timeout)
105 self.assertEqual(180, settings.ssh_connect_timeout)
106 self.assertIsNone(settings.availability_zone)
107 self.assertIsNone(settings.volume_names)
109 def test_config_with_name_flavor_port_only(self):
110 port_settings = PortConfig(name='foo-port', network_name='bar-net')
111 settings = VmInstanceSettings(
112 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
113 self.assertEqual('foo', settings.name)
114 self.assertEqual('bar', settings.flavor)
115 self.assertEqual(1, len(settings.port_settings))
116 self.assertEqual('foo-port', settings.port_settings[0].name)
117 self.assertEqual('bar-net', settings.port_settings[0].network_name)
118 self.assertEqual(0, len(settings.security_group_names))
119 self.assertEqual(0, len(settings.floating_ip_settings))
120 self.assertIsNone(settings.sudo_user)
121 self.assertEqual(900, settings.vm_boot_timeout)
122 self.assertEqual(300, settings.vm_delete_timeout)
123 self.assertEqual(180, settings.ssh_connect_timeout)
124 self.assertIsNone(settings.availability_zone)
125 self.assertIsNone(settings.volume_names)
128 port_settings = PortConfig(name='foo-port', network_name='bar-net')
129 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
130 router_name='foo-bar-router')
132 settings = VmInstanceSettings(
133 name='foo', flavor='bar', port_settings=[port_settings],
134 security_group_names=['sec_grp_1'],
135 floating_ip_settings=[fip_settings], sudo_user='joe',
136 vm_boot_timeout=999, vm_delete_timeout=333,
137 ssh_connect_timeout=111, availability_zone='server name',
138 volume_names=['vol1'])
139 self.assertEqual('foo', settings.name)
140 self.assertEqual('bar', settings.flavor)
141 self.assertEqual(1, len(settings.port_settings))
142 self.assertEqual('foo-port', settings.port_settings[0].name)
143 self.assertEqual('bar-net', settings.port_settings[0].network_name)
144 self.assertEqual(1, len(settings.security_group_names))
145 self.assertEqual('sec_grp_1', settings.security_group_names[0])
146 self.assertEqual(1, len(settings.floating_ip_settings))
147 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
148 self.assertEqual('bar-port',
149 settings.floating_ip_settings[0].port_name)
150 self.assertEqual('foo-bar-router',
151 settings.floating_ip_settings[0].router_name)
152 self.assertEqual('joe', settings.sudo_user)
153 self.assertEqual(999, settings.vm_boot_timeout)
154 self.assertEqual(333, settings.vm_delete_timeout)
155 self.assertEqual(111, settings.ssh_connect_timeout)
156 self.assertEqual('server name', settings.availability_zone)
157 self.assertEqual('vol1', settings.volume_names[0])
159 def test_config_all(self):
160 port_settings = PortConfig(name='foo-port', network_name='bar-net')
161 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
162 router_name='foo-bar-router')
164 settings = VmInstanceSettings(
165 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
166 'security_group_names': ['sec_grp_1'],
167 'floating_ips': [fip_settings], 'sudo_user': 'joe',
168 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
169 'ssh_connect_timeout': 111, 'availability_zone': 'server name',
170 'volume_names': ['vol2']})
171 self.assertEqual('foo', settings.name)
172 self.assertEqual('bar', settings.flavor)
173 self.assertEqual(1, len(settings.port_settings))
174 self.assertEqual('foo-port', settings.port_settings[0].name)
175 self.assertEqual('bar-net', settings.port_settings[0].network_name)
176 self.assertEqual(1, len(settings.security_group_names))
177 self.assertEqual(1, len(settings.floating_ip_settings))
178 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
179 self.assertEqual('bar-port',
180 settings.floating_ip_settings[0].port_name)
181 self.assertEqual('foo-bar-router',
182 settings.floating_ip_settings[0].router_name)
183 self.assertEqual('joe', settings.sudo_user)
184 self.assertEqual(999, settings.vm_boot_timeout)
185 self.assertEqual(333, settings.vm_delete_timeout)
186 self.assertEqual(111, settings.ssh_connect_timeout)
187 self.assertEqual('server name', settings.availability_zone)
188 self.assertEqual('vol2', settings.volume_names[0])
191 class FloatingIpSettingsUnitTests(unittest.TestCase):
193 Tests the construction of the FloatingIpSettings class
196 def test_no_params(self):
197 with self.assertRaises(FloatingIpConfigError):
200 def test_empty_config(self):
201 with self.assertRaises(FloatingIpConfigError):
202 FloatingIpSettings(**dict())
204 def test_name_only(self):
205 with self.assertRaises(FloatingIpConfigError):
206 FloatingIpSettings(name='foo')
208 def test_config_with_name_only(self):
209 with self.assertRaises(FloatingIpConfigError):
210 FloatingIpSettings(**{'name': 'foo'})
212 def test_name_port_only(self):
213 with self.assertRaises(FloatingIpConfigError):
214 FloatingIpSettings(name='foo', port_name='bar')
216 def test_config_with_name_port_only(self):
217 with self.assertRaises(FloatingIpConfigError):
218 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
220 def test_name_router_only(self):
221 with self.assertRaises(FloatingIpConfigError):
222 FloatingIpSettings(name='foo', router_name='bar')
224 def test_config_with_name_router_only(self):
225 with self.assertRaises(FloatingIpConfigError):
226 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
228 def test_name_port_router_name_only(self):
229 settings = FloatingIpSettings(name='foo', port_name='foo-port',
230 router_name='bar-router')
231 self.assertEqual('foo', settings.name)
232 self.assertEqual('foo-port', settings.port_name)
233 self.assertIsNone(settings.port_id)
234 self.assertEqual('bar-router', settings.router_name)
235 self.assertIsNone(settings.subnet_name)
236 self.assertTrue(settings.provisioning)
238 def test_name_port_router_id_only(self):
239 settings = FloatingIpSettings(name='foo', port_id='foo-port',
240 router_name='bar-router')
241 self.assertEqual('foo', settings.name)
242 self.assertEqual('foo-port', settings.port_id)
243 self.assertIsNone(settings.port_name)
244 self.assertEqual('bar-router', settings.router_name)
245 self.assertIsNone(settings.subnet_name)
246 self.assertTrue(settings.provisioning)
248 def test_config_with_name_port_router_only(self):
249 settings = FloatingIpSettings(
250 **{'name': 'foo', 'port_name': 'foo-port',
251 'router_name': 'bar-router'})
252 self.assertEqual('foo', settings.name)
253 self.assertEqual('foo-port', settings.port_name)
254 self.assertIsNone(settings.port_id)
255 self.assertEqual('bar-router', settings.router_name)
256 self.assertIsNone(settings.subnet_name)
257 self.assertTrue(settings.provisioning)
260 settings = FloatingIpSettings(name='foo', port_name='foo-port',
261 router_name='bar-router',
262 subnet_name='bar-subnet',
264 self.assertEqual('foo', settings.name)
265 self.assertEqual('foo-port', settings.port_name)
266 self.assertIsNone(settings.port_id)
267 self.assertEqual('bar-router', settings.router_name)
268 self.assertEqual('bar-subnet', settings.subnet_name)
269 self.assertFalse(settings.provisioning)
271 def test_config_all(self):
272 settings = FloatingIpSettings(
273 **{'name': 'foo', 'port_name': 'foo-port',
274 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
275 'provisioning': False})
276 self.assertEqual('foo', settings.name)
277 self.assertEqual('foo-port', settings.port_name)
278 self.assertIsNone(settings.port_id)
279 self.assertEqual('bar-router', settings.router_name)
280 self.assertEqual('bar-subnet', settings.subnet_name)
281 self.assertFalse(settings.provisioning)
284 class SimpleHealthCheck(OSIntegrationTestCase):
286 Test for the CreateInstance class with a single NIC/Port with Floating IPs
291 Instantiates the CreateImage object that is responsible for downloading
292 and creating an OS image file
295 super(self.__class__, self).__start__()
297 self.nova = nova_utils.nova_client(self.os_creds)
298 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
299 self.vm_inst_name = guid + '-inst'
300 self.port_1_name = guid + 'port-1'
302 # Initialize for tearDown()
303 self.image_creator = None
304 self.network_creator = None
305 self.flavor_creator = None
306 self.inst_creator = None
308 self.priv_net_config = openstack_tests.get_priv_net_config(
309 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
310 self.port_settings = PortConfig(
311 name=self.port_1_name,
312 network_name=self.priv_net_config.network_settings.name)
315 # Set the default image settings, then set any custom parameters sent
317 os_image_settings = openstack_tests.cirros_image_settings(
318 name=guid + '-image', image_metadata=self.image_metadata)
321 self.image_creator = OpenStackImage(self.os_creds,
323 self.image_creator.create()
326 self.network_creator = OpenStackNetwork(
327 self.os_creds, self.priv_net_config.network_settings)
328 self.network_creator.create()
331 self.flavor_ram = 256
332 if (self.flavor_metadata and
333 self.flavor_metadata.get('hw:mem_page_size') == 'large'):
334 self.flavor_ram = 1024
335 self.flavor_creator = OpenStackFlavor(
337 FlavorConfig(name=guid + '-flavor-name', ram=self.flavor_ram,
338 disk=10, vcpus=1, metadata=self.flavor_metadata))
339 self.flavor_creator.create()
340 except Exception as e:
346 Cleans the created object
348 if self.inst_creator:
350 self.inst_creator.clean()
351 except Exception as e:
353 'Unexpected exception cleaning VM instance with message'
356 if self.network_creator:
358 self.network_creator.clean()
359 except Exception as e:
361 'Unexpected exception cleaning network with message - %s',
364 if self.flavor_creator:
366 self.flavor_creator.clean()
367 except Exception as e:
369 'Unexpected exception cleaning flavor with message - %s',
372 if self.image_creator and not self.image_creator.image_settings.exists:
374 self.image_creator.clean()
375 except Exception as e:
377 'Unexpected exception cleaning image with message - %s',
380 super(self.__class__, self).__clean__()
382 def test_check_vm_ip_dhcp(self):
384 Tests the creation of an OpenStack instance with a single port and
385 ensures that it's assigned IP address is the actual.
387 instance_settings = VmInstanceConfig(
388 name=self.vm_inst_name,
389 flavor=self.flavor_creator.flavor_settings.name,
390 port_settings=[self.port_settings])
392 self.inst_creator = OpenStackVmInstance(
393 self.os_creds, instance_settings,
394 self.image_creator.image_settings)
395 self.inst_creator.create()
397 ip = self.inst_creator.get_port_ip(self.port_settings.name)
398 self.assertIsNotNone(ip)
400 self.assertTrue(self.inst_creator.vm_active(block=True))
402 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
405 class CreateInstanceSimpleTests(OSIntegrationTestCase):
407 Simple instance creation tests without any other objects
412 Instantiates the CreateImage object that is responsible for downloading
413 and creating an OS image file
416 super(self.__class__, self).__start__()
418 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
419 self.vm_inst_name = guid + '-inst'
420 self.nova = nova_utils.nova_client(self.os_creds)
421 os_image_settings = openstack_tests.cirros_image_settings(
422 name=guid + '-image', image_metadata=self.image_metadata)
424 net_config = openstack_tests.get_priv_net_config(
425 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
426 router_name=guid + '-pub-router', external_net=self.ext_net_name)
428 # Initialize for tearDown()
429 self.image_creator = None
430 self.flavor_creator = None
432 self.network_creator = None
433 self.inst_creator = None
437 self.image_creator = OpenStackImage(self.os_creds,
439 self.image_creator.create()
442 self.flavor_creator = OpenStackFlavor(
444 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
445 vcpus=2, metadata=self.flavor_metadata))
446 self.flavor_creator.create()
449 self.network_creator = OpenStackNetwork(
450 self.os_creds, net_config.network_settings)
451 self.network_creator.create()
453 self.port_settings = PortConfig(
455 network_name=net_config.network_settings.name)
457 except Exception as e:
463 Cleans the created object
465 if self.inst_creator:
467 self.inst_creator.clean()
468 except Exception as e:
470 'Unexpected exception cleaning VM instance with message '
473 if self.flavor_creator:
475 self.flavor_creator.clean()
476 except Exception as e:
478 'Unexpected exception cleaning flavor with message - %s',
481 if self.network_creator:
483 self.network_creator.clean()
484 except Exception as e:
486 'Unexpected exception cleaning network with message - %s',
489 if self.image_creator and not self.image_creator.image_settings.exists:
491 self.image_creator.clean()
492 except Exception as e:
494 'Unexpected exception cleaning image with message - %s', e)
496 super(self.__class__, self).__clean__()
498 def test_create_delete_instance(self):
500 Tests the creation of an OpenStack instance with a single port with a
501 static IP without a Floating IP.
503 instance_settings = VmInstanceConfig(
504 name=self.vm_inst_name,
505 flavor=self.flavor_creator.flavor_settings.name,
506 port_settings=[self.port_settings])
508 self.inst_creator = OpenStackVmInstance(
509 self.os_creds, instance_settings,
510 self.image_creator.image_settings)
512 vm_inst = self.inst_creator.create()
513 self.assertIsNotNone(nova_utils.get_server(
514 self.nova, vm_inst_settings=instance_settings))
517 nova_utils.delete_vm_instance(self.nova, vm_inst)
519 self.assertTrue(self.inst_creator.vm_deleted(block=True))
520 self.assertIsNone(nova_utils.get_server(
521 self.nova, vm_inst_settings=instance_settings))
523 # Exception should not be thrown
524 self.inst_creator.clean()
527 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
529 Test for the CreateInstance class with a single NIC/Port with Floating IPs
534 Instantiates the CreateImage object that is responsible for downloading
535 and creating an OS image file within OpenStack
537 super(self.__class__, self).__start__()
539 self.nova = nova_utils.nova_client(self.os_creds)
540 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
541 self.keypair_priv_filepath = 'tmp/' + guid
542 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
543 self.keypair_name = guid + '-kp'
544 self.vm_inst_name = guid + '-inst'
545 self.port_1_name = guid + 'port-1'
546 self.port_2_name = guid + 'port-2'
547 self.floating_ip_name = guid + 'fip1'
549 # Initialize for tearDown()
550 self.image_creator = None
551 self.network_creator = None
552 self.router_creator = None
553 self.flavor_creator = None
554 self.keypair_creator = None
555 self.sec_grp_creator = None
556 self.inst_creators = list()
558 self.pub_net_config = openstack_tests.get_pub_net_config(
559 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
560 router_name=guid + '-pub-router', external_net=self.ext_net_name)
561 os_image_settings = openstack_tests.cirros_image_settings(
562 name=guid + '-image', image_metadata=self.image_metadata)
565 self.image_creator = OpenStackImage(self.os_creds,
567 self.image_creator.create()
570 self.network_creator = OpenStackNetwork(
571 self.os_creds, self.pub_net_config.network_settings)
572 self.network_creator.create()
575 self.router_creator = OpenStackRouter(
576 self.os_creds, self.pub_net_config.router_settings)
577 self.router_creator.create()
580 self.flavor_creator = OpenStackFlavor(
582 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
583 vcpus=2, metadata=self.flavor_metadata))
584 self.flavor_creator.create()
586 self.keypair_creator = OpenStackKeypair(
587 self.os_creds, KeypairConfig(
588 name=self.keypair_name,
589 public_filepath=self.keypair_pub_filepath,
590 private_filepath=self.keypair_priv_filepath))
591 self.keypair_creator.create()
593 sec_grp_name = guid + '-sec-grp'
594 rule1 = SecurityGroupRuleConfig(
595 sec_grp_name=sec_grp_name, direction=Direction.ingress,
596 protocol=Protocol.icmp)
597 rule2 = SecurityGroupRuleConfig(
598 sec_grp_name=sec_grp_name, direction=Direction.ingress,
599 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
600 self.sec_grp_creator = OpenStackSecurityGroup(
603 name=sec_grp_name, rule_settings=[rule1, rule2]))
604 self.sec_grp_creator.create()
605 except Exception as e:
611 Cleans the created object
613 for inst_creator in self.inst_creators:
616 except Exception as e:
618 'Unexpected exception cleaning VM instance with message '
621 if self.keypair_creator:
623 self.keypair_creator.clean()
624 except Exception as e:
626 'Unexpected exception cleaning keypair with message - %s',
629 if self.flavor_creator:
631 self.flavor_creator.clean()
632 except Exception as e:
634 'Unexpected exception cleaning flavor with message - %s',
637 if self.sec_grp_creator:
639 self.sec_grp_creator.clean()
640 except Exception as e:
642 'Unexpected exception cleaning security group with message'
645 if self.router_creator:
647 self.router_creator.clean()
648 except Exception as e:
650 'Unexpected exception cleaning router with message - %s',
653 if self.network_creator:
655 self.network_creator.clean()
656 except Exception as e:
658 'Unexpected exception cleaning network with message - %s',
661 if self.image_creator and not self.image_creator.image_settings.exists:
663 self.image_creator.clean()
664 except Exception as e:
666 'Unexpected exception cleaning image with message - %s', e)
668 super(self.__class__, self).__clean__()
670 def test_single_port_static(self):
672 Tests the creation of an OpenStack instance with a single port with a
673 static IP without a Floating IP.
676 sub_settings = self.pub_net_config.network_settings.subnet_settings
677 port_settings = PortConfig(
678 name=self.port_1_name,
679 network_name=self.pub_net_config.network_settings.name,
681 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
683 instance_settings = VmInstanceConfig(
684 name=self.vm_inst_name,
685 flavor=self.flavor_creator.flavor_settings.name,
686 port_settings=[port_settings],
687 floating_ip_settings=[FloatingIpConfig(
688 name=self.floating_ip_name, port_name=self.port_1_name,
689 router_name=self.pub_net_config.router_settings.name)])
691 inst_creator = OpenStackVmInstance(
692 self.os_creds, instance_settings,
693 self.image_creator.image_settings,
694 keypair_settings=self.keypair_creator.keypair_settings)
695 self.inst_creators.append(inst_creator)
696 vm_inst = inst_creator.create(block=True)
698 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
699 self.assertTrue(inst_creator.vm_active(block=True))
700 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
702 def test_ssh_client_fip_before_active(self):
704 Tests the ability to access a VM via SSH and a floating IP when it has
705 been assigned prior to being active.
707 port_settings = PortConfig(
708 name=self.port_1_name,
709 network_name=self.pub_net_config.network_settings.name)
711 instance_settings = VmInstanceConfig(
712 name=self.vm_inst_name,
713 flavor=self.flavor_creator.flavor_settings.name,
714 port_settings=[port_settings],
715 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
716 floating_ip_settings=[FloatingIpConfig(
717 name=self.floating_ip_name, port_name=self.port_1_name,
718 router_name=self.pub_net_config.router_settings.name)])
720 inst_creator = OpenStackVmInstance(
721 self.os_creds, instance_settings,
722 self.image_creator.image_settings,
723 keypair_settings=self.keypair_creator.keypair_settings)
724 self.inst_creators.append(inst_creator)
725 vm_inst = inst_creator.create()
726 self.assertIsNotNone(vm_inst)
728 self.assertTrue(inst_creator.vm_active(block=True))
730 ip = inst_creator.get_port_ip(port_settings.name)
731 self.assertTrue(check_dhcp_lease(inst_creator, ip))
733 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
735 self.assertTrue(validate_ssh_client(inst_creator))
737 def test_ssh_client_fip_after_active(self):
739 Tests the ability to access a VM via SSH and a floating IP when it has
740 been assigned prior to being active.
742 port_settings = PortConfig(
743 name=self.port_1_name,
744 network_name=self.pub_net_config.network_settings.name)
746 instance_settings = VmInstanceConfig(
747 name=self.vm_inst_name,
748 flavor=self.flavor_creator.flavor_settings.name,
749 port_settings=[port_settings],
750 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
751 floating_ip_settings=[FloatingIpConfig(
752 name=self.floating_ip_name, port_name=self.port_1_name,
753 router_name=self.pub_net_config.router_settings.name)])
755 inst_creator = OpenStackVmInstance(
756 self.os_creds, instance_settings,
757 self.image_creator.image_settings,
758 keypair_settings=self.keypair_creator.keypair_settings)
759 self.inst_creators.append(inst_creator)
761 # block=True will force the create() method to block until the
762 vm_inst = inst_creator.create(block=True)
763 self.assertIsNotNone(vm_inst)
765 self.assertTrue(inst_creator.vm_active(block=True))
767 ip = inst_creator.get_port_ip(port_settings.name)
768 self.assertTrue(check_dhcp_lease(inst_creator, ip))
770 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
772 self.assertTrue(validate_ssh_client(inst_creator))
774 def test_ssh_client_fip_after_reboot(self):
776 Tests the ability to access a VM via SSH and a floating IP after it has
779 port_settings = PortConfig(
780 name=self.port_1_name,
781 network_name=self.pub_net_config.network_settings.name)
783 instance_settings = VmInstanceConfig(
784 name=self.vm_inst_name,
785 flavor=self.flavor_creator.flavor_settings.name,
786 port_settings=[port_settings],
787 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
788 floating_ip_settings=[FloatingIpConfig(
789 name=self.floating_ip_name, port_name=self.port_1_name,
790 router_name=self.pub_net_config.router_settings.name)])
792 inst_creator = OpenStackVmInstance(
793 self.os_creds, instance_settings,
794 self.image_creator.image_settings,
795 keypair_settings=self.keypair_creator.keypair_settings)
796 self.inst_creators.append(inst_creator)
798 # block=True will force the create() method to block until the
799 vm_inst = inst_creator.create(block=True)
800 self.assertIsNotNone(vm_inst)
802 self.assertTrue(inst_creator.vm_active(block=True))
804 ip = inst_creator.get_port_ip(port_settings.name)
805 self.assertTrue(check_dhcp_lease(inst_creator, ip))
807 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
809 self.assertTrue(validate_ssh_client(inst_creator))
811 # Test default reboot which should be 'SOFT'
812 inst_creator.reboot()
813 # Lag time to allow for shutdown routine to take effect
815 self.assertTrue(check_dhcp_lease(inst_creator, ip))
816 self.assertTrue(validate_ssh_client(inst_creator))
819 inst_creator.reboot(reboot_type=RebootType.soft)
821 self.assertTrue(check_dhcp_lease(inst_creator, ip))
822 self.assertTrue(validate_ssh_client(inst_creator))
825 inst_creator.reboot(reboot_type=RebootType.hard)
827 self.assertTrue(check_dhcp_lease(inst_creator, ip))
828 self.assertTrue(validate_ssh_client(inst_creator))
830 def test_ssh_client_fip_after_init(self):
832 Tests the ability to assign a floating IP to an already initialized
833 OpenStackVmInstance object. After the floating IP has been allocated
834 and assigned, this test will ensure that it can be accessed via SSH.
836 port_settings = PortConfig(
837 name=self.port_1_name,
838 network_name=self.pub_net_config.network_settings.name)
840 instance_settings = VmInstanceConfig(
841 name=self.vm_inst_name,
842 flavor=self.flavor_creator.flavor_settings.name,
843 port_settings=[port_settings],
844 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
846 inst_creator = OpenStackVmInstance(
847 self.os_creds, instance_settings,
848 self.image_creator.image_settings,
849 keypair_settings=self.keypair_creator.keypair_settings)
850 self.inst_creators.append(inst_creator)
852 # block=True will force the create() method to block until the
853 vm_inst = inst_creator.create(block=True)
854 self.assertIsNotNone(vm_inst)
856 self.assertTrue(inst_creator.vm_active(block=True))
857 ip = inst_creator.get_port_ip(port_settings.name)
858 self.assertTrue(check_dhcp_lease(inst_creator, ip))
859 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
861 inst_creator.add_floating_ip(FloatingIpConfig(
862 name=self.floating_ip_name, port_name=self.port_1_name,
863 router_name=self.pub_net_config.router_settings.name))
865 self.assertTrue(validate_ssh_client(inst_creator))
867 def test_ssh_client_fip_reverse_engineer(self):
869 Tests the ability to assign a floating IP to a reverse engineered
870 OpenStackVmInstance object. After the floating IP has been allocated
871 and assigned, this test will ensure that it can be accessed via SSH.
873 port_settings = PortConfig(
874 name=self.port_1_name,
875 network_name=self.pub_net_config.network_settings.name)
877 instance_settings = VmInstanceConfig(
878 name=self.vm_inst_name,
879 flavor=self.flavor_creator.flavor_settings.name,
880 port_settings=[port_settings],
881 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
883 inst_creator = OpenStackVmInstance(
884 self.os_creds, instance_settings,
885 self.image_creator.image_settings,
886 keypair_settings=self.keypair_creator.keypair_settings)
887 self.inst_creators.append(inst_creator)
889 # block=True will force the create() method to block until the
890 vm_inst = inst_creator.create(block=True)
891 self.assertIsNotNone(vm_inst)
893 self.assertTrue(inst_creator.vm_active(block=True))
895 derived_inst_creator = create_instance.generate_creator(
896 self.os_creds, vm_inst, self.image_creator.image_settings,
897 self.keypair_creator.keypair_settings)
899 derived_inst_creator.add_floating_ip(FloatingIpConfig(
900 name=self.floating_ip_name, port_name=self.port_1_name,
901 router_name=self.pub_net_config.router_settings.name))
902 self.inst_creators.append(derived_inst_creator)
904 self.assertTrue(validate_ssh_client(
905 derived_inst_creator, fip_name=self.floating_ip_name))
907 def test_ssh_client_fip_second_creator(self):
909 Tests the ability to access a VM via SSH and a floating IP via a
910 creator that is identical to the original creator.
912 port_settings = PortConfig(
913 name=self.port_1_name,
914 network_name=self.pub_net_config.network_settings.name)
916 instance_settings = VmInstanceConfig(
917 name=self.vm_inst_name,
918 flavor=self.flavor_creator.flavor_settings.name,
919 port_settings=[port_settings],
920 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
921 floating_ip_settings=[FloatingIpConfig(
922 name=self.floating_ip_name, port_name=self.port_1_name,
923 router_name=self.pub_net_config.router_settings.name)])
925 inst_creator = OpenStackVmInstance(
926 self.os_creds, instance_settings,
927 self.image_creator.image_settings,
928 keypair_settings=self.keypair_creator.keypair_settings)
929 self.inst_creators.append(inst_creator)
931 # block=True will force the create() method to block until the
932 vm_inst = inst_creator.create(block=True)
933 self.assertIsNotNone(vm_inst)
935 self.assertTrue(inst_creator.vm_active(block=True))
937 ip = inst_creator.get_port_ip(port_settings.name)
938 self.assertTrue(check_dhcp_lease(inst_creator, ip))
940 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
942 self.assertTrue(validate_ssh_client(inst_creator))
944 inst_creator2 = OpenStackVmInstance(
945 self.os_creds, instance_settings,
946 self.image_creator.image_settings,
947 keypair_settings=self.keypair_creator.keypair_settings)
948 inst_creator2.create()
949 self.assertTrue(validate_ssh_client(inst_creator2))
952 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
954 Test for the CreateInstance class with a single NIC/Port with Floating IPs
959 Instantiates the CreateImage object that is responsible for downloading
960 and creating an OS image file within OpenStack
962 super(self.__class__, self).__start__()
964 self.nova = nova_utils.nova_client(self.os_creds)
965 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
966 self.keypair_priv_filepath = 'tmp/' + self.guid
967 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
968 self.keypair_name = self.guid + '-kp'
969 self.vm_inst_name = self.guid + '-inst'
970 self.port1_name = self.guid + 'port1'
971 self.port2_name = self.guid + 'port2'
973 # Initialize for tearDown()
974 self.image_creator = None
975 self.network_creator = None
976 self.router_creator = None
977 self.flavor_creator = None
978 self.keypair_creator = None
979 self.sec_grp_creator = None
980 self.inst_creator = None
982 os_image_settings = openstack_tests.cirros_image_settings(
983 name=self.guid + '-image', image_metadata=self.image_metadata)
985 self.image_creator = OpenStackImage(
986 self.os_creds, os_image_settings)
987 self.image_creator.create()
989 self.flavor_creator = OpenStackFlavor(
992 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
993 metadata=self.flavor_metadata))
994 self.flavor_creator.create()
996 self.keypair_creator = OpenStackKeypair(
997 self.os_creds, KeypairConfig(
998 name=self.keypair_name,
999 public_filepath=self.keypair_pub_filepath,
1000 private_filepath=self.keypair_priv_filepath))
1001 self.keypair_creator.create()
1003 sec_grp_name = self.guid + '-sec-grp'
1004 rule1 = SecurityGroupRuleConfig(
1005 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1006 protocol=Protocol.icmp)
1007 rule2 = SecurityGroupRuleConfig(
1008 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1009 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
1010 self.sec_grp_creator = OpenStackSecurityGroup(
1012 SecurityGroupConfig(
1013 name=sec_grp_name, rule_settings=[rule1, rule2]))
1014 self.sec_grp_creator.create()
1015 except Exception as e:
1021 Cleans the created object
1023 if self.inst_creator:
1025 self.inst_creator.clean()
1026 except Exception as e:
1028 'Unexpected exception cleaning VM instance with message '
1031 if self.keypair_creator:
1033 self.keypair_creator.clean()
1034 except Exception as e:
1036 'Unexpected exception cleaning keypair with message - %s',
1039 if self.flavor_creator:
1041 self.flavor_creator.clean()
1042 except Exception as e:
1044 'Unexpected exception cleaning flavor with message - %s',
1047 if self.sec_grp_creator:
1049 self.sec_grp_creator.clean()
1050 except Exception as e:
1052 'Unexpected exception cleaning security group with message'
1055 if self.router_creator:
1057 self.router_creator.clean()
1058 except Exception as e:
1060 'Unexpected exception cleaning router with message - %s',
1063 if self.network_creator:
1065 self.network_creator.clean()
1066 except Exception as e:
1068 'Unexpected exception cleaning network with message - %s',
1071 if self.image_creator and not self.image_creator.image_settings.exists:
1073 self.image_creator.clean()
1074 except Exception as e:
1076 'Unexpected exception cleaning image with message - %s', e)
1078 super(self.__class__, self).__clean__()
1080 def test_v4fip_v6overlay(self):
1082 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1083 network when the external network does not have an IPv6 subnet.
1085 subnet_settings = SubnetConfig(
1086 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
1088 network_settings = NetworkConfig(
1089 name=self.guid + '-net', subnet_settings=[subnet_settings])
1090 router_settings = RouterConfig(
1091 name=self.guid + '-router', external_gateway=self.ext_net_name,
1092 internal_subnets=[subnet_settings.name])
1095 self.network_creator = OpenStackNetwork(
1096 self.os_creds, network_settings)
1097 self.network_creator.create()
1100 self.router_creator = OpenStackRouter(
1101 self.os_creds, router_settings)
1102 self.router_creator.create()
1104 port_settings = PortConfig(
1105 name=self.port1_name, network_name=network_settings.name)
1107 instance_settings = VmInstanceConfig(
1108 name=self.vm_inst_name,
1109 flavor=self.flavor_creator.flavor_settings.name,
1110 port_settings=[port_settings],
1111 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1112 floating_ip_settings=[FloatingIpConfig(
1113 name='fip1', port_name=self.port1_name,
1114 router_name=router_settings.name)])
1116 self.inst_creator = OpenStackVmInstance(
1117 self.os_creds, instance_settings,
1118 self.image_creator.image_settings,
1119 keypair_settings=self.keypair_creator.keypair_settings)
1121 with self.assertRaises(BadRequest):
1122 self.inst_creator.create(block=True)
1124 def test_fip_v4and6_overlay(self):
1126 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1127 network when the external network does not have an IPv6 subnet.
1129 subnet4_settings = SubnetConfig(
1130 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
1132 subnet6_settings = SubnetConfig(
1133 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
1135 network_settings = NetworkConfig(
1136 name=self.guid + '-net',
1137 subnet_settings=[subnet4_settings, subnet6_settings])
1138 router_settings = RouterConfig(
1139 name=self.guid + '-router', external_gateway=self.ext_net_name,
1140 internal_subnets=[subnet4_settings.name])
1143 self.network_creator = OpenStackNetwork(
1144 self.os_creds, network_settings)
1145 self.network_creator.create()
1148 self.router_creator = OpenStackRouter(
1149 self.os_creds, router_settings)
1150 self.router_creator.create()
1152 port_settings = PortConfig(
1153 name=self.port1_name, network_name=network_settings.name)
1155 instance_settings = VmInstanceConfig(
1156 name=self.vm_inst_name,
1157 flavor=self.flavor_creator.flavor_settings.name,
1158 port_settings=[port_settings],
1159 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1160 floating_ip_settings=[FloatingIpConfig(
1161 name='fip1', port_name=self.port1_name,
1162 router_name=router_settings.name)])
1164 self.inst_creator = OpenStackVmInstance(
1165 self.os_creds, instance_settings,
1166 self.image_creator.image_settings,
1167 keypair_settings=self.keypair_creator.keypair_settings)
1169 self.inst_creator.create(block=True)
1170 ssh_client = self.inst_creator.ssh_client()
1171 self.assertIsNotNone(ssh_client)
1174 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1176 Test for the CreateInstance class with a single NIC/Port where mac and IP
1177 values are manually set
1182 Instantiates the CreateImage object that is responsible for downloading
1183 and creating an OS image file within OpenStack
1185 super(self.__class__, self).__start__()
1187 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1188 self.vm_inst_name = guid + '-inst'
1189 self.port_1_name = guid + 'port-1'
1190 self.port_2_name = guid + 'port-2'
1191 self.floating_ip_name = guid + 'fip1'
1193 # Initialize for tearDown()
1194 self.image_creator = None
1195 self.network_creator = None
1196 self.flavor_creator = None
1197 self.inst_creator = None
1199 self.net_config = openstack_tests.get_priv_net_config(
1200 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1201 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1202 os_image_settings = openstack_tests.cirros_image_settings(
1203 name=guid + '-image', image_metadata=self.image_metadata)
1207 self.image_creator = OpenStackImage(self.os_creds,
1209 self.image_creator.create()
1212 self.network_creator = OpenStackNetwork(
1213 self.os_creds, self.net_config.network_settings)
1214 self.network_creator.create()
1217 self.flavor_creator = OpenStackFlavor(
1218 self.admin_os_creds,
1219 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1220 vcpus=2, metadata=self.flavor_metadata))
1221 self.flavor_creator.create()
1222 except Exception as e:
1228 Cleans the created object
1230 if self.inst_creator:
1232 self.inst_creator.clean()
1233 except Exception as e:
1235 'Unexpected exception cleaning VM instance with message '
1238 if self.flavor_creator:
1240 self.flavor_creator.clean()
1241 except Exception as e:
1243 'Unexpected exception cleaning flavor with message - %s',
1246 if self.network_creator:
1248 self.network_creator.clean()
1249 except Exception as e:
1251 'Unexpected exception cleaning network with message - %s',
1254 if self.image_creator and not self.image_creator.image_settings.exists:
1256 self.image_creator.clean()
1257 except Exception as e:
1259 'Unexpected exception cleaning image with message - %s', e)
1261 super(self.__class__, self).__clean__()
1263 def test_set_custom_valid_ip_one_subnet(self):
1265 Tests the creation of an OpenStack instance with a single port with a
1266 static IP on a network with one subnet.
1269 sub_settings = self.net_config.network_settings.subnet_settings
1270 port_settings = PortConfig(
1271 name=self.port_1_name,
1272 network_name=self.net_config.network_settings.name,
1273 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1275 instance_settings = VmInstanceConfig(
1276 name=self.vm_inst_name,
1277 flavor=self.flavor_creator.flavor_settings.name,
1278 port_settings=[port_settings])
1280 self.inst_creator = OpenStackVmInstance(
1281 self.os_creds, instance_settings,
1282 self.image_creator.image_settings)
1283 self.inst_creator.create(block=True)
1285 self.assertEqual(ip, self.inst_creator.get_port_ip(
1287 subnet_name=self.net_config.network_settings.subnet_settings[
1290 def test_set_custom_invalid_ip_one_subnet(self):
1292 Tests the creation of an OpenStack instance with a single port with a
1293 static IP on a network with one subnet.
1296 sub_settings = self.net_config.network_settings.subnet_settings
1297 port_settings = PortConfig(
1298 name=self.port_1_name,
1299 network_name=self.net_config.network_settings.name,
1300 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1302 instance_settings = VmInstanceConfig(
1303 name=self.vm_inst_name,
1304 flavor=self.flavor_creator.flavor_settings.name,
1305 port_settings=[port_settings])
1307 self.inst_creator = OpenStackVmInstance(
1308 self.os_creds, instance_settings,
1309 self.image_creator.image_settings)
1311 with self.assertRaises(InvalidIpForSubnetClient):
1312 self.inst_creator.create()
1314 def test_set_custom_valid_mac(self):
1316 Tests the creation of an OpenStack instance with a single port where
1317 the MAC address is assigned.
1319 mac_addr = '0a:1b:2c:3d:4e:5f'
1320 port_settings = PortConfig(
1321 name=self.port_1_name,
1322 network_name=self.net_config.network_settings.name,
1323 mac_address=mac_addr)
1325 instance_settings = VmInstanceConfig(
1326 name=self.vm_inst_name,
1327 flavor=self.flavor_creator.flavor_settings.name,
1328 port_settings=[port_settings])
1330 self.inst_creator = OpenStackVmInstance(
1331 self.os_creds, instance_settings,
1332 self.image_creator.image_settings)
1333 self.inst_creator.create(block=True)
1335 self.assertEqual(mac_addr,
1336 self.inst_creator.get_port_mac(self.port_1_name))
1338 def test_set_custom_invalid_mac(self):
1340 Tests the creation of an OpenStack instance with a single port where an
1341 invalid MAC address value is being
1342 assigned. This should raise an Exception
1344 port_settings = PortConfig(
1345 name=self.port_1_name,
1346 network_name=self.net_config.network_settings.name,
1349 instance_settings = VmInstanceConfig(
1350 name=self.vm_inst_name,
1351 flavor=self.flavor_creator.flavor_settings.name,
1352 port_settings=[port_settings])
1354 self.inst_creator = OpenStackVmInstance(
1355 self.os_creds, instance_settings,
1356 self.image_creator.image_settings)
1358 with self.assertRaises(Exception):
1359 self.inst_creator.create()
1361 def test_set_custom_mac_and_ip(self):
1363 Tests the creation of an OpenStack instance with a single port where
1364 the IP and MAC address is assigned.
1367 mac_addr = '0a:1b:2c:3d:4e:5f'
1368 sub_settings = self.net_config.network_settings.subnet_settings
1369 port_settings = PortConfig(
1370 name=self.port_1_name,
1371 network_name=self.net_config.network_settings.name,
1372 mac_address=mac_addr,
1373 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1375 instance_settings = VmInstanceConfig(
1376 name=self.vm_inst_name,
1377 flavor=self.flavor_creator.flavor_settings.name,
1378 port_settings=[port_settings])
1380 self.inst_creator = OpenStackVmInstance(
1381 self.os_creds, instance_settings,
1382 self.image_creator.image_settings)
1383 self.inst_creator.create(block=True)
1385 self.assertEqual(ip, self.inst_creator.get_port_ip(
1387 subnet_name=self.net_config.network_settings.subnet_settings[
1389 self.assertEqual(mac_addr,
1390 self.inst_creator.get_port_mac(self.port_1_name))
1392 def test_set_allowed_address_pairs(self):
1394 Tests the creation of an OpenStack instance with a single port where
1395 max_allowed_address_pair is set.
1398 mac_addr = '0a:1b:2c:3d:4e:5f'
1399 pair = {'ip_address': ip, 'mac_address': mac_addr}
1400 port_settings = PortConfig(
1401 name=self.port_1_name,
1402 network_name=self.net_config.network_settings.name,
1403 allowed_address_pairs=[pair])
1405 instance_settings = VmInstanceConfig(
1406 name=self.vm_inst_name,
1407 flavor=self.flavor_creator.flavor_settings.name,
1408 port_settings=[port_settings])
1410 self.inst_creator = OpenStackVmInstance(
1411 self.os_creds, instance_settings,
1412 self.image_creator.image_settings)
1413 self.inst_creator.create(block=True)
1415 port = self.inst_creator.get_port_by_name(port_settings.name)
1416 self.assertIsNotNone(port)
1417 self.assertIsNotNone(port.allowed_address_pairs)
1418 self.assertEqual(1, len(port.allowed_address_pairs))
1419 validation_utils.objects_equivalent(pair,
1420 port.allowed_address_pairs[0])
1422 def test_set_allowed_address_pairs_bad_mac(self):
1424 Tests the creation of an OpenStack instance with a single port where
1425 max_allowed_address_pair is set with an invalid MAC address.
1429 pair = {'ip_address': ip, 'mac_address': mac_addr}
1431 pairs.add((ip, mac_addr))
1432 port_settings = PortConfig(
1433 name=self.port_1_name,
1434 network_name=self.net_config.network_settings.name,
1435 allowed_address_pairs=[pair])
1437 instance_settings = VmInstanceConfig(
1438 name=self.vm_inst_name,
1439 flavor=self.flavor_creator.flavor_settings.name,
1440 port_settings=[port_settings])
1442 self.inst_creator = OpenStackVmInstance(
1443 self.os_creds, instance_settings,
1444 self.image_creator.image_settings)
1445 with self.assertRaises(Exception):
1446 self.inst_creator.create()
1448 def test_set_allowed_address_pairs_bad_ip(self):
1450 Tests the creation of an OpenStack instance with a single port where
1451 max_allowed_address_pair is set with an invalid MAC address.
1454 mac_addr = '0a:1b:2c:3d:4e:5f'
1455 pair = {'ip_address': ip, 'mac_address': mac_addr}
1457 pairs.add((ip, mac_addr))
1458 port_settings = PortConfig(
1459 name=self.port_1_name,
1460 network_name=self.net_config.network_settings.name,
1461 allowed_address_pairs=[pair])
1463 instance_settings = VmInstanceConfig(
1464 name=self.vm_inst_name,
1465 flavor=self.flavor_creator.flavor_settings.name,
1466 port_settings=[port_settings])
1468 self.inst_creator = OpenStackVmInstance(
1469 self.os_creds, instance_settings,
1470 self.image_creator.image_settings)
1471 with self.assertRaises(Exception):
1472 self.inst_creator.create()
1475 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1477 Test for the CreateInstance where one VM is deployed to each compute node
1482 Instantiates the CreateImage object that is responsible for downloading
1483 and creating an OS image file within OpenStack
1485 super(self.__class__, self).__start__()
1487 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1488 self.vm_inst_name = guid + '-inst'
1489 self.port_base_name = guid + 'port'
1491 # Initialize for tearDown()
1492 self.image_creator = None
1493 self.flavor_creator = None
1494 self.network_creator = None
1495 self.inst_creators = list()
1497 self.priv_net_config = openstack_tests.get_priv_net_config(
1498 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1500 os_image_settings = openstack_tests.cirros_image_settings(
1501 name=guid + '-image', image_metadata=self.image_metadata)
1505 self.network_creator = OpenStackNetwork(
1506 self.admin_os_creds, self.priv_net_config.network_settings)
1507 self.network_creator.create()
1510 self.flavor_creator = OpenStackFlavor(
1511 self.admin_os_creds,
1512 FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
1513 vcpus=1, metadata=self.flavor_metadata))
1514 self.flavor_creator.create()
1517 self.image_creator = OpenStackImage(self.os_creds,
1519 self.image_creator.create()
1521 except Exception as e:
1527 Cleans the created object
1529 for inst_creator in self.inst_creators:
1531 inst_creator.clean()
1532 except Exception as e:
1534 'Unexpected exception cleaning VM instance with message '
1537 if self.flavor_creator:
1539 self.flavor_creator.clean()
1540 except Exception as e:
1542 'Unexpected exception cleaning flavor with message - %s',
1545 if self.network_creator:
1547 self.network_creator.clean()
1548 except Exception as e:
1550 'Unexpected exception cleaning network with message - %s',
1553 if self.image_creator and not self.image_creator.image_settings.exists:
1555 self.image_creator.clean()
1556 except Exception as e:
1558 'Unexpected exception cleaning image with message - %s', e)
1560 super(self.__class__, self).__clean__()
1562 def test_deploy_vm_to_each_compute_node(self):
1564 Tests the creation of OpenStack VM instances to each compute node.
1566 from snaps.openstack.utils import nova_utils
1567 nova = nova_utils.nova_client(self.admin_os_creds)
1568 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1570 # Create Instance on each server/zone
1572 for zone in zone_hosts:
1573 inst_name = self.vm_inst_name + '-' + zone
1575 port_settings = PortConfig(
1576 name=self.port_base_name + '-' + str(ctr),
1577 network_name=self.priv_net_config.network_settings.name)
1579 instance_settings = VmInstanceConfig(
1581 flavor=self.flavor_creator.flavor_settings.name,
1582 availability_zone=zone,
1583 port_settings=[port_settings])
1584 inst_creator = OpenStackVmInstance(
1585 self.admin_os_creds, instance_settings,
1586 self.image_creator.image_settings)
1587 self.inst_creators.append(inst_creator)
1588 inst_creator.create()
1590 # Validate instances to ensure they've been deployed to the correct
1593 for zone in zone_hosts:
1594 creator = self.inst_creators[index]
1595 self.assertTrue(creator.vm_active(block=True))
1596 info = creator.get_vm_info()
1597 deployed_zone = info['OS-EXT-AZ:availability_zone']
1598 deployed_host = info['OS-EXT-SRV-ATTR:host']
1599 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1603 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1605 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1607 These tests require a Centos image
1612 Instantiates the CreateImage object that is responsible for downloading
1613 and creating an OS image file within OpenStack
1615 super(self.__class__, self).__start__()
1617 self.nova = nova_utils.nova_client(self.os_creds)
1619 # Initialize for tearDown()
1620 self.image_creator = None
1621 self.network_creators = list()
1622 self.router_creators = list()
1623 self.flavor_creator = None
1624 self.keypair_creator = None
1625 self.sec_grp_creator = None
1626 self.inst_creator = None
1628 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1629 self.keypair_priv_filepath = 'tmp/' + self.guid
1630 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1631 self.keypair_name = self.guid + '-kp'
1632 self.vm_inst_name = self.guid + '-inst'
1633 self.port_1_name = self.guid + '-port-1'
1634 self.port_2_name = self.guid + '-port-2'
1635 self.floating_ip_name = self.guid + 'fip1'
1636 self.priv_net_config = openstack_tests.get_priv_net_config(
1637 net_name=self.guid + '-priv-net',
1638 subnet_name=self.guid + '-priv-subnet',
1639 router_name=self.guid + '-priv-router',
1640 external_net=self.ext_net_name)
1641 self.pub_net_config = openstack_tests.get_pub_net_config(
1642 net_name=self.guid + '-pub-net',
1643 subnet_name=self.guid + '-pub-subnet',
1644 router_name=self.guid + '-pub-router',
1645 external_net=self.ext_net_name)
1647 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1648 os_image_settings = openstack_tests.centos_image_settings(
1649 name=image_name, image_metadata=self.image_metadata)
1653 self.image_creator = OpenStackImage(self.os_creds,
1655 self.image_creator.create()
1657 # First network is public
1658 self.network_creators.append(OpenStackNetwork(
1659 self.os_creds, self.pub_net_config.network_settings))
1660 # Second network is private
1661 self.network_creators.append(OpenStackNetwork(
1662 self.os_creds, self.priv_net_config.network_settings))
1663 for network_creator in self.network_creators:
1664 network_creator.create()
1666 self.router_creators.append(OpenStackRouter(
1667 self.os_creds, self.pub_net_config.router_settings))
1668 self.router_creators.append(OpenStackRouter(
1669 self.os_creds, self.priv_net_config.router_settings))
1672 for router_creator in self.router_creators:
1673 router_creator.create()
1676 self.flavor_creator = OpenStackFlavor(
1677 self.admin_os_creds,
1678 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
1680 metadata=self.flavor_metadata))
1681 self.flavor_creator.create()
1684 self.keypair_creator = OpenStackKeypair(
1685 self.os_creds, KeypairConfig(
1686 name=self.keypair_name,
1687 public_filepath=self.keypair_pub_filepath,
1688 private_filepath=self.keypair_priv_filepath))
1689 self.keypair_creator.create()
1691 sec_grp_name = self.guid + '-sec-grp'
1692 rule1 = SecurityGroupRuleConfig(
1693 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1694 protocol=Protocol.icmp)
1695 rule2 = SecurityGroupRuleConfig(
1696 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1697 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
1698 self.sec_grp_creator = OpenStackSecurityGroup(
1700 SecurityGroupConfig(
1701 name=sec_grp_name, rule_settings=[rule1, rule2]))
1702 self.sec_grp_creator.create()
1709 Cleans the created objects
1711 if self.inst_creator:
1713 self.inst_creator.clean()
1714 except Exception as e:
1716 'Unexpected exception cleaning VM instance with message '
1719 if self.keypair_creator:
1721 self.keypair_creator.clean()
1722 except Exception as e:
1724 'Unexpected exception cleaning keypair with message - %s',
1727 if self.flavor_creator:
1729 self.flavor_creator.clean()
1730 except Exception as e:
1732 'Unexpected exception cleaning flavor with message - %s',
1735 for router_creator in self.router_creators:
1737 router_creator.clean()
1738 except Exception as e:
1740 'Unexpected exception cleaning router with message - %s',
1743 for network_creator in self.network_creators:
1745 network_creator.clean()
1746 except Exception as e:
1748 'Unexpected exception cleaning network with message - %s',
1751 if self.sec_grp_creator:
1753 self.sec_grp_creator.clean()
1754 except Exception as e:
1756 'Unexpected exception cleaning security group with message'
1759 if self.image_creator and not self.image_creator.image_settings.exists:
1761 self.image_creator.clean()
1762 except Exception as e:
1764 'Unexpected exception cleaning image with message - %s', e)
1766 super(self.__class__, self).__clean__()
1768 def test_dual_ports_dhcp(self):
1770 Tests the creation of an OpenStack instance with a dual ports/NICs with
1772 NOTE: This test and any others that call ansible will most likely fail
1773 unless you do one of two things:
1774 1. Have a ~/.ansible.cfg (or alternate means) to
1775 set host_key_checking = False
1776 2. Set the following environment variable in your executing shell:
1777 ANSIBLE_HOST_KEY_CHECKING=False
1778 Should this not be performed, the creation of the host ssh key will
1779 cause your ansible calls to fail.
1781 # Create ports/NICs for instance
1784 for network_creator in self.network_creators:
1785 ports_settings.append(PortConfig(
1786 name=self.guid + '-port-' + str(ctr),
1787 network_name=network_creator.network_settings.name))
1791 instance_settings = VmInstanceConfig(
1792 name=self.vm_inst_name,
1793 flavor=self.flavor_creator.flavor_settings.name,
1794 port_settings=ports_settings,
1795 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1796 floating_ip_settings=[FloatingIpConfig(
1797 name=self.floating_ip_name, port_name=self.port_1_name,
1798 router_name=self.pub_net_config.router_settings.name)])
1800 self.inst_creator = OpenStackVmInstance(
1801 self.os_creds, instance_settings,
1802 self.image_creator.image_settings,
1803 keypair_settings=self.keypair_creator.keypair_settings)
1805 vm_inst = self.inst_creator.create(block=True)
1807 self.assertEqual(vm_inst.id, self.inst_creator.get_vm_inst().id)
1809 # Effectively blocks until VM has been properly activated
1810 self.assertTrue(self.inst_creator.vm_active(block=True))
1812 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1813 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1815 # Effectively blocks until VM's ssh port has been opened
1816 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1818 self.assertEqual(0, self.inst_creator.config_nics())
1821 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1823 Tests that include, add, and remove security groups from VM instances
1828 Instantiates the CreateImage object that is responsible for downloading
1829 and creating an OS image file within OpenStack
1831 super(self.__class__, self).__start__()
1833 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1834 self.vm_inst_name = self.guid + '-inst'
1835 self.nova = nova_utils.nova_client(self.os_creds)
1836 os_image_settings = openstack_tests.cirros_image_settings(
1837 name=self.guid + '-image', image_metadata=self.image_metadata)
1839 self.vm_inst_name = self.guid + '-inst'
1840 self.port_1_name = self.guid + 'port-1'
1841 self.port_2_name = self.guid + 'port-2'
1842 self.floating_ip_name = self.guid + 'fip1'
1844 net_config = openstack_tests.get_priv_net_config(
1845 net_name=self.guid + '-pub-net',
1846 subnet_name=self.guid + '-pub-subnet',
1847 router_name=self.guid + '-pub-router',
1848 external_net=self.ext_net_name)
1850 # Initialize for tearDown()
1851 self.image_creator = None
1852 self.flavor_creator = None
1853 self.network_creator = None
1854 self.router_creator = None
1855 self.inst_creator = None
1856 self.sec_grp_creators = list()
1860 self.image_creator = OpenStackImage(self.os_creds,
1862 self.image_creator.create()
1865 self.network_creator = OpenStackNetwork(
1866 self.os_creds, net_config.network_settings)
1867 self.network_creator.create()
1870 self.flavor_creator = OpenStackFlavor(
1871 self.admin_os_creds,
1872 FlavorConfig(name=self.guid + '-flavor-name', ram=256,
1874 metadata=self.flavor_metadata))
1875 self.flavor_creator.create()
1877 self.port_settings = PortConfig(
1878 name=self.guid + '-port',
1879 network_name=net_config.network_settings.name)
1880 except Exception as e:
1886 Cleans the created object
1888 if self.inst_creator:
1890 self.inst_creator.clean()
1891 except Exception as e:
1893 'Unexpected exception cleaning VM instance with message -'
1896 for sec_grp_creator in self.sec_grp_creators:
1898 sec_grp_creator.clean()
1899 except Exception as e:
1901 'Unexpected exception cleaning security group with message'
1904 if self.flavor_creator:
1906 self.flavor_creator.clean()
1907 except Exception as e:
1909 'Unexpected exception cleaning flavor with message - %s',
1912 if self.network_creator:
1914 self.network_creator.clean()
1915 except Exception as e:
1917 'Unexpected exception cleaning network with message - %s',
1920 if self.image_creator and not self.image_creator.image_settings.exists:
1922 self.image_creator.clean()
1923 except Exception as e:
1925 'Unexpected exception cleaning image with message - %s', e)
1927 super(self.__class__, self).__clean__()
1929 def test_add_security_group(self):
1931 Tests the addition of a security group created after the instance.
1934 instance_settings = VmInstanceConfig(
1935 name=self.vm_inst_name,
1936 flavor=self.flavor_creator.flavor_settings.name,
1937 port_settings=[self.port_settings])
1938 self.inst_creator = OpenStackVmInstance(
1939 self.os_creds, instance_settings,
1940 self.image_creator.image_settings)
1941 vm_inst = self.inst_creator.create(block=True)
1942 self.assertIsNotNone(vm_inst)
1944 # Create security group object to add to instance
1945 sec_grp_settings = SecurityGroupConfig(
1946 name=self.guid + '-name', description='hello group')
1947 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1949 sec_grp = sec_grp_creator.create()
1950 self.sec_grp_creators.append(sec_grp_creator)
1952 # Check that group has not been added
1953 self.assertFalse(inst_has_sec_grp(
1954 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1956 # Add security group to instance after activated
1957 self.inst_creator.add_security_group(sec_grp)
1959 # Validate that security group has been added
1960 self.assertTrue(inst_has_sec_grp(
1961 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1963 def test_add_invalid_security_group(self):
1965 Tests the addition of a security group that no longer exists.
1968 instance_settings = VmInstanceConfig(
1969 name=self.vm_inst_name,
1970 flavor=self.flavor_creator.flavor_settings.name,
1971 port_settings=[self.port_settings])
1972 self.inst_creator = OpenStackVmInstance(
1973 self.os_creds, instance_settings,
1974 self.image_creator.image_settings)
1975 vm_inst = self.inst_creator.create(block=True)
1976 self.assertIsNotNone(vm_inst)
1978 # Create security group object to add to instance
1979 sec_grp_settings = SecurityGroupConfig(
1980 name=self.guid + '-name', description='hello group')
1981 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1983 sec_grp = sec_grp_creator.create()
1984 sec_grp_creator.clean()
1985 self.sec_grp_creators.append(sec_grp_creator)
1987 # Check that group has not been added
1988 self.assertFalse(inst_has_sec_grp(
1989 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1991 # Add security group to instance after activated
1992 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1994 # Validate that security group has been added
1995 self.assertFalse(inst_has_sec_grp(
1996 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1998 def test_remove_security_group(self):
2000 Tests the removal of a security group created before and added to the
2003 # Create security group object to add to instance
2004 sec_grp_settings = SecurityGroupConfig(
2005 name=self.guid + '-name', description='hello group')
2006 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
2008 sec_grp = sec_grp_creator.create()
2009 self.sec_grp_creators.append(sec_grp_creator)
2012 instance_settings = VmInstanceConfig(
2013 name=self.vm_inst_name,
2014 flavor=self.flavor_creator.flavor_settings.name,
2015 security_group_names=[sec_grp_settings.name],
2016 port_settings=[self.port_settings])
2017 self.inst_creator = OpenStackVmInstance(
2018 self.os_creds, instance_settings,
2019 self.image_creator.image_settings)
2020 vm_inst = self.inst_creator.create(block=True)
2021 self.assertIsNotNone(vm_inst)
2023 # Check that group has been added
2024 self.assertTrue(inst_has_sec_grp(
2025 self.nova, vm_inst, sec_grp_settings.name))
2027 # Add security group to instance after activated
2028 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
2030 # Validate that security group has been added
2031 self.assertFalse(inst_has_sec_grp(
2032 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2034 def test_remove_security_group_never_added(self):
2036 Tests the removal of a security group that was never added in the first
2039 # Create security group object to add to instance
2040 sec_grp_settings = SecurityGroupConfig(
2041 name=self.guid + '-name', description='hello group')
2042 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
2044 sec_grp = sec_grp_creator.create()
2045 self.sec_grp_creators.append(sec_grp_creator)
2048 instance_settings = VmInstanceConfig(
2049 name=self.vm_inst_name,
2050 flavor=self.flavor_creator.flavor_settings.name,
2051 port_settings=[self.port_settings])
2052 self.inst_creator = OpenStackVmInstance(
2053 self.os_creds, instance_settings,
2054 self.image_creator.image_settings)
2055 vm_inst = self.inst_creator.create(block=True)
2056 self.assertIsNotNone(vm_inst)
2058 # Check that group has been added
2059 self.assertFalse(inst_has_sec_grp(
2060 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2062 # Add security group to instance after activated
2063 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
2065 # Validate that security group has been added
2066 self.assertFalse(inst_has_sec_grp(
2067 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2069 def test_add_same_security_group(self):
2071 Tests the addition of a security group created before add added to the
2074 # Create security group object to add to instance
2075 sec_grp_settings = SecurityGroupConfig(
2076 name=self.guid + '-name', description='hello group')
2077 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
2079 sec_grp = sec_grp_creator.create()
2080 self.sec_grp_creators.append(sec_grp_creator)
2083 instance_settings = VmInstanceConfig(
2084 name=self.vm_inst_name,
2085 flavor=self.flavor_creator.flavor_settings.name,
2086 security_group_names=[sec_grp_settings.name],
2087 port_settings=[self.port_settings])
2088 self.inst_creator = OpenStackVmInstance(
2089 self.os_creds, instance_settings,
2090 self.image_creator.image_settings)
2091 vm_inst = self.inst_creator.create(block=True)
2092 self.assertIsNotNone(vm_inst)
2094 # Check that group has been added
2095 self.assertTrue(inst_has_sec_grp(
2096 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2098 # Add security group to instance after activated
2099 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
2101 # Validate that security group has been added
2102 self.assertTrue(inst_has_sec_grp(
2103 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
2106 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
2108 Returns true if instance has a security group of a given name
2109 :param nova: the nova client
2110 :param vm_inst: the VmInst domain object
2111 :param sec_grp_name: the name of the security group to validate
2114 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
2115 for name in sec_grp_names:
2116 if sec_grp_name == name:
2121 def validate_ssh_client(instance_creator, fip_name=None):
2123 Returns True if instance_creator returns an SSH client that is valid
2124 :param instance_creator: the object responsible for creating the VM
2126 :param fip_name: the name of the floating IP to use
2129 ssh_active = instance_creator.vm_ssh_active(block=True)
2132 ssh_client = instance_creator.ssh_client(fip_name=fip_name)
2135 out = ssh_client.exec_command('pwd')[1]
2136 channel = out.channel
2137 in_buffer = channel.in_buffer
2138 pwd_out = in_buffer.read(1024)
2139 if not pwd_out or len(pwd_out) < 10:
2150 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
2152 Test for the CreateInstance class for creating an image from a 3-part image
2157 Instantiates the CreateImage object that is responsible for downloading
2158 and creating an OS image file within OpenStack
2160 super(self.__class__, self).__start__()
2162 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2163 self.image_name = guid
2164 self.vm_inst_name = guid + '-inst'
2165 self.nova = nova_utils.nova_client(self.os_creds)
2167 net_config = openstack_tests.get_priv_net_config(
2168 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2169 router_name=guid + '-pub-router', external_net=self.ext_net_name)
2171 # Initialize for tearDown()
2172 self.image_creator = None
2173 self.network_creator = None
2174 self.flavor_creator = None
2175 self.inst_creator = None
2178 if self.image_metadata and 'disk_file' in self.image_metadata:
2179 metadata = self.image_metadata
2180 elif self.image_metadata and 'cirros' in self.image_metadata \
2181 and 'disk_file' in self.image_metadata['cirros']:
2182 metadata = self.image_metadata['cirros']
2185 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
2187 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
2189 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
2191 image_settings = openstack_tests.cirros_image_settings(
2192 name=self.image_name,
2193 image_metadata=metadata)
2195 if not image_settings.ramdisk_image_settings or not \
2196 image_settings.kernel_image_settings:
2198 '3 Part image will not be tested. Image metadata has '
2199 'overridden this functionality')
2201 self.image_creator = OpenStackImage(self.os_creds, image_settings)
2202 self.image_creator.create()
2205 self.flavor_creator = OpenStackFlavor(
2206 self.admin_os_creds,
2207 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
2208 vcpus=2, metadata=self.flavor_metadata))
2209 self.flavor_creator.create()
2212 self.network_creator = OpenStackNetwork(
2213 self.os_creds, net_config.network_settings)
2214 self.network_creator.create()
2216 self.port_settings = PortConfig(
2217 name=guid + '-port',
2218 network_name=net_config.network_settings.name)
2219 except Exception as e:
2225 Cleans the created object
2227 if self.inst_creator:
2229 self.inst_creator.clean()
2230 except Exception as e:
2232 'Unexpected exception cleaning VM instance with message -'
2235 if self.flavor_creator:
2237 self.flavor_creator.clean()
2238 except Exception as e:
2240 'Unexpected exception cleaning flavor with message - %s',
2243 if self.network_creator:
2245 self.network_creator.clean()
2246 except Exception as e:
2248 'Unexpected exception cleaning network with message - %s',
2251 if self.image_creator and not self.image_creator.image_settings.exists:
2253 self.image_creator.clean()
2254 except Exception as e:
2256 'Unexpected exception cleaning image with message - %s', e)
2258 super(self.__class__, self).__clean__()
2260 def test_create_instance_from_three_part_image(self):
2262 Tests the creation of an OpenStack instance from a 3-part image.
2264 instance_settings = VmInstanceConfig(
2265 name=self.vm_inst_name,
2266 flavor=self.flavor_creator.flavor_settings.name,
2267 port_settings=[self.port_settings])
2269 # The last created image is the main image from which we create the
2271 self.inst_creator = OpenStackVmInstance(
2272 self.os_creds, instance_settings,
2273 self.image_creator.image_settings)
2275 vm_inst = self.inst_creator.create()
2276 self.assertIsNotNone(vm_inst)
2277 self.assertTrue(self.inst_creator.vm_active(block=True))
2280 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2282 Tests the custom image_metadata that can be set by clients for handling
2283 images differently than the default behavior of the existing tests
2284 primarily for offline testing
2289 Instantiates the CreateImage object that is responsible for downloading
2290 and creating an OS image file within OpenStack
2292 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2294 self.tmpDir = 'tmp/' + str(self.guid)
2295 if not os.path.exists(self.tmpDir):
2296 os.makedirs(self.tmpDir)
2298 self.image_name = self.guid + '-image'
2299 self.vm_inst_name = self.guid + '-inst'
2300 self.port_1_name = self.guid + 'port-1'
2302 # Initialize for tearDown()
2303 self.image_creator = None
2304 self.network_creator = None
2305 self.flavor_creator = None
2306 self.inst_creator = None
2308 self.priv_net_config = openstack_tests.get_priv_net_config(
2309 net_name=self.guid + '-priv-net',
2310 subnet_name=self.guid + '-priv-subnet')
2311 self.port_settings = PortConfig(
2312 name=self.port_1_name,
2313 network_name=self.priv_net_config.network_settings.name)
2316 # Download image file
2317 self.image_file = file_utils.download(
2318 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2321 self.network_creator = OpenStackNetwork(
2322 self.os_creds, self.priv_net_config.network_settings)
2323 self.network_creator.create()
2326 self.flavor_creator = OpenStackFlavor(
2329 name=self.guid + '-flavor-name', ram=256, disk=10,
2331 self.flavor_creator.create()
2332 except Exception as e:
2338 Cleans the created object
2340 if self.inst_creator:
2342 self.inst_creator.clean()
2343 except Exception as e:
2345 'Unexpected exception cleaning VM instance with message - '
2348 if self.network_creator:
2350 self.network_creator.clean()
2351 except Exception as e:
2353 'Unexpected exception cleaning network with message - %s',
2356 if self.flavor_creator:
2358 self.flavor_creator.clean()
2359 except Exception as e:
2361 'Unexpected exception cleaning flavor with message - %s',
2364 if self.image_creator:
2366 self.image_creator.clean()
2367 except Exception as e:
2369 'Unexpected exception cleaning image with message - %s', e)
2371 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2372 shutil.rmtree(self.tmpDir)
2374 def test_inst_from_file_image_simple_flat(self):
2376 Creates a VM instance from a locally sourced file image using simply
2377 the 'disk_file' attribute vs. using the 'config' option which
2378 completely overrides all image settings
2381 metadata = {'disk_file': self.image_file.name}
2383 os_image_settings = openstack_tests.cirros_image_settings(
2384 name=self.image_name, image_metadata=metadata)
2385 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2386 self.assertEqual(openstack_tests.CIRROS_USER,
2387 os_image_settings.image_user)
2388 self.assertIsNone(os_image_settings.url)
2389 self.assertFalse(os_image_settings.exists)
2390 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2391 os_image_settings.format)
2393 self.assertIsNone(os_image_settings.kernel_image_settings)
2394 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2396 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2397 self.image_creator.create()
2399 instance_settings = VmInstanceConfig(
2400 name=self.vm_inst_name,
2401 flavor=self.flavor_creator.flavor_settings.name,
2402 port_settings=[self.port_settings])
2403 self.inst_creator = OpenStackVmInstance(
2404 self.os_creds, instance_settings,
2405 self.image_creator.image_settings)
2406 self.inst_creator.create()
2408 self.assertTrue(self.inst_creator.vm_active(block=True))
2410 def test_inst_from_file_image_simple_nested(self):
2412 Creates a VM instance from a locally sourced file image using simply
2413 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2414 which completely overrides all image settings
2417 metadata = {'cirros': {'disk_file': self.image_file.name}}
2419 os_image_settings = openstack_tests.cirros_image_settings(
2420 name=self.image_name, image_metadata=metadata)
2421 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2422 self.assertEqual(openstack_tests.CIRROS_USER,
2423 os_image_settings.image_user)
2424 self.assertIsNone(os_image_settings.url)
2425 self.assertFalse(os_image_settings.exists)
2426 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2427 os_image_settings.format)
2429 self.assertIsNone(os_image_settings.kernel_image_settings)
2430 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2432 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2433 self.image_creator.create()
2435 instance_settings = VmInstanceConfig(
2436 name=self.vm_inst_name,
2437 flavor=self.flavor_creator.flavor_settings.name,
2438 port_settings=[self.port_settings])
2439 self.inst_creator = OpenStackVmInstance(
2440 self.os_creds, instance_settings,
2441 self.image_creator.image_settings)
2442 self.inst_creator.create()
2444 self.assertTrue(self.inst_creator.vm_active(block=True))
2446 def test_inst_from_existing(self):
2448 Creates a VM instance from a image creator that has been configured to
2449 use an existing image
2452 os_image_settings = openstack_tests.cirros_image_settings(
2453 name=self.image_name)
2454 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2455 self.image_creator.create()
2457 image_settings = self.image_creator.image_settings
2458 test_image_creator = OpenStackImage(
2461 name=image_settings.name, image_user=image_settings.image_user,
2463 test_image_creator.create()
2464 self.assertEqual(self.image_creator.get_image().id,
2465 test_image_creator.get_image().id)
2467 instance_settings = VmInstanceConfig(
2468 name=self.vm_inst_name,
2469 flavor=self.flavor_creator.flavor_settings.name,
2470 port_settings=[self.port_settings])
2471 self.inst_creator = OpenStackVmInstance(
2472 self.os_creds, instance_settings,
2473 test_image_creator.image_settings)
2474 self.inst_creator.create()
2476 self.assertTrue(self.inst_creator.vm_active(block=True))
2478 def test_inst_from_file_image_complex(self):
2480 Creates a VM instance from a locally sourced file image by overriding
2481 the default settings by using a dict() that can be read in by
2486 os_image_settings = openstack_tests.cirros_image_settings(
2487 name=self.image_name)
2488 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2489 self.image_creator.create()
2494 'name': os_image_settings.name,
2495 'image_user': os_image_settings.image_user,
2497 test_image_settings = openstack_tests.cirros_image_settings(
2498 image_metadata=metadata)
2499 test_image = OpenStackImage(self.os_creds, test_image_settings)
2502 instance_settings = VmInstanceConfig(
2503 name=self.vm_inst_name,
2504 flavor=self.flavor_creator.flavor_settings.name,
2505 port_settings=[self.port_settings])
2506 self.inst_creator = OpenStackVmInstance(self.os_creds,
2508 test_image_settings)
2509 self.inst_creator.create()
2511 self.assertTrue(self.inst_creator.vm_active(block=True))
2513 def test_inst_from_file_3part_image_complex(self):
2515 Creates a VM instance from a locally sourced file image by overriding
2516 the default settings by using a dict() that can be read in by
2521 kernel_file = file_utils.download(
2522 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2523 ramdisk_file = file_utils.download(
2524 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2529 'name': self.image_name,
2530 'image_user': openstack_tests.CIRROS_USER,
2531 'image_file': self.image_file.name,
2532 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2533 'kernel_image_settings': {
2534 'name': self.image_name + '-kernel',
2535 'image_user': openstack_tests.CIRROS_USER,
2536 'image_file': kernel_file.name,
2537 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2538 'ramdisk_image_settings': {
2539 'name': self.image_name + '-ramdisk',
2540 'image_user': openstack_tests.CIRROS_USER,
2541 'image_file': ramdisk_file.name,
2542 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2544 os_image_settings = openstack_tests.cirros_image_settings(
2545 name=self.image_name, image_metadata=metadata)
2546 self.assertEqual(self.image_name, os_image_settings.name)
2547 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2548 self.assertEqual(openstack_tests.CIRROS_USER,
2549 os_image_settings.image_user)
2550 self.assertIsNone(os_image_settings.url)
2551 self.assertFalse(os_image_settings.exists)
2552 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2553 os_image_settings.format)
2555 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2556 self.assertEqual(self.image_name + '-kernel',
2557 os_image_settings.kernel_image_settings.name)
2558 self.assertEqual(kernel_file.name,
2559 os_image_settings.kernel_image_settings.image_file)
2560 self.assertEqual(openstack_tests.CIRROS_USER,
2561 os_image_settings.kernel_image_settings.image_user)
2562 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2563 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2564 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2565 os_image_settings.kernel_image_settings.format)
2567 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2568 self.assertEqual(self.image_name + '-ramdisk',
2569 os_image_settings.ramdisk_image_settings.name)
2570 self.assertEqual(ramdisk_file.name,
2571 os_image_settings.ramdisk_image_settings.image_file)
2572 self.assertEqual(openstack_tests.CIRROS_USER,
2573 os_image_settings.ramdisk_image_settings.image_user)
2574 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2575 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2576 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2577 os_image_settings.ramdisk_image_settings.format)
2579 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2580 self.image_creator.create()
2582 instance_settings = VmInstanceConfig(
2583 name=self.vm_inst_name,
2584 flavor=self.flavor_creator.flavor_settings.name,
2585 port_settings=[self.port_settings])
2586 self.inst_creator = OpenStackVmInstance(
2587 self.os_creds, instance_settings,
2588 self.image_creator.image_settings)
2589 self.inst_creator.create()
2591 self.assertTrue(self.inst_creator.vm_active(block=True))
2593 def test_inst_from_file_3part_image_simple_flat(self):
2595 Creates a VM instance from a 3-part image locally sourced from file
2596 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2597 attributes vs. using the 'config' option which completely overrides all
2601 kernel_file = file_utils.download(
2602 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2603 ramdisk_file = file_utils.download(
2604 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2606 metadata = {'disk_file': self.image_file.name,
2607 'kernel_file': kernel_file.name,
2608 'ramdisk_file': ramdisk_file.name}
2610 os_image_settings = openstack_tests.cirros_image_settings(
2611 name=self.image_name, image_metadata=metadata)
2613 self.assertEqual(self.image_name, os_image_settings.name)
2614 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2615 self.assertEqual(openstack_tests.CIRROS_USER,
2616 os_image_settings.image_user)
2617 self.assertIsNone(os_image_settings.url)
2618 self.assertFalse(os_image_settings.exists)
2619 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2620 os_image_settings.format)
2622 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2623 self.assertEqual(self.image_name + '-kernel',
2624 os_image_settings.kernel_image_settings.name)
2625 self.assertEqual(kernel_file.name,
2626 os_image_settings.kernel_image_settings.image_file)
2627 self.assertEqual(openstack_tests.CIRROS_USER,
2628 os_image_settings.kernel_image_settings.image_user)
2629 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2630 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2631 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2632 os_image_settings.kernel_image_settings.format)
2634 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2635 self.assertEqual(self.image_name + '-ramdisk',
2636 os_image_settings.ramdisk_image_settings.name)
2637 self.assertEqual(ramdisk_file.name,
2638 os_image_settings.ramdisk_image_settings.image_file)
2639 self.assertEqual(openstack_tests.CIRROS_USER,
2640 os_image_settings.ramdisk_image_settings.image_user)
2641 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2642 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2643 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2644 os_image_settings.ramdisk_image_settings.format)
2646 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2647 self.image_creator.create()
2649 self.assertIsNotNone(self.image_creator.get_kernel_image())
2650 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2652 instance_settings = VmInstanceConfig(
2653 name=self.vm_inst_name,
2654 flavor=self.flavor_creator.flavor_settings.name,
2655 port_settings=[self.port_settings])
2656 self.inst_creator = OpenStackVmInstance(
2657 self.os_creds, instance_settings,
2658 self.image_creator.image_settings)
2659 self.inst_creator.create()
2661 self.assertTrue(self.inst_creator.vm_active(block=True))
2663 def test_inst_from_file_3part_image_simple_nested(self):
2665 Creates a VM instance from a 3-part image locally sourced from file
2666 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2667 attributes under 'cirros' vs. using the 'config' option which
2668 completely overrides all image settings
2671 kernel_file = file_utils.download(
2672 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2673 ramdisk_file = file_utils.download(
2674 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2676 metadata = {'cirros': {'disk_file': self.image_file.name,
2677 'kernel_file': kernel_file.name,
2678 'ramdisk_file': ramdisk_file.name}}
2680 os_image_settings = openstack_tests.cirros_image_settings(
2681 name=self.image_name, image_metadata=metadata)
2683 self.assertEqual(self.image_name, os_image_settings.name)
2684 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2685 self.assertEqual(openstack_tests.CIRROS_USER,
2686 os_image_settings.image_user)
2687 self.assertIsNone(os_image_settings.url)
2688 self.assertFalse(os_image_settings.exists)
2689 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2690 os_image_settings.format)
2692 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2693 self.assertEqual(self.image_name + '-kernel',
2694 os_image_settings.kernel_image_settings.name)
2695 self.assertEqual(kernel_file.name,
2696 os_image_settings.kernel_image_settings.image_file)
2697 self.assertEqual(openstack_tests.CIRROS_USER,
2698 os_image_settings.kernel_image_settings.image_user)
2699 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2700 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2701 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2702 os_image_settings.kernel_image_settings.format)
2704 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2705 self.assertEqual(self.image_name + '-ramdisk',
2706 os_image_settings.ramdisk_image_settings.name)
2707 self.assertEqual(ramdisk_file.name,
2708 os_image_settings.ramdisk_image_settings.image_file)
2709 self.assertEqual(openstack_tests.CIRROS_USER,
2710 os_image_settings.ramdisk_image_settings.image_user)
2711 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2712 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2713 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2714 os_image_settings.ramdisk_image_settings.format)
2716 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2717 self.image_creator.create()
2719 self.assertIsNotNone(self.image_creator.get_kernel_image())
2720 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2722 instance_settings = VmInstanceConfig(
2723 name=self.vm_inst_name,
2724 flavor=self.flavor_creator.flavor_settings.name,
2725 port_settings=[self.port_settings])
2726 self.inst_creator = OpenStackVmInstance(
2727 self.os_creds, instance_settings,
2728 self.image_creator.image_settings)
2729 self.inst_creator.create()
2731 self.assertTrue(self.inst_creator.vm_active(block=True))
2733 def test_inst_from_file_3part_image_existing(self):
2735 Creates a VM instance from a 3-part image that is existing
2738 kernel_file = file_utils.download(
2739 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2740 ramdisk_file = file_utils.download(
2741 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2743 metadata = {'cirros': {'disk_file': self.image_file.name,
2744 'kernel_file': kernel_file.name,
2745 'ramdisk_file': ramdisk_file.name}}
2747 os_image_settings = openstack_tests.cirros_image_settings(
2748 name=self.image_name, image_metadata=metadata)
2749 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2750 self.image_creator.create()
2752 image_settings = self.image_creator.image_settings
2753 test_image_creator = OpenStackImage(
2756 name=image_settings.name, image_user=image_settings.image_user,
2758 test_image_creator.create()
2759 self.assertEqual(self.image_creator.get_image().id,
2760 test_image_creator.get_image().id)
2762 instance_settings = VmInstanceConfig(
2763 name=self.vm_inst_name,
2764 flavor=self.flavor_creator.flavor_settings.name,
2765 port_settings=[self.port_settings])
2766 self.inst_creator = OpenStackVmInstance(
2767 self.os_creds, instance_settings,
2768 test_image_creator.image_settings)
2769 self.inst_creator.create()
2771 self.assertTrue(self.inst_creator.vm_active(block=True))
2774 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2776 Tests the ability of two VMs to communicate when attached to separate
2777 private networks that are tied together with a router.
2782 Instantiates the CreateImage object that is responsible for downloading
2783 and creating an OS image file within OpenStack
2785 super(self.__class__, self).__start__()
2787 cidr1 = '10.200.201.0/24'
2788 cidr2 = '10.200.202.0/24'
2789 static_gateway_ip1 = '10.200.201.1'
2790 static_gateway_ip2 = '10.200.202.1'
2791 self.ip1 = '10.200.201.5'
2792 self.ip2 = '10.200.202.5'
2794 self.nova = nova_utils.nova_client(self.os_creds)
2796 # Initialize for tearDown()
2797 self.image_creator = None
2798 self.network_creators = list()
2799 self.router_creator = None
2800 self.flavor_creator = None
2801 self.sec_grp_creator = None
2802 self.inst_creators = list()
2804 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2805 self.vm_inst1_name = self.guid + '-inst1'
2806 self.vm_inst2_name = self.guid + '-inst2'
2807 self.port_1_name = self.guid + '-vm1-port'
2808 self.port_2_name = self.guid + '-vm2-port'
2809 self.net_config_1 = NetworkConfig(
2810 name=self.guid + '-net1',
2812 create_network.SubnetConfig(
2813 cidr=cidr1, name=self.guid + '-subnet1',
2814 gateway_ip=static_gateway_ip1)])
2815 self.net_config_2 = NetworkConfig(
2816 name=self.guid + '-net2',
2818 create_network.SubnetConfig(
2819 cidr=cidr2, name=self.guid + '-subnet2',
2820 gateway_ip=static_gateway_ip2)])
2822 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2823 os_image_settings = openstack_tests.cirros_image_settings(
2824 name=image_name, image_metadata=self.image_metadata)
2828 self.image_creator = OpenStackImage(self.os_creds,
2830 self.image_creator.create()
2832 # First network is public
2833 self.network_creators.append(OpenStackNetwork(
2834 self.os_creds, self.net_config_1))
2835 # Second network is private
2836 self.network_creators.append(OpenStackNetwork(
2837 self.os_creds, self.net_config_2))
2838 for network_creator in self.network_creators:
2839 network_creator.create()
2842 create_network.PortConfig(
2843 name=self.guid + '-router-port1',
2846 self.net_config_1.subnet_settings[0].name,
2847 'ip': static_gateway_ip1
2849 network_name=self.net_config_1.name,
2850 project_name=self.os_creds.project_name),
2851 create_network.PortConfig(
2852 name=self.guid + '-router-port2',
2855 self.net_config_2.subnet_settings[0].name,
2856 'ip': static_gateway_ip2
2858 network_name=self.net_config_2.name,
2859 project_name=self.os_creds.project_name)]
2861 router_settings = RouterConfig(
2862 name=self.guid + '-pub-router', port_settings=port_settings)
2863 self.router_creator = create_router.OpenStackRouter(
2864 self.os_creds, router_settings)
2865 self.router_creator.create()
2868 self.flavor_creator = OpenStackFlavor(
2869 self.admin_os_creds,
2870 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
2872 metadata=self.flavor_metadata))
2873 self.flavor_creator.create()
2875 sec_grp_name = self.guid + '-sec-grp'
2876 rule1 = SecurityGroupRuleConfig(
2877 sec_grp_name=sec_grp_name, direction=Direction.ingress,
2878 protocol=Protocol.icmp)
2879 self.sec_grp_creator = OpenStackSecurityGroup(
2881 SecurityGroupConfig(
2882 name=sec_grp_name, rule_settings=[rule1]))
2883 self.sec_grp_creator.create()
2890 Cleans the created objects
2892 for inst_creator in self.inst_creators:
2894 inst_creator.clean()
2895 except Exception as e:
2897 'Unexpected exception cleaning VM instance with message '
2900 if self.flavor_creator:
2902 self.flavor_creator.clean()
2903 except Exception as e:
2905 'Unexpected exception cleaning flavor with message - %s',
2908 if self.router_creator:
2910 self.router_creator.clean()
2911 except Exception as e:
2913 'Unexpected exception cleaning router with message - %s',
2916 for network_creator in self.network_creators:
2918 network_creator.clean()
2919 except Exception as e:
2921 'Unexpected exception cleaning network with message - %s',
2924 if self.sec_grp_creator:
2926 self.sec_grp_creator.clean()
2927 except Exception as e:
2929 'Unexpected exception cleaning security group with message'
2932 if self.image_creator and not self.image_creator.image_settings.exists:
2934 self.image_creator.clean()
2935 except Exception as e:
2937 'Unexpected exception cleaning image with message - %s', e)
2939 super(self.__class__, self).__clean__()
2941 def test_ping_via_router(self):
2943 Tests the creation of two OpenStack instances with one port on
2944 different private networks wit a router in between to ensure that they
2948 # Create ports/NICs for instance
2951 for network_creator in self.network_creators:
2952 ports_settings.append(PortConfig(
2953 name=self.guid + '-port-' + str(ctr),
2954 network_name=network_creator.network_settings.name))
2957 # Configure instances
2958 instance1_settings = VmInstanceConfig(
2959 name=self.vm_inst1_name,
2960 flavor=self.flavor_creator.flavor_settings.name,
2961 userdata=_get_ping_userdata(self.ip2),
2962 port_settings=[PortConfig(
2963 name=self.port_1_name,
2966 self.net_config_1.subnet_settings[0].name,
2969 network_name=self.network_creators[0].network_settings.name)])
2970 instance2_settings = VmInstanceConfig(
2971 name=self.vm_inst2_name,
2972 flavor=self.flavor_creator.flavor_settings.name,
2973 userdata=_get_ping_userdata(self.ip1),
2974 port_settings=[PortConfig(
2975 name=self.port_2_name,
2978 self.net_config_2.subnet_settings[0].name,
2981 network_name=self.network_creators[1].network_settings.name)])
2984 self.inst_creators.append(OpenStackVmInstance(
2985 self.os_creds, instance1_settings,
2986 self.image_creator.image_settings))
2987 self.inst_creators.append(OpenStackVmInstance(
2988 self.os_creds, instance2_settings,
2989 self.image_creator.image_settings))
2991 for inst_creator in self.inst_creators:
2992 inst_creator.create(block=True)
2994 # Check for DHCP lease
2995 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2996 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2998 # Effectively blocks until VM has been properly activated
2999 self.assertTrue(check_ping(self.inst_creators[0]))
3000 self.assertTrue(check_ping(self.inst_creators[1]))
3003 class CreateInstanceVolumeTests(OSIntegrationTestCase):
3005 Simple instance creation with an attached volume
3010 Instantiates the CreateImage object that is responsible for downloading
3011 and creating an OS image file
3014 super(self.__class__, self).__start__()
3016 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
3017 self.vm_inst_name = guid + '-inst'
3018 self.nova = nova_utils.nova_client(self.os_creds)
3019 os_image_settings = openstack_tests.cirros_image_settings(
3020 name=guid + '-image', image_metadata=self.image_metadata)
3022 net_config = openstack_tests.get_priv_net_config(
3023 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
3024 router_name=guid + '-pub-router', external_net=self.ext_net_name)
3026 self.volume_settings1 = VolumeConfig(
3027 name=self.__class__.__name__ + '-' + str(guid) + '-1')
3028 self.volume_settings2 = VolumeConfig(
3029 name=self.__class__.__name__ + '-' + str(guid) + '-2')
3031 # Initialize for tearDown()
3032 self.image_creator = None
3033 self.flavor_creator = None
3035 self.network_creator = None
3036 self.inst_creator = None
3037 self.volume_creator1 = None
3038 self.volume_creator2 = None
3042 self.image_creator = OpenStackImage(self.os_creds,
3044 self.image_creator.create()
3047 self.flavor_creator = OpenStackFlavor(
3048 self.admin_os_creds,
3049 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
3050 vcpus=2, metadata=self.flavor_metadata))
3051 self.flavor_creator.create()
3054 self.network_creator = OpenStackNetwork(
3055 self.os_creds, net_config.network_settings)
3056 self.network_creator.create()
3058 self.port_settings = PortConfig(
3059 name=guid + '-port',
3060 network_name=net_config.network_settings.name)
3062 self.volume_creator1 = OpenStackVolume(
3063 self.os_creds, self.volume_settings1)
3064 self.volume_creator1.create(block=True)
3066 self.volume_creator2 = OpenStackVolume(
3067 self.os_creds, self.volume_settings2)
3068 self.volume_creator2.create(block=True)
3070 except Exception as e:
3076 Cleans the created object
3078 if self.inst_creator:
3080 self.inst_creator.clean()
3081 except Exception as e:
3083 'Unexpected exception cleaning VM instance with message '
3086 if self.flavor_creator:
3088 self.flavor_creator.clean()
3089 except Exception as e:
3091 'Unexpected exception cleaning flavor with message - %s',
3094 if self.network_creator:
3096 self.network_creator.clean()
3097 except Exception as e:
3099 'Unexpected exception cleaning network with message - %s',
3102 if self.volume_creator2:
3104 self.volume_creator2.clean()
3105 except Exception as e:
3107 'Unexpected exception cleaning volume with message - %s',
3110 if self.volume_creator1:
3112 self.volume_creator1.clean()
3113 except Exception as e:
3115 'Unexpected exception cleaning volume with message - %s',
3118 if self.image_creator and not self.image_creator.image_settings.exists:
3120 self.image_creator.clean()
3121 except Exception as e:
3123 'Unexpected exception cleaning image with message - %s', e)
3125 super(self.__class__, self).__clean__()
3127 def test_create_instance_with_one_volume(self):
3129 Tests the creation of an OpenStack instance with a single volume.
3131 instance_settings = VmInstanceConfig(
3132 name=self.vm_inst_name,
3133 flavor=self.flavor_creator.flavor_settings.name,
3134 port_settings=[self.port_settings],
3135 volume_names=[self.volume_settings1.name])
3137 self.inst_creator = OpenStackVmInstance(
3138 self.os_creds, instance_settings,
3139 self.image_creator.image_settings)
3141 vm_inst = self.inst_creator.create(block=True)
3142 self.assertIsNotNone(nova_utils.get_server(
3143 self.nova, vm_inst_settings=instance_settings))
3145 self.assertIsNotNone(vm_inst)
3146 self.assertEqual(1, len(vm_inst.volume_ids))
3147 self.assertEqual(self.volume_creator1.get_volume().id,
3148 vm_inst.volume_ids[0]['id'])
3150 def test_create_instance_with_two_volumes(self):
3152 Tests the creation of an OpenStack instance with a single volume.
3154 instance_settings = VmInstanceConfig(
3155 name=self.vm_inst_name,
3156 flavor=self.flavor_creator.flavor_settings.name,
3157 port_settings=[self.port_settings],
3158 volume_names=[self.volume_settings1.name,
3159 self.volume_settings2.name])
3161 self.inst_creator = OpenStackVmInstance(
3162 self.os_creds, instance_settings,
3163 self.image_creator.image_settings)
3165 vm_inst = self.inst_creator.create(block=True)
3166 self.assertIsNotNone(nova_utils.get_server(
3167 self.nova, vm_inst_settings=instance_settings))
3169 self.assertIsNotNone(vm_inst)
3170 self.assertEqual(2, len(vm_inst.volume_ids))
3171 self.assertEqual(self.volume_creator1.get_volume().id,
3172 vm_inst.volume_ids[0]['id'])
3173 self.assertEqual(self.volume_creator2.get_volume().id,
3174 vm_inst.volume_ids[1]['id'])
3177 def check_dhcp_lease(inst_creator, ip, timeout=160):
3179 Returns true if the expected DHCP lease has been acquired
3180 :param inst_creator: the SNAPS OpenStackVmInstance object
3181 :param ip: the IP address to look for
3182 :param timeout: how long to query for IP address
3186 start_time = time.time()
3188 logger.info("Looking for IP %s in the console log" % ip)
3190 while timeout > time.time() - start_time:
3191 output = inst_creator.get_console_output()
3192 full_log = full_log + output
3193 if re.search(ip, output):
3194 logger.info('DHCP lease obtained logged in console')
3199 logger.error('Full console output -\n' + full_log)
3201 logger.debug('Full console output -\n' + full_log)
3206 def _get_ping_userdata(test_ip):
3208 Returns the post VM creation script to be added into the VM's userdata
3209 :param test_ip: the IP value to substitute into the script
3210 :return: the bash script contents
3213 return ("#!/bin/sh\n\n"
3215 " ping -c 1 %s 2>&1 >/dev/null\n"
3217 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3218 " echo 'vPing OK'\n"
3221 " echo 'vPing KO'\n"
3228 def check_ping(vm_creator, timeout=160):
3230 Check for VM for ping result
3234 while tries < timeout:
3236 p_console = vm_creator.get_console_output()
3237 if "vPing OK" in p_console:
3239 elif "failed to read iid from metadata" in p_console or tries > 5: