1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
23 from neutronclient.common.exceptions import (
24 InvalidIpForSubnetClient, BadRequest)
26 from snaps import file_utils
27 from snaps.config.flavor import FlavorConfig
28 from snaps.config.image import ImageConfig
29 from snaps.config.keypair import KeypairConfig
30 from snaps.config.network import PortConfig, NetworkConfig, SubnetConfig
31 from snaps.config.router import RouterConfig
32 from snaps.config.security_group import (
33 Protocol, SecurityGroupRuleConfig, Direction, SecurityGroupConfig)
34 from snaps.config.vm_inst import (
35 VmInstanceConfig, FloatingIpConfig, VmInstanceConfigError,
36 FloatingIpConfigError)
37 from snaps.config.volume import VolumeConfig
38 from snaps.openstack import create_network, create_router, create_instance
39 from snaps.openstack.create_flavor import OpenStackFlavor
40 from snaps.openstack.create_image import OpenStackImage
41 from snaps.openstack.create_instance import (
42 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)
43 from snaps.openstack.create_keypairs import OpenStackKeypair
44 from snaps.openstack.create_network import OpenStackNetwork
45 from snaps.openstack.create_router import OpenStackRouter
46 from snaps.openstack.create_security_group import OpenStackSecurityGroup
47 from snaps.openstack.create_volume import OpenStackVolume
48 from snaps.openstack.tests import openstack_tests, validation_utils
49 from snaps.openstack.tests.os_source_file_test import (
50 OSIntegrationTestCase, OSComponentTestCase)
51 from snaps.openstack.utils import nova_utils, keystone_utils, neutron_utils
52 from snaps.openstack.utils.nova_utils import RebootType
54 __author__ = 'spisarski'
58 logger = logging.getLogger('create_instance_tests')
61 class VmInstanceSettingsUnitTests(unittest.TestCase):
63 Tests the construction of the VmInstanceSettings class
66 def test_no_params(self):
67 with self.assertRaises(VmInstanceConfigError):
70 def test_empty_config(self):
71 with self.assertRaises(VmInstanceConfigError):
72 VmInstanceSettings(config=dict())
74 def test_name_only(self):
75 with self.assertRaises(VmInstanceConfigError):
76 VmInstanceSettings(name='foo')
78 def test_config_with_name_only(self):
79 with self.assertRaises(VmInstanceConfigError):
80 VmInstanceSettings(config={'name': 'foo'})
82 def test_name_flavor_only(self):
83 with self.assertRaises(VmInstanceConfigError):
84 VmInstanceSettings(name='foo', flavor='bar')
86 def test_config_with_name_flavor_only(self):
87 with self.assertRaises(VmInstanceConfigError):
88 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
90 def test_name_flavor_port_only(self):
91 port_settings = PortConfig(name='foo-port', network_name='bar-net')
92 settings = VmInstanceSettings(name='foo', flavor='bar',
93 port_settings=[port_settings])
94 self.assertEqual('foo', settings.name)
95 self.assertEqual('bar', settings.flavor)
96 self.assertEqual(1, len(settings.port_settings))
97 self.assertEqual('foo-port', settings.port_settings[0].name)
98 self.assertEqual('bar-net', settings.port_settings[0].network_name)
99 self.assertEqual(0, len(settings.security_group_names))
100 self.assertEqual(0, len(settings.floating_ip_settings))
101 self.assertIsNone(settings.sudo_user)
102 self.assertEqual(900, settings.vm_boot_timeout)
103 self.assertEqual(300, settings.vm_delete_timeout)
104 self.assertEqual(180, settings.ssh_connect_timeout)
105 self.assertIsNone(settings.availability_zone)
106 self.assertIsNone(settings.volume_names)
108 def test_config_with_name_flavor_port_only(self):
109 port_settings = PortConfig(name='foo-port', network_name='bar-net')
110 settings = VmInstanceSettings(
111 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
112 self.assertEqual('foo', settings.name)
113 self.assertEqual('bar', settings.flavor)
114 self.assertEqual(1, len(settings.port_settings))
115 self.assertEqual('foo-port', settings.port_settings[0].name)
116 self.assertEqual('bar-net', settings.port_settings[0].network_name)
117 self.assertEqual(0, len(settings.security_group_names))
118 self.assertEqual(0, len(settings.floating_ip_settings))
119 self.assertIsNone(settings.sudo_user)
120 self.assertEqual(900, settings.vm_boot_timeout)
121 self.assertEqual(300, settings.vm_delete_timeout)
122 self.assertEqual(180, settings.ssh_connect_timeout)
123 self.assertIsNone(settings.availability_zone)
124 self.assertIsNone(settings.volume_names)
127 port_settings = PortConfig(name='foo-port', network_name='bar-net')
128 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
129 router_name='foo-bar-router')
131 settings = VmInstanceSettings(
132 name='foo', flavor='bar', port_settings=[port_settings],
133 security_group_names=['sec_grp_1'],
134 floating_ip_settings=[fip_settings], sudo_user='joe',
135 vm_boot_timeout=999, vm_delete_timeout=333,
136 ssh_connect_timeout=111, availability_zone='server name',
137 volume_names=['vol1'])
138 self.assertEqual('foo', settings.name)
139 self.assertEqual('bar', settings.flavor)
140 self.assertEqual(1, len(settings.port_settings))
141 self.assertEqual('foo-port', settings.port_settings[0].name)
142 self.assertEqual('bar-net', settings.port_settings[0].network_name)
143 self.assertEqual(1, len(settings.security_group_names))
144 self.assertEqual('sec_grp_1', settings.security_group_names[0])
145 self.assertEqual(1, len(settings.floating_ip_settings))
146 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
147 self.assertEqual('bar-port',
148 settings.floating_ip_settings[0].port_name)
149 self.assertEqual('foo-bar-router',
150 settings.floating_ip_settings[0].router_name)
151 self.assertEqual('joe', settings.sudo_user)
152 self.assertEqual(999, settings.vm_boot_timeout)
153 self.assertEqual(333, settings.vm_delete_timeout)
154 self.assertEqual(111, settings.ssh_connect_timeout)
155 self.assertEqual('server name', settings.availability_zone)
156 self.assertEqual('vol1', settings.volume_names[0])
158 def test_config_all(self):
159 port_settings = PortConfig(name='foo-port', network_name='bar-net')
160 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
161 router_name='foo-bar-router')
163 settings = VmInstanceSettings(
164 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
165 'security_group_names': ['sec_grp_1'],
166 'floating_ips': [fip_settings], 'sudo_user': 'joe',
167 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
168 'ssh_connect_timeout': 111, 'availability_zone': 'server name',
169 'volume_names': ['vol2']})
170 self.assertEqual('foo', settings.name)
171 self.assertEqual('bar', settings.flavor)
172 self.assertEqual(1, len(settings.port_settings))
173 self.assertEqual('foo-port', settings.port_settings[0].name)
174 self.assertEqual('bar-net', settings.port_settings[0].network_name)
175 self.assertEqual(1, len(settings.security_group_names))
176 self.assertEqual(1, len(settings.floating_ip_settings))
177 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
178 self.assertEqual('bar-port',
179 settings.floating_ip_settings[0].port_name)
180 self.assertEqual('foo-bar-router',
181 settings.floating_ip_settings[0].router_name)
182 self.assertEqual('joe', settings.sudo_user)
183 self.assertEqual(999, settings.vm_boot_timeout)
184 self.assertEqual(333, settings.vm_delete_timeout)
185 self.assertEqual(111, settings.ssh_connect_timeout)
186 self.assertEqual('server name', settings.availability_zone)
187 self.assertEqual('vol2', settings.volume_names[0])
190 class FloatingIpSettingsUnitTests(unittest.TestCase):
192 Tests the construction of the FloatingIpSettings class
195 def test_no_params(self):
196 with self.assertRaises(FloatingIpConfigError):
199 def test_empty_config(self):
200 with self.assertRaises(FloatingIpConfigError):
201 FloatingIpSettings(**dict())
203 def test_name_only(self):
204 with self.assertRaises(FloatingIpConfigError):
205 FloatingIpSettings(name='foo')
207 def test_config_with_name_only(self):
208 with self.assertRaises(FloatingIpConfigError):
209 FloatingIpSettings(**{'name': 'foo'})
211 def test_name_port_only(self):
212 with self.assertRaises(FloatingIpConfigError):
213 FloatingIpSettings(name='foo', port_name='bar')
215 def test_config_with_name_port_only(self):
216 with self.assertRaises(FloatingIpConfigError):
217 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
219 def test_name_router_only(self):
220 with self.assertRaises(FloatingIpConfigError):
221 FloatingIpSettings(name='foo', router_name='bar')
223 def test_config_with_name_router_only(self):
224 with self.assertRaises(FloatingIpConfigError):
225 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
227 def test_name_port_router_name_only(self):
228 settings = FloatingIpSettings(name='foo', port_name='foo-port',
229 router_name='bar-router')
230 self.assertEqual('foo', settings.name)
231 self.assertEqual('foo-port', settings.port_name)
232 self.assertIsNone(settings.port_id)
233 self.assertEqual('bar-router', settings.router_name)
234 self.assertIsNone(settings.subnet_name)
235 self.assertTrue(settings.provisioning)
237 def test_name_port_router_id_only(self):
238 settings = FloatingIpSettings(name='foo', port_id='foo-port',
239 router_name='bar-router')
240 self.assertEqual('foo', settings.name)
241 self.assertEqual('foo-port', settings.port_id)
242 self.assertIsNone(settings.port_name)
243 self.assertEqual('bar-router', settings.router_name)
244 self.assertIsNone(settings.subnet_name)
245 self.assertTrue(settings.provisioning)
247 def test_config_with_name_port_router_only(self):
248 settings = FloatingIpSettings(
249 **{'name': 'foo', 'port_name': 'foo-port',
250 'router_name': 'bar-router'})
251 self.assertEqual('foo', settings.name)
252 self.assertEqual('foo-port', settings.port_name)
253 self.assertIsNone(settings.port_id)
254 self.assertEqual('bar-router', settings.router_name)
255 self.assertIsNone(settings.subnet_name)
256 self.assertTrue(settings.provisioning)
259 settings = FloatingIpSettings(name='foo', port_name='foo-port',
260 router_name='bar-router',
261 subnet_name='bar-subnet',
263 self.assertEqual('foo', settings.name)
264 self.assertEqual('foo-port', settings.port_name)
265 self.assertIsNone(settings.port_id)
266 self.assertEqual('bar-router', settings.router_name)
267 self.assertEqual('bar-subnet', settings.subnet_name)
268 self.assertFalse(settings.provisioning)
270 def test_config_all(self):
271 settings = FloatingIpSettings(
272 **{'name': 'foo', 'port_name': 'foo-port',
273 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
274 'provisioning': False})
275 self.assertEqual('foo', settings.name)
276 self.assertEqual('foo-port', settings.port_name)
277 self.assertIsNone(settings.port_id)
278 self.assertEqual('bar-router', settings.router_name)
279 self.assertEqual('bar-subnet', settings.subnet_name)
280 self.assertFalse(settings.provisioning)
283 class SimpleHealthCheck(OSIntegrationTestCase):
285 Test for the CreateInstance class with a single NIC/Port with Floating IPs
290 Instantiates the CreateImage object that is responsible for downloading
291 and creating an OS image file
294 super(self.__class__, self).__start__()
296 self.nova = nova_utils.nova_client(self.os_creds)
297 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
298 self.vm_inst_name = guid + '-inst'
299 self.port_1_name = guid + 'port-1'
301 # Initialize for tearDown()
302 self.image_creator = None
303 self.network_creator = None
304 self.flavor_creator = None
305 self.inst_creator = None
307 self.priv_net_config = openstack_tests.get_priv_net_config(
308 net_name=guid + '-priv-net',
309 subnet_name=guid + '-priv-subnet',
310 netconf_override=self.netconf_override)
311 self.port_settings = PortConfig(
312 name=self.port_1_name,
313 network_name=self.priv_net_config.network_settings.name)
316 # Set the default image settings, then set any custom parameters sent
318 os_image_settings = openstack_tests.cirros_image_settings(
319 name=guid + '-image', image_metadata=self.image_metadata)
322 self.image_creator = OpenStackImage(self.os_creds,
324 self.image_creator.create()
327 self.network_creator = OpenStackNetwork(
328 self.os_creds, self.priv_net_config.network_settings)
329 self.network_creator.create()
332 self.flavor_ram = 256
333 if (self.flavor_metadata and
334 self.flavor_metadata.get('hw:mem_page_size') == 'large'):
335 self.flavor_ram = 1024
336 self.flavor_creator = OpenStackFlavor(
338 FlavorConfig(name=guid + '-flavor-name', ram=self.flavor_ram,
339 disk=10, vcpus=1, metadata=self.flavor_metadata))
340 self.flavor_creator.create()
341 except Exception as e:
347 Cleans the created object
349 if self.inst_creator:
351 self.inst_creator.clean()
352 except Exception as e:
354 'Unexpected exception cleaning VM instance with message'
357 if self.network_creator:
359 self.network_creator.clean()
360 except Exception as e:
362 'Unexpected exception cleaning network with message - %s',
365 if self.flavor_creator:
367 self.flavor_creator.clean()
368 except Exception as e:
370 'Unexpected exception cleaning flavor with message - %s',
373 if self.image_creator and not self.image_creator.image_settings.exists:
375 self.image_creator.clean()
376 except Exception as e:
378 'Unexpected exception cleaning image with message - %s',
381 super(self.__class__, self).__clean__()
383 def test_check_vm_ip_dhcp(self):
385 Tests the creation of an OpenStack instance with a single port and
386 ensures that it's assigned IP address is the actual.
388 instance_settings = VmInstanceConfig(
389 name=self.vm_inst_name,
390 flavor=self.flavor_creator.flavor_settings.name,
391 port_settings=[self.port_settings])
393 self.inst_creator = OpenStackVmInstance(
394 self.os_creds, instance_settings,
395 self.image_creator.image_settings)
396 self.inst_creator.create()
398 ip = self.inst_creator.get_port_ip(self.port_settings.name)
399 self.assertIsNotNone(ip)
401 self.assertTrue(self.inst_creator.vm_active(block=True))
403 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
406 class CreateInstanceSimpleTests(OSIntegrationTestCase):
408 Simple instance creation tests without any other objects
413 Setup the objects required for the test
415 super(self.__class__, self).__start__()
417 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
418 self.vm_inst_name = self.guid + '-inst'
419 self.nova = nova_utils.nova_client(self.os_creds)
420 self.neutron = neutron_utils.neutron_client(self.os_creds)
421 os_image_settings = openstack_tests.cirros_image_settings(
422 name=self.guid + '-image', image_metadata=self.image_metadata)
424 # Initialize for tearDown()
425 self.image_creator = None
426 self.flavor_creator = None
428 self.network_creator = None
429 self.inst_creator = None
433 self.image_creator = OpenStackImage(self.os_creds,
435 self.image_creator.create()
438 self.flavor_creator = OpenStackFlavor(
440 FlavorConfig(name=self.guid + '-flavor-name', ram=256, disk=10,
441 vcpus=2, metadata=self.flavor_metadata))
442 self.flavor_creator.create()
443 self.network_creator = None
444 except Exception as e:
450 Cleans the created object
452 if self.inst_creator:
454 self.inst_creator.clean()
455 except Exception as e:
457 'Unexpected exception cleaning VM instance with message '
460 if self.flavor_creator:
462 self.flavor_creator.clean()
463 except Exception as e:
465 'Unexpected exception cleaning flavor with message - %s',
468 if self.network_creator:
470 self.network_creator.clean()
471 except Exception as e:
473 'Unexpected exception cleaning network with message - %s',
476 if self.image_creator and not self.image_creator.image_settings.exists:
478 self.image_creator.clean()
479 except Exception as e:
481 'Unexpected exception cleaning image with message - %s', e)
483 super(self.__class__, self).__clean__()
485 def test_create_delete_instance(self):
487 Tests the creation of an OpenStack instance with a single port with a
488 static IP without a Floating IP.
491 net_config = openstack_tests.get_priv_net_config(
492 net_name=self.guid + '-pub-net',
493 subnet_name=self.guid + '-pub-subnet',
494 router_name=self.guid + '-pub-router',
495 external_net=self.ext_net_name,
496 netconf_override=self.netconf_override)
497 self.network_creator = OpenStackNetwork(
498 self.os_creds, net_config.network_settings)
499 self.network_creator.create()
501 self.port_settings = PortConfig(
502 name=self.guid + '-port',
503 network_name=net_config.network_settings.name)
505 instance_settings = VmInstanceConfig(
506 name=self.vm_inst_name,
507 flavor=self.flavor_creator.flavor_settings.name,
508 port_settings=[self.port_settings])
510 self.inst_creator = OpenStackVmInstance(
511 self.os_creds, instance_settings,
512 self.image_creator.image_settings)
514 vm_inst = self.inst_creator.create(block=True)
515 self.assertIsNotNone(nova_utils.get_server(
516 self.nova, self.neutron, self.keystone,
517 vm_inst_settings=instance_settings))
519 self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
520 self.assertIsNone(self.inst_creator.get_vm_inst().compute_host)
523 nova_utils.delete_vm_instance(self.nova, vm_inst)
525 self.assertTrue(self.inst_creator.vm_deleted(block=True))
526 self.assertIsNone(nova_utils.get_server(
527 self.nova, self.neutron, self.keystone,
528 vm_inst_settings=instance_settings))
530 # Exception should not be thrown
531 self.inst_creator.clean()
533 def test_create_admin_instance(self):
535 Tests the creation of an OpenStack instance with a single port with a
536 static IP without a Floating IP.
539 net_config = openstack_tests.get_priv_net_config(
540 net_name=self.guid + '-pub-net',
541 subnet_name=self.guid + '-pub-subnet',
542 router_name=self.guid + '-pub-router',
543 external_net=self.ext_net_name,
544 netconf_override=self.netconf_override)
545 self.network_creator = OpenStackNetwork(
546 self.admin_os_creds, net_config.network_settings)
547 self.network_creator.create()
549 self.port_settings = PortConfig(
550 name=self.guid + '-port',
551 network_name=net_config.network_settings.name)
553 instance_settings = VmInstanceConfig(
554 name=self.vm_inst_name,
555 flavor=self.flavor_creator.flavor_settings.name,
556 port_settings=[self.port_settings])
558 self.inst_creator = OpenStackVmInstance(
559 self.admin_os_creds, instance_settings,
560 self.image_creator.image_settings)
562 admin_nova = nova_utils.nova_client(self.admin_os_creds)
563 admin_neutron = neutron_utils.neutron_client(self.admin_os_creds)
564 admin_key = keystone_utils.keystone_client(self.admin_os_creds)
565 vm_inst = self.inst_creator.create(block=True)
567 self.assertIsNotNone(vm_inst)
568 vm_inst_get = nova_utils.get_server(
569 admin_nova, admin_neutron, admin_key,
570 vm_inst_settings=instance_settings)
571 self.assertEqual(vm_inst, vm_inst_get)
573 self.assertIsNone(nova_utils.get_server(
574 self.nova, self.neutron, self.keystone,
575 vm_inst_settings=instance_settings))
577 self.assertIsNotNone(self.inst_creator.get_vm_inst().availability_zone)
578 self.assertIsNotNone(self.inst_creator.get_vm_inst().compute_host)
581 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
583 Test for the CreateInstance class with a single NIC/Port with Floating IPs
588 Instantiates the CreateImage object that is responsible for downloading
589 and creating an OS image file within OpenStack
591 super(self.__class__, self).__start__()
593 self.nova = nova_utils.nova_client(self.os_creds)
594 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
595 self.keypair_priv_filepath = 'tmp/' + guid
596 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
597 self.keypair_name = guid + '-kp'
598 self.vm_inst_name = guid + '-inst'
599 self.port_1_name = guid + 'port-1'
600 self.port_2_name = guid + 'port-2'
601 self.floating_ip_name = guid + 'fip1'
603 # Initialize for tearDown()
604 self.image_creator = None
605 self.network_creator = None
606 self.router_creator = None
607 self.flavor_creator = None
608 self.keypair_creator = None
609 self.sec_grp_creator = None
610 self.inst_creators = list()
612 self.pub_net_config = openstack_tests.get_pub_net_config(
613 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
614 router_name=guid + '-pub-router', external_net=self.ext_net_name,
615 netconf_override=self.netconf_override)
616 os_image_settings = openstack_tests.cirros_image_settings(
617 name=guid + '-image', image_metadata=self.image_metadata)
620 self.image_creator = OpenStackImage(self.os_creds,
622 self.image_creator.create()
625 self.network_creator = OpenStackNetwork(
626 self.os_creds, self.pub_net_config.network_settings)
627 self.network_creator.create()
630 self.router_creator = OpenStackRouter(
631 self.os_creds, self.pub_net_config.router_settings)
632 self.router_creator.create()
635 self.flavor_creator = OpenStackFlavor(
637 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
638 vcpus=2, metadata=self.flavor_metadata))
639 self.flavor_creator.create()
641 self.keypair_creator = OpenStackKeypair(
642 self.os_creds, KeypairConfig(
643 name=self.keypair_name,
644 public_filepath=self.keypair_pub_filepath,
645 private_filepath=self.keypair_priv_filepath))
646 self.keypair_creator.create()
648 sec_grp_name = guid + '-sec-grp'
649 rule1 = SecurityGroupRuleConfig(
650 sec_grp_name=sec_grp_name, direction=Direction.ingress,
651 protocol=Protocol.icmp)
652 rule2 = SecurityGroupRuleConfig(
653 sec_grp_name=sec_grp_name, direction=Direction.ingress,
654 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
655 self.sec_grp_creator = OpenStackSecurityGroup(
658 name=sec_grp_name, rule_settings=[rule1, rule2]))
659 self.sec_grp_creator.create()
660 except Exception as e:
666 Cleans the created object
668 for inst_creator in self.inst_creators:
671 except Exception as e:
673 'Unexpected exception cleaning VM instance with message '
676 if self.keypair_creator:
678 self.keypair_creator.clean()
679 except Exception as e:
681 'Unexpected exception cleaning keypair with message - %s',
684 if self.flavor_creator:
686 self.flavor_creator.clean()
687 except Exception as e:
689 'Unexpected exception cleaning flavor with message - %s',
692 if self.sec_grp_creator:
694 self.sec_grp_creator.clean()
695 except Exception as e:
697 'Unexpected exception cleaning security group with message'
700 if self.router_creator:
702 self.router_creator.clean()
703 except Exception as e:
705 'Unexpected exception cleaning router with message - %s',
708 if self.network_creator:
710 self.network_creator.clean()
711 except Exception as e:
713 'Unexpected exception cleaning network with message - %s',
716 if self.image_creator and not self.image_creator.image_settings.exists:
718 self.image_creator.clean()
719 except Exception as e:
721 'Unexpected exception cleaning image with message - %s', e)
723 super(self.__class__, self).__clean__()
725 def test_single_port_static(self):
727 Tests the creation of an OpenStack instance with a single port with a
728 static IP without a Floating IP.
731 sub_settings = self.pub_net_config.network_settings.subnet_settings
732 port_settings = PortConfig(
733 name=self.port_1_name,
734 network_name=self.pub_net_config.network_settings.name,
736 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
738 instance_settings = VmInstanceConfig(
739 name=self.vm_inst_name,
740 flavor=self.flavor_creator.flavor_settings.name,
741 port_settings=[port_settings],
742 floating_ip_settings=[FloatingIpConfig(
743 name=self.floating_ip_name, port_name=self.port_1_name,
744 router_name=self.pub_net_config.router_settings.name)])
746 inst_creator = OpenStackVmInstance(
747 self.os_creds, instance_settings,
748 self.image_creator.image_settings,
749 keypair_settings=self.keypair_creator.keypair_settings)
750 self.inst_creators.append(inst_creator)
751 vm_inst = inst_creator.create(block=True)
753 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
754 self.assertTrue(inst_creator.vm_active(block=True))
755 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
757 def test_ssh_client_fip_before_active(self):
759 Tests the ability to access a VM via SSH and a floating IP when it has
760 been assigned prior to being active.
762 port_settings = PortConfig(
763 name=self.port_1_name,
764 network_name=self.pub_net_config.network_settings.name)
766 instance_settings = VmInstanceConfig(
767 name=self.vm_inst_name,
768 flavor=self.flavor_creator.flavor_settings.name,
769 port_settings=[port_settings],
770 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
771 floating_ip_settings=[FloatingIpConfig(
772 name=self.floating_ip_name, port_name=self.port_1_name,
773 router_name=self.pub_net_config.router_settings.name)])
775 inst_creator = OpenStackVmInstance(
776 self.os_creds, instance_settings,
777 self.image_creator.image_settings,
778 keypair_settings=self.keypair_creator.keypair_settings)
779 self.inst_creators.append(inst_creator)
780 vm_inst = inst_creator.create()
781 self.assertIsNotNone(vm_inst)
783 self.assertTrue(inst_creator.vm_active(block=True))
785 ip = inst_creator.get_port_ip(port_settings.name)
786 self.assertTrue(check_dhcp_lease(inst_creator, ip))
788 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
790 self.assertTrue(validate_ssh_client(inst_creator))
792 def test_ssh_client_fip_after_active(self):
794 Tests the ability to access a VM via SSH and a floating IP when it has
795 been assigned prior to being active.
797 port_settings = PortConfig(
798 name=self.port_1_name,
799 network_name=self.pub_net_config.network_settings.name)
801 instance_settings = VmInstanceConfig(
802 name=self.vm_inst_name,
803 flavor=self.flavor_creator.flavor_settings.name,
804 port_settings=[port_settings],
805 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
806 floating_ip_settings=[FloatingIpConfig(
807 name=self.floating_ip_name, port_name=self.port_1_name,
808 router_name=self.pub_net_config.router_settings.name)])
810 inst_creator = OpenStackVmInstance(
811 self.os_creds, instance_settings,
812 self.image_creator.image_settings,
813 keypair_settings=self.keypair_creator.keypair_settings)
814 self.inst_creators.append(inst_creator)
816 # block=True will force the create() method to block until the
817 vm_inst = inst_creator.create(block=True)
818 self.assertIsNotNone(vm_inst)
820 self.assertTrue(inst_creator.vm_active(block=True))
822 ip = inst_creator.get_port_ip(port_settings.name)
823 self.assertTrue(check_dhcp_lease(inst_creator, ip))
825 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
827 self.assertTrue(validate_ssh_client(inst_creator))
829 def test_ssh_client_fip_after_reboot(self):
831 Tests the ability to access a VM via SSH and a floating IP after it has
834 port_settings = PortConfig(
835 name=self.port_1_name,
836 network_name=self.pub_net_config.network_settings.name)
838 instance_settings = VmInstanceConfig(
839 name=self.vm_inst_name,
840 flavor=self.flavor_creator.flavor_settings.name,
841 port_settings=[port_settings],
842 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
843 floating_ip_settings=[FloatingIpConfig(
844 name=self.floating_ip_name, port_name=self.port_1_name,
845 router_name=self.pub_net_config.router_settings.name)])
847 inst_creator = OpenStackVmInstance(
848 self.os_creds, instance_settings,
849 self.image_creator.image_settings,
850 keypair_settings=self.keypair_creator.keypair_settings)
851 self.inst_creators.append(inst_creator)
853 # block=True will force the create() method to block until the
854 vm_inst = inst_creator.create(block=True)
855 self.assertIsNotNone(vm_inst)
857 self.assertTrue(inst_creator.vm_active(block=True))
859 ip = inst_creator.get_port_ip(port_settings.name)
860 self.assertTrue(check_dhcp_lease(inst_creator, ip))
862 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
864 self.assertTrue(validate_ssh_client(inst_creator))
866 # Test default reboot which should be 'SOFT'
867 inst_creator.reboot()
868 # Lag time to allow for shutdown routine to take effect
870 self.assertTrue(check_dhcp_lease(inst_creator, ip))
871 self.assertTrue(validate_ssh_client(inst_creator))
874 inst_creator.reboot(reboot_type=RebootType.soft)
876 self.assertTrue(check_dhcp_lease(inst_creator, ip))
877 self.assertTrue(validate_ssh_client(inst_creator))
880 inst_creator.reboot(reboot_type=RebootType.hard)
882 self.assertTrue(check_dhcp_lease(inst_creator, ip))
883 self.assertTrue(validate_ssh_client(inst_creator))
885 def test_ssh_client_fip_after_init(self):
887 Tests the ability to assign a floating IP to an already initialized
888 OpenStackVmInstance object. After the floating IP has been allocated
889 and assigned, this test will ensure that it can be accessed via SSH.
891 port_settings = PortConfig(
892 name=self.port_1_name,
893 network_name=self.pub_net_config.network_settings.name)
895 instance_settings = VmInstanceConfig(
896 name=self.vm_inst_name,
897 flavor=self.flavor_creator.flavor_settings.name,
898 port_settings=[port_settings],
899 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
901 inst_creator = OpenStackVmInstance(
902 self.os_creds, instance_settings,
903 self.image_creator.image_settings,
904 keypair_settings=self.keypair_creator.keypair_settings)
905 self.inst_creators.append(inst_creator)
907 # block=True will force the create() method to block until the
908 vm_inst = inst_creator.create(block=True)
909 self.assertIsNotNone(vm_inst)
911 self.assertTrue(inst_creator.vm_active(block=True))
912 ip = inst_creator.get_port_ip(port_settings.name)
913 self.assertTrue(check_dhcp_lease(inst_creator, ip))
914 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
916 inst_creator.add_floating_ip(FloatingIpConfig(
917 name=self.floating_ip_name, port_name=self.port_1_name,
918 router_name=self.pub_net_config.router_settings.name))
920 self.assertTrue(validate_ssh_client(inst_creator))
922 def test_ssh_client_fip_reverse_engineer(self):
924 Tests the ability to assign a floating IP to a reverse engineered
925 OpenStackVmInstance object. After the floating IP has been allocated
926 and assigned, this test will ensure that it can be accessed via SSH.
928 port_settings = PortConfig(
929 name=self.port_1_name,
930 network_name=self.pub_net_config.network_settings.name)
932 instance_settings = VmInstanceConfig(
933 name=self.vm_inst_name,
934 flavor=self.flavor_creator.flavor_settings.name,
935 port_settings=[port_settings],
936 security_group_names=[self.sec_grp_creator.sec_grp_settings.name])
938 inst_creator = OpenStackVmInstance(
939 self.os_creds, instance_settings,
940 self.image_creator.image_settings,
941 keypair_settings=self.keypair_creator.keypair_settings)
942 self.inst_creators.append(inst_creator)
944 # block=True will force the create() method to block until the
945 vm_inst = inst_creator.create(block=True)
946 self.assertIsNotNone(vm_inst)
948 self.assertTrue(inst_creator.vm_active(block=True))
950 derived_inst_creator = create_instance.generate_creator(
951 self.os_creds, vm_inst, self.image_creator.image_settings,
952 self.os_creds.project_name, self.keypair_creator.keypair_settings)
954 derived_inst_creator.add_floating_ip(FloatingIpConfig(
955 name=self.floating_ip_name, port_name=self.port_1_name,
956 router_name=self.pub_net_config.router_settings.name))
957 self.inst_creators.append(derived_inst_creator)
959 self.assertTrue(validate_ssh_client(
960 derived_inst_creator, fip_name=self.floating_ip_name))
962 def test_ssh_client_fip_second_creator(self):
964 Tests the ability to access a VM via SSH and a floating IP via a
965 creator that is identical to the original creator.
967 port_settings = PortConfig(
968 name=self.port_1_name,
969 network_name=self.pub_net_config.network_settings.name)
971 instance_settings = VmInstanceConfig(
972 name=self.vm_inst_name,
973 flavor=self.flavor_creator.flavor_settings.name,
974 port_settings=[port_settings],
975 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
976 floating_ip_settings=[FloatingIpConfig(
977 name=self.floating_ip_name, port_name=self.port_1_name,
978 router_name=self.pub_net_config.router_settings.name)])
980 inst_creator = OpenStackVmInstance(
981 self.os_creds, instance_settings,
982 self.image_creator.image_settings,
983 keypair_settings=self.keypair_creator.keypair_settings)
984 self.inst_creators.append(inst_creator)
986 # block=True will force the create() method to block until the
987 vm_inst = inst_creator.create(block=True)
988 self.assertIsNotNone(vm_inst)
990 self.assertTrue(inst_creator.vm_active(block=True))
992 ip = inst_creator.get_port_ip(port_settings.name)
993 self.assertTrue(check_dhcp_lease(inst_creator, ip))
995 self.assertEqual(vm_inst.id, inst_creator.get_vm_inst().id)
997 self.assertTrue(validate_ssh_client(inst_creator))
999 inst_creator2 = OpenStackVmInstance(
1000 self.os_creds, instance_settings,
1001 self.image_creator.image_settings,
1002 keypair_settings=self.keypair_creator.keypair_settings)
1003 inst_creator2.create()
1004 self.assertTrue(validate_ssh_client(inst_creator2))
1007 class CreateInstanceIPv6NetworkTests(OSIntegrationTestCase):
1009 Test for the CreateInstance class with a single NIC/Port with Floating IPs
1014 Instantiates the CreateImage object that is responsible for downloading
1015 and creating an OS image file within OpenStack
1017 super(self.__class__, self).__start__()
1019 self.nova = nova_utils.nova_client(self.os_creds)
1020 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1021 self.keypair_priv_filepath = 'tmp/' + self.guid
1022 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1023 self.keypair_name = self.guid + '-kp'
1024 self.vm_inst_name = self.guid + '-inst'
1025 self.port1_name = self.guid + 'port1'
1026 self.port2_name = self.guid + 'port2'
1028 # Initialize for tearDown()
1029 self.image_creator = None
1030 self.network_creator = None
1031 self.router_creator = None
1032 self.flavor_creator = None
1033 self.keypair_creator = None
1034 self.sec_grp_creator = None
1035 self.inst_creator = None
1037 os_image_settings = openstack_tests.cirros_image_settings(
1038 name=self.guid + '-image', image_metadata=self.image_metadata)
1040 self.image_creator = OpenStackImage(
1041 self.os_creds, os_image_settings)
1042 self.image_creator.create()
1044 self.flavor_creator = OpenStackFlavor(
1045 self.admin_os_creds,
1047 name=self.guid + '-flavor-name', ram=256, disk=10, vcpus=2,
1048 metadata=self.flavor_metadata))
1049 self.flavor_creator.create()
1051 self.keypair_creator = OpenStackKeypair(
1052 self.os_creds, KeypairConfig(
1053 name=self.keypair_name,
1054 public_filepath=self.keypair_pub_filepath,
1055 private_filepath=self.keypair_priv_filepath))
1056 self.keypair_creator.create()
1058 sec_grp_name = self.guid + '-sec-grp'
1059 rule1 = SecurityGroupRuleConfig(
1060 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1061 protocol=Protocol.icmp)
1062 rule2 = SecurityGroupRuleConfig(
1063 sec_grp_name=sec_grp_name, direction=Direction.ingress,
1064 protocol=Protocol.tcp, port_range_min=22, port_range_max=22)
1065 self.sec_grp_creator = OpenStackSecurityGroup(
1067 SecurityGroupConfig(
1068 name=sec_grp_name, rule_settings=[rule1, rule2]))
1069 self.sec_grp_creator.create()
1070 except Exception as e:
1076 Cleans the created object
1078 if self.inst_creator:
1080 self.inst_creator.clean()
1081 except Exception as e:
1083 'Unexpected exception cleaning VM instance with message '
1086 if self.keypair_creator:
1088 self.keypair_creator.clean()
1089 except Exception as e:
1091 'Unexpected exception cleaning keypair with message - %s',
1094 if self.flavor_creator:
1096 self.flavor_creator.clean()
1097 except Exception as e:
1099 'Unexpected exception cleaning flavor with message - %s',
1102 if self.sec_grp_creator:
1104 self.sec_grp_creator.clean()
1105 except Exception as e:
1107 'Unexpected exception cleaning security group with message'
1110 if self.router_creator:
1112 self.router_creator.clean()
1113 except Exception as e:
1115 'Unexpected exception cleaning router with message - %s',
1118 if self.network_creator:
1120 self.network_creator.clean()
1121 except Exception as e:
1123 'Unexpected exception cleaning network with message - %s',
1126 if self.image_creator and not self.image_creator.image_settings.exists:
1128 self.image_creator.clean()
1129 except Exception as e:
1131 'Unexpected exception cleaning image with message - %s', e)
1133 super(self.__class__, self).__clean__()
1135 def test_v4fip_v6overlay(self):
1137 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1138 network when the external network does not have an IPv6 subnet.
1140 subnet_settings = SubnetConfig(
1141 name=self.guid + '-subnet', cidr='1:1:0:0:0:0:0:0/64',
1143 network_settings = NetworkConfig(
1144 name=self.guid + '-net', subnet_settings=[subnet_settings])
1145 router_settings = RouterConfig(
1146 name=self.guid + '-router', external_gateway=self.ext_net_name,
1147 internal_subnets=[subnet_settings.name])
1150 self.network_creator = OpenStackNetwork(
1151 self.os_creds, network_settings)
1152 self.network_creator.create()
1155 self.router_creator = OpenStackRouter(
1156 self.os_creds, router_settings)
1157 self.router_creator.create()
1159 port_settings = PortConfig(
1160 name=self.port1_name, network_name=network_settings.name)
1162 instance_settings = VmInstanceConfig(
1163 name=self.vm_inst_name,
1164 flavor=self.flavor_creator.flavor_settings.name,
1165 port_settings=[port_settings],
1166 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1167 floating_ip_settings=[FloatingIpConfig(
1168 name='fip1', port_name=self.port1_name,
1169 router_name=router_settings.name)])
1171 self.inst_creator = OpenStackVmInstance(
1172 self.os_creds, instance_settings,
1173 self.image_creator.image_settings,
1174 keypair_settings=self.keypair_creator.keypair_settings)
1176 with self.assertRaises(BadRequest):
1177 self.inst_creator.create(block=True)
1179 def test_fip_v4and6_overlay(self):
1181 Tests the ability to assign an IPv4 floating IP to an IPv6 overlay
1182 network when the external network does not have an IPv6 subnet.
1184 subnet4_settings = SubnetConfig(
1185 name=self.guid + '-subnet4', cidr='10.0.1.0/24',
1187 subnet6_settings = SubnetConfig(
1188 name=self.guid + '-subnet6', cidr='1:1:0:0:0:0:0:0/64',
1190 network_settings = NetworkConfig(
1191 name=self.guid + '-net',
1192 subnet_settings=[subnet4_settings, subnet6_settings])
1193 router_settings = RouterConfig(
1194 name=self.guid + '-router', external_gateway=self.ext_net_name,
1195 internal_subnets=[subnet4_settings.name])
1198 self.network_creator = OpenStackNetwork(
1199 self.os_creds, network_settings)
1200 self.network_creator.create()
1203 self.router_creator = OpenStackRouter(
1204 self.os_creds, router_settings)
1205 self.router_creator.create()
1207 port_settings = PortConfig(
1208 name=self.port1_name, network_name=network_settings.name)
1210 instance_settings = VmInstanceConfig(
1211 name=self.vm_inst_name,
1212 flavor=self.flavor_creator.flavor_settings.name,
1213 port_settings=[port_settings],
1214 security_group_names=[self.sec_grp_creator.sec_grp_settings.name],
1215 floating_ip_settings=[FloatingIpConfig(
1216 name='fip1', port_name=self.port1_name,
1217 router_name=router_settings.name)])
1219 self.inst_creator = OpenStackVmInstance(
1220 self.os_creds, instance_settings,
1221 self.image_creator.image_settings,
1222 keypair_settings=self.keypair_creator.keypair_settings)
1224 self.inst_creator.create(block=True)
1225 ssh_client = self.inst_creator.ssh_client()
1226 self.assertIsNotNone(ssh_client)
1229 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
1231 Test for the CreateInstance class with a single NIC/Port where mac and IP
1232 values are manually set
1237 Instantiates the CreateImage object that is responsible for downloading
1238 and creating an OS image file within OpenStack
1240 super(self.__class__, self).__start__()
1242 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1243 self.vm_inst_name = guid + '-inst'
1244 self.port_1_name = guid + 'port-1'
1245 self.port_2_name = guid + 'port-2'
1246 self.floating_ip_name = guid + 'fip1'
1248 # Initialize for tearDown()
1249 self.image_creator = None
1250 self.network_creator = None
1251 self.flavor_creator = None
1252 self.inst_creator = None
1254 self.net_config = openstack_tests.get_priv_net_config(
1255 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1256 router_name=guid + '-pub-router', external_net=self.ext_net_name,
1257 netconf_override=self.netconf_override)
1258 os_image_settings = openstack_tests.cirros_image_settings(
1259 name=guid + '-image', image_metadata=self.image_metadata)
1263 self.image_creator = OpenStackImage(self.os_creds,
1265 self.image_creator.create()
1268 self.network_creator = OpenStackNetwork(
1269 self.os_creds, self.net_config.network_settings)
1270 self.network_creator.create()
1273 self.flavor_creator = OpenStackFlavor(
1274 self.admin_os_creds,
1275 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
1276 vcpus=2, metadata=self.flavor_metadata))
1277 self.flavor_creator.create()
1278 except Exception as e:
1284 Cleans the created object
1286 if self.inst_creator:
1288 self.inst_creator.clean()
1289 except Exception as e:
1291 'Unexpected exception cleaning VM instance with message '
1294 if self.flavor_creator:
1296 self.flavor_creator.clean()
1297 except Exception as e:
1299 'Unexpected exception cleaning flavor with message - %s',
1302 if self.network_creator:
1304 self.network_creator.clean()
1305 except Exception as e:
1307 'Unexpected exception cleaning network with message - %s',
1310 if self.image_creator and not self.image_creator.image_settings.exists:
1312 self.image_creator.clean()
1313 except Exception as e:
1315 'Unexpected exception cleaning image with message - %s', e)
1317 super(self.__class__, self).__clean__()
1319 def test_set_custom_valid_ip_one_subnet(self):
1321 Tests the creation of an OpenStack instance with a single port with a
1322 static IP on a network with one subnet.
1325 sub_settings = self.net_config.network_settings.subnet_settings
1326 port_settings = PortConfig(
1327 name=self.port_1_name,
1328 network_name=self.net_config.network_settings.name,
1329 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1331 instance_settings = VmInstanceConfig(
1332 name=self.vm_inst_name,
1333 flavor=self.flavor_creator.flavor_settings.name,
1334 port_settings=[port_settings])
1336 self.inst_creator = OpenStackVmInstance(
1337 self.os_creds, instance_settings,
1338 self.image_creator.image_settings)
1339 self.inst_creator.create(block=True)
1341 self.assertEqual(ip, self.inst_creator.get_port_ip(
1343 subnet_name=self.net_config.network_settings.subnet_settings[
1346 def test_set_custom_invalid_ip_one_subnet(self):
1348 Tests the creation of an OpenStack instance with a single port with a
1349 static IP on a network with one subnet.
1352 sub_settings = self.net_config.network_settings.subnet_settings
1353 port_settings = PortConfig(
1354 name=self.port_1_name,
1355 network_name=self.net_config.network_settings.name,
1356 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1358 instance_settings = VmInstanceConfig(
1359 name=self.vm_inst_name,
1360 flavor=self.flavor_creator.flavor_settings.name,
1361 port_settings=[port_settings])
1363 self.inst_creator = OpenStackVmInstance(
1364 self.os_creds, instance_settings,
1365 self.image_creator.image_settings)
1367 with self.assertRaises(InvalidIpForSubnetClient):
1368 self.inst_creator.create()
1370 def test_set_custom_valid_mac(self):
1372 Tests the creation of an OpenStack instance with a single port where
1373 the MAC address is assigned.
1375 mac_addr = '0a:1b:2c:3d:4e:5f'
1376 port_settings = PortConfig(
1377 name=self.port_1_name,
1378 network_name=self.net_config.network_settings.name,
1379 mac_address=mac_addr)
1381 instance_settings = VmInstanceConfig(
1382 name=self.vm_inst_name,
1383 flavor=self.flavor_creator.flavor_settings.name,
1384 port_settings=[port_settings])
1386 self.inst_creator = OpenStackVmInstance(
1387 self.os_creds, instance_settings,
1388 self.image_creator.image_settings)
1389 self.inst_creator.create(block=True)
1391 self.assertEqual(mac_addr,
1392 self.inst_creator.get_port_mac(self.port_1_name))
1394 def test_set_custom_invalid_mac(self):
1396 Tests the creation of an OpenStack instance with a single port where an
1397 invalid MAC address value is being
1398 assigned. This should raise an Exception
1400 port_settings = PortConfig(
1401 name=self.port_1_name,
1402 network_name=self.net_config.network_settings.name,
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)
1414 with self.assertRaises(Exception):
1415 self.inst_creator.create()
1417 def test_set_custom_mac_and_ip(self):
1419 Tests the creation of an OpenStack instance with a single port where
1420 the IP and MAC address is assigned.
1423 mac_addr = '0a:1b:2c:3d:4e:5f'
1424 sub_settings = self.net_config.network_settings.subnet_settings
1425 port_settings = PortConfig(
1426 name=self.port_1_name,
1427 network_name=self.net_config.network_settings.name,
1428 mac_address=mac_addr,
1429 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
1431 instance_settings = VmInstanceConfig(
1432 name=self.vm_inst_name,
1433 flavor=self.flavor_creator.flavor_settings.name,
1434 port_settings=[port_settings])
1436 self.inst_creator = OpenStackVmInstance(
1437 self.os_creds, instance_settings,
1438 self.image_creator.image_settings)
1439 self.inst_creator.create(block=True)
1441 self.assertEqual(ip, self.inst_creator.get_port_ip(
1443 subnet_name=self.net_config.network_settings.subnet_settings[
1445 self.assertEqual(mac_addr,
1446 self.inst_creator.get_port_mac(self.port_1_name))
1448 def test_set_allowed_address_pairs(self):
1450 Tests the creation of an OpenStack instance with a single port where
1451 max_allowed_address_pair is set.
1454 mac_addr = '0a:1b:2c:3d:4e:5f'
1455 pair = {'ip_address': ip, 'mac_address': mac_addr}
1456 port_settings = PortConfig(
1457 name=self.port_1_name,
1458 network_name=self.net_config.network_settings.name,
1459 allowed_address_pairs=[pair])
1461 instance_settings = VmInstanceConfig(
1462 name=self.vm_inst_name,
1463 flavor=self.flavor_creator.flavor_settings.name,
1464 port_settings=[port_settings])
1466 self.inst_creator = OpenStackVmInstance(
1467 self.os_creds, instance_settings,
1468 self.image_creator.image_settings)
1469 self.inst_creator.create(block=True)
1471 port = self.inst_creator.get_port_by_name(port_settings.name)
1472 self.assertIsNotNone(port)
1473 self.assertIsNotNone(port.allowed_address_pairs)
1474 self.assertEqual(1, len(port.allowed_address_pairs))
1475 validation_utils.objects_equivalent(pair,
1476 port.allowed_address_pairs[0])
1478 def test_set_allowed_address_pairs_bad_mac(self):
1480 Tests the creation of an OpenStack instance with a single port where
1481 max_allowed_address_pair is set with an invalid MAC address.
1485 pair = {'ip_address': ip, 'mac_address': mac_addr}
1487 pairs.add((ip, mac_addr))
1488 port_settings = PortConfig(
1489 name=self.port_1_name,
1490 network_name=self.net_config.network_settings.name,
1491 allowed_address_pairs=[pair])
1493 instance_settings = VmInstanceConfig(
1494 name=self.vm_inst_name,
1495 flavor=self.flavor_creator.flavor_settings.name,
1496 port_settings=[port_settings])
1498 self.inst_creator = OpenStackVmInstance(
1499 self.os_creds, instance_settings,
1500 self.image_creator.image_settings)
1501 with self.assertRaises(Exception):
1502 self.inst_creator.create()
1504 def test_set_allowed_address_pairs_bad_ip(self):
1506 Tests the creation of an OpenStack instance with a single port where
1507 max_allowed_address_pair is set with an invalid MAC address.
1510 mac_addr = '0a:1b:2c:3d:4e:5f'
1511 pair = {'ip_address': ip, 'mac_address': mac_addr}
1513 pairs.add((ip, mac_addr))
1514 port_settings = PortConfig(
1515 name=self.port_1_name,
1516 network_name=self.net_config.network_settings.name,
1517 allowed_address_pairs=[pair])
1519 instance_settings = VmInstanceConfig(
1520 name=self.vm_inst_name,
1521 flavor=self.flavor_creator.flavor_settings.name,
1522 port_settings=[port_settings])
1524 self.inst_creator = OpenStackVmInstance(
1525 self.os_creds, instance_settings,
1526 self.image_creator.image_settings)
1527 with self.assertRaises(Exception):
1528 self.inst_creator.create()
1531 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1533 Test for the CreateInstance where one VM is deployed to each compute node
1538 Instantiates the CreateImage object that is responsible for downloading
1539 and creating an OS image file within OpenStack
1541 super(self.__class__, self).__start__()
1543 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1544 self.vm_inst_name = guid + '-inst'
1545 self.port_base_name = guid + 'port'
1547 # Initialize for tearDown()
1548 self.image_creator = None
1549 self.flavor_creator = None
1550 self.network_creator = None
1551 self.inst_creators = list()
1553 self.priv_net_config = openstack_tests.get_priv_net_config(
1554 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet',
1555 netconf_override=self.netconf_override)
1557 os_image_settings = openstack_tests.cirros_image_settings(
1558 name=guid + '-image', image_metadata=self.image_metadata)
1562 self.network_creator = OpenStackNetwork(
1563 self.admin_os_creds, self.priv_net_config.network_settings)
1564 self.network_creator.create()
1567 self.flavor_creator = OpenStackFlavor(
1568 self.admin_os_creds,
1569 FlavorConfig(name=guid + '-flavor-name', ram=512, disk=1,
1570 vcpus=1, metadata=self.flavor_metadata))
1571 self.flavor_creator.create()
1574 self.image_creator = OpenStackImage(self.os_creds,
1576 self.image_creator.create()
1578 except Exception as e:
1584 Cleans the created object
1586 for inst_creator in self.inst_creators:
1588 inst_creator.clean()
1589 except Exception as e:
1591 'Unexpected exception cleaning VM instance with message '
1594 if self.flavor_creator:
1596 self.flavor_creator.clean()
1597 except Exception as e:
1599 'Unexpected exception cleaning flavor with message - %s',
1602 if self.network_creator:
1604 self.network_creator.clean()
1605 except Exception as e:
1607 'Unexpected exception cleaning network with message - %s',
1610 if self.image_creator and not self.image_creator.image_settings.exists:
1612 self.image_creator.clean()
1613 except Exception as e:
1615 'Unexpected exception cleaning image with message - %s', e)
1617 super(self.__class__, self).__clean__()
1619 def test_deploy_vm_to_each_compute_node(self):
1621 Tests the creation of OpenStack VM instances to each compute node.
1623 from snaps.openstack.utils import nova_utils
1624 nova = nova_utils.nova_client(self.admin_os_creds)
1625 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1627 # Create Instance on each server/zone
1629 for zone in zone_hosts:
1630 inst_name = self.vm_inst_name + '-' + zone
1632 port_settings = PortConfig(
1633 name=self.port_base_name + '-' + str(ctr),
1634 network_name=self.priv_net_config.network_settings.name)
1636 instance_settings = VmInstanceConfig(
1638 flavor=self.flavor_creator.flavor_settings.name,
1639 availability_zone=zone,
1640 port_settings=[port_settings])
1641 inst_creator = OpenStackVmInstance(
1642 self.admin_os_creds, instance_settings,
1643 self.image_creator.image_settings)
1644 self.inst_creators.append(inst_creator)
1645 inst_creator.create(block=True)
1646 avail_zone = inst_creator.get_vm_inst().availability_zone
1647 self.assertTrue(avail_zone in zone)
1648 compute_host = inst_creator.get_vm_inst().compute_host
1649 self.assertTrue(compute_host in zone)
1651 # Validate instances to ensure they've been deployed to the correct
1654 for zone in zone_hosts:
1655 creator = self.inst_creators[index]
1656 self.assertTrue(creator.vm_active(block=True))
1657 info = creator.get_vm_info()
1658 deployed_zone = info['OS-EXT-AZ:availability_zone']
1659 deployed_host = info['OS-EXT-SRV-ATTR:host']
1660 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1664 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1666 Tests that include, add, and remove security groups from VM instances
1671 Instantiates the CreateImage object that is responsible for downloading
1672 and creating an OS image file within OpenStack
1674 super(self.__class__, self).__start__()
1676 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1677 self.vm_inst_name = self.guid + '-inst'
1678 self.nova = nova_utils.nova_client(self.os_creds)
1679 os_image_settings = openstack_tests.cirros_image_settings(
1680 name=self.guid + '-image', image_metadata=self.image_metadata)
1682 self.vm_inst_name = self.guid + '-inst'
1683 self.port_1_name = self.guid + 'port-1'
1684 self.port_2_name = self.guid + 'port-2'
1685 self.floating_ip_name = self.guid + 'fip1'
1687 net_config = openstack_tests.get_priv_net_config(
1688 net_name=self.guid + '-pub-net',
1689 subnet_name=self.guid + '-pub-subnet',
1690 router_name=self.guid + '-pub-router',
1691 external_net=self.ext_net_name,
1692 netconf_override=self.netconf_override)
1694 # Initialize for tearDown()
1695 self.image_creator = None
1696 self.flavor_creator = None
1697 self.network_creator = None
1698 self.router_creator = None
1699 self.inst_creator = None
1700 self.sec_grp_creators = list()
1704 self.image_creator = OpenStackImage(self.os_creds,
1706 self.image_creator.create()
1709 self.network_creator = OpenStackNetwork(
1710 self.os_creds, net_config.network_settings)
1711 self.network_creator.create()
1714 self.flavor_creator = OpenStackFlavor(
1715 self.admin_os_creds,
1716 FlavorConfig(name=self.guid + '-flavor-name', ram=256,
1718 metadata=self.flavor_metadata))
1719 self.flavor_creator.create()
1721 self.port_settings = PortConfig(
1722 name=self.guid + '-port',
1723 network_name=net_config.network_settings.name)
1724 except Exception as e:
1730 Cleans the created object
1732 if self.inst_creator:
1734 self.inst_creator.clean()
1735 except Exception as e:
1737 'Unexpected exception cleaning VM instance with message -'
1740 for sec_grp_creator in self.sec_grp_creators:
1742 sec_grp_creator.clean()
1743 except Exception as e:
1745 'Unexpected exception cleaning security group with message'
1748 if self.flavor_creator:
1750 self.flavor_creator.clean()
1751 except Exception as e:
1753 'Unexpected exception cleaning flavor with message - %s',
1756 if self.network_creator:
1758 self.network_creator.clean()
1759 except Exception as e:
1761 'Unexpected exception cleaning network with message - %s',
1764 if self.image_creator and not self.image_creator.image_settings.exists:
1766 self.image_creator.clean()
1767 except Exception as e:
1769 'Unexpected exception cleaning image with message - %s', e)
1771 super(self.__class__, self).__clean__()
1773 def test_add_security_group(self):
1775 Tests the addition of a security group created after the instance.
1778 instance_settings = VmInstanceConfig(
1779 name=self.vm_inst_name,
1780 flavor=self.flavor_creator.flavor_settings.name,
1781 port_settings=[self.port_settings])
1782 self.inst_creator = OpenStackVmInstance(
1783 self.os_creds, instance_settings,
1784 self.image_creator.image_settings)
1785 vm_inst = self.inst_creator.create(block=True)
1786 self.assertIsNotNone(vm_inst)
1788 # Create security group object to add to instance
1789 sec_grp_settings = SecurityGroupConfig(
1790 name=self.guid + '-name', description='hello group')
1791 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1793 sec_grp = sec_grp_creator.create()
1794 self.sec_grp_creators.append(sec_grp_creator)
1796 # Check that group has not been added
1797 self.assertFalse(inst_has_sec_grp(
1798 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1800 # Add security group to instance after activated
1801 self.inst_creator.add_security_group(sec_grp)
1803 # Validate that security group has been added
1804 self.assertTrue(inst_has_sec_grp(
1805 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1807 def test_add_invalid_security_group(self):
1809 Tests the addition of a security group that no longer exists.
1812 instance_settings = VmInstanceConfig(
1813 name=self.vm_inst_name,
1814 flavor=self.flavor_creator.flavor_settings.name,
1815 port_settings=[self.port_settings])
1816 self.inst_creator = OpenStackVmInstance(
1817 self.os_creds, instance_settings,
1818 self.image_creator.image_settings)
1819 vm_inst = self.inst_creator.create(block=True)
1820 self.assertIsNotNone(vm_inst)
1822 # Create security group object to add to instance
1823 sec_grp_settings = SecurityGroupConfig(
1824 name=self.guid + '-name', description='hello group')
1825 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1827 sec_grp = sec_grp_creator.create()
1828 sec_grp_creator.clean()
1829 self.sec_grp_creators.append(sec_grp_creator)
1831 # Check that group has not been added
1832 self.assertFalse(inst_has_sec_grp(
1833 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1835 # Add security group to instance after activated
1836 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1838 # Validate that security group has been added
1839 self.assertFalse(inst_has_sec_grp(
1840 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1842 def test_remove_security_group(self):
1844 Tests the removal of a security group created before and added to the
1847 # Create security group object to add to instance
1848 sec_grp_settings = SecurityGroupConfig(
1849 name=self.guid + '-name', description='hello group')
1850 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1852 sec_grp = sec_grp_creator.create()
1853 self.sec_grp_creators.append(sec_grp_creator)
1856 instance_settings = VmInstanceConfig(
1857 name=self.vm_inst_name,
1858 flavor=self.flavor_creator.flavor_settings.name,
1859 security_group_names=[sec_grp_settings.name],
1860 port_settings=[self.port_settings])
1861 self.inst_creator = OpenStackVmInstance(
1862 self.os_creds, instance_settings,
1863 self.image_creator.image_settings)
1864 vm_inst = self.inst_creator.create(block=True)
1865 self.assertIsNotNone(vm_inst)
1867 # Check that group has been added
1868 self.assertTrue(inst_has_sec_grp(
1869 self.nova, vm_inst, sec_grp_settings.name))
1871 # Add security group to instance after activated
1872 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1874 # Validate that security group has been added
1875 self.assertFalse(inst_has_sec_grp(
1876 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1878 def test_remove_security_group_never_added(self):
1880 Tests the removal of a security group that was never added in the first
1883 # Create security group object to add to instance
1884 sec_grp_settings = SecurityGroupConfig(
1885 name=self.guid + '-name', description='hello group')
1886 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1888 sec_grp = sec_grp_creator.create()
1889 self.sec_grp_creators.append(sec_grp_creator)
1892 instance_settings = VmInstanceConfig(
1893 name=self.vm_inst_name,
1894 flavor=self.flavor_creator.flavor_settings.name,
1895 port_settings=[self.port_settings])
1896 self.inst_creator = OpenStackVmInstance(
1897 self.os_creds, instance_settings,
1898 self.image_creator.image_settings)
1899 vm_inst = self.inst_creator.create(block=True)
1900 self.assertIsNotNone(vm_inst)
1902 # Check that group has been added
1903 self.assertFalse(inst_has_sec_grp(
1904 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1906 # Add security group to instance after activated
1907 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1909 # Validate that security group has been added
1910 self.assertFalse(inst_has_sec_grp(
1911 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1913 def test_add_same_security_group(self):
1915 Tests the addition of a security group created before add added to the
1918 # Create security group object to add to instance
1919 sec_grp_settings = SecurityGroupConfig(
1920 name=self.guid + '-name', description='hello group')
1921 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1923 sec_grp = sec_grp_creator.create()
1924 self.sec_grp_creators.append(sec_grp_creator)
1927 instance_settings = VmInstanceConfig(
1928 name=self.vm_inst_name,
1929 flavor=self.flavor_creator.flavor_settings.name,
1930 security_group_names=[sec_grp_settings.name],
1931 port_settings=[self.port_settings])
1932 self.inst_creator = OpenStackVmInstance(
1933 self.os_creds, instance_settings,
1934 self.image_creator.image_settings)
1935 vm_inst = self.inst_creator.create(block=True)
1936 self.assertIsNotNone(vm_inst)
1938 # Check that group has been added
1939 self.assertTrue(inst_has_sec_grp(
1940 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1942 # Add security group to instance after activated
1943 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1945 # Validate that security group has been added
1946 self.assertTrue(inst_has_sec_grp(
1947 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1950 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1952 Returns true if instance has a security group of a given name
1953 :param nova: the nova client
1954 :param vm_inst: the VmInst domain object
1955 :param sec_grp_name: the name of the security group to validate
1958 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1959 for name in sec_grp_names:
1960 if sec_grp_name == name:
1965 def validate_ssh_client(instance_creator, fip_name=None):
1967 Returns True if instance_creator returns an SSH client that is valid
1968 :param instance_creator: the object responsible for creating the VM
1970 :param fip_name: the name of the floating IP to use
1973 ssh_active = instance_creator.vm_ssh_active(block=True)
1976 ssh_client = instance_creator.ssh_client(fip_name=fip_name)
1979 out = ssh_client.exec_command('pwd')[1]
1980 channel = out.channel
1981 in_buffer = channel.in_buffer
1982 pwd_out = in_buffer.read(1024)
1983 if not pwd_out or len(pwd_out) < 10:
1994 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
1996 Test for the CreateInstance class for creating an image from a 3-part image
2001 Instantiates the CreateImage object that is responsible for downloading
2002 and creating an OS image file within OpenStack
2004 super(self.__class__, self).__start__()
2006 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2007 self.image_name = guid
2008 self.vm_inst_name = guid + '-inst'
2009 self.nova = nova_utils.nova_client(self.os_creds)
2011 net_config = openstack_tests.get_priv_net_config(
2012 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2013 router_name=guid + '-pub-router', external_net=self.ext_net_name,
2014 netconf_override=self.netconf_override)
2016 # Initialize for tearDown()
2017 self.image_creator = None
2018 self.network_creator = None
2019 self.flavor_creator = None
2020 self.inst_creator = None
2023 if self.image_metadata and 'disk_file' in self.image_metadata:
2024 metadata = self.image_metadata
2025 elif self.image_metadata and 'cirros' in self.image_metadata \
2026 and 'disk_file' in self.image_metadata['cirros']:
2027 metadata = self.image_metadata['cirros']
2030 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
2032 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
2034 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
2036 image_settings = openstack_tests.cirros_image_settings(
2037 name=self.image_name,
2038 image_metadata=metadata)
2040 if not image_settings.ramdisk_image_settings or not \
2041 image_settings.kernel_image_settings:
2043 '3 Part image will not be tested. Image metadata has '
2044 'overridden this functionality')
2046 self.image_creator = OpenStackImage(self.os_creds, image_settings)
2047 self.image_creator.create()
2050 self.flavor_creator = OpenStackFlavor(
2051 self.admin_os_creds,
2052 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=10,
2053 vcpus=2, metadata=self.flavor_metadata))
2054 self.flavor_creator.create()
2057 self.network_creator = OpenStackNetwork(
2058 self.os_creds, net_config.network_settings)
2059 self.network_creator.create()
2061 self.port_settings = PortConfig(
2062 name=guid + '-port',
2063 network_name=net_config.network_settings.name)
2064 except Exception as e:
2070 Cleans the created object
2072 if self.inst_creator:
2074 self.inst_creator.clean()
2075 except Exception as e:
2077 'Unexpected exception cleaning VM instance with message -'
2080 if self.flavor_creator:
2082 self.flavor_creator.clean()
2083 except Exception as e:
2085 'Unexpected exception cleaning flavor with message - %s',
2088 if self.network_creator:
2090 self.network_creator.clean()
2091 except Exception as e:
2093 'Unexpected exception cleaning network with message - %s',
2096 if self.image_creator and not self.image_creator.image_settings.exists:
2098 self.image_creator.clean()
2099 except Exception as e:
2101 'Unexpected exception cleaning image with message - %s', e)
2103 super(self.__class__, self).__clean__()
2105 def test_create_instance_from_three_part_image(self):
2107 Tests the creation of an OpenStack instance from a 3-part image.
2109 instance_settings = VmInstanceConfig(
2110 name=self.vm_inst_name,
2111 flavor=self.flavor_creator.flavor_settings.name,
2112 port_settings=[self.port_settings])
2114 # The last created image is the main image from which we create the
2116 self.inst_creator = OpenStackVmInstance(
2117 self.os_creds, instance_settings,
2118 self.image_creator.image_settings)
2120 vm_inst = self.inst_creator.create()
2121 self.assertIsNotNone(vm_inst)
2122 self.assertTrue(self.inst_creator.vm_active(block=True))
2125 class CreateInstanceMockOfflineTests(OSComponentTestCase):
2127 Tests the custom image_metadata that can be set by clients for handling
2128 images differently than the default behavior of the existing tests
2129 primarily for offline testing
2134 Instantiates the CreateImage object that is responsible for downloading
2135 and creating an OS image file within OpenStack
2137 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2139 self.tmpDir = 'tmp/' + str(self.guid)
2140 if not os.path.exists(self.tmpDir):
2141 os.makedirs(self.tmpDir)
2143 self.image_name = self.guid + '-image'
2144 self.vm_inst_name = self.guid + '-inst'
2145 self.port_1_name = self.guid + 'port-1'
2147 # Initialize for tearDown()
2148 self.image_creator = None
2149 self.network_creator = None
2150 self.flavor_creator = None
2151 self.inst_creator = None
2153 self.priv_net_config = openstack_tests.get_priv_net_config(
2154 net_name=self.guid + '-priv-net',
2155 subnet_name=self.guid + '-priv-subnet')
2156 self.port_settings = PortConfig(
2157 name=self.port_1_name,
2158 network_name=self.priv_net_config.network_settings.name)
2161 # Download image file
2162 self.image_file = file_utils.download(
2163 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
2166 self.network_creator = OpenStackNetwork(
2167 self.os_creds, self.priv_net_config.network_settings)
2168 self.network_creator.create()
2171 self.flavor_creator = OpenStackFlavor(
2174 name=self.guid + '-flavor-name', ram=256, disk=10,
2176 self.flavor_creator.create()
2177 except Exception as e:
2183 Cleans the created object
2185 if self.inst_creator:
2187 self.inst_creator.clean()
2188 except Exception as e:
2190 'Unexpected exception cleaning VM instance with message - '
2193 if self.network_creator:
2195 self.network_creator.clean()
2196 except Exception as e:
2198 'Unexpected exception cleaning network with message - %s',
2201 if self.flavor_creator:
2203 self.flavor_creator.clean()
2204 except Exception as e:
2206 'Unexpected exception cleaning flavor with message - %s',
2209 if self.image_creator:
2211 self.image_creator.clean()
2212 except Exception as e:
2214 'Unexpected exception cleaning image with message - %s', e)
2216 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2217 shutil.rmtree(self.tmpDir)
2219 def test_inst_from_file_image_simple_flat(self):
2221 Creates a VM instance from a locally sourced file image using simply
2222 the 'disk_file' attribute vs. using the 'config' option which
2223 completely overrides all image settings
2226 metadata = {'disk_file': self.image_file.name}
2228 os_image_settings = openstack_tests.cirros_image_settings(
2229 name=self.image_name, image_metadata=metadata)
2230 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2231 self.assertEqual(openstack_tests.CIRROS_USER,
2232 os_image_settings.image_user)
2233 self.assertIsNone(os_image_settings.url)
2234 self.assertFalse(os_image_settings.exists)
2235 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2236 os_image_settings.format)
2238 self.assertIsNone(os_image_settings.kernel_image_settings)
2239 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2241 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2242 self.image_creator.create()
2244 instance_settings = VmInstanceConfig(
2245 name=self.vm_inst_name,
2246 flavor=self.flavor_creator.flavor_settings.name,
2247 port_settings=[self.port_settings])
2248 self.inst_creator = OpenStackVmInstance(
2249 self.os_creds, instance_settings,
2250 self.image_creator.image_settings)
2251 self.inst_creator.create()
2253 self.assertTrue(self.inst_creator.vm_active(block=True))
2255 def test_inst_from_file_image_simple_nested(self):
2257 Creates a VM instance from a locally sourced file image using simply
2258 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2259 which completely overrides all image settings
2262 metadata = {'cirros': {'disk_file': self.image_file.name}}
2264 os_image_settings = openstack_tests.cirros_image_settings(
2265 name=self.image_name, image_metadata=metadata)
2266 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2267 self.assertEqual(openstack_tests.CIRROS_USER,
2268 os_image_settings.image_user)
2269 self.assertIsNone(os_image_settings.url)
2270 self.assertFalse(os_image_settings.exists)
2271 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2272 os_image_settings.format)
2274 self.assertIsNone(os_image_settings.kernel_image_settings)
2275 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2277 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2278 self.image_creator.create()
2280 instance_settings = VmInstanceConfig(
2281 name=self.vm_inst_name,
2282 flavor=self.flavor_creator.flavor_settings.name,
2283 port_settings=[self.port_settings])
2284 self.inst_creator = OpenStackVmInstance(
2285 self.os_creds, instance_settings,
2286 self.image_creator.image_settings)
2287 self.inst_creator.create()
2289 self.assertTrue(self.inst_creator.vm_active(block=True))
2291 def test_inst_from_existing(self):
2293 Creates a VM instance from a image creator that has been configured to
2294 use an existing image
2297 os_image_settings = openstack_tests.cirros_image_settings(
2298 name=self.image_name)
2299 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2300 self.image_creator.create()
2302 image_settings = self.image_creator.image_settings
2303 test_image_creator = OpenStackImage(
2306 name=image_settings.name, image_user=image_settings.image_user,
2308 test_image_creator.create()
2309 self.assertEqual(self.image_creator.get_image().id,
2310 test_image_creator.get_image().id)
2312 instance_settings = VmInstanceConfig(
2313 name=self.vm_inst_name,
2314 flavor=self.flavor_creator.flavor_settings.name,
2315 port_settings=[self.port_settings])
2316 self.inst_creator = OpenStackVmInstance(
2317 self.os_creds, instance_settings,
2318 test_image_creator.image_settings)
2319 self.inst_creator.create()
2321 self.assertTrue(self.inst_creator.vm_active(block=True))
2323 def test_inst_from_file_image_complex(self):
2325 Creates a VM instance from a locally sourced file image by overriding
2326 the default settings by using a dict() that can be read in by
2331 os_image_settings = openstack_tests.cirros_image_settings(
2332 name=self.image_name)
2333 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2334 self.image_creator.create()
2339 'name': os_image_settings.name,
2340 'image_user': os_image_settings.image_user,
2342 test_image_settings = openstack_tests.cirros_image_settings(
2343 image_metadata=metadata)
2344 test_image = OpenStackImage(self.os_creds, test_image_settings)
2347 instance_settings = VmInstanceConfig(
2348 name=self.vm_inst_name,
2349 flavor=self.flavor_creator.flavor_settings.name,
2350 port_settings=[self.port_settings])
2351 self.inst_creator = OpenStackVmInstance(self.os_creds,
2353 test_image_settings)
2354 self.inst_creator.create()
2356 self.assertTrue(self.inst_creator.vm_active(block=True))
2358 def test_inst_from_file_3part_image_complex(self):
2360 Creates a VM instance from a locally sourced file image by overriding
2361 the default settings by using a dict() that can be read in by
2366 kernel_file = file_utils.download(
2367 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2368 ramdisk_file = file_utils.download(
2369 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2374 'name': self.image_name,
2375 'image_user': openstack_tests.CIRROS_USER,
2376 'image_file': self.image_file.name,
2377 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2378 'kernel_image_settings': {
2379 'name': self.image_name + '-kernel',
2380 'image_user': openstack_tests.CIRROS_USER,
2381 'image_file': kernel_file.name,
2382 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2383 'ramdisk_image_settings': {
2384 'name': self.image_name + '-ramdisk',
2385 'image_user': openstack_tests.CIRROS_USER,
2386 'image_file': ramdisk_file.name,
2387 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2389 os_image_settings = openstack_tests.cirros_image_settings(
2390 name=self.image_name, image_metadata=metadata)
2391 self.assertEqual(self.image_name, os_image_settings.name)
2392 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2393 self.assertEqual(openstack_tests.CIRROS_USER,
2394 os_image_settings.image_user)
2395 self.assertIsNone(os_image_settings.url)
2396 self.assertFalse(os_image_settings.exists)
2397 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2398 os_image_settings.format)
2400 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2401 self.assertEqual(self.image_name + '-kernel',
2402 os_image_settings.kernel_image_settings.name)
2403 self.assertEqual(kernel_file.name,
2404 os_image_settings.kernel_image_settings.image_file)
2405 self.assertEqual(openstack_tests.CIRROS_USER,
2406 os_image_settings.kernel_image_settings.image_user)
2407 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2408 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2409 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2410 os_image_settings.kernel_image_settings.format)
2412 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2413 self.assertEqual(self.image_name + '-ramdisk',
2414 os_image_settings.ramdisk_image_settings.name)
2415 self.assertEqual(ramdisk_file.name,
2416 os_image_settings.ramdisk_image_settings.image_file)
2417 self.assertEqual(openstack_tests.CIRROS_USER,
2418 os_image_settings.ramdisk_image_settings.image_user)
2419 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2420 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2421 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2422 os_image_settings.ramdisk_image_settings.format)
2424 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2425 self.image_creator.create()
2427 instance_settings = VmInstanceConfig(
2428 name=self.vm_inst_name,
2429 flavor=self.flavor_creator.flavor_settings.name,
2430 port_settings=[self.port_settings])
2431 self.inst_creator = OpenStackVmInstance(
2432 self.os_creds, instance_settings,
2433 self.image_creator.image_settings)
2434 self.inst_creator.create()
2436 self.assertTrue(self.inst_creator.vm_active(block=True))
2438 def test_inst_from_file_3part_image_simple_flat(self):
2440 Creates a VM instance from a 3-part image locally sourced from file
2441 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2442 attributes vs. using the 'config' option which completely overrides all
2446 kernel_file = file_utils.download(
2447 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2448 ramdisk_file = file_utils.download(
2449 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2451 metadata = {'disk_file': self.image_file.name,
2452 'kernel_file': kernel_file.name,
2453 'ramdisk_file': ramdisk_file.name}
2455 os_image_settings = openstack_tests.cirros_image_settings(
2456 name=self.image_name, image_metadata=metadata)
2458 self.assertEqual(self.image_name, os_image_settings.name)
2459 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2460 self.assertEqual(openstack_tests.CIRROS_USER,
2461 os_image_settings.image_user)
2462 self.assertIsNone(os_image_settings.url)
2463 self.assertFalse(os_image_settings.exists)
2464 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2465 os_image_settings.format)
2467 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2468 self.assertEqual(self.image_name + '-kernel',
2469 os_image_settings.kernel_image_settings.name)
2470 self.assertEqual(kernel_file.name,
2471 os_image_settings.kernel_image_settings.image_file)
2472 self.assertEqual(openstack_tests.CIRROS_USER,
2473 os_image_settings.kernel_image_settings.image_user)
2474 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2475 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2476 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2477 os_image_settings.kernel_image_settings.format)
2479 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2480 self.assertEqual(self.image_name + '-ramdisk',
2481 os_image_settings.ramdisk_image_settings.name)
2482 self.assertEqual(ramdisk_file.name,
2483 os_image_settings.ramdisk_image_settings.image_file)
2484 self.assertEqual(openstack_tests.CIRROS_USER,
2485 os_image_settings.ramdisk_image_settings.image_user)
2486 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2487 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2488 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2489 os_image_settings.ramdisk_image_settings.format)
2491 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2492 self.image_creator.create()
2494 self.assertIsNotNone(self.image_creator.get_kernel_image())
2495 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2497 instance_settings = VmInstanceConfig(
2498 name=self.vm_inst_name,
2499 flavor=self.flavor_creator.flavor_settings.name,
2500 port_settings=[self.port_settings])
2501 self.inst_creator = OpenStackVmInstance(
2502 self.os_creds, instance_settings,
2503 self.image_creator.image_settings)
2504 self.inst_creator.create()
2506 self.assertTrue(self.inst_creator.vm_active(block=True))
2508 def test_inst_from_file_3part_image_simple_nested(self):
2510 Creates a VM instance from a 3-part image locally sourced from file
2511 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2512 attributes under 'cirros' vs. using the 'config' option which
2513 completely overrides all image settings
2516 kernel_file = file_utils.download(
2517 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2518 ramdisk_file = file_utils.download(
2519 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2521 metadata = {'cirros': {'disk_file': self.image_file.name,
2522 'kernel_file': kernel_file.name,
2523 'ramdisk_file': ramdisk_file.name}}
2525 os_image_settings = openstack_tests.cirros_image_settings(
2526 name=self.image_name, image_metadata=metadata)
2528 self.assertEqual(self.image_name, os_image_settings.name)
2529 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2530 self.assertEqual(openstack_tests.CIRROS_USER,
2531 os_image_settings.image_user)
2532 self.assertIsNone(os_image_settings.url)
2533 self.assertFalse(os_image_settings.exists)
2534 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2535 os_image_settings.format)
2537 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2538 self.assertEqual(self.image_name + '-kernel',
2539 os_image_settings.kernel_image_settings.name)
2540 self.assertEqual(kernel_file.name,
2541 os_image_settings.kernel_image_settings.image_file)
2542 self.assertEqual(openstack_tests.CIRROS_USER,
2543 os_image_settings.kernel_image_settings.image_user)
2544 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2545 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2546 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2547 os_image_settings.kernel_image_settings.format)
2549 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2550 self.assertEqual(self.image_name + '-ramdisk',
2551 os_image_settings.ramdisk_image_settings.name)
2552 self.assertEqual(ramdisk_file.name,
2553 os_image_settings.ramdisk_image_settings.image_file)
2554 self.assertEqual(openstack_tests.CIRROS_USER,
2555 os_image_settings.ramdisk_image_settings.image_user)
2556 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2557 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2558 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2559 os_image_settings.ramdisk_image_settings.format)
2561 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2562 self.image_creator.create()
2564 self.assertIsNotNone(self.image_creator.get_kernel_image())
2565 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2567 instance_settings = VmInstanceConfig(
2568 name=self.vm_inst_name,
2569 flavor=self.flavor_creator.flavor_settings.name,
2570 port_settings=[self.port_settings])
2571 self.inst_creator = OpenStackVmInstance(
2572 self.os_creds, instance_settings,
2573 self.image_creator.image_settings)
2574 self.inst_creator.create()
2576 self.assertTrue(self.inst_creator.vm_active(block=True))
2578 def test_inst_from_file_3part_image_existing(self):
2580 Creates a VM instance from a 3-part image that is existing
2583 kernel_file = file_utils.download(
2584 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2585 ramdisk_file = file_utils.download(
2586 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2588 metadata = {'cirros': {'disk_file': self.image_file.name,
2589 'kernel_file': kernel_file.name,
2590 'ramdisk_file': ramdisk_file.name}}
2592 os_image_settings = openstack_tests.cirros_image_settings(
2593 name=self.image_name, image_metadata=metadata)
2594 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2595 self.image_creator.create()
2597 image_settings = self.image_creator.image_settings
2598 test_image_creator = OpenStackImage(
2601 name=image_settings.name, image_user=image_settings.image_user,
2603 test_image_creator.create()
2604 self.assertEqual(self.image_creator.get_image().id,
2605 test_image_creator.get_image().id)
2607 instance_settings = VmInstanceConfig(
2608 name=self.vm_inst_name,
2609 flavor=self.flavor_creator.flavor_settings.name,
2610 port_settings=[self.port_settings])
2611 self.inst_creator = OpenStackVmInstance(
2612 self.os_creds, instance_settings,
2613 test_image_creator.image_settings)
2614 self.inst_creator.create()
2616 self.assertTrue(self.inst_creator.vm_active(block=True))
2619 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2621 Tests the ability of two VMs to communicate when attached to separate
2622 private networks that are tied together with a router.
2627 Instantiates the CreateImage object that is responsible for downloading
2628 and creating an OS image file within OpenStack
2630 super(self.__class__, self).__start__()
2632 cidr1 = '10.200.201.0/24'
2633 cidr2 = '10.200.202.0/24'
2634 static_gateway_ip1 = '10.200.201.1'
2635 static_gateway_ip2 = '10.200.202.1'
2636 self.ip1 = '10.200.201.5'
2637 self.ip2 = '10.200.202.5'
2639 self.nova = nova_utils.nova_client(self.os_creds)
2641 # Initialize for tearDown()
2642 self.image_creator = None
2643 self.network_creators = list()
2644 self.router_creator = None
2645 self.flavor_creator = None
2646 self.sec_grp_creator = None
2647 self.inst_creators = list()
2649 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2650 self.vm_inst1_name = self.guid + '-inst1'
2651 self.vm_inst2_name = self.guid + '-inst2'
2652 self.port_1_name = self.guid + '-vm1-port'
2653 self.port_2_name = self.guid + '-vm2-port'
2654 self.net_config_1 = NetworkConfig(
2655 name=self.guid + '-net1',
2657 create_network.SubnetConfig(
2658 cidr=cidr1, name=self.guid + '-subnet1',
2659 gateway_ip=static_gateway_ip1)])
2660 self.net_config_2 = NetworkConfig(
2661 name=self.guid + '-net2',
2663 create_network.SubnetConfig(
2664 cidr=cidr2, name=self.guid + '-subnet2',
2665 gateway_ip=static_gateway_ip2)])
2667 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2668 os_image_settings = openstack_tests.cirros_image_settings(
2669 name=image_name, image_metadata=self.image_metadata)
2673 self.image_creator = OpenStackImage(
2674 self.os_creds, os_image_settings)
2675 self.image_creator.create()
2677 # First network is public
2678 self.network_creators.append(OpenStackNetwork(
2679 self.os_creds, self.net_config_1))
2681 # Second network is private
2682 self.network_creators.append(OpenStackNetwork(
2683 self.os_creds, self.net_config_2))
2684 for network_creator in self.network_creators:
2685 network_creator.create()
2689 name=self.guid + '-router-port1',
2692 self.net_config_1.subnet_settings[0].name,
2693 'ip': static_gateway_ip1
2695 network_name=self.net_config_1.name),
2697 name=self.guid + '-router-port2',
2700 self.net_config_2.subnet_settings[0].name,
2701 'ip': static_gateway_ip2
2703 network_name=self.net_config_2.name)]
2705 router_settings = RouterConfig(
2706 name=self.guid + '-pub-router', port_settings=port_settings)
2707 self.router_creator = OpenStackRouter(
2708 self.os_creds, router_settings)
2709 self.router_creator.create()
2711 self.flavor_creator = OpenStackFlavor(
2712 self.admin_os_creds,
2713 FlavorConfig(name=self.guid + '-flavor-name', ram=512,
2715 metadata=self.flavor_metadata))
2716 self.flavor_creator.create()
2718 sec_grp_name = self.guid + '-sec-grp'
2719 rule1 = SecurityGroupRuleConfig(
2720 sec_grp_name=sec_grp_name, direction=Direction.ingress,
2721 protocol=Protocol.icmp)
2722 self.sec_grp_creator = OpenStackSecurityGroup(
2724 SecurityGroupConfig(
2725 name=sec_grp_name, rule_settings=[rule1]))
2726 self.sec_grp_creator.create()
2733 Cleans the created objects
2735 for inst_creator in self.inst_creators:
2737 inst_creator.clean()
2738 except Exception as e:
2740 'Unexpected exception cleaning VM instance with message '
2743 if self.flavor_creator:
2745 self.flavor_creator.clean()
2746 except Exception as e:
2748 'Unexpected exception cleaning flavor with message - %s',
2751 if self.router_creator:
2753 self.router_creator.clean()
2754 except Exception as e:
2756 'Unexpected exception cleaning router with message - %s',
2759 for network_creator in self.network_creators:
2761 network_creator.clean()
2762 except Exception as e:
2764 'Unexpected exception cleaning network with message - %s',
2767 if self.sec_grp_creator:
2769 self.sec_grp_creator.clean()
2770 except Exception as e:
2772 'Unexpected exception cleaning security group with message'
2775 if self.image_creator and not self.image_creator.image_settings.exists:
2777 self.image_creator.clean()
2778 except Exception as e:
2780 'Unexpected exception cleaning image with message - %s', e)
2782 super(self.__class__, self).__clean__()
2784 def test_ping_via_router(self):
2786 Tests the creation of two OpenStack instances with one port on
2787 different private networks wit a router in between to ensure that they
2791 # Create ports/NICs for instance
2794 for network_creator in self.network_creators:
2795 ports_settings.append(PortConfig(
2796 name=self.guid + '-port-' + str(ctr),
2797 network_name=network_creator.network_settings.name))
2800 # Configure instances
2801 instance1_settings = VmInstanceConfig(
2802 name=self.vm_inst1_name,
2803 flavor=self.flavor_creator.flavor_settings.name,
2804 userdata=_get_ping_userdata(self.ip2),
2805 port_settings=[PortConfig(
2806 name=self.port_1_name,
2809 self.net_config_1.subnet_settings[0].name,
2812 network_name=self.network_creators[0].network_settings.name)])
2813 instance2_settings = VmInstanceConfig(
2814 name=self.vm_inst2_name,
2815 flavor=self.flavor_creator.flavor_settings.name,
2816 userdata=_get_ping_userdata(self.ip1),
2817 port_settings=[PortConfig(
2818 name=self.port_2_name,
2821 self.net_config_2.subnet_settings[0].name,
2824 network_name=self.network_creators[1].network_settings.name)])
2827 self.inst_creators.append(OpenStackVmInstance(
2828 self.os_creds, instance1_settings,
2829 self.image_creator.image_settings))
2830 self.inst_creators.append(OpenStackVmInstance(
2831 self.os_creds, instance2_settings,
2832 self.image_creator.image_settings))
2834 for inst_creator in self.inst_creators:
2835 inst_creator.create(block=True)
2837 # Check for DHCP lease
2838 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2839 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2841 # Effectively blocks until VM has been properly activated
2842 self.assertTrue(check_ping(self.inst_creators[0]))
2843 self.assertTrue(check_ping(self.inst_creators[1]))
2846 class CreateInstanceVolumeTests(OSIntegrationTestCase):
2848 Simple instance creation with an attached volume
2853 Instantiates the CreateImage object that is responsible for downloading
2854 and creating an OS image file
2857 super(self.__class__, self).__start__()
2859 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2860 self.vm_inst_name = guid + '-inst'
2861 self.nova = nova_utils.nova_client(self.os_creds)
2862 self.neutron = neutron_utils.neutron_client(self.os_creds)
2863 os_image_settings = openstack_tests.cirros_image_settings(
2864 name=guid + '-image', image_metadata=self.image_metadata)
2866 net_config = openstack_tests.get_priv_net_config(
2867 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
2868 router_name=guid + '-pub-router', external_net=self.ext_net_name,
2869 netconf_override=self.netconf_override)
2871 self.volume_settings1 = VolumeConfig(
2872 name=self.__class__.__name__ + '-' + str(guid) + '-1')
2873 self.volume_settings2 = VolumeConfig(
2874 name=self.__class__.__name__ + '-' + str(guid) + '-2')
2876 # Initialize for tearDown()
2877 self.image_creator = None
2878 self.flavor_creator = None
2880 self.network_creator = None
2881 self.inst_creator = None
2882 self.volume_creator1 = None
2883 self.volume_creator2 = None
2887 self.image_creator = OpenStackImage(self.os_creds,
2889 self.image_creator.create()
2892 self.flavor_creator = OpenStackFlavor(
2893 self.admin_os_creds,
2894 FlavorConfig(name=guid + '-flavor-name', ram=256, disk=1,
2895 vcpus=2, metadata=self.flavor_metadata))
2896 self.flavor_creator.create()
2899 self.network_creator = OpenStackNetwork(
2900 self.os_creds, net_config.network_settings)
2901 self.network_creator.create()
2903 self.port_settings = PortConfig(
2904 name=guid + '-port',
2905 network_name=net_config.network_settings.name)
2907 self.volume_creator1 = OpenStackVolume(
2908 self.os_creds, self.volume_settings1)
2909 self.volume_creator1.create(block=True)
2911 self.volume_creator2 = OpenStackVolume(
2912 self.os_creds, self.volume_settings2)
2913 self.volume_creator2.create(block=True)
2915 except Exception as e:
2921 Cleans the created object
2923 if self.inst_creator:
2925 self.inst_creator.clean()
2926 except Exception as e:
2928 'Unexpected exception cleaning VM instance with message '
2931 if self.flavor_creator:
2933 self.flavor_creator.clean()
2934 except Exception as e:
2936 'Unexpected exception cleaning flavor with message - %s',
2939 if self.network_creator:
2941 self.network_creator.clean()
2942 except Exception as e:
2944 'Unexpected exception cleaning network with message - %s',
2947 if self.volume_creator2:
2949 self.volume_creator2.clean()
2950 except Exception as e:
2952 'Unexpected exception cleaning volume with message - %s',
2955 if self.volume_creator1:
2957 self.volume_creator1.clean()
2958 except Exception as e:
2960 'Unexpected exception cleaning volume with message - %s',
2963 if self.image_creator and not self.image_creator.image_settings.exists:
2965 self.image_creator.clean()
2966 except Exception as e:
2968 'Unexpected exception cleaning image with message - %s', e)
2970 super(self.__class__, self).__clean__()
2972 def test_create_instance_with_one_volume(self):
2974 Tests the creation of an OpenStack instance with a single volume.
2976 instance_settings = VmInstanceConfig(
2977 name=self.vm_inst_name,
2978 flavor=self.flavor_creator.flavor_settings.name,
2979 port_settings=[self.port_settings],
2980 volume_names=[self.volume_settings1.name])
2982 self.inst_creator = OpenStackVmInstance(
2983 self.os_creds, instance_settings,
2984 self.image_creator.image_settings)
2986 vm_inst = self.inst_creator.create(block=True)
2987 self.assertIsNotNone(nova_utils.get_server(
2988 self.nova, self.neutron, self.keystone,
2989 vm_inst_settings=instance_settings))
2991 self.assertIsNotNone(vm_inst)
2992 self.assertEqual(1, len(vm_inst.volume_ids))
2993 self.assertEqual(self.volume_creator1.get_volume().id,
2994 vm_inst.volume_ids[0]['id'])
2996 def test_create_instance_with_two_volumes(self):
2998 Tests the creation of an OpenStack instance with a single volume.
3000 instance_settings = VmInstanceConfig(
3001 name=self.vm_inst_name,
3002 flavor=self.flavor_creator.flavor_settings.name,
3003 port_settings=[self.port_settings],
3004 volume_names=[self.volume_settings1.name,
3005 self.volume_settings2.name])
3007 self.inst_creator = OpenStackVmInstance(
3008 self.os_creds, instance_settings,
3009 self.image_creator.image_settings)
3011 vm_inst = self.inst_creator.create(block=True)
3012 self.assertIsNotNone(nova_utils.get_server(
3013 self.nova, self.neutron, self.keystone,
3014 vm_inst_settings=instance_settings))
3016 self.assertIsNotNone(vm_inst)
3017 self.assertEqual(2, len(vm_inst.volume_ids))
3018 self.assertEqual(self.volume_creator1.get_volume().id,
3019 vm_inst.volume_ids[0]['id'])
3020 self.assertEqual(self.volume_creator2.get_volume().id,
3021 vm_inst.volume_ids[1]['id'])
3024 def check_dhcp_lease(inst_creator, ip, timeout=160):
3026 Returns true if the expected DHCP lease has been acquired
3027 :param inst_creator: the SNAPS OpenStackVmInstance object
3028 :param ip: the IP address to look for
3029 :param timeout: how long to query for IP address
3033 start_time = time.time()
3035 logger.info("Looking for IP %s in the console log" % ip)
3037 while timeout > time.time() - start_time:
3038 output = inst_creator.get_console_output()
3039 full_log = full_log + output
3040 if re.search(ip, output):
3041 logger.info('DHCP lease obtained logged in console')
3046 logger.error('Full console output -\n' + full_log)
3048 logger.debug('Full console output -\n' + full_log)
3053 def _get_ping_userdata(test_ip):
3055 Returns the post VM creation script to be added into the VM's userdata
3056 :param test_ip: the IP value to substitute into the script
3057 :return: the bash script contents
3060 return ("#!/bin/sh\n\n"
3062 " ping -c 1 %s 2>&1 >/dev/null\n"
3064 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
3065 " echo 'vPing OK'\n"
3068 " echo 'vPing KO'\n"
3075 def check_ping(vm_creator, timeout=160):
3077 Check for VM for ping result
3081 while tries < timeout:
3083 p_console = vm_creator.get_console_output()
3084 if "vPing OK" in p_console:
3086 elif "failed to read iid from metadata" in p_console or tries > 5: