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 check_parent_dir(self, arg_fctrl_dir):
Msg.dbg("Checking for control file in parent directory")
Msg.user(
"Test Root[%s], Work Dir[%s]" %
(str(self.parent_data.test_root), str(self.parent_data.work_dir)),
"CHECK-PARENT-DIR")
if arg_fctrl_dir.startswith(".."):
my_search_dir = arg_fctrl_dir
my_work_dir = PathUtils.append_path(self.parent_data.test_root,
self.parent_data.work_dir)
my_test_root = self.parent_data.test_root
Msg.user(
"Updated Test Root[%s], Full Work Dir[%s], Search Dir[%s]" %
(my_test_root, my_work_dir, my_search_dir), "CHECK-PARENT-DIR")
while my_search_dir.startswith(".."):
# First get the parent directory
# The search [updated] directory started with [..] split path for both the work directory and the search directory
# this fact that the [updated] search directory still begins with a [..], means that the work directory
my_test_root, my_dumy = PathUtils.split_dir(my_test_root)
my_work_dir, my_dumy = PathUtils.split_dir(my_work_dir)
my_search_dir = my_search_dir[3:]
Msg.user(
"Updated Test Root[%s], Full Work Dir[%s], Search Dir[%s]"
% (my_test_root, my_work_dir, my_search_dir),
"CHECK-PARENT-DIR")
my_filepath = str(
PathUtils.append_path(
my_work_dir,
PathUtils.append_path(my_search_dir, self.fctrl_name)))
Msg.user("File Path[%s] ... " % (my_filepath),
"CHECK-PARENT-DIR")
if PathUtils.check_found(my_filepath):
self.fctrl_dir = PathUtils.append_path(
my_work_dir, my_search_dir)
return True
my_filepath = str(
PathUtils.append_path(
my_test_root,
PathUtils.append_path(my_search_dir, self.fctrl_name)))
Msg.user("File Path[%s] ... " % (my_filepath),
"CHECK-PARENT-DIR")
if PathUtils.check_found(my_filepath):
self.fctrl_dir = PathUtils.append_path(
my_test_root, my_search_dir)
return True
raise Exception(
"Control Item File[%s] Not Found in Parent Directory: [%s]" %
(self.fctrl_name, arg_fctrl_dir))
return False
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):
# 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 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 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 check_ctrl_dir(self, arg_fctrl_dir):
Msg.user(
"Checking for control file at relative path[%s] from test root" %
(arg_fctrl_dir), "RELATIVE PATH")
my_tmp_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
Msg.user("Building Control Directory ...", "RELATIVE PATH")
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.user("Setting Control Directory: %s ..." % (self.fctrl_dir),
"RELATIVE PATH")
return True
return False
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
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
