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