snaps/provisioning/tests/ansible_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
  16 import uuid
  17
  18 import os
  19 import pkg_resources
  20 from scp import SCPClient
  21
  22 from snaps.config.flavor import FlavorConfig
  23 from snaps.openstack import create_flavor
  24 from snaps.openstack import create_image
  25 from snaps.openstack import create_instance
  26 from snaps.openstack import create_keypairs
  27 from snaps.openstack import create_network
  28 from snaps.openstack import create_router
  29 from snaps.openstack.create_security_group import (
  30     SecurityGroupRuleSettings,  Direction, Protocol, OpenStackSecurityGroup,
  31     SecurityGroupSettings)
  32 from snaps.openstack.tests import openstack_tests
  33 from snaps.openstack.tests.create_instance_tests import check_dhcp_lease
  34 from snaps.openstack.tests.os_source_file_test import OSIntegrationTestCase
  35 from snaps.openstack.utils import nova_utils
  36 from snaps.provisioning import ansible_utils
  37
  38 VM_BOOT_TIMEOUT = 600
  39
  40 ip_1 = '10.0.1.100'
  41 ip_2 = '10.0.1.200'
  42
  43
  44 class AnsibleProvisioningTests(OSIntegrationTestCase):
  45     """
  46     Test for the CreateInstance class with two NIC/Ports, eth0 with floating IP
  47     and eth1 w/o
  48     """
  49
  50     def setUp(self):
  51         """
  52         Instantiates the CreateImage object that is responsible for downloading
  53         and creating an OS image file within OpenStack
  54         """
  55         super(self.__class__, self).__start__()
  56
  57         self.nova = nova_utils.nova_client(self.os_creds)
  58
  59         guid = self.__class__.__name__ + '-' + str(uuid.uuid4())
  60         self.keypair_priv_filepath = 'tmp/' + guid
  61         self.keypair_pub_filepath = self.keypair_priv_filepath + '.pub'
  62         self.keypair_name = guid + '-kp'
  63         self.vm_inst_name = guid + '-inst'
  64         self.test_file_local_path = 'tmp/' + guid + '-hello.txt'
  65         self.port_1_name = guid + '-port-1'
  66         self.port_2_name = guid + '-port-2'
  67         self.floating_ip_name = guid + 'fip1'
  68
  69         # Setup members to cleanup just in case they don't get created
  70         self.inst_creator = None
  71         self.keypair_creator = None
  72         self.sec_grp_creator = None
  73         self.flavor_creator = None
  74         self.router_creator = None
  75         self.network_creator = None
  76         self.image_creator = None
  77
  78         try:
  79             # Create Image
  80             os_image_settings = openstack_tests.ubuntu_image_settings(
  81                 name=guid + '-' + '-image',
  82                 image_metadata=self.image_metadata)
  83             self.image_creator = create_image.OpenStackImage(self.os_creds,
  84                                                              os_image_settings)
  85             self.image_creator.create()
  86
  87             # First network is public
  88             self.pub_net_config = openstack_tests.get_pub_net_config(
  89                 net_name=guid + '-pub-net', subnet_name=guid + '-pub-subnet',
  90                 router_name=guid + '-pub-router',
  91                 external_net=self.ext_net_name)
  92
  93             self.network_creator = create_network.OpenStackNetwork(
  94                 self.os_creds, self.pub_net_config.network_settings)
  95             self.network_creator.create()
  96
  97             # Create routers
  98             self.router_creator = create_router.OpenStackRouter(
  99                 self.os_creds, self.pub_net_config.router_settings)
 100             self.router_creator.create()
 101
 102             # Create Flavor
 103             self.flavor_creator = create_flavor.OpenStackFlavor(
 104                 self.admin_os_creds,
 105                 FlavorConfig(
 106                     name=guid + '-flavor-name', ram=2048, disk=10, vcpus=2,
 107                     metadata=self.flavor_metadata))
 108             self.flavor_creator.create()
 109
 110             # Create Key/Pair
 111             self.keypair_creator = create_keypairs.OpenStackKeypair(
 112                 self.os_creds, create_keypairs.KeypairSettings(
 113                     name=self.keypair_name,
 114                     public_filepath=self.keypair_pub_filepath,
 115                     private_filepath=self.keypair_priv_filepath))
 116             self.keypair_creator.create()
 117
 118             # Create Security Group
 119             sec_grp_name = guid + '-sec-grp'
 120             rule1 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
 121                                               direction=Direction.ingress,
 122                                               protocol=Protocol.icmp)
 123             rule2 = SecurityGroupRuleSettings(sec_grp_name=sec_grp_name,
 124                                               direction=Direction.ingress,
 125                                               protocol=Protocol.tcp,
 126                                               port_range_min=22,
 127                                               port_range_max=22)
 128             self.sec_grp_creator = OpenStackSecurityGroup(
 129                 self.os_creds,
 130                 SecurityGroupSettings(name=sec_grp_name,
 131                                       rule_settings=[rule1, rule2]))
 132             self.sec_grp_creator.create()
 133
 134             # Create instance
 135             ports_settings = list()
 136             ports_settings.append(
 137                 create_network.PortSettings(
 138                     name=self.port_1_name,
 139                     network_name=self.pub_net_config.network_settings.name))
 140
 141             instance_settings = create_instance.VmInstanceSettings(
 142                 name=self.vm_inst_name,
 143                 flavor=self.flavor_creator.flavor_settings.name,
 144                 port_settings=ports_settings,
 145                 floating_ip_settings=[create_instance.FloatingIpSettings(
 146                     name=self.floating_ip_name, port_name=self.port_1_name,
 147                     router_name=self.pub_net_config.router_settings.name)])
 148
 149             self.inst_creator = create_instance.OpenStackVmInstance(
 150                 self.os_creds, instance_settings,
 151                 self.image_creator.image_settings,
 152                 keypair_settings=self.keypair_creator.keypair_settings)
 153         except:
 154             self.tearDown()
 155             raise
 156
 157     def tearDown(self):
 158         """
 159         Cleans the created objects
 160         """
 161         if self.inst_creator:
 162             try:
 163                 self.inst_creator.clean()
 164             except:
 165                 pass
 166
 167         if self.sec_grp_creator:
 168             try:
 169                 self.sec_grp_creator.clean()
 170             except:
 171                 pass
 172
 173         if self.keypair_creator:
 174             try:
 175                 self.keypair_creator.clean()
 176             except:
 177                 pass
 178
 179         if self.flavor_creator:
 180             try:
 181                 self.flavor_creator.clean()
 182             except:
 183                 pass
 184
 185         if os.path.isfile(self.keypair_pub_filepath):
 186             try:
 187                 os.remove(self.keypair_pub_filepath)
 188             except:
 189                 pass
 190
 191         if os.path.isfile(self.keypair_priv_filepath):
 192             try:
 193                 os.remove(self.keypair_priv_filepath)
 194             except:
 195                 pass
 196
 197         if self.router_creator:
 198             try:
 199                 self.router_creator.clean()
 200             except:
 201                 pass
 202
 203         if self.network_creator:
 204             try:
 205                 self.network_creator.clean()
 206             except:
 207                 pass
 208
 209         if self.image_creator and not self.image_creator.image_settings.exists:
 210             try:
 211                 self.image_creator.clean()
 212             except:
 213                 pass
 214
 215         if os.path.isfile(self.test_file_local_path):
 216             os.remove(self.test_file_local_path)
 217
 218         super(self.__class__, self).__clean__()
 219
 220     def test_apply_simple_playbook(self):
 221         """
 222         Tests application of an Ansible playbook that simply copies over a file
 223         1. Have a ~/.ansible.cfg (or alternate means) to
 224            set host_key_checking = False
 225         2. Set the following environment variable in your executing shell:
 226            ANSIBLE_HOST_KEY_CHECKING=False
 227         Should this not be performed, the creation of the host ssh key will
 228         cause your ansible calls to fail.
 229         """
 230         self.inst_creator.create(block=True)
 231
 232         priv_ip = self.inst_creator.get_port_ip(self.port_1_name)
 233         self.assertTrue(check_dhcp_lease(self.inst_creator, priv_ip))
 234
 235         # Apply Security Group
 236         self.inst_creator.add_security_group(
 237             self.sec_grp_creator.get_security_group())
 238
 239         # Block until VM's ssh port has been opened
 240         self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
 241
 242         ssh_client = self.inst_creator.ssh_client()
 243         self.assertIsNotNone(ssh_client)
 244
 245         try:
 246             out = ssh_client.exec_command('pwd')[1].channel.in_buffer.read(
 247                 1024)
 248             self.assertIsNotNone(out)
 249             self.assertGreater(len(out), 1)
 250         finally:
 251             ssh_client.close()
 252
 253         # Need to use the first floating IP as subsequent ones are currently
 254         # broken with Apex CO
 255         ip = self.inst_creator.get_floating_ip().ip
 256         user = self.inst_creator.get_image_user()
 257         priv_key = self.inst_creator.keypair_settings.private_filepath
 258
 259         relative_pb_path = pkg_resources.resource_filename(
 260             'snaps.provisioning.tests.playbooks', 'simple_playbook.yml')
 261         retval = self.inst_creator.apply_ansible_playbook(relative_pb_path)
 262         self.assertEqual(0, retval)
 263
 264         ssh = ansible_utils.ssh_client(ip, user, priv_key,
 265                                        self.os_creds.proxy_settings)
 266         self.assertIsNotNone(ssh)
 267         scp = None
 268         try:
 269             scp = SCPClient(ssh.get_transport())
 270             scp.get('~/hello.txt', self.test_file_local_path)
 271         finally:
 272             if scp:
 273                 scp.close()
 274             ssh.close()
 275
 276         self.assertTrue(os.path.isfile(self.test_file_local_path))
 277
 278         test_file = None
 279
 280         try:
 281             with open(self.test_file_local_path) as test_file:
 282                 file_contents = test_file.readline()
 283                 self.assertEqual('Hello World!', file_contents)
 284         finally:
 285             if test_file:
 286                 test_file.close()
 287
 288     def test_apply_template_playbook(self):
 289         """
 290         Tests application of an Ansible playbook that applies a template to a
 291         file:
 292         1. Have a ~/.ansible.cfg (or alternate means) to set
 293            host_key_checking = False
 294         2. Set the following environment variable in your executing shell:
 295            ANSIBLE_HOST_KEY_CHECKING=False
 296         Should this not be performed, the creation of the host ssh key will
 297         cause your ansible calls to fail.
 298         """
 299         self.inst_creator.create(block=True)
 300
 301         priv_ip = self.inst_creator.get_port_ip(self.port_1_name)
 302         self.assertTrue(check_dhcp_lease(self.inst_creator, priv_ip))
 303
 304         # Apply Security Group
 305         self.inst_creator.add_security_group(
 306             self.sec_grp_creator.get_security_group())
 307
 308         # Block until VM's ssh port has been opened
 309         self.assertTrue(self.inst_creator.vm_ssh_active(block=True))
 310
 311         # Apply Security Group
 312         self.inst_creator.add_security_group(
 313             self.sec_grp_creator.get_security_group())
 314
 315         # Need to use the first floating IP as subsequent ones are currently
 316         # broken with Apex CO
 317         ip = self.inst_creator.get_floating_ip().ip
 318         user = self.inst_creator.get_image_user()
 319         priv_key = self.inst_creator.keypair_settings.private_filepath
 320
 321         relative_pb_path = pkg_resources.resource_filename(
 322             'snaps.provisioning.tests.playbooks',
 323             'template_playbook.yml')
 324         retval = self.inst_creator.apply_ansible_playbook(relative_pb_path,
 325                                                           variables={
 326                                                               'name': 'Foo'})
 327         self.assertEqual(0, retval)
 328
 329         ssh = ansible_utils.ssh_client(ip, user, priv_key,
 330                                        self.os_creds.proxy_settings)
 331         self.assertIsNotNone(ssh)
 332         scp = None
 333
 334         try:
 335             scp = SCPClient(ssh.get_transport())
 336             scp.get('/tmp/hello.txt', self.test_file_local_path)
 337         finally:
 338             if scp:
 339                 scp.close()
 340             ssh.close()
 341
 342         self.assertTrue(os.path.isfile(self.test_file_local_path))
 343
 344         test_file = None
 345         try:
 346             with open(self.test_file_local_path) as test_file:
 347                 file_contents = test_file.readline()
 348                 self.assertEqual('Hello Foo!', file_contents)
 349         finally:
 350             if test_file:
 351                 test_file.close()