def __get_latest_build_dir(build_server, build_dir):
with host_helper.ssh_to_build_server(bld_srv=build_server) as bld_srv_ssh:
output = bld_srv_ssh.exec_cmd('ls -l {} | grep --color="never" "latest_build"'.format(build_dir))[1]
build_dir_ = output.split('->')[-1].strip().split(sep=r'/')[-1]
print("Latest build dir: {}".format(build_dir_))
return build_dir_
def set_test_patch_info():
build_path = ProjVar.get_var('BUILD_PATH')
build_server = system_helper.get_build_info()['BUILD_SERVER']
if not build_path or not build_server:
skip('Build path or server not found from /etc/build.info')
with host_helper.ssh_to_build_server(bld_srv=build_server) as bs_ssh:
patch_dir = common.get_symlink(
bs_ssh, file_path='{}/test_patches'.format(build_path))
if not patch_dir:
skip("Test patches are not available for {}:{}".format(
build_server, build_path))
PatchingVars.set_patching_var(patch_dir=patch_dir)
return build_server, patch_dir
def get_latest_green_build(build_server=DEFAULT_BUILD_SERVER, builds_dir=None):
"""
Get the build id of latest green build
Args:
build_server (str): yow-cgts4-lx, etc
builds_dir (str|None): e.g, /localdisk/loadbuild/jenkins/CGCS_4.0_Centos_Build. Only used if build_path is None
Returns (str): such as '2017-07-18_22-01-27'
"""
if not builds_dir:
builds_dir = BuildServerPath.DEFAULT_HOST_BUILDS_DIR
green_path = '{}/latest_green_build'.format(builds_dir)
with host_helper.ssh_to_build_server(bld_srv=build_server) as bld_srv_ssh:
output = bld_srv_ssh.exec_cmd('ls -l {} | cat'.format(green_path), fail_ok=False)[1]
build_id = output.split(sep='->')[-1].split(sep='/')[-1].strip()
print("Latest Green Build is: {}. \nFull output: {}".format(build_id, output))
return build_id
def __wait_for_new_load(build_server, build_dir, trigger_window, timeout):
trigger_window = float(trigger_window)
timeout = float(timeout)
minutes = int(trigger_window * 60)
hours, minutes = divmod(minutes, 60)
with host_helper.ssh_to_build_server(bld_srv=build_server) as bld_srv_ssh:
window_time = datetime.timedelta(hours=hours, minutes=minutes)
end_time = time.time() + int(timeout * 3600)
while time.time() < end_time:
latest_bld_time = get_modify_time(bld_srv_ssh, build_dir)
current_time = get_current_time(ssh_client=bld_srv_ssh)
if current_time < latest_bld_time + window_time:
print("New build available from {}:{}".format(build_server, build_dir))
return True
time.sleep(60)
else:
print("No new build (modified within {} hours) available from {}:{} after {} hours polling".format(
trigger_window, build_server, build_dir, timeout))
return False
def mark_status_on_build_server(status,
build_server,
build_id=None,
builds_dir=None,
build_path=None):
"""
This is for marking the load RED/YELLOW/GREEN.
e.g., touch /localdisk/loadbuild/jenkins/CGCS_4.0_Centos_Build/2017-05-08_22-01-14/GREEN
Args:
status (str): GREEN, YELLOW or RED
build_server (str): yow-cgts4-lx, etc
build_id (str|None): e.g., 2017-05-08_22-01-14. Only used if build_path is None
builds_dir (str|None): e.g, /localdisk/loadbuild/jenkins/CGCS_4.0_Centos_Build. Only used if build_path is None
build_path (str|None): e.g., /localdisk/loadbuild/jenkins/CGCS_4.0_Centos_Build/2017-05-08_22-01-14/
"""
if status not in ['RED', 'YELLOW', 'GREEN']:
raise ValueError("Invalid status {}".format(status))
if build_path:
build_paths = [build_path]
else:
if not build_id:
raise ValueError("Either build_id or build_dir has to be provided")
if builds_dir:
builds_dirs = [builds_dir]
else:
builds_dirs = (BuildServerPath.TITANIUM_HOST_BUILDS_DIR,
BuildServerPath.STX_HOST_BUILDS_DIR,
BuildServerPath.STX_RELEASE_DIR)
build_paths = ['{}/{}'.format(dir_, build_id) for dir_ in builds_dirs]
with host_helper.ssh_to_build_server(bld_srv=build_server) as bld_srv_ssh:
for build_path in build_paths:
build_path = os.path.normpath(build_path)
if not bld_srv_ssh.file_exists(file_path=build_path):
print("Build path {} does not exist".format(build_path))
continue
if status == 'GREEN':
green_path = '{}/latest_green_build'.format(
os.path.dirname(build_path))
bld_srv_ssh.exec_cmd('rm -f {}'.format(green_path))
bld_srv_ssh.exec_cmd('ln -s {} {}'.format(
build_path, green_path),
fail_ok=False)
print(
"latest_green_build symlink is successfully updated to {}:{}"
.format(build_server, build_path))
status_file = '{}/{}'.format(build_path, status)
bld_srv_ssh.exec_cmd('touch {}'.format(status_file), fail_ok=False)
if not bld_srv_ssh.file_exists(file_path=status_file):
raise FileNotFoundError(
"Touched file {} does not exist!".format(status_file))
print("{} is successfully touched on {}".format(
status_file, build_server))
break
else:
raise ValueError('Build path not found on {}: {}'.format(
build_server, build_paths))
def backup_load_iso_image(backup_info):
"""
Save a copy of the bootimage.iso for later restore.
Args:
backup_info
Returns:
True - the ISO is successfully copied to backup server
- False otherwise
"""
backup_dest = backup_info['backup_dest']
backup_dest_path = backup_info['backup_dest_full_path']
load_path = ProjVar.get_var('BUILD_PATH')
build_info = system_helper.get_build_info()
build_id = build_info['BUILD_ID']
assert re.match(TIS_BLD_DIR_REGEX, build_id), "Invalid Build Id pattern"
build_server = build_info['BUILD_SERVER']
if not build_server:
build_server = BuildServerPath.DEFAULT_BUILD_SERVER # default
with host_helper.ssh_to_build_server(
bld_srv=build_server) as build_server_conn:
cmd = "test -e " + load_path
assert build_server_conn.exec_cmd(cmd, rm_date=False)[0] == 0, 'The system build {} not found in {}:{}'.\
format(build_id, build_server, load_path)
iso_file_path = os.path.join(load_path, "export",
install_helper.UPGRADE_LOAD_ISO_FILE)
if not build_server_conn.exec_cmd("test -e " + iso_file_path):
LOG.warn("No ISO found on path:{}".format(iso_file_path))
return True
pre_opts = 'sshpass -p "{0}"'.format(HostLinuxUser.get_password())
# build_server_conn.rsync("-L " + iso_file_path, lab['controller-0 ip'],
build_server_conn.rsync("-L " + iso_file_path,
html_helper.get_ip_addr(),
os.path.join(HostLinuxUser.get_home(),
"bootimage.iso"),
pre_opts=pre_opts,
timeout=360)
if backup_dest == 'usb':
usb_part1 = None
usb_partition_info = install_helper.get_usb_device_partition_info()
for k, v in usb_partition_info.items():
if k[-1:] == "1":
usb_part1 = k
if not usb_part1:
LOG.info(
"No partition exist for burning load iso image in usb: {}".
format(usb_partition_info))
return False
# Check if the ISO is uploaded to controller-0
con_ssh = ControllerClient.get_active_controller()
cmd = "test -e " + os.path.join(HostLinuxUser.get_home(),
"bootimage.iso")
assert con_ssh.exec_cmd(
cmd)[0] == 0, 'The bootimage.iso file not found in {}'.format(
HostLinuxUser.get_home())
LOG.tc_step(
"Burning backup load ISO to /dev/{} ...".format(usb_part1))
# Write the ISO to USB
cmd = "echo {} | sudo -S dd if={} of=/dev/{} bs=1M oflag=direct; sync"\
.format(HostLinuxUser.get_password(), os.path.join(HostLinuxUser.get_home(), "bootimage.iso"), usb_part1)
rc, output = con_ssh.exec_cmd(cmd, expect_timeout=900)
if rc == 0:
LOG.info(
" The backup build iso file copied to USB for restore. {}".
format(output))
return True
else:
LOG.error(
"Failed to copy backup build iso file to USB {}: {}".format(
usb_part1, output))
return False
else:
LOG.tc_step(
"Copying load image ISO to local test server: {} ...".format(
backup_dest_path))
common.scp_from_active_controller_to_test_server(
os.path.join(HostLinuxUser.get_home(), "bootimage.iso"),
backup_dest_path)
LOG.info(" The backup build iso file copied to local test server: {}".
format(backup_dest_path))
return True