def __init__(self, name, category, ttl=DAY, description='', **kwargs):
self.ttl = ttl
self.category = category
self._name, self.extension = os.path.splitext(name)
self._name = substitute_config(self._name)
self.extension = self.extension.replace('.', '')
self._content = None
self.description = description
def get_evidence_dependency(path, locker, fetcher=None):
"""
Provide evidence to fetchers that depend on that other evidence to fetch.
Use when a fetcher needs evidence fetched by another fetcher in order to
complete its fetch process. The premise is that if the evidence is in the
evidence cache then return that because it was placed there by another
fetcher. If not then get the evidence directly from the locker without
putting that evidence into the evidence cache. When an evidence dependency
is not found the fetcher is queued up as a dependency rerun for subsequent
processing.
:param path: relative path to the evidence within the Locker. For example,
``raw/source1/evidence.json``.
:param locker: evidence Locker object.
:param fetcher: optional Python notation path to fetcher method. If
provided, this defines the fetcher that is added to the re-run list.
Otherwise the execution stack is traversed to find the fetcher caller.
:returns: the evidence object.
"""
path = substitute_config(path)
evidence = get_config().get_evidence(path)
if evidence is None or evidence.content is None:
try:
evidence = locker.get_evidence(path)
except (StaleEvidenceError, EvidenceNotFoundError):
rerun = None
if fetcher:
module, clss, method = fetcher.rsplit('.', 2)
rerun = {'module': module, 'class': clss, 'method': method}
else:
for frame_info in inspect.stack()[1:]:
if frame_info.function.startswith(FETCH_PREFIX):
frame = frame_info.frame
rerun = {
'module': inspect.getmodule(frame).__name__,
'class': frame.f_locals['self'].__class__.__name__,
'method': frame.f_code.co_name
}
break
if not rerun:
raise DependencyFetcherNotFoundError(
f'Cannot re-run, no fetcher found for evidence {path}.')
locker.dependency_rerun.append(rerun)
raise DependencyUnavailableError(
f'evidence dependency {path} is currently unavailable.')
return evidence
def get_evidence_by_path(path, locker=None):
"""
Provide an evidence object specified by the given path.
The following strategy is used:
* Return evidence if it is present in the evidence cache populating
content if necessary and possible.
* If evidence is not in the evidence cache but a locker is provided, then
the evidence will be retrieved from the locker.
* Otherwise, an evidence object is built with the default parameters.
:param path: relative path to the evidence within the Locker. For example,
``raw/source1/evidence.json``.
:returns: the evidence object.
"""
path = substitute_config(path)
evidence = get_config().get_evidence(path)
if evidence:
if locker and evidence.content is None:
evidence = locker.load_content(evidence)
return evidence
if locker:
try:
evidence = locker.get_evidence(path)
get_config().add_evidences([evidence])
return evidence
except ValueError:
pass
try:
rootdir, category, name = path.strip('/').split('/')
except ValueError:
raise ValueError(f'Invalid evidence path format "{path}"')
if rootdir not in __init_map:
raise ValueError(f'Unable to create evidence from root dir {rootdir}')
return __init_map[rootdir](name, category)
def name(self):
return substitute_config(self._name)
def from_locker(cls, path, locker):
path = substitute_config(path)
return cls(locker.get_evidence(path))
