def transform(self):
# host item values of None default to modified localhost values
cfg = self.get()
for host in cfg['hosts']:
if host == 'localhost':
continue
for item, value in cfg['hosts'][host].items():
newvalue = value or cfg['hosts']['localhost'][item]
if newvalue and 'directory' in item:
# replace local home dir with $HOME for evaluation on other
# host
newvalue = newvalue.replace(os.environ['HOME'], '$HOME')
cfg['hosts'][host][item] = newvalue
# Expand environment variables and ~user in LOCAL file paths.
for key, val in cfg['documentation']['files'].items():
cfg['documentation']['files'][key] = expandvars(val)
cfg['pyro']['ports directory'] = expandvars(
cfg['pyro']['ports directory'])
for key, val in cfg['hosts']['localhost'].items():
if val and 'directory' in key:
cfg['hosts']['localhost'][key] = expandvars(val)
def transform(self):
"""Transform various settings.
Host item values of None default to modified localhost values.
Expand environment variables and ~ notations.
"""
cfg = self.get()
for host in cfg['hosts']:
if host == 'localhost':
continue
for item, value in cfg['hosts'][host].items():
newvalue = value or cfg['hosts']['localhost'][item]
if newvalue and 'directory' in item:
# replace local home dir with $HOME for evaluation on other
# host
newvalue = newvalue.replace(os.environ['HOME'], '$HOME')
cfg['hosts'][host][item] = newvalue
# Expand environment variables and ~user in LOCAL file paths.
for key, val in cfg['documentation']['files'].items():
cfg['documentation']['files'][key] = expandvars(val)
cfg['pyro']['ports directory'] = expandvars(
cfg['pyro']['ports directory'])
for key, val in cfg['hosts']['localhost'].items():
if val and 'directory' in key:
cfg['hosts']['localhost'][key] = expandvars(val)
def get_tmpdir(self):
"""Make a new temporary directory and arrange for it to be
deleted automatically when we're finished with it. Call this
explicitly just before use to ensure the directory is not
deleted by other processes before it is needed. THIS IS
CURRENTLY ONLY USED BY A FEW CYLC COMMANDS. If cylc suites
ever need it this must be called AFTER FORKING TO DAEMON MODE or
atexit() will delete the directory when the initial process
exits after forking."""
cfg = self.get()
tdir = cfg['temporary directory']
if tdir:
tdir = expandvars(tdir)
tmpdir = mkdtemp(prefix="cylc-", dir=expandvars(tdir))
else:
tmpdir = mkdtemp(prefix="cylc-")
# self-cleanup
atexit.register(lambda: shutil.rmtree(tmpdir))
# now replace the original item to allow direct access
cfg['temporary directory'] = tmpdir
return tmpdir
def get_tmpdir(self):
"""Make a new temporary directory and arrange for it to be
deleted automatically when we're finished with it. Call this
explicitly just before use to ensure the directory is not
deleted by other processes before it is needed. THIS IS
CURRENTLY ONLY USED BY A FEW CYLC COMMANDS. If cylc suites
ever need it this must be called AFTER FORKING TO DAEMON MODE or
atexit() will delete the directory when the initial process
exits after forking."""
cfg = self.get()
tdir = cfg['temporary directory']
if tdir:
tdir = expandvars(tdir)
tmpdir = mkdtemp(prefix="cylc-", dir=expandvars(tdir))
else:
tmpdir = mkdtemp(prefix="cylc-")
# self-cleanup
atexit.register(lambda: shutil.rmtree(tmpdir))
# now replace the original item to allow direct access
cfg['temporary directory'] = tmpdir
return tmpdir
def _prep_submit_task_job_impl(self, suite, itask, rtconfig):
"""Helper for self._prep_submit_task_job."""
# Submit number
itask.submit_num += 1
itask.summary['submit_num'] = itask.submit_num
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
owner_at_host = itask.task_owner + "@" + itask.task_host
else:
owner_at_host = itask.task_host
itask.summary['host'] = owner_at_host
itask.summary['job_hosts'][itask.submit_num] = owner_at_host
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[rtconfig['job']['batch system']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
if itask.summary[self.KEY_EXECUTE_TIME_LIMIT]:
# Default = 1, 2 and 7 minutes intervals, roughly 1, 3 and 10
# minutes after time limit exceeded
itask.poll_timers[self.KEY_EXECUTE_TIME_LIMIT] = (TaskActionTimer(
delays=batch_sys_conf.get(
'execution time limit polling intervals', [60, 120, 420])))
for label, key in [
('submission polling intervals', TASK_STATUS_SUBMITTED),
('execution polling intervals', TASK_STATUS_RUNNING)
]:
if key in itask.poll_timers:
itask.poll_timers[key].reset()
else:
values = self.task_events_mgr.get_host_conf(itask,
label,
skey='job')
if values:
itask.poll_timers[key] = TaskActionTimer(delays=values)
scripts = self._get_job_scripts(itask, rtconfig)
# Retry delays, needed for the try_num
self._set_retry_timers(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = self.task_events_mgr.get_task_job_id(itask.point,
itask.tdef.name,
itask.submit_num)
job_file_path = os.path.join(
GLOBAL_CFG.get_derived_host_item(suite, "suite job log directory",
itask.task_host,
itask.task_owner), job_d,
self.JOB_FILE_BASE)
return {
'batch_system_name':
rtconfig['job']['batch system'],
'batch_submit_command_template':
(rtconfig['job']['batch submit command template']),
'batch_system_conf':
batch_sys_conf,
'directives':
rtconfig['directives'],
'environment':
rtconfig['environment'],
'execution_time_limit':
itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script':
rtconfig['env-script'],
'err-script':
rtconfig['err-script'],
'host':
itask.task_host,
'init-script':
rtconfig['init-script'],
'job_file_path':
job_file_path,
'job_d':
job_d,
'namespace_hierarchy':
itask.tdef.namespace_hierarchy,
'owner':
itask.task_owner,
'param_env_tmpl':
rtconfig['parameter environment templates'],
'param_var':
itask.tdef.param_var,
'post-script':
scripts[2],
'pre-script':
scripts[0],
'remote_suite_d':
rtconfig['remote']['suite definition directory'],
'script':
scripts[1],
'shell':
rtconfig['job']['shell'],
'submit_num':
itask.submit_num,
'suite_name':
suite,
'task_id':
itask.identity,
'try_num':
itask.get_try_num(),
'work_d':
rtconfig['work sub-directory'],
}
def _prep_submit_task_job_impl(self, suite, itask):
"""Helper for self._prep_submit_task_job."""
overrides = self.task_events_mgr.broadcast_mgr.get_broadcast(
itask.identity)
if overrides:
rtconfig = pdeepcopy(itask.tdef.rtconfig)
poverride(rtconfig, overrides)
else:
rtconfig = itask.tdef.rtconfig
# Retry delays, needed for the try_num
self._set_retry_timers(itask, rtconfig)
# Submit number and try number
LOG.debug("[%s] -incrementing submit number" % (itask.identity,))
itask.submit_num += 1
itask.summary['submit_num'] = itask.submit_num
itask.local_job_file_path = None
self.suite_db_mgr.put_insert_task_jobs(itask, {
"is_manual_submit": itask.is_manual_submit,
"try_num": itask.get_try_num(),
"time_submit": get_current_time_string(),
})
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
# Determine task host settings now, just before job submission,
# because dynamic host selection may be used.
# host may be None (= run task on suite host)
itask.task_host = get_task_host(rtconfig['remote']['host'])
if not itask.task_host:
itask.task_host = 'localhost'
elif itask.task_host != "localhost":
LOG.info("[%s] -Task host: %s" % (
itask.identity, itask.task_host))
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
user_at_host = itask.task_owner + "@" + itask.task_host
else:
user_at_host = itask.task_host
itask.summary['host'] = user_at_host
itask.summary['job_hosts'][itask.submit_num] = user_at_host
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[rtconfig['job']['batch system']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
if itask.summary[self.KEY_EXECUTE_TIME_LIMIT]:
# Default = 1, 2 and 7 minutes intervals, roughly 1, 3 and 10
# minutes after time limit exceeded
itask.poll_timers[self.KEY_EXECUTE_TIME_LIMIT] = (
TaskActionTimer(delays=batch_sys_conf.get(
'execution time limit polling intervals', [60, 120, 420])))
for label, key in [
('submission polling intervals', TASK_STATUS_SUBMITTED),
('execution polling intervals', TASK_STATUS_RUNNING)]:
if key in itask.poll_timers:
itask.poll_timers[key].reset()
else:
values = self.task_events_mgr.get_host_conf(
itask, label, skey='job')
if values:
itask.poll_timers[key] = TaskActionTimer(delays=values)
self.init_host(suite, itask.task_host, itask.task_owner)
if itask.state.outputs.has_custom_triggers():
self.suite_db_mgr.put_update_task_outputs(itask)
self.suite_db_mgr.put_update_task_jobs(itask, {
"user_at_host": user_at_host,
"batch_sys_name": itask.summary['batch_sys_name'],
})
itask.is_manual_submit = False
scripts = self._get_job_scripts(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = self.task_events_mgr.get_task_job_id(
itask.point, itask.tdef.name, itask.submit_num)
job_file_path = os.path.join(
GLOBAL_CFG.get_derived_host_item(
suite, "suite job log directory",
itask.task_host, itask.task_owner),
job_d, self.JOB_FILE_BASE)
return {
'batch_system_name': rtconfig['job']['batch system'],
'batch_submit_command_template': (
rtconfig['job']['batch submit command template']),
'batch_system_conf': batch_sys_conf,
'directives': rtconfig['directives'],
'environment': rtconfig['environment'],
'execution_time_limit': itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script': rtconfig['env-script'],
'err-script': rtconfig['err-script'],
'host': itask.task_host,
'init-script': rtconfig['init-script'],
'job_file_path': job_file_path,
'job_d': job_d,
'namespace_hierarchy': itask.tdef.namespace_hierarchy,
'owner': itask.task_owner,
'param_var': itask.tdef.param_var,
'post-script': scripts[2],
'pre-script': scripts[0],
'remote_suite_d': rtconfig['remote']['suite definition directory'],
'script': scripts[1],
'shell': rtconfig['job']['shell'],
'submit_num': itask.submit_num,
'suite_name': suite,
'task_id': itask.identity,
'try_num': itask.get_try_num(),
'work_d': rtconfig['work sub-directory'],
}
def __init__(self, task_id, suite, jobconfig, submit_num):
self.jobconfig = jobconfig
self.task_id = task_id
self.suite = suite
self.logfiles = jobconfig.get('log files')
self.command = None
self.job_submit_command_template = jobconfig.get('command template')
common_job_log_path = jobconfig.get('common job log path')
self.local_jobfile_path = jobconfig.get('local job file path')
self.logfiles.add_path(self.local_jobfile_path)
task_host = jobconfig.get('task host')
task_owner = jobconfig.get('task owner')
self.remote_shell_template = GLOBAL_CFG.get_host_item(
'remote shell template', task_host, task_owner)
if is_remote_host(task_host) or is_remote_user(task_owner):
self.local = False
if task_owner:
self.task_owner = task_owner
else:
self.task_owner = None
if task_host:
self.task_host = task_host
else:
self.task_host = socket.gethostname()
remote_job_log_dir = GLOBAL_CFG.get_derived_host_item(
self.suite, 'suite job log directory', self.task_host,
self.task_owner)
remote_jobfile_path = os.path.join(remote_job_log_dir,
common_job_log_path)
# Remote log files
self.stdout_file = remote_jobfile_path + ".out"
self.stderr_file = remote_jobfile_path + ".err"
# Used in command construction:
self.jobfile_path = remote_jobfile_path
# Record paths of remote log files for access by gui
if True:
# by ssh URL
url_prefix = self.task_host
if self.task_owner:
url_prefix = self.task_owner + "@" + url_prefix
self.logfiles.add_path(url_prefix + ':' + self.stdout_file)
self.logfiles.add_path(url_prefix + ':' + self.stderr_file)
else:
# CURRENTLY DISABLED:
# If the remote and suite hosts see a common filesystem, or
# if the remote task is really just a local task with a
# different owner, we could just use local filesystem access.
# But to use this: (a) special namespace config would be
# required to indicate we have a common filesystem, and
# (b) we'd need to consider how the log directory can be
# specified (for example use of '$HOME' as for remote
# task use would not work here as log file access is by
# gui under the suite owner account.
self.logfiles.add_path(self.stdout_file)
self.logfiles.add_path(self.stderr_file)
else:
# LOCAL TASKS
self.local = True
self.task_owner = None
# Used in command construction:
self.jobfile_path = self.local_jobfile_path
# Local stdout and stderr log file paths:
self.stdout_file = self.local_jobfile_path + ".out"
self.stderr_file = self.local_jobfile_path + ".err"
# interpolate environment variables in extra logs
for idx in range(0, len(self.logfiles.paths)):
self.logfiles.paths[idx] = expandvars(self.logfiles.paths[idx])
# Record paths of local log files for access by gui
self.logfiles.add_path(self.stdout_file)
self.logfiles.add_path(self.stderr_file)
# set some defaults that can be overridden by derived classes
self.jobconfig['directive prefix'] = None
self.jobconfig['directive final'] = "# FINAL DIRECTIVE"
self.jobconfig['directive connector'] = " "
self.jobconfig['job vacation signal'] = None
# overrideable methods
self.set_directives()
self.set_job_vacation_signal()
self.set_scripting()
self.set_environment()
def __init__( self, task_id, suite, jobconfig, submit_num ):
self.jobconfig = jobconfig
self.task_id = task_id
self.suite = suite
self.logfiles = jobconfig.get( 'log files' )
self.job_submit_command_template = jobconfig.get('command template')
# Local job script path: append submit number.
# (used by both local and remote tasks)
tag = task_id + TaskID.DELIM + submit_num
gcfg = get_global_cfg()
self.local_jobfile_path = os.path.join( \
gcfg.get_derived_host_item( self.suite, 'suite job log directory' ), tag )
# The directory is created in config.py
self.logfiles.add_path( self.local_jobfile_path )
task_host = jobconfig.get('task host')
task_owner = jobconfig.get('task owner')
self.remote_shell_template = gcfg.get_host_item( 'remote shell template', task_host, task_owner )
if is_remote_host(task_host) or is_remote_user(task_owner):
# REMOTE TASK OR USER ACCOUNT SPECIFIED FOR TASK - submit using ssh
self.local = False
if task_owner:
self.task_owner = task_owner
else:
self.task_owner = None
if task_host:
self.task_host = task_host
else:
self.task_host = socket.gethostname()
self.remote_jobfile_path = os.path.join( \
gcfg.get_derived_host_item( self.suite, 'suite job log directory', self.task_host, self.task_owner ), tag )
# Remote log files
self.stdout_file = self.remote_jobfile_path + ".out"
self.stderr_file = self.remote_jobfile_path + ".err"
# Used in command construction:
self.jobfile_path = self.remote_jobfile_path
# Record paths of remote log files for access by gui
if True:
# by ssh URL
url_prefix = self.task_host
if self.task_owner:
url_prefix = self.task_owner + "@" + url_prefix
self.logfiles.add_path( url_prefix + ':' + self.stdout_file)
self.logfiles.add_path( url_prefix + ':' + self.stderr_file)
else:
# CURRENTLY DISABLED:
# If the remote and suite hosts see a common filesystem, or
# if the remote task is really just a local task with a
# different owner, we could just use local filesystem access.
# But to use this: (a) special namespace config would be
# required to indicate we have a common filesystem, and
# (b) we'd need to consider how the log directory can be
# specified (for example use of '$HOME' as for remote
# task use would not work here as log file access is by
# gui under the suite owner account.
self.logfiles.add_path( self.stdout_file )
self.logfiles.add_path( self.stderr_file )
else:
# LOCAL TASKS
self.local = True
self.task_owner = None
# Used in command construction:
self.jobfile_path = self.local_jobfile_path
# Local stdout and stderr log file paths:
self.stdout_file = self.local_jobfile_path + ".out"
self.stderr_file = self.local_jobfile_path + ".err"
# interpolate environment variables in extra logs
for idx in range( 0, len( self.logfiles.paths )):
self.logfiles.paths[idx] = expandvars( self.logfiles.paths[idx] )
# Record paths of local log files for access by gui
self.logfiles.add_path( self.stdout_file)
self.logfiles.add_path( self.stderr_file)
# set some defaults that can be overridden by derived classes
self.jobconfig[ 'directive prefix' ] = None
self.jobconfig[ 'directive final' ] = "# FINAL DIRECTIVE"
self.jobconfig[ 'directive connector' ] = " "
# overrideable methods
self.set_directives()
self.set_scripting()
self.set_environment()
def _prep_submit_task_job_impl(self, suite, itask, rtconfig):
"""Helper for self._prep_submit_task_job."""
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
owner_at_host = itask.task_owner + "@" + itask.task_host
else:
owner_at_host = itask.task_host
itask.summary['host'] = owner_at_host
itask.summary['job_hosts'][itask.submit_num] = owner_at_host
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[itask.summary['batch_sys_name']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
scripts = self._get_job_scripts(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = get_task_job_id(itask.point, itask.tdef.name, itask.submit_num)
job_file_path = os.path.join(
glbl_cfg().get_derived_host_item(suite, "suite job log directory",
itask.task_host,
itask.task_owner), job_d,
JOB_LOG_JOB)
return {
'batch_system_name':
rtconfig['job']['batch system'],
'batch_submit_command_template':
(rtconfig['job']['batch submit command template']),
'batch_system_conf':
batch_sys_conf,
'dependencies':
itask.state.get_resolved_dependencies(),
'directives':
rtconfig['directives'],
'environment':
rtconfig['environment'],
'execution_time_limit':
itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script':
rtconfig['env-script'],
'err-script':
rtconfig['err-script'],
'host':
itask.task_host,
'init-script':
rtconfig['init-script'],
'job_file_path':
job_file_path,
'job_d':
job_d,
'namespace_hierarchy':
itask.tdef.namespace_hierarchy,
'owner':
itask.task_owner,
'param_env_tmpl':
rtconfig['parameter environment templates'],
'param_var':
itask.tdef.param_var,
'post-script':
scripts[2],
'pre-script':
scripts[0],
'remote_suite_d':
rtconfig['remote']['suite definition directory'],
'script':
scripts[1],
'shell':
rtconfig['job']['shell'],
'submit_num':
itask.submit_num,
'suite_name':
suite,
'task_id':
itask.identity,
'try_num':
itask.get_try_num(),
'uuid_str':
self.task_remote_mgr.uuid_str,
'work_d':
rtconfig['work sub-directory'],
}
def _prep_submit_task_job_impl(self, suite, itask):
"""Helper for self._prep_submit_task_job."""
overrides = BroadcastServer.get_inst().get(itask.identity)
if overrides:
rtconfig = pdeepcopy(itask.tdef.rtconfig)
poverride(rtconfig, overrides)
else:
rtconfig = itask.tdef.rtconfig
# Retry delays, needed for the try_num
self._set_retry_timers(itask, rtconfig)
# Submit number and try number
LOG.debug("[%s] -incrementing submit number" % (itask.identity,))
itask.submit_num += 1
itask.summary['submit_num'] = itask.submit_num
itask.local_job_file_path = None
self.suite_db_mgr.put_insert_task_jobs(itask, {
"is_manual_submit": itask.is_manual_submit,
"try_num": itask.get_try_num(),
"time_submit": get_current_time_string(),
})
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
# Determine task host settings now, just before job submission,
# because dynamic host selection may be used.
# host may be None (= run task on suite host)
itask.task_host = get_task_host(rtconfig['remote']['host'])
if not itask.task_host:
itask.task_host = 'localhost'
elif itask.task_host != "localhost":
LOG.info("[%s] -Task host: %s" % (
itask.identity, itask.task_host))
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
user_at_host = itask.task_owner + "@" + itask.task_host
else:
user_at_host = itask.task_host
itask.summary['host'] = user_at_host
itask.summary['job_hosts'][itask.submit_num] = user_at_host
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[rtconfig['job']['batch system']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
if itask.summary[self.KEY_EXECUTE_TIME_LIMIT]:
# Default = 1, 2 and 7 minutes intervals, roughly 1, 3 and 10
# minutes after time limit exceeded
itask.poll_timers[self.KEY_EXECUTE_TIME_LIMIT] = (
TaskActionTimer(delays=batch_sys_conf.get(
'execution time limit polling intervals', [60, 120, 420])))
for label, key in [
('submission polling intervals', TASK_STATUS_SUBMITTED),
('execution polling intervals', TASK_STATUS_RUNNING)]:
if key in itask.poll_timers:
itask.poll_timers[key].reset()
else:
values = self.task_events_mgr.get_host_conf(
itask, label, skey='job')
if values:
itask.poll_timers[key] = TaskActionTimer(delays=values)
self.init_host(suite, itask.task_host, itask.task_owner)
self.suite_db_mgr.put_update_task_jobs(itask, {
"user_at_host": user_at_host,
"batch_sys_name": itask.summary['batch_sys_name'],
})
itask.is_manual_submit = False
scripts = self._get_job_scripts(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = self.task_events_mgr.get_task_job_id(
itask.point, itask.tdef.name, itask.submit_num)
job_file_path = os.path.join(
GLOBAL_CFG.get_derived_host_item(
suite, "suite job log directory",
itask.task_host, itask.task_owner),
job_d, self.JOB_FILE_BASE)
return {
'batch_system_name': rtconfig['job']['batch system'],
'batch_submit_command_template': (
rtconfig['job']['batch submit command template']),
'batch_system_conf': batch_sys_conf,
'directives': rtconfig['directives'],
'environment': rtconfig['environment'],
'execution_time_limit': itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script': rtconfig['env-script'],
'err-script': rtconfig['err-script'],
'host': itask.task_host,
'init-script': rtconfig['init-script'],
'job_file_path': job_file_path,
'job_d': job_d,
'namespace_hierarchy': itask.tdef.namespace_hierarchy,
'owner': itask.task_owner,
'param_var': itask.tdef.param_var,
'post-script': scripts[2],
'pre-script': scripts[0],
'remote_suite_d': rtconfig['remote']['suite definition directory'],
'script': scripts[1],
'shell': rtconfig['job']['shell'],
'submit_num': itask.submit_num,
'suite_name': suite,
'task_id': itask.identity,
'try_num': itask.get_try_num(),
'work_d': rtconfig['work sub-directory'],
}
def _prep_submit_task_job_impl(self, suite, itask, rtconfig):
"""Helper for self._prep_submit_task_job."""
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
owner_at_host = itask.task_owner + "@" + itask.task_host
else:
owner_at_host = itask.task_host
itask.summary['host'] = owner_at_host
itask.summary['job_hosts'][itask.submit_num] = owner_at_host
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[itask.summary['batch_sys_name']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
scripts = self._get_job_scripts(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = get_task_job_id(
itask.point, itask.tdef.name, itask.submit_num)
job_file_path = os.path.join(
glbl_cfg().get_derived_host_item(
suite, "suite job log directory",
itask.task_host, itask.task_owner),
job_d, JOB_LOG_JOB)
return {
'batch_system_name': rtconfig['job']['batch system'],
'batch_submit_command_template': (
rtconfig['job']['batch submit command template']),
'batch_system_conf': batch_sys_conf,
'dependencies': itask.state.get_resolved_dependencies(),
'directives': rtconfig['directives'],
'environment': rtconfig['environment'],
'execution_time_limit': itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script': rtconfig['env-script'],
'err-script': rtconfig['err-script'],
'host': itask.task_host,
'init-script': rtconfig['init-script'],
'job_file_path': job_file_path,
'job_d': job_d,
'namespace_hierarchy': itask.tdef.namespace_hierarchy,
'owner': itask.task_owner,
'param_env_tmpl': rtconfig['parameter environment templates'],
'param_var': itask.tdef.param_var,
'post-script': scripts[2],
'pre-script': scripts[0],
'remote_suite_d': rtconfig['remote']['suite definition directory'],
'script': scripts[1],
'shell': rtconfig['job']['shell'],
'submit_num': itask.submit_num,
'suite_name': suite,
'task_id': itask.identity,
'try_num': itask.get_try_num(),
'uuid_str': self.task_remote_mgr.uuid_str,
'work_d': rtconfig['work sub-directory'],
}
def _prep_submit_task_job_impl(self, suite, itask, rtconfig):
"""Helper for self._prep_submit_task_job."""
itask.task_owner = rtconfig['remote']['owner']
if itask.task_owner:
owner_at_host = itask.task_owner + "@" + itask.task_host
else:
owner_at_host = itask.task_host
itask.summary['host'] = owner_at_host
itask.summary['job_hosts'][itask.submit_num] = owner_at_host
itask.summary['batch_sys_name'] = rtconfig['job']['batch system']
for name in rtconfig['extra log files']:
itask.summary['logfiles'].append(expandvars(name))
try:
batch_sys_conf = self.task_events_mgr.get_host_conf(
itask, 'batch systems')[rtconfig['job']['batch system']]
except (TypeError, KeyError):
batch_sys_conf = {}
try:
itask.summary[self.KEY_EXECUTE_TIME_LIMIT] = float(
rtconfig['job']['execution time limit'])
except TypeError:
pass
if itask.summary[self.KEY_EXECUTE_TIME_LIMIT]:
# Default = 1, 2 and 7 minutes intervals, roughly 1, 3 and 10
# minutes after time limit exceeded
itask.poll_timers[self.KEY_EXECUTE_TIME_LIMIT] = (
TaskActionTimer(delays=batch_sys_conf.get(
'execution time limit polling intervals', [60, 120, 420])))
for label, key in [
('submission polling intervals', TASK_STATUS_SUBMITTED),
('execution polling intervals', TASK_STATUS_RUNNING)]:
if key in itask.poll_timers:
itask.poll_timers[key].reset()
else:
values = self.task_events_mgr.get_host_conf(
itask, label, skey='job')
if values:
itask.poll_timers[key] = TaskActionTimer(delays=values)
scripts = self._get_job_scripts(itask, rtconfig)
# Location of job file, etc
self._create_job_log_path(suite, itask)
job_d = get_task_job_id(
itask.point, itask.tdef.name, itask.submit_num)
job_file_path = os.path.join(
glbl_cfg().get_derived_host_item(
suite, "suite job log directory",
itask.task_host, itask.task_owner),
job_d, JOB_LOG_JOB)
return {
'batch_system_name': rtconfig['job']['batch system'],
'batch_submit_command_template': (
rtconfig['job']['batch submit command template']),
'batch_system_conf': batch_sys_conf,
'directives': rtconfig['directives'],
'environment': rtconfig['environment'],
'execution_time_limit': itask.summary[self.KEY_EXECUTE_TIME_LIMIT],
'env-script': rtconfig['env-script'],
'err-script': rtconfig['err-script'],
'host': itask.task_host,
'init-script': rtconfig['init-script'],
'job_file_path': job_file_path,
'job_d': job_d,
'namespace_hierarchy': itask.tdef.namespace_hierarchy,
'owner': itask.task_owner,
'param_env_tmpl': rtconfig['parameter environment templates'],
'param_var': itask.tdef.param_var,
'post-script': scripts[2],
'pre-script': scripts[0],
'remote_suite_d': rtconfig['remote']['suite definition directory'],
'script': scripts[1],
'shell': rtconfig['job']['shell'],
'submit_num': itask.submit_num,
'suite_name': suite,
'task_id': itask.identity,
'try_num': itask.get_try_num(),
'uuid_str': self.task_remote_mgr.uuid_str,
'work_d': rtconfig['work sub-directory'],
}
