snaps/openstack/utils/tests/settings_utils_tests.py

   1 # Copyright (c) 2017 Cable Television Laboratories, Inc. ("CableLabs")
   2 #                    and others.  All rights reserved.
   3 #
   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:
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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.
  15 import logging
  16 import os
  17 import uuid
  18
  19 from snaps.openstack import (
  20     create_image, create_network, create_router, create_flavor,
  21     create_keypairs, create_instance)
  22 from snaps.openstack.create_network import (
  23     NetworkSettings, OpenStackNetwork, SubnetSettings)
  24 from snaps.openstack.create_security_group import (
  25     SecurityGroupRuleSettings,  Direction, Protocol, OpenStackSecurityGroup,
  26     SecurityGroupSettings)
  27 from snaps.openstack.tests import openstack_tests
  28 from snaps.openstack.tests.os_source_file_test import OSComponentTestCase
  29 from snaps.openstack.utils import (
  30     neutron_utils, settings_utils, nova_utils, glance_utils)
  31
  32 __author__ = 'spisarski'
  33
  34 logger = logging.getLogger('nova_utils_tests')
  35
  36
  37 class SettingsUtilsNetworkingTests(OSComponentTestCase):
  38     """
  39     Tests the ability to reverse engineer NetworkSettings objects from existing
  40     networks deployed to OpenStack
  41     """
  42
  43     def setUp(self):
  44         """
  45         Instantiates OpenStack instances that cannot be spawned by Heat
  46         """
  47         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
  48         self.network_name = guid + '-net'
  49         self.subnet_name = guid + '-subnet'
  50         self.net_creator = None
  51         self.neutron = neutron_utils.neutron_client(self.os_creds)
  52
  53     def tearDown(self):
  54         """
  55         Cleans the image and downloaded image file
  56         """
  57         if self.net_creator:
  58             try:
  59                 self.net_creator.clean()
  60             except:
  61                 pass
  62
  63     def test_derive_net_settings_no_subnet(self):
  64         """
  65         Validates the utility function settings_utils#create_network_settings
  66         returns an acceptable NetworkSettings object and ensures that the
  67         new settings object will not cause the new OpenStackNetwork instance
  68         to create another network
  69         """
  70         net_settings = NetworkSettings(name=self.network_name)
  71         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
  72         network = self.net_creator.create()
  73
  74         derived_settings = settings_utils.create_network_settings(
  75             self.neutron, network)
  76
  77         self.assertIsNotNone(derived_settings)
  78         self.assertEqual(net_settings.name, derived_settings.name)
  79         self.assertEqual(net_settings.admin_state_up,
  80                          derived_settings.admin_state_up)
  81         self.assertEqual(net_settings.external, derived_settings.external)
  82         self.assertEqual(len(net_settings.subnet_settings),
  83                          len(derived_settings.subnet_settings))
  84
  85         net_creator = OpenStackNetwork(self.os_creds, derived_settings)
  86         derived_network = net_creator.create()
  87
  88         self.assertEqual(network, derived_network)
  89
  90     def test_derive_net_settings_two_subnets(self):
  91         """
  92         Validates the utility function settings_utils#create_network_settings
  93         returns an acceptable NetworkSettings object
  94         """
  95         subnet_settings = list()
  96         subnet_settings.append(SubnetSettings(name='sub1', cidr='10.0.0.0/24'))
  97         subnet_settings.append(SubnetSettings(name='sub2', cidr='10.0.1.0/24'))
  98         net_settings = NetworkSettings(name=self.network_name,
  99                                        subnet_settings=subnet_settings)
 100         self.net_creator = OpenStackNetwork(self.os_creds, net_settings)
 101         network = self.net_creator.create()
 102
 103         derived_settings = settings_utils.create_network_settings(
 104             self.neutron, network)
 105
 106         self.assertIsNotNone(derived_settings)
 107         self.assertEqual(net_settings.name, derived_settings.name)
 108         self.assertEqual(net_settings.admin_state_up,
 109                          derived_settings.admin_state_up)
 110         self.assertEqual(net_settings.external, derived_settings.external)
 111         self.assertEqual(len(net_settings.subnet_settings),
 112                          len(derived_settings.subnet_settings))
 113
 114         # Validate the first subnet
 115         orig_sub1 = net_settings.subnet_settings[0]
 116         found = False
 117         for derived_sub in derived_settings.subnet_settings:
 118             if orig_sub1.name == derived_sub.name:
 119                 self.assertEqual(orig_sub1.cidr, derived_sub.cidr)
 120                 found = True
 121
 122         self.assertTrue(found)
 123
 124         # Validate the second subnet
 125         orig_sub2 = net_settings.subnet_settings[1]
 126         found = False
 127         for derived_sub in derived_settings.subnet_settings:
 128             if orig_sub2.name == derived_sub.name:
 129                 self.assertEqual(orig_sub2.cidr, derived_sub.cidr)
 130                 self.assertEqual(orig_sub2.ip_version, derived_sub.ip_version)
 131                 found = True
 132
 133         self.assertTrue(found)
 134
 135
 136 class SettingsUtilsVmInstTests(OSComponentTestCase):
 137     """
 138     Tests the ability to reverse engineer VmInstanceSettings objects from
 139     existing VMs/servers deployed to OpenStack
 140     """
 141
 142     def setUp(self):
 143         """
 144         Instantiates the CreateImage object that is responsible for downloading
 145         and creating an OS image file within OpenStack
 146         """
 147         # super(self.__class__, self).__start__()
 148
 149         self.nova = nova_utils.nova_client(self.os_creds)
 150         self.glance = glance_utils.glance_client(self.os_creds)
 151         self.neutron = neutron_utils.neutron_client(self.os_creds)
 152
 153         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
 154         self.keypair_priv_filepath = 'tmp/' + guid
 155         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
 156         self.keypair_name = guid + '-kp'
 157         self.vm_inst_name = guid + '-inst'
 158         self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
 159         self.port_1_name = guid + '-port-1'
 160         self.port_2_name = guid + '-port-2'
 161         self.floating_ip_name = guid + 'fip1'
 162
 163         # Setup members to cleanup just in case they don't get created
 164         self.inst_creator = None
 165         self.keypair_creator = None
 166         self.sec_grp_creator = None
 167         self.flavor_creator = None
 168         self.router_creator = None
 169         self.network_creator = None
 170         self.image_creator = None
 171
 172         try:
 173             # Create Image
 174             os_image_settings = openstack_tests.cirros_image_settings(
 175                 name=guid + '-' + '-image',
 176                 image_metadata=self.image_metadata)
 177             self.image_creator = create_image.OpenStackImage(self.os_creds,
 178                                                              os_image_settings)
 179             self.image_creator.create()
 180
 181             # First network is public
 182             self.pub_net_config = openstack_tests.get_pub_net_config(
 183                 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
 184                 router_name=guid + '-pub-router',
 185                 external_net=self.ext_net_name)
 186
 187             self.network_creator = create_network.OpenStackNetwork(
 188                 self.os_creds, self.pub_net_config.network_settings)
 189             self.network_creator.create()
 190
 191             # Create routers
 192             self.router_creator = create_router.OpenStackRouter(
 193                 self.os_creds, self.pub_net_config.router_settings)
 194             self.router_creator.create()
 195
 196             # Create Flavor
 197             self.flavor_creator = create_flavor.OpenStackFlavor(
 198                 self.os_creds,
 199                 create_flavor.FlavorSettings(name=guid + '-flavor-name',
 200                                              ram=256, disk=1, vcpus=1))
 201             self.flavor_creator.create()
 202
 203             # Create Key/Pair
 204             self.keypair_creator = create_keypairs.OpenStackKeypair(
 205                 self.os_creds, create_keypairs.KeypairSettings(
 206                     name=self.keypair_name,
 207                     public_filepath=self.keypair_pub_filepath,
 208                     private_filepath=self.keypair_priv_filepath))
 209             self.keypair_creator.create()
 210
 211             # Create Security Group
 212             sec_grp_name = guid + '-sec-grp'
 213             rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
 214                                               direction=Direction.ingress,
 215                                               protocol=Protocol.icmp)
 216             rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
 217                                               direction=Direction.ingress,
 218                                               protocol=Protocol.tcp,
 219                                               port_range_min=22,
 220                                               port_range_max=22)
 221             self.sec_grp_creator = OpenStackSecurityGroup(
 222                 self.os_creds,
 223                 SecurityGroupSettings(name=sec_grp_name,
 224                                       rule_settings=[rule1, rule2]))
 225             self.sec_grp_creator.create()
 226
 227             # Create instance
 228             ports_settings = list()
 229             ports_settings.append(
 230                 create_network.PortSettings(
 231                     name=self.port_1_name,
 232                     network_name=self.pub_net_config.network_settings.name))
 233
 234             instance_settings = create_instance.VmInstanceSettings(
 235                 name=self.vm_inst_name,
 236                 flavor=self.flavor_creator.flavor_settings.name,
 237                 port_settings=ports_settings,
 238                 floating_ip_settings=[create_instance.FloatingIpSettings(
 239                     name=self.floating_ip_name, port_name=self.port_1_name,
 240                     router_name=self.pub_net_config.router_settings.name)])
 241
 242             self.inst_creator = create_instance.OpenStackVmInstance(
 243                 self.os_creds, instance_settings,
 244                 self.image_creator.image_settings,
 245                 keypair_settings=self.keypair_creator.keypair_settings)
 246         except:
 247             self.tearDown()
 248             raise
 249
 250     def tearDown(self):
 251         """
 252         Cleans the created objects
 253         """
 254         if self.inst_creator:
 255             try:
 256                 self.inst_creator.clean()
 257             except:
 258                 pass
 259
 260         if self.sec_grp_creator:
 261             try:
 262                 self.sec_grp_creator.clean()
 263             except:
 264                 pass
 265
 266         if self.keypair_creator:
 267             try:
 268                 self.keypair_creator.clean()
 269             except:
 270                 pass
 271
 272         if self.flavor_creator:
 273             try:
 274                 self.flavor_creator.clean()
 275             except:
 276                 pass
 277
 278         if os.path.isfile(self.keypair_pub_filepath):
 279             try:
 280                 os.remove(self.keypair_pub_filepath)
 281             except:
 282                 pass
 283
 284         if os.path.isfile(self.keypair_priv_filepath):
 285             try:
 286                 os.remove(self.keypair_priv_filepath)
 287             except:
 288                 pass
 289
 290         if self.router_creator:
 291             try:
 292                 self.router_creator.clean()
 293             except:
 294                 pass
 295
 296         if self.network_creator:
 297             try:
 298                 self.network_creator.clean()
 299             except:
 300                 pass
 301
 302         if self.image_creator and not self.image_creator.image_settings.exists:
 303             try:
 304                 self.image_creator.clean()
 305             except:
 306                 pass
 307
 308         if os.path.isfile(self.test_file_local_path):
 309             os.remove(self.test_file_local_path)
 310
 311         # super(self.__class__, self).__clean__()
 312
 313     def test_derive_vm_inst_settings(self):
 314         """
 315         Validates the utility function settings_utils#create_vm_inst_settings
 316         returns an acceptable VmInstanceSettings object
 317         """
 318         self.inst_creator.create(block=True)
 319
 320         server = nova_utils.get_server(
 321             self.nova, vm_inst_settings=self.inst_creator.instance_settings)
 322         derived_vm_settings = settings_utils.create_vm_inst_settings(
 323             self.nova, self.neutron, server)
 324         self.assertIsNotNone(derived_vm_settings)
 325         self.assertIsNotNone(derived_vm_settings.port_settings)
 326         self.assertIsNotNone(derived_vm_settings.floating_ip_settings)
 327
 328     def test_derive_image_settings(self):
 329         """
 330         Validates the utility function settings_utils#create_image_settings
 331         returns an acceptable ImageSettings object
 332         """
 333         self.inst_creator.create(block=True)
 334
 335         server = nova_utils.get_server(
 336             self.nova, vm_inst_settings=self.inst_creator.instance_settings)
 337         derived_image_settings = settings_utils.determine_image_settings(
 338             self.glance, server, [self.image_creator.image_settings])
 339         self.assertIsNotNone(derived_image_settings)
 340         self.assertEqual(self.image_creator.image_settings.name,
 341                          derived_image_settings.name)