--- /dev/null
+# Copyright 2019 Nokia
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import sys
+import argparse
+import subprocess
+import os
+import importlib
+import time
+
+from yaml import load
+from netaddr import IPNetwork
+from netaddr import IPAddress
+
+import hw_detector.hw_detect_lib as hw_detect
+from hw_detector.hw_exception import HWException
+from remoteinstaller.installer.bmc_management.bmctools import BMCException
+from remoteinstaller.installer.catfile import CatFile
+from remoteinstaller.installer.catfile import CatFileException
+
+class InstallException(Exception):
+ pass
+
+class Installer(object):
+ SSH_OPTS = '-o StrictHostKeyChecking=no \
+ -o UserKnownHostsFile=/dev/null \
+ -o ServerAliveInterval=60'
+
+ def __init__(self, args):
+ self._yaml_path = args.yaml
+ self._boot_iso_path = args.boot_iso
+ self._iso_url = args.iso
+ self._logdir = args.logdir
+ self._callback_url = args.callback_url
+ self._client_key = args.client_key
+ self._client_cert = args.client_cert
+ self._ca_cert = args.ca_cert
+ self._own_ip = args.host_ip
+ self._tag = args.tag
+ self._http_port = args.http_port
+
+ # TODO
+ self._disable_bmc_initial_reset = True
+ self._disable_other_bmc_reset = True
+
+ self._uc = self._read_user_config(self._yaml_path)
+ self._vip = None
+ self._first_controller_ip = None
+ self._first_controller_bmc = None
+
+ @staticmethod
+ def _read_user_config(config_file_path):
+ logging.debug('Read user config from %s', config_file_path)
+
+ try:
+ with open(config_file_path, 'r') as f:
+ y = load(f)
+
+ return y
+ except Exception as ex:
+ raise InstallException(str(ex))
+
+ @staticmethod
+ def _execute_shell(command, desc=''):
+ logging.debug('Execute %s with command: %s', desc, command)
+
+ p = subprocess.Popen(command.split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+ out, _ = p.communicate()
+ if p.returncode:
+ logging.warning('Failed to %s: %s (rc=%s)', desc, out, p.returncode)
+ raise InstallException('Failed to {}'.format(desc))
+
+ return (p.returncode, out)
+
+ def _attach_iso_as_virtual_media(self, file_list):
+ logging.info('Attach ISO as virtual media')
+
+ nfs_mount = os.path.dirname(self._boot_iso_path)
+ boot_iso_filename = os.path.basename(self._boot_iso_path)
+ patched_iso_filename = '{}/{}_{}'.format(nfs_mount, self._tag, boot_iso_filename)
+
+ self._patch_iso(patched_iso_filename, file_list)
+
+ self._first_controller_bmc.attach_virtual_cd(self._own_ip, nfs_mount, os.path.basename(patched_iso_filename))
+
+ def _create_cloud_config(self, first_controller):
+ logging.info('Create network config file')
+
+ domain = self._uc['hosts'][first_controller].get('network_domain')
+ extnet = self._uc['networking']['infra_external']['network_domains'][domain]
+
+ vlan = extnet.get('vlan')
+ first_ip = extnet['ip_range_start']
+ gateway = extnet['gateway']
+ dns = self._uc['networking']['dns'][0]
+ cidr = extnet['cidr']
+ prefix = IPNetwork(cidr).prefixlen
+
+ self._vip = str(IPAddress(first_ip))
+
+ pre_allocated_ips = self._uc['hosts'][first_controller].get('pre_allocated_ips', None)
+ if pre_allocated_ips:
+ pre_allocated_infra_external_ip = pre_allocated_ips.get('infra_external', None)
+ self._first_controller_ip = str(IPAddress(pre_allocated_infra_external_ip))
+
+ if not self._first_controller_ip:
+ self._first_controller_ip = str(IPAddress(first_ip)+1)
+
+ controller_network_profile = self._uc['hosts'][first_controller]['network_profiles'][0]
+ mappings = self._uc['network_profiles'][controller_network_profile]['interface_net_mapping']
+ for interface in mappings:
+ if 'infra_external' in mappings[interface]:
+ infra_external_interface = interface
+ break
+
+ if infra_external_interface.startswith('bond'):
+ bonds = self._uc['network_profiles'][controller_network_profile]['bonding_interfaces']
+ device = bonds[infra_external_interface][0]
+ else:
+ device = infra_external_interface
+
+ # TODO
+ # ROOTFS_DISK
+
+ logging.debug('VLAN=%s', vlan)
+ logging.debug('DEV=%s', device)
+ logging.debug('IP=%s/%s', self._first_controller_ip, prefix)
+ logging.debug('DGW=%s', gateway)
+ logging.debug('NAMESERVER=%s', dns)
+ logging.debug('ISO_URL="%s"', self._iso_url)
+
+ network_config_filename = '{}/network_config'.format(os.getcwd())
+ with open(network_config_filename, 'w') as f:
+ if vlan:
+ f.write('VLAN={}\n'.format(vlan))
+ f.write('DEV={}\n'.format(device))
+ f.write('IP={}/{}\n'.format(self._first_controller_ip, prefix))
+ f.write('DGW={}\n'.format(gateway))
+ f.write('NAMESERVER={}\n'.format(dns))
+ f.write('\n')
+ f.write('ISO_URL="{}"'.format(self._iso_url))
+
+ logging.debug('CALLBACK_URL="%s"', self._callback_url)
+
+ callback_url_filename = '{}/callback_url'.format(os.getcwd())
+ with open(callback_url_filename, 'w') as f:
+ f.write(self._callback_url)
+
+ if self._client_cert:
+ return [self._yaml_path,
+ network_config_filename,
+ callback_url_filename,
+ self._client_key,
+ self._client_cert,
+ self._ca_cert]
+
+ return [self._yaml_path,
+ network_config_filename,
+ callback_url_filename]
+
+ def _patch_iso(self, iso_target, file_list):
+ logging.info('Patch boot ISO')
+ logging.debug('Original ISO: %s', self._boot_iso_path)
+ logging.debug('Target ISO: %s', iso_target)
+
+ file_list_str = ' '.join(file_list)
+ logging.debug('Files to add: %s', file_list_str)
+
+ self._execute_shell('/usr/bin/patchiso.sh {} {} {}'.format(self._boot_iso_path,
+ iso_target,
+ file_list_str), 'patch ISO')
+
+ def _put_file(self, ip, user, passwd, file_name, to_file=''):
+ self._execute_shell('sshpass -p {} scp {} {} {}@{}:{}'.format(passwd,
+ Installer.SSH_OPTS,
+ file_name,
+ user,
+ ip,
+ to_file))
+
+ def _get_file(self, log_dir, ip, user, passwd, file_name, recursive=False):
+ if recursive:
+ self._execute_shell('sshpass -p {} scp {} -r {}@{}:{} {}'.format(passwd,
+ Installer.SSH_OPTS,
+ user,
+ ip,
+ file_name,
+ log_dir))
+ else:
+ self._execute_shell('sshpass -p {} scp {} {}@{}:{} {}'.format(passwd,
+ Installer.SSH_OPTS,
+ user,
+ ip,
+ file_name,
+ log_dir))
+
+ def _get_node_logs(self, log_dir, ip, user, passwd):
+ self._get_file(log_dir, ip, user, passwd, '/srv/deployment/log/cm.log')
+ self._get_file(log_dir, ip, user, passwd, '/srv/deployment/log/bootstrap.log')
+ self._get_file(log_dir, ip, user, passwd, '/var/log/ironic', recursive=True)
+
+ def _get_journal_logs(self, log_dir, ip, user, passwd):
+ self._put_file(ip, user, passwd, '/opt/remoteinstaller/get_journals.sh')
+ self._put_file(ip, user, passwd, '/opt/remoteinstaller/print_hosts.py')
+
+ self._execute_shell('sh ./get_journals.sh')
+
+ self._get_file(log_dir, ip, user, passwd, '/tmp/node_journals.tgz')
+
+ def _get_logs_from_console(self, log_dir, bmc, admin_user, admin_passwd):
+ bmc_host = bmc.get_host()
+ bmc_user = bmc.get_user()
+ bmc_passwd = bmc.get_passwd()
+
+ log_file = '{}/cat_bootstrap.log'.format(log_dir)
+ try:
+ cat_file = CatFile(bmc_host, bmc_user, bmc_passwd, admin_user, admin_passwd)
+ cat_file.cat('/srv/deployment/log/bootstrap.log', log_file)
+ except CatFileException as ex:
+ logging.info('Could not cat file from console: %s', str(ex))
+
+ cat_file = CatFile(bmc_host, bmc_user, bmc_passwd, 'root', 'root')
+ cat_file.cat('/srv/deployment/log/bootstrap.log', log_file)
+
+ def get_logs(self, log_dir, admin_passwd):
+ admin_user = self._uc['users']['admin_user_name']
+
+ ssh_command = 'nc -w1 {} 22 </dev/null &> /dev/null'.format(self._first_controller_ip)
+ ssh_responds = self._execute_shell(ssh_command)
+
+ if ssh_responds:
+ self._get_node_logs(log_dir, self._first_controller_ip, admin_user, admin_passwd)
+
+ self._get_journal_logs(log_dir, self._first_controller_ip, admin_user, admin_passwd)
+ else:
+ self._get_logs_from_console(log_dir,
+ self._first_controller_bmc,
+ admin_user,
+ admin_passwd)
+
+ def install(self):
+ try:
+ logging.info('Start install')
+
+ if os.path.dirname(self._boot_iso_path) == '':
+ self._boot_iso_path = '{}/{}'.format(os.getcwd(), self._boot_iso_path)
+
+ if self._logdir:
+ if not os.path.exists(self._logdir):
+ os.makedirs(self._logdir)
+ else:
+ self._logdir = '.'
+
+ other_bmcs = []
+ first_controller = None
+ for hw in sorted(self._uc['hosts']):
+ logging.info('HW node name is %s', hw)
+
+ if not first_controller:
+ if 'controller' in self._uc['hosts'][hw]['service_profiles'] or \
+ 'caas_master' in self._uc['hosts'][hw]['service_profiles']:
+ first_controller = hw
+ logging.info('HW is first controller')
+
+ host = self._uc['hosts'][hw]['hwmgmt']['address']
+ user = self._uc['hosts'][hw]['hwmgmt']['user']
+ passwd = self._uc['hosts'][hw]['hwmgmt']['password']
+
+ bmc_log_path = '{}/{}.log'.format(self._logdir, hw)
+
+ try:
+ hw_data = hw_detect.get_hw_data(host, user, passwd, False)
+ except HWException as e:
+ error = "Harware not detected for {}: {}".format(hw, str(e))
+ logging.error(error)
+ raise BMCException(error)
+
+ logging.info("Hardware belongs to %s product family", (hw_data['product_family']))
+ if 'Unknown' in hw_data['product_family']:
+ error = "Hardware not detected for %s" % hw
+ logging.error(error)
+ raise BMCException(error)
+
+ bmc_mod_name = 'remoteinstaller.installer.bmc_management.{}'.format(hw_data['product_family'].lower())
+ bmc_mod = importlib.import_module(bmc_mod_name)
+ bmc_class = getattr(bmc_mod, hw_data['product_family'])
+ bmc = bmc_class(host, user, passwd, bmc_log_path)
+ bmc.set_host_name(hw)
+
+ bmc.setup_sol()
+
+ if hw != first_controller:
+ other_bmcs.append(bmc)
+ bmc.power('off')
+ else:
+ self._first_controller_bmc = bmc
+
+ logging.debug('First controller: %s', first_controller)
+
+ if not self._disable_bmc_initial_reset:
+ self._first_controller_bmc.reset()
+ time_after_reset = int(time.time())
+
+ if not self._disable_other_bmc_reset:
+ for bmc in other_bmcs:
+ bmc.reset()
+
+ if not self._disable_bmc_initial_reset:
+ # Make sure we sleep at least 6min after the first controller BMC reset
+ sleep_time = 6*60-int(time.time())-time_after_reset
+ if sleep_time > 0:
+ logging.debug('Waiting for first controller BMC to stabilize \
+ (%s sec) after reset', sleep_time)
+ time.sleep(sleep_time)
+
+ config_file_names = self._create_cloud_config(first_controller)
+
+ self._first_controller_bmc.setup_boot_options_for_virtual_media()
+
+ self._attach_iso_as_virtual_media(config_file_names)
+
+ self._first_controller_bmc.boot_from_virtual_media()
+
+ self._first_controller_bmc.wait_for_bootup()
+
+ self._first_controller_bmc.close()
+
+ access_info = {'vip': self._vip,
+ 'installer_node_ip': self._first_controller_ip,
+ 'admin_user': self._uc['users']['admin_user_name']}
+
+ return access_info
+ except BMCException as ex:
+ logging.error('Installation failed: %s', str(ex))
+ raise InstallException(str(ex))
+
+def main():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('-y', '--yaml', required=True,
+ help='User config yaml file path')
+ parser.add_argument('-b', '--boot-iso', required=True,
+ help='Path to boot ISO image in NFS mount')
+ parser.add_argument('-i', '--iso', required=True,
+ help='URL to ISO image')
+ parser.add_argument('-d', '--debug', action='store_true', required=False,
+ help='Debug level for logging')
+ parser.add_argument('-l', '--logdir', required=False,
+ help='Directory path for log files')
+ parser.add_argument('-c', '--callback-url', required=True,
+ help='Callback URL for progress reporting')
+ parser.add_argument('-K', '--client-key', required=True,
+ help='Client key file path')
+ parser.add_argument('-C', '--client-cert', required=True,
+ help='Client cert file path')
+ parser.add_argument('-A', '--ca-cert', required=True,
+ help='CA cert file path')
+ parser.add_argument('-H', '--host-ip', required=True,
+ help='IP for hosting HTTPD and NFS')
+ parser.add_argument('-T', '--http-port', required=False,
+ help='Port for HTTPD')
+
+ parsed_args = parser.parse_args()
+
+ if parsed_args.debug:
+ log_level = logging.DEBUG
+ else:
+ log_level = logging.INFO
+
+ logging.basicConfig(stream=sys.stdout, level=log_level)
+
+ logging.debug('args: %s', parsed_args)
+ installer = Installer(parsed_args)
+
+ installer.install()
+
+if __name__ == "__main__":
+ sys.exit(main())
Code Review / ta / remote-installer.git / blobdiff