def import_cert(cert="ROOTCA.pem"):
time.sleep(1)
log.info("start import certificate")
rootca_pem_1 = os.path.exists("/etc/ssl/certs/ROOTCA.pem")
if rootca_pem_1:
log.info("certificate is already exist")
return True
else:
log.info("certificate not exist, start install cert")
shutil.copy(
os.path.join(get_current_dir(), 'Test_Utility', 'ROOTCA.pem'),
'/usr/local/share/ca-certificates/ROOTCA.pem')
time.sleep(0.2)
c = os.path.exists("/usr/local/share/ca-certificates/{}".format(cert))
if not c:
log.error('copy cert fail')
return False
log.info('copy cert success')
subprocess.getstatusoutput("/usr/bin/hptc-cert-mgr --apply")
time.sleep(4)
rootca_pem_2 = os.path.exists("/etc/ssl/certs/ROOTCA.pem")
if not rootca_pem_2:
log.error('install certificates fail')
return False
else:
log.info('install certificates success')
time.sleep(1)
return True
def enable_wlan(device_name):
try:
subprocess.run(
"/usr/lib/hptc-network-mgr/wireless/hptc-wireless-manager --up {}".
format(device_name),
shell=True)
log.info("enable {}".format(device_name))
except Exception as e:
log.error(e)
def get_user():
try:
user = getpass.getuser()
return user
except Exception as e:
log.error(
"[socket server][get_user]Error while getting user: {}".format(
e))
return ""
def enable_lan_filber(device_name):
try:
subprocess.Popen(
"/usr/lib/hptc-network-mgr/common/netmgr_wired --up {}".format(
device_name),
shell=True)
log.info("enable {}".format(device_name))
except Exception as e:
log.error(e)
def __init__(self, client_socket):
threading.Thread.__init__(self)
self.client_socket: socket.socket = client_socket
self.user = self.get_user().lower()
if self.user in User_List:
ip = self.client_socket.getsockname()[0]
try:
user_manager.change_key_state(self.user, ip)
except Exception as e:
log.error("change key {} fail {} : {}".format(
self.user, ip, e))
def log_off():
try:
os.system("shutdown -l")
print('logoff')
time.sleep(5)
return True
except Exception as e:
log.error(
"[socket server][log_off]Error while logging off: {}".format(
e))
return False
def run(self):
while True:
data = self.client_socket.recv(BUFSIZE)
print(data, "[socket server][run]data")
if not data:
log.info(
'[socket server][run]No response. Close the client connection {0}.'
.format(self.client_socket.getpeername()))
# self.client_socket.sendall('No data received. Connection closed.'.encode(encoding))
# print('socket connection disconnect')
break
string = bytes.decode(data, encoding).strip()
log.info(
"[socket server][run]Content from client: {}.".format(string))
if string.upper() == 'GET_USER':
user = self.get_user()
if user:
self.client_socket.sendall(
'{}'.format(user).encode(encoding))
else:
self.client_socket.sendall(
'[socket server][run]get_user fail'.encode(encoding))
elif string.upper() == 'LOGOFF':
logoff = self.log_off()
if logoff:
self.client_socket.sendall(
'[socket server][run]logoff done'.encode(encoding))
else:
self.client_socket.sendall(
'[socket server][run]logoff fail'.encode(encoding))
elif 'WAKEUP' in string.upper():
# wakeup mac time(s)
log.info("[socket server][run]Send 'Accept {}'".format(string))
self.client_socket.sendall(
'Accept {}'.format(string).encode(encoding))
info = string.split(" ")[1:]
log.info("[socket server][run]start wakeup {}".format(
" ".join(info)))
self.wake_up(*info)
elif string.upper() == 'GETINFO':
info = self.get_info()
if info:
self.client_socket.sendall(
'{}'.format(info).encode(encoding))
else:
self.client_socket.sendall(
'[socket server][run]get_info fail'.encode(encoding))
else:
log.error(
'[socket server][run]Invalid message {}.'.format(string))
break
self.client_socket.close()
def wake_up(mac, *args):
try:
tool_path = r".\wol.exe"
time.sleep(int(args[0]))
for i in range(8):
time.sleep(1)
log.info("Send: {} {}".format(tool_path, mac))
os.system("{} {}".format(tool_path, mac))
return True
except Exception as e:
log.error(e)
log.error("[socket server][wake_up]Wakeup fail")
return True
def change_key_state(self, user_name, state, key="user"):
self.ftp.download_file(self.remote_base_file, self.file_path)
time.sleep(2)
yaml_obj = YamlOperator(self.file_path)
total_users = yaml_obj.read()
value = total_users.get(key).get(user_name)
if value:
total_users[key][user_name] = state
yaml_obj.write(total_users)
self.ftp.upload_file(self.file_path, self.remote_base_file)
else:
log.error('invalid user {}'.format(user_name))
return False
return True
def ping_server(ip="15.83.240.98"):
log.info("start ping " + ip)
s = subprocess.Popen("ping {} -c 50 | grep -i received".format(ip),
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE,
shell=True)
out, error = s.communicate(timeout=60)
out = out.decode()
out_list = out.split(',')
try:
s.kill()
res = re.search(r"(\d+)", out_list[2])
result = res.group(1)
if int(result) <= 25:
log.info("ping " + ip + " success")
return True
# if out_list[2] == ' 0% packet loss':
# log.info("ping " + ip + " success")
# return True
else:
log.error("ping " + ip + " fail")
log.error(f'ping {ip} result: {out}')
return False
except Exception as e:
log.error(e)
log.error("ping " + ip + " fail")
return False
def run(self):
log.info("Socket server Listener started.")
try:
while True:
client_socket, client_addr = self.sock.accept()
# print("Accept a connect from client {}.".format(client_addr[0]))
log.info(
"Accept a connect from client {}.".format(client_addr))
client_socket.sendall(
'Hi, I got your request. We can start to communicate.'.
encode(encoding))
Process(client_socket).start()
except Exception as e:
log.error(e)
log.error("socket client error, and break")
def start(self):
self.__set()
assert self.__method_name_list, "Need a method list!"
index = self.read_a_file()
log.info("Get Status: {}".format(index))
if index == -1:
log.info(" This {} Flow has Ended".format(self.__class_name))
return
flag = True
self.current_step = index
new_list = self.__method_name_list[index:]
for method_name in new_list:
if method_name in self.__skip_list:
self.current_step += 1
continue
method = self.__dic.get(method_name)
assert method, "{} Not Exist".format(method_name)
log.info("Start Step Method {}".format(method_name))
try:
result_dict = {"event_method": method, "return": True}
method(self)
self.result_handler.update_class_property(**result_dict)
self.result_handler.start()
self.exec_callback(self.__work_around_list_success)
except self.exception as e:
flag = False
self.suspend_exec()
self.end_flow()
log.error(e)
result_dict = {
"event_method": method,
"error_msg": {
"actual":
"Fail at Index {} : {}".format(self.current_step, e)
},
"return": False
}
self.result_handler.update_class_property(**result_dict)
self.result_handler.start()
self.exec_callback(self.__work_around_list_fail)
if not self.__exec:
break
self.current_step += 1
log.debug("Capture Flag Return : {}".format(flag))
return flag
def load_data_from_ftp():
file_obj = YamlOperator(
get_current_dir('Test_Data', 'td_common', 'global_config.yml'))
content = file_obj.read()
ftp_server = content['td_ftp']['server']
ftp_user = content['td_ftp']['username']
ftp_passwd = content['td_ftp']['password']
td_path = content['td_ftp']['td_path']
try:
ftp = FTPUtils(ftp_server, ftp_user, ftp_passwd)
ftp.change_dir(td_path)
folders = ftp.get_item_list('')
for folder in folders:
if not ftp.is_item_file(folder):
ftp.download_dir(folder, get_current_dir(folder))
ftp.close()
except:
log.error('ftp exception:\n{}'.format(traceback.format_exc()))
def __load_uut_result(self):
result_file = get_current_dir('Test_Report', '{}.yaml'.format(self.ip))
if not os.path.exists(result_file):
empty_result = [{
'uut_name': self.ip,
'case_name': 'No result return',
'steps': [],
'result': 'fail'
}, {
'uut_name': self.ip,
'case_name': 'No result return',
'steps': [],
'result': 'pass'
}]
log.error('Result File {} Not Exsit'.format(result_file))
result = empty_result
else:
with open(result_file, encoding='utf-8') as f:
result = yaml.safe_load(f.read())
try:
self.return_to_ALM(result)
except Exception as e:
log.error('Fail to return result to ALM:')
log.error(str(e))
return result
def collect_report():
"""
collect report and send to ALM server for automated return result to ALM
alm need addition.yml(case<->alm information), ip.yml(cases result)
:return:
#By: balance
"""
# expect only ip.yml exist in test_report
global_conf = YamlOperator(
get_current_dir('Test_Data', 'td_common', 'global_config.yml')).read()
ftp_svr = global_conf['alm_ftp']['server']
ftp_user = global_conf['alm_ftp']['username']
ftp_pass = global_conf['alm_ftp']['password']
ftp_path = global_conf['alm_ftp']['report_path']
result_file = get_folder_items(get_current_dir('Test_Report'),
file_only=True,
filter_name='.yaml')[0]
log.info(f'[common][collect result]Get result file: {result_file}')
prefix = time.strftime("test_%m%d%H%M%S", time.localtime())
log.info(
'[common][collect result]Copy additional.yml and ip.yml to test report'
)
shutil.copy(get_current_dir('Test_Data', 'additional.yml'),
get_current_dir('Test_Report', '{}_add.yml'.format(prefix)))
shutil.copy(get_current_dir('Test_Report', result_file),
get_current_dir('Test_Report', '{}_result.yml'.format(prefix)))
try:
ftp = file_transfer.FTPUtils(ftp_svr, ftp_user, ftp_pass)
ftp.change_dir(ftp_path)
ftp.upload_file(
get_current_dir('Test_Report', '{}_result.yml'.format(prefix)),
'{}_result.yml'.format(prefix))
ftp.upload_file(
get_current_dir('Test_Report', '{}_add.yml'.format(prefix)),
'{}_add.yml'.format(prefix))
ftp.close()
log.info('[common][collect result]upload report to ftp server')
except:
log.error('[common][collect result]FTP Fail Exception:\n{}'.format(
traceback.format_exc()))
def memory_check(dtype="-m", limit: int = 300, strict_mode=True):
"""
check memeory > limit
raise ValueError if strict_mode is Ture else return False
"""
try:
res = os.popen(f"free {dtype}").readlines()
line_name = res[0]
line_value = res[1]
index = line_name.index("available")
available_str = line_value[index:index +
len("available")].strip("kbgyteKBGYTE ")
avail = float(available_str)
print(avail)
except Exception as e:
log.error(e)
return -1
if avail < limit and strict_mode:
raise MemoryNotSufficient(
"current Memory is not sufficient! Current: {}".format(avail))
elif avail < limit:
return False
return True
def remote_start(case_name, result_file, test_data, pic_name, user_manager, parameters, performance):
global session, rdp_server, user
if parameters['vdi'].upper() == 'RDP':
session = parameters.get('session')
rdp_server = user_manager.get_a_available_key(session.lower())
conn = vdi_connection.RDPLinux(user=user, parameters=parameters, rdp_server=rdp_server)
elif parameters['vdi'].upper() == 'VIEW':
conn = vdi_connection.ViewLinux(user=user, parameters=parameters)
elif parameters['vdi'].upper() == 'CITRIX':
conn = vdi_connection.CitrixLinux(user=user, parameters=parameters)
else:
conn = None
log.info('init connection instance')
first_collect_flag = False
if conn:
# VDI Test
conn_flag = False
for count in range(2):
logon = conn.logon(parameters['session'])
if logon is True:
pymouse.PyMouse().click(1, 1)
log.info('successfully logon session: {}'.format(parameters['session']))
steps = {
'step_name': 'logon vdi',
'result': 'Pass',
'expect': '', # can be string or pic path
'actual': 'logon successfully',
'note': ''}
common_function.update_cases_result(result_file, case_name, steps)
conn_flag = True
pic_sim, diff_res, first_collect_flag = check_layout(os.path.join(test_data,
'td_multiple_display',
'{}_pic'.format(parameters['vdi']).lower(),
pic_name))
if pic_sim >= 0.99:
log.info('check layout pass')
steps = {
'step_name': 'check vdi layout',
'result': 'Pass',
'expect': 'similarity > 99%', # can be string or pic path
'actual': 'layout and resolution set correctly： {}'.format(pic_sim),
'note': ''}
common_function.update_cases_result(result_file, case_name, steps)
else:
log.error('check layout Fail, autual: {}'.format(pic_sim))
shutil.copy(common_function.get_current_dir('temp.png'),
common_function.get_current_dir('Test_Report', 'img', '{}.jpg'.format(case_name)))
steps = {
'step_name': 'check vdi layout',
'result': 'Fail',
'expect': 'similarity > 99%', # can be string or pic path
'actual': 'img/{}.png'.format(case_name), # can be string or pic path
'note': 'actual result: {}'.format(pic_sim)}
common_function.update_cases_result(result_file, case_name, steps)
if not os.path.exists(common_function.get_current_dir('Test_Report', 'img')):
os.mkdir(common_function.get_current_dir('Test_Report', 'img'))
try:
common_function.check_free_memory("beforeremote")
picture_operator.save_from_data(
'{}'.format(common_function.get_current_dir('Test_Report', 'img',
'{}.png'.format(
case_name))),
diff_res)
common_function.check_free_memory("afterremote")
except:
save_fail_path = common_function.get_current_dir('Test_Report', 'img', 'save_fail_remote_{}.txt'.format(case_name))
f = open(save_fail_path, "w")
f.write(traceback.format_exc())
f.close()
finally:
log.debug(gc.garbage)
gc.collect()
log.info("collecting performance data")
path = "{}/Test_Report/performance/".format(common_function.get_current_dir())
if not os.path.exists(path):
os.makedirs(path)
performance.file = path + "{}.txt".format("".join(case_name.split("_")[2:-4]).replace(" ", ""))
performance.start()
conn.logoff()
break
elif isinstance(logon, str):
log.warning('logon fail in cycle {}'.format(count))
# wait 2min try again
time.sleep(120)
if not user:
log.info("user get none before, try to get a new user")
user = user_manager.get_a_available_key()
conn.user = user
if parameters['vdi'].upper() == 'RDP' and not rdp_server:
log.info("try to get rdp_server")
session = parameters.get('session')
rdp_server = user_manager.get_a_available_key(session.lower())
conn.server = rdp_server
conn.domain_list = [rdp_server]
continue
else:
log.error("logon fail in cycle {}& white list can't catch it, break!".format(count))
break
if not conn_flag:
log.error('logon fail, and try count finished')
steps = {
'step_name': 'logon vdi',
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': 'Fail to logon within 6 mins', # can be string or pic path
'note': ''}
common_function.update_cases_result(result_file, case_name, steps)
return False, first_collect_flag
return True, first_collect_flag
def main():
# show_desktop()
if os.path.exists(get_current_dir('flag.txt')):
with open(get_current_dir('flag.txt')) as f:
test_flag = f.read()
if 'TEST FINISHED' in test_flag.upper():
return
if not os.path.exists('time.txt'):
with open('time.txt', 'w') as f:
f.write(time.ctime())
prepare_for_framework()
additional_path = get_current_dir('Test_Data', 'additional.yml')
file_obj = YamlOperator(additional_path)
content = file_obj.read()
site = content.get('AutoDash_Site')
if not site:
load_data_from_ftp()
script_name = os.path.basename(__file__).split('.')[0]
add_linux_script_startup([script_name])
check_water_mark()
path = get_current_dir('reboot.txt')
if not os.path.exists(path):
with open(path, 'w+') as f:
f.write("0")
time.sleep(5)
if os.path.exists(path):
SwitchThinProMode("admin")
os.popen('reboot')
time.sleep(30)
if not os.path.exists(get_current_dir('Test_Report')):
os.mkdir(get_current_dir('Test_Report'))
test_data_path = os.path.join(get_current_dir(), 'Test_Data')
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('testing')
if not os.path.exists(os.path.join(test_data_path, 'script.yml')):
log.info('script.yml not exist, please check if no cases planned')
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('test finished')
return
with open(os.path.join(test_data_path, 'script.yml'), 'r') as f:
scripts = yaml.safe_load(f)
with open(os.path.join(test_data_path, 'additional.yml'), 'r') as f:
additional = yaml.safe_load(f)
for script in scripts:
script_name, script_status = list(script.items())[0]
if script_status.upper() == 'NORUN':
log.info('Begin to Test case {}'.format(script_name))
try:
if need_reboot() == 1:
change_reboot_status(0)
reboot_command()
memory_check(limit=MEMORY_LIMIT)
globals()[script_name.split('__')[0]].start(
case_name=script_name.split('__')[1], kwargs=additional)
script[script_name] = 'Finished'
with open(os.path.join(test_data_path, 'script.yml'),
'w') as f:
yaml.safe_dump(scripts, f)
except MemoryNotSufficient as e:
log.debug(e)
log.debug("start reboot")
reboot_command()
except:
with open(get_current_dir('Test_Report', 'debug.log'),
'a') as f:
f.write(traceback.format_exc())
capture_screen(
get_current_dir(
'Test_Report',
'img',
'{}.jpg'.format(script_name.split('__')[1]),
))
script[script_name] = 'Finished'
with open(os.path.join(test_data_path, 'script.yml'),
'w') as f:
yaml.safe_dump(scripts, f)
steps = {
'step_name': 'case exception',
'result': 'Fail',
'expect': '', # can be string or pic path
'actual': 'img/{}.jpg'.format(script_name.split('__')[1]),
'note': traceback.format_exc()
}
base_name = get_report_base_name()
report_file = get_current_dir('Test_Report', base_name)
# result_file = get_current_dir(r'Test_Report', '{}.yaml'.format(check_ip_yaml()))
update_cases_result(report_file,
script_name.split('__')[1], steps)
else:
log.info('Test case {} status is Finished, Skip test'.format(
script_name))
if os.path.exists(path):
if need_reboot() == 0:
change_reboot_status(9)
log.info("Start Reboot before Report")
reboot_command()
else:
os.remove(path)
if site:
share_folder = content.get('share_folder')
host = share_folder.split('/')[0]
folder_path = '/'.join(share_folder.split('/')[1:])
user = content.get('user')
password = content.get('password')
flag_path = '/{}/{}.txt'.format(folder_path, site)
log.info('end_flag: {}'.format(flag_path))
with open(get_current_dir('{}.txt'.format(site)), 'w') as f:
f.write('test finished')
ftp = FTPUtils(host, user, password)
ftp.ftp.cwd('ThinPro_Automation_Site')
local_folder = get_current_dir('Test_Report')
ftp_folder = r'/{}/Test_Report'.format(folder_path)
num = 0
while True:
try:
ftp = FTPUtils(host, user, password)
log.info('upload Test_Report folder to ftp')
log.info(local_folder)
log.info(ftp_folder)
ftp.new_dir(ftp_folder)
local_report = get_current_dir('Test_Report',
'{}.yaml'.format(site))
ftp_report = '/{}/Test_Report/{}.yaml'.format(
folder_path, site)
ftp.upload_file(local_report, ftp_report)
ftp.upload_file(get_current_dir(r"{}.txt".format(site)),
flag_path)
break
except:
if num > 30:
traceback.print_exc()
break
else:
num += 5
time.sleep(5)
else:
with open(get_current_dir('flag.txt'), 'w') as f:
f.write('test finished')
with open('time.txt') as f:
start = f.read()
end = time.ctime()
report = email_tool.GenerateReport(start, end)
report.generate()
file = email_tool.zip_dir()
log.info('zipped file name: {}'.format(file_obj))
additional_email = additional.get('email') if additional.get(
'email') else ''
email_tool.send_mail(
recipient=['*****@*****.**', additional_email],
subject='Automation Report Linux {}'.format(
zip_file_name(get_report_number(), get_report_value())),
attachment=file)
os.remove(file)
os.remove('time.txt')
try:
collect_report()
except Exception as e:
print(e)
log.error(e)
report = email_tool.GenerateReport(start, end)
report.generate()
file = email_tool.zip_dir()
log.info('zipped file name: {}'.format(file_obj))
additional_email = additional.get('email') if additional.get(
'email') else ''
email_tool.send_mail(
recipient=['*****@*****.**', additional_email],
subject='Automation Report Linux {}'.format(
zip_file_name(get_report_number(), get_report_value())),
attachment=file)
os.remove(file)
os.remove('time.txt')
try:
collect_report()
except Exception as e:
print(e)
log.error(e)
if __name__ == '__main__':
try:
if not os.path.exists(get_current_dir('Test_Data', 'profile.xml')):
export_profile()
main()
if os.path.exists(get_current_dir('Test_Data', 'profile.xml')):
os.popen('rm {}'.format(get_current_dir('Test_Data',
'profile.xml')))
except:
log.error(traceback.format_exc())
def switch_mode(self):
if self.switch_to == 'user':
if self.current_mode() == 'user':
log.info("now is user mode")
return True
if self.current_mode() == 'admin':
for _ in range(3):
os.popen('hptc-switch-admin')
time.sleep(2)
if self.current_mode() == 'user':
log.info("switch to user mode success")
return True
log.error("switch to user fail, try again")
time.sleep(2)
else:
log.error("switch to user mode fail")
return False
if self.switch_to == 'admin':
if self.current_mode() == 'admin':
log.info("now is admin mode")
return True
if self.current_mode() == 'user':
log.info("change mode user")
if self.judge_has_root_pw():
os.popen('hptc-switch-admin')
time.sleep(3)
# kb.type_string(self.password)
# time.sleep(1)
# kb.tap_key(kb.enter_key)
pyautogui.typewrite(self.password)
time.sleep(2)
pyautogui.press('enter')
time.sleep(2)
if self.current_mode() == 'admin':
log.info("switch to admin mode success")
return True
else:
kb.tap_key(kb.enter_key)
time.sleep(1)
kb.type_string('root')
time.sleep(1)
kb.tap_key(kb.tab_key)
time.sleep(1)
kb.type_string(self.password)
time.sleep(1)
kb.tap_key(kb.enter_key)
time.sleep(1)
if self.current_mode() == 'admin':
log.info("switch to admin mode success")
return True
else:
log.info("switch to admin mode fail")
return False
if not self.judge_has_root_pw():
os.popen('hptc-switch-admin')
time.sleep(2)
kb.type_string(self.password)
time.sleep(1)
kb.tap_key(kb.tab_key)
time.sleep(1)
kb.type_string(self.password)
time.sleep(1)
kb.tap_key(kb.enter_key)
time.sleep(2)
if self.current_mode() == 'admin':
log.info("switch to admin mode success")
return True
else:
log.error("switch to admin mode fail")
return False