1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
2 # and others. All rights reserved.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at:
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
23 from neutronclient.common.exceptions import InvalidIpForSubnetClient
25 from snaps import file_utils
26 from snaps.openstack import create_network, create_router
27 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
28 from snaps.openstack.create_image import OpenStackImage, ImageSettings
29 from snaps.openstack.create_instance import (
30 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings,
31 VmInstanceSettingsError, FloatingIpSettingsError)
32 from snaps.openstack.create_keypairs import OpenStackKeypair, KeypairSettings
33 from snaps.openstack.create_network import (
34 OpenStackNetwork, PortSettings, NetworkSettings)
35 from snaps.openstack.create_router import OpenStackRouter, RouterSettings
36 from snaps.openstack.create_security_group import (
37 SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
39 from snaps.openstack.tests import openstack_tests, validation_utils
40 from snaps.openstack.tests.os_source_file_test import (
41 OSIntegrationTestCase, OSComponentTestCase)
42 from snaps.openstack.utils import nova_utils
44 __author__ = 'spisarski'
48 logger = logging.getLogger('create_instance_tests')
51 class VmInstanceSettingsUnitTests(unittest.TestCase):
53 Tests the construction of the VmInstanceSettings class
56 def test_no_params(self):
57 with self.assertRaises(VmInstanceSettingsError):
60 def test_empty_config(self):
61 with self.assertRaises(VmInstanceSettingsError):
62 VmInstanceSettings(config=dict())
64 def test_name_only(self):
65 with self.assertRaises(VmInstanceSettingsError):
66 VmInstanceSettings(name='foo')
68 def test_config_with_name_only(self):
69 with self.assertRaises(VmInstanceSettingsError):
70 VmInstanceSettings(config={'name': 'foo'})
72 def test_name_flavor_only(self):
73 with self.assertRaises(VmInstanceSettingsError):
74 VmInstanceSettings(name='foo', flavor='bar')
76 def test_config_with_name_flavor_only(self):
77 with self.assertRaises(VmInstanceSettingsError):
78 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
80 def test_name_flavor_port_only(self):
81 port_settings = PortSettings(name='foo-port', network_name='bar-net')
82 settings = VmInstanceSettings(name='foo', flavor='bar',
83 port_settings=[port_settings])
84 self.assertEqual('foo', settings.name)
85 self.assertEqual('bar', settings.flavor)
86 self.assertEqual(1, len(settings.port_settings))
87 self.assertEqual('foo-port', settings.port_settings[0].name)
88 self.assertEqual('bar-net', settings.port_settings[0].network_name)
89 self.assertEqual(0, len(settings.security_group_names))
90 self.assertEqual(0, len(settings.floating_ip_settings))
91 self.assertIsNone(settings.sudo_user)
92 self.assertEqual(900, settings.vm_boot_timeout)
93 self.assertEqual(300, settings.vm_delete_timeout)
94 self.assertEqual(180, settings.ssh_connect_timeout)
95 self.assertIsNone(settings.availability_zone)
97 def test_config_with_name_flavor_port_only(self):
98 port_settings = PortSettings(name='foo-port', network_name='bar-net')
99 settings = VmInstanceSettings(
100 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
101 self.assertEqual('foo', settings.name)
102 self.assertEqual('bar', settings.flavor)
103 self.assertEqual(1, len(settings.port_settings))
104 self.assertEqual('foo-port', settings.port_settings[0].name)
105 self.assertEqual('bar-net', settings.port_settings[0].network_name)
106 self.assertEqual(0, len(settings.security_group_names))
107 self.assertEqual(0, len(settings.floating_ip_settings))
108 self.assertIsNone(settings.sudo_user)
109 self.assertEqual(900, settings.vm_boot_timeout)
110 self.assertEqual(300, settings.vm_delete_timeout)
111 self.assertEqual(180, settings.ssh_connect_timeout)
112 self.assertIsNone(settings.availability_zone)
115 port_settings = PortSettings(name='foo-port', network_name='bar-net')
116 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
117 router_name='foo-bar-router')
119 settings = VmInstanceSettings(name='foo', flavor='bar',
120 port_settings=[port_settings],
121 security_group_names=['sec_grp_1'],
122 floating_ip_settings=[fip_settings],
123 sudo_user='joe', vm_boot_timeout=999,
124 vm_delete_timeout=333,
125 ssh_connect_timeout=111,
126 availability_zone='server name')
127 self.assertEqual('foo', settings.name)
128 self.assertEqual('bar', settings.flavor)
129 self.assertEqual(1, len(settings.port_settings))
130 self.assertEqual('foo-port', settings.port_settings[0].name)
131 self.assertEqual('bar-net', settings.port_settings[0].network_name)
132 self.assertEqual(1, len(settings.security_group_names))
133 self.assertEqual('sec_grp_1', settings.security_group_names[0])
134 self.assertEqual(1, len(settings.floating_ip_settings))
135 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
136 self.assertEqual('bar-port',
137 settings.floating_ip_settings[0].port_name)
138 self.assertEqual('foo-bar-router',
139 settings.floating_ip_settings[0].router_name)
140 self.assertEqual('joe', settings.sudo_user)
141 self.assertEqual(999, settings.vm_boot_timeout)
142 self.assertEqual(333, settings.vm_delete_timeout)
143 self.assertEqual(111, settings.ssh_connect_timeout)
144 self.assertEqual('server name', settings.availability_zone)
146 def test_config_all(self):
147 port_settings = PortSettings(name='foo-port', network_name='bar-net')
148 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
149 router_name='foo-bar-router')
151 settings = VmInstanceSettings(
152 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
153 'security_group_names': ['sec_grp_1'],
154 'floating_ips': [fip_settings], 'sudo_user': 'joe',
155 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
156 'ssh_connect_timeout': 111, 'availability_zone': 'server name'})
157 self.assertEqual('foo', settings.name)
158 self.assertEqual('bar', settings.flavor)
159 self.assertEqual(1, len(settings.port_settings))
160 self.assertEqual('foo-port', settings.port_settings[0].name)
161 self.assertEqual('bar-net', settings.port_settings[0].network_name)
162 self.assertEqual(1, len(settings.security_group_names))
163 self.assertEqual(1, len(settings.floating_ip_settings))
164 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
165 self.assertEqual('bar-port',
166 settings.floating_ip_settings[0].port_name)
167 self.assertEqual('foo-bar-router',
168 settings.floating_ip_settings[0].router_name)
169 self.assertEqual('joe', settings.sudo_user)
170 self.assertEqual(999, settings.vm_boot_timeout)
171 self.assertEqual(333, settings.vm_delete_timeout)
172 self.assertEqual(111, settings.ssh_connect_timeout)
173 self.assertEqual('server name', settings.availability_zone)
176 class FloatingIpSettingsUnitTests(unittest.TestCase):
178 Tests the construction of the FloatingIpSettings class
181 def test_no_params(self):
182 with self.assertRaises(FloatingIpSettingsError):
185 def test_empty_config(self):
186 with self.assertRaises(FloatingIpSettingsError):
187 FloatingIpSettings(**dict())
189 def test_name_only(self):
190 with self.assertRaises(FloatingIpSettingsError):
191 FloatingIpSettings(name='foo')
193 def test_config_with_name_only(self):
194 with self.assertRaises(FloatingIpSettingsError):
195 FloatingIpSettings(**{'name': 'foo'})
197 def test_name_port_only(self):
198 with self.assertRaises(FloatingIpSettingsError):
199 FloatingIpSettings(name='foo', port_name='bar')
201 def test_config_with_name_port_only(self):
202 with self.assertRaises(FloatingIpSettingsError):
203 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
205 def test_name_router_only(self):
206 with self.assertRaises(FloatingIpSettingsError):
207 FloatingIpSettings(name='foo', router_name='bar')
209 def test_config_with_name_router_only(self):
210 with self.assertRaises(FloatingIpSettingsError):
211 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
213 def test_name_port_router_only(self):
214 settings = FloatingIpSettings(name='foo', port_name='foo-port',
215 router_name='bar-router')
216 self.assertEqual('foo', settings.name)
217 self.assertEqual('foo-port', settings.port_name)
218 self.assertEqual('bar-router', settings.router_name)
219 self.assertIsNone(settings.subnet_name)
220 self.assertTrue(settings.provisioning)
222 def test_config_with_name_port_router_only(self):
223 settings = FloatingIpSettings(
224 **{'name': 'foo', 'port_name': 'foo-port',
225 'router_name': 'bar-router'})
226 self.assertEqual('foo', settings.name)
227 self.assertEqual('foo-port', settings.port_name)
228 self.assertEqual('bar-router', settings.router_name)
229 self.assertIsNone(settings.subnet_name)
230 self.assertTrue(settings.provisioning)
233 settings = FloatingIpSettings(name='foo', port_name='foo-port',
234 router_name='bar-router',
235 subnet_name='bar-subnet',
237 self.assertEqual('foo', settings.name)
238 self.assertEqual('foo-port', settings.port_name)
239 self.assertEqual('bar-router', settings.router_name)
240 self.assertEqual('bar-subnet', settings.subnet_name)
241 self.assertFalse(settings.provisioning)
243 def test_config_all(self):
244 settings = FloatingIpSettings(
245 **{'name': 'foo', 'port_name': 'foo-port',
246 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
247 'provisioning': False})
248 self.assertEqual('foo', settings.name)
249 self.assertEqual('foo-port', settings.port_name)
250 self.assertEqual('bar-router', settings.router_name)
251 self.assertEqual('bar-subnet', settings.subnet_name)
252 self.assertFalse(settings.provisioning)
255 class SimpleHealthCheck(OSIntegrationTestCase):
257 Test for the CreateInstance class with a single NIC/Port with Floating IPs
262 Instantiates the CreateImage object that is responsible for downloading
263 and creating an OS image file
266 super(self.__class__, self).__start__()
268 self.nova = nova_utils.nova_client(self.os_creds)
269 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
270 self.vm_inst_name = guid + '-inst'
271 self.port_1_name = guid + 'port-1'
273 # Initialize for tearDown()
274 self.image_creator = None
275 self.network_creator = None
276 self.flavor_creator = None
277 self.inst_creator = None
279 self.priv_net_config = openstack_tests.get_priv_net_config(
280 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
281 self.port_settings = PortSettings(
282 name=self.port_1_name,
283 network_name=self.priv_net_config.network_settings.name)
286 # Set the default image settings, then set any custom parameters sent
288 os_image_settings = openstack_tests.cirros_image_settings(
289 name=guid + '-image', image_metadata=self.image_metadata)
292 self.image_creator = OpenStackImage(self.os_creds,
294 self.image_creator.create()
297 self.network_creator = OpenStackNetwork(
298 self.os_creds, self.priv_net_config.network_settings)
299 self.network_creator.create()
302 self.flavor_creator = OpenStackFlavor(
304 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
305 vcpus=1, metadata=self.flavor_metadata))
306 self.flavor_creator.create()
307 except Exception as e:
313 Cleans the created object
315 if self.inst_creator:
317 self.inst_creator.clean()
318 except Exception as e:
320 'Unexpected exception cleaning VM instance with message'
323 if self.network_creator:
325 self.network_creator.clean()
326 except Exception as e:
328 'Unexpected exception cleaning network with message - %s',
331 if self.flavor_creator:
333 self.flavor_creator.clean()
334 except Exception as e:
336 'Unexpected exception cleaning flavor with message - %s',
339 if self.image_creator and not self.image_creator.image_settings.exists:
341 self.image_creator.clean()
342 except Exception as e:
344 'Unexpected exception cleaning image with message - %s',
347 super(self.__class__, self).__clean__()
349 def test_check_vm_ip_dhcp(self):
351 Tests the creation of an OpenStack instance with a single port and
352 ensures that it's assigned IP address is the actual.
354 instance_settings = VmInstanceSettings(
355 name=self.vm_inst_name,
356 flavor=self.flavor_creator.flavor_settings.name,
357 port_settings=[self.port_settings])
359 self.inst_creator = OpenStackVmInstance(
360 self.os_creds, instance_settings,
361 self.image_creator.image_settings)
362 self.inst_creator.create()
364 ip = self.inst_creator.get_port_ip(self.port_settings.name)
365 self.assertIsNotNone(ip)
367 self.assertTrue(self.inst_creator.vm_active(block=True))
369 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
372 class CreateInstanceSimpleTests(OSIntegrationTestCase):
374 Simple instance creation tests without any other objects
379 Instantiates the CreateImage object that is responsible for downloading
380 and creating an OS image file
383 super(self.__class__, self).__start__()
385 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
386 self.vm_inst_name = guid + '-inst'
387 self.nova = nova_utils.nova_client(self.os_creds)
388 os_image_settings = openstack_tests.cirros_image_settings(
389 name=guid + '-image', image_metadata=self.image_metadata)
391 net_config = openstack_tests.get_priv_net_config(
392 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
393 router_name=guid + '-pub-router', external_net=self.ext_net_name)
395 # Initialize for tearDown()
396 self.image_creator = None
397 self.flavor_creator = None
399 self.network_creator = None
400 self.inst_creator = None
404 self.image_creator = OpenStackImage(self.os_creds,
406 self.image_creator.create()
409 self.flavor_creator = OpenStackFlavor(
411 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
412 vcpus=2, metadata=self.flavor_metadata))
413 self.flavor_creator.create()
416 self.network_creator = OpenStackNetwork(
417 self.os_creds, net_config.network_settings)
418 self.network_creator.create()
420 self.port_settings = PortSettings(
422 network_name=net_config.network_settings.name)
424 except Exception as e:
430 Cleans the created object
432 if self.inst_creator:
434 self.inst_creator.clean()
435 except Exception as e:
437 'Unexpected exception cleaning VM instance with message '
440 if self.flavor_creator:
442 self.flavor_creator.clean()
443 except Exception as e:
445 'Unexpected exception cleaning flavor with message - %s',
448 if self.network_creator:
450 self.network_creator.clean()
451 except Exception as e:
453 'Unexpected exception cleaning network with message - %s',
456 if self.image_creator and not self.image_creator.image_settings.exists:
458 self.image_creator.clean()
459 except Exception as e:
461 'Unexpected exception cleaning image with message - %s', e)
463 super(self.__class__, self).__clean__()
465 def test_create_delete_instance(self):
467 Tests the creation of an OpenStack instance with a single port with a
468 static IP without a Floating IP.
470 instance_settings = VmInstanceSettings(
471 name=self.vm_inst_name,
472 flavor=self.flavor_creator.flavor_settings.name,
473 port_settings=[self.port_settings])
475 self.inst_creator = OpenStackVmInstance(
476 self.os_creds, instance_settings,
477 self.image_creator.image_settings)
479 vm_inst = self.inst_creator.create()
480 self.assertIsNotNone(nova_utils.get_server(
481 self.nova, vm_inst_settings=instance_settings))
484 nova_utils.delete_vm_instance(self.nova, vm_inst)
486 self.assertTrue(self.inst_creator.vm_deleted(block=True))
487 self.assertIsNone(nova_utils.get_server(
488 self.nova, vm_inst_settings=instance_settings))
490 # Exception should not be thrown
491 self.inst_creator.clean()
494 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
496 Test for the CreateInstance class with a single NIC/Port with Floating IPs
501 Instantiates the CreateImage object that is responsible for downloading
502 and creating an OS image file within OpenStack
504 super(self.__class__, self).__start__()
506 self.nova = nova_utils.nova_client(self.os_creds)
507 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
508 self.keypair_priv_filepath = 'tmp/' + guid
509 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
510 self.keypair_name = guid + '-kp'
511 self.vm_inst_name = guid + '-inst'
512 self.port_1_name = guid + 'port-1'
513 self.port_2_name = guid + 'port-2'
514 self.floating_ip_name = guid + 'fip1'
516 # Initialize for tearDown()
517 self.image_creator = None
518 self.network_creator = None
519 self.router_creator = None
520 self.flavor_creator = None
521 self.keypair_creator = None
522 self.sec_grp_creator = None
523 self.inst_creators = list()
525 self.pub_net_config = openstack_tests.get_pub_net_config(
526 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
527 router_name=guid + '-pub-router', external_net=self.ext_net_name)
528 os_image_settings = openstack_tests.cirros_image_settings(
529 name=guid + '-image', image_metadata=self.image_metadata)
532 self.image_creator = OpenStackImage(self.os_creds,
534 self.image_creator.create()
537 self.network_creator = OpenStackNetwork(
538 self.os_creds, self.pub_net_config.network_settings)
539 self.network_creator.create()
542 self.router_creator = OpenStackRouter(
543 self.os_creds, self.pub_net_config.router_settings)
544 self.router_creator.create()
547 self.flavor_creator = OpenStackFlavor(
549 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
550 vcpus=2, metadata=self.flavor_metadata))
551 self.flavor_creator.create()
553 self.keypair_creator = OpenStackKeypair(
554 self.os_creds, KeypairSettings(
555 name=self.keypair_name,
556 public_filepath=self.keypair_pub_filepath,
557 private_filepath=self.keypair_priv_filepath))
558 self.keypair_creator.create()
560 sec_grp_name = guid + '-sec-grp'
561 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
562 direction=Direction.ingress,
563 protocol=Protocol.icmp)
564 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
565 direction=Direction.ingress,
566 protocol=Protocol.tcp,
569 self.sec_grp_creator = OpenStackSecurityGroup(
571 SecurityGroupSettings(name=sec_grp_name,
572 rule_settings=[rule1, rule2]))
573 self.sec_grp_creator.create()
574 except Exception as e:
580 Cleans the created object
582 for inst_creator in self.inst_creators:
585 except Exception as e:
587 'Unexpected exception cleaning VM instance with message '
590 if self.keypair_creator:
592 self.keypair_creator.clean()
593 except Exception as e:
595 'Unexpected exception cleaning keypair with message - %s',
598 if os.path.isfile(self.keypair_pub_filepath):
599 os.remove(self.keypair_pub_filepath)
601 if os.path.isfile(self.keypair_priv_filepath):
602 os.remove(self.keypair_priv_filepath)
604 if self.flavor_creator:
606 self.flavor_creator.clean()
607 except Exception as e:
609 'Unexpected exception cleaning flavor with message - %s',
612 if self.sec_grp_creator:
614 self.sec_grp_creator.clean()
615 except Exception as e:
617 'Unexpected exception cleaning security group with message'
620 if self.router_creator:
622 self.router_creator.clean()
623 except Exception as e:
625 'Unexpected exception cleaning router with message - %s',
628 if self.network_creator:
630 self.network_creator.clean()
631 except Exception as e:
633 'Unexpected exception cleaning network with message - %s',
636 if self.image_creator and not self.image_creator.image_settings.exists:
638 self.image_creator.clean()
639 except Exception as e:
641 'Unexpected exception cleaning image with message - %s', e)
643 super(self.__class__, self).__clean__()
645 def test_single_port_static(self):
647 Tests the creation of an OpenStack instance with a single port with a
648 static IP without a Floating IP.
651 sub_settings = self.pub_net_config.network_settings.subnet_settings
652 port_settings = PortSettings(
653 name=self.port_1_name,
654 network_name=self.pub_net_config.network_settings.name,
656 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
658 instance_settings = VmInstanceSettings(
659 name=self.vm_inst_name,
660 flavor=self.flavor_creator.flavor_settings.name,
661 port_settings=[port_settings],
662 floating_ip_settings=[FloatingIpSettings(
663 name=self.floating_ip_name, port_name=self.port_1_name,
664 router_name=self.pub_net_config.router_settings.name)])
666 inst_creator = OpenStackVmInstance(
667 self.os_creds, instance_settings,
668 self.image_creator.image_settings,
669 keypair_settings=self.keypair_creator.keypair_settings)
670 self.inst_creators.append(inst_creator)
671 vm_inst = inst_creator.create()
673 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
674 self.assertTrue(inst_creator.vm_active(block=True))
675 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
677 def test_ssh_client_fip_before_active(self):
679 Tests the ability to access a VM via SSH and a floating IP when it has
680 been assigned prior to being active.
682 port_settings = PortSettings(
683 name=self.port_1_name,
684 network_name=self.pub_net_config.network_settings.name)
686 instance_settings = VmInstanceSettings(
687 name=self.vm_inst_name,
688 flavor=self.flavor_creator.flavor_settings.name,
689 port_settings=[port_settings],
690 floating_ip_settings=[FloatingIpSettings(
691 name=self.floating_ip_name, port_name=self.port_1_name,
692 router_name=self.pub_net_config.router_settings.name)])
694 inst_creator = OpenStackVmInstance(
695 self.os_creds, instance_settings,
696 self.image_creator.image_settings,
697 keypair_settings=self.keypair_creator.keypair_settings)
698 self.inst_creators.append(inst_creator)
699 vm_inst = inst_creator.create()
700 self.assertIsNotNone(vm_inst)
702 self.assertTrue(inst_creator.vm_active(block=True))
704 ip = inst_creator.get_port_ip(port_settings.name)
705 self.assertTrue(check_dhcp_lease(inst_creator, ip))
707 inst_creator.add_security_group(
708 self.sec_grp_creator.get_security_group())
709 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
711 self.assertTrue(validate_ssh_client(inst_creator))
713 def test_ssh_client_fip_after_active(self):
715 Tests the ability to access a VM via SSH and a floating IP when it has
716 been assigned prior to being active.
718 port_settings = PortSettings(
719 name=self.port_1_name,
720 network_name=self.pub_net_config.network_settings.name)
722 instance_settings = VmInstanceSettings(
723 name=self.vm_inst_name,
724 flavor=self.flavor_creator.flavor_settings.name,
725 port_settings=[port_settings],
726 floating_ip_settings=[FloatingIpSettings(
727 name=self.floating_ip_name, port_name=self.port_1_name,
728 router_name=self.pub_net_config.router_settings.name)])
730 inst_creator = OpenStackVmInstance(
731 self.os_creds, instance_settings,
732 self.image_creator.image_settings,
733 keypair_settings=self.keypair_creator.keypair_settings)
734 self.inst_creators.append(inst_creator)
736 # block=True will force the create() method to block until the
737 vm_inst = inst_creator.create(block=True)
738 self.assertIsNotNone(vm_inst)
740 self.assertTrue(inst_creator.vm_active(block=True))
742 ip = inst_creator.get_port_ip(port_settings.name)
743 self.assertTrue(check_dhcp_lease(inst_creator, ip))
745 inst_creator.add_security_group(
746 self.sec_grp_creator.get_security_group())
747 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
749 self.assertTrue(validate_ssh_client(inst_creator))
751 def test_ssh_client_fip_second_creator(self):
753 Tests the ability to access a VM via SSH and a floating IP via a
754 creator that is identical to the original creator.
756 port_settings = PortSettings(
757 name=self.port_1_name,
758 network_name=self.pub_net_config.network_settings.name)
760 instance_settings = VmInstanceSettings(
761 name=self.vm_inst_name,
762 flavor=self.flavor_creator.flavor_settings.name,
763 port_settings=[port_settings],
764 floating_ip_settings=[FloatingIpSettings(
765 name=self.floating_ip_name, port_name=self.port_1_name,
766 router_name=self.pub_net_config.router_settings.name)])
768 inst_creator = OpenStackVmInstance(
769 self.os_creds, instance_settings,
770 self.image_creator.image_settings,
771 keypair_settings=self.keypair_creator.keypair_settings)
772 self.inst_creators.append(inst_creator)
774 # block=True will force the create() method to block until the
775 vm_inst = inst_creator.create(block=True)
776 self.assertIsNotNone(vm_inst)
778 self.assertTrue(inst_creator.vm_active(block=True))
780 ip = inst_creator.get_port_ip(port_settings.name)
781 self.assertTrue(check_dhcp_lease(inst_creator, ip))
783 inst_creator.add_security_group(
784 self.sec_grp_creator.get_security_group())
785 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
787 self.assertTrue(validate_ssh_client(inst_creator))
789 inst_creator2 = OpenStackVmInstance(
790 self.os_creds, instance_settings,
791 self.image_creator.image_settings,
792 keypair_settings=self.keypair_creator.keypair_settings)
793 inst_creator2.create()
794 self.assertTrue(validate_ssh_client(inst_creator2))
797 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
799 Test for the CreateInstance class with a single NIC/Port where mac and IP
800 values are manually set
805 Instantiates the CreateImage object that is responsible for downloading
806 and creating an OS image file within OpenStack
808 super(self.__class__, self).__start__()
810 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
811 self.vm_inst_name = guid + '-inst'
812 self.port_1_name = guid + 'port-1'
813 self.port_2_name = guid + 'port-2'
814 self.floating_ip_name = guid + 'fip1'
816 # Initialize for tearDown()
817 self.image_creator = None
818 self.network_creator = None
819 self.flavor_creator = None
820 self.inst_creator = None
822 self.net_config = openstack_tests.get_priv_net_config(
823 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
824 router_name=guid + '-pub-router', external_net=self.ext_net_name)
825 os_image_settings = openstack_tests.cirros_image_settings(
826 name=guid + '-image', image_metadata=self.image_metadata)
830 self.image_creator = OpenStackImage(self.os_creds,
832 self.image_creator.create()
835 self.network_creator = OpenStackNetwork(
836 self.os_creds, self.net_config.network_settings)
837 self.network_creator.create()
840 self.flavor_creator = OpenStackFlavor(
842 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
843 vcpus=2, metadata=self.flavor_metadata))
844 self.flavor_creator.create()
845 except Exception as e:
851 Cleans the created object
853 if self.inst_creator:
855 self.inst_creator.clean()
856 except Exception as e:
858 'Unexpected exception cleaning VM instance with message '
861 if self.flavor_creator:
863 self.flavor_creator.clean()
864 except Exception as e:
866 'Unexpected exception cleaning flavor with message - %s',
869 if self.network_creator:
871 self.network_creator.clean()
872 except Exception as e:
874 'Unexpected exception cleaning network with message - %s',
877 if self.image_creator and not self.image_creator.image_settings.exists:
879 self.image_creator.clean()
880 except Exception as e:
882 'Unexpected exception cleaning image with message - %s', e)
884 super(self.__class__, self).__clean__()
886 def test_set_custom_valid_ip_one_subnet(self):
888 Tests the creation of an OpenStack instance with a single port with a
889 static IP on a network with one subnet.
892 sub_settings = self.net_config.network_settings.subnet_settings
893 port_settings = PortSettings(
894 name=self.port_1_name,
895 network_name=self.net_config.network_settings.name,
896 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
898 instance_settings = VmInstanceSettings(
899 name=self.vm_inst_name,
900 flavor=self.flavor_creator.flavor_settings.name,
901 port_settings=[port_settings])
903 self.inst_creator = OpenStackVmInstance(
904 self.os_creds, instance_settings,
905 self.image_creator.image_settings)
906 self.inst_creator.create(block=True)
908 self.assertEqual(ip, self.inst_creator.get_port_ip(
910 subnet_name=self.net_config.network_settings.subnet_settings[
913 def test_set_custom_invalid_ip_one_subnet(self):
915 Tests the creation of an OpenStack instance with a single port with a
916 static IP on a network with one subnet.
919 sub_settings = self.net_config.network_settings.subnet_settings
920 port_settings = PortSettings(
921 name=self.port_1_name,
922 network_name=self.net_config.network_settings.name,
923 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
925 instance_settings = VmInstanceSettings(
926 name=self.vm_inst_name,
927 flavor=self.flavor_creator.flavor_settings.name,
928 port_settings=[port_settings])
930 self.inst_creator = OpenStackVmInstance(
931 self.os_creds, instance_settings,
932 self.image_creator.image_settings)
934 with self.assertRaises(InvalidIpForSubnetClient):
935 self.inst_creator.create()
937 def test_set_custom_valid_mac(self):
939 Tests the creation of an OpenStack instance with a single port where
940 the MAC address is assigned.
942 mac_addr = '0a:1b:2c:3d:4e:5f'
943 port_settings = PortSettings(
944 name=self.port_1_name,
945 network_name=self.net_config.network_settings.name,
946 mac_address=mac_addr)
948 instance_settings = VmInstanceSettings(
949 name=self.vm_inst_name,
950 flavor=self.flavor_creator.flavor_settings.name,
951 port_settings=[port_settings])
953 self.inst_creator = OpenStackVmInstance(
954 self.os_creds, instance_settings,
955 self.image_creator.image_settings)
956 self.inst_creator.create(block=True)
958 self.assertEqual(mac_addr,
959 self.inst_creator.get_port_mac(self.port_1_name))
961 def test_set_custom_invalid_mac(self):
963 Tests the creation of an OpenStack instance with a single port where an
964 invalid MAC address value is being
965 assigned. This should raise an Exception
967 port_settings = PortSettings(
968 name=self.port_1_name,
969 network_name=self.net_config.network_settings.name,
972 instance_settings = VmInstanceSettings(
973 name=self.vm_inst_name,
974 flavor=self.flavor_creator.flavor_settings.name,
975 port_settings=[port_settings])
977 self.inst_creator = OpenStackVmInstance(
978 self.os_creds, instance_settings,
979 self.image_creator.image_settings)
981 with self.assertRaises(Exception):
982 self.inst_creator.create()
984 def test_set_custom_mac_and_ip(self):
986 Tests the creation of an OpenStack instance with a single port where
987 the IP and MAC address is assigned.
990 mac_addr = '0a:1b:2c:3d:4e:5f'
991 sub_settings = self.net_config.network_settings.subnet_settings
992 port_settings = PortSettings(
993 name=self.port_1_name,
994 network_name=self.net_config.network_settings.name,
995 mac_address=mac_addr,
996 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
998 instance_settings = VmInstanceSettings(
999 name=self.vm_inst_name,
1000 flavor=self.flavor_creator.flavor_settings.name,
1001 port_settings=[port_settings])
1003 self.inst_creator = OpenStackVmInstance(
1004 self.os_creds, instance_settings,
1005 self.image_creator.image_settings)
1006 self.inst_creator.create(block=True)
1008 self.assertEqual(ip, self.inst_creator.get_port_ip(
1010 subnet_name=self.net_config.network_settings.subnet_settings[
1012 self.assertEqual(mac_addr,
1013 self.inst_creator.get_port_mac(self.port_1_name))
1015 def test_set_allowed_address_pairs(self):
1017 Tests the creation of an OpenStack instance with a single port where
1018 max_allowed_address_pair is set.
1021 mac_addr = '0a:1b:2c:3d:4e:5f'
1022 pair = {'ip_address': ip, 'mac_address': mac_addr}
1023 port_settings = PortSettings(
1024 name=self.port_1_name,
1025 network_name=self.net_config.network_settings.name,
1026 allowed_address_pairs=[pair])
1028 instance_settings = VmInstanceSettings(
1029 name=self.vm_inst_name,
1030 flavor=self.flavor_creator.flavor_settings.name,
1031 port_settings=[port_settings])
1033 self.inst_creator = OpenStackVmInstance(
1034 self.os_creds, instance_settings,
1035 self.image_creator.image_settings)
1036 self.inst_creator.create(block=True)
1038 port = self.inst_creator.get_port_by_name(port_settings.name)
1039 self.assertIsNotNone(port)
1040 self.assertIsNotNone(port.allowed_address_pairs)
1041 self.assertEqual(1, len(port.allowed_address_pairs))
1042 validation_utils.objects_equivalent(pair,
1043 port.allowed_address_pairs[0])
1045 def test_set_allowed_address_pairs_bad_mac(self):
1047 Tests the creation of an OpenStack instance with a single port where
1048 max_allowed_address_pair is set with an invalid MAC address.
1052 pair = {'ip_address': ip, 'mac_address': mac_addr}
1054 pairs.add((ip, mac_addr))
1055 port_settings = PortSettings(
1056 name=self.port_1_name,
1057 network_name=self.net_config.network_settings.name,
1058 allowed_address_pairs=[pair])
1060 instance_settings = VmInstanceSettings(
1061 name=self.vm_inst_name,
1062 flavor=self.flavor_creator.flavor_settings.name,
1063 port_settings=[port_settings])
1065 self.inst_creator = OpenStackVmInstance(
1066 self.os_creds, instance_settings,
1067 self.image_creator.image_settings)
1068 with self.assertRaises(Exception):
1069 self.inst_creator.create()
1071 def test_set_allowed_address_pairs_bad_ip(self):
1073 Tests the creation of an OpenStack instance with a single port where
1074 max_allowed_address_pair is set with an invalid MAC address.
1077 mac_addr = '0a:1b:2c:3d:4e:5f'
1078 pair = {'ip_address': ip, 'mac_address': mac_addr}
1080 pairs.add((ip, mac_addr))
1081 port_settings = PortSettings(
1082 name=self.port_1_name,
1083 network_name=self.net_config.network_settings.name,
1084 allowed_address_pairs=[pair])
1086 instance_settings = VmInstanceSettings(
1087 name=self.vm_inst_name,
1088 flavor=self.flavor_creator.flavor_settings.name,
1089 port_settings=[port_settings])
1091 self.inst_creator = OpenStackVmInstance(
1092 self.os_creds, instance_settings,
1093 self.image_creator.image_settings)
1094 with self.assertRaises(Exception):
1095 self.inst_creator.create()
1098 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1100 Test for the CreateInstance where one VM is deployed to each compute node
1105 Instantiates the CreateImage object that is responsible for downloading
1106 and creating an OS image file within OpenStack
1108 super(self.__class__, self).__start__()
1110 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1111 self.vm_inst_name = guid + '-inst'
1112 self.port_base_name = guid + 'port'
1114 # Initialize for tearDown()
1115 self.image_creator = None
1116 self.flavor_creator = None
1117 self.network_creator = None
1118 self.inst_creators = list()
1120 self.priv_net_config = openstack_tests.get_priv_net_config(
1121 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1123 os_image_settings = openstack_tests.cirros_image_settings(
1124 name=guid + '-image', image_metadata=self.image_metadata)
1128 self.network_creator = OpenStackNetwork(
1129 self.admin_os_creds, self.priv_net_config.network_settings)
1130 self.network_creator.create()
1133 self.flavor_creator = OpenStackFlavor(
1134 self.admin_os_creds,
1135 FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1,
1136 vcpus=1, metadata=self.flavor_metadata))
1137 self.flavor_creator.create()
1140 self.image_creator = OpenStackImage(self.os_creds,
1142 self.image_creator.create()
1144 except Exception as e:
1150 Cleans the created object
1152 for inst_creator in self.inst_creators:
1154 inst_creator.clean()
1155 except Exception as e:
1157 'Unexpected exception cleaning VM instance with message '
1160 if self.flavor_creator:
1162 self.flavor_creator.clean()
1163 except Exception as e:
1165 'Unexpected exception cleaning flavor with message - %s',
1168 if self.network_creator:
1170 self.network_creator.clean()
1171 except Exception as e:
1173 'Unexpected exception cleaning network with message - %s',
1176 if self.image_creator and not self.image_creator.image_settings.exists:
1178 self.image_creator.clean()
1179 except Exception as e:
1181 'Unexpected exception cleaning image with message - %s', e)
1183 super(self.__class__, self).__clean__()
1185 def test_deploy_vm_to_each_compute_node(self):
1187 Tests the creation of OpenStack VM instances to each compute node.
1189 from snaps.openstack.utils import nova_utils
1190 nova = nova_utils.nova_client(self.admin_os_creds)
1191 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1193 # Create Instance on each server/zone
1195 for zone in zone_hosts:
1196 inst_name = self.vm_inst_name + '-' + zone
1198 port_settings = PortSettings(
1199 name=self.port_base_name + '-' + str(ctr),
1200 network_name=self.priv_net_config.network_settings.name)
1202 instance_settings = VmInstanceSettings(
1204 flavor=self.flavor_creator.flavor_settings.name,
1205 availability_zone=zone,
1206 port_settings=[port_settings])
1207 inst_creator = OpenStackVmInstance(
1208 self.admin_os_creds, instance_settings,
1209 self.image_creator.image_settings)
1210 self.inst_creators.append(inst_creator)
1211 inst_creator.create()
1213 # Validate instances to ensure they've been deployed to the correct
1216 for zone in zone_hosts:
1217 creator = self.inst_creators[index]
1218 self.assertTrue(creator.vm_active(block=True))
1219 info = creator.get_vm_info()
1220 deployed_zone = info['OS-EXT-AZ:availability_zone']
1221 deployed_host = info['OS-EXT-SRV-ATTR:host']
1222 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1226 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1228 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1230 These tests require a Centos image
1235 Instantiates the CreateImage object that is responsible for downloading
1236 and creating an OS image file within OpenStack
1238 super(self.__class__, self).__start__()
1240 self.nova = nova_utils.nova_client(self.os_creds)
1242 # Initialize for tearDown()
1243 self.image_creator = None
1244 self.network_creators = list()
1245 self.router_creators = list()
1246 self.flavor_creator = None
1247 self.keypair_creator = None
1248 self.sec_grp_creator = None
1249 self.inst_creator = None
1251 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1252 self.keypair_priv_filepath = 'tmp/' + self.guid
1253 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1254 self.keypair_name = self.guid + '-kp'
1255 self.vm_inst_name = self.guid + '-inst'
1256 self.port_1_name = self.guid + '-port-1'
1257 self.port_2_name = self.guid + '-port-2'
1258 self.floating_ip_name = self.guid + 'fip1'
1259 self.priv_net_config = openstack_tests.get_priv_net_config(
1260 net_name=self.guid + '-priv-net',
1261 subnet_name=self.guid + '-priv-subnet',
1262 router_name=self.guid + '-priv-router',
1263 external_net=self.ext_net_name)
1264 self.pub_net_config = openstack_tests.get_pub_net_config(
1265 net_name=self.guid + '-pub-net',
1266 subnet_name=self.guid + '-pub-subnet',
1267 router_name=self.guid + '-pub-router',
1268 external_net=self.ext_net_name)
1270 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1271 os_image_settings = openstack_tests.centos_image_settings(
1272 name=image_name, image_metadata=self.image_metadata)
1276 self.image_creator = OpenStackImage(self.os_creds,
1278 self.image_creator.create()
1280 # First network is public
1281 self.network_creators.append(OpenStackNetwork(
1282 self.os_creds, self.pub_net_config.network_settings))
1283 # Second network is private
1284 self.network_creators.append(OpenStackNetwork(
1285 self.os_creds, self.priv_net_config.network_settings))
1286 for network_creator in self.network_creators:
1287 network_creator.create()
1289 self.router_creators.append(OpenStackRouter(
1290 self.os_creds, self.pub_net_config.router_settings))
1291 self.router_creators.append(OpenStackRouter(
1292 self.os_creds, self.priv_net_config.router_settings))
1295 for router_creator in self.router_creators:
1296 router_creator.create()
1299 self.flavor_creator = OpenStackFlavor(
1300 self.admin_os_creds,
1301 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
1303 metadata=self.flavor_metadata))
1304 self.flavor_creator.create()
1307 self.keypair_creator = OpenStackKeypair(
1308 self.os_creds, KeypairSettings(
1309 name=self.keypair_name,
1310 public_filepath=self.keypair_pub_filepath,
1311 private_filepath=self.keypair_priv_filepath))
1312 self.keypair_creator.create()
1314 sec_grp_name = self.guid + '-sec-grp'
1315 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1316 direction=Direction.ingress,
1317 protocol=Protocol.icmp)
1318 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1319 direction=Direction.ingress,
1320 protocol=Protocol.tcp,
1323 self.sec_grp_creator = OpenStackSecurityGroup(
1325 SecurityGroupSettings(name=sec_grp_name,
1326 rule_settings=[rule1, rule2]))
1327 self.sec_grp_creator.create()
1334 Cleans the created objects
1336 if self.inst_creator:
1338 self.inst_creator.clean()
1339 except Exception as e:
1341 'Unexpected exception cleaning VM instance with message '
1344 if self.keypair_creator:
1346 self.keypair_creator.clean()
1347 except Exception as e:
1349 'Unexpected exception cleaning keypair with message - %s',
1352 if os.path.isfile(self.keypair_pub_filepath):
1353 os.remove(self.keypair_pub_filepath)
1355 if os.path.isfile(self.keypair_priv_filepath):
1356 os.remove(self.keypair_priv_filepath)
1358 if self.flavor_creator:
1360 self.flavor_creator.clean()
1361 except Exception as e:
1363 'Unexpected exception cleaning flavor with message - %s',
1366 for router_creator in self.router_creators:
1368 router_creator.clean()
1369 except Exception as e:
1371 'Unexpected exception cleaning router with message - %s',
1374 for network_creator in self.network_creators:
1376 network_creator.clean()
1377 except Exception as e:
1379 'Unexpected exception cleaning network with message - %s',
1382 if self.sec_grp_creator:
1384 self.sec_grp_creator.clean()
1385 except Exception as e:
1387 'Unexpected exception cleaning security group with message'
1390 if self.image_creator and not self.image_creator.image_settings.exists:
1392 self.image_creator.clean()
1393 except Exception as e:
1395 'Unexpected exception cleaning image with message - %s', e)
1397 super(self.__class__, self).__clean__()
1399 def test_dual_ports_dhcp(self):
1401 Tests the creation of an OpenStack instance with a dual ports/NICs with
1403 NOTE: This test and any others that call ansible will most likely fail
1404 unless you do one of two things:
1405 1. Have a ~/.ansible.cfg (or alternate means) to
1406 set host_key_checking = False
1407 2. Set the following environment variable in your executing shell:
1408 ANSIBLE_HOST_KEY_CHECKING=False
1409 Should this not be performed, the creation of the host ssh key will
1410 cause your ansible calls to fail.
1412 # Create ports/NICs for instance
1415 for network_creator in self.network_creators:
1416 ports_settings.append(PortSettings(
1417 name=self.guid + '-port-' + str(ctr),
1418 network_name=network_creator.network_settings.name))
1422 instance_settings = VmInstanceSettings(
1423 name=self.vm_inst_name,
1424 flavor=self.flavor_creator.flavor_settings.name,
1425 port_settings=ports_settings,
1426 floating_ip_settings=[FloatingIpSettings(
1427 name=self.floating_ip_name, port_name=self.port_1_name,
1428 router_name=self.pub_net_config.router_settings.name)])
1430 self.inst_creator = OpenStackVmInstance(
1431 self.os_creds, instance_settings,
1432 self.image_creator.image_settings,
1433 keypair_settings=self.keypair_creator.keypair_settings)
1435 vm_inst = self.inst_creator.create(block=True)
1437 self.assertEqual(vm_inst, self.inst_creator.get_vm_inst())
1439 # Effectively blocks until VM has been properly activated
1440 self.assertTrue(self.inst_creator.vm_active(block=True))
1442 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1443 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1445 # Add security group to VM
1446 self.inst_creator.add_security_group(
1447 self.sec_grp_creator.get_security_group())
1449 # Effectively blocks until VM's ssh port has been opened
1450 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1452 self.assertEqual(0, self.inst_creator.config_nics())
1455 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1457 Tests that include, add, and remove security groups from VM instances
1462 Instantiates the CreateImage object that is responsible for downloading
1463 and creating an OS image file within OpenStack
1465 super(self.__class__, self).__start__()
1467 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1468 self.vm_inst_name = self.guid + '-inst'
1469 self.nova = nova_utils.nova_client(self.os_creds)
1470 os_image_settings = openstack_tests.cirros_image_settings(
1471 name=self.guid + '-image', image_metadata=self.image_metadata)
1473 self.vm_inst_name = self.guid + '-inst'
1474 self.port_1_name = self.guid + 'port-1'
1475 self.port_2_name = self.guid + 'port-2'
1476 self.floating_ip_name = self.guid + 'fip1'
1478 net_config = openstack_tests.get_priv_net_config(
1479 net_name=self.guid + '-pub-net',
1480 subnet_name=self.guid + '-pub-subnet',
1481 router_name=self.guid + '-pub-router',
1482 external_net=self.ext_net_name)
1484 # Initialize for tearDown()
1485 self.image_creator = None
1486 self.flavor_creator = None
1487 self.network_creator = None
1488 self.router_creator = None
1489 self.inst_creator = None
1490 self.sec_grp_creators = list()
1494 self.image_creator = OpenStackImage(self.os_creds,
1496 self.image_creator.create()
1499 self.network_creator = OpenStackNetwork(
1500 self.os_creds, net_config.network_settings)
1501 self.network_creator.create()
1504 self.flavor_creator = OpenStackFlavor(
1505 self.admin_os_creds,
1506 FlavorSettings(name=self.guid + '-flavor-name', ram=256,
1508 metadata=self.flavor_metadata))
1509 self.flavor_creator.create()
1511 self.port_settings = PortSettings(
1512 name=self.guid + '-port',
1513 network_name=net_config.network_settings.name)
1514 except Exception as e:
1520 Cleans the created object
1522 if self.inst_creator:
1524 self.inst_creator.clean()
1525 except Exception as e:
1527 'Unexpected exception cleaning VM instance with message -'
1530 for sec_grp_creator in self.sec_grp_creators:
1532 sec_grp_creator.clean()
1533 except Exception as e:
1535 'Unexpected exception cleaning security group with message'
1538 if self.flavor_creator:
1540 self.flavor_creator.clean()
1541 except Exception as e:
1543 'Unexpected exception cleaning flavor with message - %s',
1546 if self.network_creator:
1548 self.network_creator.clean()
1549 except Exception as e:
1551 'Unexpected exception cleaning network with message - %s',
1554 if self.image_creator and not self.image_creator.image_settings.exists:
1556 self.image_creator.clean()
1557 except Exception as e:
1559 'Unexpected exception cleaning image with message - %s', e)
1561 super(self.__class__, self).__clean__()
1563 def test_add_security_group(self):
1565 Tests the addition of a security group created after the instance.
1568 instance_settings = VmInstanceSettings(
1569 name=self.vm_inst_name,
1570 flavor=self.flavor_creator.flavor_settings.name,
1571 port_settings=[self.port_settings])
1572 self.inst_creator = OpenStackVmInstance(
1573 self.os_creds, instance_settings,
1574 self.image_creator.image_settings)
1575 vm_inst = self.inst_creator.create(block=True)
1576 self.assertIsNotNone(vm_inst)
1578 # Create security group object to add to instance
1579 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1580 description='hello group')
1581 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1583 sec_grp = sec_grp_creator.create()
1584 self.sec_grp_creators.append(sec_grp_creator)
1586 # Check that group has not been added
1587 self.assertFalse(inst_has_sec_grp(
1588 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1590 # Add security group to instance after activated
1591 self.inst_creator.add_security_group(sec_grp)
1593 # Validate that security group has been added
1594 self.assertTrue(inst_has_sec_grp(
1595 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1597 def test_add_invalid_security_group(self):
1599 Tests the addition of a security group that no longer exists.
1602 instance_settings = VmInstanceSettings(
1603 name=self.vm_inst_name,
1604 flavor=self.flavor_creator.flavor_settings.name,
1605 port_settings=[self.port_settings])
1606 self.inst_creator = OpenStackVmInstance(
1607 self.os_creds, instance_settings,
1608 self.image_creator.image_settings)
1609 vm_inst = self.inst_creator.create(block=True)
1610 self.assertIsNotNone(vm_inst)
1612 # Create security group object to add to instance
1613 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1614 description='hello group')
1615 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1617 sec_grp = sec_grp_creator.create()
1618 sec_grp_creator.clean()
1619 self.sec_grp_creators.append(sec_grp_creator)
1621 # Check that group has not been added
1622 self.assertFalse(inst_has_sec_grp(
1623 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1625 # Add security group to instance after activated
1626 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1628 # Validate that security group has been added
1629 self.assertFalse(inst_has_sec_grp(
1630 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1632 def test_remove_security_group(self):
1634 Tests the removal of a security group created before and added to the
1637 # Create security group object to add to instance
1638 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1639 description='hello group')
1640 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1642 sec_grp = sec_grp_creator.create()
1643 self.sec_grp_creators.append(sec_grp_creator)
1646 instance_settings = VmInstanceSettings(
1647 name=self.vm_inst_name,
1648 flavor=self.flavor_creator.flavor_settings.name,
1649 security_group_names=[sec_grp_settings.name],
1650 port_settings=[self.port_settings])
1651 self.inst_creator = OpenStackVmInstance(
1652 self.os_creds, instance_settings,
1653 self.image_creator.image_settings)
1654 vm_inst = self.inst_creator.create(block=True)
1655 self.assertIsNotNone(vm_inst)
1657 # Check that group has been added
1658 self.assertTrue(inst_has_sec_grp(
1659 self.nova, vm_inst, sec_grp_settings.name))
1661 # Add security group to instance after activated
1662 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1664 # Validate that security group has been added
1665 self.assertFalse(inst_has_sec_grp(
1666 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1668 def test_remove_security_group_never_added(self):
1670 Tests the removal of a security group that was never added in the first
1673 # Create security group object to add to instance
1674 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1675 description='hello group')
1676 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1678 sec_grp = sec_grp_creator.create()
1679 self.sec_grp_creators.append(sec_grp_creator)
1682 instance_settings = VmInstanceSettings(
1683 name=self.vm_inst_name,
1684 flavor=self.flavor_creator.flavor_settings.name,
1685 port_settings=[self.port_settings])
1686 self.inst_creator = OpenStackVmInstance(
1687 self.os_creds, instance_settings,
1688 self.image_creator.image_settings)
1689 vm_inst = self.inst_creator.create(block=True)
1690 self.assertIsNotNone(vm_inst)
1692 # Check that group has been added
1693 self.assertFalse(inst_has_sec_grp(
1694 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1696 # Add security group to instance after activated
1697 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1699 # Validate that security group has been added
1700 self.assertFalse(inst_has_sec_grp(
1701 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1703 def test_add_same_security_group(self):
1705 Tests the addition of a security group created before add added to the
1708 # Create security group object to add to instance
1709 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1710 description='hello group')
1711 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1713 sec_grp = sec_grp_creator.create()
1714 self.sec_grp_creators.append(sec_grp_creator)
1717 instance_settings = VmInstanceSettings(
1718 name=self.vm_inst_name,
1719 flavor=self.flavor_creator.flavor_settings.name,
1720 security_group_names=[sec_grp_settings.name],
1721 port_settings=[self.port_settings])
1722 self.inst_creator = OpenStackVmInstance(
1723 self.os_creds, instance_settings,
1724 self.image_creator.image_settings)
1725 vm_inst = self.inst_creator.create(block=True)
1726 self.assertIsNotNone(vm_inst)
1728 # Check that group has been added
1729 self.assertTrue(inst_has_sec_grp(
1730 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1732 # Add security group to instance after activated
1733 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1735 # Validate that security group has been added
1736 self.assertTrue(inst_has_sec_grp(
1737 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1740 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1742 Returns true if instance has a security group of a given name
1743 :param nova: the nova client
1744 :param vm_inst: the VmInst domain object
1745 :param sec_grp_name: the name of the security group to validate
1748 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1749 for name in sec_grp_names:
1750 if sec_grp_name == name:
1755 def validate_ssh_client(instance_creator):
1757 Returns True if instance_creator returns an SSH client that is valid
1758 :param instance_creator: the object responsible for creating the VM
1762 ssh_active = instance_creator.vm_ssh_active(block=True)
1765 ssh_client = instance_creator.ssh_client()
1768 out = ssh_client.exec_command('pwd')[1]
1774 channel = out.channel
1775 in_buffer = channel.in_buffer
1776 pwd_out = in_buffer.read(1024)
1777 if not pwd_out or len(pwd_out) < 10:
1784 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
1786 Test for the CreateInstance class for creating an image from a 3-part image
1791 Instantiates the CreateImage object that is responsible for downloading
1792 and creating an OS image file within OpenStack
1794 super(self.__class__, self).__start__()
1796 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1797 self.image_name = guid
1798 self.vm_inst_name = guid + '-inst'
1799 self.nova = nova_utils.nova_client(self.os_creds)
1801 net_config = openstack_tests.get_priv_net_config(
1802 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1803 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1805 # Initialize for tearDown()
1806 self.image_creator = None
1807 self.network_creator = None
1808 self.flavor_creator = None
1809 self.inst_creator = None
1812 if self.image_metadata and 'disk_file' in self.image_metadata:
1813 metadata = self.image_metadata
1814 elif self.image_metadata and 'cirros' in self.image_metadata \
1815 and 'disk_file' in self.image_metadata['cirros']:
1816 metadata = self.image_metadata['cirros']
1819 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
1821 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
1823 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
1825 image_settings = openstack_tests.cirros_image_settings(
1826 name=self.image_name,
1827 image_metadata=metadata)
1829 if not image_settings.ramdisk_image_settings or not \
1830 image_settings.kernel_image_settings:
1832 '3 Part image will not be tested. Image metadata has '
1833 'overridden this functionality')
1835 self.image_creator = OpenStackImage(self.os_creds, image_settings)
1836 self.image_creator.create()
1839 self.flavor_creator = OpenStackFlavor(
1840 self.admin_os_creds,
1841 FlavorSettings(name=guid + '-flavor-name', ram=256, disk=10,
1842 vcpus=2, metadata=self.flavor_metadata))
1843 self.flavor_creator.create()
1846 self.network_creator = OpenStackNetwork(
1847 self.os_creds, net_config.network_settings)
1848 self.network_creator.create()
1850 self.port_settings = PortSettings(
1851 name=guid + '-port',
1852 network_name=net_config.network_settings.name)
1853 except Exception as e:
1859 Cleans the created object
1861 if self.inst_creator:
1863 self.inst_creator.clean()
1864 except Exception as e:
1866 'Unexpected exception cleaning VM instance with message -'
1869 if self.flavor_creator:
1871 self.flavor_creator.clean()
1872 except Exception as e:
1874 'Unexpected exception cleaning flavor with message - %s',
1877 if self.network_creator:
1879 self.network_creator.clean()
1880 except Exception as e:
1882 'Unexpected exception cleaning network with message - %s',
1885 if self.image_creator and not self.image_creator.image_settings.exists:
1887 self.image_creator.clean()
1888 except Exception as e:
1890 'Unexpected exception cleaning image with message - %s', e)
1892 super(self.__class__, self).__clean__()
1894 def test_create_instance_from_three_part_image(self):
1896 Tests the creation of an OpenStack instance from a 3-part image.
1898 instance_settings = VmInstanceSettings(
1899 name=self.vm_inst_name,
1900 flavor=self.flavor_creator.flavor_settings.name,
1901 port_settings=[self.port_settings])
1903 # The last created image is the main image from which we create the
1905 self.inst_creator = OpenStackVmInstance(
1906 self.os_creds, instance_settings,
1907 self.image_creator.image_settings)
1909 vm_inst = self.inst_creator.create()
1910 self.assertIsNotNone(vm_inst)
1911 self.assertTrue(self.inst_creator.vm_active(block=True))
1914 class CreateInstanceMockOfflineTests(OSComponentTestCase):
1916 Tests the custom image_metadata that can be set by clients for handling
1917 images differently than the default behavior of the existing tests
1918 primarily for offline testing
1923 Instantiates the CreateImage object that is responsible for downloading
1924 and creating an OS image file within OpenStack
1926 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1928 self.tmpDir = 'tmp/' + str(self.guid)
1929 if not os.path.exists(self.tmpDir):
1930 os.makedirs(self.tmpDir)
1932 self.image_name = self.guid + '-image'
1933 self.vm_inst_name = self.guid + '-inst'
1934 self.port_1_name = self.guid + 'port-1'
1936 # Initialize for tearDown()
1937 self.image_creator = None
1938 self.network_creator = None
1939 self.flavor_creator = None
1940 self.inst_creator = None
1942 self.priv_net_config = openstack_tests.get_priv_net_config(
1943 net_name=self.guid + '-priv-net',
1944 subnet_name=self.guid + '-priv-subnet')
1945 self.port_settings = PortSettings(
1946 name=self.port_1_name,
1947 network_name=self.priv_net_config.network_settings.name)
1950 # Download image file
1951 self.image_file = file_utils.download(
1952 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
1955 self.network_creator = OpenStackNetwork(
1956 self.os_creds, self.priv_net_config.network_settings)
1957 self.network_creator.create()
1960 self.flavor_creator = OpenStackFlavor(
1963 name=self.guid + '-flavor-name', ram=256, disk=10,
1965 self.flavor_creator.create()
1966 except Exception as e:
1972 Cleans the created object
1974 if self.inst_creator:
1976 self.inst_creator.clean()
1977 except Exception as e:
1979 'Unexpected exception cleaning VM instance with message - '
1982 if self.network_creator:
1984 self.network_creator.clean()
1985 except Exception as e:
1987 'Unexpected exception cleaning network with message - %s',
1990 if self.flavor_creator:
1992 self.flavor_creator.clean()
1993 except Exception as e:
1995 'Unexpected exception cleaning flavor with message - %s',
1998 if self.image_creator:
2000 self.image_creator.clean()
2001 except Exception as e:
2003 'Unexpected exception cleaning image with message - %s', e)
2005 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
2006 shutil.rmtree(self.tmpDir)
2008 def test_inst_from_file_image_simple_flat(self):
2010 Creates a VM instance from a locally sourced file image using simply
2011 the 'disk_file' attribute vs. using the 'config' option which
2012 completely overrides all image settings
2015 metadata = {'disk_file': self.image_file.name}
2017 os_image_settings = openstack_tests.cirros_image_settings(
2018 name=self.image_name, image_metadata=metadata)
2019 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2020 self.assertEqual(openstack_tests.CIRROS_USER,
2021 os_image_settings.image_user)
2022 self.assertIsNone(os_image_settings.url)
2023 self.assertFalse(os_image_settings.exists)
2024 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2025 os_image_settings.format)
2027 self.assertIsNone(os_image_settings.kernel_image_settings)
2028 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2030 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2031 self.image_creator.create()
2033 instance_settings = VmInstanceSettings(
2034 name=self.vm_inst_name,
2035 flavor=self.flavor_creator.flavor_settings.name,
2036 port_settings=[self.port_settings])
2037 self.inst_creator = OpenStackVmInstance(
2038 self.os_creds, instance_settings,
2039 self.image_creator.image_settings)
2040 self.inst_creator.create()
2042 self.assertTrue(self.inst_creator.vm_active(block=True))
2044 def test_inst_from_file_image_simple_nested(self):
2046 Creates a VM instance from a locally sourced file image using simply
2047 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
2048 which completely overrides all image settings
2051 metadata = {'cirros': {'disk_file': self.image_file.name}}
2053 os_image_settings = openstack_tests.cirros_image_settings(
2054 name=self.image_name, image_metadata=metadata)
2055 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2056 self.assertEqual(openstack_tests.CIRROS_USER,
2057 os_image_settings.image_user)
2058 self.assertIsNone(os_image_settings.url)
2059 self.assertFalse(os_image_settings.exists)
2060 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2061 os_image_settings.format)
2063 self.assertIsNone(os_image_settings.kernel_image_settings)
2064 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2066 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2067 self.image_creator.create()
2069 instance_settings = VmInstanceSettings(
2070 name=self.vm_inst_name,
2071 flavor=self.flavor_creator.flavor_settings.name,
2072 port_settings=[self.port_settings])
2073 self.inst_creator = OpenStackVmInstance(
2074 self.os_creds, instance_settings,
2075 self.image_creator.image_settings)
2076 self.inst_creator.create()
2078 self.assertTrue(self.inst_creator.vm_active(block=True))
2080 def test_inst_from_existing(self):
2082 Creates a VM instance from a image creator that has been configured to
2083 use an existing image
2086 os_image_settings = openstack_tests.cirros_image_settings(
2087 name=self.image_name)
2088 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2089 self.image_creator.create()
2091 image_settings = self.image_creator.image_settings
2092 test_image_creator = OpenStackImage(
2094 ImageSettings(name=image_settings.name,
2095 image_user=image_settings.image_user,
2097 test_image_creator.create()
2098 self.assertEqual(self.image_creator.get_image().id,
2099 test_image_creator.get_image().id)
2101 instance_settings = VmInstanceSettings(
2102 name=self.vm_inst_name,
2103 flavor=self.flavor_creator.flavor_settings.name,
2104 port_settings=[self.port_settings])
2105 self.inst_creator = OpenStackVmInstance(
2106 self.os_creds, instance_settings,
2107 test_image_creator.image_settings)
2108 self.inst_creator.create()
2110 self.assertTrue(self.inst_creator.vm_active(block=True))
2112 def test_inst_from_file_image_complex(self):
2114 Creates a VM instance from a locally sourced file image by overriding
2115 the default settings by using a dict() that can be read in by
2120 os_image_settings = openstack_tests.cirros_image_settings(
2121 name=self.image_name)
2122 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2123 self.image_creator.create()
2128 'name': os_image_settings.name,
2129 'image_user': os_image_settings.image_user,
2131 test_image_settings = openstack_tests.cirros_image_settings(
2132 image_metadata=metadata)
2133 test_image = OpenStackImage(self.os_creds, test_image_settings)
2136 instance_settings = VmInstanceSettings(
2137 name=self.vm_inst_name,
2138 flavor=self.flavor_creator.flavor_settings.name,
2139 port_settings=[self.port_settings])
2140 self.inst_creator = OpenStackVmInstance(self.os_creds,
2142 test_image_settings)
2143 self.inst_creator.create()
2145 self.assertTrue(self.inst_creator.vm_active(block=True))
2147 def test_inst_from_file_3part_image_complex(self):
2149 Creates a VM instance from a locally sourced file image by overriding
2150 the default settings by using a dict() that can be read in by
2155 kernel_file = file_utils.download(
2156 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2157 ramdisk_file = file_utils.download(
2158 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2163 'name': self.image_name,
2164 'image_user': openstack_tests.CIRROS_USER,
2165 'image_file': self.image_file.name,
2166 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2167 'kernel_image_settings': {
2168 'name': self.image_name + '-kernel',
2169 'image_user': openstack_tests.CIRROS_USER,
2170 'image_file': kernel_file.name,
2171 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2172 'ramdisk_image_settings': {
2173 'name': self.image_name + '-ramdisk',
2174 'image_user': openstack_tests.CIRROS_USER,
2175 'image_file': ramdisk_file.name,
2176 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2178 os_image_settings = openstack_tests.cirros_image_settings(
2179 name=self.image_name, image_metadata=metadata)
2180 self.assertEqual(self.image_name, os_image_settings.name)
2181 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2182 self.assertEqual(openstack_tests.CIRROS_USER,
2183 os_image_settings.image_user)
2184 self.assertIsNone(os_image_settings.url)
2185 self.assertFalse(os_image_settings.exists)
2186 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2187 os_image_settings.format)
2189 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2190 self.assertEqual(self.image_name + '-kernel',
2191 os_image_settings.kernel_image_settings.name)
2192 self.assertEqual(kernel_file.name,
2193 os_image_settings.kernel_image_settings.image_file)
2194 self.assertEqual(openstack_tests.CIRROS_USER,
2195 os_image_settings.kernel_image_settings.image_user)
2196 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2197 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2198 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2199 os_image_settings.kernel_image_settings.format)
2201 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2202 self.assertEqual(self.image_name + '-ramdisk',
2203 os_image_settings.ramdisk_image_settings.name)
2204 self.assertEqual(ramdisk_file.name,
2205 os_image_settings.ramdisk_image_settings.image_file)
2206 self.assertEqual(openstack_tests.CIRROS_USER,
2207 os_image_settings.ramdisk_image_settings.image_user)
2208 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2209 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2210 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2211 os_image_settings.ramdisk_image_settings.format)
2213 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2214 self.image_creator.create()
2216 instance_settings = VmInstanceSettings(
2217 name=self.vm_inst_name,
2218 flavor=self.flavor_creator.flavor_settings.name,
2219 port_settings=[self.port_settings])
2220 self.inst_creator = OpenStackVmInstance(
2221 self.os_creds, instance_settings,
2222 self.image_creator.image_settings)
2223 self.inst_creator.create()
2225 self.assertTrue(self.inst_creator.vm_active(block=True))
2227 def test_inst_from_file_3part_image_simple_flat(self):
2229 Creates a VM instance from a 3-part image locally sourced from file
2230 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2231 attributes vs. using the 'config' option which completely overrides all
2235 kernel_file = file_utils.download(
2236 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2237 ramdisk_file = file_utils.download(
2238 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2240 metadata = {'disk_file': self.image_file.name,
2241 'kernel_file': kernel_file.name,
2242 'ramdisk_file': ramdisk_file.name}
2244 os_image_settings = openstack_tests.cirros_image_settings(
2245 name=self.image_name, image_metadata=metadata)
2247 self.assertEqual(self.image_name, os_image_settings.name)
2248 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2249 self.assertEqual(openstack_tests.CIRROS_USER,
2250 os_image_settings.image_user)
2251 self.assertIsNone(os_image_settings.url)
2252 self.assertFalse(os_image_settings.exists)
2253 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2254 os_image_settings.format)
2256 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2257 self.assertEqual(self.image_name + '-kernel',
2258 os_image_settings.kernel_image_settings.name)
2259 self.assertEqual(kernel_file.name,
2260 os_image_settings.kernel_image_settings.image_file)
2261 self.assertEqual(openstack_tests.CIRROS_USER,
2262 os_image_settings.kernel_image_settings.image_user)
2263 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2264 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2265 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2266 os_image_settings.kernel_image_settings.format)
2268 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2269 self.assertEqual(self.image_name + '-ramdisk',
2270 os_image_settings.ramdisk_image_settings.name)
2271 self.assertEqual(ramdisk_file.name,
2272 os_image_settings.ramdisk_image_settings.image_file)
2273 self.assertEqual(openstack_tests.CIRROS_USER,
2274 os_image_settings.ramdisk_image_settings.image_user)
2275 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2276 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2277 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2278 os_image_settings.ramdisk_image_settings.format)
2280 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2281 self.image_creator.create()
2283 self.assertIsNotNone(self.image_creator.get_kernel_image())
2284 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2286 instance_settings = VmInstanceSettings(
2287 name=self.vm_inst_name,
2288 flavor=self.flavor_creator.flavor_settings.name,
2289 port_settings=[self.port_settings])
2290 self.inst_creator = OpenStackVmInstance(
2291 self.os_creds, instance_settings,
2292 self.image_creator.image_settings)
2293 self.inst_creator.create()
2295 self.assertTrue(self.inst_creator.vm_active(block=True))
2297 def test_inst_from_file_3part_image_simple_nested(self):
2299 Creates a VM instance from a 3-part image locally sourced from file
2300 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2301 attributes under 'cirros' vs. using the 'config' option which
2302 completely overrides all image settings
2305 kernel_file = file_utils.download(
2306 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2307 ramdisk_file = file_utils.download(
2308 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2310 metadata = {'cirros': {'disk_file': self.image_file.name,
2311 'kernel_file': kernel_file.name,
2312 'ramdisk_file': ramdisk_file.name}}
2314 os_image_settings = openstack_tests.cirros_image_settings(
2315 name=self.image_name, image_metadata=metadata)
2317 self.assertEqual(self.image_name, os_image_settings.name)
2318 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2319 self.assertEqual(openstack_tests.CIRROS_USER,
2320 os_image_settings.image_user)
2321 self.assertIsNone(os_image_settings.url)
2322 self.assertFalse(os_image_settings.exists)
2323 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2324 os_image_settings.format)
2326 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2327 self.assertEqual(self.image_name + '-kernel',
2328 os_image_settings.kernel_image_settings.name)
2329 self.assertEqual(kernel_file.name,
2330 os_image_settings.kernel_image_settings.image_file)
2331 self.assertEqual(openstack_tests.CIRROS_USER,
2332 os_image_settings.kernel_image_settings.image_user)
2333 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2334 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2335 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2336 os_image_settings.kernel_image_settings.format)
2338 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2339 self.assertEqual(self.image_name + '-ramdisk',
2340 os_image_settings.ramdisk_image_settings.name)
2341 self.assertEqual(ramdisk_file.name,
2342 os_image_settings.ramdisk_image_settings.image_file)
2343 self.assertEqual(openstack_tests.CIRROS_USER,
2344 os_image_settings.ramdisk_image_settings.image_user)
2345 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2346 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2347 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2348 os_image_settings.ramdisk_image_settings.format)
2350 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2351 self.image_creator.create()
2353 self.assertIsNotNone(self.image_creator.get_kernel_image())
2354 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2356 instance_settings = VmInstanceSettings(
2357 name=self.vm_inst_name,
2358 flavor=self.flavor_creator.flavor_settings.name,
2359 port_settings=[self.port_settings])
2360 self.inst_creator = OpenStackVmInstance(
2361 self.os_creds, instance_settings,
2362 self.image_creator.image_settings)
2363 self.inst_creator.create()
2365 self.assertTrue(self.inst_creator.vm_active(block=True))
2367 def test_inst_from_file_3part_image_existing(self):
2369 Creates a VM instance from a 3-part image that is existing
2372 kernel_file = file_utils.download(
2373 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2374 ramdisk_file = file_utils.download(
2375 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2377 metadata = {'cirros': {'disk_file': self.image_file.name,
2378 'kernel_file': kernel_file.name,
2379 'ramdisk_file': ramdisk_file.name}}
2381 os_image_settings = openstack_tests.cirros_image_settings(
2382 name=self.image_name, image_metadata=metadata)
2383 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2384 self.image_creator.create()
2386 image_settings = self.image_creator.image_settings
2387 test_image_creator = OpenStackImage(
2389 ImageSettings(name=image_settings.name,
2390 image_user=image_settings.image_user,
2392 test_image_creator.create()
2393 self.assertEqual(self.image_creator.get_image().id,
2394 test_image_creator.get_image().id)
2396 instance_settings = VmInstanceSettings(
2397 name=self.vm_inst_name,
2398 flavor=self.flavor_creator.flavor_settings.name,
2399 port_settings=[self.port_settings])
2400 self.inst_creator = OpenStackVmInstance(
2401 self.os_creds, instance_settings,
2402 test_image_creator.image_settings)
2403 self.inst_creator.create()
2405 self.assertTrue(self.inst_creator.vm_active(block=True))
2408 class CreateInstanceTwoNetTests(OSIntegrationTestCase):
2410 Tests the ability of two VMs to communicate when attached to separate
2411 private networks that are tied together with a router.
2416 Instantiates the CreateImage object that is responsible for downloading
2417 and creating an OS image file within OpenStack
2419 super(self.__class__, self).__start__()
2421 cidr1 = '10.200.201.0/24'
2422 cidr2 = '10.200.202.0/24'
2423 static_gateway_ip1 = '10.200.201.1'
2424 static_gateway_ip2 = '10.200.202.1'
2425 self.ip1 = '10.200.201.5'
2426 self.ip2 = '10.200.202.5'
2428 self.nova = nova_utils.nova_client(self.os_creds)
2430 # Initialize for tearDown()
2431 self.image_creator = None
2432 self.network_creators = list()
2433 self.router_creator = None
2434 self.flavor_creator = None
2435 self.sec_grp_creator = None
2436 self.inst_creators = list()
2438 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
2439 self.vm_inst1_name = self.guid + '-inst1'
2440 self.vm_inst2_name = self.guid + '-inst2'
2441 self.port_1_name = self.guid + '-vm1-port'
2442 self.port_2_name = self.guid + '-vm2-port'
2443 self.net_config_1 = NetworkSettings(
2444 name=self.guid + '-net1',
2446 create_network.SubnetSettings(
2447 cidr=cidr1, name=self.guid + '-subnet1',
2448 gateway_ip=static_gateway_ip1)])
2449 self.net_config_2 = NetworkSettings(
2450 name=self.guid + '-net2',
2452 create_network.SubnetSettings(
2453 cidr=cidr2, name=self.guid + '-subnet2',
2454 gateway_ip=static_gateway_ip2)])
2456 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
2457 os_image_settings = openstack_tests.cirros_image_settings(
2458 name=image_name, image_metadata=self.image_metadata)
2462 self.image_creator = OpenStackImage(self.os_creds,
2464 self.image_creator.create()
2466 # First network is public
2467 self.network_creators.append(OpenStackNetwork(
2468 self.os_creds, self.net_config_1))
2469 # Second network is private
2470 self.network_creators.append(OpenStackNetwork(
2471 self.os_creds, self.net_config_2))
2472 for network_creator in self.network_creators:
2473 network_creator.create()
2476 create_network.PortSettings(
2477 name=self.guid + '-router-port1',
2480 self.net_config_1.subnet_settings[0].name,
2481 'ip': static_gateway_ip1
2483 network_name=self.net_config_1.name,
2484 project_name=self.os_creds.project_name),
2485 create_network.PortSettings(
2486 name=self.guid + '-router-port2',
2489 self.net_config_2.subnet_settings[0].name,
2490 'ip': static_gateway_ip2
2492 network_name=self.net_config_2.name,
2493 project_name=self.os_creds.project_name)]
2495 router_settings = RouterSettings(name=self.guid + '-pub-router',
2496 port_settings=port_settings)
2497 self.router_creator = create_router.OpenStackRouter(
2498 self.os_creds, router_settings)
2499 self.router_creator.create()
2502 self.flavor_creator = OpenStackFlavor(
2503 self.admin_os_creds,
2504 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
2506 metadata=self.flavor_metadata))
2507 self.flavor_creator.create()
2509 sec_grp_name = self.guid + '-sec-grp'
2510 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
2511 direction=Direction.ingress,
2512 protocol=Protocol.icmp)
2513 self.sec_grp_creator = OpenStackSecurityGroup(
2515 SecurityGroupSettings(name=sec_grp_name,
2516 rule_settings=[rule1]))
2517 self.sec_grp_creator.create()
2524 Cleans the created objects
2526 for inst_creator in self.inst_creators:
2528 inst_creator.clean()
2529 except Exception as e:
2531 'Unexpected exception cleaning VM instance with message '
2534 if self.flavor_creator:
2536 self.flavor_creator.clean()
2537 except Exception as e:
2539 'Unexpected exception cleaning flavor with message - %s',
2542 if self.router_creator:
2544 self.router_creator.clean()
2545 except Exception as e:
2547 'Unexpected exception cleaning router with message - %s',
2550 for network_creator in self.network_creators:
2552 network_creator.clean()
2553 except Exception as e:
2555 'Unexpected exception cleaning network with message - %s',
2558 if self.sec_grp_creator:
2560 self.sec_grp_creator.clean()
2561 except Exception as e:
2563 'Unexpected exception cleaning security group with message'
2566 if self.image_creator and not self.image_creator.image_settings.exists:
2568 self.image_creator.clean()
2569 except Exception as e:
2571 'Unexpected exception cleaning image with message - %s', e)
2573 super(self.__class__, self).__clean__()
2575 def test_ping_via_router(self):
2577 Tests the creation of two OpenStack instances with one port on
2578 different private networks wit a router in between to ensure that they
2582 # Create ports/NICs for instance
2585 for network_creator in self.network_creators:
2586 ports_settings.append(PortSettings(
2587 name=self.guid + '-port-' + str(ctr),
2588 network_name=network_creator.network_settings.name))
2591 # Configure instances
2592 instance1_settings = VmInstanceSettings(
2593 name=self.vm_inst1_name,
2594 flavor=self.flavor_creator.flavor_settings.name,
2595 userdata=_get_ping_userdata(self.ip2),
2596 port_settings=[PortSettings(
2597 name=self.port_1_name,
2600 self.net_config_1.subnet_settings[0].name,
2603 network_name=self.network_creators[0].network_settings.name)])
2604 instance2_settings = VmInstanceSettings(
2605 name=self.vm_inst2_name,
2606 flavor=self.flavor_creator.flavor_settings.name,
2607 userdata=_get_ping_userdata(self.ip1),
2608 port_settings=[PortSettings(
2609 name=self.port_2_name,
2612 self.net_config_2.subnet_settings[0].name,
2615 network_name=self.network_creators[1].network_settings.name)])
2618 self.inst_creators.append(OpenStackVmInstance(
2619 self.os_creds, instance1_settings,
2620 self.image_creator.image_settings))
2621 self.inst_creators.append(OpenStackVmInstance(
2622 self.os_creds, instance2_settings,
2623 self.image_creator.image_settings))
2625 for inst_creator in self.inst_creators:
2626 inst_creator.create(block=True)
2628 # Check for DHCP lease
2629 self.assertTrue(check_dhcp_lease(self.inst_creators[0], self.ip1))
2630 self.assertTrue(check_dhcp_lease(self.inst_creators[1], self.ip2))
2632 # Effectively blocks until VM has been properly activated
2633 self.assertTrue(check_ping(self.inst_creators[0]))
2634 self.assertTrue(check_ping(self.inst_creators[1]))
2637 def check_dhcp_lease(inst_creator, ip, timeout=160):
2639 Returns true if the expected DHCP lease has been acquired
2640 :param inst_creator: the SNAPS OpenStackVmInstance object
2641 :param ip: the IP address to look for
2642 :param timeout: how long to query for IP address
2646 start_time = time.time()
2648 logger.info("Looking for IP %s in the console log" % ip)
2650 while timeout > time.time() - start_time:
2651 output = inst_creator.get_console_output()
2652 full_log = full_log + output
2653 if re.search(ip, output):
2654 logger.info('DHCP lease obtained logged in console')
2659 logger.error('Full console output -\n' + full_log)
2661 logger.debug('Full console output -\n' + full_log)
2666 def _get_ping_userdata(test_ip):
2668 Returns the post VM creation script to be added into the VM's userdata
2669 :param test_ip: the IP value to substitute into the script
2670 :return: the bash script contents
2673 return ("#!/bin/sh\n\n"
2675 " ping -c 1 %s 2>&1 >/dev/null\n"
2677 " if [ \"Z$RES\" = \"Z0\" ] ; then\n"
2678 " echo 'vPing OK'\n"
2681 " echo 'vPing KO'\n"
2688 def check_ping(vm_creator, timeout=160):
2690 Check for VM for ping result
2694 while tries < timeout:
2696 p_console = vm_creator.get_console_output()
2697 if "vPing OK" in p_console:
2699 elif "failed to read iid from metadata" in p_console or tries > 5: