Lines Matching refs:self
81 def device_action(self, *args, **kwargs): argument
82 if not self.get_recover_state():
83 LOG.debug("Device {} {} is false".format(self.device_sn,
89 result = func(self, *args, **kwargs)
97 result = func(self, *args, **kwargs)
100 self.log.exception("Generate report error!", exc_info=False)
105 self.log.error("error type: {}, error: {}".format
110 HdcHelper.CONNECTOR_NAME, self.device_sn, ConfigConst.recover_state))
111 self.set_recover_state(False)
112 callback_to_outer(self, "recover failed")
114 callback_to_outer(self, "error:{}, prepare to recover".format(error))
115 if not self.recover_device():
117 self.device_sn, ConfigConst.recover_state))
118 self.set_recover_state(False)
119 callback_to_outer(self, "recover failed")
122 callback_to_outer(self, "recover success")
124 self.log.error("error type: {}, error: {}".format(error.__class__.__name__, error))
125 callback_to_outer(self, "error:{}, prepare to recover".format(error))
126 if not self.recover_device():
128 self.device_sn, ConfigConst.recover_state))
129 self.set_recover_state(False)
130 callback_to_outer(self, "recover failed")
133 callback_to_outer(self, "recover success")
135 self.log.exception("error type: {}, error: {}".format(
198 def __init__(self): argument
199 self.extend_value = {}
200 self.device_lock = threading.RLock()
201 self.forward_ports = []
202 self.forward_ports_abc = []
203 self.proxy_listener = None
204 self.device_props = {}
206 def __eq__(self, other): argument
207 return self.device_sn == other.__get_serial__() and \
208 self.device_os_type == other.device_os_type
210 def __description__(self): argument
212 DeviceProperties.sn: convert_serial(self.device_sn),
213 DeviceProperties.model: self.get_property("const.product.model"),
214 DeviceProperties.type_: self.get_device_type(),
216 DeviceProperties.version: self.get_property("const.product.software.version"),
217 DeviceProperties.others: self.device_props
221 def __set_serial__(self, device_sn=""): argument
222 self.device_sn = device_sn
223 return self.device_sn
225 def __get_serial__(self): argument
226 return self.device_sn
228 def extend_device_props(self): argument
229 if self.device_props:
238 self.push_file(query_bin_path, DEVICE_TEMP_PATH)
241 out = self.execute_shell_command(
247 self.device_props.update(params)
249 def get(self, key=None, default=None): argument
252 value = getattr(self, key, None)
256 return self.extend_value.get(key, default)
258 def recover_device(self): argument
259 if not self.get_recover_state():
261 self.device_sn, ConfigConst.recover_state))
264 result = self.device_state_monitor.wait_for_device_available(self.reboot_timeout)
266 self.device_log_collector.restart_catch_device_log()
269 def get_device_type(self): argument
270 model = self.get_property("const.product.devicetype",
273 self.label = self.model_dict.get(model, ProductForm.phone)
274 return self.label
276 def get_property(self, prop_name, retry=RETRY_ATTEMPTS, argument
281 if not self.get_recover_state():
284 stdout = self.execute_shell_command(command, timeout=5 * 1000,
293 def connector_command(self, command, **kwargs): argument
299 if self.host != "127.0.0.1":
300 cmd = [HdcHelper.CONNECTOR_NAME, "-s", "{}:{}".format(self.host, self.port),
301 "-t", self.device_sn]
303 cmd = [HdcHelper.CONNECTOR_NAME, "-t", self.device_sn]
304 LOG.debug("{} execute command {} {}{}".format(convert_serial(self.device_sn),
323 def execute_shell_command(self, command, timeout=TIMEOUT, argument
328 self, command, timeout=timeout,
333 self, command, timeout=timeout,
336 def execute_shell_cmd_background(self, command, timeout=TIMEOUT, argument
338 status = HdcHelper.execute_shell_command(self, command,
342 self.wait_for_device_not_available(DEFAULT_UNAVAILABLE_TIMEOUT)
343 self.device_state_monitor.wait_for_device_available(BACKGROUND_TIME)
345 self.connector_command(cmd)
346 self.device_log_collector.restart_catch_device_log()
349 def wait_for_device_not_available(self, wait_time): argument
350 return self.device_state_monitor.wait_for_device_not_available(
353 def _wait_for_device_online(self, wait_time=None): argument
354 return self.device_state_monitor.wait_for_device_online(wait_time)
356 def _do_reboot(self): argument
357 HdcHelper.reboot(self)
358 self.wait_for_boot_completion()
360 def _reboot_until_online(self): argument
361 self._do_reboot()
363 def reboot(self): argument
364 self._reboot_until_online()
365 self.enable_hdc_root()
366 self.device_log_collector.restart_catch_device_log()
369 def install_package(self, package_path, command=""): argument
373 return HdcHelper.install_package(self, package_path, command)
376 def uninstall_package(self, package_name): argument
377 return HdcHelper.uninstall_package(self, package_name)
380 def push_file(self, local, remote, **kwargs): argument
393 ret = self.execute_shell_command("test -d %s && echo 0" % remote)
396 self.execute_shell_command("mkdir -p %s" % remote)
398 if self.host != "127.0.0.1":
399 self.connector_command("file send {} {}".format(local, remote))
403 HdcHelper.push_file(self, local, remote, is_create=is_create,
405 if not self.is_file_exist(remote):
410 def pull_file(self, remote, local, **kwargs): argument
418 self.connector_command("file recv {} {}".format(remote, local))
420 def enable_hdc_root(self): argument
423 def is_directory(self, path): argument
425 output = self.execute_shell_command("ls -ld {}".format(path))
430 def is_file_exist(self, file_path): argument
432 output = self.execute_shell_command("ls {}".format(file_path))
437 def get_recover_result(self, retry=RETRY_ATTEMPTS): argument
439 stdout = self.execute_shell_command(command, timeout=5 * 1000,
444 def set_recover_state(self, state): argument
445 with self.device_lock:
446 setattr(self, ConfigConst.recover_state, state)
448 self.test_device_state = TestDeviceState.NOT_AVAILABLE
449 self.device_allocation_state = DeviceAllocationState.unavailable
451 if self.proxy_listener is not None:
452 if self._abc_proxy or (not self.is_abc and self.proxy):
453 self.proxy_listener(is_exception=True)
455 def get_recover_state(self, default_state=True): argument
456 with self.device_lock:
457 state = getattr(self, ConfigConst.recover_state, default_state)
460 def wait_for_boot_completion(self): argument
466 return self.device_state_monitor.wait_for_boot_complete(self.reboot_timeout)
473 def device_log_collector(self): argument
474 if self._device_log_collector is None:
475 self._device_log_collector = DeviceLogCollector(self)
476 return self._device_log_collector
478 def close(self): argument
479 self.reconnecttimes = 0
481 def reset(self): argument
482 self.log.debug("start reset device...")
483 if self._proxy is not None:
484 self._proxy.close()
485 self._proxy = None
486 if self._uitestdeamon is not None:
487 self._uitestdeamon = None
488 if self.is_abc:
489 self.stop_harmony_rpc(kill_all=False)
491 self.stop_harmony_rpc(kill_all=True)
493 if self.proxy_listener is not None:
494 self.proxy_listener(is_exception=False)
495 self.remove_ports()
496 self.device_log_collector.stop_restart_catch_device_log()
499 def is_abc(self): argument
501 return self._is_abc
504 def proxy(self): argument
509 if self._proxy is None:
511 self.check_uitest_status()
512 self._proxy = self.get_harmony()
518 self._proxy = None
519 self.log.error("DeviceTest-10012 proxy:%s" % str(error))
520 return self._proxy
523 def abc_proxy(self): argument
528 if self._abc_proxy is None:
530 self.check_uitest_status()
531 self._abc_proxy = self.get_harmony(start_abc=True)
535 self._abc_proxy = None
536 self.log.error("DeviceTest-10012 abc_proxy:%s" % str(error))
537 return self._abc_proxy
540 def uitestdeamon(self): argument
543 if self._uitestdeamon is None:
544 self._uitestdeamon = UiTestDeamon(self)
545 return self._uitestdeamon
556 def is_oh(self): argument
559 def get_harmony(self, start_abc=False): argument
560 if self.initdevice:
562 self.start_abc_rpc(re_install_rpc=True)
564 self.start_harmony_rpc(re_install_rpc=True)
565 self._h_port = self.get_local_port(start_abc)
566 port = self.d_port if not start_abc else self.abc_d_port
569 self._h_port, port)
570 self.connector_command(cmd)
571 self.log.info(
572 "get_proxy d_port:{} {}".format(self._h_port, port))
576 rpc_proxy = OpenHarmony(port=self._h_port, addr=self.host, device=self)
578 self.log.error(' proxy init error: {}.'.format(str(error)))
581 def start_uitest(self): argument
583 if self.is_abc:
584 result = self.execute_shell_command("{} start-daemon singleness &".format(UITEST_PATH))
589 uitest_version = self.execute_shell_command("{} --version".format(UITEST_PATH))
597 if not self.is_file_exist(UITEST_SHMF):
598 self.log.debug('Path {} not exist, create it.'.format(UITEST_SHMF))
599 self.execute_shell_command("echo abc > {}".format(UITEST_SHMF))
600 self.execute_shell_command("chmod -R 666 {}".format(UITEST_SHMF))
601 … result = self.execute_shell_command("{} start-daemon {} &".format(UITEST_PATH, UITEST_SHMF))
603 result = self.execute_shell_command(UITEST_COMMAND)
604 self.log.debug('start uitest, {}'.format(result))
606 def start_harmony_rpc(self, re_install_rpc=False): argument
607 if self.check_rpc_status(check_abc=False):
611 self.log.debug('Harmony rpc already start!!!!')
617 OpenHarmony.install_harmony_rpc(self)
619 self.log.debug(str(error))
620 self.log.error('please check devicetest extension module is exist.')
625 self.log.debug(str(error))
626 self.log.error('root device init RPC error.')
628 if not self.is_abc:
629 self.stop_harmony_rpc()
631 self.log.debug('Abc mode, kill hap if hap is running.')
632 self.stop_harmony_rpc(kill_all=False)
634 result = self.execute_shell_command(cmd)
635 self.log.debug('start devicetest ability, {}'.format(result))
637 …raise RpcNotRunningError("harmony {} rpc start failed".format("system" if self.is_abc else "normal…
639 if not self.is_abc:
640 self.start_uitest()
642 if not self.check_rpc_status(check_abc=False):
643 …raise RpcNotRunningError("harmony {} rpc process not found".format("system" if self.is_abc else "n…
646 def start_abc_rpc(self, re_install_rpc=False): argument
650 OpenHarmony.init_abc_resource(self)
652 self.log.debug(str(error))
653 self.log.error('please check devicetest extension module is exist.')
656 self.log.debug(str(error))
657 self.log.error('root device init abc RPC error.')
659 if self.is_abc and self.check_rpc_status(check_abc=True):
660 self.log.debug('Harmony abc rpc already start!!!!')
662 self.start_uitest()
665 if not self.check_rpc_status(check_abc=True):
668 def stop_harmony_rpc(self, kill_all=True): argument
669 if not self.get_recover_state():
673 proc_pids = self.get_devicetest_proc_pid()
679 self.execute_shell_command(cmd)
682 def check_uitest_status(self): argument
683 self.log.debug('Check uitest running status.')
684 proc_pids = self.get_devicetest_proc_pid(print_info=False)
685 if self.is_abc and proc_pids[1] != "":
687 self.execute_shell_command('kill {}'.format(proc_pids[0]))
688 self.execute_shell_command('kill {}'.format(proc_pids[1]))
689 self.log.debug('Uitest is running in normal mode, current mode is abc, wait it exit.')
690 if not self.is_abc and proc_pids[2] != "":
692 self.execute_shell_command('kill {}'.format(proc_pids[0]))
693 self.execute_shell_command('kill {}'.format(proc_pids[2]))
694 self.log.debug('Uitest is running in abc mode, current mode is normal, wait it exit.')
695 self.log.debug('Finish check uitest running status.')
697 def get_devicetest_proc_pid(self, print_info=True): argument
700 proc_running = self.execute_shell_command(cmd).strip()
719 self.log.debug("\n".join(result))
722 def is_harmony_rpc_running(self, check_abc=False): argument
723 proc_pids = self.get_devicetest_proc_pid(print_info=False)
724 if not self.is_abc:
725 …self.log.debug('is_proc_running: agent pid: {}, uitest pid: {}'.format(proc_pids[0], proc_pids[1]))
730 self.log.debug('is_proc_running: uitest pid: {}'.format(proc_pids[2]))
734 self.log.debug('is_proc_running: agent pid: {}'.format(proc_pids[0]))
739 def is_harmony_rpc_socket_running(self, port, check_server=True): argument
740 out = self.execute_shell_command("netstat -anp | grep {}".format(port))
741 self.log.debug(out)
753 def check_rpc_status(self, check_abc=False, check_server=True): argument
754 port = self.d_port if not check_abc else self.abc_d_port
755 if self.is_harmony_rpc_running(check_abc) and \
756 self.is_harmony_rpc_socket_running(port, check_server=check_server):
757 self.log.debug('Harmony rpc is running!!!! If is check abc: {}'.format(check_abc))
759 self.log.debug('Harmony rpc is not running!!!! If is check abc: {}'.format(check_abc))
762 def install_app(self, remote_path, command): argument
764 ret = self.execute_shell_command(
768 return self.execute_shell_command(
772 self.log.error("%s, maybe there has a warning box appears "
776 def uninstall_app(self, package_name): argument
778 ret = self.execute_shell_command("pm uninstall %s" % package_name)
779 self.log.debug(ret)
782 self.log.error('DeviceTest-20013 uninstall: %s' % str(err))
785 def reconnect(self, waittime=60): argument
789 if not self.wait_for_boot_completion():
790 self._proxy = None
791 self._uitestdeamon = None
793 if self._proxy:
795 if not self.is_abc and self.proxy_listener is not None:
796 self.proxy_listener(is_exception=True)
797 self.start_harmony_rpc(re_install_rpc=True)
798 self._h_port = self.get_local_port(start_abc=False)
800 self._h_port, self.d_port)
801 self.connector_command(cmd)
803 self._proxy.init(port=self._h_port, addr=self.host, device=self)
806 self._proxy.init(port=self._h_port, addr=self.host, device=self)
808 if self.is_abc and self._abc_proxy:
810 if self.proxy_listener is not None:
811 self.proxy_listener(is_exception=True)
812 self.start_abc_rpc(re_install_rpc=True)
813 self._h_port = self.get_local_port(start_abc=True)
815 self._h_port, self.abc_d_port)
816 self.connector_command(cmd)
818 self._abc_proxy.init(port=self._h_port, addr=self.host, device=self)
821 self._abc_proxy.init(port=self._h_port, addr=self.host, device=self)
823 if self._uitestdeamon is not None:
824 self._uitestdeamon.init(self)
826 if self._proxy:
827 return self._proxy
830 def get_local_port(self, start_abc): argument
832 host = self.host
834 h_port = get_forward_port(self, host, port)
836 self.forward_ports_abc.append(h_port)
838 self.forward_ports.append(h_port)
839 self.log.info("tcp forward port: {} for {}".format(
840 h_port, convert_serial(self.device_sn)))
843 def remove_ports(self): argument
844 for port in self.forward_ports:
846 port, self.d_port)
847 self.connector_command(cmd)
848 for port in self.forward_ports_abc:
850 port, self.abc_d_port)
851 self.connector_command(cmd)
852 self.forward_ports.clear()
853 self.forward_ports_abc.clear()
855 def remove_history_ports(self, port): argument
857 res = self.connector_command(cmd, is_print=False)
863 self.connector_command(cmd, is_print=False)
865 def take_picture(self, name): argument
872 if self._device_report_path is None:
874 self._device_report_path = EnvPool.report_path
875 temp_path = os.path.join(self._device_report_path, "temp")
880 … out = self.execute_shell_command("snapshot_display -f /data/local/tmp/{}".format(picture_name))
881 self.log.debug("result: {}".format(out))
885 self.pull_file("/data/local/tmp/{}".format(picture_name), path)
887 self.log.error("devicetest take_picture: {}".format(str(error)))
890 def set_device_report_path(self, path): argument
891 self._device_report_path = path
893 def get_device_report_path(self): argument
894 return self._device_report_path
896 def execute_shell_in_daemon(self, command): argument
897 if self.host != "127.0.0.1":
899 self.host, self.port), "-t", self.device_sn, "shell"]
901 cmd = [HdcHelper.CONNECTOR_NAME, "-t", self.device_sn, "shell"]
903 convert_serial(self.device_sn), HdcHelper.CONNECTOR_NAME, command))
918 def webview(self): argument
920 if self._webview is None:
921 self._webview = WebView(self)
922 return self._webview
933 def __init__(self, device): argument
934 self.device = device
936 def _set_device_log_level(self, **kwargs): argument
938 if not self.device_log_level:
941 self.device_log_level = "INFO"
943 self.device_log_level = log_level
944 cmd = "hilog -b {}".format(self.device_log_level)
945 self.device.execute_shell_command(cmd)
947 def restart_catch_device_log(self): argument
948 self._sync_device_time()
949 for _, path in enumerate(self.hilog_file_address):
953 _, proc = self.start_catch_device_log(hilog_file_pipe=hilog_file_pipe)
954 self.restart_proc.append(proc)
956 def stop_restart_catch_device_log(self): argument
958 for _, proc in enumerate(self.restart_proc):
959 self.stop_catch_device_log(proc)
960 self.restart_proc.clear()
961 self.hilog_file_address.clear()
962 self.log_file_address.clear()
964 def start_catch_device_log(self, log_file_pipe=None, argument
970 self._sync_device_time()
971 self._set_device_log_level(**kwargs)
976 if self.device.host != "127.0.0.1":
977 … cmd = [HdcHelper.CONNECTOR_NAME, "-s", "{}:{}".format(self.device.host, self.device.port),
978 "-t", self.device.device_sn, command]
980 cmd = [HdcHelper.CONNECTOR_NAME, "-t", self.device.device_sn, command]
982 self.device.device_sn, convert_serial(self.device.device_sn)))
987 def stop_catch_device_log(self, proc): argument
993 self.device.log.debug("Stop catch device hilog.")
995 def start_hilog_task(self, **kwargs): argument
1000 … self.device.log.debug("hilog task Invalid size string {}. Use default 10M".format(log_size))
1004 self.device.log.debug("hilog task file size should be "
1008 self.device.log.debug("hilog task file size should be "
1012 self._sync_device_time()
1013 self.is_clear = kwargs.get("is_clear", True)
1015 self.clear_crash_log()
1018 self.device.execute_shell_command(cmd)
1021 self.device.execute_shell_command(cmd)
1024 self._set_device_log_level(**kwargs)
1027 out = self.device.execute_shell_command(cmd)
1031 out = self.device.execute_shell_command(cmd)
1034 def stop_hilog_task(self, log_name, **kwargs): argument
1036 self.device.execute_shell_command(cmd)
1039 path = "{}/log/{}".format(self.device.get_device_report_path(), module_name)
1041 path = "{}/log/".format(self.device.get_device_report_path())
1044 self.device.pull_file("/data/log/hilog/", path)
1047 …new_hilog_dir = "{}/log/{}/hilog_{}".format(self.device.get_device_report_path(), module_name, log…
1048 …os.rename("{}/log/{}/hilog".format(self.device.get_device_report_path(), module_name), new_hilog_d…
1052 … self.device.log.warning("Rename hilog folder {}_hilog failed. error: {}".format(log_name, e))
1055 out = self.device.execute_shell_command(cmd)
1058 self.device.pull_file("/data/log/{}_hilog.tar.gz".format(log_name), path)
1060 self.device.execute_shell_command(cmd)
1062 if self.is_clear:
1064 self.device.execute_shell_command(cmd)
1066 self.start_get_crash_log(log_name, module_name=module_name)
1068 self.pull_extra_log_files(log_name, module_name, kwargs.get("extras_dirs", None))
1070 def _get_log(self, log_path, *params): argument
1079 log_result = self.device.execute_shell_command("ls {}".format(log_path))
1089 def start_get_crash_log(self, task_name, **kwargs): argument
1096 self.device.pull_file(device_path, local_path)
1103 log_array.extend(self._get_log(NATIVE_CRASH_PATH, "cppcrash"))
1104 log_array.extend(self._get_log(JS_CRASH_PATH, "jscrash", "appfreeze", "cppcrash"))
1105 log_array.extend(self._get_log(ROOT_PATH, "SERVICE_BLOCK", "appfreeze"))
1108 …crash_path = "{}/log/{}/crash_log_{}/".format(self.device.get_device_report_path(), module_name, t…
1110 … crash_path = "{}/log/crash_log_{}/".format(self.device.get_device_report_path(), task_name)
1115 def clear_crash_log(self): argument
1116 if not self.is_clear:
1123 self.device.execute_shell_command(clear_cmd)
1129 def _sync_device_time(self): argument
1133 self.device.execute_shell_command("date '{}'".format(cur_time))
1135 def add_log_address(self, log_file_address, hilog_file_address): argument
1138 self.log_file_address.append(log_file_address)
1140 self.hilog_file_address.append(hilog_file_address)
1142 def remove_log_address(self, log_file_address, hilog_file_address): argument
1143 if log_file_address and log_file_address in self.log_file_address:
1144 self.log_file_address.remove(log_file_address)
1145 if hilog_file_address and hilog_file_address in self.hilog_file_address:
1146 self.hilog_file_address.remove(hilog_file_address)
1148 def pull_extra_log_files(self, task_name, module_name, dirs: str): argument
1153 extra_log_path = "{}/log/{}/extra_log_{}/".format(self.device.get_device_report_path(),
1158 self.device.pull_file(dir_path, extra_log_path)
1160 if self.device.is_directory(dir_path):
1164 self.device.execute_shell_command(clear_cmd)