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 report( self ): if self.default is None: self.default = 0 if self.secondary is None: self.secondary = 0 if self.total is None: self.total = 0 Msg.info( "Task Id: %s, Task Index: %d" % ( self.task_id, self.task_index )) my_msg = "Process Log Contains " if self.detail_flags & SummaryDetail.AnyDetail == SummaryDetail.Nothing : my_msg = "Process No Found or is Empty" else: if self.detail_flags & SummaryDetail.ForceCmd == SummaryDetail.ForceCmd : my_msg += "ForceCommand, " if self.detail_flags & SummaryDetail.ForceResult == SummaryDetail.ForceResult: my_msg += "ForceResult, " if self.detail_flags & SummaryDetail.IssCmd == SummaryDetail.IssCmd : my_msg += "IssCommand, " if self.detail_flags & SummaryDetail.IssResult == SummaryDetail.IssResult : my_msg += "IssResult, " my_msg = my_msg[:-2] # Msg.user( my_msg ) # Msg.info( "Originating Control File: %s" % ( self.parent_fctrl )) # Msg.info( "Control File Item: %s" % ( str( self.fctrl_item ))) # Msg.info( "F-Run Control File: %s" % ( self.frun_path )) Msg.dbg( "Force Ret Code: %s" % ( str( self.force_retcode ))) Msg.info( "[%s], Generate Command: %s" % ( SysUtils.ifthen( SysUtils.success( self.force_retcode ), "SUCCESS", "FAILED" ), str( self.force_cmd ))) Msg.info( "Instructions Generated - Default: %d, Secondary: %d, Total: %d" % ( self.default, self.secondary, self.total )) if self.iss_cmd is not None: if self.iss_success(): Msg.info( "[SUCCESS], ISS Command: %s" % ( str( self.iss_cmd ))) else: Msg.info( "[FAILED], ISS Command: %s" % ( str( self.iss_cmd ))) #Msg.fout( self.iss_log, "user" ) Msg.blank()
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 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)
def process(self): # Msg.dbg( "TaskController::process()") for my_ndx in range(0, self.ctrl_item.iterations): try: # my_usr_lbl = Msg.set_label( "user", "TASK-ITERATION" ) # Msg.user( "Executing Iteration #%d of %d Task: %s " % ( my_ndx + 1, self.ctrl_item.iterations, self.ctrl_item.fctrl_name )) self.process_task_list() except Exception as arg_ex: # pass Msg.error_trace() Msg.err(str(arg_ex)) Msg.blank() finally: pass
def load(self, arg_ctrl_item ): super().load( arg_ctrl_item ) # Msg.dbg( "FileController::load()" ) self.parent_fctrl = self.ctrl_item.file_path() # Msg.dbg( "File Path: %s" % ( self.parent_fctrl )) #my_content = open( self.parent_fctrl ).read() # Msg.dbg( "\n" + my_content ) try: my_content = open( self.parent_fctrl ).read() except Exception as arg_ex: Msg.err( "Message: %s, Control File Path: %s" % ( str( arg_ex ), self.parent_fctrl )) my_err_queue_item = SummaryErrorQueueItem( { "error" : arg_ex , "message": "Control File Not Found ..." , "path" : self.ctrl_item.file_path() , "type" : str( type( arg_ex )) } ) self.ctrl_item.summary().queue.enqueue( my_err_queue_item ) return False finally: pass try: my_glb, my_loc = SysUtils.exec_content( my_content ) except Exception as arg_ex: my_exc_type, my_exc_val, my_exc_tb = sys.exc_info() my_ex = arg_ex Msg.err( "Message: %s, Control File Path: %s" % ( str( arg_ex ), self.parent_fctrl)) Msg.blank() my_err_queue_item = SummaryErrorQueueItem( { "error" : arg_ex , "message": "Control File not processed..." , "path" : self.ctrl_item.file_path() , "type" : str( my_exc_type ) } ) self.ctrl_item.summary().queue.enqueue( my_err_queue_item ) return False finally: pass self.fcontrol = my_loc["control_items"] return True
def process(self): # Msg.dbg( "FileController::process()" ) # Msg.dbg( "FileController Contents: \n\"" + str( self.fcontrol ) + "\n" ) try: # Msg.lout( my_options["work-dir"], MsgLevel.dbg, "Work Director Stack" ) # a control file may iterate through to completion according to the amount set in num_runs for my_ndx in range( self.ctrl_item.iterations ): # my_usr_lbl = Msg.set_label( "user", "FILE-ITERATION" ) # Msg.user( "Executing %d of %d Iterations, Control File: %s" % ( my_ndx + 1, self.ctrl_item.iterations, self.ctrl_item.file_path() )) # Msg.set_label( "user", my_usr_lbl ) try: my_item_ndx = 0 # each item in the control set exists as a dictionary for my_item_dict in self.fcontrol: try: my_item_ndx += 1 my_usr_lbl = Msg.set_label( "user", "CTRL-FILE" ) Msg.blank( "user" ) Msg.user( "Processing Line: %s" % (str( my_item_dict ))) my_ctrl_item = ControlItem() my_ctrl_item.parent_fctrl = self.parent_fctrl my_ctrl_item.fctrl_item = str( my_item_dict ) my_item_dict[CtrlItmKeys.parent_vals], my_parent_data = self.ctrl_item.values() Msg.lout( my_parent_data, "user", "Result Parent Data" ) Msg.lout( my_item_dict , "user", "Result Item Dictionary" ) Msg.set_label( "user", my_usr_lbl ) # Msg.user( "Processing Updated Line: %s" % (str( my_item_dict )), "CTRL-FILE" ) # Msg.user( str( my_parent_data.data() ), "CTRL-FILE" ) my_ctrl_item.load( my_item_dict, my_parent_data ) my_item_type = my_ctrl_item.item_type() my_controller = None if my_item_type == ControlItemType.TaskItem: # Msg.dbg( "\nControl Item is a Control Task ..." ) my_controller = TaskController() elif my_item_type == ControlItemType.FileItem: # Msg.dbg( "\nControl Item is a Control File ..." ) my_controller = FileController() else: raise Exception( "\"" + my_fctrl_name + "\": Unknown Item Type ...\nUnable to Process ... " ) # Whew! everything is set up and ready to rock and roll, let the dogs out # my_controller.load( my_ctrl_item ) # my_controller.process() if my_controller.load( my_ctrl_item ): my_controller.process() # my_controller.load( my_ctrl_item ) # my_controller.process() # Msg.dbg( "%s: Controller Creation Complete" % ( my_ctrl_item.fctrl_name )) except TypeError as arg_ex: Msg.err( str( arg_ex )) my_err_queue_item = SummaryErrorQueueItem( { "error" : "Item #%s Contains an Invalid Type" % ( str( my_item_ndx )) , "message": arg_ex , "path" : self.ctrl_item.file_path() , "type" : str( type( arg_ex )) } ) self.ctrl_item.summary().queue.enqueue( my_err_queue_item ) Msg.blank() except FileNotFoundError as arg_ex: Msg.err( str( arg_ex )) my_err_queue_item = SummaryErrorQueueItem( { "error" : arg_ex , "message": "Control File Not Found ..." , "path" : self.ctrl_item.file_path() , "type" : str( type( arg_ex )) } ) self.ctrl_item.summary().queue.enqueue( my_err_queue_item ) Msg.blank() except Exception as arg_ex: Msg.error_trace( str(arg_ex) ) Msg.err( str(arg_ex)) Msg.blank() finally: my_controller = None my_item_dict = None except Exception as arg_ex: Msg.error_trace( "[ERROR] - " + str(arg_ex) ) Msg.err( str(arg_ex)) finally: pass finally: pass # Msg.dbg() return True
my_module = UnitTestRun(the_force_root) Msg.info("\nForce Path: %s" % (str(the_force_root))) Msg.info("Original Directory: " + my_pwd) Msg.dbg("Processing Command Line and Loading Control File") my_module.load() Msg.dbg("Directory set to %s" % (PathUtils.current_dir())) if not PathUtils.chdir(the_force_root, False): Msg.dbg( "Directory Unchanged, using the current directory for output") my_module.run() Msg.dbg("Test Completed ....\n") Msg.blank() sys.exit(40) except getopt.GetoptError as arg_ex: from force_init import force_usage Msg.error_trace("[ERROR] - " + str(arg_ex)) force_usage(UsageStr) sys.exit(41) except Exception as arg_ex: from force_init import force_usage Msg.err("[ERROR] - An Unhandled Error has Occurred during run of " + str(sys.argv[0]))
def thread_done(self): Msg.info("UnitTest_LoopThread << Execute Done .... ") Msg.blank()
def __exit__(self, type, value, traceback): self.process_result() Msg.blank()