def run_module(self, request, configs, source): json_config = JsonParser(source) if request.root.source.source_file.strip(): folder_name = "task_%s_%s" % (self.config.tmp_id, request.root.source.test_name) tmp_sub_folder = os.path.join(self.config.tmp_folder, folder_name) os.makedirs(tmp_sub_folder, exist_ok=True) configs["report_path"] = tmp_sub_folder self.result = "%s.xml" % os.path.join(tmp_sub_folder, "report") module_path = os.path.dirname(source) file_list = get_config_value('py_file', json_config.get_driver(), is_list=True) if not file_list: file_list = get_file_list(module_path) else: folder_name = "task_%s_report" % self.config.tmp_id tmp_sub_folder = os.path.join(self.config.tmp_folder, folder_name) self.result = "%s.xml" % os.path.join(tmp_sub_folder, "report") json_config = JsonParser(source) file_list = get_config_value('py_file', json_config.get_driver(), is_list=True) configs["test_name"] = request.root.source.test_name configs["execute"] = get_config_value('execute', json_config.get_driver(), False) os.makedirs(tmp_sub_folder, exist_ok=True) self._run_devicetest(configs, file_list)
def __execute__(self, request): kits = [] try: self.config = request.config setattr(self.config, "command_result", "") self.config.device = request.config.environment.devices[0] self.__init_nfs_server__(request=request) config_file = request.root.source.config_file json_config = JsonParser(config_file) pre_cmd = get_config_value('pre_cmd', json_config.get_driver(), False) execute_dir = get_config_value('execute', json_config.get_driver(), False) kits = get_kit_instances(json_config, request.config.resource_path, request.config.testcases_path) from xdevice import Scheduler for kit in kits: if not Scheduler.is_execute: raise ExecuteTerminate() copy_list = kit.__setup__(request.config.device, request=request) self.file_name = request.root.source.test_name self.set_file_name(request, request.root.source.test_name) self.config.device.execute_command_with_timeout( command=pre_cmd, timeout=0.5) self.config.device.execute_command_with_timeout( command="cd {}".format(execute_dir), timeout=1) for test_bin in copy_list: if not test_bin.endswith(".run-test"): continue command, _, _ = get_execute_command(test_bin, False) self._do_test_run(command, request) device_log_file = get_device_log_file( request.config.report_path, request.config.device.__get_serial__()) with open(device_log_file, "a", encoding="UTF-8") as file_name: file_name.write(self.config.command_result) except (LiteDeviceExecuteCommandError, Exception) as exception: LOG.error(exception) self.error_message = exception finally: LOG.info("-------------finally-----------------") # umount the dirs already mount for kit in kits: kit.__teardown__(request.config.device) close_error = self.config.device.close() self.error_message = close_error if close_error else\ "case results are abnormal" report_name = "report" if request.root.source. \ test_name.startswith("{") else get_filename_extension( request.root.source.test_name)[0] self.result = check_result_report( request.config.report_path, self.result, self.error_message, report_name)
def __check_config__(self, config): self.remote = get_config_value('server', config, is_list=False) self.paths = get_config_value('paths', config) self.mount_list = get_config_value('mount', config, is_list=True) self.server = get_config_value('server', config, is_list=False, default="NfsServer") if not self.mount_list: msg = "The config for mount kit is invalid with mount:{}" \ .format(self.mount_list) LOG.error(msg) raise TypeError(msg)
def __check_config__(self, config): setattr(self.mount_kit, "mount_list", get_config_value('mount', config)) setattr( self.mount_kit, "server", get_config_value('server', config, is_list=False, default="NfsServer")) self.query = get_config_value('query', config, is_list=False) if not self.query: msg = "The config for query kit is invalid with query:{}" \ .format(self.query) LOG.error(msg) raise TypeError(msg)
def __check_config__(self, config): self.timeout = str( int(get_config_value('timeout', config, is_list=False)) * 1000) self.burn_file = get_config_value('burn_file', config, is_list=False) burn_command = get_config_value('burn_command', config, is_list=False, default=RESET_CMD) self.burn_command = burn_command.replace(" ", "").split(",") self.paths = get_config_value('paths', config) if not self.timeout or not self.burn_file or not self.burn_command: msg = "The config for deploy kit is invalid with timeout:{} " \ "burn_file:{} burn_command:{}".format(self.timeout, self.burn_file, self.burn_command) LOG.error(msg) raise TypeError(msg)
def __execute__(self, request): kits = [] try: self.config = request.config self.init_cpp_config() self.config.device = request.config.environment.devices[0] self.__init_nfs_server__(request=request) config_file = request.root.source.config_file json_config = JsonParser(config_file) self._get_driver_config(json_config) bin_file = get_config_value('execute', json_config.get_driver(), False) kits = get_kit_instances(json_config, request.config.resource_path, request.config.testcases_path) from xdevice import Scheduler for kit in kits: if not Scheduler.is_execute: raise ExecuteTerminate() kit.__setup__(request.config.device, request=request) execute_dir = "/".join(bin_file.split("/")[0:-1]) execute_bin = bin_file.split("/")[-1] self.config.device.execute_command_with_timeout( command="cd {}".format(execute_dir), timeout=1) command, report_path, self.has_param = get_execute_command( execute_bin, self.config.xml_output, execute_dir) self.config.device_xml_path = (self.linux_directory + report_path).replace("//", "/") self.set_file_name(request, command) self.need_download = self.is_download( request.config.testcases_path) if self.need_download and self.has_param: self.delete_device_xml(request, self.config.device_xml_path) if os.path.exists(self.result): os.remove(self.result) if request.config.testargs.get("dry_run"): self.config.dry_run = request.config.testargs.get( "dry_run")[0].lower() self.dry_run(command, request.listeners) else: self.run_cpp_test(command, request) self.generate_device_xml(request, execute_bin) device_log_file = get_device_log_file( request.config.report_path, request.config.device.__get_serial__()) with open(device_log_file, "a", encoding="UTF-8") as file_name: file_name.write(self.config.command_result) except (LiteDeviceExecuteCommandError, Exception) as exception: LOG.exception(exception) self.error_message = exception finally: LOG.info("-------------finally-----------------") self._after_command(kits, request)
def __check_config__(self, config): self.checksum_command = get_config_value("command", config, is_list=False) self.hash_file_name = get_config_value("hash_file_name", config, is_list=False) self.device_label = get_config_value("device_label", config, is_list=False) if not self.checksum_command or not self.hash_file_name or \ not self.device_label: msg = "The config for rootfs kit is invalid : checksum :{}" \ " hash_file_name:{} device_label:{}" \ .format(self.checksum_command, self.hash_file_name, self.device_label) LOG.error(msg) return TypeError(msg)
def _get_driver_config(self, json_config): xml_output = get_config_value('xml-output', json_config.get_driver(), False) if isinstance(xml_output, bool): self.config.xml_output = xml_output elif str(xml_output).lower() == "true": self.config.xml_output = True else: self.config.xml_output = False rerun = get_config_value('rerun', json_config.get_driver(), False) if isinstance(rerun, bool): self.rerun = rerun elif str(rerun).lower() == "false": self.rerun = False else: self.rerun = True
def set_up_env(request, source): if not source.endswith(".json"): source = "%s.json" % source json_config = JsonParser(source) test_args = get_config_value('xml-output', json_config.get_driver()) kits = get_kit_instances(json_config, request.config.resource_path, request.config.testcases_path) kits_copy = copy.deepcopy(kits) from xdevice import Scheduler for kit in kits: if not Scheduler.is_execute: raise ExecuteTerminate() kit.__setup__(request.config.device, request=request) return test_args, kits, kits_copy
def _reset_device(self, request, source): json_config = JsonParser(source) reset_cmd = [] kit_instances = get_kit_instances(json_config, request.config.resource_path, request.config.testcases_path) from xdevice import Scheduler for (kit_instance, kit_info) in zip(kit_instances, json_config.get_kits()): if not isinstance(kit_instance, DeployKit): continue if not self.file_name: self.file_name = get_config_value( 'burn_file', kit_info)[0].split("\\")[-1].split(".")[0] reset_cmd = kit_instance.burn_command if not Scheduler.is_execute: raise ExecuteTerminate() setup_result = kit_instance.__setup__( self.config.device.local_device) if not setup_result: raise DeviceError("set_up wifiiot failed") reset_cmd = [int(item, 16) for item in reset_cmd] return reset_cmd