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(self):
# Msg.dbg( "ExecuteController::process()")
# my_usr_lbl = Msg.set_label( "user", "EXEC-VALS" )
# Msg.lout( self.ctrl_item.catalougs(), "user", "Control Item Cataloug" )
my_task_file = PathUtils.include_trailing_path_delimiter(
self.ctrl_item.parent_data.test_root)
my_task_file += PathUtils.include_trailing_path_delimiter(
self.ctrl_item.fctrl_dir)
my_task_file += self.ctrl_item.fctrl_name
my_tmp, my_task_ndx = PathUtils.split_path(self.ctrl_item.fctrl_dir)
my_task_name = self.ctrl_item.fctrl_name.replace(".py", "")
# Msg.user( "Task File: %s, Task Name: %s, Task Index: %s" % ( my_task_file, my_task_name, my_task_ndx ) )
self.process_task_file(my_task_file, my_task_name, my_task_ndx)
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 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 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 extract_iss_data(self, arg_item_dict):
# first get the iss dictionary
# Msg.lout( arg_item_dict, "user", "RAW Item Dictionary ..." )
my_iss_data = arg_item_dict.get(CtrlItmKeys.iss, CtrlItmDefs.iss)
my_iss_path = my_iss_data.get(CtrlItmKeys.iss_path, None)
if my_iss_path is not None:
# if the iss path was not specified then the iss path currently in the parent data instance is the correct one
Msg.dbg("Iss Path: %s, Test Root: %s" %
(my_iss_path, self.parent_data.test_root))
# check to see if path is absolute path
if not SysUtils.found(my_iss_path.find(
self.parent_data.test_root)):
Msg.dbg("Test Root Not Found ...")
# if not then prepend the test root
my_iss_path = PathUtils.include_trailing_path_delimiter(
self.parent_data.test_root
) + PathUtils.exclude_leading_path_delimiter(my_iss_path)
self.parent_data.update_iss_path(my_iss_path)
Msg.dbg("Final Iss Path: %s" % (self.parent_data.iss_path))
def resolve_file_location(self):
my_fctrl_dir, self.fctrl_name = PathUtils.split_path(
str(self.fctrl_name))
Msg.user(
"Extracted File Path: %s, Control File Path: %s, Extracted File Name: %s"
% (str(my_fctrl_dir), str(self.fctrl_dir), str(self.fctrl_name)),
"FCTRL-DIR")
Msg.user(
"1 - Control Directory: %s, Force Directory: %s, Test Root: %s, Work Dir: %s, Control File: %s, self.fctrl_dir: %s"
% (my_fctrl_dir, self.parent_data.force_path,
self.parent_data.test_root, self.parent_data.work_dir,
self.fctrl_name, self.fctrl_dir), "FCTRL-DIR")
# if the name does not contain a path use the contol directory
if my_fctrl_dir is None:
my_fctrl_dir = self.fctrl_dir
Msg.user(
"Control Directory: %s, Force Directory: %s, Test Root: %s, Work Dir: %s, Control File: %s"
% (my_fctrl_dir, self.parent_data.force_path,
self.parent_data.test_root, self.parent_data.work_dir,
self.fctrl_name), "FCTRL-DIR")
# because of the requirement of not knowing and needing to discover the directory
# situation it is necessary to search for the control file
my_tmp = None
my_tmp_dir = None
# if the a directory was specified in the control name or a specifies as part of the control item it is
# necessary to check for either a absolute path or relative parent path
# Msg.dbg( "Checking: [%s] for [%s]" % ( my_fctrl_dir, self.fctrl_name ))
if my_fctrl_dir is None:
raise Exception(
"Control File Location was not specified, File[%s]" %
(self.fctrl_name))
if self.check_full_path(my_fctrl_dir):
Msg.user("Using Real Path as Control Directory", "FILE_LOCATION")
pass
elif self.check_parent_dir(my_fctrl_dir):
Msg.user("Using Parent Directory as Control Directory",
"FILE_LOCATION")
pass
elif self.check_work_dir(my_fctrl_dir):
Msg.user(
"Using Current Control File Location as Control Directory",
"FILE_LOCATION")
pass
elif self.check_ctrl_dir(my_fctrl_dir):
Msg.user("Using Specified Control Directory as Control Directory",
"FILE_LOCATION")
pass
else:
if self.item_type() == ControlItemType.TaskItem:
my_err_queue_item = SummaryErrorQueueItem({
"error":
"Template Not Found at Specified Location",
"message":
"Template File Not Found ...",
"path":
self.file_path(),
"type":
str("FileNotFoundError")
})
self.summary().queue.enqueue(my_err_queue_item)
elif self.item_type() == ControlItemType.FileItem:
my_err_queue_item = SummaryErrorQueueItem({
"error":
"FileNotFoundError",
"message":
"Control File Not Found at Specified Location",
"path":
self.file_path(),
"type":
str("FileNotFoundError")
})
self.summary().queue.enqueue(my_err_queue_item)
raise Exception("File[%s] Not Found at Location Specified[%s]" %
(self.fctrl_name, my_fctrl_dir))
# Msg.dbg( "Raw Control Directory: %s" % ( self.fctrl_dir ))
# Msg.dbg( "Test Root: %s" % ( self.test_root ))
# remove the test root if present
if SysUtils.found(self.fctrl_dir.find(self.parent_data.test_root)):
# Msg.dbg( "Test Root Found" )
self.fctrl_dir = self.fctrl_dir.replace(self.parent_data.test_root,
"")
# Msg.dbg( "Trimmed Control Directory: %s" % ( self.fctrl_dir ))
# add the trailing path delimiter
self.fctrl_dir = PathUtils.include_trailing_path_delimiter(
self.fctrl_dir)
Msg.user("Delimited Control Directory: %s" % (self.fctrl_dir),
"FILE_LOCATION")
return True
def file_path(self):
return "%s%s%s" % (self.parent_data.test_root,
PathUtils.include_trailing_path_delimiter(
self.fctrl_dir), self.fctrl_name)
def load_force_log(self, arg_seed_only=False):
self.default = None
self.secondary = None
self.total = None
self.seed = None
self.task_path = PathUtils.include_trailing_path_delimiter(
self.work_dir)
my_glog = "%s%s" % (self.task_path, self.force_log)
Msg.dbg("Path: %s" % my_glog)
# Msg.user( "Opening Generator Log File: %s" % ( my_glog ))
with open(my_glog, "r") as my_flog:
try:
for my_line in my_flog:
if SysUtils.found(
my_line.find("Secondary Instructions Generated")):
# my_secondary = my_line.replace( "[notice]Secondary Instructions Generated:", "" ).strip()
# self.secondary = int( my_secondary )
my_lpos = my_line.find(':')
my_count = int(my_line[my_lpos + 2:].strip())
# Msg.user( "Secondary Instructions: %d" % ( my_count ))
self.secondary = my_count
elif SysUtils.found(
my_line.find("Default Instructions Generated")):
# my_pos = my_line.find( ":" ) + 2
# my_default = my_line[ my_pos: ].strip()
# get the count for this instruction type
my_lpos = my_line.find(':')
my_count = int(my_line[my_lpos + 2:].strip())
# Msg.user( "Default Instructions: %d" % ( my_count ))
self.default = my_count
# my_default = my_line.replace( "[notice]Default Instructions Generated:", "" ).strip()
# self.default = int( my_default )
if SysUtils.found(
my_line.find("Total Instructions Generated")):
self.total = int(
my_line.replace(
"[notice]Total Instructions Generated: ",
"").strip())
my_lpos = my_line.find(':')
my_count = int(my_line[my_lpos + 2:].strip())
# Msg.user( "Total Instructions: %d" % ( my_count ))
self.total = my_count
if SysUtils.found(my_line.find("Initial seed")):
self.seed = my_line.replace("[notice]", "").replace(
"Initial seed = ", "").strip()
# Msg.dbg( "Seed: %s" % ( self.seed ))
# for simulation only the seed is needed
if arg_seed_only:
break
if not (self.seed is None or self.total is None
or self.secondary is None or self.default is None):
break
except Exception as arg_ex:
# NOTE: Determine the possible errors and handle accordingly, for now just keep processing
Msg.error_trace()
Msg.err(str(arg_ex))
finally:
my_flog.close()