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