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