def test_restore_simplex_install(install_setup):
"""
Complete fresh_install steps for a simplex lab
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Boot controller-0
- Run restore controller-0
- Unlock controller-0
"""
lab = install_setup["lab"]
controller0_node = lab["controller-0"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
do_boot_c0 = RestoreVars.get_restore_var('RESTORE_PRE_BOOT_CONTROLLER0')
stop_before_ansible_restore =\
RestoreVars.get_restore_var('STOP_BEFORE_ANSIBLE_RESTORE')
if do_boot_c0:
fresh_install_helper.install_controller(
sys_type=SysType.AIO_SX,
patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn,
init_global_vars=True)
else:
LOG.tc_step("Skipping controller-0 install")
if stop_before_ansible_restore:
skip("Stopping test before restoring")
if InstallVars.get_install_var('IPV6_OAM'):
restore_helper.setup_ipv6_oam(controller0_node)
restore_helper.restore_platform()
fresh_install_helper.unlock_active_controller(controller0_node)
controller0_node.telnet_conn.hostname = r"controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.ssh_to_controller(
controller0_node.host_ip)
install_helper.update_auth_url(ssh_con=controller0_node.ssh_conn)
if lab.get("floating ip"):
setup_tis_ssh(lab)
fresh_install_helper.wait_for_hosts_ready(controller0_node.name, lab=lab)
fresh_install_helper.reset_global_vars()
def setup_test_session(global_setup, request):
"""
Setup primary tenant before the first test gets executed.
TIS ssh was already set up at collecting phase.
"""
ProjVar.set_var(PRIMARY_TENANT='admin')
ProjVar.set_var(SOURCE_OPENRC=True)
setups.setup_primary_tenant('admin')
con_ssh = setups.setup_tis_ssh(InstallVars.get_install_var("LAB"))
ControllerClient.set_active_controller(ssh_client=con_ssh)
# set build id to be used to upload/write test results
setups.set_session(con_ssh=con_ssh)
def set_build_vars():
try:
setups.copy_test_files()
# set build id to be used to upload/write test results
setups.set_build_info(con_ssh)
except:
LOG.warning('Unable to set BUILD info')
pass
set_build_vars()
request.addfinalizer(set_build_vars)
def pytest_collectstart():
"""
Set up the ssh session at collectstart. Because skipif condition is evaluated at the collecting test cases phase.
"""
global con_ssh
con_ssh = setups.setup_tis_ssh(InstallVars.get_install_var("LAB"))
InstallVars.set_install_var(con_ssh=con_ssh)
auth = setups.get_auth_via_openrc(con_ssh)
if auth:
CliAuth.set_vars(**setups.get_auth_via_openrc(con_ssh))
Tenant.set_platform_url(CliAuth.get_var('OS_AUTH_URL'))
Tenant.set_region(CliAuth.get_var('OS_REGION_NAME'))
def pytest_collectstart():
"""
Set up the ssh session at collectstart. Because skipif condition is evaluated at the collecting test cases phase.
"""
global con_ssh
lab = ProjVar.get_var("LAB")
if 'vbox' in lab['short_name']:
con_ssh = setups.setup_vbox_tis_ssh(lab)
else:
con_ssh = setups.setup_tis_ssh(lab)
ProjVar.set_var(con_ssh=con_ssh)
CliAuth.set_vars(**setups.get_auth_via_openrc(con_ssh))
Tenant.set_region(region=CliAuth.get_var('OS_REGION_NAME'))
Tenant.set_platform_url(url='OS_AUTH_URL')
def pytest_collectstart():
"""
Set up the ssh session at collectstart. Because skipif condition is
evaluated at the collecting test cases phase.
"""
global initialized
if not initialized:
global con_ssh
con_ssh = setups.setup_tis_ssh(ProjVar.get_var("LAB"))
ProjVar.set_var(con_ssh=con_ssh)
CliAuth.set_vars(**setups.get_auth_via_openrc(con_ssh))
if setups.is_https(con_ssh):
CliAuth.set_vars(HTTPS=True)
auth_url = CliAuth.get_var('OS_AUTH_URL')
Tenant.set_platform_url(auth_url)
setups.set_region(region=None)
if ProjVar.get_var('IS_DC'):
Tenant.set_platform_url(url=auth_url, central_region=True)
initialized = True
def test_duplex_plus_install(install_setup):
"""
Complete fresh_install steps for a duplex plus (AIO+) lab
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Determine active controller
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Install controller-0
- Download configuration files, heat templates, images, and licenses
- Configure controller-0, run lab_setup, and unlock controller-0
- Add the standby controller
- Run the lab_setup.sh script
- Re-add the standby controller
- Run the lab_setup.sh script
- Install the Standby Controller
- Run the lab_setup.sh script twice
- Unlock the standby controller
- Run the lab_setup.sh script
"""
lab = install_setup["lab"]
hosts = lab["hosts"]
boot_device = lab["boot_device_dict"]
controller0_node = lab["controller-0"]
final_step = install_setup["control"]["stop"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
guest_server = install_setup["servers"]["guest"]
install_subcloud = install_setup.get("install_subcloud")
lab_files_server = install_setup["servers"]["lab_files"]
helm_chart_server = install_setup["servers"]["helm_charts"]
if final_step == '0' or final_step == "setup":
skip("stopping at install step: {}".format(LOG.test_step))
fresh_install_helper.install_controller(
sys_type=SysType.AIO_DX,
patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn,
init_global_vars=True)
# controller0_node.telnet_conn.login()
# controller0_node.telnet_conn.flush()
# fresh_install_helper.set_software_version_var(use_telnet=True, con_telnet=controller0_node.telnet_conn)
build_server = install_setup["servers"]["build"]
fresh_install_helper.download_lab_files(
lab_files_server=lab_files_server,
build_server=build_server,
guest_server=guest_server,
load_path=InstallVars.get_install_var("TIS_BUILD_DIR"),
license_path=InstallVars.get_install_var("LICENSE"),
guest_path=InstallVars.get_install_var('GUEST_IMAGE'),
helm_chart_server=helm_chart_server)
if install_subcloud:
fresh_install_helper.configure_subcloud(controller0_node,
lab_files_server,
subcloud=install_subcloud,
final_step=final_step)
else:
fresh_install_helper.configure_controller_(controller0_node)
deploy_mgr = fresh_install_helper.use_deploy_manager(controller0_node, lab)
if not deploy_mgr:
fresh_install_helper.check_ansible_configured_mgmt_interface(
controller0_node, lab)
#fresh_install_helper.collect_lab_config_yaml(lab, build_server, stage=fresh_install_helper.DEPLOY_INTITIAL)
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
fresh_install_helper.unlock_active_controller(controller0_node)
else:
fresh_install_helper.wait_for_deploy_mgr_controller_config(
controller0_node, lab=lab)
controller0_node.telnet_conn.hostname = r"controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.establish_ssh_connection(
controller0_node.host_ip)
install_helper.update_auth_url(ssh_con=controller0_node.ssh_conn)
if not deploy_mgr:
fresh_install_helper.bulk_add_hosts(lab=lab,
con_ssh=controller0_node.ssh_conn)
else:
fresh_install_helper.wait_for_deployment_mgr_to_bulk_add_hosts(
controller0_node, lab=lab)
fresh_install_helper.boot_hosts(boot_device)
#fresh_install_helper.collect_lab_config_yaml(lab, build_server, stage=fresh_install_helper.DEPLOY_INTERIM)
if not deploy_mgr:
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
fresh_install_helper.unlock_hosts(["controller-1"],
con_ssh=controller0_node.ssh_conn)
else:
fresh_install_helper.wait_for_deploy_mgr_lab_config(controller0_node,
lab=lab)
fresh_install_helper.wait_for_hosts_ready(hosts, lab=lab)
container_helper.wait_for_apps_status(apps='platform-integ-apps',
timeout=1800,
con_ssh=controller0_node.ssh_conn,
status='applied')
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
if lab.get("floating ip"):
collect_sys_net_info(lab)
setup_tis_ssh(lab)
#fresh_install_helper.check_heat_resources(con_ssh=controller0_node.ssh_conn)
if not deploy_mgr:
fresh_install_helper.collect_lab_config_yaml(
lab, build_server, stage=fresh_install_helper.DEPLOY_LAST)
fresh_install_helper.attempt_to_run_post_install_scripts()
fresh_install_helper.reset_global_vars()
fresh_install_helper.verify_install_uuid(lab)
if deploy_mgr:
fresh_install_helper.validate_deployment_mgr_install(
controller0_node, lab)
def test_standard_restore_install(install_setup):
"""
Configure the active controller
Prerequisites:
- pxeboot has been setup.
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Determine active controller
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Install controller-0
- Unlock controller-0
- Boot the other hosts
- Unlock the other hosts
"""
lab = install_setup["lab"]
hosts = lab["hosts"]
boot_device = lab['boot_device_dict']
controller0_node = lab["controller-0"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
# Power off that which is NOT Controller-0
hostnames = [
hostname for hostname in lab['hosts'] if 'controller-0' not in hostname
]
vlm_helper.power_off_hosts(hostnames, lab=lab, count=2)
do_boot_c0 = RestoreVars.get_restore_var('RESTORE_PRE_BOOT_CONTROLLER0')
stop_before_ansible_restore = \
RestoreVars.get_restore_var('STOP_BEFORE_ANSIBLE_RESTORE')
if do_boot_c0:
fresh_install_helper.install_controller(
sys_type=SysType.REGULAR,
patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn,
init_global_vars=True)
else:
LOG.tc_step("Skipping controller-0 install")
if stop_before_ansible_restore:
skip("Stopping test before restoring")
if InstallVars.get_install_var('IPV6_OAM'):
restore_helper.setup_ipv6_oam(controller0_node)
restore_helper.restore_platform()
fresh_install_helper.unlock_active_controller(controller0_node)
controller0_node.telnet_conn.hostname = r"controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.ssh_to_controller(
controller0_node.host_ip)
install_helper.update_auth_url(ssh_con=controller0_node.ssh_conn)
# Boot that which is Not Controller-0
fresh_install_helper.restore_boot_hosts(boot_device)
# Unlock controller-1
fresh_install_helper.unlock_hosts(['controller-1'],
con_ssh=controller0_node.ssh_conn)
# Unlock computes
fresh_install_helper.unlock_hosts(
[host_ for host_ in hosts if 'compute' in host_],
con_ssh=controller0_node.ssh_conn)
fresh_install_helper.send_arp_cmd()
if lab.get("floating ip"):
collect_sys_net_info(lab)
setup_tis_ssh(lab)
fresh_install_helper.reset_global_vars()
fresh_install_helper.verify_install_uuid(lab)
def test_simplex_install(install_setup):
"""
Complete fresh_install steps for a simplex lab
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Install controller-0
- Download configuration files, heat templates, images, and licenses
- Configure controller-0, run lab_setup, and unlock controller-0
- Run lab setup script if specified
- Setup heat resources
"""
lab = install_setup["lab"]
controller0_node = lab["controller-0"]
final_step = install_setup["control"]["stop"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
guest_server = install_setup["servers"]["guest"]
install_subcloud = install_setup.get("install_subcloud")
helm_chart_server = install_setup["servers"]["helm_charts"]
if final_step == '0' or final_step == "setup":
skip("stopping at install step: {}".format(LOG.test_step))
fresh_install_helper.install_controller(sys_type=SysType.AIO_SX, patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn, init_global_vars=True)
# controller0_node.telnet_conn.login()
# controller0_node.telnet_conn.flush()
# fresh_install_helper.set_software_version_var(use_telnet=True, con_telnet=controller0_node.telnet_conn)
lab_files_server = install_setup["servers"]["lab_files"]
build_server = install_setup["servers"]["build"]
fresh_install_helper.download_lab_files(lab_files_server=lab_files_server, build_server=build_server,
guest_server=guest_server,
load_path=InstallVars.get_install_var("TIS_BUILD_DIR"),
license_path=InstallVars.get_install_var("LICENSE"),
guest_path=InstallVars.get_install_var('GUEST_IMAGE'),
helm_chart_server=helm_chart_server)
if install_subcloud:
fresh_install_helper.configure_subcloud(controller0_node, install_setup["dc_system_controller"],
subcloud=install_subcloud, final_step=final_step)
else:
fresh_install_helper.configure_controller_(controller0_node)
deploy_mgr = fresh_install_helper.use_deploy_manager(controller0_node, lab)
if not deploy_mgr:
# fresh_install_helper.collect_lab_config_yaml(lab, build_server, stage=fresh_install_helper.DEPLOY_INTITIAL)
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
fresh_install_helper.unlock_active_controller(controller0_node)
controller0_node.telnet_conn.hostname = r"controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
else:
fresh_install_helper.wait_for_deploy_mgr_controller_config(controller0_node, lab=lab)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.ssh_to_controller(controller0_node.host_ip)
install_helper.update_auth_url(ssh_con=controller0_node.ssh_conn)
container_helper.wait_for_apps_status(apps='platform-integ-apps', timeout=1800,
con_ssh=controller0_node.ssh_conn, status='applied')
fresh_install_helper.run_lab_setup(controller0_node.ssh_conn)
if lab.get("floating ip"):
setup_tis_ssh(lab)
fresh_install_helper.wait_for_hosts_ready(controller0_node.name, lab=lab)
# fresh_install_helper.check_heat_resources(con_ssh=controller0_node.ssh_conn)
if not deploy_mgr:
fresh_install_helper.collect_lab_config_yaml(lab, build_server, stage=fresh_install_helper.DEPLOY_LAST)
if install_subcloud:
fresh_install_helper.wait_for_subcloud_to_be_managed(install_subcloud, install_setup["dc_system_controller"],
lab=lab)
fresh_install_helper.attempt_to_run_post_install_scripts()
fresh_install_helper.reset_global_vars()
def test_distributed_cloud_install(install_setup):
"""
Configure the active controller
Prerequisites:
- pxeboot has been setup.
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Determine active controller
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Install controller-0
- Download configuration files, heat templates, images, and licenses
- Configure controller-0, run lab_setup, and unlock controller-0
- Add the other hosts
- Boot the other hosts
- Run lab setup
- Unlock the other hosts
- Run lab setup
- Setup heat resources and clear any install related alarms
"""
dc_lab = install_setup["lab"]
central_region_lab = dc_lab['central_region']
hosts = dc_lab['central_region']["hosts"]
boot_device = central_region_lab['boot_device_dict']
controller0_node = central_region_lab["controller-0"]
final_step = install_setup["control"]["stop"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
guest_server = install_setup["servers"]["guest"]
if final_step == '0' or final_step == "setup":
pytest.skip("stopping at install step: {}".format(LOG.test_step))
fresh_install_helper.install_controller(
lab=central_region_lab,
sys_type=SysType.DISTRIBUTED_CLOUD,
patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn,
init_global_vars=True)
# controller0_node.telnet_conn.login()
# controller0_node.telnet_conn.flush()
# fresh_install_helper.set_software_version_var(use_telnet=True, con_telnet=controller0_node.telnet_conn)
lab_files_server = install_setup["servers"]["lab_files"]
build_server = install_setup["servers"]["build"]
load_path = InstallVars.get_install_var("TIS_BUILD_DIR")
ipv6_install = InstallVars.get_install_var("DC_IPV6")
fresh_install_helper.download_lab_files(
lab=central_region_lab,
lab_files_server=lab_files_server,
build_server=build_server,
guest_server=guest_server,
load_path=load_path,
license_path=InstallVars.get_install_var("LICENSE"),
guest_path=InstallVars.get_install_var('GUEST_IMAGE'))
# TODO Change config and lab setup files to common name
fresh_install_helper.configure_controller_(controller0_node,
lab=central_region_lab,
banner=False,
branding=False)
fresh_install_helper.wait_for_deploy_mgr_controller_config(
controller0_node, lab=central_region_lab)
controller0_node.telnet_conn.hostname = "controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.ssh_to_controller(
controller0_node.host_ip)
fresh_install_helper.wait_for_deployment_mgr_to_bulk_add_hosts(
controller0_node, lab=central_region_lab)
LOG.info("Booting standby controller host...")
# TODO: get controller-1 hostname
fresh_install_helper.boot_hosts(boot_device,
hostnames=['controller-1'],
lab=central_region_lab,
wait_for_online=False)
host_helper.wait_for_hosts_ready(
[host for host in hosts if controller0_node.name not in host],
con_ssh=controller0_node.ssh_conn)
fresh_install_helper.wait_for_deploy_mgr_lab_config(controller0_node,
lab=central_region_lab)
fresh_install_helper.wait_for_hosts_ready(["controller-1"],
lab=central_region_lab)
container_helper.wait_for_apps_status(apps='platform-integ-apps',
timeout=1800,
con_ssh=controller0_node.ssh_conn,
status='applied')
LOG.info("Running lab setup script ...")
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
if dc_lab.get("floating ip"):
collect_sys_net_info(dc_lab)
setup_tis_ssh(dc_lab)
fresh_install_helper.wait_for_hosts_ready(controller0_node.name,
lab=central_region_lab)
fresh_install_helper.attempt_to_run_post_install_scripts(
controller0_node=controller0_node)
fresh_install_helper.reset_global_vars()
fresh_install_helper.verify_install_uuid(lab=central_region_lab)
fresh_install_helper.validate_deployment_mgr_install(
controller0_node, central_region_lab)
def test_standard_install(install_setup):
"""
Configure the active controller
Prerequisites:
- pxeboot has been setup.
Test Setups:
- Retrieve dictionary containing lab information
- Retrieve required paths to directories, images, and licenses
- Determine active controller
- Initialize build server and boot server objects
- Retrieve what steps to be skipped
Test Steps:
- Install controller-0
- Download configuration files, heat templates, images, and licenses
- Configure controller-0, run lab_setup, and unlock controller-0
- Add the other hosts
- Boot the other hosts
- Run lab setup
- Unlock the other hosts
- Run lab setup
- Setup heat resources and clear any install related alarms
"""
lab = install_setup["lab"]
hosts = lab["hosts"]
boot_device = lab['boot_device_dict']
controller0_node = lab["controller-0"]
final_step = install_setup["control"]["stop"]
patch_dir = install_setup["directories"]["patches"]
patch_server = install_setup["servers"]["patches"]
guest_server = install_setup["servers"]["guest"]
install_subcloud = install_setup.get("install_subcloud")
helm_chart_server = install_setup["servers"]["helm_charts"]
if final_step == '0' or final_step == "setup":
skip("stopping at install step: {}".format(LOG.test_step))
fresh_install_helper.install_controller(sys_type=SysType.REGULAR, patch_dir=patch_dir,
patch_server_conn=patch_server.ssh_conn,
init_global_vars=True)
lab_files_server = install_setup["servers"]["lab_files"]
lab_files_dir = install_setup["directories"]["lab_files"]
build_server = install_setup["servers"]["build"]
fresh_install_helper.download_lab_files(lab_files_server=lab_files_server,
build_server=build_server,
guest_server=guest_server, lab_files_dir=lab_files_dir,
load_path=InstallVars.get_install_var("TIS_BUILD_DIR"),
license_path=InstallVars.get_install_var("LICENSE"),
guest_path=InstallVars.get_install_var('GUEST_IMAGE'),
helm_chart_server=helm_chart_server)
if install_subcloud:
fresh_install_helper.configure_subcloud(controller0_node, install_setup["dc_system_controller"],
subcloud=install_subcloud, final_step=final_step)
deploy_mgr = True
else:
fresh_install_helper.configure_controller_(controller0_node)
deploy_mgr = fresh_install_helper.use_deploy_manager(controller0_node, lab)
if not deploy_mgr:
fresh_install_helper.check_ansible_configured_mgmt_interface(controller0_node, lab)
# fresh_install_helper.collect_lab_config_yaml(lab, build_server,
# stage=fresh_install_helper.DEPLOY_INTITIAL)
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
fresh_install_helper.unlock_active_controller(controller0_node)
controller0_node.telnet_conn.hostname = r"controller\-[01]"
controller0_node.telnet_conn.set_prompt(Prompt.CONTROLLER_PROMPT)
else:
fresh_install_helper.wait_for_deploy_mgr_controller_config(controller0_node, lab=lab)
if controller0_node.ssh_conn is None:
controller0_node.ssh_conn = install_helper.ssh_to_controller(controller0_node.host_ip)
install_helper.update_auth_url(ssh_con=controller0_node.ssh_conn)
if not deploy_mgr:
fresh_install_helper.bulk_add_hosts(lab=lab, con_ssh=controller0_node.ssh_conn)
else:
fresh_install_helper.wait_for_deployment_mgr_to_bulk_add_hosts(controller0_node, lab=lab)
fresh_install_helper.boot_hosts(boot_device)
# fresh_install_helper.collect_lab_config_yaml(lab, build_server,
# stage=fresh_install_helper.DEPLOY_INTERIM)
if not deploy_mgr:
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
# Unlock controller-1
fresh_install_helper.unlock_hosts(['controller-1'], con_ssh=controller0_node.ssh_conn)
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
# Unlock computes
fresh_install_helper.unlock_hosts([host_ for host_ in hosts if 'compute' in host_],
con_ssh=controller0_node.ssh_conn)
fresh_install_helper.send_arp_cmd()
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
else:
fresh_install_helper.wait_for_deploy_mgr_lab_config(controller0_node, lab=lab)
fresh_install_helper.wait_for_hosts_ready(hosts, lab=lab)
fresh_install_helper.run_lab_setup(con_ssh=controller0_node.ssh_conn)
container_helper.wait_for_apps_status(apps='platform-integ-apps', timeout=1200,
con_ssh=controller0_node.ssh_conn, status='applied')
if lab.get("floating ip"):
collect_sys_net_info(lab)
setup_tis_ssh(lab)
# fresh_install_helper.check_heat_resources(con_ssh=controller0_node.ssh_conn)
if not deploy_mgr:
fresh_install_helper.collect_lab_config_yaml(lab, build_server,
stage=fresh_install_helper.DEPLOY_LAST)
if install_subcloud:
fresh_install_helper.wait_for_subcloud_to_be_managed(install_subcloud, install_setup["dc_system_controller"],
lab=lab)
fresh_install_helper.attempt_to_run_post_install_scripts()
fresh_install_helper.reset_global_vars()
fresh_install_helper.verify_install_uuid(lab)
if deploy_mgr:
fresh_install_helper.validate_deployment_mgr_install(controller0_node, lab)
