def identity(self):
if self.task.identity is not None:
return self.task.identity
# Acquire workspace resources before calculating the identity
for c in self.children:
if c.is_workspace_resource():
c.task.acquire_ws()
sha = hashlib.sha1()
HashInfluenceRegistry.get().apply_all(self.task, sha)
self.task.identity = sha.hexdigest()
return str(self.task.identity)
def inspect(ctx, task, influence=False, artifact=False, salt=None):
"""
View information about a task.
This command displays information about a task, such as its class
documentation, parameters and their accepted values, requirements,
task class origin (file/line), influence attributes, artifact identity,
cache status, and more. Default parameter values, if any, are highlighted.
"""
task_name = task
task_cls_name, task_params = utils.parse_task_name(task_name)
task_registry = TaskRegistry.get()
task = task_registry.get_task_class(task_cls_name)
raise_task_error_if(not task, task_name, "no such task")
from jolt import inspection
print()
print(" {0}".format(task.name))
print()
if task.__doc__:
print(" {0}".format(task.__doc__.strip()))
print()
print(" Parameters")
has_param = False
params = {
key: getattr(task, key)
for key in dir(task)
if isinstance(utils.getattr_safe(task, key), Parameter)
}
for item, param in params.items():
has_param = True
print(" {0:<15} {1}".format(item, param.help or ""))
if not has_param:
print(" None")
print()
print(" Definition")
print(" {0:<15} {1} ({2})".format(
"File",
fs.path.relpath(inspection.getfile(task),
JoltLoader.get().joltdir), inspection.getlineno(task)))
print()
print(" Requirements")
manifest = ctx.obj["manifest"]
try:
task = task_registry.get_task(task_name, manifest=manifest)
for req in sorted(
utils.as_list(utils.call_or_return(task, task.requires))):
print(" {0}".format(task.tools.expand(req)))
if not task.requires:
print(" None")
print()
except Exception as e:
log.exception()
if "has not been set" in str(e):
print(" Unavailable (parameters must be set)")
print()
return
print(" Unavailable (exception during evaluation)")
print()
return
if salt:
task.taint = salt
if artifact:
acache = cache.ArtifactCache.get()
builder = graph.GraphBuilder(task_registry, manifest)
dag = builder.build([task.qualified_name])
tasks = dag.select(lambda graph, node: node.task is task)
assert len(tasks) == 1, "graph produced multiple tasks, one expected"
proxy = tasks[0]
task = proxy.task
print(" Cache")
print(" Identity {0}".format(proxy.identity))
if acache.is_available_locally(proxy):
with acache.get_artifact(proxy) as artifact:
print(" Location {0}".format(artifact.path))
print(" Local True ({0})".format(
utils.as_human_size(acache.get_artifact(proxy).get_size())))
else:
print(" Local False")
print(" Remote {0}".format(
acache.is_available_remotely(proxy)))
print()
if influence:
print(" Influence")
for string in HashInfluenceRegistry.get().get_strings(task):
string = string.split(":", 1)
print(" {:<18}{}".format(string[0][10:], string[1].strip()))
def global_influence(path, cls=GitInfluenceProvider):
HashInfluenceRegistry.get().register(cls(path))
def global_influence(path,
include=None,
exclude=None,
network=True,
cls=RepoInfluenceProvider):
HashInfluenceRegistry.get().register(cls(path, include, exclude, network))