def set_uuid(self, nodetype):
"""Create and set a new UUID, for a given type of node.
:param nodetype: Type of node
:return: The new UUID
"""
uuid = UUID.u()
self[NodeType.get_id(nodetype)] = uuid
return uuid
def check(nodetype, **kwargs):
"""Get status of a task or template (etc.).
:param nodetype: Type of thing you are looking for
:type nodetype: str, See ``NodeType`` for defined values
:param state: Only look at nodes in the given state (default=DONE, None for any)
:type state: str
:param multiple: If True, return all matching items; otherwise group by nodetype and, if given, name.
Return only the last record for each grouping.
:type multiple: bool
:param names: List of names (may be regular expressions) of nodes to look for.
:type names: list of str, or str
:param program_id: Only checks the nodes for the specifed program
:param template_id: only checks the nodes that belong to the template with
the specified template_id.
:return: list(LogStatus). See parameter `multiple`.
"""
if _log is None:
raise NotInitializedError("check")
if not NodeType.is_known(nodetype):
raise ValueError(
"Unknown nodetype {}, not in {}".format(nodetype, NodeType.known()))
node_id_key = NodeType.get_id(nodetype)
check_nodetype = nodetype != NodeType.ANY
check_state = 'state' in kwargs and kwargs['state'] is not None
multiple = False
in_template_id = None
in_program_id = None
if 'template_id' in kwargs:
in_template_id = kwargs['template_id']
if 'program_id' in kwargs:
in_program_id = kwargs['program_id']
if not in_program_id:
in_program_id = _program_uuid
if 'multiple' in kwargs:
multiple = kwargs['multiple']
name_filters = []
names = None
if 'names' in list(kwargs.keys()):
names = kwargs['names']
if isinstance(names, str):
names = [names]
if not names:
names = ['']
for name in names:
if not name.startswith('^'):
name = '.*' + name
name_filters.append(re.compile(name))
def fltr(rec):
if in_program_id and not in_program_id == rec.get(Keyword.PROGRAM_UID, None):
return False
if rec.get(Keyword.NODETYPE, None) is None or rec.get(Keyword.NAME, None) is None:
return False
if check_nodetype and not rec.get(Keyword.NODETYPE, None).startswith(nodetype):
return False
if in_template_id and not in_template_id.replace(" ", "+") == rec.get(Keyword.TMPL_UID, None):
return False
if check_state:
log_state = rec.get(Keyword.STATE, None)
if log_state is not None and kwargs['state'] != log_state:
return False
if name_filters:
return any([nf.match(rec.get(Keyword.NAME, "")) for nf in name_filters])
else:
return True
# Let's keep the results in order that the
# nodes are created in (i.e. when they are logged as new)
result = OrderedDict()
keylist = [Keyword.NODETYPE]
keylist.append(Keyword.NAME)
keylist.append(node_id_key)
if _log and _log.is_file: # XXX: Put this logic in BaseLogger subclasses
with open(_log.path, 'rb') as f:
linenum = 1
try:
for rec in Reader(f):
if fltr(rec):
key = '#'.join([rec.get(k, '') for k in keylist])
if multiple:
# keep a list per name
_dict_append(result, key, rec)
else:
# keep only 1 per name
result[key] = rec
linenum += 1
except ValueError as err:
# add line number to error before re-raising
raise ValueError("Line {:d}: {}".format(linenum, err))
else:
raise NotImplementedError(
'Only know how to search files, not {}'.format(_log.path))
if result:
if multiple:
flattened = itertools.chain.from_iterable(iter(result.values()))
return list(map(LogStatus, flattened))
else:
return list(map(LogStatus, list(result.values())))
else:
return None
def get_uuid(self, nodetype):
return self[NodeType.get_id(nodetype)]
