def get_runnertype_by_name(runnertype_name):
"""
Get an runnertype by name.
On error, raise ST2ObjectNotFoundError.
"""
try:
runnertypes = RunnerType.query(name=runnertype_name)
except (ValueError, ValidationError) as e:
LOG.error(
'Database lookup for name="%s" resulted in exception: %s',
runnertype_name,
e,
)
raise StackStormDBObjectNotFoundError(
'Unable to find runnertype with name="%s"' % runnertype_name
)
if not runnertypes:
raise StackStormDBObjectNotFoundError(
'Unable to find RunnerType with name="%s"' % runnertype_name
)
if len(runnertypes) > 1:
LOG.warning(
"More than one RunnerType returned from DB lookup by name. "
"Result list is: %s",
runnertypes,
)
return runnertypes[0]
def get_one(self, ref_or_id, file_path, requester_user, **kwargs):
"""
Outputs the content of a specific file in a pack.
Handles requests:
GET /packs/views/file/<pack_ref_or_id>/<file path>
"""
pack_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
if not pack_db:
msg = 'Pack with ref_or_id "%s" does not exist' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
if not file_path:
raise ValueError('Missing file path')
pack_ref = pack_db.ref
# Note: Until list filtering is in place we don't require RBAC check for icon file
permission_type = PermissionType.PACK_VIEW
if file_path not in WHITELISTED_FILE_PATHS:
rbac_utils.assert_user_has_resource_db_permission(
user_db=requester_user,
resource_db=pack_db,
permission_type=permission_type)
normalized_file_path = get_pack_file_abs_path(pack_ref=pack_ref,
file_path=file_path)
if not normalized_file_path or not os.path.isfile(
normalized_file_path):
# Ignore references to files which don't exist on disk
raise StackStormDBObjectNotFoundError('File "%s" not found' %
(file_path))
file_size, file_mtime = self._get_file_stats(
file_path=normalized_file_path)
response = Response()
if not self._is_file_changed(file_mtime, **kwargs):
response.status = http_client.NOT_MODIFIED
else:
if file_size is not None and file_size > MAX_FILE_SIZE:
msg = ('File %s exceeds maximum allowed file size (%s bytes)' %
(file_path, MAX_FILE_SIZE))
raise ValueError(msg)
content_type = mimetypes.guess_type(normalized_file_path)[0] or \
'application/octet-stream'
response.headers['Content-Type'] = content_type
response.body = self._get_file_content(
file_path=normalized_file_path)
response.headers['Last-Modified'] = format_date_time(file_mtime)
response.headers['ETag'] = repr(file_mtime)
return response
def get_one(self, group_id, requester_user):
rbac_utils = get_rbac_backend().get_utils_class()
rbac_utils.assert_user_is_admin(user_db=requester_user)
coordinator = coordination.get_coordinator()
if not isinstance(group_id, six.binary_type):
group_id = group_id.encode('utf-8')
try:
member_ids = list(coordinator.get_members(group_id).get())
except GroupNotCreated:
msg = ('Group with ID "%s" not found.' % (group_id.decode('utf-8')))
raise StackStormDBObjectNotFoundError(msg)
result = {
'members': []
}
for member_id in member_ids:
capabilities = coordinator.get_member_capabilities(group_id, member_id).get()
item = {
'group_id': group_id.decode('utf-8'),
'member_id': member_id.decode('utf-8'),
'capabilities': capabilities
}
result['members'].append(item)
return result
def get_one(self, name_or_id, *file_path_components):
"""
Outputs the content of all the files inside the pack.
Handles requests:
GET /packs/views/files/<pack_name>/<file path>
"""
pack_db = self._get_by_name_or_id(name_or_id=name_or_id)
if not file_path_components:
raise ValueError('Missing file path')
file_path = os.path.join(*file_path_components)
pack_name = pack_db.name
normalized_file_path = get_pack_file_abs_path(pack_name=pack_name,
file_path=file_path)
if not normalized_file_path or not os.path.isfile(
normalized_file_path):
# Ignore references to files which don't exist on disk
raise StackStormDBObjectNotFoundError('File "%s" not found' %
(file_path))
content = self._get_file_content(file_path=normalized_file_path)
return content
def get(self, *args, **kwargs):
exclude_fields = kwargs.pop('exclude_fields', None)
raise_exception = kwargs.pop('raise_exception', False)
only_fields = kwargs.pop('only_fields', None)
args = self._process_arg_filters(args)
instances = self.model.objects(*args, **kwargs)
if exclude_fields:
instances = instances.exclude(*exclude_fields)
if only_fields:
try:
instances = instances.only(*only_fields)
except mongoengine.errors.LookUpError as e:
msg = (
'Invalid or unsupported include attribute specified: %s' %
str(e))
raise ValueError(msg)
instance = instances[0] if instances else None
log_query_and_profile_data_for_queryset(queryset=instances)
if not instance and raise_exception:
msg = 'Unable to find the %s instance. %s' % (self.model.__name__,
kwargs)
raise StackStormDBObjectNotFoundError(msg)
return instance
def _get_by_ref_or_id(self, ref_or_id, exclude_fields=None, include_fields=None):
"""
Retrieve resource object by an id of a reference.
Note: This method throws StackStormDBObjectNotFoundError exception if the object is not
found in the database.
"""
if exclude_fields and include_fields:
msg = ('exclude_fields and include_fields arguments are mutually exclusive. '
'You need to provide either one or another, but not both.')
raise ValueError(msg)
if ResourceReference.is_resource_reference(ref_or_id):
# references always contain a dot and id's can't contain it
is_reference = True
else:
is_reference = False
if is_reference:
resource_db = self._get_by_ref(resource_ref=ref_or_id, exclude_fields=exclude_fields,
include_fields=include_fields)
else:
resource_db = self._get_by_id(resource_id=ref_or_id, exclude_fields=exclude_fields,
include_fields=include_fields)
if not resource_db:
msg = 'Resource with a reference or id "%s" not found' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
return resource_db
def get_one(self, ref_or_id, requester_user):
"""
Outputs the file associated with action entry_point
Handles requests:
GET /actions/views/entry_point/1
"""
LOG.info('GET /actions/views/entry_point with ref_or_id=%s', ref_or_id)
action_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
permission_type = PermissionType.ACTION_VIEW
rbac_utils.assert_user_has_resource_db_permission(
user_db=requester_user,
resource_db=action_db,
permission_type=permission_type)
pack = getattr(action_db, 'pack', None)
entry_point = getattr(action_db, 'entry_point', None)
abs_path = utils.get_entry_point_abs_path(pack, entry_point)
if not abs_path:
raise StackStormDBObjectNotFoundError(
'Action ref_or_id=%s has no entry_point to output' % ref_or_id)
with open(abs_path) as file:
content = file.read()
return content
def create_trigger_instance(trigger,
payload,
occurrence_time,
raise_on_no_trigger=False):
"""
This creates a trigger instance object given trigger and payload.
Trigger can be just a string reference (pack.name) or a ``dict`` containing 'id' or
'uid' or type' and 'parameters' keys.
:param trigger: Trigger reference or dictionary with trigger query filters.
:type trigger: ``str`` or ``dict``
:param payload: Trigger payload.
:type payload: ``dict``
"""
trigger_db = get_trigger_db_by_ref_or_dict(trigger=trigger)
if not trigger_db:
LOG.debug("No trigger in db for %s", trigger)
if raise_on_no_trigger:
raise StackStormDBObjectNotFoundError("Trigger not found for %s" %
trigger)
return None
trigger_ref = trigger_db.get_reference().ref
trigger_instance = TriggerInstanceDB()
trigger_instance.trigger = trigger_ref
trigger_instance.payload = payload
trigger_instance.occurrence_time = occurrence_time
trigger_instance.status = TRIGGER_INSTANCE_PENDING
return TriggerInstance.add_or_update(trigger_instance)
def _schedule_execution(self, action_alias_db, params, notify, context, requester_user,
show_secrets):
action_ref = action_alias_db.action_ref
action_db = action_utils.get_action_by_ref(action_ref)
if not action_db:
raise StackStormDBObjectNotFoundError('Action with ref "%s" not found ' % (action_ref))
assert_user_has_resource_db_permission(user_db=requester_user, resource_db=action_db,
permission_type=PermissionType.ACTION_EXECUTE)
try:
# prior to shipping off the params cast them to the right type.
params = action_param_utils.cast_params(action_ref=action_alias_db.action_ref,
params=params,
cast_overrides=CAST_OVERRIDES)
if not context:
context = {
'action_alias_ref': reference.get_ref_from_model(action_alias_db),
'user': get_system_username()
}
liveaction = LiveActionDB(action=action_alias_db.action_ref, context=context,
parameters=params, notify=notify)
_, action_execution_db = action_service.request(liveaction)
mask_secrets = self._get_mask_secrets(requester_user, show_secrets=show_secrets)
return ActionExecutionAPI.from_model(action_execution_db, mask_secrets=mask_secrets)
except ValueError as e:
LOG.exception('Unable to execute action.')
abort(http_client.BAD_REQUEST, str(e))
except jsonschema.ValidationError as e:
LOG.exception('Unable to execute action. Parameter validation failed.')
abort(http_client.BAD_REQUEST, str(e))
except Exception as e:
LOG.exception('Unable to execute action. Unexpected error encountered.')
abort(http_client.INTERNAL_SERVER_ERROR, str(e))
def _get_by_ref_or_id(self, ref_or_id, exclude_fields=None):
"""
Retrieve resource object by an id of a reference.
Note: This method throws StackStormDBObjectNotFoundError exception if the object is not
found in the database.
"""
if ResourceReference.is_resource_reference(ref_or_id):
# references always contain a dot and id's can't contain it
is_reference = True
else:
is_reference = False
if is_reference:
resource_db = self._get_by_ref(resource_ref=ref_or_id,
exclude_fields=exclude_fields)
else:
resource_db = self._get_by_id(resource_id=ref_or_id,
exclude_fields=exclude_fields)
if not resource_db:
msg = 'Resource with a reference or id "%s" not found' % (
ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
return resource_db
def create_trigger_instance(trigger,
payload,
occurrence_time,
raise_on_no_trigger=False):
"""
This creates a trigger instance object given trigger and payload.
Trigger can be just a string reference (pack.name) or a ``dict`` containing 'id' or
'uid' or type' and 'parameters' keys.
:param trigger: Trigger reference or dictionary with trigger query filters.
:type trigger: ``str`` or ``dict``
:param payload: Trigger payload.
:type payload: ``dict``
"""
# TODO: This is nasty, this should take a unique reference and not a dict
if isinstance(trigger, six.string_types):
trigger_db = TriggerService.get_trigger_db_by_ref(trigger)
else:
# If id / uid is available we try to look up Trigger by id. This way we can avoid bug in
# pymongo / mongoengine related to "parameters" dictionary lookups
trigger_id = trigger.get('id', None)
trigger_uid = trigger.get('uid', None)
# TODO: Remove parameters dictionary look up when we can confirm each trigger dictionary
# passed to this method always contains id or uid
if trigger_id:
LOG.debug('Looking up TriggerDB by id: %s', trigger_id)
trigger_db = TriggerService.get_trigger_db_by_id(id=trigger_id)
elif trigger_uid:
LOG.debug('Looking up TriggerDB by uid: %s', trigger_uid)
trigger_db = TriggerService.get_trigger_db_by_uid(uid=trigger_uid)
else:
# Last resort - look it up by parameters
trigger_type = trigger.get('type', None)
parameters = trigger.get('parameters', {})
LOG.debug(
'Looking up TriggerDB by type and parameters: type=%s, parameters=%s',
trigger_type, parameters)
trigger_db = TriggerService.get_trigger_db_given_type_and_params(
type=trigger_type, parameters=parameters)
if trigger_db is None:
LOG.debug('No trigger in db for %s', trigger)
if raise_on_no_trigger:
raise StackStormDBObjectNotFoundError('Trigger not found for %s',
trigger)
return None
trigger_ref = trigger_db.get_reference().ref
trigger_instance = TriggerInstanceDB()
trigger_instance.trigger = trigger_ref
trigger_instance.payload = payload
trigger_instance.occurrence_time = occurrence_time
trigger_instance.status = TRIGGER_INSTANCE_PENDING
return TriggerInstance.add_or_update(trigger_instance)
def get_trace_db_by_live_action(liveaction):
"""
Given a liveaction does the best attempt to return a TraceDB.
1. From trace_context in liveaction.context
2. From parent in liveaction.context
3. From action_execution associated with provided liveaction
4. Creates a new TraceDB (which calling method is on the hook to persist).
:param liveaction: liveaction from which to figure out a TraceDB.
:type liveaction: ``LiveActionDB``
:returns: (boolean, TraceDB) if the TraceDB was created(but not saved to DB) or
retrieved from the DB and the TraceDB itself.
:rtype: ``tuple``
"""
trace_db = None
created = False
# 1. Try to get trace_db from liveaction context.
# via trigger_instance + rule or via user specified trace_context
trace_context = liveaction.context.get(TRACE_CONTEXT, None)
if trace_context:
trace_context = _get_valid_trace_context(trace_context)
trace_db = get_trace(trace_context=trace_context,
ignore_trace_tag=True)
# found a trace_context but no trace_db. This implies a user supplied
# trace_tag so create a new trace_db
if not trace_db:
trace_db = TraceDB(trace_tag=trace_context.trace_tag)
created = True
return (created, trace_db)
# 2. If not found then check if parent context contains an execution_id.
# This cover case for child execution of a workflow.
parent_context = executions.get_parent_context(liveaction_db=liveaction)
if not trace_context and parent_context:
parent_execution_id = parent_context.get("execution_id", None)
if parent_execution_id:
# go straight to a trace_db. If there is a parent execution then that must
# be associated with a Trace.
trace_db = get_trace_db_by_action_execution(
action_execution_id=parent_execution_id)
if not trace_db:
raise StackStormDBObjectNotFoundError(
"No trace found for execution %s" % parent_execution_id)
return (created, trace_db)
# 3. Check if the action_execution associated with liveaction leads to a trace_db
execution = ActionExecution.get(liveaction__id=str(liveaction.id))
if execution:
trace_db = get_trace_db_by_action_execution(action_execution=execution)
# 4. No trace_db found, therefore create one. This typically happens
# when execution is run by hand.
if not trace_db:
trace_db = TraceDB(trace_tag="execution-%s" % str(liveaction.id))
created = True
return (created, trace_db)
def _get_by_ref_or_id(self, ref_or_id):
if PolicyTypeReference.is_reference(ref_or_id):
resource_db = self._get_by_ref(resource_ref=ref_or_id)
else:
resource_db = self._get_by_id(resource_id=ref_or_id)
if not resource_db:
msg = 'PolicyType with a reference of id "%s" not found.' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
return resource_db
def _get_by_ref_or_id(self, ref_or_id, exclude_fields=None):
resource_db = self._get_by_id(resource_id=ref_or_id, exclude_fields=exclude_fields)
if not resource_db:
# Try ref
resource_db = self._get_by_ref(ref=ref_or_id, exclude_fields=exclude_fields)
if not resource_db:
msg = 'Resource with a ref or id "%s" not found' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
return resource_db
def get_one(self, ref_or_id, requester_user):
"""
Outputs the file associated with action entry_point
Handles requests:
GET /actions/views/entry_point/1
"""
LOG.info("GET /actions/views/entry_point with ref_or_id=%s", ref_or_id)
action_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
permission_type = PermissionType.ACTION_VIEW
rbac_utils = get_rbac_backend().get_utils_class()
rbac_utils.assert_user_has_resource_db_permission(
user_db=requester_user,
resource_db=action_db,
permission_type=permission_type,
)
pack = getattr(action_db, "pack", None)
entry_point = getattr(action_db, "entry_point", None)
abs_path = utils.get_entry_point_abs_path(pack, entry_point)
if not abs_path:
raise StackStormDBObjectNotFoundError(
"Action ref_or_id=%s has no entry_point to output" % ref_or_id)
with codecs.open(abs_path, "r") as fp:
content = fp.read()
# Ensure content is utf-8
if isinstance(content, six.binary_type):
content = content.decode("utf-8")
try:
content_type = mimetypes.guess_type(abs_path)[0]
except Exception:
content_type = None
# Special case if /etc/mime.types doesn't contain entry for yaml, py
if not content_type:
_, extension = os.path.splitext(abs_path)
if extension in [".yaml", ".yml"]:
content_type = "application/x-yaml"
elif extension in [".py"]:
content_type = "application/x-python"
else:
content_type = "text/plain"
response = Response()
response.headers["Content-Type"] = content_type
response.text = content
return response
def get_one(self, ref_or_id, *file_path_components):
"""
Outputs the content of a specific file in a pack.
Handles requests:
GET /packs/views/files/<pack_ref_or_id>/<file path>
"""
pack_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
if not pack_db:
msg = 'Pack with ref_or_id "%s" does not exist' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
if not file_path_components:
raise ValueError('Missing file path')
file_path = os.path.join(*file_path_components)
pack_name = pack_db.name
normalized_file_path = get_pack_file_abs_path(pack_name=pack_name,
file_path=file_path)
if not normalized_file_path or not os.path.isfile(
normalized_file_path):
# Ignore references to files which don't exist on disk
raise StackStormDBObjectNotFoundError('File "%s" not found' %
(file_path))
file_size = self._get_file_size(file_path=normalized_file_path)
if file_size is not None and file_size > MAX_FILE_SIZE:
msg = ('File %s exceeds maximum allowed file size (%s bytes)' %
(file_path, MAX_FILE_SIZE))
raise ValueError(msg)
content_type = mimetypes.guess_type(
normalized_file_path)[0] or 'application/octet-stream'
response.headers['Cache-Control'] = 'public, max-age=86400'
response.headers['Content-Type'] = content_type
response.body = self._get_file_content(file_path=normalized_file_path)
return response
def get_one(self, ref_or_id, requester_user):
"""
Outputs the content of all the files inside the pack.
Handles requests:
GET /packs/views/files/<pack_ref_or_id>
"""
pack_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
rbac_utils = get_rbac_backend().get_utils_class()
rbac_utils.assert_user_has_resource_db_permission(
user_db=requester_user,
resource_db=pack_db,
permission_type=PermissionType.PACK_VIEW,
)
if not pack_db:
msg = 'Pack with ref_or_id "%s" does not exist' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
pack_ref = pack_db.ref
pack_files = pack_db.files
result = []
for file_path in pack_files:
normalized_file_path = get_pack_file_abs_path(
pack_ref=pack_ref, file_path=file_path
)
if not normalized_file_path or not os.path.isfile(normalized_file_path):
# Ignore references to files which don't exist on disk
continue
file_size = self._get_file_size(file_path=normalized_file_path)
if file_size is not None and file_size > MAX_FILE_SIZE:
LOG.debug(
'Skipping file "%s" which size exceeds max file size (%s bytes)'
% (normalized_file_path, MAX_FILE_SIZE)
)
continue
content = self._get_file_content(file_path=normalized_file_path)
include_file = self._include_file(file_path=file_path, content=content)
if not include_file:
LOG.debug('Skipping binary file "%s"' % (normalized_file_path))
continue
item = {"file_path": file_path, "content": content}
result.append(item)
return result
def _get_by_name_or_id(self, name_or_id, exclude_fields=None):
"""
Retrieve resource object by an id of a name.
"""
resource_db = self._get_by_id(resource_id=name_or_id, exclude_fields=exclude_fields)
if not resource_db:
# Try name
resource_db = self._get_by_name(resource_name=name_or_id, exclude_fields=exclude_fields)
if not resource_db:
msg = 'Resource with a name or id "%s" not found' % (name_or_id)
raise StackStormDBObjectNotFoundError(msg)
return resource_db
def get_runnertype_by_id(runnertype_id):
"""
Get RunnerType by id.
On error, raise StackStormDBObjectNotFoundError
"""
try:
runnertype = RunnerType.get_by_id(runnertype_id)
except (ValueError, ValidationError) as e:
LOG.warning('Database lookup for runnertype with id="%s" resulted in '
'exception: %s', runnertype_id, e)
raise StackStormDBObjectNotFoundError('Unable to find runnertype with '
'id="%s"' % runnertype_id)
return runnertype
def get(self, exclude_fields=None, *args, **kwargs):
raise_exception = kwargs.pop('raise_exception', False)
instances = self.model.objects(**kwargs)
if exclude_fields:
instances = instances.exclude(*exclude_fields)
instance = instances[0] if instances else None
log_query_and_profile_data_for_queryset(queryset=instances)
if not instance and raise_exception:
msg = 'Unable to find the %s instance. %s' % (self.model.__name__, kwargs)
raise StackStormDBObjectNotFoundError(msg)
return instance
def get_action_by_id(action_id):
"""
Get Action by id.
On error, raise StackStormDBObjectNotFoundError
"""
action = None
try:
action = Action.get_by_id(action_id)
except (ValueError, ValidationError) as e:
LOG.warning('Database lookup for action with id="%s" resulted in '
'exception: %s', action_id, e)
raise StackStormDBObjectNotFoundError('Unable to find action with '
'id="%s"' % action_id)
return action
def get_liveaction_by_id(liveaction_id):
"""
Get LiveAction by id.
On error, raise ST2DBObjectNotFoundError.
"""
liveaction = None
try:
liveaction = LiveAction.get_by_id(liveaction_id)
except (ValidationError, ValueError) as e:
LOG.error('Database lookup for LiveAction with id="%s" resulted in '
'exception: %s', liveaction_id, e)
raise StackStormDBObjectNotFoundError('Unable to find LiveAction with '
'id="%s"' % liveaction_id)
return liveaction
def _get_one_by_scope_and_name(self, scope, name, from_model_kwargs=None):
"""
Retrieve an item given scope and name. Only KeyValuePair now has concept of 'scope'.
:param scope: Scope the key belongs to.
:type scope: ``str``
:param name: Name of the key.
:type name: ``str``
"""
instance = self.access.get_by_scope_and_name(scope=scope, name=name)
if not instance:
msg = 'KeyValuePair with name: %s and scope: %s not found in db.' % (name, scope)
raise StackStormDBObjectNotFoundError(msg)
from_model_kwargs = from_model_kwargs or {}
result = self.model.from_model(instance, **from_model_kwargs)
LOG.debug('GET with scope=%s and name=%s, client_result=%s', scope, name, result)
return result
def get_by_scope_and_name(cls, scope, name):
"""
Get a key value store given a scope and name.
:param scope: Scope which the key belongs to.
:type scope: ``str``
:param name: Name of the key.
:type key: ``str``
:rtype: :class:`KeyValuePairDB` or ``None``
"""
query_result = cls.impl.query(scope=scope, name=name)
if not query_result:
msg = 'The key "%s" does not exist in the StackStorm datastore.'
raise StackStormDBObjectNotFoundError(msg % name)
return query_result.first() if query_result else None
def get_one(self, ref_or_id):
"""
Outputs the content of all the files inside the pack.
Handles requests:
GET /packs/views/files/<pack_ref_or_id>
"""
pack_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
if not pack_db:
msg = 'Pack with ref_or_id "%s" does not exist' % (ref_or_id)
raise StackStormDBObjectNotFoundError(msg)
pack_name = pack_db.name
pack_files = pack_db.files
result = []
for file_path in pack_files:
normalized_file_path = get_pack_file_abs_path(pack_name=pack_name,
file_path=file_path)
if not normalized_file_path or not os.path.isfile(
normalized_file_path):
# Ignore references to files which don't exist on disk
continue
file_size = self._get_file_size(file_path=normalized_file_path)
if file_size is not None and file_size > MAX_FILE_SIZE:
LOG.debug(
'Skipping file "%s" which size exceeds max file size (%s bytes)'
% (normalized_file_path, MAX_FILE_SIZE))
continue
content = self._get_file_content(file_path=normalized_file_path)
include_file = self._include_file(file_path=file_path,
content=content)
if not include_file:
LOG.debug('Skipping binary file "%s"' % (normalized_file_path))
continue
item = {'file_path': file_path, 'content': content}
result.append(item)
return result
def get_trace(trace_context, ignore_trace_tag=False):
"""
:param trace_context: context object using which a trace can be found.
:type trace_context: ``dict`` or ``TraceContext``
:param ignore_trace_tag: Even if a trace_tag is provided will be ignored.
:type ignore_trace_tag: ``str``
:rtype: ``TraceDB``
"""
trace_context = _get_valid_trace_context(trace_context)
if not trace_context.id_ and not trace_context.trace_tag:
raise ValueError(
"Atleast one of id_ or trace_tag should be specified.")
if trace_context.id_:
try:
return Trace.get_by_id(trace_context.id_)
except (ValidationError, ValueError):
LOG.warning(
'Database lookup for Trace with id="%s" failed.',
trace_context.id_,
exc_info=True,
)
raise StackStormDBObjectNotFoundError(
'Unable to find Trace with id="%s"' % trace_context.id_)
if ignore_trace_tag:
return None
traces = Trace.query(trace_tag=trace_context.trace_tag)
# Assume this method only handles 1 trace.
if len(traces) > 1:
raise UniqueTraceNotFoundException(
"More than 1 Trace matching %s found." % trace_context.trace_tag)
return traces[0]
def create_trigger_instance(trigger,
payload,
occurrence_time,
raise_on_no_trigger=False):
"""
This creates a trigger instance object given trigger and payload.
Trigger can be just a string reference (pack.name) or a ``dict``
containing 'type' and 'parameters'.
:param trigger: Dictionary with trigger query filters.
:type trigger: ``dict``
:param payload: Trigger payload.
:type payload: ``dict``
"""
# TODO: This is nasty, this should take a unique reference and not a dict
if isinstance(trigger, six.string_types):
trigger_db = TriggerService.get_trigger_db_by_ref(trigger)
else:
type_ = trigger.get('type', None)
parameters = trigger.get('parameters', {})
trigger_db = TriggerService.get_trigger_db_given_type_and_params(
type=type_, parameters=parameters)
if trigger_db is None:
LOG.debug('No trigger in db for %s', trigger)
if raise_on_no_trigger:
raise StackStormDBObjectNotFoundError('Trigger not found for %s',
trigger)
return None
trigger_ref = trigger_db.get_reference().ref
trigger_instance = TriggerInstanceDB()
trigger_instance.trigger = trigger_ref
trigger_instance.payload = payload
trigger_instance.occurrence_time = occurrence_time
trigger_instance.status = TRIGGER_INSTANCE_PENDING
return TriggerInstance.add_or_update(trigger_instance)
def get_one(self, ref_or_id):
"""
Outputs the file associated with action entry_point
Handles requests:
GET /actions/views/entry_point/1
"""
LOG.info('GET /actions/views/overview with ref_or_id=%s', ref_or_id)
action_db = self._get_by_ref_or_id(ref_or_id=ref_or_id)
pack = getattr(action_db, 'pack', None)
entry_point = getattr(action_db, 'entry_point', None)
abs_path = utils.get_entry_point_abs_path(pack, entry_point)
if not abs_path:
raise StackStormDBObjectNotFoundError(
'Action ref_or_id=%s has no entry_point to output' % ref_or_id)
with open(abs_path) as file:
content = file.read()
return content
def get_one(self, action_id):
"""
Outputs the file associated with action entry_point
Handles requests:
GET /actions/views/entry_point/1
"""
LOG.info('GET /actions/views/overview with id=%s', action_id)
action_db = LookupUtils._get_action_by_id(action_id)
pack = getattr(action_db, 'pack', None)
entry_point = getattr(action_db, 'entry_point', None)
abs_path = RunnerContainerService.get_entry_point_abs_path(
pack, entry_point)
if not abs_path:
raise StackStormDBObjectNotFoundError(
'Action id=%s has no entry_point to output' % action_id)
with open(abs_path) as file:
content = file.read()
return content
