def pytest_configure(config):
# Lab install params
lab = config.getoption('lab')
use_usb = config.getoption('use_usb')
backup_src_path = config.getoption('backup_path')
backup_build_id = config.getoption('backup_build_id')
backup_src = 'usb' if use_usb else 'local'
skip_setup_feed = config.getoption('skip_setup_feed')
skip_reinstall = config.getoption('skip_reinstall')
low_latency = config.getoption('low_latency')
cinder_backup = config.getoption('cinder_backup')
# build_server = config.getoption('build_server')
backup_builds_dir = config.getoption('backup_builds_dir')
build_server = config.getoption('build_server')
# tis_build_dir = config.getoption('tis_build_dir')
setups.set_install_params(lab=lab, skip='feed' if skip_setup_feed else None, resume=None, installconf_path=None,
drop=None, boot='usb' if use_usb else 'feed', controller0_ceph_mon_device=None,
iso_path=None, controller1_ceph_mon_device=None, ceph_mon_gib=None,
low_latency=low_latency, security='standard',
stop=None, wipedisk=False, ovs=False, patch_dir=None, boot_server=None)
if backup_src == 'usb':
if (not backup_src_path) or (BackupRestore.USB_MOUNT_POINT not in backup_src_path):
backup_src_path = BackupRestore.USB_BACKUP_PATH
elif not backup_src_path:
backup_src_path = BackupRestore.LOCAL_BACKUP_PATH
if not backup_builds_dir:
backup_builds_dir = os.path.basename(BuildServerPath.DEFAULT_HOST_BUILDS_DIR)
RestoreVars.set_restore_vars(backup_src=backup_src, backup_src_path=backup_src_path, build_server=build_server,
backup_build_id=backup_build_id, backup_builds_dir=backup_builds_dir)
reinstall_storage = config.getoption('reinstall_storage')
RestoreVars.set_restore_var(reinstall_storage=reinstall_storage)
RestoreVars.set_restore_var(skip_setup_feed=skip_setup_feed)
RestoreVars.set_restore_var(skip_reinstall=skip_reinstall)
RestoreVars.set_restore_var(low_latency=low_latency)
RestoreVars.set_restore_var(cinder_backup=cinder_backup)
ProjVar.set_var(always_collect=True)
ProjVar.set_var(SOURCE_OPENRC=True)
def pytest_configure(config):
# Lab fresh_install params
lab_arg = config.getoption('lab')
resume_install = config.getoption('resumeinstall')
skiplist = config.getoption('skiplist')
wipedisk = config.getoption('wipedisk')
controller0_ceph_mon_device = config.getoption('ceph_mon_dev_controller_0')
controller1_ceph_mon_device = config.getoption('ceph_mon_dev_controller_1')
ceph_mon_gib = config.getoption('ceph_mon_gib')
install_conf = config.getoption('installconf')
lab_file_dir = config.getoption('file_dir')
build_server = config.getoption('build_server')
boot_server = config.getoption('boot_server')
tis_build_dir = config.getoption('tis_build_dir')
tis_builds_dir = config.getoption('tis_builds_dir')
install_license = config.getoption('upgrade_license')
heat_templates = config.getoption('heat_templates')
guest_image = config.getoption('guest_image_path')
boot_type = config.getoption('boot_list')
iso_path = config.getoption('iso_path')
low_lat = config.getoption('low_latency')
security = config.getoption('security')
controller = config.getoption('controller')
compute = config.getoption('compute')
storage = config.getoption('storage')
stop_step = config.getoption('stop_step')
drop_num = config.getoption('drop_num')
patch_dir = config.getoption('patch_dir')
kubernetes = config.getoption('kubernetes_config')
no_openstack = config.getoption('no_openstack')
deploy_openstack_from_controller_1 = config.getoption(
'deploy_openstack_from_controller_1')
dc_ipv6 = config.getoption('dc_ipv6')
helm_chart_path = config.getoption('helm_chart_path')
no_manage = config.getoption('no_manage')
extract_deploy_config = config.getoption('extract_deploy_config')
vswitch_type = config.getoption('vswitch_type')
ipv6_oam = config.getoption('ipv6_oam')
subcloud_host = config.getoption('subcloud_host')
# Restore parameters
backup_src_path = config.getoption('backup_path')
has_wipe_ceph_osds = config.getoption('has_wipe_ceph_osds')
wipe_ceph_osds = config.getoption('wipe_ceph_osds')
restore_pre_boot_controller0 = config.getoption(
'restore_pre_boot_controller0')
stop_before_ansible_restore = config.getoption(
'stop_before_ansible_restore')
RestoreVars.set_restore_var(backup_src_path=backup_src_path)
RestoreVars.set_restore_var(has_wipe_ceph_osds=has_wipe_ceph_osds)
RestoreVars.set_restore_var(wipe_ceph_osds=wipe_ceph_osds)
RestoreVars.set_restore_var(
restore_pre_boot_controller0=restore_pre_boot_controller0)
RestoreVars.set_restore_var(
stop_before_ansible_restore=stop_before_ansible_restore)
if not lab_arg:
raise ValueError("Lab name must be provided")
vswitch_types = [
VSwitchType.OVS, VSwitchType.OVS_DPDK, VSwitchType.AVS,
VSwitchType.NONE
]
if vswitch_type not in vswitch_types:
raise ValueError(
"Invalid vswitch type {}; Valid types are: {} ".format(
vswitch_type, vswitch_types))
lab_dict = setups.get_lab_dict(lab_arg)
lab_name = lab_dict['name']
if 'yow' in lab_name:
lab_name = lab_name[4:]
if subcloud_host:
is_subcloud = False
sublcoud_name = None
dc_float_ip = None
dc_lab_name = None
else:
is_subcloud, sublcoud_name, dc_float_ip, dc_lab_name = setups.is_lab_subcloud(
lab_dict, ipv6=ipv6_oam)
if is_subcloud and 'yow' in dc_lab_name:
dc_lab_name = dc_lab_name[4:]
if resume_install is True:
resume_install = fresh_install_helper.get_resume_step(lab_dict)
LOG.info("Resume Install step at {}".format(resume_install))
if not install_conf:
build_server = build_server if build_server else BuildServerPath.DEFAULT_BUILD_SERVER
if not tis_builds_dir and not tis_build_dir:
# Take latest master load from cengn
host_build_dir_path = BuildServerPath.DEFAULT_HOST_BUILD_PATH
elif tis_build_dir and os.path.isabs(tis_build_dir):
host_build_dir_path = tis_build_dir
else:
# Take in-house StarlingX_Upstream_build
tis_builds_dir = tis_builds_dir if tis_builds_dir else ''
tis_build_dir = tis_build_dir if tis_build_dir else BuildServerPath.LATEST_BUILD
host_build_dir_path = os.path.join(
BuildServerPath.DEFAULT_WORK_SPACE, tis_builds_dir,
tis_build_dir)
host_build_dir_path = os.path.normpath(host_build_dir_path)
if host_build_dir_path.endswith('/latest_build'):
build_id = build_info.get_latest_host_build_dir(
build_server=build_server,
latest_build_simlink=host_build_dir_path)
host_build_dir_path = host_build_dir_path[:-len('latest_build'
)] + build_id
files_server = build_server
if lab_file_dir:
if lab_file_dir.find(":/") != -1:
files_server = lab_file_dir[:lab_file_dir.find(":/")]
lab_file_dir = lab_file_dir[lab_file_dir.find(":") + 1:]
if not os.path.isabs(lab_file_dir):
lab_file_dir = "{}/lab/yow/{}".format(host_build_dir_path,
lab_file_dir)
else:
lab_file_dir = "{}/lab/yow/{}".format(host_build_dir_path, lab_name if lab_name else '') \
if not is_subcloud else "{}/lab/yow/{}".format(host_build_dir_path, dc_lab_name if dc_lab_name else '')
if not heat_templates:
if BuildServerPath.BldsDirNames.TC_19_05_BUILD in host_build_dir_path:
heat_templates = os.path.join(
BuildServerPath.EAR_HOST_BUILD_PATH,
BuildServerPath.HEAT_TEMPLATES)
else:
heat_templates = os.path.join(
BuildServerPath.STX_HOST_BUILDS_DIR, 'latest_full_build',
BuildServerPath.HEAT_TEMPLATES)
elif not os.path.isabs(heat_templates):
heat_templates = os.path.join(host_build_dir_path, heat_templates)
if not helm_chart_path:
helm_path_in_build = BuildServerPath.STX_HELM_CHARTS_CENGN \
if '/import/' in host_build_dir_path or '19.05' \
in host_build_dir_path else BuildServerPath.TITANIUM_HELM_CHARTS
helm_chart_path = os.path.join(host_build_dir_path,
helm_path_in_build)
if boot_type.lower() in ('usb_burn', 'pxe_iso',
'iso_feed') and not iso_path:
iso_path_in_build = BuildServerPath.ISO_PATH_CENGN \
if '/import/' in host_build_dir_path \
else BuildServerPath.ISO_PATH
iso_path = os.path.join(host_build_dir_path, iso_path_in_build)
install_conf = setups.write_installconf(
lab=lab_arg,
controller=controller,
compute=compute,
storage=storage,
lab_files_dir=lab_file_dir,
patch_dir=patch_dir,
tis_build_dir=host_build_dir_path,
build_server=build_server,
files_server=files_server,
license_path=install_license,
guest_image=guest_image,
heat_templates=heat_templates,
boot=boot_type,
iso_path=iso_path,
security=security,
low_latency=low_lat,
stop=stop_step,
vswitch_type=vswitch_type,
boot_server=boot_server,
resume=resume_install,
skip=skiplist,
kubernetes=kubernetes,
helm_chart_path=helm_chart_path)
setups.set_install_params(
lab=lab_arg,
skip=skiplist,
resume=resume_install,
wipedisk=wipedisk,
drop=drop_num,
installconf_path=install_conf,
controller0_ceph_mon_device=controller0_ceph_mon_device,
controller1_ceph_mon_device=controller1_ceph_mon_device,
ceph_mon_gib=ceph_mon_gib,
boot=boot_type,
iso_path=iso_path,
security=security,
low_latency=low_lat,
stop=stop_step,
patch_dir=patch_dir,
vswitch_type=vswitch_type,
boot_server=boot_server,
dc_float_ip=dc_float_ip,
ipv6_oam=ipv6_oam,
install_subcloud=sublcoud_name,
kubernetes=kubernetes,
no_openstack=no_openstack,
dc_ipv6=dc_ipv6,
helm_chart_path=helm_chart_path,
no_manage=no_manage,
deploy_openstack_from_controller_1=
deploy_openstack_from_controller_1,
extract_deploy_config=extract_deploy_config,
subcloud_host=subcloud_host)
frame_str = '*' * len('Install Arguments:')
args = "\n\n{}\nInstall Arguments:\n{}\n".format(frame_str, frame_str)
install_vars = InstallVars.get_install_vars()
bs = install_vars['BUILD_SERVER']
for var, value in install_vars.items():
if (not value and value != 0) or (value == bs
and var != 'BUILD_SERVER'):
continue
elif var == 'LAB':
for k, v in dict(value).items():
if re.search('_nodes| ip', k):
args += "\n{:<20}: {}".format(k, v)
else:
args += "\n{:<20}: {}".format(var, value)
args += "\n{:<20}: {}\n".format('LOG_DIR', ProjVar.get_var('LOG_DIR'))
LOG.info(args)
if resume_install:
try:
con0_ip = install_vars.get('LAB', {}).get('controller-0 ip')
if con0_ip:
with host_helper.ssh_to_host(con0_ip, timeout=60) as con0_ssh:
setups.set_build_info(con_ssh=con0_ssh)
setups.set_session(con_ssh=con0_ssh)
except:
pass
def pre_restore_checkup():
"""
Fixture to check the system states before doing system restore, including:
- collect logs
- check if backup files exist on the backup media
- check if the build-ids match with each other
- wipe disks
Args:
Return:
backup files:
- the backup files to restore with
"""
lab = InstallVars.get_install_var('LAB')
LOG.info("Lab info; {}".format(lab))
backup_build_id = RestoreVars.get_restore_var("BACKUP_BUILD_ID")
controller_node = lab['controller-0']
backup_src = RestoreVars.get_restore_var('backup_src'.upper())
backup_src_path = RestoreVars.get_restore_var('backup_src_path'.upper())
tis_backup_files = []
extra_controller_prompt = Prompt.TIS_NODE_PROMPT_BASE.format(lab['name'].
split('_')[0]) + '|' + \
Prompt.CONTROLLER_0
controller_conn = install_helper.ssh_to_controller(
controller_node.host_ip,
initial_prompt=extra_controller_prompt,
fail_ok=True)
LOG.info('Collect logs before restore')
if controller_conn:
collect_logs(controller_conn)
ControllerClient.set_active_controller(controller_conn)
else:
LOG.info('Cannot collect logs because no ssh connection to the lab')
if not controller_conn:
LOG.warn(
'failed to collect logs because no ssh connection established to '
'controller-0 of lab:{}'.format(controller_node.host_ip))
else:
pass
LOG.info('backup_src={}, backup_src_path={}'.format(
backup_src, backup_src_path))
if backup_src.lower() == 'usb':
if controller_conn:
LOG.info("Connection established with controller-0 ....")
ControllerClient.set_active_controller(ssh_client=controller_conn)
LOG.info(
"Checking if a USB flash drive with backup files is plugged in... "
)
usb_device_name = install_helper.get_usb_device_name(
con_ssh=controller_conn)
assert usb_device_name, "No USB found "
LOG.info("USB flash drive found, checking for backup files ... ")
usb_part_info = install_helper.get_usb_device_partition_info(
usb_device=usb_device_name, con_ssh=controller_conn)
assert usb_part_info and len(
usb_part_info) > 0, "No USB or partition found"
usb_part_name = "{}2".format(usb_device_name)
assert usb_part_name in usb_part_info.keys(
), "No {} partition exist in USB"
result, mount_point = install_helper.is_usb_mounted(
usb_device=usb_part_name, con_ssh=controller_conn)
if not result:
assert install_helper.mount_usb(usb_device=usb_part_name, con_ssh=controller_conn), \
"Unable to mount USB partition {}".format(usb_part_name)
tis_backup_files = install_helper.get_titanium_backup_filenames_usb(
usb_device=usb_part_name, con_ssh=controller_conn)
assert len(
tis_backup_files) >= 2, "Missing backup files: {}".format(
tis_backup_files)
# extract build id from the file name
file_parts = tis_backup_files[0].split('_')
file_backup_build_id = '_'.join([file_parts[3], file_parts[4]])
assert re.match(TIS_BLD_DIR_REGEX,
file_backup_build_id), " Invalid build id format {} extracted from " \
"backup_file {}".format(
file_backup_build_id, tis_backup_files[0])
if backup_build_id is not None:
if backup_build_id != file_backup_build_id:
LOG.info(
" The build id extracted from backup file is different than "
"specified; Using the extracted build id {} ....".
format(file_backup_build_id))
backup_build_id = file_backup_build_id
else:
backup_build_id = file_backup_build_id
RestoreVars.set_restore_var(backup_build_id=backup_build_id)
else:
LOG.info(" SSH connection not available yet with controller-0; "
"USB will be checked after controller boot ....")
else:
test_server_attr = dict()
test_server_attr['name'] = TestFileServer.get_hostname().split('.')[0]
test_server_attr['server_ip'] = TestFileServer.get_server()
test_server_attr['prompt'] = r'\[{}@{} {}\]\$ ' \
.format(TestFileServer.get_user(), test_server_attr['name'], TestFileServer.get_user())
test_server_conn = install_helper.establish_ssh_connection(
test_server_attr['name'],
user=TestFileServer.get_user(),
password=TestFileServer.get_password(),
initial_prompt=test_server_attr['prompt'])
test_server_conn.set_prompt(test_server_attr['prompt'])
test_server_conn.deploy_ssh_key(install_helper.get_ssh_public_key())
test_server_attr['ssh_conn'] = test_server_conn
test_server_obj = Server(**test_server_attr)
RestoreVars.set_restore_var(backup_src_server=test_server_obj)
# test if backup path for the lab exist in Test server
if os.path.basename(backup_src_path) != lab['short_name']:
backup_src_path += '/{}'.format(lab['short_name'])
RestoreVars.set_restore_var(backup_src_path=backup_src_path)
assert not test_server_conn.exec_cmd("test -e {}".format(backup_src_path))[0], \
"Missing backup files from source {}: {}".format(test_server_attr['name'],
backup_src_path)
tis_backup_files = install_helper.get_backup_files(
TITANIUM_BACKUP_FILE_PATTERN, backup_src_path, test_server_conn)
assert len(tis_backup_files) >= 2, "Missing backup files: {}".format(
tis_backup_files)
# extract build id from the file name
file_parts = tis_backup_files[0].split('_')
file_backup_build_id = '_'.join([file_parts[3], file_parts[4]])
assert re.match(TIS_BLD_DIR_REGEX,
file_backup_build_id), "Invalid build id format {} extracted from " \
"backup_file {}".format(
file_backup_build_id, tis_backup_files[0])
if backup_build_id is not None:
if backup_build_id != file_backup_build_id:
LOG.info(
" The build id extracted from backup file is different than specified; "
"Using the extracted build id {} ....".format(
file_backup_build_id))
backup_build_id = file_backup_build_id
else:
backup_build_id = file_backup_build_id
RestoreVars.set_restore_var(backup_build_id=backup_build_id)
if controller_conn:
# Wipe disks in order to make controller-0 NOT boot from hard-disks
# hosts = [k for k , v in lab.items() if isinstance(v, node.Node)]
# install_helper.wipe_disk_hosts(hosts)
if not RestoreVars.get_restore_var('skip_reinstall'):
LOG.info('Try to do wipedisk_via_helper on controller-0')
install_helper.wipedisk_via_helper(controller_conn)
assert backup_build_id, "The Build id of the system backup must be provided."
return tis_backup_files