def __call__(spec, dataset=None):
if not isinstance(spec, (tuple, list)):
# maybe coming from config
import shlex
spec = shlex.split(spec)
name = spec[0]
args = spec[1:]
procedure_file = _get_procedure_implementation(name, ds=dataset)
if not procedure_file:
# TODO error result
raise ValueError("Cannot find procedure with name '%s'", name)
ds = require_dataset(dataset,
check_installed=False,
purpose='run a procedure') if dataset else None
cmd_tmpl = _guess_exec(procedure_file)
cmd = cmd_tmpl.format(script=procedure_file,
ds=ds.path if ds else '',
args=u' '.join(u'"{}"'.format(a)
for a in args) if args else '')
lgr.debug('Attempt to run procedure {} as: {}'.format(name, cmd))
for r in Run.__call__(
cmd=cmd,
dataset=ds,
# See gh-2593 for discussion on run feature extension
#explicit=True,
#inputs=None,
#outputs=None,
# pass through here
on_failure='ignore',
):
yield r
def __call__(spec=None, dataset=None, discover=False, help_proc=False):
if not spec and not discover:
raise InsufficientArgumentsError(
'requires at least a procedure name')
if help_proc and not spec:
raise InsufficientArgumentsError('requires a procedure name')
try:
ds = require_dataset(dataset,
check_installed=False,
purpose='run a procedure')
except NoDatasetArgumentFound:
ds = None
if discover:
reported = set()
for m, cmd_tmpl, cmd_help in _get_procedure_implementation('*',
ds=ds):
if m in reported:
continue
ex = _guess_exec(m)
# configured template (call-format string) takes precedence:
if cmd_tmpl:
ex['template'] = cmd_tmpl
if ex['type'] is None and ex['template'] is None:
# doesn't seem like a match
lgr.debug(
"Neither type nor execution template found for "
"%s. Ignored.", m)
continue
message = ex['type'] if ex['type'] else 'unknown type'
message += ' (missing)' if ex['state'] == 'absent' else ''
res = get_status_dict(action='run_procedure',
path=m,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='ok',
state=ex['state'],
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
message=message)
reported.add(m)
yield res
return
if not isinstance(spec, (tuple, list)):
# maybe coming from config
import shlex
spec = shlex.split(spec)
name = spec[0]
args = spec[1:]
try:
# get the first match an run with it
procedure_file, cmd_tmpl, cmd_help = \
next(_get_procedure_implementation(name, ds=ds))
except StopIteration:
res = get_status_dict(
action='run_procedure',
# TODO: Default renderer requires a key "path" to exist.
# Doesn't make a lot of sense in this case
path=name,
logger=lgr,
refds=ds.path if ds else None,
status='impossible',
message="Cannot find procedure with name '%s'" % name)
yield res
return
ex = _guess_exec(procedure_file)
# configured template (call-format string) takes precedence:
if cmd_tmpl:
ex['template'] = cmd_tmpl
if help_proc:
if cmd_help:
res = get_status_dict(action='procedure_help',
path=procedure_file,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='ok',
state=ex['state'],
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
message=cmd_help)
else:
res = get_status_dict(action='procedure_help',
path=procedure_file,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='impossible',
state=ex['state'],
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
message="No help available for '%s'" %
name)
yield res
return
if not ex['template']:
raise ValueError("No idea how to execute procedure %s. "
"Missing 'execute' permissions?" % procedure_file)
cmd = ex['template'].format(
script=procedure_file,
ds=ds.path if ds else '',
args=u' '.join(u'"{}"'.format(a) for a in args) if args else '')
lgr.debug('Attempt to run procedure {} as: {}'.format(name, cmd))
for r in Run.__call__(
cmd=cmd,
dataset=ds,
explicit=True,
inputs=None,
outputs=None,
# pass through here
on_failure='ignore',
):
yield r
def __call__(
spec=None,
dataset=None,
discover=False,
help_proc=False):
if not spec and not discover:
raise InsufficientArgumentsError('requires at least a procedure name')
if help_proc and not spec:
raise InsufficientArgumentsError('requires a procedure name')
try:
ds = require_dataset(
dataset, check_installed=False,
purpose='run a procedure')
except NoDatasetArgumentFound:
ds = None
if discover:
reported = set()
for m, cmd_name, cmd_tmpl, cmd_help in \
_get_procedure_implementation('*', ds=ds):
if m in reported:
continue
ex = _guess_exec(m)
# configured template (call-format string) takes precedence:
if cmd_tmpl:
ex['template'] = cmd_tmpl
if ex['type'] is None and ex['template'] is None:
# doesn't seem like a match
lgr.debug("Neither type nor execution template found for "
"%s. Ignored.", m)
continue
message = ex['type'] if ex['type'] else 'unknown type'
message += ' (missing)' if ex['state'] == 'absent' else ''
res = get_status_dict(
action='discover_procedure',
path=m,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='ok',
state=ex['state'],
procedure_name=cmd_name,
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
procedure_help=cmd_help,
message=message)
reported.add(m)
yield res
return
if not isinstance(spec, (tuple, list)):
# maybe coming from config
import shlex
spec = shlex.split(spec)
name = spec[0]
args = spec[1:]
try:
# get the first match an run with it
procedure_file, cmd_name, cmd_tmpl, cmd_help = \
next(_get_procedure_implementation(name, ds=ds))
except StopIteration:
res = get_status_dict(
action='run_procedure',
# TODO: Default renderer requires a key "path" to exist.
# Doesn't make a lot of sense in this case
path=name,
logger=lgr,
refds=ds.path if ds else None,
status='impossible',
message="Cannot find procedure with name '%s'" % name)
yield res
return
ex = _guess_exec(procedure_file)
# configured template (call-format string) takes precedence:
if cmd_tmpl:
ex['template'] = cmd_tmpl
if help_proc:
if cmd_help:
res = get_status_dict(
action='procedure_help',
path=procedure_file,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='ok',
state=ex['state'],
procedure_name=cmd_name,
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
message=cmd_help)
else:
res = get_status_dict(
action='procedure_help',
path=procedure_file,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='impossible',
state=ex['state'],
procedure_name=cmd_name,
procedure_type=ex['type'],
procedure_callfmt=ex['template'],
message="No help available for '%s'" % name)
yield res
return
if not ex['template']:
raise ValueError("No idea how to execute procedure %s. "
"Missing 'execute' permissions?" % procedure_file)
cmd = ex['template'].format(
script=procedure_file,
ds=ds.path if ds else '',
args=u' '.join(u'"{}"'.format(a) for a in args) if args else '')
lgr.debug('Attempt to run procedure {} as: {}'.format(
name,
cmd))
for r in Run.__call__(
cmd=cmd,
dataset=ds,
explicit=True,
inputs=None,
outputs=None,
# pass through here
on_failure='ignore',
return_type='generator'
):
yield r
def __call__(
spec=None,
dataset=None,
discover=False):
if not spec and not discover:
raise InsufficientArgumentsError('requires at least a procedure name')
ds = require_dataset(
dataset, check_installed=False,
purpose='run a procedure') if dataset else None
if discover:
reported = set()
for m in _get_procedure_implementation('*', ds=ds):
if m in reported:
continue
cmd_type, cmd_tmpl = _guess_exec(m)
res = get_status_dict(
action='run_procedure',
path=m,
type='file',
logger=lgr,
refds=ds.path if ds else None,
status='ok',
procedure_type=cmd_type,
procedure_callfmt=cmd_tmpl,
message=cmd_type)
reported.add(m)
yield res
return
if not isinstance(spec, (tuple, list)):
# maybe coming from config
import shlex
spec = shlex.split(spec)
name = spec[0]
args = spec[1:]
try:
# get the first match an run with it
procedure_file = next(_get_procedure_implementation(name, ds=ds))
except StopIteration:
# TODO error result
raise ValueError("Cannot find procedure with name '%s'", name)
cmd_type, cmd_tmpl = _guess_exec(procedure_file)
if cmd_tmpl is None:
raise ValueError(
"No idea how to execute procedure %s. Missing 'execute' permissions?",
procedure_file)
cmd = cmd_tmpl.format(
script=procedure_file,
ds=ds.path if ds else '',
args=u' '.join(u'"{}"'.format(a) for a in args) if args else '')
lgr.debug('Attempt to run procedure {} as: {}'.format(
name,
cmd))
for r in Run.__call__(
cmd=cmd,
dataset=ds,
explicit=True,
inputs=None,
outputs=None,
# pass through here
on_failure='ignore',
):
yield r
def __call__(cmd, container_name=None, dataset=None,
inputs=None, outputs=None, message=None, expand=None,
explicit=False, sidecar=None):
pwd, _ = get_command_pwds(dataset)
ds = require_dataset(dataset, check_installed=True,
purpose='run a containerized command execution')
# get the container list
containers = {c['name']: c
for c in ContainersList.__call__(dataset=ds)}
if container_name is None and len(containers) == 1:
# no questions asked, take container and run
container = containers.popitem()[1]
elif container_name and container_name in containers:
container = containers[container_name]
else:
# anything else is an error
raise ValueError(
'Container selection impossible: not specified or unknown '
'(known containers are: {})'.format(list(containers.keys())))
image_path = op.relpath(container["path"], pwd)
# sure we could check whether the container image is present,
# but it might live in a subdataset that isn't even installed yet
# let's leave all this business to `get` that is called by `run`
cmd = normalize_command(cmd)
# expand the command with container execution
if 'cmdexec' in container:
callspec = container['cmdexec']
# Temporary kludge to give a more helpful message
if callspec.startswith("["):
import simplejson
try:
simplejson.loads(callspec)
except simplejson.errors.JSONDecodeError:
pass # Never mind, false positive.
else:
raise ValueError(
'cmdexe {!r} is in an old, unsupported format. '
'Convert it to a plain string.'.format(callspec))
cmd = callspec.format(img=image_path, cmd=cmd)
else:
# just prepend and pray
cmd = container['path'] + ' ' + cmd
# with amend inputs to also include the container image
inputs = (inputs or []) + [image_path]
# fire!
for r in Run.__call__(
cmd=cmd,
dataset=ds,
inputs=inputs,
outputs=outputs,
message=message,
expand=expand,
explicit=explicit,
sidecar=sidecar,
on_failure="ignore"):
yield r