apex/undercloud/undercloud.py

   1 ##############################################################################
   2 # Copyright (c) 2017 Tim Rozet (trozet@redhat.com) and others.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9
  10 import libvirt
  11 import logging
  12 import os
  13 import platform
  14 import shutil
  15 import subprocess
  16 import time
  17
  18 from apex.virtual import utils as virt_utils
  19 from apex.virtual import configure_vm as vm_lib
  20 from apex.common import constants
  21 from apex.common import utils
  22
  23
  24 class ApexUndercloudException(Exception):
  25     pass
  26
  27
  28 class Undercloud:
  29     """
  30     This class represents an Apex Undercloud VM
  31     """
  32     def __init__(self, image_path, template_path,
  33                  root_pw=None, external_network=False,
  34                  image_name='undercloud.qcow2',
  35                  os_version=constants.DEFAULT_OS_VERSION):
  36         self.ip = None
  37         self.os_version = os_version
  38         self.root_pw = root_pw
  39         self.external_net = external_network
  40         self.volume = os.path.join(constants.LIBVIRT_VOLUME_PATH,
  41                                    'undercloud.qcow2')
  42         self.image_path = image_path
  43         self.image_name = image_name
  44         self.template_path = template_path
  45         self.vm = None
  46         if Undercloud._get_vm():
  47             logging.error("Undercloud VM already exists.  Please clean "
  48                           "before creating")
  49             raise ApexUndercloudException("Undercloud VM already exists!")
  50         self.create()
  51
  52     @staticmethod
  53     def _get_vm():
  54         conn = libvirt.open('qemu:///system')
  55         try:
  56             vm = conn.lookupByName('undercloud')
  57             return vm
  58         except libvirt.libvirtError:
  59             logging.debug("No undercloud VM exists")
  60
  61     def create(self):
  62         networks = ['admin']
  63         if self.external_net:
  64             networks.append('external')
  65         console = 'ttyAMA0' if platform.machine() == 'aarch64' else 'ttyS0'
  66         root = 'vda' if platform.machine() == 'aarch64' else 'sda'
  67
  68         self.vm = vm_lib.create_vm(name='undercloud',
  69                                    image=self.volume,
  70                                    baremetal_interfaces=networks,
  71                                    direct_boot='overcloud-full',
  72                                    kernel_args=['console={}'.format(console),
  73                                                 'root=/dev/{}'.format(root)],
  74                                    default_network=True,
  75                                    template_dir=self.template_path)
  76         self.setup_volumes()
  77         self.inject_auth()
  78         self._update_delorean_repo()
  79
  80     @staticmethod
  81     def _get_ip(vm):
  82         ip_out = vm.interfaceAddresses(
  83             libvirt.VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_LEASE, 0)
  84         if ip_out:
  85             for (name, val) in ip_out.items():
  86                 for ipaddr in val['addrs']:
  87                     if ipaddr['type'] == libvirt.VIR_IP_ADDR_TYPE_IPV4:
  88                         return ipaddr['addr']
  89
  90     def _set_ip(self):
  91         ip = self._get_ip(self.vm)
  92         if ip:
  93             self.ip = ip
  94             return True
  95
  96     @staticmethod
  97     def get_ip():
  98         vm = Undercloud._get_vm()
  99         return Undercloud._get_ip(vm)
 100
 101     def start(self):
 102         """
 103         Start Undercloud VM
 104         :return: None
 105         """
 106         if self.vm.isActive():
 107             logging.info("Undercloud already started")
 108         else:
 109             logging.info("Starting undercloud")
 110             self.vm.create()
 111             # give 10 seconds to come up
 112             time.sleep(10)
 113         # set IP
 114         for x in range(5):
 115             if self._set_ip():
 116                 logging.info("Undercloud started.  IP Address: {}".format(
 117                     self.ip))
 118                 break
 119             logging.debug("Did not find undercloud IP in {} "
 120                           "attempts...".format(x))
 121             time.sleep(10)
 122         else:
 123             logging.error("Cannot find IP for Undercloud")
 124             raise ApexUndercloudException(
 125                 "Unable to find IP for undercloud.  Check if VM booted "
 126                 "correctly")
 127
 128     def detect_nat(self, net_settings):
 129         if self.external_net:
 130             net = net_settings['networks'][constants.EXTERNAL_NETWORK][0]
 131         else:
 132             net = net_settings['networks'][constants.ADMIN_NETWORK]
 133         if net['gateway'] == net['installer_vm']['ip']:
 134             return True
 135         else:
 136             return False
 137
 138     def configure(self, net_settings, deploy_settings,
 139                   playbook, apex_temp_dir, virtual_oc=False):
 140         """
 141         Configures undercloud VM
 142         :param net_settings: Network settings for deployment
 143         :param deploy_settings: Deployment settings for deployment
 144         :param playbook: playbook to use to configure undercloud
 145         :param apex_temp_dir: temporary apex directory to hold configs/logs
 146         :param virtual_oc: Boolean to determine if overcloud is virt
 147         :return: None
 148         """
 149
 150         logging.info("Configuring Undercloud...")
 151         # run ansible
 152         ansible_vars = Undercloud.generate_config(net_settings,
 153                                                   deploy_settings)
 154         ansible_vars['apex_temp_dir'] = apex_temp_dir
 155
 156         ansible_vars['nat'] = self.detect_nat(net_settings)
 157         try:
 158             utils.run_ansible(ansible_vars, playbook, host=self.ip,
 159                               user='stack')
 160         except subprocess.CalledProcessError:
 161             logging.error(
 162                 "Failed to install undercloud..."
 163                 "please check log: {}".format(os.path.join(
 164                     apex_temp_dir, 'apex-undercloud-install.log')))
 165             raise ApexUndercloudException('Failed to install undercloud')
 166         logging.info("Undercloud installed!")
 167
 168     def setup_volumes(self):
 169         for img_file in ('overcloud-full.vmlinuz', 'overcloud-full.initrd',
 170                          self.image_name):
 171             src_img = os.path.join(self.image_path, img_file)
 172             if img_file == self.image_name:
 173                 dest_img = os.path.join(constants.LIBVIRT_VOLUME_PATH,
 174                                         'undercloud.qcow2')
 175             else:
 176                 dest_img = os.path.join(constants.LIBVIRT_VOLUME_PATH,
 177                                         img_file)
 178             if not os.path.isfile(src_img):
 179                 raise ApexUndercloudException(
 180                     "Required source file does not exist:{}".format(src_img))
 181             if os.path.exists(dest_img):
 182                 os.remove(dest_img)
 183             shutil.copyfile(src_img, dest_img)
 184             shutil.chown(dest_img, user='qemu', group='qemu')
 185             os.chmod(dest_img, 0o0744)
 186         # TODO(trozet):check if resize needed right now size is 50gb
 187         # there is a lib called vminspect which has some dependencies and is
 188         # not yet available in pip.  Consider switching to this lib later.
 189
 190     def inject_auth(self):
 191         virt_ops = list()
 192         # virt-customize keys/pws
 193         if self.root_pw:
 194             pw_op = "password:{}".format(self.root_pw)
 195             virt_ops.append({constants.VIRT_PW: pw_op})
 196         # ssh key setup
 197         virt_ops.append({constants.VIRT_RUN_CMD:
 198                         'mkdir -p /root/.ssh'})
 199         virt_ops.append({constants.VIRT_UPLOAD:
 200                          '/root/.ssh/id_rsa.pub:/root/.ssh/authorized_keys'})
 201         run_cmds = [
 202             'chmod 600 /root/.ssh/authorized_keys',
 203             'restorecon /root/.ssh/authorized_keys',
 204             'cp /root/.ssh/authorized_keys /home/stack/.ssh/',
 205             'chown stack:stack /home/stack/.ssh/authorized_keys',
 206             'chmod 600 /home/stack/.ssh/authorized_keys'
 207         ]
 208         for cmd in run_cmds:
 209             virt_ops.append({constants.VIRT_RUN_CMD: cmd})
 210         virt_utils.virt_customize(virt_ops, self.volume)
 211
 212     @staticmethod
 213     def generate_config(ns, ds):
 214         """
 215         Generates a dictionary of settings for configuring undercloud
 216         :param ns: network settings to derive undercloud settings
 217         :param ds: deploy settings to derive undercloud settings
 218         :return: dictionary of settings
 219         """
 220
 221         ns_admin = ns['networks']['admin']
 222         intro_range = ns['apex']['networks']['admin']['introspection_range']
 223         config = dict()
 224         # Check if this is an ARM deployment
 225         config['aarch64'] = platform.machine() == 'aarch64'
 226         # Configuration for undercloud.conf
 227         config['undercloud_config'] = [
 228             "enable_ui false",
 229             "undercloud_update_packages false",
 230             "undercloud_debug false",
 231             "inspection_extras false",
 232             "ipxe_enabled {}".format(
 233                 str(ds['global_params'].get('ipxe', True) and
 234                     not config['aarch64'])),
 235             "undercloud_hostname undercloud.{}".format(ns['dns-domain']),
 236             "local_ip {}/{}".format(str(ns_admin['installer_vm']['ip']),
 237                                     str(ns_admin['cidr']).split('/')[1]),
 238             "network_gateway {}".format(str(ns_admin['installer_vm']['ip'])),
 239             "network_cidr {}".format(str(ns_admin['cidr'])),
 240             "dhcp_start {}".format(str(ns_admin['dhcp_range'][0])),
 241             "dhcp_end {}".format(str(ns_admin['dhcp_range'][1])),
 242             "inspection_iprange {}".format(','.join(intro_range))
 243         ]
 244
 245         config['ironic_config'] = [
 246             "disk_utils iscsi_verify_attempts 30",
 247             "disk_partitioner check_device_max_retries 40"
 248         ]
 249
 250         config['nova_config'] = [
 251             "dns_domain {}".format(ns['dns-domain']),
 252             "dhcp_domain {}".format(ns['dns-domain'])
 253         ]
 254
 255         config['neutron_config'] = [
 256             "dns_domain {}".format(ns['dns-domain']),
 257         ]
 258         # FIXME(trozet): possible bug here with not using external network
 259         ns_external = ns['networks']['external'][0]
 260         config['external_network'] = {
 261             "vlan": ns_external['installer_vm']['vlan'],
 262             "ip": ns_external['installer_vm']['ip'],
 263             "prefix": str(ns_external['cidr']).split('/')[1],
 264             "enabled": ns_external['enabled']
 265         }
 266         # TODO(trozet): clean this logic up and merge with above
 267         if 'external' in ns.enabled_network_list:
 268             nat_cidr = ns_external['cidr']
 269         else:
 270             nat_cidr = ns['networks']['admin']['cidr']
 271         config['nat_cidr'] = str(nat_cidr)
 272         if nat_cidr.version == 6:
 273             config['nat_network_ipv6'] = True
 274         else:
 275             config['nat_network_ipv6'] = False
 276         config['http_proxy'] = ns.get('http_proxy', '')
 277         config['https_proxy'] = ns.get('https_proxy', '')
 278
 279         return config
 280
 281     def _update_delorean_repo(self):
 282         if utils.internet_connectivity():
 283             logging.info('Updating delorean repo on Undercloud')
 284             delorean_repo = (
 285                 "https://trunk.rdoproject.org/centos7-{}"
 286                 "/current-tripleo/delorean.repo".format(self.os_version))
 287             cmd = ("curl -L -f -o "
 288                    "/etc/yum.repos.d/deloran.repo {}".format(delorean_repo))
 289             try:
 290                 virt_utils.virt_customize([{constants.VIRT_RUN_CMD: cmd}],
 291                                           self.volume)
 292             except Exception:
 293                 logging.warning("Failed to download and update delorean repo "
 294                                 "for Undercloud")