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.
24 from snaps import file_utils
25 from snaps.openstack.create_flavor import OpenStackFlavor, FlavorSettings
26 from snaps.openstack.create_image import OpenStackImage, ImageSettings
27 from snaps.openstack.create_instance import (
28 VmInstanceSettings, OpenStackVmInstance, FloatingIpSettings)
29 from snaps.openstack.create_keypairs import OpenStackKeypair, KeypairSettings
30 from snaps.openstack.create_network import OpenStackNetwork, PortSettings
31 from snaps.openstack.create_router import OpenStackRouter
32 from snaps.openstack.create_security_group import (
33 SecurityGroupSettings, OpenStackSecurityGroup, SecurityGroupRuleSettings,
35 from snaps.openstack.tests import openstack_tests, validation_utils
36 from snaps.openstack.tests.os_source_file_test import (
37 OSIntegrationTestCase, OSComponentTestCase)
38 from snaps.openstack.utils import nova_utils
40 __author__ = 'spisarski'
44 logger = logging.getLogger('create_instance_tests')
47 class VmInstanceSettingsUnitTests(unittest.TestCase):
49 Tests the construction of the VmInstanceSettings class
52 def test_no_params(self):
53 with self.assertRaises(Exception):
56 def test_empty_config(self):
57 with self.assertRaises(Exception):
58 VmInstanceSettings(config=dict())
60 def test_name_only(self):
61 with self.assertRaises(Exception):
62 VmInstanceSettings(name='foo')
64 def test_config_with_name_only(self):
65 with self.assertRaises(Exception):
66 VmInstanceSettings(config={'name': 'foo'})
68 def test_name_flavor_only(self):
69 with self.assertRaises(Exception):
70 VmInstanceSettings(name='foo', flavor='bar')
72 def test_config_with_name_flavor_only(self):
73 with self.assertRaises(Exception):
74 VmInstanceSettings(config={'name': 'foo', 'flavor': 'bar'})
76 def test_name_flavor_port_only(self):
77 port_settings = PortSettings(name='foo-port', network_name='bar-net')
78 settings = VmInstanceSettings(name='foo', flavor='bar',
79 port_settings=[port_settings])
80 self.assertEqual('foo', settings.name)
81 self.assertEqual('bar', settings.flavor)
82 self.assertEqual(1, len(settings.port_settings))
83 self.assertEqual('foo-port', settings.port_settings[0].name)
84 self.assertEqual('bar-net', settings.port_settings[0].network_name)
85 self.assertEqual(0, len(settings.security_group_names))
86 self.assertEqual(0, len(settings.floating_ip_settings))
87 self.assertIsNone(settings.sudo_user)
88 self.assertEqual(900, settings.vm_boot_timeout)
89 self.assertEqual(300, settings.vm_delete_timeout)
90 self.assertEqual(180, settings.ssh_connect_timeout)
91 self.assertIsNone(settings.availability_zone)
93 def test_config_with_name_flavor_port_only(self):
94 port_settings = PortSettings(name='foo-port', network_name='bar-net')
95 settings = VmInstanceSettings(
96 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings]})
97 self.assertEqual('foo', settings.name)
98 self.assertEqual('bar', settings.flavor)
99 self.assertEqual(1, len(settings.port_settings))
100 self.assertEqual('foo-port', settings.port_settings[0].name)
101 self.assertEqual('bar-net', settings.port_settings[0].network_name)
102 self.assertEqual(0, len(settings.security_group_names))
103 self.assertEqual(0, len(settings.floating_ip_settings))
104 self.assertIsNone(settings.sudo_user)
105 self.assertEqual(900, settings.vm_boot_timeout)
106 self.assertEqual(300, settings.vm_delete_timeout)
107 self.assertEqual(180, settings.ssh_connect_timeout)
108 self.assertIsNone(settings.availability_zone)
111 port_settings = PortSettings(name='foo-port', network_name='bar-net')
112 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
113 router_name='foo-bar-router')
115 settings = VmInstanceSettings(name='foo', flavor='bar',
116 port_settings=[port_settings],
117 security_group_names=['sec_grp_1'],
118 floating_ip_settings=[fip_settings],
119 sudo_user='joe', vm_boot_timeout=999,
120 vm_delete_timeout=333,
121 ssh_connect_timeout=111,
122 availability_zone='server name')
123 self.assertEqual('foo', settings.name)
124 self.assertEqual('bar', settings.flavor)
125 self.assertEqual(1, len(settings.port_settings))
126 self.assertEqual('foo-port', settings.port_settings[0].name)
127 self.assertEqual('bar-net', settings.port_settings[0].network_name)
128 self.assertEqual(1, len(settings.security_group_names))
129 self.assertEqual('sec_grp_1', settings.security_group_names[0])
130 self.assertEqual(1, len(settings.floating_ip_settings))
131 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
132 self.assertEqual('bar-port',
133 settings.floating_ip_settings[0].port_name)
134 self.assertEqual('foo-bar-router',
135 settings.floating_ip_settings[0].router_name)
136 self.assertEqual('joe', settings.sudo_user)
137 self.assertEqual(999, settings.vm_boot_timeout)
138 self.assertEqual(333, settings.vm_delete_timeout)
139 self.assertEqual(111, settings.ssh_connect_timeout)
140 self.assertEqual('server name', settings.availability_zone)
142 def test_config_all(self):
143 port_settings = PortSettings(name='foo-port', network_name='bar-net')
144 fip_settings = FloatingIpSettings(name='foo-fip', port_name='bar-port',
145 router_name='foo-bar-router')
147 settings = VmInstanceSettings(
148 **{'name': 'foo', 'flavor': 'bar', 'ports': [port_settings],
149 'security_group_names': ['sec_grp_1'],
150 'floating_ips': [fip_settings], 'sudo_user': 'joe',
151 'vm_boot_timeout': 999, 'vm_delete_timeout': 333,
152 'ssh_connect_timeout': 111, 'availability_zone': 'server name'})
153 self.assertEqual('foo', settings.name)
154 self.assertEqual('bar', settings.flavor)
155 self.assertEqual(1, len(settings.port_settings))
156 self.assertEqual('foo-port', settings.port_settings[0].name)
157 self.assertEqual('bar-net', settings.port_settings[0].network_name)
158 self.assertEqual(1, len(settings.security_group_names))
159 self.assertEqual(1, len(settings.floating_ip_settings))
160 self.assertEqual('foo-fip', settings.floating_ip_settings[0].name)
161 self.assertEqual('bar-port',
162 settings.floating_ip_settings[0].port_name)
163 self.assertEqual('foo-bar-router',
164 settings.floating_ip_settings[0].router_name)
165 self.assertEqual('joe', settings.sudo_user)
166 self.assertEqual(999, settings.vm_boot_timeout)
167 self.assertEqual(333, settings.vm_delete_timeout)
168 self.assertEqual(111, settings.ssh_connect_timeout)
169 self.assertEqual('server name', settings.availability_zone)
172 class FloatingIpSettingsUnitTests(unittest.TestCase):
174 Tests the construction of the FloatingIpSettings class
177 def test_no_params(self):
178 with self.assertRaises(Exception):
181 def test_empty_config(self):
182 with self.assertRaises(Exception):
183 FloatingIpSettings(**dict())
185 def test_name_only(self):
186 with self.assertRaises(Exception):
187 FloatingIpSettings(name='foo')
189 def test_config_with_name_only(self):
190 with self.assertRaises(Exception):
191 FloatingIpSettings(**{'name': 'foo'})
193 def test_name_port_only(self):
194 with self.assertRaises(Exception):
195 FloatingIpSettings(name='foo', port_name='bar')
197 def test_config_with_name_port_only(self):
198 with self.assertRaises(Exception):
199 FloatingIpSettings(**{'name': 'foo', 'port_name': 'bar'})
201 def test_name_router_only(self):
202 with self.assertRaises(Exception):
203 FloatingIpSettings(name='foo', router_name='bar')
205 def test_config_with_name_router_only(self):
206 with self.assertRaises(Exception):
207 FloatingIpSettings(**{'name': 'foo', 'router_name': 'bar'})
209 def test_name_port_router_only(self):
210 settings = FloatingIpSettings(name='foo', port_name='foo-port',
211 router_name='bar-router')
212 self.assertEqual('foo', settings.name)
213 self.assertEqual('foo-port', settings.port_name)
214 self.assertEqual('bar-router', settings.router_name)
215 self.assertIsNone(settings.subnet_name)
216 self.assertTrue(settings.provisioning)
218 def test_config_with_name_port_router_only(self):
219 settings = FloatingIpSettings(
220 **{'name': 'foo', 'port_name': 'foo-port',
221 'router_name': 'bar-router'})
222 self.assertEqual('foo', settings.name)
223 self.assertEqual('foo-port', settings.port_name)
224 self.assertEqual('bar-router', settings.router_name)
225 self.assertIsNone(settings.subnet_name)
226 self.assertTrue(settings.provisioning)
229 settings = FloatingIpSettings(name='foo', port_name='foo-port',
230 router_name='bar-router',
231 subnet_name='bar-subnet',
233 self.assertEqual('foo', settings.name)
234 self.assertEqual('foo-port', settings.port_name)
235 self.assertEqual('bar-router', settings.router_name)
236 self.assertEqual('bar-subnet', settings.subnet_name)
237 self.assertFalse(settings.provisioning)
239 def test_config_all(self):
240 settings = FloatingIpSettings(
241 **{'name': 'foo', 'port_name': 'foo-port',
242 'router_name': 'bar-router', 'subnet_name': 'bar-subnet',
243 'provisioning': False})
244 self.assertEqual('foo', settings.name)
245 self.assertEqual('foo-port', settings.port_name)
246 self.assertEqual('bar-router', settings.router_name)
247 self.assertEqual('bar-subnet', settings.subnet_name)
248 self.assertFalse(settings.provisioning)
251 class SimpleHealthCheck(OSIntegrationTestCase):
253 Test for the CreateInstance class with a single NIC/Port with Floating IPs
258 Instantiates the CreateImage object that is responsible for downloading
259 and creating an OS image file
262 super(self.__class__, self).__start__()
264 self.nova = nova_utils.nova_client(self.os_creds)
265 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
266 self.vm_inst_name = guid + '-inst'
267 self.port_1_name = guid + 'port-1'
269 # Initialize for tearDown()
270 self.image_creator = None
271 self.network_creator = None
272 self.flavor_creator = None
273 self.inst_creator = None
275 self.priv_net_config = openstack_tests.get_priv_net_config(
276 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
277 self.port_settings = PortSettings(
278 name=self.port_1_name,
279 network_name=self.priv_net_config.network_settings.name)
282 # Set the default image settings, then set any custom parameters sent
284 os_image_settings = openstack_tests.cirros_image_settings(
285 name=guid + '-image', image_metadata=self.image_metadata)
288 self.image_creator = OpenStackImage(self.os_creds,
290 self.image_creator.create()
293 self.network_creator = OpenStackNetwork(
294 self.os_creds, self.priv_net_config.network_settings)
295 self.network_creator.create()
298 self.flavor_creator = OpenStackFlavor(
300 FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
301 vcpus=1, metadata=self.flavor_metadata))
302 self.flavor_creator.create()
303 except Exception as e:
309 Cleans the created object
311 if self.inst_creator:
313 self.inst_creator.clean()
314 except Exception as e:
316 'Unexpected exception cleaning VM instance with message'
319 if self.network_creator:
321 self.network_creator.clean()
322 except Exception as e:
324 'Unexpected exception cleaning network with message - %s',
327 if self.flavor_creator:
329 self.flavor_creator.clean()
330 except Exception as e:
332 'Unexpected exception cleaning flavor with message - %s',
335 if self.image_creator and not self.image_creator.image_settings.exists:
337 self.image_creator.clean()
338 except Exception as e:
340 'Unexpected exception cleaning image with message - %s',
343 super(self.__class__, self).__clean__()
345 def test_check_vm_ip_dhcp(self):
347 Tests the creation of an OpenStack instance with a single port and
348 ensures that it's assigned IP address is the actual.
350 instance_settings = VmInstanceSettings(
351 name=self.vm_inst_name,
352 flavor=self.flavor_creator.flavor_settings.name,
353 port_settings=[self.port_settings])
355 self.inst_creator = OpenStackVmInstance(
356 self.os_creds, instance_settings,
357 self.image_creator.image_settings)
358 self.inst_creator.create()
360 ip = self.inst_creator.get_port_ip(self.port_settings.name)
361 self.assertIsNotNone(ip)
363 self.assertTrue(self.inst_creator.vm_active(block=True))
365 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
368 class CreateInstanceSimpleTests(OSIntegrationTestCase):
370 Simple instance creation tests without any other objects
375 Instantiates the CreateImage object that is responsible for downloading
376 and creating an OS image file
379 super(self.__class__, self).__start__()
381 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
382 self.vm_inst_name = guid + '-inst'
383 self.nova = nova_utils.nova_client(self.os_creds)
384 os_image_settings = openstack_tests.cirros_image_settings(
385 name=guid + '-image', image_metadata=self.image_metadata)
387 net_config = openstack_tests.get_priv_net_config(
388 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
389 router_name=guid + '-pub-router', external_net=self.ext_net_name)
391 # Initialize for tearDown()
392 self.image_creator = None
393 self.flavor_creator = None
395 self.network_creator = None
396 self.inst_creator = None
400 self.image_creator = OpenStackImage(self.os_creds,
402 self.image_creator.create()
405 self.flavor_creator = OpenStackFlavor(
407 FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
408 vcpus=2, metadata=self.flavor_metadata))
409 self.flavor_creator.create()
412 self.network_creator = OpenStackNetwork(
413 self.os_creds, net_config.network_settings)
414 self.network_creator.create()
416 self.port_settings = PortSettings(
418 network_name=net_config.network_settings.name)
420 except Exception as e:
426 Cleans the created object
428 if self.inst_creator:
430 self.inst_creator.clean()
431 except Exception as e:
433 'Unexpected exception cleaning VM instance with message '
436 if self.flavor_creator:
438 self.flavor_creator.clean()
439 except Exception as e:
441 'Unexpected exception cleaning flavor with message - %s',
444 if self.network_creator:
446 self.network_creator.clean()
447 except Exception as e:
449 'Unexpected exception cleaning network with message - %s',
452 if self.image_creator and not self.image_creator.image_settings.exists:
454 self.image_creator.clean()
455 except Exception as e:
457 'Unexpected exception cleaning image with message - %s', e)
459 super(self.__class__, self).__clean__()
461 def test_create_delete_instance(self):
463 Tests the creation of an OpenStack instance with a single port with a
464 static IP without a Floating IP.
466 instance_settings = VmInstanceSettings(
467 name=self.vm_inst_name,
468 flavor=self.flavor_creator.flavor_settings.name,
469 port_settings=[self.port_settings])
471 self.inst_creator = OpenStackVmInstance(
472 self.os_creds, instance_settings,
473 self.image_creator.image_settings)
475 vm_inst = self.inst_creator.create()
476 self.assertEqual(1, len(
477 nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
480 nova_utils.delete_vm_instance(self.nova, vm_inst)
482 self.assertTrue(self.inst_creator.vm_deleted(block=True))
483 self.assertEqual(0, len(
484 nova_utils.get_servers_by_name(self.nova, instance_settings.name)))
486 # Exception should not be thrown
487 self.inst_creator.clean()
490 class CreateInstanceSingleNetworkTests(OSIntegrationTestCase):
492 Test for the CreateInstance class with a single NIC/Port with Floating IPs
497 Instantiates the CreateImage object that is responsible for downloading
498 and creating an OS image file within OpenStack
500 super(self.__class__, self).__start__()
502 self.nova = nova_utils.nova_client(self.os_creds)
503 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
504 self.keypair_priv_filepath = 'tmp/' + guid
505 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
506 self.keypair_name = guid + '-kp'
507 self.vm_inst_name = guid + '-inst'
508 self.port_1_name = guid + 'port-1'
509 self.port_2_name = guid + 'port-2'
510 self.floating_ip_name = guid + 'fip1'
512 # Initialize for tearDown()
513 self.image_creator = None
514 self.network_creator = None
515 self.router_creator = None
516 self.flavor_creator = None
517 self.keypair_creator = None
518 self.sec_grp_creator = None
519 self.inst_creators = list()
521 self.pub_net_config = openstack_tests.get_pub_net_config(
522 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
523 router_name=guid + '-pub-router', external_net=self.ext_net_name)
524 os_image_settings = openstack_tests.cirros_image_settings(
525 name=guid + '-image', image_metadata=self.image_metadata)
528 self.image_creator = OpenStackImage(self.os_creds,
530 self.image_creator.create()
533 self.network_creator = OpenStackNetwork(
534 self.os_creds, self.pub_net_config.network_settings)
535 self.network_creator.create()
538 self.router_creator = OpenStackRouter(
539 self.os_creds, self.pub_net_config.router_settings)
540 self.router_creator.create()
543 self.flavor_creator = OpenStackFlavor(
545 FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
546 vcpus=2, metadata=self.flavor_metadata))
547 self.flavor_creator.create()
549 self.keypair_creator = OpenStackKeypair(
550 self.os_creds, KeypairSettings(
551 name=self.keypair_name,
552 public_filepath=self.keypair_pub_filepath,
553 private_filepath=self.keypair_priv_filepath))
554 self.keypair_creator.create()
556 sec_grp_name = guid + '-sec-grp'
557 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
558 direction=Direction.ingress,
559 protocol=Protocol.icmp)
560 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
561 direction=Direction.ingress,
562 protocol=Protocol.tcp,
565 self.sec_grp_creator = OpenStackSecurityGroup(
567 SecurityGroupSettings(name=sec_grp_name,
568 rule_settings=[rule1, rule2]))
569 self.sec_grp_creator.create()
570 except Exception as e:
576 Cleans the created object
578 for inst_creator in self.inst_creators:
581 except Exception as e:
583 'Unexpected exception cleaning VM instance with message '
586 if self.keypair_creator:
588 self.keypair_creator.clean()
589 except Exception as e:
591 'Unexpected exception cleaning keypair with message - %s',
594 if os.path.isfile(self.keypair_pub_filepath):
595 os.remove(self.keypair_pub_filepath)
597 if os.path.isfile(self.keypair_priv_filepath):
598 os.remove(self.keypair_priv_filepath)
600 if self.flavor_creator:
602 self.flavor_creator.clean()
603 except Exception as e:
605 'Unexpected exception cleaning flavor with message - %s',
608 if self.sec_grp_creator:
610 self.sec_grp_creator.clean()
611 except Exception as e:
613 'Unexpected exception cleaning security group with message'
616 if self.router_creator:
618 self.router_creator.clean()
619 except Exception as e:
621 'Unexpected exception cleaning router with message - %s',
624 if self.network_creator:
626 self.network_creator.clean()
627 except Exception as e:
629 'Unexpected exception cleaning network with message - %s',
632 if self.image_creator and not self.image_creator.image_settings.exists:
634 self.image_creator.clean()
635 except Exception as e:
637 'Unexpected exception cleaning image with message - %s', e)
639 super(self.__class__, self).__clean__()
641 def test_single_port_static(self):
643 Tests the creation of an OpenStack instance with a single port with a
644 static IP without a Floating IP.
647 sub_settings = self.pub_net_config.network_settings.subnet_settings
648 port_settings = PortSettings(
649 name=self.port_1_name,
650 network_name=self.pub_net_config.network_settings.name,
652 {'subnet_name': sub_settings[0].name, 'ip': ip_1}])
654 instance_settings = VmInstanceSettings(
655 name=self.vm_inst_name,
656 flavor=self.flavor_creator.flavor_settings.name,
657 port_settings=[port_settings],
658 floating_ip_settings=[FloatingIpSettings(
659 name=self.floating_ip_name, port_name=self.port_1_name,
660 router_name=self.pub_net_config.router_settings.name)])
662 inst_creator = OpenStackVmInstance(
663 self.os_creds, instance_settings,
664 self.image_creator.image_settings,
665 keypair_settings=self.keypair_creator.keypair_settings)
666 self.inst_creators.append(inst_creator)
667 vm_inst = inst_creator.create()
669 self.assertEqual(ip_1, inst_creator.get_port_ip(self.port_1_name))
670 self.assertTrue(inst_creator.vm_active(block=True))
671 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
673 def test_ssh_client_fip_before_active(self):
675 Tests the ability to access a VM via SSH and a floating IP when it has
676 been assigned prior to being active.
678 port_settings = PortSettings(
679 name=self.port_1_name,
680 network_name=self.pub_net_config.network_settings.name)
682 instance_settings = VmInstanceSettings(
683 name=self.vm_inst_name,
684 flavor=self.flavor_creator.flavor_settings.name,
685 port_settings=[port_settings],
686 floating_ip_settings=[FloatingIpSettings(
687 name=self.floating_ip_name, port_name=self.port_1_name,
688 router_name=self.pub_net_config.router_settings.name)])
690 inst_creator = OpenStackVmInstance(
691 self.os_creds, instance_settings,
692 self.image_creator.image_settings,
693 keypair_settings=self.keypair_creator.keypair_settings)
694 self.inst_creators.append(inst_creator)
695 vm_inst = inst_creator.create()
696 self.assertIsNotNone(vm_inst)
698 self.assertTrue(inst_creator.vm_active(block=True))
700 ip = inst_creator.get_port_ip(port_settings.name)
701 self.assertTrue(check_dhcp_lease(inst_creator, ip))
703 inst_creator.add_security_group(
704 self.sec_grp_creator.get_security_group())
705 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
707 self.assertTrue(validate_ssh_client(inst_creator))
709 def test_ssh_client_fip_after_active(self):
711 Tests the ability to access a VM via SSH and a floating IP when it has
712 been assigned prior to being active.
714 port_settings = PortSettings(
715 name=self.port_1_name,
716 network_name=self.pub_net_config.network_settings.name)
718 instance_settings = VmInstanceSettings(
719 name=self.vm_inst_name,
720 flavor=self.flavor_creator.flavor_settings.name,
721 port_settings=[port_settings],
722 floating_ip_settings=[FloatingIpSettings(
723 name=self.floating_ip_name, port_name=self.port_1_name,
724 router_name=self.pub_net_config.router_settings.name)])
726 inst_creator = OpenStackVmInstance(
727 self.os_creds, instance_settings,
728 self.image_creator.image_settings,
729 keypair_settings=self.keypair_creator.keypair_settings)
730 self.inst_creators.append(inst_creator)
732 # block=True will force the create() method to block until the
733 vm_inst = inst_creator.create(block=True)
734 self.assertIsNotNone(vm_inst)
736 self.assertTrue(inst_creator.vm_active(block=True))
738 ip = inst_creator.get_port_ip(port_settings.name)
739 self.assertTrue(check_dhcp_lease(inst_creator, ip))
741 inst_creator.add_security_group(
742 self.sec_grp_creator.get_security_group())
743 self.assertEqual(vm_inst, inst_creator.get_vm_inst())
745 self.assertTrue(validate_ssh_client(inst_creator))
748 class CreateInstancePortManipulationTests(OSIntegrationTestCase):
750 Test for the CreateInstance class with a single NIC/Port where mac and IP
751 values are manually set
756 Instantiates the CreateImage object that is responsible for downloading
757 and creating an OS image file within OpenStack
759 super(self.__class__, self).__start__()
761 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
762 self.vm_inst_name = guid + '-inst'
763 self.port_1_name = guid + 'port-1'
764 self.port_2_name = guid + 'port-2'
765 self.floating_ip_name = guid + 'fip1'
767 # Initialize for tearDown()
768 self.image_creator = None
769 self.network_creator = None
770 self.flavor_creator = None
771 self.inst_creator = None
773 self.net_config = openstack_tests.get_priv_net_config(
774 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
775 router_name=guid + '-pub-router', external_net=self.ext_net_name)
776 os_image_settings = openstack_tests.cirros_image_settings(
777 name=guid + '-image', image_metadata=self.image_metadata)
781 self.image_creator = OpenStackImage(self.os_creds,
783 self.image_creator.create()
786 self.network_creator = OpenStackNetwork(
787 self.os_creds, self.net_config.network_settings)
788 self.network_creator.create()
791 self.flavor_creator = OpenStackFlavor(
793 FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
794 vcpus=2, metadata=self.flavor_metadata))
795 self.flavor_creator.create()
796 except Exception as e:
802 Cleans the created object
804 if self.inst_creator:
806 self.inst_creator.clean()
807 except Exception as e:
809 'Unexpected exception cleaning VM instance with message '
812 if self.flavor_creator:
814 self.flavor_creator.clean()
815 except Exception as e:
817 'Unexpected exception cleaning flavor with message - %s',
820 if self.network_creator:
822 self.network_creator.clean()
823 except Exception as e:
825 'Unexpected exception cleaning network with message - %s',
828 if self.image_creator and not self.image_creator.image_settings.exists:
830 self.image_creator.clean()
831 except Exception as e:
833 'Unexpected exception cleaning image with message - %s', e)
835 super(self.__class__, self).__clean__()
837 def test_set_custom_valid_ip_one_subnet(self):
839 Tests the creation of an OpenStack instance with a single port with a
840 static IP on a network with one subnet.
843 sub_settings = self.net_config.network_settings.subnet_settings
844 port_settings = PortSettings(
845 name=self.port_1_name,
846 network_name=self.net_config.network_settings.name,
847 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
849 instance_settings = VmInstanceSettings(
850 name=self.vm_inst_name,
851 flavor=self.flavor_creator.flavor_settings.name,
852 port_settings=[port_settings])
854 self.inst_creator = OpenStackVmInstance(
855 self.os_creds, instance_settings,
856 self.image_creator.image_settings)
857 self.inst_creator.create(block=True)
859 self.assertEqual(ip, self.inst_creator.get_port_ip(
861 subnet_name=self.net_config.network_settings.subnet_settings[
864 def test_set_custom_invalid_ip_one_subnet(self):
866 Tests the creation of an OpenStack instance with a single port with a
867 static IP on a network with one subnet.
870 sub_settings = self.net_config.network_settings.subnet_settings
871 port_settings = PortSettings(
872 name=self.port_1_name,
873 network_name=self.net_config.network_settings.name,
874 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
876 instance_settings = VmInstanceSettings(
877 name=self.vm_inst_name,
878 flavor=self.flavor_creator.flavor_settings.name,
879 port_settings=[port_settings])
881 self.inst_creator = OpenStackVmInstance(
882 self.os_creds, instance_settings,
883 self.image_creator.image_settings)
885 with self.assertRaises(Exception):
886 self.inst_creator.create()
888 def test_set_custom_valid_mac(self):
890 Tests the creation of an OpenStack instance with a single port where
891 the MAC address is assigned.
893 mac_addr = '0a:1b:2c:3d:4e:5f'
894 port_settings = PortSettings(
895 name=self.port_1_name,
896 network_name=self.net_config.network_settings.name,
897 mac_address=mac_addr)
899 instance_settings = VmInstanceSettings(
900 name=self.vm_inst_name,
901 flavor=self.flavor_creator.flavor_settings.name,
902 port_settings=[port_settings])
904 self.inst_creator = OpenStackVmInstance(
905 self.os_creds, instance_settings,
906 self.image_creator.image_settings)
907 self.inst_creator.create(block=True)
909 self.assertEqual(mac_addr,
910 self.inst_creator.get_port_mac(self.port_1_name))
912 def test_set_custom_invalid_mac(self):
914 Tests the creation of an OpenStack instance with a single port where an
915 invalid MAC address value is being
916 assigned. This should raise an Exception
918 port_settings = PortSettings(
919 name=self.port_1_name,
920 network_name=self.net_config.network_settings.name,
923 instance_settings = VmInstanceSettings(
924 name=self.vm_inst_name,
925 flavor=self.flavor_creator.flavor_settings.name,
926 port_settings=[port_settings])
928 self.inst_creator = OpenStackVmInstance(
929 self.os_creds, instance_settings,
930 self.image_creator.image_settings)
932 with self.assertRaises(Exception):
933 self.inst_creator.create()
935 def test_set_custom_mac_and_ip(self):
937 Tests the creation of an OpenStack instance with a single port where
938 the IP and MAC address is assigned.
941 mac_addr = '0a:1b:2c:3d:4e:5f'
942 sub_settings = self.net_config.network_settings.subnet_settings
943 port_settings = PortSettings(
944 name=self.port_1_name,
945 network_name=self.net_config.network_settings.name,
946 mac_address=mac_addr,
947 ip_addrs=[{'subnet_name': sub_settings[0].name, 'ip': ip}])
949 instance_settings = VmInstanceSettings(
950 name=self.vm_inst_name,
951 flavor=self.flavor_creator.flavor_settings.name,
952 port_settings=[port_settings])
954 self.inst_creator = OpenStackVmInstance(
955 self.os_creds, instance_settings,
956 self.image_creator.image_settings)
957 self.inst_creator.create(block=True)
959 self.assertEqual(ip, self.inst_creator.get_port_ip(
961 subnet_name=self.net_config.network_settings.subnet_settings[
963 self.assertEqual(mac_addr,
964 self.inst_creator.get_port_mac(self.port_1_name))
966 def test_set_allowed_address_pairs(self):
968 Tests the creation of an OpenStack instance with a single port where
969 max_allowed_address_pair is set.
972 mac_addr = '0a:1b:2c:3d:4e:5f'
973 pair = {'ip_address': ip, 'mac_address': mac_addr}
974 port_settings = PortSettings(
975 name=self.port_1_name,
976 network_name=self.net_config.network_settings.name,
977 allowed_address_pairs=[pair])
979 instance_settings = VmInstanceSettings(
980 name=self.vm_inst_name,
981 flavor=self.flavor_creator.flavor_settings.name,
982 port_settings=[port_settings])
984 self.inst_creator = OpenStackVmInstance(
985 self.os_creds, instance_settings,
986 self.image_creator.image_settings)
987 self.inst_creator.create(block=True)
989 port = self.inst_creator.get_port_by_name(port_settings.name)
990 self.assertIsNotNone(port)
991 self.assertIsNotNone(port.allowed_address_pairs)
992 self.assertEqual(1, len(port.allowed_address_pairs))
993 validation_utils.objects_equivalent(pair,
994 port.allowed_address_pairs[0])
996 def test_set_allowed_address_pairs_bad_mac(self):
998 Tests the creation of an OpenStack instance with a single port where
999 max_allowed_address_pair is set with an invalid MAC address.
1003 pair = {'ip_address': ip, 'mac_address': mac_addr}
1005 pairs.add((ip, mac_addr))
1006 port_settings = PortSettings(
1007 name=self.port_1_name,
1008 network_name=self.net_config.network_settings.name,
1009 allowed_address_pairs=[pair])
1011 instance_settings = VmInstanceSettings(
1012 name=self.vm_inst_name,
1013 flavor=self.flavor_creator.flavor_settings.name,
1014 port_settings=[port_settings])
1016 self.inst_creator = OpenStackVmInstance(
1017 self.os_creds, instance_settings,
1018 self.image_creator.image_settings)
1019 with self.assertRaises(Exception):
1020 self.inst_creator.create()
1022 def test_set_allowed_address_pairs_bad_ip(self):
1024 Tests the creation of an OpenStack instance with a single port where
1025 max_allowed_address_pair is set with an invalid MAC address.
1028 mac_addr = '0a:1b:2c:3d:4e:5f'
1029 pair = {'ip_address': ip, 'mac_address': mac_addr}
1031 pairs.add((ip, mac_addr))
1032 port_settings = PortSettings(
1033 name=self.port_1_name,
1034 network_name=self.net_config.network_settings.name,
1035 allowed_address_pairs=[pair])
1037 instance_settings = VmInstanceSettings(
1038 name=self.vm_inst_name,
1039 flavor=self.flavor_creator.flavor_settings.name,
1040 port_settings=[port_settings])
1042 self.inst_creator = OpenStackVmInstance(
1043 self.os_creds, instance_settings,
1044 self.image_creator.image_settings)
1045 with self.assertRaises(Exception):
1046 self.inst_creator.create()
1049 class CreateInstanceOnComputeHost(OSIntegrationTestCase):
1051 Test for the CreateInstance where one VM is deployed to each compute node
1056 Instantiates the CreateImage object that is responsible for downloading
1057 and creating an OS image file within OpenStack
1059 super(self.__class__, self).__start__()
1061 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1062 self.vm_inst_name = guid + '-inst'
1063 self.port_base_name = guid + 'port'
1065 # Initialize for tearDown()
1066 self.image_creator = None
1067 self.flavor_creator = None
1068 self.network_creator = None
1069 self.inst_creators = list()
1071 self.priv_net_config = openstack_tests.get_priv_net_config(
1072 net_name=guid + '-priv-net', subnet_name=guid + '-priv-subnet')
1074 os_image_settings = openstack_tests.cirros_image_settings(
1075 name=guid + '-image', image_metadata=self.image_metadata)
1079 self.network_creator = OpenStackNetwork(
1080 self.admin_os_creds, self.priv_net_config.network_settings)
1081 self.network_creator.create()
1084 self.flavor_creator = OpenStackFlavor(
1085 self.admin_os_creds,
1086 FlavorSettings(name=guid + '-flavor-name', ram=512, disk=1,
1087 vcpus=1, metadata=self.flavor_metadata))
1088 self.flavor_creator.create()
1091 self.image_creator = OpenStackImage(self.os_creds,
1093 self.image_creator.create()
1095 except Exception as e:
1101 Cleans the created object
1103 for inst_creator in self.inst_creators:
1105 inst_creator.clean()
1106 except Exception as e:
1108 'Unexpected exception cleaning VM instance with message '
1111 if self.flavor_creator:
1113 self.flavor_creator.clean()
1114 except Exception as e:
1116 'Unexpected exception cleaning flavor with message - %s',
1119 if self.network_creator:
1121 self.network_creator.clean()
1122 except Exception as e:
1124 'Unexpected exception cleaning network with message - %s',
1127 if self.image_creator and not self.image_creator.image_settings.exists:
1129 self.image_creator.clean()
1130 except Exception as e:
1132 'Unexpected exception cleaning image with message - %s', e)
1134 super(self.__class__, self).__clean__()
1136 def test_deploy_vm_to_each_compute_node(self):
1138 Tests the creation of OpenStack VM instances to each compute node.
1140 from snaps.openstack.utils import nova_utils
1141 nova = nova_utils.nova_client(self.admin_os_creds)
1142 zone_hosts = nova_utils.get_availability_zone_hosts(nova)
1144 # Create Instance on each server/zone
1146 for zone in zone_hosts:
1147 inst_name = self.vm_inst_name + '-' + zone
1149 port_settings = PortSettings(
1150 name=self.port_base_name + '-' + str(ctr),
1151 network_name=self.priv_net_config.network_settings.name)
1153 instance_settings = VmInstanceSettings(
1155 flavor=self.flavor_creator.flavor_settings.name,
1156 availability_zone=zone,
1157 port_settings=[port_settings])
1158 inst_creator = OpenStackVmInstance(
1159 self.admin_os_creds, instance_settings,
1160 self.image_creator.image_settings)
1161 self.inst_creators.append(inst_creator)
1162 inst_creator.create()
1164 # Validate instances to ensure they've been deployed to the correct
1167 for zone in zone_hosts:
1168 creator = self.inst_creators[index]
1169 self.assertTrue(creator.vm_active(block=True))
1170 info = creator.get_vm_info()
1171 deployed_zone = info['OS-EXT-AZ:availability_zone']
1172 deployed_host = info['OS-EXT-SRV-ATTR:host']
1173 self.assertEqual(zone, deployed_zone + ':' + deployed_host)
1177 class CreateInstancePubPrivNetTests(OSIntegrationTestCase):
1179 Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
1181 These tests require a Centos image
1186 Instantiates the CreateImage object that is responsible for downloading
1187 and creating an OS image file within OpenStack
1189 super(self.__class__, self).__start__()
1191 self.nova = nova_utils.nova_client(self.os_creds)
1193 # Initialize for tearDown()
1194 self.image_creator = None
1195 self.network_creators = list()
1196 self.router_creators = list()
1197 self.flavor_creator = None
1198 self.keypair_creator = None
1199 self.sec_grp_creator = None
1200 self.inst_creator = None
1202 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1203 self.keypair_priv_filepath = 'tmp/' + self.guid
1204 self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
1205 self.keypair_name = self.guid + '-kp'
1206 self.vm_inst_name = self.guid + '-inst'
1207 self.port_1_name = self.guid + '-port-1'
1208 self.port_2_name = self.guid + '-port-2'
1209 self.floating_ip_name = self.guid + 'fip1'
1210 self.priv_net_config = openstack_tests.get_priv_net_config(
1211 net_name=self.guid + '-priv-net',
1212 subnet_name=self.guid + '-priv-subnet',
1213 router_name=self.guid + '-priv-router',
1214 external_net=self.ext_net_name)
1215 self.pub_net_config = openstack_tests.get_pub_net_config(
1216 net_name=self.guid + '-pub-net',
1217 subnet_name=self.guid + '-pub-subnet',
1218 router_name=self.guid + '-pub-router',
1219 external_net=self.ext_net_name)
1221 image_name = self.__class__.__name__ + '-' + str(uuid.uuid4())
1222 os_image_settings = openstack_tests.centos_image_settings(
1223 name=image_name, image_metadata=self.image_metadata)
1227 self.image_creator = OpenStackImage(self.os_creds,
1229 self.image_creator.create()
1231 # First network is public
1232 self.network_creators.append(OpenStackNetwork(
1233 self.os_creds, self.pub_net_config.network_settings))
1234 # Second network is private
1235 self.network_creators.append(OpenStackNetwork(
1236 self.os_creds, self.priv_net_config.network_settings))
1237 for network_creator in self.network_creators:
1238 network_creator.create()
1240 self.router_creators.append(OpenStackRouter(
1241 self.os_creds, self.pub_net_config.router_settings))
1242 self.router_creators.append(OpenStackRouter(
1243 self.os_creds, self.priv_net_config.router_settings))
1246 for router_creator in self.router_creators:
1247 router_creator.create()
1250 self.flavor_creator = OpenStackFlavor(
1251 self.admin_os_creds,
1252 FlavorSettings(name=self.guid + '-flavor-name', ram=512,
1254 metadata=self.flavor_metadata))
1255 self.flavor_creator.create()
1258 self.keypair_creator = OpenStackKeypair(
1259 self.os_creds, KeypairSettings(
1260 name=self.keypair_name,
1261 public_filepath=self.keypair_pub_filepath,
1262 private_filepath=self.keypair_priv_filepath))
1263 self.keypair_creator.create()
1265 sec_grp_name = self.guid + '-sec-grp'
1266 rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1267 direction=Direction.ingress,
1268 protocol=Protocol.icmp)
1269 rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
1270 direction=Direction.ingress,
1271 protocol=Protocol.tcp,
1274 self.sec_grp_creator = OpenStackSecurityGroup(
1276 SecurityGroupSettings(name=sec_grp_name,
1277 rule_settings=[rule1, rule2]))
1278 self.sec_grp_creator.create()
1285 Cleans the created objects
1287 if self.inst_creator:
1289 self.inst_creator.clean()
1290 except Exception as e:
1292 'Unexpected exception cleaning VM instance with message '
1295 if self.keypair_creator:
1297 self.keypair_creator.clean()
1298 except Exception as e:
1300 'Unexpected exception cleaning keypair with message - %s',
1303 if os.path.isfile(self.keypair_pub_filepath):
1304 os.remove(self.keypair_pub_filepath)
1306 if os.path.isfile(self.keypair_priv_filepath):
1307 os.remove(self.keypair_priv_filepath)
1309 if self.flavor_creator:
1311 self.flavor_creator.clean()
1312 except Exception as e:
1314 'Unexpected exception cleaning flavor with message - %s',
1317 for router_creator in self.router_creators:
1319 router_creator.clean()
1320 except Exception as e:
1322 'Unexpected exception cleaning router with message - %s',
1325 for network_creator in self.network_creators:
1327 network_creator.clean()
1328 except Exception as e:
1330 'Unexpected exception cleaning network with message - %s',
1333 if self.sec_grp_creator:
1335 self.sec_grp_creator.clean()
1336 except Exception as e:
1338 'Unexpected exception cleaning security group with message'
1341 if self.image_creator and not self.image_creator.image_settings.exists:
1343 self.image_creator.clean()
1344 except Exception as e:
1346 'Unexpected exception cleaning image with message - %s', e)
1348 super(self.__class__, self).__clean__()
1350 def test_dual_ports_dhcp(self):
1352 Tests the creation of an OpenStack instance with a dual ports/NICs with
1354 NOTE: This test and any others that call ansible will most likely fail
1355 unless you do one of two things:
1356 1. Have a ~/.ansible.cfg (or alternate means) to
1357 set host_key_checking = False
1358 2. Set the following environment variable in your executing shell:
1359 ANSIBLE_HOST_KEY_CHECKING=False
1360 Should this not be performed, the creation of the host ssh key will
1361 cause your ansible calls to fail.
1363 # Create ports/NICs for instance
1366 for network_creator in self.network_creators:
1367 ports_settings.append(PortSettings(
1368 name=self.guid + '-port-' + str(ctr),
1369 network_name=network_creator.network_settings.name))
1373 instance_settings = VmInstanceSettings(
1374 name=self.vm_inst_name,
1375 flavor=self.flavor_creator.flavor_settings.name,
1376 port_settings=ports_settings,
1377 floating_ip_settings=[FloatingIpSettings(
1378 name=self.floating_ip_name, port_name=self.port_1_name,
1379 router_name=self.pub_net_config.router_settings.name)])
1381 self.inst_creator = OpenStackVmInstance(
1382 self.os_creds, instance_settings,
1383 self.image_creator.image_settings,
1384 keypair_settings=self.keypair_creator.keypair_settings)
1386 vm_inst = self.inst_creator.create(block=True)
1388 self.assertEqual(vm_inst, self.inst_creator.get_vm_inst())
1390 # Effectively blocks until VM has been properly activated
1391 self.assertTrue(self.inst_creator.vm_active(block=True))
1393 ip = self.inst_creator.get_port_ip(ports_settings[0].name)
1394 self.assertTrue(check_dhcp_lease(self.inst_creator, ip))
1396 # Add security group to VM
1397 self.inst_creator.add_security_group(
1398 self.sec_grp_creator.get_security_group())
1400 # Effectively blocks until VM's ssh port has been opened
1401 self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
1403 self.assertEqual(0, self.inst_creator.config_nics())
1406 class InstanceSecurityGroupTests(OSIntegrationTestCase):
1408 Tests that include, add, and remove security groups from VM instances
1413 Instantiates the CreateImage object that is responsible for downloading
1414 and creating an OS image file within OpenStack
1416 super(self.__class__, self).__start__()
1418 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1419 self.vm_inst_name = self.guid + '-inst'
1420 self.nova = nova_utils.nova_client(self.os_creds)
1421 os_image_settings = openstack_tests.cirros_image_settings(
1422 name=self.guid + '-image', image_metadata=self.image_metadata)
1424 self.vm_inst_name = self.guid + '-inst'
1425 self.port_1_name = self.guid + 'port-1'
1426 self.port_2_name = self.guid + 'port-2'
1427 self.floating_ip_name = self.guid + 'fip1'
1429 net_config = openstack_tests.get_priv_net_config(
1430 net_name=self.guid + '-pub-net',
1431 subnet_name=self.guid + '-pub-subnet',
1432 router_name=self.guid + '-pub-router',
1433 external_net=self.ext_net_name)
1435 # Initialize for tearDown()
1436 self.image_creator = None
1437 self.flavor_creator = None
1438 self.network_creator = None
1439 self.router_creator = None
1440 self.inst_creator = None
1441 self.sec_grp_creators = list()
1445 self.image_creator = OpenStackImage(self.os_creds,
1447 self.image_creator.create()
1450 self.network_creator = OpenStackNetwork(
1451 self.os_creds, net_config.network_settings)
1452 self.network_creator.create()
1455 self.flavor_creator = OpenStackFlavor(
1456 self.admin_os_creds,
1457 FlavorSettings(name=self.guid + '-flavor-name', ram=128,
1459 metadata=self.flavor_metadata))
1460 self.flavor_creator.create()
1462 self.port_settings = PortSettings(
1463 name=self.guid + '-port',
1464 network_name=net_config.network_settings.name)
1465 except Exception as e:
1471 Cleans the created object
1473 if self.inst_creator:
1475 self.inst_creator.clean()
1476 except Exception as e:
1478 'Unexpected exception cleaning VM instance with message -'
1481 for sec_grp_creator in self.sec_grp_creators:
1483 sec_grp_creator.clean()
1484 except Exception as e:
1486 'Unexpected exception cleaning security group with message'
1489 if self.flavor_creator:
1491 self.flavor_creator.clean()
1492 except Exception as e:
1494 'Unexpected exception cleaning flavor with message - %s',
1497 if self.network_creator:
1499 self.network_creator.clean()
1500 except Exception as e:
1502 'Unexpected exception cleaning network with message - %s',
1505 if self.image_creator and not self.image_creator.image_settings.exists:
1507 self.image_creator.clean()
1508 except Exception as e:
1510 'Unexpected exception cleaning image with message - %s', e)
1512 super(self.__class__, self).__clean__()
1514 def test_add_security_group(self):
1516 Tests the addition of a security group created after the instance.
1519 instance_settings = VmInstanceSettings(
1520 name=self.vm_inst_name,
1521 flavor=self.flavor_creator.flavor_settings.name,
1522 port_settings=[self.port_settings])
1523 self.inst_creator = OpenStackVmInstance(
1524 self.os_creds, instance_settings,
1525 self.image_creator.image_settings)
1526 vm_inst = self.inst_creator.create(block=True)
1527 self.assertIsNotNone(vm_inst)
1529 # Create security group object to add to instance
1530 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1531 description='hello group')
1532 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1534 sec_grp = sec_grp_creator.create()
1535 self.sec_grp_creators.append(sec_grp_creator)
1537 # Check that group has not been added
1538 self.assertFalse(inst_has_sec_grp(
1539 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1541 # Add security group to instance after activated
1542 self.inst_creator.add_security_group(sec_grp)
1544 # Validate that security group has been added
1545 self.assertTrue(inst_has_sec_grp(
1546 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1548 def test_add_invalid_security_group(self):
1550 Tests the addition of a security group that no longer exists.
1553 instance_settings = VmInstanceSettings(
1554 name=self.vm_inst_name,
1555 flavor=self.flavor_creator.flavor_settings.name,
1556 port_settings=[self.port_settings])
1557 self.inst_creator = OpenStackVmInstance(
1558 self.os_creds, instance_settings,
1559 self.image_creator.image_settings)
1560 vm_inst = self.inst_creator.create(block=True)
1561 self.assertIsNotNone(vm_inst)
1563 # Create security group object to add to instance
1564 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1565 description='hello group')
1566 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1568 sec_grp = sec_grp_creator.create()
1569 sec_grp_creator.clean()
1570 self.sec_grp_creators.append(sec_grp_creator)
1572 # Check that group has not been added
1573 self.assertFalse(inst_has_sec_grp(
1574 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1576 # Add security group to instance after activated
1577 self.assertFalse(self.inst_creator.add_security_group(sec_grp))
1579 # Validate that security group has been added
1580 self.assertFalse(inst_has_sec_grp(
1581 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1583 def test_remove_security_group(self):
1585 Tests the removal of a security group created before and added to the
1588 # Create security group object to add to instance
1589 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1590 description='hello group')
1591 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1593 sec_grp = sec_grp_creator.create()
1594 self.sec_grp_creators.append(sec_grp_creator)
1597 instance_settings = VmInstanceSettings(
1598 name=self.vm_inst_name,
1599 flavor=self.flavor_creator.flavor_settings.name,
1600 security_group_names=[sec_grp_settings.name],
1601 port_settings=[self.port_settings])
1602 self.inst_creator = OpenStackVmInstance(
1603 self.os_creds, instance_settings,
1604 self.image_creator.image_settings)
1605 vm_inst = self.inst_creator.create(block=True)
1606 self.assertIsNotNone(vm_inst)
1608 # Check that group has been added
1609 self.assertTrue(inst_has_sec_grp(
1610 self.nova, vm_inst, sec_grp_settings.name))
1612 # Add security group to instance after activated
1613 self.assertTrue(self.inst_creator.remove_security_group(sec_grp))
1615 # Validate that security group has been added
1616 self.assertFalse(inst_has_sec_grp(
1617 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1619 def test_remove_security_group_never_added(self):
1621 Tests the removal of a security group that was never added in the first
1624 # Create security group object to add to instance
1625 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1626 description='hello group')
1627 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1629 sec_grp = sec_grp_creator.create()
1630 self.sec_grp_creators.append(sec_grp_creator)
1633 instance_settings = VmInstanceSettings(
1634 name=self.vm_inst_name,
1635 flavor=self.flavor_creator.flavor_settings.name,
1636 port_settings=[self.port_settings])
1637 self.inst_creator = OpenStackVmInstance(
1638 self.os_creds, instance_settings,
1639 self.image_creator.image_settings)
1640 vm_inst = self.inst_creator.create(block=True)
1641 self.assertIsNotNone(vm_inst)
1643 # Check that group has been added
1644 self.assertFalse(inst_has_sec_grp(
1645 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1647 # Add security group to instance after activated
1648 self.assertFalse(self.inst_creator.remove_security_group(sec_grp))
1650 # Validate that security group has been added
1651 self.assertFalse(inst_has_sec_grp(
1652 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1654 def test_add_same_security_group(self):
1656 Tests the addition of a security group created before add added to the
1659 # Create security group object to add to instance
1660 sec_grp_settings = SecurityGroupSettings(name=self.guid + '-name',
1661 description='hello group')
1662 sec_grp_creator = OpenStackSecurityGroup(self.os_creds,
1664 sec_grp = sec_grp_creator.create()
1665 self.sec_grp_creators.append(sec_grp_creator)
1668 instance_settings = VmInstanceSettings(
1669 name=self.vm_inst_name,
1670 flavor=self.flavor_creator.flavor_settings.name,
1671 security_group_names=[sec_grp_settings.name],
1672 port_settings=[self.port_settings])
1673 self.inst_creator = OpenStackVmInstance(
1674 self.os_creds, instance_settings,
1675 self.image_creator.image_settings)
1676 vm_inst = self.inst_creator.create(block=True)
1677 self.assertIsNotNone(vm_inst)
1679 # Check that group has been added
1680 self.assertTrue(inst_has_sec_grp(
1681 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1683 # Add security group to instance after activated
1684 self.assertTrue(self.inst_creator.add_security_group(sec_grp))
1686 # Validate that security group has been added
1687 self.assertTrue(inst_has_sec_grp(
1688 self.nova, self.inst_creator.get_vm_inst(), sec_grp_settings.name))
1691 def inst_has_sec_grp(nova, vm_inst, sec_grp_name):
1693 Returns true if instance has a security group of a given name
1694 :param nova: the nova client
1695 :param vm_inst: the VmInst domain object
1696 :param sec_grp_name: the name of the security group to validate
1699 sec_grp_names = nova_utils.get_server_security_group_names(nova, vm_inst)
1700 for name in sec_grp_names:
1701 if sec_grp_name == name:
1706 def validate_ssh_client(instance_creator):
1708 Returns True if instance_creator returns an SSH client that is valid
1709 :param instance_creator: the object responsible for creating the VM
1713 ssh_active = instance_creator.vm_ssh_active(block=True)
1716 ssh_client = instance_creator.ssh_client()
1718 out = ssh_client.exec_command('pwd')[1]
1722 channel = out.channel
1723 in_buffer = channel.in_buffer
1724 pwd_out = in_buffer.read(1024)
1725 if not pwd_out or len(pwd_out) < 10:
1732 class CreateInstanceFromThreePartImage(OSIntegrationTestCase):
1734 Test for the CreateInstance class for creating an image from a 3-part image
1739 Instantiates the CreateImage object that is responsible for downloading
1740 and creating an OS image file within OpenStack
1742 super(self.__class__, self).__start__()
1744 guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1745 self.image_name = guid
1746 self.vm_inst_name = guid + '-inst'
1747 self.nova = nova_utils.nova_client(self.os_creds)
1749 net_config = openstack_tests.get_priv_net_config(
1750 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
1751 router_name=guid + '-pub-router', external_net=self.ext_net_name)
1753 # Initialize for tearDown()
1754 self.image_creator = None
1755 self.network_creator = None
1756 self.flavor_creator = None
1757 self.inst_creator = None
1760 if self.image_metadata and 'disk_file' in self.image_metadata:
1761 metadata = self.image_metadata
1762 elif self.image_metadata and 'cirros' in self.image_metadata \
1763 and 'disk_file' in self.image_metadata['cirros']:
1764 metadata = self.image_metadata['cirros']
1767 'disk_url': openstack_tests.CIRROS_DEFAULT_IMAGE_URL,
1769 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL,
1771 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL}
1773 image_settings = openstack_tests.cirros_image_settings(
1774 name=self.image_name,
1775 image_metadata=metadata)
1777 if not image_settings.ramdisk_image_settings or not \
1778 image_settings.kernel_image_settings:
1780 '3 Part image will not be tested. Image metadata has '
1781 'overridden this functionality')
1783 self.image_creator = OpenStackImage(self.os_creds, image_settings)
1784 self.image_creator.create()
1787 self.flavor_creator = OpenStackFlavor(
1788 self.admin_os_creds,
1789 FlavorSettings(name=guid + '-flavor-name', ram=128, disk=10,
1790 vcpus=2, metadata=self.flavor_metadata))
1791 self.flavor_creator.create()
1794 self.network_creator = OpenStackNetwork(
1795 self.os_creds, net_config.network_settings)
1796 self.network_creator.create()
1798 self.port_settings = PortSettings(
1799 name=guid + '-port',
1800 network_name=net_config.network_settings.name)
1801 except Exception as e:
1807 Cleans the created object
1809 if self.inst_creator:
1811 self.inst_creator.clean()
1812 except Exception as e:
1814 'Unexpected exception cleaning VM instance with message -'
1817 if self.flavor_creator:
1819 self.flavor_creator.clean()
1820 except Exception as e:
1822 'Unexpected exception cleaning flavor with message - %s',
1825 if self.network_creator:
1827 self.network_creator.clean()
1828 except Exception as e:
1830 'Unexpected exception cleaning network with message - %s',
1833 if self.image_creator and not self.image_creator.image_settings.exists:
1835 self.image_creator.clean()
1836 except Exception as e:
1838 'Unexpected exception cleaning image with message - %s', e)
1840 super(self.__class__, self).__clean__()
1842 def test_create_instance_from_three_part_image(self):
1844 Tests the creation of an OpenStack instance from a 3-part image.
1846 instance_settings = VmInstanceSettings(
1847 name=self.vm_inst_name,
1848 flavor=self.flavor_creator.flavor_settings.name,
1849 port_settings=[self.port_settings])
1851 # The last created image is the main image from which we create the
1853 self.inst_creator = OpenStackVmInstance(
1854 self.os_creds, instance_settings,
1855 self.image_creator.image_settings)
1857 vm_inst = self.inst_creator.create()
1858 self.assertIsNotNone(vm_inst)
1859 self.assertTrue(self.inst_creator.vm_active(block=True))
1862 class CreateInstanceMockOfflineTests(OSComponentTestCase):
1864 Tests the custom image_metadata that can be set by clients for handling
1865 images differently than the default behavior of the existing tests
1866 primarily for offline testing
1871 Instantiates the CreateImage object that is responsible for downloading
1872 and creating an OS image file within OpenStack
1874 self.guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
1876 self.tmpDir = 'tmp/' + str(self.guid)
1877 if not os.path.exists(self.tmpDir):
1878 os.makedirs(self.tmpDir)
1880 self.image_name = self.guid + '-image'
1881 self.vm_inst_name = self.guid + '-inst'
1882 self.port_1_name = self.guid + 'port-1'
1884 # Initialize for tearDown()
1885 self.image_creator = None
1886 self.network_creator = None
1887 self.flavor_creator = None
1888 self.inst_creator = None
1890 self.priv_net_config = openstack_tests.get_priv_net_config(
1891 net_name=self.guid + '-priv-net',
1892 subnet_name=self.guid + '-priv-subnet')
1893 self.port_settings = PortSettings(
1894 name=self.port_1_name,
1895 network_name=self.priv_net_config.network_settings.name)
1898 # Download image file
1899 self.image_file = file_utils.download(
1900 openstack_tests.CIRROS_DEFAULT_IMAGE_URL, self.tmpDir)
1903 self.network_creator = OpenStackNetwork(
1904 self.os_creds, self.priv_net_config.network_settings)
1905 self.network_creator.create()
1908 self.flavor_creator = OpenStackFlavor(
1911 name=self.guid + '-flavor-name', ram=128, disk=10,
1913 self.flavor_creator.create()
1914 except Exception as e:
1920 Cleans the created object
1922 if self.inst_creator:
1924 self.inst_creator.clean()
1925 except Exception as e:
1927 'Unexpected exception cleaning VM instance with message - '
1930 if self.network_creator:
1932 self.network_creator.clean()
1933 except Exception as e:
1935 'Unexpected exception cleaning network with message - %s',
1938 if self.flavor_creator:
1940 self.flavor_creator.clean()
1941 except Exception as e:
1943 'Unexpected exception cleaning flavor with message - %s',
1946 if self.image_creator:
1948 self.image_creator.clean()
1949 except Exception as e:
1951 'Unexpected exception cleaning image with message - %s', e)
1953 if os.path.exists(self.tmpDir) and os.path.isdir(self.tmpDir):
1954 shutil.rmtree(self.tmpDir)
1956 def test_inst_from_file_image_simple_flat(self):
1958 Creates a VM instance from a locally sourced file image using simply
1959 the 'disk_file' attribute vs. using the 'config' option which
1960 completely overrides all image settings
1963 metadata = {'disk_file': self.image_file.name}
1965 os_image_settings = openstack_tests.cirros_image_settings(
1966 name=self.image_name, image_metadata=metadata)
1967 self.assertEqual(self.image_file.name, os_image_settings.image_file)
1968 self.assertEqual(openstack_tests.CIRROS_USER,
1969 os_image_settings.image_user)
1970 self.assertIsNone(os_image_settings.url)
1971 self.assertFalse(os_image_settings.exists)
1972 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
1973 os_image_settings.format)
1975 self.assertIsNone(os_image_settings.kernel_image_settings)
1976 self.assertIsNone(os_image_settings.ramdisk_image_settings)
1978 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
1979 self.image_creator.create()
1981 instance_settings = VmInstanceSettings(
1982 name=self.vm_inst_name,
1983 flavor=self.flavor_creator.flavor_settings.name,
1984 port_settings=[self.port_settings])
1985 self.inst_creator = OpenStackVmInstance(
1986 self.os_creds, instance_settings,
1987 self.image_creator.image_settings)
1988 self.inst_creator.create()
1990 self.assertTrue(self.inst_creator.vm_active(block=True))
1992 def test_inst_from_file_image_simple_nested(self):
1994 Creates a VM instance from a locally sourced file image using simply
1995 the 'disk_file' attribute under 'cirros' vs. using the 'config' option
1996 which completely overrides all image settings
1999 metadata = {'cirros': {'disk_file': self.image_file.name}}
2001 os_image_settings = openstack_tests.cirros_image_settings(
2002 name=self.image_name, image_metadata=metadata)
2003 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2004 self.assertEqual(openstack_tests.CIRROS_USER,
2005 os_image_settings.image_user)
2006 self.assertIsNone(os_image_settings.url)
2007 self.assertFalse(os_image_settings.exists)
2008 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2009 os_image_settings.format)
2011 self.assertIsNone(os_image_settings.kernel_image_settings)
2012 self.assertIsNone(os_image_settings.ramdisk_image_settings)
2014 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2015 self.image_creator.create()
2017 instance_settings = VmInstanceSettings(
2018 name=self.vm_inst_name,
2019 flavor=self.flavor_creator.flavor_settings.name,
2020 port_settings=[self.port_settings])
2021 self.inst_creator = OpenStackVmInstance(
2022 self.os_creds, instance_settings,
2023 self.image_creator.image_settings)
2024 self.inst_creator.create()
2026 self.assertTrue(self.inst_creator.vm_active(block=True))
2028 def test_inst_from_existing(self):
2030 Creates a VM instance from a image creator that has been configured to
2031 use an existing image
2034 os_image_settings = openstack_tests.cirros_image_settings(
2035 name=self.image_name)
2036 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2037 self.image_creator.create()
2039 image_settings = self.image_creator.image_settings
2040 test_image_creator = OpenStackImage(
2042 ImageSettings(name=image_settings.name,
2043 image_user=image_settings.image_user,
2045 test_image_creator.create()
2046 self.assertEqual(self.image_creator.get_image().id,
2047 test_image_creator.get_image().id)
2049 instance_settings = VmInstanceSettings(
2050 name=self.vm_inst_name,
2051 flavor=self.flavor_creator.flavor_settings.name,
2052 port_settings=[self.port_settings])
2053 self.inst_creator = OpenStackVmInstance(
2054 self.os_creds, instance_settings,
2055 test_image_creator.image_settings)
2056 self.inst_creator.create()
2058 self.assertTrue(self.inst_creator.vm_active(block=True))
2060 def test_inst_from_file_image_complex(self):
2062 Creates a VM instance from a locally sourced file image by overriding
2063 the default settings by using a dict() that can be read in by
2068 os_image_settings = openstack_tests.cirros_image_settings(
2069 name=self.image_name)
2070 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2071 self.image_creator.create()
2076 'name': os_image_settings.name,
2077 'image_user': os_image_settings.image_user,
2079 test_image_settings = openstack_tests.cirros_image_settings(
2080 image_metadata=metadata)
2081 test_image = OpenStackImage(self.os_creds, test_image_settings)
2084 instance_settings = VmInstanceSettings(
2085 name=self.vm_inst_name,
2086 flavor=self.flavor_creator.flavor_settings.name,
2087 port_settings=[self.port_settings])
2088 self.inst_creator = OpenStackVmInstance(self.os_creds,
2090 test_image_settings)
2091 self.inst_creator.create()
2093 self.assertTrue(self.inst_creator.vm_active(block=True))
2095 def test_inst_from_file_3part_image_complex(self):
2097 Creates a VM instance from a locally sourced file image by overriding
2098 the default settings by using a dict() that can be read in by
2103 kernel_file = file_utils.download(
2104 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2105 ramdisk_file = file_utils.download(
2106 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2111 'name': self.image_name,
2112 'image_user': openstack_tests.CIRROS_USER,
2113 'image_file': self.image_file.name,
2114 'format': openstack_tests.DEFAULT_IMAGE_FORMAT,
2115 'kernel_image_settings': {
2116 'name': self.image_name + '-kernel',
2117 'image_user': openstack_tests.CIRROS_USER,
2118 'image_file': kernel_file.name,
2119 'format': openstack_tests.DEFAULT_IMAGE_FORMAT},
2120 'ramdisk_image_settings': {
2121 'name': self.image_name + '-ramdisk',
2122 'image_user': openstack_tests.CIRROS_USER,
2123 'image_file': ramdisk_file.name,
2124 'format': openstack_tests.DEFAULT_IMAGE_FORMAT}}}}
2126 os_image_settings = openstack_tests.cirros_image_settings(
2127 name=self.image_name, image_metadata=metadata)
2128 self.assertEqual(self.image_name, os_image_settings.name)
2129 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2130 self.assertEqual(openstack_tests.CIRROS_USER,
2131 os_image_settings.image_user)
2132 self.assertIsNone(os_image_settings.url)
2133 self.assertFalse(os_image_settings.exists)
2134 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2135 os_image_settings.format)
2137 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2138 self.assertEqual(self.image_name + '-kernel',
2139 os_image_settings.kernel_image_settings.name)
2140 self.assertEqual(kernel_file.name,
2141 os_image_settings.kernel_image_settings.image_file)
2142 self.assertEqual(openstack_tests.CIRROS_USER,
2143 os_image_settings.kernel_image_settings.image_user)
2144 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2145 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2146 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2147 os_image_settings.kernel_image_settings.format)
2149 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2150 self.assertEqual(self.image_name + '-ramdisk',
2151 os_image_settings.ramdisk_image_settings.name)
2152 self.assertEqual(ramdisk_file.name,
2153 os_image_settings.ramdisk_image_settings.image_file)
2154 self.assertEqual(openstack_tests.CIRROS_USER,
2155 os_image_settings.ramdisk_image_settings.image_user)
2156 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2157 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2158 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2159 os_image_settings.ramdisk_image_settings.format)
2161 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2162 self.image_creator.create()
2164 instance_settings = VmInstanceSettings(
2165 name=self.vm_inst_name,
2166 flavor=self.flavor_creator.flavor_settings.name,
2167 port_settings=[self.port_settings])
2168 self.inst_creator = OpenStackVmInstance(
2169 self.os_creds, instance_settings,
2170 self.image_creator.image_settings)
2171 self.inst_creator.create()
2173 self.assertTrue(self.inst_creator.vm_active(block=True))
2175 def test_inst_from_file_3part_image_simple_flat(self):
2177 Creates a VM instance from a 3-part image locally sourced from file
2178 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2179 attributes vs. using the 'config' option which completely overrides all
2183 kernel_file = file_utils.download(
2184 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2185 ramdisk_file = file_utils.download(
2186 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2188 metadata = {'disk_file': self.image_file.name,
2189 'kernel_file': kernel_file.name,
2190 'ramdisk_file': ramdisk_file.name}
2192 os_image_settings = openstack_tests.cirros_image_settings(
2193 name=self.image_name, image_metadata=metadata)
2195 self.assertEqual(self.image_name, os_image_settings.name)
2196 self.assertEqual(self.image_file.name, os_image_settings.image_file)
2197 self.assertEqual(openstack_tests.CIRROS_USER,
2198 os_image_settings.image_user)
2199 self.assertIsNone(os_image_settings.url)
2200 self.assertFalse(os_image_settings.exists)
2201 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2202 os_image_settings.format)
2204 self.assertIsNotNone(os_image_settings.kernel_image_settings)
2205 self.assertEqual(self.image_name + '-kernel',
2206 os_image_settings.kernel_image_settings.name)
2207 self.assertEqual(kernel_file.name,
2208 os_image_settings.kernel_image_settings.image_file)
2209 self.assertEqual(openstack_tests.CIRROS_USER,
2210 os_image_settings.kernel_image_settings.image_user)
2211 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2212 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2213 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2214 os_image_settings.kernel_image_settings.format)
2216 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2217 self.assertEqual(self.image_name + '-ramdisk',
2218 os_image_settings.ramdisk_image_settings.name)
2219 self.assertEqual(ramdisk_file.name,
2220 os_image_settings.ramdisk_image_settings.image_file)
2221 self.assertEqual(openstack_tests.CIRROS_USER,
2222 os_image_settings.ramdisk_image_settings.image_user)
2223 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2224 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2225 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2226 os_image_settings.ramdisk_image_settings.format)
2228 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2229 self.image_creator.create()
2231 self.assertIsNotNone(self.image_creator.get_kernel_image())
2232 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2234 instance_settings = VmInstanceSettings(
2235 name=self.vm_inst_name,
2236 flavor=self.flavor_creator.flavor_settings.name,
2237 port_settings=[self.port_settings])
2238 self.inst_creator = OpenStackVmInstance(
2239 self.os_creds, instance_settings,
2240 self.image_creator.image_settings)
2241 self.inst_creator.create()
2243 self.assertTrue(self.inst_creator.vm_active(block=True))
2245 def test_inst_from_file_3part_image_simple_nested(self):
2247 Creates a VM instance from a 3-part image locally sourced from file
2248 images using simply the 'disk_file', 'kernel_file', and 'ramdisk_file'
2249 attributes under 'cirros' vs. using the 'config' option which
2250 completely overrides all image settings
2253 kernel_file = file_utils.download(
2254 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2255 ramdisk_file = file_utils.download(
2256 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2258 metadata = {'cirros': {'disk_file': self.image_file.name,
2259 'kernel_file': kernel_file.name,
2260 'ramdisk_file': ramdisk_file.name}}
2262 os_image_settings = openstack_tests.cirros_image_settings(
2263 name=self.image_name, image_metadata=metadata)
2265 self.assertEqual(self.image_name, os_image_settings.name)
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.assertIsNotNone(os_image_settings.kernel_image_settings)
2275 self.assertEqual(self.image_name + '-kernel',
2276 os_image_settings.kernel_image_settings.name)
2277 self.assertEqual(kernel_file.name,
2278 os_image_settings.kernel_image_settings.image_file)
2279 self.assertEqual(openstack_tests.CIRROS_USER,
2280 os_image_settings.kernel_image_settings.image_user)
2281 self.assertIsNone(os_image_settings.kernel_image_settings.url)
2282 self.assertFalse(os_image_settings.kernel_image_settings.exists)
2283 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2284 os_image_settings.kernel_image_settings.format)
2286 self.assertIsNotNone(os_image_settings.ramdisk_image_settings)
2287 self.assertEqual(self.image_name + '-ramdisk',
2288 os_image_settings.ramdisk_image_settings.name)
2289 self.assertEqual(ramdisk_file.name,
2290 os_image_settings.ramdisk_image_settings.image_file)
2291 self.assertEqual(openstack_tests.CIRROS_USER,
2292 os_image_settings.ramdisk_image_settings.image_user)
2293 self.assertIsNone(os_image_settings.ramdisk_image_settings.url)
2294 self.assertFalse(os_image_settings.ramdisk_image_settings.exists)
2295 self.assertEqual(openstack_tests.DEFAULT_IMAGE_FORMAT,
2296 os_image_settings.ramdisk_image_settings.format)
2298 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2299 self.image_creator.create()
2301 self.assertIsNotNone(self.image_creator.get_kernel_image())
2302 self.assertIsNotNone(self.image_creator.get_ramdisk_image())
2304 instance_settings = VmInstanceSettings(
2305 name=self.vm_inst_name,
2306 flavor=self.flavor_creator.flavor_settings.name,
2307 port_settings=[self.port_settings])
2308 self.inst_creator = OpenStackVmInstance(
2309 self.os_creds, instance_settings,
2310 self.image_creator.image_settings)
2311 self.inst_creator.create()
2313 self.assertTrue(self.inst_creator.vm_active(block=True))
2315 def test_inst_from_file_3part_image_existing(self):
2317 Creates a VM instance from a 3-part image that is existing
2320 kernel_file = file_utils.download(
2321 openstack_tests.CIRROS_DEFAULT_KERNEL_IMAGE_URL, self.tmpDir)
2322 ramdisk_file = file_utils.download(
2323 openstack_tests.CIRROS_DEFAULT_RAMDISK_IMAGE_URL, self.tmpDir)
2325 metadata = {'cirros': {'disk_file': self.image_file.name,
2326 'kernel_file': kernel_file.name,
2327 'ramdisk_file': ramdisk_file.name}}
2329 os_image_settings = openstack_tests.cirros_image_settings(
2330 name=self.image_name, image_metadata=metadata)
2331 self.image_creator = OpenStackImage(self.os_creds, os_image_settings)
2332 self.image_creator.create()
2334 image_settings = self.image_creator.image_settings
2335 test_image_creator = OpenStackImage(
2337 ImageSettings(name=image_settings.name,
2338 image_user=image_settings.image_user,
2340 test_image_creator.create()
2341 self.assertEqual(self.image_creator.get_image().id,
2342 test_image_creator.get_image().id)
2344 instance_settings = VmInstanceSettings(
2345 name=self.vm_inst_name,
2346 flavor=self.flavor_creator.flavor_settings.name,
2347 port_settings=[self.port_settings])
2348 self.inst_creator = OpenStackVmInstance(
2349 self.os_creds, instance_settings,
2350 test_image_creator.image_settings)
2351 self.inst_creator.create()
2353 self.assertTrue(self.inst_creator.vm_active(block=True))
2356 def check_dhcp_lease(inst_creator, ip, timeout=160):
2358 Returns true if the expected DHCP lease has been acquired
2359 :param inst_creator: the SNAPS OpenStackVmInstance object
2360 :param ip: the IP address to look for
2361 :param timeout: how long to query for IP address
2365 start_time = time.time()
2367 logger.info("Looking for IP %s in the console log" % ip)
2369 while timeout > time.time() - start_time:
2370 output = inst_creator.get_console_output()
2371 full_log = full_log + output
2372 if re.search(ip, output):
2373 logger.info('DHCP lease obtained logged in console')
2378 logger.error('Full console output -\n' + full_log)
2380 logger.debug('Full console output -\n' + full_log)