def set_current_test(self, arg_test_id, arg_test_log, arg_sim_cmd): Msg.dbg("RegressionSummary:: set_current_test( %s, %s, %s " % (str(arg_test_id), str(arg_test_log), str(arg_sim_cmd))) self.curr_test_id = arg_test_id self.curr_test_log = arg_test_log self.sim_cmd = arg_sim_cmd
def populate(self, arg_dict): self.work_dir = arg_dict[CtrlItmKeys.fdir] #Msg.trace() Msg.user("self.work_dir: %s" % (self.work_dir), "ParentData::populate()") self.test_root = arg_dict[CtrlItmKeys.test_root] self.mode = arg_dict[CtrlItmKeys.mode] self.force_path = arg_dict[CtrlItmKeys.force_path] self.action = arg_dict[CtrlItmKeys.action] self.process_queue = arg_dict[CtrlItmKeys.process_queue] self.force_cmd = arg_dict[CtrlItmKeys.force_cmd] self.process_max = arg_dict.get(CtrlItmKeys.process_max, CtrlItmDefs.process_max) self.iss_path = arg_dict.get(CtrlItmKeys.iss_path, CtrlItmDefs.iss_path) if not SysUtils.found(self.iss_path.find(self.test_root)): # Msg.user( "Test Root Not Found ..." ) # if not then prepend the test root self.iss_path = PathUtils.include_trailing_path_delimiter( self.test_root) + PathUtils.exclude_leading_path_delimiter( self.iss_path) Msg.user("Final Iss Path: %s" % (self.iss_path), "ISS_PATH") self.timeout = arg_dict.get(CtrlItmKeys.timeout, CtrlItmDefs.timeout) return self
def process_group_items( self, arg_ofile, arg_items ): # Msg.trace("PerformanceSummaryItem::process_group_items") my_grp_count = 0 my_grp_elapsed = 0 try: for my_item in arg_items: my_item_elapsed = my_item.force_end - my_item.force_start my_item_count = my_item.total my_grp_elapsed += my_item_elapsed my_grp_count += my_item_count my_line = "\nTask: %s, Instructions: %d, Elapsed: %0.3f\n" % ( my_item.task_id, my_item_count, my_item_elapsed ) arg_ofile.write( my_line ) # Msg.dbg( my_line ) #end: for my_task in my_group["tasks"]: except Exception as arg_ex: Msg.error_trace() Msg.err( "Error Processing Summary, Reason: %s" % ( str( arg_ex ) )) return my_grp_count, my_grp_elapsed
def process_groups( self, arg_ofile ): my_total_count = 0 my_total_elapsed = 0 my_groups = self.groups.task_groups(); # Msg.trace("PerformanceSummaryItem::process_groups") for my_group, my_items in my_groups.items(): try: my_str = "\nBegin Group: %s\n" % ( my_group ) arg_ofile.write( my_str ) Msg.blank( "info" ) Msg.info( my_str ) my_grp_count, my_grp_elapsed = self.process_group_items( arg_ofile, my_items ) my_total_count += my_grp_count my_total_elapsed += my_grp_elapsed my_line = "\nGroup Instructions: %3d\n" % ( my_grp_count ) my_line += "Group Elapsed Time: %0.3f\n" % ( my_grp_elapsed ) my_line += "Group Instructions per Second: %0.3f\n" % ( SysUtils.ifthen( bool( my_grp_elapsed ), my_grp_count / my_grp_elapsed, 0 )) my_line += "End Group: %s\n" % ( my_group ) Msg.info( my_line ) arg_ofile.write( my_line ) except Exception as arg_ex: Msg.error_trace() Msg.err( "Unable to process, Group: %s, Reason: %s" % ( my_group, type( arg_ex ))) return my_total_count, my_total_elapsed
def process_summary( self, sum_level = SummaryLevel.Fail ): my_file_name = "%sperformance_summary.log" % ( PathUtils().include_trailing_path_delimiter( self.summary_dir )) Msg.dbg( "Master Log File: %s" % ( my_file_name )) my_utcdt = DateTime.UTCNow() my_ofile = None try: # First try to open file with open( my_file_name, "w" ) as my_ofile: my_ofile.write( "Date: %s\n" % ( DateTime.DateAsStr( my_utcdt ))) my_ofile.write( "Time: %s\n" % ( DateTime.TimeAsStr( my_utcdt ))) self.process_errors( my_ofile ) my_total_count, my_total_elapsed = self.process_groups( my_ofile ) Msg.blank( "info" ) my_line = "Total Instructions Generated: %3d\n" % ( my_total_count ) my_line += "Total Elapsed Time: %0.3f\n" % ( my_total_elapsed ) my_line += "Overall Instructions per Second: %0.3f\n" % ( SysUtils.ifthen( bool( my_total_elapsed ), my_total_count / my_total_elapsed, 0 )) Msg.info( my_line ) my_ofile.write( my_line ) except Exception as arg_ex: Msg.error_trace() Msg.err( "Error Processing Summary, " + str( arg_ex ) ) finally: my_ofile.close()
def initialize_sim(self): # Msg.dbg( "ExecuteController::initialize_sim()") if not self.ctrl_item.no_sim: my_tmlog = "iss.railhouse" #arg_testname.replace( ".py", ".log" ) self.sim_log = "iss_sim.log" self.sim_cmd = "%s -T %s -C %s -i %d --exit_loop=%d" % ( self.ctrl_item.parent_data.iss_path, my_tmlog, self.ctrl_item.num_cores, self.ctrl_item.max_instr, self.ctrl_item.exit_loop) if not self.ctrl_item.iss is None and type( self.ctrl_item.iss) is dict: for my_key in self.ctrl_item.iss.keys(): if not my_key == CtrlItmKeys.iss_path: Msg.user("sim_cmd: %s, key: %s " % (str(self.sim_cmd), str(my_key))) self.sim_cmd += " %s %s" % ( str(my_key), SysUtils.ifthen( self.ctrl_item.iss[my_key] is None, "", str(self.ctrl_item.iss[my_key]))) self.sim_cmd += "%s%s" #
def run(self): Msg.dbg("ThreadTestRun::run()") with UnitTest_HiThread(): pass with UnitTest_HiEvent(): pass with UnitTest_HiMutex(): pass
def init_thread( self ): Msg.info( "HiEvent: Creating Test Thread ..." ) myThreadProcs = { "on-start" : self.thread_start # start thread sequence (outside thread space) , "on-execute" : self.thread_execute # thread termination handler (inside thread space) , "on-done" : self.thread_done # thread terminated handler (outside thread space) , "on-finished": self.thread_finished # thread before finished handler (inside thread space) } self.thread = ThreadFactory( "EventTestThread", True, myThreadProcs )
def process_errors(self, arg_ofile): if len(self.errors) > 0: arg_ofile.write("\n") Msg.blank() for my_eitem in self.errors: my_err_line = str(my_eitem.get_err_line()) Msg.info(my_err_line) arg_ofile.write("%s\n" % (my_err_line))
def load_iss_result(self, arg_dict): # Msg.lout( arg_dict, "user", "ISS Results Dictionary ... " ) self.iss_log = arg_dict["iss-log"] try: self.iss_retcode = int(arg_dict["iss-retcode"]) except: self.iss_retcode = -1 Msg.err("ISS Return Code in unrecognizable format")
def run_test(self): Msg.info("HiThread(Loop): Start Unit Test ... ") myThreadProcs = { "on-start": self.thread_start # start thread sequence (outside thread space) , "on-execute": self. thread_execute # thread termination handler (inside thread space) , "on-finished": self. thread_finished # thread before finished handler (inside thread space) , "on-done": self. thread_done # thread terminated handler (outside thread space) } myThreadOpts = { "heartbeat-rate": 2, "sleep-period": 100, "daemon": False # run once threads should not be daemons , "active": False # do not start the thread until ready } Msg.info("UnitTest_LoopThread << Creating Thread With Loop... ") myThread = ThreadFactory("LoopThread", False, myThreadProcs, myThreadOpts) Msg.info("UnitTest_LoopThread << Initializing Thread ... ") myThread.start_thread() # wait for thread to terminate myThread.wait_for() Msg.info("UnitTest_LoopThread >> Thread Completed ... ")
def run_test(self): Msg.info("HiThread(NoLoop): Start Unit Test ... ") myThreadProcs = { "on-start": self.thread_start # start thread sequence (outside thread space) , "on-execute": self. thread_execute # thread termination handler (inside thread space) , "on-finished": self. thread_finished # thread before finished handler (inside thread space) , "on-done": self. thread_done # thread terminated handler (outside thread space) } Msg.info("UnitTest_NoLoopThread >> Creating NoLoop Thread ... ") myThread = ThreadFactory("NoLoopThread", True, myThreadProcs) Msg.info("UnitTest_NoLoopThread >> Initializing Thread ... ") myThread.start_thread() # wait for thread to terminate myThread.wait_for() Msg.info("UnitTest_NoLoopThread >> Thread Completed ... ")
def commit_generate( self ): self.force_result = SysUtils.ifthen( SysUtils.success( self.force_retcode ), "PASS", "FAIL" ) self.force_level = SummaryLevel.Any if SysUtils.failed( self.force_retcode ): self.force_level = SummaryLevel.Fail Msg.lout( self, "user" , "Performance Summary Item Commit Generate" ) if SysUtils.success( self.force_retcode ): self.instruction_counts( ) Msg.info( "Instructions: %d, Default: %d, Secondary: %d, Elapsed Time: %0.5f Seconds\n\n" % ( self.count, self.default, self.secondary, self.force_end - self.force_start )) return 1 return 0
def run(self): # Block on process queue while we have threads running and stuff to do # == Replaced ==>> while True: # == Replaced ==>> # Pop off the top of the process queue (should block if the queue is empty) # == Replaced ==>> try: # == Replaced ==>> next_item = self.summary_queue.dequeue(0) # == Replaced ==>> except TimeoutError: # == Replaced ==>> if (workers_done_event.isSet()): # == Replaced ==>> summary_done_event.Signal() # == Replaced ==>> return # == Replaced ==>> else: # == Replaced ==>> self.HeartBeat() # == Replaced ==>> continue # == Replaced ==>> my_item = self.summary.create_summary_item() # == Replaced ==>> my_item.load( next_item ) # == Replaced ==>> self.summary.commit_item( my_item ) # == Replaced ==>> next_item = None try: while True: #not workers_done_event.isSet(): # Pop off the top of the process queue (should block if the queue is empty) try: # my_item = self.summary.create_summary_item() # my_qitem = self.summary_queue.dequeue(0) # my_item.load( my_qitem ) # self.summary.commit_item( my_item ) # my_qitem = None # my_qitem = self.summary_queue.dequeue(0) my_qitem = self.summary_queue.dequeue(0) if isinstance(my_qitem, SummaryErrorQueueItem): Msg.user(str(my_qitem.error_info), "SUMMARY_ERROR") my_eitem = SummaryErrorItem() my_eitem.load(my_qitem) self.summary.commit_error_item(my_eitem) else: my_item = self.summary.create_summary_item() my_item.load(my_qitem) self.summary.commit_item(my_item) my_qitem = None except TimeoutError as arg_ex: # {{{TODO}}} Implement proper heartbeat # Msg.dbg( str( arg_ex ) ) if (workers_done_event.isSet()): break else: self.HeartBeat() continue except Exception as arg_ex: Msg.error_trace() Msg.err(str(arg_ex)) raise except: Msg.error_trace() raise finally: summary_done_event.Signal()
def write_control_file(self, arg_frun_file, arg_content): #arg_filename = "_def_frun.py" with open(arg_frun_file, "w") as my_ofile: try: return (my_ofile.write(arg_content) > 0) except Exception as arg_ex: Msg.error_trace() Msg.err("Error Writing Control File, " + str(arg_ex)) # reraise exception to prevent creating tasks in queue if the control file cannot be written finally: my_ofile.close() return False
def load_gen_result(self, arg_dict): # Msg.lout( arg_dict, "dbg", "Generate Results Dictionary ... " ) try: self.force_retcode = int(str(arg_dict["force-retcode"]).strip()) except: self.force_retcode = -1 Msg.err("Generate Return Code in unrecognizable format") self.force_stdout = arg_dict["force-stdout"] self.force_stderr = arg_dict["force-stderr"] if SysUtils.failed(self.force_retcode): self.force_level = SummaryLevel.Fail self.force_start = float(arg_dict.get("force-start", 0.00)) self.force_end = float(arg_dict.get("force-end", 0.00))
def load_force_elog( self ): self.force_msg = None my_elog = "%s%s" % ( PathUtils.include_trailing_path_delimiter( self.work_dir ), self.force_elog ) # Msg.dbg( my_elog ) if SysUtils.failed( self.force_retcode ): Msg.fout( my_elog, "dbg" ) with open( my_elog , "r" ) as my_flog: try: for my_line in my_flog: if SysUtils.found( my_line.find( "[fail]" )): self.force_msg = my_line.replace( "[fail]", "" ).strip() # Msg.dbg( "Message: %s" % ( str( self.force_msg ))) break finally: my_flog.close()
def check_full_path(self, arg_fctrl_dir): # handle fully qualified path if found Msg.dbg("Checking for control file with real path[%s][%s]" % (str(arg_fctrl_dir), str(self.fctrl_name))) if arg_fctrl_dir.startswith("/"): # there is only one scenario where the control directory starts with the path delimiter and that is the path # is a real path from the root directory of the system, the control file must exist at that location if PathUtils.check_found( PathUtils.append_path(arg_fctrl_dir, self.fctrl_name)): self.fctrl_dir = arg_fctrl_dir return True raise Exception( "Control Item File: [%s] count not be located Not Found at [%s]" % (self.fctrl_name, arg_fctrl_dir)) return False
def load_item_values(self, arg_item_dict): my_options = arg_item_dict.get(CtrlItmKeys.options, CtrlItmDefs.options) my_parent_vals = arg_item_dict.get(CtrlItmKeys.parent_vals, {}) Msg.lout(my_parent_vals, "dbg", "Parent Values from Control Item") Msg.lout(self.parent_data, "dbg", "Persistent Data") # Control File Location self.fctrl_dir = my_options.get( CtrlItmKeys.fdir, SysUtils.ifthen(self.parent_data.work_dir is None, CtrlItmDefs.fctrl_dir, self.parent_data.work_dir)) # Populated from control item options self.iterations = my_options.get(CtrlItmKeys.iterations, CtrlItmDefs.iterations) # Populated from control item options or parent self.exit_loop = my_options.get( CtrlItmKeys.exit_loop, my_parent_vals.get(CtrlItmKeys.exit_loop, CtrlItmDefs.exit_loop)) self.group = my_options.get( CtrlItmKeys.group, my_parent_vals.get(CtrlItmKeys.group, CtrlItmDefs.group)) self.min_instr = my_options.get( CtrlItmKeys.min_instr, my_parent_vals.get(CtrlItmKeys.min_instr, CtrlItmDefs.min_instr)) self.max_instr = my_options.get( CtrlItmKeys.max_instr, my_parent_vals.get(CtrlItmKeys.max_instr, CtrlItmDefs.max_instr)) self.num_cores = my_options.get( CtrlItmKeys.num_cores, my_parent_vals.get(CtrlItmKeys.num_cores, CtrlItmDefs.num_cores)) self.no_asm = my_options.get( CtrlItmKeys.no_asm, my_parent_vals.get(CtrlItmKeys.no_asm, CtrlItmDefs.no_asm)) self.no_sim = my_options.get( CtrlItmKeys.no_sim, my_parent_vals.get(CtrlItmKeys.no_sim, CtrlItmDefs.no_sim)) self.timeout = my_options.get( CtrlItmKeys.timeout, my_parent_vals.get(CtrlItmKeys.timeout, CtrlItmDefs.timeout))
def commit_simulate( self ): self.instr_count, self.iss_message = self.extract_iss_info() Msg.user( "Instr Count: %d, Message: %s" % (self.instr_count, self.iss_message )) try: # check the return code for error if SysUtils.success( self.iss_retcode ): # Check to see for instruction overrun if int( self.instr_count ) < self.max_instr: if int( self.instr_count ) >= self.min_instr: self.iss_result = "PASS" self.iss_level = SummaryLevel.Any return 1 self.iss_result = "FAIL" self.iss_level = SummaryLevel.Fail return 0 finally: pass
def load_process_info(self, arg_process_info): # update the user label and send iteration message to the screen if user is active # my_usr_lbl = Msg.set_label( "user", "PROCESS-RESULT" ) # Msg.user( "Executing Iteration #%d of Test File: %s" % ( my_ndx + 1, arg_task_file )) Msg.dbg("self.process_result: (%s)" % (str(arg_process_info.get("process-result", None)))) # Msg.set_label( "user", my_usr_lbl ) self.process_cmd = arg_process_info.get("process-cmd", None) self.process_log = arg_process_info.get("process-log", None) self.process_result = arg_process_info.get("process-result", None) self.frun_path = arg_process_info.get("frun-path", None) self.parent_fctrl = arg_process_info.get("parent-fctrl", None) self.fctrl_item = arg_process_info.get("fctrl-item", None) self.item_group = arg_process_info.get("item-group", None) self.fctrl_content = arg_process_info.get("content", None) self.detail_flags = SummaryDetail.Nothing
def instruction_counts( self ): my_lines = None my_glog = "%s%s" % ( PathUtils.include_trailing_path_delimiter( self.work_dir ), self.force_log ) Msg.user("Path: %s" % my_glog) with open( my_glog, "r" ) as my_log: my_lines = my_log.readlines() Msg.dbg( "Line %d: %s" % ( len( my_lines ), my_lines[-1])) my_log.close() try: my_results = [ my_tmp for my_tmp in my_lines if re.search( ' Instructions Generated', my_tmp )] Msg.lout( my_results, "dbg" ) if not my_results: raise Exception( "Instruction Count Not Found in \"gen.log\"" ) # ok there are instruction counts located for my_line in my_results: my_line = my_line.strip() # find the instruction type (Total, Default, Secondary) my_lpos = my_line.find(']') my_rpos = my_line.find( "Instr" ) my_type = PerformanceInstructionType.instruction_type(( my_line[my_lpos + 1 : my_rpos - 1 ]).strip()) # get the count for this instruction type my_lpos = my_line.find( ':' ) my_count = int( my_line[my_lpos+2:].strip()) if my_type == PerformanceInstructionType.Total: self.count = my_count elif my_type == PerformanceInstructionType.Secondary: self.secondary = my_count elif my_type == PerformanceInstructionType.Default: self.default = my_count except ValueError: Msg.error_trace() Msg.err( "Unable to extract instruction count from %s" % ( int( my_lines[-1] ))) return 0
def process_task(self, arg_task_file): try: # get the subdirectory index my_ndx = int(PathUtils.next_subdir()) # update the user label and send iteration message to the screen if user is active # my_usr_lbl = Msg.set_label( "user", "TEST-ITERATION" ) # Msg.user( "Executing Iteration #%d of Test File: %s" % ( my_ndx + 1, arg_task_file )) # Msg.set_label( "user", my_usr_lbl ) # create subdirectory and change into it PathUtils.chdir("%05d" % my_ndx, True) # save the task template file name with path to the control item self.ctrl_item.fname = arg_task_file # write out the control file # if the write was successful then enqueue the new control file name with real path my_ctrl_file = "%s_def_frun.py" % ( PathUtils.include_trailing_path_delimiter( PathUtils.current_dir())) PathUtils.touch("%sSTARTED" % PathUtils.include_trailing_path_delimiter( PathUtils.current_dir())) my_content = self.prepare(arg_task_file) if self.write_control_file(my_ctrl_file, my_content): # my_queue_item = ProcessQueueItem( my_ctrl_file, self.ctrl_item.parent_fctrl, self.ctrl_item.fctrl_item, self.ctrl_item.group, my_content ) my_queue_item = ProcessQueueItem( my_ctrl_file, self.ctrl_item, my_content ) # self.parent_fctrl, self.ctrl_item.fctrl_item, self.ctrl_item.group) self.ctrl_item.parent_data.process_queue.enqueue(my_queue_item) except Exception as arg_ex: Msg.error_trace() Msg.err(str(arg_ex)) # reraise to prevent adding to summary instance raise finally: PathUtils.chdir("..")
def check_work_dir(self, arg_fctrl_dir): # check the work directory Msg.dbg( "Checking for control file using implict path[%s] of current control file" % (str(arg_fctrl_dir))) if not self.parent_data.work_dir is None: my_tmp_dir = PathUtils.append_path(self.parent_data.work_dir, arg_fctrl_dir) if not SysUtils.found(my_tmp_dir.find(self.parent_data.test_root)): # Prepend the test_root on the work directory my_tmp_dir = PathUtils.append_path(self.parent_data.test_root, my_tmp_dir) if PathUtils.check_found( PathUtils.append_path(my_tmp_dir, self.fctrl_name)): self.fctrl_dir = my_tmp_dir # Msg.dbg( "Using Control File Directory: %s" % ( self.fctrl_dir )) return True return False
def extract_results(self, arg_result, arg_cmd, arg_log, arg_process_item, arg_start_time, arg_end_time): Msg.dbg("Return Code %s, Command Line: |%s|, Log File: %s" % (str(arg_result), arg_cmd, arg_log)) #Msg.fout( arg_log, "info" ) my_summary_item = SummaryQueueItem({ "process-cmd": arg_cmd, "process-log": arg_log, "process-result": arg_result, "frun-path": arg_process_item.frun_path, "parent-fctrl": arg_process_item.parent_fctrl, "fctrl-item": arg_process_item.fctrl_item, "item-group": arg_process_item.item_group, "content": arg_process_item.content, "start-time": arg_start_time, "end-time": arg_end_time }) while (self.summary.queue.enqueue(my_summary_item) == False): self.HeartBeat() pass
def execute(self): Msg.info("LoopThread::execute() => Enter ") for i in range(3): Msg.info("Thread Work: %d:%d" % (self.max_loops, i + 1)) self.check_finished() self.heartbeat() Msg.info("LoopThread::execute() => Leave")
def load(self, arg_queue_item): try: # my_usr_lbl = Msg.set_label( "user", "SUMMARY_ITEM" ) self.load_process_info(arg_queue_item.process_info) # Msg.lout( self, "user", "Summary Item(load_process_info)" ) self.load_task_info() # Msg.lout( self, "user", "Summary Item(load_task_info)" ) self.load_process_log() # Msg.lout( self, "user", "Summary Item(load_process_log)" ) self.load_force_log() # Msg.lout( self, "user", "Summary Item(load_force_log)" ) self.load_force_elog() # Msg.lout( self, "user", "Summary Item(load_force_elog)" ) self.prepare() self.report() # Msg.set_label( "user", my_usr_lbl ) except Exception as arg_ex: Msg.error_trace() Msg.err(str(arg_ex)) except: Msg.error_trace()
def exec_iss(self, arg_task_name): # Msg.dbg( "ExecuteController::exec_iss( %s )" % ( arg_task_name ) ) # build rest of command for iss my_elf = "%s.Default.ELF" % (arg_task_name) # Msg.dbg( "Looking For: %s" % ( my_elf )) my_elf = SysUtils.ifthen(PathUtils.check_file(my_elf), " %s" % my_elf, "") # Msg.dbg( "Using ELF: %s" % ( my_elf )) my_elfns = "%s.Secondary.ELF" % (arg_task_name) # Msg.dbg( "Looking For: %s" % ( my_elfns )) my_elfns = SysUtils.ifthen(PathUtils.check_file(my_elfns), " %s" % my_elfns, "") my_cmd = self.sim_cmd % (my_elf, my_elfns) try: # execute the simulation Msg.info("ISSCommand = " + str({"iss-command": my_cmd})) my_log = self.sim_log my_elog = self.sim_log #my_ret_code = int( SysUtils.exec_cmd( my_cmd ) ) my_result = SysUtils.exec_process(my_cmd, my_log, my_elog, self.ctrl_item.timeout, True) my_ret_code = int(my_result[0]) my_std_out = str(my_result[1]) my_std_err = str(my_result[2]) my_start = str(my_result[3]) my_end = str(my_result[4]) Msg.info("ISSResult = " + str({ "iss-retcode": my_ret_code, "iss-log": self.sim_log, "iss-stdout": my_std_out, "iss-stderr": my_std_err, "iss-start": my_start, "iss-end": my_end })) except Exception as arg_ex: Msg.error_trace("ISS Execute Failure") Msg.err("ISS did not properly execute, Reason: %s" % (str(arg_ex))) return False return True
def with_test( self ): # create a mutex my_mutex = HiMutex( "with_mutex" ) # Msg.info( "Before With: Mutex[%s] is %s" % ( my_mutex.name, SysUtils.ifthen( my_mutex.locked(), "Locked", "Unlocked" ))) Msg.info( "Before With: Mutex[%s]" % ( my_mutex.name )) with my_mutex : Msg.info( "In With: Mutex[%s]" % ( my_mutex.name )) # Msg.info( "In With: Mutex[%s] is %s" % ( my_mutex.name, SysUtils.ifthen( my_mutex.locked(), "Locked", "Unlocked" ))) Msg.info( "After With: Mutex[%s]" % ( my_mutex.name ))
def process_task_list(self): for my_task_file in self.task_list: # Msg.dbg( "Process Task File: %s" % ( my_task_file )) my_curdir = PathUtils.current_dir() try: # self.process_task_file( my_task_file ) self.process_task_file(my_task_file) except Exception as arg_ex: Msg.error_trace() Msg.err(str(arg_ex)) Msg.blank() finally: PathUtils.chdir(my_curdir)