def update_task_proxies(self, task_ids=None):
"""Update dynamic task instance fields"""
update_time = time()
# update task instance
for itask in self.schd.pool.get_all_tasks():
name, point_string = TaskID.split(itask.identity)
if ((task_ids and itask.identity not in task_ids) or
(itask.identity not in self.task_proxies)):
continue
ts = itask.get_state_summary()
self.cycle_states.setdefault(point_string, {})[name] = ts['state']
tproxy = self.task_proxies[itask.identity]
tproxy.checksum = f"{itask.identity}@{update_time}"
tproxy.state = ts['state']
tproxy.job_submits = ts['submit_num']
tproxy.spawned = ast.literal_eval(ts['spawned'])
tproxy.latest_message = ts['latest_message']
tproxy.jobs[:] = [
f"{self.workflow_id}/{job_id}" for job_id in itask.jobs]
tproxy.broadcasts[:] = [
f"{key}={val}" for key, val in
self.schd.task_events_mgr.broadcast_mgr.get_broadcast(
itask.identity).items()]
prereq_list = []
for prereq in itask.state.prerequisites:
# Protobuf messages populated within
prereq_obj = prereq.api_dump(self.workflow_id)
if prereq_obj:
prereq_list.append(prereq_obj)
tproxy.prerequisites.extend(prereq_list)
for _, msg, is_completed in itask.state.outputs.get_all():
tproxy.outputs.append(f"{msg}={is_completed}")
def remove_task_jobs(self, task_id):
"""removed all jobs associated with a task from the pool."""
name, point_string = TaskID.split(task_id)
t_id = f"/{point_string}/{name}/"
for job_d in self.pool.keys():
if t_id in job_d:
del self.pool[job_d]
def match_ext_trigger(self, itask):
"""Match external triggers for a waiting task proxy."""
if not self.ext_triggers or not itask.state.external_triggers:
return
has_changed = False
for trig, satisfied in list(itask.state.external_triggers.items()):
if satisfied:
continue
for qmsg, qid in self.ext_triggers.copy():
if trig == qmsg:
# Matched.
point_string = TaskID.split(itask.identity)[1]
# Set trigger satisfied.
itask.state.external_triggers[trig] = True
# Broadcast the event ID to the cycle point.
if qid is not None:
self.put_broadcast(
[point_string],
['root'],
[{'environment': {'CYLC_EXT_TRIGGER_ID': qid}}],
)
self.ext_triggers[(qmsg, qid)] -= 1
if not self.ext_triggers[(qmsg, qid)]:
del self.ext_triggers[(qmsg, qid)]
has_changed = True
break
return has_changed
def match_ext_trigger(self, itask):
"""Match external triggers for a waiting task proxy."""
if not self.ext_triggers or not itask.state.external_triggers:
return
has_changed = False
for trig, satisfied in list(itask.state.external_triggers.items()):
if satisfied:
continue
for qmsg, qid in self.ext_triggers.copy():
if trig == qmsg:
# Matched.
point_string = TaskID.split(itask.identity)[1]
# Set trigger satisfied.
itask.state.external_triggers[trig] = True
# Broadcast the event ID to the cycle point.
if qid is not None:
self.put_broadcast(
[point_string],
['root'],
[{'environment': {'CYLC_EXT_TRIGGER_ID': qid}}],
)
self.ext_triggers[(qmsg, qid)] -= 1
if not self.ext_triggers[(qmsg, qid)]:
del self.ext_triggers[(qmsg, qid)]
has_changed = True
break
return has_changed
def _match_ext_trigger(self, itask):
"""Match external triggers for a waiting task proxy."""
if not self.ext_triggers or not itask.state.external_triggers:
return False
for trig, satisfied in list(itask.state.external_triggers.items()):
if satisfied:
continue
for qmsg, qid in self.ext_triggers.copy():
if trig != qmsg:
continue
# Matched.
point_string = TaskID.split(itask.identity)[1]
# Set trigger satisfied.
itask.state.external_triggers[trig] = True
# Broadcast the event ID to the cycle point.
if qid is not None:
self.put_broadcast(
[point_string],
['root'],
[{
'environment': {
'CYLC_EXT_TRIGGER_ID': qid
}
}],
)
# Create data-store delta
self.data_store_mgr.delta_task_ext_trigger(
itask, qid, qmsg, True)
self.ext_triggers[(qmsg, qid)] -= 1
if not self.ext_triggers[(qmsg, qid)]:
del self.ext_triggers[(qmsg, qid)]
return True
return False
def _get_tasks_info(schd):
"""Retrieve task summary info and states."""
task_summary = {}
task_states = {}
for task in schd.pool.get_tasks():
ts = task.get_state_summary()
task_summary[task.identity] = ts
name, point_string = TaskID.split(task.identity)
task_states.setdefault(point_string, {})
task_states[point_string][name] = ts['state']
for task in schd.pool.get_rh_tasks():
ts = task.get_state_summary()
ts['state'] = TASK_STATUS_RUNAHEAD
task_summary[task.identity] = ts
name, point_string = TaskID.split(task.identity)
task_states.setdefault(point_string, {})
task_states[point_string][name] = ts['state']
return task_summary, task_states
def _get_tasks_info(schd):
"""Retrieve task summary info and states."""
task_summary = {}
task_states = {}
for task in schd.pool.get_tasks():
ts = task.get_state_summary()
task_summary[task.identity] = ts
name, point_string = TaskID.split(task.identity)
task_states.setdefault(point_string, {})
task_states[point_string][name] = ts['state']
for task in schd.pool.get_rh_tasks():
ts = task.get_state_summary()
ts['state'] = TASK_STATUS_RUNAHEAD
task_summary[task.identity] = ts
name, point_string = TaskID.split(task.identity)
task_states.setdefault(point_string, {})
task_states[point_string][name] = ts['state']
return task_summary, task_states
def insert_job(self, job_conf):
"""Insert job into pool."""
update_time = time()
job_owner = job_conf['owner']
sub_num = job_conf['submit_num']
name, point_string = TaskID.split(job_conf['task_id'])
t_id = f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}'
j_id = f'{t_id}{ID_DELIM}{sub_num}'
j_buf = PbJob(
stamp=f'{j_id}@{update_time}',
id=j_id,
submit_num=sub_num,
state=JOB_STATUSES_ALL[0],
task_proxy=t_id,
batch_sys_name=job_conf['batch_system_name'],
env_script=job_conf['env-script'],
err_script=job_conf['err-script'],
exit_script=job_conf['exit-script'],
execution_time_limit=job_conf['execution_time_limit'],
host=job_conf['host'],
init_script=job_conf['init-script'],
job_log_dir=job_conf['job_log_dir'],
owner=job_owner,
post_script=job_conf['post-script'],
pre_script=job_conf['pre-script'],
script=job_conf['script'],
work_sub_dir=job_conf['work_d'],
name=name,
cycle_point=point_string,
)
j_buf.batch_sys_conf.extend([
f'{key}={val}'
for key, val in job_conf['batch_system_conf'].items()
])
j_buf.directives.extend(
[f'{key}={val}' for key, val in job_conf['directives'].items()])
j_buf.environment.extend(
[f'{key}={val}' for key, val in job_conf['environment'].items()])
j_buf.param_env_tmpl.extend([
f'{key}={val}' for key, val in job_conf['param_env_tmpl'].items()
])
j_buf.param_var.extend(
[f'{key}={val}' for key, val in job_conf['param_var'].items()])
j_buf.extra_logs.extend(job_conf['logfiles'])
self.updates[j_id] = j_buf
self.task_jobs.setdefault(t_id, set()).add(j_id)
self.updates_pending = True
def main(
parser: COP,
options: 'Values',
workflow: str,
task_id: Optional[str] = None
) -> None:
workflow, _ = parse_reg(workflow)
pclient = get_client(workflow, timeout=options.comms_timeout)
if task_id and not TaskID.is_valid_id(task_id):
raise UserInputError("Invalid task ID: %s" % task_id)
flow_kwargs = {
'request_string': FLOW_QUERY,
'variables': {'wFlows': [workflow]}
}
task_kwargs: Dict[str, Any] = {
'request_string': TASK_QUERY,
}
# cylc ping WORKFLOW
result = pclient('graphql', flow_kwargs)
msg = ""
for flow in result['workflows']:
w_name = flow['name']
w_port = flow['port']
w_pub_port = flow['pubPort']
if cylc.flow.flags.verbosity > 0:
sys.stdout.write(
f'{w_name} running on '
f'{pclient.host}:{w_port} {w_pub_port}\n'
)
# cylc ping WORKFLOW TASKID
if task_id:
task, point = TaskID.split(task_id)
w_id = flow['id']
task_kwargs['variables'] = {
'tProxy': f'{w_id}{ID_DELIM}{point}{ID_DELIM}{task}'
}
task_result = pclient('graphql', task_kwargs)
if not task_result.get('taskProxy'):
msg = "task not found"
elif task_result['taskProxy']['state'] != TASK_STATUS_RUNNING:
msg = f"task not {TASK_STATUS_RUNNING}"
if msg:
print(cparse(f'<red>{msg}</red>'))
sys.exit(1)
def insert_job(self, job_conf):
"""Insert job into pool."""
update_time = time()
int_id = job_conf['job_d']
job_owner = job_conf['owner']
name, point_string = TaskID.split(job_conf['task_id'])
t_id = f"{self.owner}/{self.suite}/{point_string}/{name}"
j_id = f"{self.owner}/{self.suite}/{int_id}"
j_buf = PbJob(
checksum=f"{int_id}@{update_time}",
id=j_id,
submit_num=job_conf['submit_num'],
state=JOB_STATUSES_ALL[0],
task_proxy=t_id,
batch_sys_name=job_conf['batch_system_name'],
env_script=job_conf['env-script'],
err_script=job_conf['err-script'],
exit_script=job_conf['exit-script'],
execution_time_limit=job_conf['execution_time_limit'],
host=job_conf['host'],
init_script=job_conf['init-script'],
job_log_dir=job_conf['job_log_dir'],
owner=job_owner,
post_script=job_conf['post-script'],
pre_script=job_conf['pre-script'],
script=job_conf['script'],
work_sub_dir=job_conf['work_d'],
)
j_buf.batch_sys_conf.extend(
[f"{key}={val}" for key, val in
job_conf['batch_system_conf'].items()])
j_buf.directives.extend(
[f"{key}={val}" for key, val in
job_conf['directives'].items()])
j_buf.environment.extend(
[f"{key}={val}" for key, val in
job_conf['environment'].items()])
j_buf.param_env_tmpl.extend(
[f"{key}={val}" for key, val in
job_conf['param_env_tmpl'].items()])
j_buf.param_var.extend(
[f"{key}={val}" for key, val in
job_conf['param_var'].items()])
j_buf.extra_logs.extend(job_conf['logfiles'])
self.pool[int_id] = j_buf
def generate_ghost_task(self, task_id):
"""Create task-point element populated with static data.
Args:
task_id (str):
valid TaskID string.
Returns:
object: cylc.flow.data_messages_pb2.PbTaskProxy
Populated task proxy data element.
"""
update_time = time()
name, point_string = TaskID.split(task_id)
self.cycle_states.setdefault(point_string, {})[name] = (None, False)
t_id = f'{self.workflow_id}{ID_DELIM}{name}'
tp_id = f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}'
tp_stamp = f'{tp_id}@{update_time}'
taskdef = self.data[self.workflow_id][TASKS].get(
t_id,
self.updates[TASKS].get(t_id, MESSAGE_MAP[TASKS])
)
tproxy = PbTaskProxy(
stamp=tp_stamp,
id=tp_id,
task=taskdef.id,
cycle_point=point_string,
depth=taskdef.depth,
name=name,
)
tproxy.namespace[:] = taskdef.namespace
tproxy.parents[:] = [
f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{p_name}'
for p_name in self.parents[name]]
tproxy.ancestors[:] = [
f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{a_name}'
for a_name in self.ancestors[name]
if a_name != name]
tproxy.first_parent = tproxy.ancestors[0]
return tproxy
def main(parser, options, suite, task_id=None):
pclient = SuiteRuntimeClient(suite, timeout=options.comms_timeout)
if task_id and not TaskID.is_valid_id(task_id):
raise UserInputError("Invalid task ID: %s" % task_id)
flow_kwargs = {
'request_string': FLOW_QUERY,
'variables': {
'wFlows': [suite]
}
}
task_kwargs = {
'request_string': TASK_QUERY,
}
# cylc ping SUITE
result = pclient('graphql', flow_kwargs)
msg = ""
for flow in result['workflows']:
w_name = flow['name']
w_port = flow['port']
w_pub_port = flow['pubPort']
if cylc.flow.flags.verbose:
sys.stdout.write(f'{w_name} running on '
f'{pclient.host}:{w_port} {w_pub_port}\n')
# cylc ping SUITE TASKID
if task_id:
task, point = TaskID.split(task_id)
w_id = flow['id']
task_kwargs['variables'] = {
'tProxy': f'{w_id}{ID_DELIM}{point}{ID_DELIM}{task}'
}
task_result = pclient('graphql', task_kwargs)
if not task_result.get('taskProxy'):
msg = "task not found"
elif task_result['taskProxy']['state'] != TASK_STATUS_RUNNING:
msg = f"task not {TASK_STATUS_RUNNING}"
if msg:
print(cparse(f'<red>{msg}</red>'))
sys.exit(1)
def insert_job(self, job_conf):
"""Insert job into pool."""
job_owner = job_conf['owner']
sub_num = job_conf['submit_num']
name, point_string = TaskID.split(job_conf['task_id'])
t_id = f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}'
j_id = f'{t_id}{ID_DELIM}{sub_num}'
j_buf = PbJob(stamp=f'{j_id}@{time()}',
id=j_id,
submit_num=sub_num,
state=JOB_STATUSES_ALL[0],
task_proxy=t_id,
batch_sys_name=job_conf['batch_system_name'],
env_script=job_conf['env-script'],
err_script=job_conf['err-script'],
exit_script=job_conf['exit-script'],
execution_time_limit=job_conf['execution_time_limit'],
host=job_conf['platform']['name'],
init_script=job_conf['init-script'],
owner=job_owner,
post_script=job_conf['post-script'],
pre_script=job_conf['pre-script'],
script=job_conf['script'],
work_sub_dir=job_conf['work_d'],
name=name,
cycle_point=point_string,
batch_sys_conf=json.dumps(job_conf['batch_system_conf']),
directives=json.dumps(job_conf['directives']),
environment=json.dumps(job_conf['environment']),
param_var=json.dumps(job_conf['param_var']))
# Add in log files.
j_buf.job_log_dir = get_task_job_log(self.schd.suite, point_string,
name, sub_num)
j_buf.extra_logs.extend(job_conf['logfiles'])
self.added[j_id] = j_buf
self.task_jobs.setdefault(t_id, set()).add(j_id)
self.updates_pending = True
def _generate_ghost_task(self, task_id):
"""Create task instances populated with static data fields."""
update_time = time()
name, point_string = TaskID.split(task_id)
self.cycle_states.setdefault(point_string, {})[name] = None
tp_id = f"{self.workflow_id}/{point_string}/{name}"
tp_check = f"{task_id}@{update_time}"
taskdef = self.tasks[name]
tproxy = PbTaskProxy(
checksum=tp_check,
id=tp_id,
task=taskdef.id,
cycle_point=point_string,
depth=taskdef.depth,
)
tproxy.namespace[:] = taskdef.namespace
tproxy.parents[:] = [
f"{self.workflow_id}/{point_string}/{p_name}"
for p_name in self.parents[name]]
p1_name = self.parents[name][0]
tproxy.first_parent = f"{self.workflow_id}/{point_string}/{p1_name}"
return tproxy
def get_broadcast(self, task_id=None):
"""Retrieve all broadcast variables that target a given task ID."""
if task_id == "None":
task_id = None
if not task_id:
# all broadcasts requested
return self.broadcasts
try:
name, point_string = TaskID.split(task_id)
except ValueError:
raise Exception("Can't split task_id %s" % task_id)
ret = {}
# The order is:
# all:root -> all:FAM -> ... -> all:task
# -> tag:root -> tag:FAM -> ... -> tag:task
for cycle in self.ALL_CYCLE_POINTS_STRS + [point_string]:
if cycle not in self.broadcasts:
continue
for namespace in reversed(self.linearized_ancestors[name]):
if namespace in self.broadcasts[cycle]:
self._addict(ret, self.broadcasts[cycle][namespace])
return ret
def get_broadcast(self, task_id=None):
"""Retrieve all broadcast variables that target a given task ID."""
if task_id == "None":
task_id = None
if not task_id:
# all broadcasts requested
return self.broadcasts
try:
name, point_string = TaskID.split(task_id)
except ValueError:
raise Exception("Can't split task_id %s" % task_id)
ret = {}
# The order is:
# all:root -> all:FAM -> ... -> all:task
# -> tag:root -> tag:FAM -> ... -> tag:task
for cycle in ALL_CYCLE_POINTS_STRS + [point_string]:
if cycle not in self.broadcasts:
continue
for namespace in reversed(self.linearized_ancestors[name]):
if namespace in self.broadcasts[cycle]:
addict(ret, self.broadcasts[cycle][namespace])
return ret
def update_task_proxies(self, updated_tasks=None):
"""Update dynamic fields of task nodes/proxies.
Args:
updated_tasks (list): [cylc.flow.task_proxy.TaskProxy]
Update task-node from corresponding given list of
task proxy objects from the workflow task pool.
"""
if not updated_tasks:
return
tasks = self.data[self.workflow_id][TASKS]
task_proxies = self.data[self.workflow_id][TASK_PROXIES]
update_time = time()
task_defs = {}
# update task instance
for itask in updated_tasks:
name, point_string = TaskID.split(itask.identity)
tp_id = (
f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}')
if (tp_id not in task_proxies
and tp_id not in self.added[TASK_PROXIES]):
continue
# Gather task definitions for elapsed time recalculation.
if name not in task_defs:
task_defs[name] = itask.tdef
# Create new message and copy existing message content.
tp_delta = self.updated[TASK_PROXIES].setdefault(
tp_id, PbTaskProxy(id=tp_id))
tp_delta.stamp = f'{tp_id}@{update_time}'
tp_delta.state = itask.state.status
if tp_id in task_proxies:
self.state_update_families.add(
task_proxies[tp_id].first_parent)
else:
self.state_update_families.add(
self.added[TASK_PROXIES][tp_id].first_parent)
tp_delta.is_held = itask.state.is_held
tp_delta.flow_label = itask.flow_label
tp_delta.job_submits = itask.submit_num
tp_delta.latest_message = itask.summary['latest_message']
tp_delta.jobs[:] = [
j_id for j_id in self.schd.job_pool.task_jobs.get(tp_id, [])
if j_id not in task_proxies.get(tp_id, PbTaskProxy()).jobs
]
prereq_list = []
for prereq in itask.state.prerequisites:
# Protobuf messages populated within
prereq_obj = prereq.api_dump(self.workflow_id)
if prereq_obj:
prereq_list.append(prereq_obj)
tp_delta.prerequisites.extend(prereq_list)
tp_delta.outputs = json.dumps({
trigger: is_completed
for trigger, _, is_completed in itask.state.outputs.get_all()
})
extras = {}
if itask.tdef.clocktrigger_offset is not None:
extras['Clock trigger time reached'] = (
itask.is_waiting_clock_done())
extras['Triggers at'] = time2str(itask.clock_trigger_time)
for trig, satisfied in itask.state.external_triggers.items():
key = f'External trigger "{trig}"'
if satisfied:
extras[key] = 'satisfied'
else:
extras[key] = 'NOT satisfied'
for label, satisfied in itask.state.xtriggers.items():
sig = self.schd.xtrigger_mgr.get_xtrig_ctx(
itask, label).get_signature()
extra = f'xtrigger "{label} = {sig}"'
if satisfied:
extras[extra] = 'satisfied'
else:
extras[extra] = 'NOT satisfied'
tp_delta.extras = json.dumps(extras)
# Recalculate effected task def elements elapsed time.
for name, tdef in task_defs.items():
elapsed_time = task_mean_elapsed_time(tdef)
if elapsed_time:
t_id = f'{self.workflow_id}{ID_DELIM}{name}'
t_delta = PbTask(stamp=f'{t_id}@{update_time}',
mean_elapsed_time=elapsed_time)
self.updated[TASKS].setdefault(
t_id, PbTask(id=t_id)).MergeFrom(t_delta)
tasks[t_id].MergeFrom(t_delta)
def generate_graph_elements(self, start_point=None, stop_point=None):
"""Generate edges and [ghost] nodes (family and task proxy elements).
Args:
start_point (cylc.flow.cycling.PointBase):
Edge generation start point.
stop_point (cylc.flow.cycling.PointBase):
Edge generation stop point.
"""
if not self.pool_points:
return
config = self.schd.config
if start_point is None:
start_point = min(self.pool_points)
if stop_point is None:
stop_point = max(self.pool_points)
# Reference set for workflow relations
new_edges = set()
# Generate ungrouped edges
for edge in config.get_graph_edges(start_point, stop_point):
# Reference or create edge source & target nodes/proxies
s_node = edge[0]
t_node = edge[1]
if s_node is None:
continue
# Is the source cycle point in the task pool?
s_name, s_point = TaskID.split(s_node)
s_point_cls = get_point(s_point)
s_pool_point = False
s_valid = TaskID.is_valid_id(s_node)
if s_valid:
s_pool_point = s_point_cls in self.pool_points
# Is the target cycle point in the task pool?
t_pool_point = False
t_valid = t_node and TaskID.is_valid_id(t_node)
if t_valid:
t_name, t_point = TaskID.split(t_node)
t_point_cls = get_point(t_point)
t_pool_point = get_point(t_point) in self.pool_points
# Proceed if either source or target cycle points
# are in the task pool.
if not s_pool_point and not t_pool_point:
continue
# If source/target is valid add/create the corresponding items.
# TODO: if xtrigger is suite_state create remote ID
source_id = (
f'{self.workflow_id}{ID_DELIM}{s_point}{ID_DELIM}{s_name}')
# Add valid source before checking for no target,
# as source may be an isolate (hence no edges).
if s_valid:
s_task_id = f'{self.workflow_id}{ID_DELIM}{s_name}'
# Add source points for pruning.
self.edge_points.setdefault(s_point_cls, set())
self.generate_ghost_task(s_task_id, source_id, s_point)
# If target is valid then created it.
# Edges are only created for valid targets.
# At present targets can't be xtriggers.
if t_valid:
target_id = (
f'{self.workflow_id}{ID_DELIM}{t_point}{ID_DELIM}{t_name}')
t_task_id = f'{self.workflow_id}{ID_DELIM}{t_name}'
# Add target points to associated source points for pruning.
self.edge_points.setdefault(s_point_cls, set())
self.edge_points[s_point_cls].add(t_point_cls)
self.generate_ghost_task(t_task_id, target_id, t_point)
# Initiate edge element.
e_id = (
f'{self.workflow_id}{ID_DELIM}{s_node}{ID_DELIM}{t_node}')
self.added[EDGES][e_id] = PbEdge(
id=e_id,
suicide=edge[3],
cond=edge[4],
source=source_id,
target=target_id,
)
new_edges.add(e_id)
# Add edge id to node field for resolver reference
self.updated[TASK_PROXIES].setdefault(
target_id, PbTaskProxy(id=target_id)).edges.append(e_id)
if s_valid:
self.updated[TASK_PROXIES].setdefault(
source_id,
PbTaskProxy(id=source_id)).edges.append(e_id)
if new_edges:
getattr(self.updated[WORKFLOW], EDGES).edges.extend(new_edges)
def main(_, options, suite, *task_args):
"""Implement "cylc show" CLI."""
pclient = SuiteRuntimeClient(suite, timeout=options.comms_timeout)
json_filter = {}
if not task_args:
query = WORKFLOW_META_QUERY
query_kwargs = {
'request_string': query,
'variables': {
'wFlows': [suite]
}
}
# Print suite info.
results = pclient('graphql', query_kwargs)
for workflow in results['workflows']:
flat_data = flatten_data(workflow)
if options.json:
json_filter.update(flat_data)
else:
for key, value in sorted(flat_data.items(), reverse=True):
ansiprint(
f'<bold>{key}:</bold> {value or "<m>(not given)</m>"}')
task_names = [arg for arg in task_args if TaskID.is_valid_name(arg)]
task_ids = [arg for arg in task_args if TaskID.is_valid_id_2(arg)]
if task_names:
tasks_query = TASK_META_QUERY
tasks_kwargs = {
'request_string': tasks_query,
'variables': {
'wFlows': [suite],
'taskIds': task_names
}
}
# Print suite info.
results = pclient('graphql', tasks_kwargs)
multi = len(results['tasks']) > 1
for task in results['tasks']:
flat_data = flatten_data(task['meta'])
if options.json:
json_filter.update({task['name']: flat_data})
else:
if multi:
print(f'----\nTASK NAME: {task["name"]}')
for key, value in sorted(flat_data.items(), reverse=True):
ansiprint(
f'<bold>{key}:</bold> {value or "<m>(not given)</m>"}')
if task_ids:
tp_query = TASK_PREREQS_QUERY
tp_kwargs = {
'request_string': tp_query,
'variables': {
'wFlows': [suite],
'taskIds': [
f'{c}{ID_DELIM}{n}' for n, c in [
TaskID.split(t_id)
for t_id in task_ids if TaskID.is_valid_id(t_id)
]
] + [
f'{c}{ID_DELIM}{n}' for c, n in [
t_id.rsplit(TaskID.DELIM2, 1)
for t_id in task_ids if not TaskID.is_valid_id(t_id)
]
]
}
}
results = pclient('graphql', tp_kwargs)
multi = len(results['taskProxies']) > 1
for t_proxy in results['taskProxies']:
task_id = TaskID.get(t_proxy['name'], t_proxy['cyclePoint'])
if options.json:
json_filter.update({task_id: t_proxy})
else:
if multi:
print(f'----\nTASK ID: {task_id}')
prereqs = []
for item in t_proxy['prerequisites']:
prefix = ''
multi_cond = len(item['conditions']) > 1
if multi_cond:
prereqs.append([
True, '', item['expression'].replace('c', ''),
item['satisfied']
])
for cond in item['conditions']:
if multi_cond and not options.list_prereqs:
prefix = f'\t{cond["exprAlias"].strip("c")} = '
_, _, point, name = cond['taskId'].split(ID_DELIM)
cond_id = TaskID.get(name, point)
prereqs.append([
False, prefix, f'{cond_id} {cond["reqState"]}',
cond['satisfied']
])
if options.list_prereqs:
for composite, _, msg, _ in prereqs:
if not composite:
print(msg)
else:
flat_meta = flatten_data(t_proxy['task']['meta'])
for key, value in sorted(flat_meta.items(), reverse=True):
ansiprint(f'<bold>{key}:</bold>'
f' {value or "<m>(not given)</m>"}')
ansiprint('\n<bold>prerequisites</bold>'
' (<red>- => not satisfied</red>):')
if not prereqs:
print(' (None)')
for _, prefix, msg, state in prereqs:
print_msg_state(f'{prefix}{msg}', state)
ansiprint('\n<bold>outputs</bold>'
' (<red>- => not completed</red>):')
if not t_proxy['outputs']:
print(' (None)')
for key, val in t_proxy['outputs'].items():
print_msg_state(f'{task_id} {key}', val)
if t_proxy['extras']:
print('\nother:')
for key, value in t_proxy['extras'].items():
print(' o %s ... %s' % (key, value))
if not results['taskProxies']:
ansiprint(f"<red>No matching tasks found: {task_ids}",
file=sys.stderr)
sys.exit(1)
if options.json:
print(json.dumps(json_filter, indent=4))
def test_split(self):
self.assertEqual(["a", '1'], TaskID.split("a.1"))
self.assertEqual(["a", '_1'], TaskID.split("a._1"))
self.assertEqual(["WTAS", '20101010T101010'],
TaskID.split("WTAS.20101010T101010"))
def main(parser, options, *args, color=False):
"""Implement cylc cat-log CLI.
Determine log path, user@host, batchview_cmd, and action (print, dir-list,
cat, edit, or tail), and then if the log path is:
a) local: perform action on log path, or
b) remote: re-invoke cylc cat-log as a) on the remote account
"""
if options.remote_args:
# Invoked on job hosts for job logs only, as a wrapper to view_log().
# Tail and batchview commands come from global config on suite host).
logpath, mode, tail_tmpl = options.remote_args[0:3]
if logpath.startswith('$'):
logpath = os.path.expandvars(logpath)
elif logpath.startswith('~'):
logpath = os.path.expanduser(logpath)
try:
batchview_cmd = options.remote_args[3]
except IndexError:
batchview_cmd = None
res = view_log(logpath,
mode,
tail_tmpl,
batchview_cmd,
remote=True,
color=color)
if res == 1:
sys.exit(res)
return
suite_name = args[0]
# Get long-format mode.
try:
mode = MODES[options.mode]
except KeyError:
mode = options.mode
if len(args) == 1:
# Cat suite logs, local only.
if options.filename is not None:
raise UserInputError("The '-f' option is for job logs only.")
logpath = get_suite_run_log_name(suite_name)
if options.rotation_num:
logs = glob('%s.*' % logpath)
logs.sort(key=os.path.getmtime, reverse=True)
try:
logpath = logs[int(options.rotation_num)]
except IndexError:
raise UserInputError("max rotation %d" % (len(logs) - 1))
tail_tmpl = str(glbl_cfg().get_host_item("tail command template"))
out = view_log(logpath, mode, tail_tmpl, color=color)
if out == 1:
sys.exit(1)
if mode == 'edit':
tmpfile_edit(out, options.geditor)
return
if len(args) == 2:
# Cat task job logs, may be on suite or job host.
if options.rotation_num is not None:
raise UserInputError("only suite (not job) logs get rotated")
task_id = args[1]
try:
task, point = TaskID.split(task_id)
except ValueError:
parser.error("Illegal task ID: %s" % task_id)
if options.submit_num != NN:
try:
options.submit_num = "%02d" % int(options.submit_num)
except ValueError:
parser.error("Illegal submit number: %s" % options.submit_num)
if options.filename is None:
options.filename = JOB_LOG_OUT
else:
# Convert short filename args to long (e.g. 'o' to 'job.out').
try:
options.filename = JOB_LOG_OPTS[options.filename]
except KeyError:
# Is already long form (standard log, or custom).
pass
user_at_host, batch_sys_name, live_job_id = get_task_job_attrs(
suite_name, point, task, options.submit_num)
user, host = split_user_at_host(user_at_host)
batchview_cmd = None
if live_job_id is not None:
# Job is currently running. Get special batch system log view
# command (e.g. qcat) if one exists, and the log is out or err.
conf_key = None
if options.filename == JOB_LOG_OUT:
if mode == 'cat':
conf_key = "out viewer"
elif mode == 'tail':
conf_key = "out tailer"
elif options.filename == JOB_LOG_ERR:
if mode == 'cat':
conf_key = "err viewer"
elif mode == 'tail':
conf_key = "err tailer"
if conf_key is not None:
conf = glbl_cfg().get_host_item("batch systems", host, user)
batchview_cmd_tmpl = None
try:
batchview_cmd_tmpl = conf[batch_sys_name][conf_key]
except KeyError:
pass
if batchview_cmd_tmpl is not None:
batchview_cmd = batchview_cmd_tmpl % {
"job_id": str(live_job_id)
}
log_is_remote = (is_remote(host, user)
and (options.filename not in JOB_LOGS_LOCAL))
log_is_retrieved = (glbl_cfg().get_host_item('retrieve job logs', host)
and live_job_id is None)
if log_is_remote and (not log_is_retrieved or options.force_remote):
logpath = os.path.normpath(
get_remote_suite_run_job_dir(host, user, suite_name, point,
task, options.submit_num,
options.filename))
tail_tmpl = str(glbl_cfg().get_host_item("tail command template",
host, user))
# Reinvoke the cat-log command on the remote account.
cmd = ['cat-log']
if cylc.flow.flags.debug:
cmd.append('--debug')
for item in [logpath, mode, tail_tmpl]:
cmd.append('--remote-arg=%s' % quote(item))
if batchview_cmd:
cmd.append('--remote-arg=%s' % quote(batchview_cmd))
cmd.append(suite_name)
is_edit_mode = (mode == 'edit')
try:
proc = remote_cylc_cmd(cmd,
user,
host,
capture_process=is_edit_mode,
manage=(mode == 'tail'))
except KeyboardInterrupt:
# Ctrl-C while tailing.
pass
else:
if is_edit_mode:
# Write remote stdout to a temp file for viewing in editor.
# Only BUFSIZE bytes at a time in case huge stdout volume.
out = NamedTemporaryFile()
data = proc.stdout.read(BUFSIZE)
while data:
out.write(data)
data = proc.stdout.read(BUFSIZE)
os.chmod(out.name, S_IRUSR)
out.seek(0, 0)
else:
# Local task job or local job log.
logpath = os.path.normpath(
get_suite_run_job_dir(suite_name, point, task,
options.submit_num, options.filename))
tail_tmpl = str(glbl_cfg().get_host_item("tail command template"))
out = view_log(logpath,
mode,
tail_tmpl,
batchview_cmd,
color=color)
if mode != 'edit':
sys.exit(out)
if mode == 'edit':
tmpfile_edit(out, options.geditor)
def update_task_proxies(self, updated_tasks=None):
"""Update dynamic fields of task nodes/proxies.
Args:
updated_tasks (list): [cylc.flow.task_proxy.TaskProxy]
Update task-node from corresponding given list of
task proxy objects from the workflow task pool.
"""
if not updated_tasks:
return
tasks = self.data[self.workflow_id][TASKS]
task_proxies = self.data[self.workflow_id][TASK_PROXIES]
update_time = time()
task_defs = {}
# update task instance
for itask in updated_tasks:
name, point_string = TaskID.split(itask.identity)
tp_id = (
f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}')
if (tp_id not in task_proxies and
tp_id not in self.updates[TASK_PROXIES]):
continue
self.cycle_states.setdefault(point_string, {})[name] = (
itask.state.status, itask.state.is_held)
# Gather task definitions for elapsed time recalculation.
if name not in task_defs:
task_defs[name] = itask.tdef
# Create new message and copy existing message content.
tp_delta = self.updates[TASK_PROXIES].setdefault(
tp_id, PbTaskProxy(id=tp_id))
tp_delta.stamp = f'{tp_id}@{update_time}'
tp_delta.state = itask.state.status
tp_delta.is_held = itask.state.is_held
tp_delta.job_submits = itask.submit_num
tp_delta.spawned = itask.has_spawned
tp_delta.latest_message = itask.summary['latest_message']
tp_delta.jobs[:] = [
j_id
for j_id in self.schd.job_pool.task_jobs.get(tp_id, [])
if j_id not in task_proxies.get(tp_id, PbTaskProxy()).jobs
]
tp_delta.broadcasts[:] = [
f'{key}={val}' for key, val in
self.schd.task_events_mgr.broadcast_mgr.get_broadcast(
itask.identity).items()]
prereq_list = []
for prereq in itask.state.prerequisites:
# Protobuf messages populated within
prereq_obj = prereq.api_dump(self.workflow_id)
if prereq_obj:
prereq_list.append(prereq_obj)
tp_delta.prerequisites.extend(prereq_list)
tp_delta.outputs[:] = [
f'{trigger}={is_completed}'
for trigger, _, is_completed in itask.state.outputs.get_all()
]
# Recalculate effected task def elements elapsed time.
for name, tdef in task_defs.items():
elapsed_time = task_mean_elapsed_time(tdef)
if elapsed_time:
t_id = f'{self.workflow_id}{ID_DELIM}{name}'
t_delta = PbTask(
stamp=f'{t_id}@{update_time}',
mean_elapsed_time=elapsed_time
)
self.updates[TASKS].setdefault(
t_id,
PbTask(id=t_id)).MergeFrom(t_delta)
tasks[t_id].MergeFrom(t_delta)
def generate_graph_elements(self,
edges=None,
task_proxies=None,
family_proxies=None,
start_point=None,
stop_point=None):
"""Generate edges and [ghost] nodes (family and task proxy elements).
Args:
edges (dict, optional):
ID-PbEdge key-value mapping.
task_proxies (dict, optional):
ID-PbTaskProxy key-value mapping.
family_proxies (dict, optional):
ID-PbFamilyProxy key-value mapping.
start_point (cylc.flow.cycling.PointBase):
Edge generation start point.
stop_point (cylc.flow.cycling.PointBase):
Edge generation stop point.
"""
if not self.pool_points:
return
config = self.schd.config
tasks = self.data[self.workflow_id][TASKS]
graph = PbEdges()
if edges is None:
edges = {}
if task_proxies is None:
task_proxies = {}
if family_proxies is None:
family_proxies = {}
if start_point is None:
start_point = min(self.pool_points)
if stop_point is None:
stop_point = max(self.pool_points)
# Used for generating family [ghost] nodes
new_points = set()
# Generate ungrouped edges
for edge in config.get_graph_edges(start_point, stop_point):
# Reference or create edge source & target nodes/proxies
s_node = edge[0]
t_node = edge[1]
if s_node is None:
continue
# Is the source cycle point in the task pool?
s_name, s_point = TaskID.split(s_node)
s_point_cls = get_point(s_point)
s_pool_point = False
s_valid = TaskID.is_valid_id(s_node)
if s_valid:
s_pool_point = s_point_cls in self.pool_points
# Is the target cycle point in the task pool?
t_pool_point = False
t_valid = t_node and TaskID.is_valid_id(t_node)
if t_valid:
t_name, t_point = TaskID.split(t_node)
t_point_cls = get_point(t_point)
t_pool_point = get_point(t_point) in self.pool_points
# Proceed if either source or target cycle points
# are in the task pool.
if not s_pool_point and not t_pool_point:
continue
# If source/target is valid add/create the corresponding items.
# TODO: if xtrigger is suite_state create remote ID
source_id = (
f'{self.workflow_id}{ID_DELIM}{s_point}{ID_DELIM}{s_name}')
if s_valid:
s_task_id = f'{self.workflow_id}{ID_DELIM}{s_name}'
new_points.add(s_point)
# Add source points for pruning.
self.edge_points.setdefault(s_point_cls, set())
if source_id not in task_proxies:
task_proxies[source_id] = self.generate_ghost_task(s_node)
if source_id not in tasks[s_task_id].proxies:
tasks[s_task_id].proxies.append(source_id)
# Add valid source before checking for no target,
# as source may be an isolate (hence no edges).
# At present targets can't be xtriggers.
if t_valid:
target_id = (
f'{self.workflow_id}{ID_DELIM}{t_point}{ID_DELIM}{t_name}')
t_task_id = f'{self.workflow_id}{ID_DELIM}{t_name}'
new_points.add(t_point)
# Add target points to associated source points for pruning.
self.edge_points.setdefault(s_point_cls, set())
self.edge_points[s_point_cls].add(t_point_cls)
if target_id not in task_proxies:
task_proxies[target_id] = self.generate_ghost_task(t_node)
if target_id not in tasks[t_task_id].proxies:
tasks[t_task_id].proxies.append(target_id)
# Initiate edge element.
e_id = (
f'{self.workflow_id}{ID_DELIM}{s_node}{ID_DELIM}{t_node}')
edges[e_id] = PbEdge(
id=e_id,
suicide=edge[3],
cond=edge[4],
)
edges[e_id].source = source_id
edges[e_id].target = target_id
# Add edge id to node field for resolver reference
task_proxies[target_id].edges.append(e_id)
if s_valid:
task_proxies[source_id].edges.append(e_id)
graph.edges.extend(edges.keys())
if new_points:
self.generate_ghost_families(family_proxies, new_points)
# Replace the originals (atomic update, for access from other threads).
self.data[self.workflow_id][TASK_PROXIES] = task_proxies
self.data[self.workflow_id][EDGES] = edges
self.data[self.workflow_id][GRAPH] = graph
def update_task_proxies(self, updated_tasks=None):
"""Update dynamic fields of task nodes/proxies.
Args:
updated_tasks (list): [cylc.flow.task_proxy.TaskProxy]
Update task-node from corresponding given list of
task proxy objects from the workflow task pool.
"""
if not updated_tasks:
return
tasks = self.data[self.workflow_id][TASKS]
task_proxies = self.data[self.workflow_id][TASK_PROXIES]
update_time = time()
task_defs = {}
# update task instance
for itask in updated_tasks:
name, point_string = TaskID.split(itask.identity)
tp_id = (
f'{self.workflow_id}{ID_DELIM}{point_string}{ID_DELIM}{name}')
if tp_id not in task_proxies:
continue
self.cycle_states.setdefault(point_string,
{})[name] = (itask.state.status,
itask.state.is_held)
# Gather task definitions for elapsed time recalculation.
if name not in task_defs:
task_defs[name] = itask.tdef
# Create new message and copy existing message content.
tproxy = PbTaskProxy()
# to avoid modification while being read.
tproxy.CopyFrom(task_proxies[tp_id])
tproxy.stamp = f'{tp_id}@{update_time}'
tproxy.state = itask.state.status
tproxy.is_held = itask.state.is_held
tproxy.job_submits = itask.submit_num
tproxy.spawned = itask.has_spawned
tproxy.latest_message = itask.summary['latest_message']
tproxy.jobs[:] = self.schd.job_pool.task_jobs.get(tp_id, [])
tproxy.broadcasts[:] = [
f'{key}={val}' for key, val in self.schd.task_events_mgr.
broadcast_mgr.get_broadcast(itask.identity).items()
]
prereq_list = []
for prereq in itask.state.prerequisites:
# Protobuf messages populated within
prereq_obj = prereq.api_dump(self.workflow_id)
if prereq_obj:
prereq_list.append(prereq_obj)
# Unlike the following list comprehension repeated message
# fields cannot be directly assigned, so is cleared first.
del tproxy.prerequisites[:]
tproxy.prerequisites.extend(prereq_list)
tproxy.outputs[:] = [
f'{trigger}={is_completed}'
for trigger, _, is_completed in itask.state.outputs.get_all()
]
# Replace the original
# (atomic update, for access from other threads).
task_proxies[tp_id] = tproxy
# Recalculate effected task def elements elapsed time.
for name, tdef in task_defs.items():
elapsed_time = task_mean_elapsed_time(tdef)
if elapsed_time:
t_id = f'{self.workflow_id}{ID_DELIM}{name}'
tasks[t_id].stamp = f'{t_id}@{update_time}'
tasks[t_id].mean_elapsed_time = elapsed_time
def main(parser, options, suite, *task_ids):
"""cylc submit CLI.
No TASK EVENT HOOKS are set for the submit command because there is
no scheduler instance watching for task failure etc.
Note: a suite contact env file is not written by this command (it
would overwrite the real one if the suite is running).
"""
if not options.verbose and not options.debug:
LOG.setLevel(WARNING)
for task_id in task_ids:
if not TaskID.is_valid_id(task_id):
raise UserInputError("Invalid task ID %s" % task_id)
suiterc = get_suite_rc(suite)
suite_dir = os.path.dirname(suiterc)
# For user-defined batch system handlers
sys.path.append(os.path.join(suite_dir, 'python'))
# Load suite config and tasks
config = SuiteConfig(
suite, suiterc, options,
load_template_vars(options.templatevars, options.templatevars_file))
itasks = []
for task_id in task_ids:
name_str, point_str = TaskID.split(task_id)
taskdefs = config.find_taskdefs(name_str)
if not taskdefs:
raise UserInputError("No task found for %s" % task_id)
for taskdef in taskdefs:
itasks.append(
TaskProxy(taskdef,
get_point(point_str).standardise(),
is_startup=True))
# Initialise job submit environment
make_suite_run_tree(suite)
# Extract job.sh from library, for use in job scripts.
extract_resources(get_suite_srv_dir(suite), ['etc/job.sh'])
pool = SubProcPool()
owner = get_user()
job_pool = JobPool(suite, owner)
db_mgr = SuiteDatabaseManager()
task_job_mgr = TaskJobManager(
suite, pool, db_mgr,
TaskEventsManager(suite, pool, db_mgr, BroadcastMgr(db_mgr), job_pool),
job_pool)
task_job_mgr.task_remote_mgr.single_task_mode = True
task_job_mgr.job_file_writer.set_suite_env({
'CYLC_UTC':
str(config.cfg['cylc']['UTC mode']),
'CYLC_DEBUG':
str(cylc.flow.flags.debug).lower(),
'CYLC_VERBOSE':
str(cylc.flow.flags.verbose).lower(),
'CYLC_SUITE_NAME':
suite,
'CYLC_CYCLING_MODE':
str(config.cfg['scheduling']['cycling mode']),
'CYLC_SUITE_INITIAL_CYCLE_POINT':
str(config.cfg['scheduling']['initial cycle point']),
'CYLC_SUITE_FINAL_CYCLE_POINT':
str(config.cfg['scheduling']['final cycle point']),
})
ret_code = 0
waiting_tasks = list(itasks)
if options.dry_run:
while waiting_tasks:
prep_tasks, bad_tasks = task_job_mgr.prep_submit_task_jobs(
suite, waiting_tasks, dry_run=True)
for itask in prep_tasks + bad_tasks:
waiting_tasks.remove(itask)
if waiting_tasks:
task_job_mgr.proc_pool.process()
sleep(1.0)
for itask in itasks:
if itask.local_job_file_path:
print(('JOB SCRIPT=%s' % itask.local_job_file_path))
else:
print(('Unable to prepare job file for %s' % itask.identity),
file=sys.stderr)
ret_code = 1
else:
while waiting_tasks:
for itask in task_job_mgr.submit_task_jobs(suite, waiting_tasks):
waiting_tasks.remove(itask)
if waiting_tasks:
task_job_mgr.proc_pool.process()
sleep(1.0)
while task_job_mgr.proc_pool.is_not_done():
task_job_mgr.proc_pool.process()
for itask in itasks:
if itask.summary.get('submit_method_id') is not None:
print(('[%s] Job ID: %s' %
(itask.identity, itask.summary['submit_method_id'])))
if itask.state(TASK_STATUS_SUBMIT_FAILED):
ret_code = 1
sys.exit(ret_code)
def main(_, options, suite):
"""Implement cylc broadcast."""
pclient = SuiteRuntimeClient(suite, timeout=options.comms_timeout)
mutation_kwargs = {
'request_string': MUTATION,
'variables': {
'wFlows': [suite],
'bMode': 'Set',
'cPoints': options.point_strings,
'nSpaces': options.namespaces,
'bSettings': options.settings,
'bCutoff': options.expire,
}
}
query_kwargs = {
'request_string': QUERY,
'variables': {
'wFlows': [suite],
'nIds': []
}
}
if options.show or options.showtask:
if options.showtask:
try:
task, point = TaskID.split(options.showtask)
query_kwargs['variables']['nIds'] = [
f'{point}{ID_DELIM}{task}'
]
except ValueError:
raise UserInputError("TASKID must be " + TaskID.SYNTAX)
result = pclient('graphql', query_kwargs)
for wflow in result['workflows']:
settings = wflow['broadcasts']
padding = get_padding(settings) * ' '
if options.raw:
print(str(settings))
else:
print_tree(settings, padding, options.unicode)
sys.exit(0)
report_cancel = True
report_set = False
if options.clear:
mutation_kwargs['variables']['bMode'] = 'Clear'
if options.expire:
mutation_kwargs['variables']['bMode'] = 'Expire'
# implement namespace and cycle point defaults here
namespaces = options.namespaces
if not namespaces:
namespaces = ["root"]
point_strings = options.point_strings
if not point_strings:
point_strings = ["*"]
if options.cancel or options.cancel_files:
settings = []
for option_item in options.cancel:
if "=" in option_item:
raise UserInputError(
"--cancel=[SEC]ITEM does not take a value")
option_item = option_item.strip()
setting = get_rdict(option_item)
settings.append(setting)
files_to_settings(settings, options.cancel_files, options.cancel)
mutation_kwargs['variables'].update({
'bMode': 'Clear',
'cPoints': point_strings,
'nSpaces': namespaces,
'bSettings': settings,
})
if options.settings or options.setting_files:
settings = []
for option_item in options.settings:
if "=" not in option_item:
raise UserInputError("--set=[SEC]ITEM=VALUE requires a value")
lhs, rhs = [s.strip() for s in option_item.split("=", 1)]
setting = get_rdict(lhs, rhs)
settings.append(setting)
files_to_settings(settings, options.setting_files)
mutation_kwargs['variables'].update({
'bMode': 'Set',
'cPoints': point_strings,
'nSpaces': namespaces,
'bSettings': settings,
})
report_cancel = False
report_set = True
results = pclient('graphql', mutation_kwargs)
for result in results['broadcast']['result']:
modified_settings = result['response'][0]
bad_options = result['response'][1]
if modified_settings:
print(
get_broadcast_change_report(modified_settings,
is_cancel=report_cancel))
sys.exit(report_bad_options(bad_options, is_set=report_set))
def generate_graph_elements(self, edges=None, graph=None,
task_proxies=None, family_proxies=None,
start_point=None, stop_point=None):
"""Generate edges and ghost nodes (proxy elements)."""
config = self.schd.config
if edges is None:
edges = {}
if graph is None:
graph = PbEdges()
if task_proxies is None:
task_proxies = {}
if family_proxies is None:
family_proxies = {}
if start_point is None:
start_point = str(self.schd.pool.get_min_point() or '')
if stop_point is None:
stop_point = str(self.schd.pool.get_max_point() or '')
cycle_points = set([])
# Generate ungrouped edges
try:
graph_edges = config.get_graph_edges(start_point, stop_point)
except TypeError:
graph_edges = []
if graph_edges:
for e_list in graph_edges:
# Reference or create edge source & target nodes/proxies
s_node = e_list[0]
t_node = e_list[1]
if s_node is None:
continue
else:
name, point = TaskID.split(s_node)
if name not in self.tasks:
continue
cycle_points.add(point)
if s_node not in task_proxies:
task_proxies[s_node] = (
self._generate_ghost_task(s_node))
source_id = task_proxies[s_node].id
if source_id not in self.tasks[name].proxies:
self.tasks[name].proxies.append(source_id)
if t_node:
if t_node not in task_proxies:
task_proxies[t_node] = (
self._generate_ghost_task(t_node))
target_id = task_proxies[t_node].id
e_id = s_node + '/' + (t_node or 'NoTargetNode')
edges[e_id] = PbEdge(
id=f"{self.workflow_id}/{e_id}",
source=source_id,
suicide=e_list[3],
cond=e_list[4],
)
if t_node:
edges[e_id].target = target_id
graph.edges.extend([e.id for e in edges.values()])
graph.leaves.extend(config.leaves)
graph.feet.extend(config.feet)
for key, info in config.suite_polling_tasks.items():
graph.workflow_polling_tasks.add(
local_proxy=key,
workflow=info[0],
remote_proxy=info[1],
req_state=info[2],
graph_string=info[3],
)
self._generate_ghost_families(family_proxies, cycle_points)
self.workflow.edges.CopyFrom(graph)
# Replace the originals (atomic update, for access from other threads).
self.task_proxies = task_proxies
self.edges = edges
self.graph = graph
def main(_, options, suite):
"""Implement cylc broadcast."""
pclient = SuiteRuntimeClient(
suite, options.owner, options.host, options.port,
options.comms_timeout)
if options.show or options.showtask:
if options.showtask:
try:
TaskID.split(options.showtask)
except ValueError:
raise UserInputError("TASKID must be " + TaskID.SYNTAX)
settings = pclient('get_broadcast', {'task_id': options.showtask})
padding = get_padding(settings) * ' '
if options.raw:
print(str(settings))
else:
print_tree(settings, padding, options.unicode)
sys.exit(0)
if options.clear:
modified_settings, bad_options = pclient(
'clear_broadcast',
{'point_strings': options.point_strings,
'namespaces': options.namespaces}
)
if modified_settings:
print(get_broadcast_change_report(
modified_settings, is_cancel=True))
sys.exit(report_bad_options(bad_options))
if options.expire:
modified_settings, bad_options = pclient(
'expire_broadcast',
{'cutoff': options.expire}
)
if modified_settings:
print(get_broadcast_change_report(
modified_settings, is_cancel=True))
sys.exit(report_bad_options(bad_options))
# implement namespace and cycle point defaults here
namespaces = options.namespaces
if not namespaces:
namespaces = ["root"]
point_strings = options.point_strings
if not point_strings:
point_strings = ["*"]
if options.cancel or options.cancel_files:
settings = []
for option_item in options.cancel:
if "=" in option_item:
raise UserInputError(
"--cancel=[SEC]ITEM does not take a value")
option_item = option_item.strip()
setting = get_rdict(option_item)
settings.append(setting)
files_to_settings(settings, options.cancel_files, options.cancel)
modified_settings, bad_options = pclient(
'clear_broadcast',
{'point_strings': point_strings,
'namespaces': namespaces,
'cancel_settings': settings}
)
if modified_settings:
print(get_broadcast_change_report(
modified_settings, is_cancel=True))
sys.exit(report_bad_options(bad_options))
if options.settings or options.setting_files:
settings = []
for option_item in options.settings:
if "=" not in option_item:
raise UserInputError(
"--set=[SEC]ITEM=VALUE requires a value")
lhs, rhs = [s.strip() for s in option_item.split("=", 1)]
setting = get_rdict(lhs, rhs)
settings.append(setting)
files_to_settings(settings, options.setting_files)
modified_settings, bad_options = pclient(
'put_broadcast',
{'point_strings': point_strings,
'namespaces': namespaces,
'settings': settings
}
)
print(get_broadcast_change_report(modified_settings))
sys.exit(report_bad_options(bad_options, is_set=True))
def main(parser: COP,
options: 'Values',
reg: str,
task_id: Optional[str] = None,
color: bool = False) -> None:
"""Implement cylc cat-log CLI.
Determine log path, user@host, batchview_cmd, and action (print, dir-list,
cat, edit, or tail), and then if the log path is:
a) local: perform action on log path, or
b) remote: re-invoke cylc cat-log as a) on the remote account
"""
if options.remote_args:
# Invoked on job hosts for job logs only, as a wrapper to view_log().
# Tail and batchview commands from global config on workflow host).
logpath, mode, tail_tmpl = options.remote_args[0:3]
logpath = expand_path(logpath)
tail_tmpl = expand_path(tail_tmpl)
try:
batchview_cmd = options.remote_args[3]
except IndexError:
batchview_cmd = None
res = view_log(logpath,
mode,
tail_tmpl,
batchview_cmd,
remote=True,
color=color)
if res == 1:
sys.exit(res)
return
workflow_name, _ = parse_reg(reg)
# Get long-format mode.
try:
mode = MODES[options.mode]
except KeyError:
mode = options.mode
if not task_id:
# Cat workflow logs, local only.
if options.filename is not None:
raise UserInputError("The '-f' option is for job logs only.")
logpath = get_workflow_run_log_name(workflow_name)
if options.rotation_num:
logs = glob('%s.*' % logpath)
logs.sort(key=os.path.getmtime, reverse=True)
try:
logpath = logs[int(options.rotation_num)]
except IndexError:
raise UserInputError("max rotation %d" % (len(logs) - 1))
tail_tmpl = os.path.expandvars(get_platform()["tail command template"])
out = view_log(logpath, mode, tail_tmpl, color=color)
if out == 1:
sys.exit(1)
if mode == 'edit':
tmpfile_edit(out, options.geditor)
return
if task_id:
# Cat task job logs, may be on workflow or job host.
if options.rotation_num is not None:
raise UserInputError("only workflow (not job) logs get rotated")
try:
task, point = TaskID.split(task_id)
except ValueError:
parser.error("Illegal task ID: %s" % task_id)
if options.submit_num != NN:
try:
options.submit_num = "%02d" % int(options.submit_num)
except ValueError:
parser.error("Illegal submit number: %s" % options.submit_num)
if options.filename is None:
options.filename = JOB_LOG_OUT
else:
# Convert short filename args to long (e.g. 'o' to 'job.out').
with suppress(KeyError):
options.filename = JOB_LOG_OPTS[options.filename]
# KeyError: Is already long form (standard log, or custom).
platform_name, job_runner_name, live_job_id = get_task_job_attrs(
workflow_name, point, task, options.submit_num)
platform = get_platform(platform_name)
batchview_cmd = None
if live_job_id is not None:
# Job is currently running. Get special job runner log view
# command (e.g. qcat) if one exists, and the log is out or err.
conf_key = None
if options.filename == JOB_LOG_OUT:
if mode == 'cat':
conf_key = "out viewer"
elif mode == 'tail':
conf_key = "out tailer"
elif options.filename == JOB_LOG_ERR:
if mode == 'cat':
conf_key = "err viewer"
elif mode == 'tail':
conf_key = "err tailer"
if conf_key is not None:
batchview_cmd_tmpl = None
with suppress(KeyError):
batchview_cmd_tmpl = platform[conf_key]
if batchview_cmd_tmpl is not None:
batchview_cmd = batchview_cmd_tmpl % {
"job_id": str(live_job_id)
}
log_is_remote = (is_remote_platform(platform)
and (options.filename != JOB_LOG_ACTIVITY))
log_is_retrieved = (platform['retrieve job logs']
and live_job_id is None)
if log_is_remote and (not log_is_retrieved or options.force_remote):
logpath = os.path.normpath(
get_remote_workflow_run_job_dir(workflow_name, point, task,
options.submit_num,
options.filename))
tail_tmpl = platform["tail command template"]
# Reinvoke the cat-log command on the remote account.
cmd = ['cat-log', *verbosity_to_opts(cylc.flow.flags.verbosity)]
for item in [logpath, mode, tail_tmpl]:
cmd.append('--remote-arg=%s' % shlex.quote(item))
if batchview_cmd:
cmd.append('--remote-arg=%s' % shlex.quote(batchview_cmd))
cmd.append(workflow_name)
is_edit_mode = (mode == 'edit')
# TODO: Add Intelligent Host selection to this
try:
proc = remote_cylc_cmd(cmd,
platform,
capture_process=is_edit_mode,
manage=(mode == 'tail'))
except KeyboardInterrupt:
# Ctrl-C while tailing.
pass
else:
if is_edit_mode:
# Write remote stdout to a temp file for viewing in editor.
# Only BUFSIZE bytes at a time in case huge stdout volume.
out = NamedTemporaryFile()
data = proc.stdout.read(BUFSIZE)
while data:
out.write(data)
data = proc.stdout.read(BUFSIZE)
os.chmod(out.name, S_IRUSR)
out.seek(0, 0)
else:
# Local task job or local job log.
logpath = os.path.normpath(
get_workflow_run_job_dir(workflow_name, point, task,
options.submit_num, options.filename))
tail_tmpl = os.path.expandvars(platform["tail command template"])
out = view_log(logpath,
mode,
tail_tmpl,
batchview_cmd,
color=color)
if mode != 'edit':
sys.exit(out)
if mode == 'edit':
tmpfile_edit(out, options.geditor)
def test_split(self):
self.assertEqual(["a", '1'], TaskID.split("a.1"))
self.assertEqual(["a", '_1'], TaskID.split("a._1"))
self.assertEqual(
["WTAS", '20101010T101010'], TaskID.split("WTAS.20101010T101010"))
