import time
import csv
import shutil
+import itertools
+import re
import paramiko
import src
STYLESHEET_GLOBAL = "jobs_global_report.xsl"
STYLESHEET_BOARD = "jobs_board_report.xsl"
-d_INT_DAY = {0 : "monday",
- 1 : "tuesday",
- 2 : "wednesday",
- 3 : "thursday",
- 4 : "friday",
- 5 : "saturday",
- 6 : "sunday"}
+
+DAYS_SEPARATOR = ","
+CSV_DELIMITER = ";"
parser = src.options.Options()
-parser.add_option('j', 'jobs_config', 'string', 'jobs_cfg',
- _('The name of the config file that contains'
+parser.add_option('n', 'name', 'string', 'jobs_cfg',
+ _('Mandatory: The name of the config file that contains'
' the jobs configuration'))
parser.add_option('o', 'only_jobs', 'list2', 'only_jobs',
_('Optional: the list of jobs to launch, by their name. '))
_("Optional: generate an xml file that can be read in a "
"browser to display the jobs status."),
False)
-parser.add_option('i', 'input_boards', 'list2', 'input_boards', _("Optional: "
- "the list of path to csv files that contain "
- "the expected boards."),[])
-parser.add_option('n', 'completion', 'boolean', 'no_label',
+parser.add_option('i', 'input_boards', 'string', 'input_boards', _("Optional: "
+ "the path to csv file that contain "
+ "the expected boards."),"")
+parser.add_option('', 'completion', 'boolean', 'no_label',
_("Optional (internal use): do not print labels, Works only "
"with --list."),
False)
self.put_dir(sat_local_path, self.sat_path, filters = ['.git'])
# put the job configuration file in order to make it reachable
# on the remote machine
- job_file_name = os.path.basename(job_file)
+ remote_job_file_name = ".%s" % os.path.basename(job_file)
self.sftp.put(job_file, os.path.join(self.sat_path,
- "data",
- "jobs",
- job_file_name))
+ remote_job_file_name))
except Exception as e:
res = str(e)
self._connection_successful = False
class Job(object):
'''Class to manage one job
'''
- def __init__(self, name, machine, application, board,
- commands, timeout, config, logger, job_file, after=None):
+ def __init__(self,
+ name,
+ machine,
+ application,
+ board,
+ commands,
+ timeout,
+ config,
+ job_file_path,
+ logger,
+ after=None,
+ prefix=None):
self.name = name
self.machine = machine
self._stdout = None # Store the command outputs field
self._stderr = None # Store the command errors field
- self.out = None # Contains something only if the job is finished
- self.err = None # Contains something only if the job is finished
-
+ self.out = ""
+ self.err = ""
+
+ self.name_remote_jobs_pyconf = ".%s" % os.path.basename(job_file_path)
self.commands = commands
self.command = (os.path.join(self.machine.sat_path, "sat") +
" -l " +
os.path.join(self.machine.sat_path,
"list_log_files.txt") +
- " job --jobs_config " +
- job_file +
+ " job --jobs_config " +
+ os.path.join(self.machine.sat_path,
+ self.name_remote_jobs_pyconf) +
" --name " +
self.name)
+ if prefix:
+ self.command = prefix + ' "' + self.command +'"'
def get_pids(self):
""" Get the pid(s) corresponding to the command that have been launched
if self._stdout.channel.closed:
self._has_finished = True
# Store the result outputs
- self.out = self._stdout.read().decode()
- self.err = self._stderr.read().decode()
+ self.out += self._stdout.read().decode()
+ self.err += self._stderr.read().decode()
# Put end time
self._Tf = time.time()
# And get the remote command status and log files
def get_log_files(self):
"""Get the log files produced by the command launched
- on the remote machine.
+ on the remote machine, and put it in the log directory of the user,
+ so they can be accessible from
"""
# Do not get the files if the command is not finished
if not self.has_finished():
# First get the file that contains the list of log files to get
tmp_file_path = src.get_tmp_filename(self.config, "list_log_files.txt")
+ remote_path = os.path.join(self.machine.sat_path, "list_log_files.txt")
self.machine.sftp.get(
- os.path.join(self.machine.sat_path, "list_log_files.txt"),
+ remote_path,
tmp_file_path)
# Read the file and get the result of the command and all the log files
file_lines = [line.replace("\n", "") for line in file_lines]
fstream_tmp.close()
os.remove(tmp_file_path)
- # The first line is the result of the command (0 success or 1 fail)
- self.res_job = file_lines[0]
+
+ try :
+ # The first line is the result of the command (0 success or 1 fail)
+ self.res_job = file_lines[0]
+ except Exception as e:
+ self.err += _("Unable to get status from remote file %s: %s" %
+ (remote_path, str(e)))
for i, job_path_remote in enumerate(file_lines[1:]):
try:
# internal traces.
# 2- The txt file containing the system command traces (like
# traces produced by the "make" command)
- if os.path.basename(os.path.dirname(job_path_remote)) != 'OUT':
+ # 3- In case of the test command, there is another file to get :
+ # the xml board that contain the test results
+ dirname = os.path.basename(os.path.dirname(job_path_remote))
+ if dirname != 'OUT' and dirname != 'TEST':
# Case 1-
local_path = os.path.join(os.path.dirname(
self.logger.logFilePath),
"job",
self.res_job,
self.command)
- else:
+ elif dirname == 'OUT':
# Case 2-
local_path = os.path.join(os.path.dirname(
self.logger.logFilePath),
'OUT',
os.path.basename(job_path_remote))
+ elif dirname == 'TEST':
+ # Case 3-
+ local_path = os.path.join(os.path.dirname(
+ self.logger.logFilePath),
+ 'TEST',
+ os.path.basename(job_path_remote))
+
# Get the file
if not os.path.exists(local_path):
self.machine.sftp.get(job_path_remote, local_path)
self.remote_log_files.append(local_path)
except Exception as e:
self.err += _("Unable to get %s log file from remote: %s" %
- (job_path_remote, str(e)))
+ (str(job_path_remote),
+ str(e)))
def has_failed(self):
'''Returns True if the job has failed.
"""In case of a failing job, one has to cancel every job that depend
on it. This method put the job as failed and will not be executed.
"""
+ if self.cancelled:
+ return
self._has_begun = True
self._has_finished = True
self.cancelled = True
- self.out = _("This job was not launched because its father has failed.")
- self.err = _("This job was not launched because its father has failed.")
+ self.out += _("This job was not launched because its father has failed.")
+ self.err += _("This job was not launched because its father has failed.")
def is_running(self):
'''Returns True if the job commands are running
self._Tf = time.time()
self.get_pids()
(out_kill, _) = self.kill_remote_process()
- self.out = "TIMEOUT \n" + out_kill.read().decode()
- self.err = "TIMEOUT : %s seconds elapsed\n" % str(self.timeout)
+ self.out += "TIMEOUT \n" + out_kill.read().decode()
+ self.err += "TIMEOUT : %s seconds elapsed\n" % str(self.timeout)
try:
self.get_log_files()
except Exception as e:
if not self.machine.successfully_connected(self.logger):
self._has_finished = True
self.out = "N\A"
- self.err = ("Connection to machine (name : %s, host: %s, port:"
+ self.err += ("Connection to machine (name : %s, host: %s, port:"
" %s, user: %s) has failed\nUse the log command "
"to get more information."
% (self.machine.name,
if (self._stdin, self._stdout, self._stderr) == (None, None, None):
self._has_finished = True
self._Tf = time.time()
- self.out = "N\A"
- self.err = "The server failed to execute the command"
+ self.out += "N\A"
+ self.err += "The server failed to execute the command"
# Put the beginning flag to true.
self._has_begun = True
self.machine.write_info(self.logger)
self.logger.write(src.printcolors.printcInfo("out : \n"))
- if self.out is None:
+ if self.out == "":
self.logger.write("Unable to get output\n")
else:
self.logger.write(self.out + "\n")
self.logger.write(src.printcolors.printcInfo("err : \n"))
- if self.err is None:
- self.logger.write("Unable to get error\n")
- else:
- self.logger.write(self.err + "\n")
+ self.logger.write(self.err + "\n")
def get_status(self):
"""Get the status of the job (used by the Gui for xml display)
def __init__(self,
runner,
logger,
- job_file,
job_file_path,
config_jobs,
lenght_columns = 20):
# The jobs configuration
self.cfg_jobs = config_jobs
- self.job_file = job_file
self.job_file_path = job_file_path
# The machine that will be used today
self.lmachines = []
'''
name = job_def.name
cmmnds = job_def.commands
- timeout = job_def.timeout
+ if not "timeout" in job_def:
+ timeout = 4*60*60 # default timeout = 4h
+ else:
+ timeout = job_def.timeout
after = None
if 'after' in job_def:
after = job_def.after
board = None
if 'board' in job_def:
board = job_def.board
+ prefix = None
+ if "prefix" in job_def:
+ prefix = job_def.prefix
return Job(name,
machine,
cmmnds,
timeout,
self.runner.cfg,
+ self.job_file_path,
self.logger,
- self.job_file,
- after = after)
+ after = after,
+ prefix = prefix)
def determine_jobs_and_machines(self):
'''Function that reads the pyconf jobs definition and instantiates all
# Copy salomeTools to the remote machine
if machine.successfully_connected(self.logger):
+ step = _("Remove SAT")
+ self.logger.write('\r%s%s%s' % (begin_line, endline, 20 * " "),3)
+ self.logger.write('\r%s%s%s' % (begin_line, endline, step), 3)
+ (__, out_dist, __) = machine.exec_command(
+ "rm -rf %s" % machine.sat_path,
+ self.logger)
+ out_dist.read()
+
+ self.logger.flush()
step = _("Copy SAT")
self.logger.write('\r%s%s%s' % (begin_line, endline, 20 * " "),3)
self.logger.write('\r%s%s%s' % (begin_line, endline, step), 3)
self.logger.write('\r%s%s%s %s' %
(begin_line,
endline,
- src.printcolors.printc(src.OK_STATUS),
- _("Copy of SAT failed")), 3)
+ src.printcolors.printc(src.KO_STATUS),
+ _("Copy of SAT failed: %s" % res_copy)), 3)
else:
self.logger.write('\r%s' %
((len(begin_line)+len(endline)+20) * " "), 3)
see the jobs states
'''
- def __init__(self, xml_dir_path, l_jobs, l_jobs_not_today, l_file_boards = []):
+ def __init__(self,
+ xml_dir_path,
+ l_jobs,
+ l_jobs_not_today,
+ prefix,
+ logger,
+ file_boards=""):
'''Initialization
:param xml_dir_path str: The path to the directory where to put
the xml resulting files
:param l_jobs List: the list of jobs that run today
:param l_jobs_not_today List: the list of jobs that do not run today
- :param l_file_boards List: the list of file path from which to read the
+ :param file_boards str: the file path from which to read the
expected boards
'''
+ # The logging instance
+ self.logger = logger
+
+ # The prefix to add to the xml files : date_hour
+ self.prefix = prefix
+
# The path of the csv files to read to fill the expected boards
- self.l_file_boards = l_file_boards
+ self.file_boards = file_boards
- today = d_INT_DAY[datetime.date.weekday(datetime.date.today())]
- self.parse_csv_boards(today)
+ if file_boards != "":
+ today = datetime.date.weekday(datetime.date.today())
+ self.parse_csv_boards(today)
+ else:
+ self.d_input_boards = {}
# The path of the global xml file
self.xml_dir_path = xml_dir_path
# Initialize the xml files
- xml_global_path = os.path.join(self.xml_dir_path, "global_report.xml")
+ self.global_name = "global_report"
+ xml_global_path = os.path.join(self.xml_dir_path,
+ self.global_name + ".xml")
self.xml_global_file = src.xmlManager.XmlLogFile(xml_global_path,
"JobsReport")
+
+ # Find history for each job
+ self.history = {}
+ self.find_history(l_jobs, l_jobs_not_today)
+
# The xml files that corresponds to the boards.
# {name_board : xml_object}}
self.d_xml_board_files = {}
+
# Create the lines and columns
self.initialize_boards(l_jobs, l_jobs_not_today)
-
+
# Write the xml file
self.update_xml_files(l_jobs)
def add_xml_board(self, name):
+ '''Add a board to the board list
+ :param name str: the board name
+ '''
xml_board_path = os.path.join(self.xml_dir_path, name + ".xml")
self.d_xml_board_files[name] = src.xmlManager.XmlLogFile(
xml_board_path,
for board in list(self.d_input_boards.keys()):
if board not in self.d_xml_board_files:
self.add_xml_board(board)
+ root_node = self.d_xml_board_files[board].xmlroot
+ src.xmlManager.append_node_attrib(root_node,
+ {"input_file" : self.file_boards})
# Loop over all jobs in order to get the lines and columns for each
# xml file
# that will not be launched today
self.put_jobs_not_today(l_jobs_not_today, xml_jobs)
+ # add also the infos node
xml_file.add_simple_node("infos",
attrib={"name" : "last update",
"JobsCommandStatus" : "running"})
-
+
+ # and put the history node
+ history_node = xml_file.add_simple_node("history")
+ name_board = os.path.basename(xml_file.logFile)[:-len(".xml")]
+ # serach for board files
+ expression = "^[0-9]{8}_+[0-9]{6}_" + name_board + ".xml$"
+ oExpr = re.compile(expression)
+ # Get the list of xml borad files that are in the log directory
+ for file_name in os.listdir(self.xml_dir_path):
+ if oExpr.search(file_name):
+ date = os.path.basename(file_name).split("_")[0]
+ file_path = os.path.join(self.xml_dir_path, file_name)
+ src.xmlManager.add_simple_node(history_node,
+ "link",
+ text=file_path,
+ attrib={"date" : date})
+
+
# Find in each board the squares that needs to be filled regarding the
# input csv files but that are not covered by a today job
for board in self.d_input_boards.keys():
xml_root_board = self.d_xml_board_files[board].xmlroot
+ # Find the missing jobs for today
xml_missing = src.xmlManager.add_simple_node(xml_root_board,
"missing_jobs")
for row, column in self.d_input_boards[board]["jobs"]:
"job",
attrib={"distribution" : row,
"application" : column })
-
+ # Find the missing jobs not today
+ xml_missing_not_today = src.xmlManager.add_simple_node(
+ xml_root_board,
+ "missing_jobs_not_today")
+ for row, column in self.d_input_boards[board]["jobs_not_today"]:
+ found = False
+ for job in l_jobs_not_today:
+ if (job.application == column and
+ job.machine.distribution == row):
+ found = True
+ break
+ if not found:
+ src.xmlManager.add_simple_node(xml_missing_not_today,
+ "job",
+ attrib={"distribution" : row,
+ "application" : column })
+
+ def find_history(self, l_jobs, l_jobs_not_today):
+ """find, for each job, in the existent xml boards the results for the
+ job. Store the results in the dictionnary self.history = {name_job :
+ list of (date, status, list links)}
+
+ :param l_jobs List: the list of jobs to run today
+ :param l_jobs_not_today List: the list of jobs that do not run today
+ """
+ # load the all the history
+ expression = "^[0-9]{8}_+[0-9]{6}_" + self.global_name + ".xml$"
+ oExpr = re.compile(expression)
+ # Get the list of global xml that are in the log directory
+ l_globalxml = []
+ for file_name in os.listdir(self.xml_dir_path):
+ if oExpr.search(file_name):
+ file_path = os.path.join(self.xml_dir_path, file_name)
+ try:
+ global_xml = src.xmlManager.ReadXmlFile(file_path)
+ l_globalxml.append(global_xml)
+ except Exception as e:
+ msg = _("\nWARNING: the file %s can not be read, it will be "
+ "ignored\n%s" % (file_path, e))
+ self.logger.write("%s\n" % src.printcolors.printcWarning(
+ msg), 5)
+
+
+ # Construct the dictionnary self.history
+ for job in l_jobs + l_jobs_not_today:
+ l_links = []
+ for global_xml in l_globalxml:
+ date = os.path.basename(global_xml.filePath).split("_")[0]
+ global_root_node = global_xml.xmlroot.find("jobs")
+ job_node = src.xmlManager.find_node_by_attrib(
+ global_root_node,
+ "job",
+ "name",
+ job.name)
+ if job_node:
+ if job_node.find("remote_log_file_path") is not None:
+ link = job_node.find("remote_log_file_path").text
+ res_job = job_node.find("res").text
+ if link != "nothing":
+ l_links.append((date, res_job, link))
+ l_links = sorted(l_links, reverse=True)
+ self.history[job.name] = l_links
+
def put_jobs_not_today(self, l_jobs_not_today, xml_node_jobs):
'''Get all the first information needed for each file and write the
first version of the files
src.xmlManager.add_simple_node(xmlj, "user", job.machine.user)
src.xmlManager.add_simple_node(xmlj, "sat_path",
job.machine.sat_path)
+ xml_history = src.xmlManager.add_simple_node(xmlj, "history")
+ for i, (date, res_job, link) in enumerate(self.history[job.name]):
+ if i==0:
+ # tag the first one (the last one)
+ src.xmlManager.add_simple_node(xml_history,
+ "link",
+ text=link,
+ attrib={"date" : date,
+ "res" : res_job,
+ "last" : "yes"})
+ else:
+ src.xmlManager.add_simple_node(xml_history,
+ "link",
+ text=link,
+ attrib={"date" : date,
+ "res" : res_job,
+ "last" : "no"})
def parse_csv_boards(self, today):
- """ Parse the csv files that describes the boards to produce and fill
+ """ Parse the csv file that describes the boards to produce and fill
the dict d_input_boards that contain the csv file contain
- :param today str: the current day of the week
+ :param today int: the current day of the week
"""
- # loop over each csv file and read its content
- l_boards = []
- for file_path in self.l_file_boards:
- l_read = []
- with open(file_path, 'r') as f:
- reader = csv.reader(f)
- for row in reader:
- l_read.append(row)
- l_boards.append(l_read)
-
+ # open the csv file and read its content
+ l_read = []
+ with open(self.file_boards, 'r') as f:
+ reader = csv.reader(f,delimiter=CSV_DELIMITER)
+ for row in reader:
+ l_read.append(row)
+ # get the delimiter for the boards (empty line)
+ boards_delimiter = [''] * len(l_read[0])
+ # Make the list of boards, by splitting with the delimiter
+ l_boards = [list(y) for x, y in itertools.groupby(l_read,
+ lambda z: z == boards_delimiter) if not x]
+
# loop over the csv lists of lines and get the rows, columns and jobs
d_boards = {}
for input_board in l_boards:
columns = input_board[0][1:]
rows = []
- columns_out = []
jobs = []
+ jobs_not_today = []
for line in input_board[1:]:
row = line[0]
+ rows.append(row)
for i, square in enumerate(line[1:]):
- if today in square:
- if row not in rows:
- rows.append(row)
- if columns[i] not in columns_out:
- columns_out.append(columns[i])
- job = (row, columns[i])
+ if square=='':
+ continue
+ days = square.split(DAYS_SEPARATOR)
+ days = [int(day) for day in days]
+ job = (row, columns[i])
+ if today in days:
jobs.append(job)
-
+ else:
+ jobs_not_today.append(job)
+
d_boards[board_name] = {"rows" : rows,
- "columns" : columns_out,
- "jobs" : jobs}
+ "columns" : columns,
+ "jobs" : jobs,
+ "jobs_not_today" : jobs_not_today}
self.d_input_boards = d_boards
src.xmlManager.add_simple_node(xmlj, "host", job.machine.host)
src.xmlManager.add_simple_node(xmlj, "port", str(job.machine.port))
src.xmlManager.add_simple_node(xmlj, "user", job.machine.user)
+ xml_history = src.xmlManager.add_simple_node(xmlj, "history")
+ for date, res_job, link in self.history[job.name]:
+ src.xmlManager.add_simple_node(xml_history,
+ "link",
+ text=link,
+ attrib={"date" : date,
+ "res" : res_job})
+
src.xmlManager.add_simple_node(xmlj, "sat_path",
job.machine.sat_path)
src.xmlManager.add_simple_node(xmlj, "application", job.application)
src.xmlManager.add_simple_node(xmlj,
"remote_log_file_path",
"nothing")
+ # Search for the test log if there is any
+ l_test_log_files = self.find_test_log(job.remote_log_files)
+ xml_test = src.xmlManager.add_simple_node(xmlj,
+ "test_log_file_path")
+ for test_log_path in l_test_log_files:
+ src.xmlManager.add_simple_node(xml_test, "path", test_log_path)
xmlafter = src.xmlManager.add_simple_node(xmlj, "after", job.after)
# get the job father
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
+ def find_test_log(self, l_remote_log_files):
+ '''Find if there is a test log (board) in the remote log files and
+ the path to it. There can be several test command, so the result is
+ a list.
+
+ :param l_remote_log_files List: the list of all remote log files
+ :return: the list of test log files path
+ :rtype: List
+ '''
+ res = []
+ for file_path in l_remote_log_files:
+ dirname = os.path.basename(os.path.dirname(file_path))
+ if dirname == "TEST":
+ res.append(file_path)
+ return res
def last_update(self, finish_status = "finished"):
'''update information about the jobs for the file xml_file
attrib={"JobsCommandStatus" : finish_status})
# Write the file
self.write_xml_files()
-
+
+ def write_xml_file(self, xml_file, stylesheet):
+ ''' Write one xml file and the same file with prefix
+ '''
+ xml_file.write_tree(stylesheet)
+ file_path = xml_file.logFile
+ file_dir = os.path.dirname(file_path)
+ file_name = os.path.basename(file_path)
+ file_name_with_prefix = self.prefix + "_" + file_name
+ xml_file.write_tree(stylesheet, os.path.join(file_dir,
+ file_name_with_prefix))
+
def write_xml_files(self):
''' Write the xml files
'''
- self.xml_global_file.write_tree(STYLESHEET_GLOBAL)
+ self.write_xml_file(self.xml_global_file, STYLESHEET_GLOBAL)
for xml_file in self.d_xml_board_files.values():
- xml_file.write_tree(STYLESHEET_BOARD)
-
+ self.write_xml_file(xml_file, STYLESHEET_BOARD)
+
+
##
# Describes the command
def description():
return _("The jobs command launches maintenances that are described"
- " in the dedicated jobs configuration file.")
+ " in the dedicated jobs configuration file.\n\nexample:\nsat "
+ "jobs --name my_jobs --publish")
##
# Runs the command.
def run(args, runner, logger):
(options, args) = parser.parse_args(args)
-
- jobs_cfg_files_dir = runner.cfg.SITE.jobs.config_path
-
- l_cfg_dir = [os.path.join(runner.cfg.VARS.datadir, "jobs"),
- jobs_cfg_files_dir]
-
- # Make sure the path to the jobs config files directory exists
- src.ensure_path_exists(jobs_cfg_files_dir)
+
+ l_cfg_dir = runner.cfg.PATHS.JOBPATH
# list option : display all the available config files
if options.list:
if not options.no_label:
logger.write("------ %s\n" %
src.printcolors.printcHeader(cfg_dir))
-
+ if not os.path.exists(cfg_dir):
+ continue
for f in sorted(os.listdir(cfg_dir)):
if not f.endswith('.pyconf'):
continue
src.printcolors.printcError(message)
return 1
- # Find the file in the directories
+ # Find the file in the directories, unless it is a full path
found = False
- for cfg_dir in l_cfg_dir:
- file_jobs_cfg = os.path.join(cfg_dir, options.jobs_cfg)
- if not file_jobs_cfg.endswith('.pyconf'):
- file_jobs_cfg += '.pyconf'
-
- if not os.path.exists(file_jobs_cfg):
- continue
- else:
- found = True
- break
+ if os.path.exists(options.jobs_cfg):
+ found = True
+ file_jobs_cfg = options.jobs_cfg
+ else:
+ for cfg_dir in l_cfg_dir:
+ file_jobs_cfg = os.path.join(cfg_dir, options.jobs_cfg)
+ if not file_jobs_cfg.endswith('.pyconf'):
+ file_jobs_cfg += '.pyconf'
+
+ if not os.path.exists(file_jobs_cfg):
+ continue
+ else:
+ found = True
+ break
if not found:
msg = _("The file configuration %(name_file)s was not found."
(_("File containing the jobs configuration"), file_jobs_cfg)
]
src.print_info(logger, info)
-
+
# Read the config that is in the file
config_jobs = src.read_config_from_a_file(file_jobs_cfg)
if options.only_jobs:
# Initialization
today_jobs = Jobs(runner,
logger,
- options.jobs_cfg,
file_jobs_cfg,
config_jobs)
# SSH connection to all machines
gui = None
if options.publish:
+ logger.write(src.printcolors.printcInfo(
+ _("Initialize the xml boards : ")), 5)
+ logger.flush()
+
# Copy the stylesheets in the log directory
- log_dir = runner.cfg.SITE.log.log_dir
+ log_dir = runner.cfg.USER.log_dir
xsl_dir = os.path.join(runner.cfg.VARS.srcDir, 'xsl')
files_to_copy = []
files_to_copy.append(os.path.join(xsl_dir, STYLESHEET_GLOBAL))
# Instanciate the Gui in order to produce the xml files that contain all
# the boards
- gui = Gui(runner.cfg.SITE.log.log_dir,
+ gui = Gui(runner.cfg.USER.log_dir,
today_jobs.ljobs,
today_jobs.ljobs_not_today,
- l_file_boards = options.input_boards)
-
+ runner.cfg.VARS.datehour,
+ logger,
+ file_boards = options.input_boards)
+
+ logger.write(src.printcolors.printcSuccess("OK"), 5)
+ logger.write("\n\n", 5)
+ logger.flush()
+
+ # Display the list of the xml files
+ logger.write(src.printcolors.printcInfo(("Here is the list of published"
+ " files :\n")), 4)
+ logger.write("%s\n" % gui.xml_global_file.logFile, 4)
+ for board in gui.d_xml_board_files.keys():
+ file_path = gui.d_xml_board_files[board].logFile
+ file_name = os.path.basename(file_path)
+ logger.write("%s\n" % file_path, 4)
+ logger.add_link(file_name, "board", 0, board)
+
+ logger.write("\n", 4)
+
today_jobs.gui = gui
interruped = False
logger.write("\n\n%s\n\n" %
(src.printcolors.printcWarning(_("Forced interruption"))), 1)
finally:
+ res = 0
if interruped:
+ res = 1
msg = _("Killing the running jobs and trying"
" to get the corresponding logs\n")
logger.write(src.printcolors.printcWarning(msg))
# find the potential not finished jobs and kill them
for jb in today_jobs.ljobs:
if not jb.has_finished():
- jb.kill_remote_process()
+ res = 1
+ try:
+ jb.kill_remote_process()
+ except Exception as e:
+ msg = _("Failed to kill job %s: %s\n" % (jb.name, e))
+ logger.write(src.printcolors.printcWarning(msg))
+ if jb.res_job != "0":
+ res = 1
if interruped:
if today_jobs.gui:
today_jobs.gui.last_update(_("Forced interruption"))
today_jobs.gui.last_update()
# Output the results
today_jobs.write_all_results()
+ return res
