def _get_function_type(self, app_name, function_name, function_type):
"""Gets the function of the for a given app and action name
Args:
app_name (str): Name of the app
function_name (str): Name of the action
function_type (WalkoffTag): Type of function, 'actions', 'conditions', or 'transforms'
Returns:
(func): The function
Raises:
UnknownApp: If the app is not found in the cache
UnknownAppAction: if the function_type is 'actions' and the given action name isn't found
UnknownCondition: if the function_type is 'conditions' and the given condition name isn't found
UnknownTransform: if the function_type is 'transforms' and the given transform name isn't found
"""
try:
app_cache = self._cache[app_name]
if not app_cache.functions:
_logger.warning('App {0} has no actions.'.format(app_name))
raise self.exception_lookup[function_type](app_name,
function_name)
except KeyError:
_logger.error('Cannot locate app {} in cache!'.format(app_name))
raise UnknownApp(app_name)
try:
return app_cache.get_run(function_name, function_type)
except KeyError:
_logger.error('App {0} has no {1} {2}'.format(
app_name, function_type.name, function_name))
raise self.exception_lookup[function_type](app_name, function_name)
def validate_app_actions(app, actions):
"""Validates that an app's actions are valid, meaning that they exist in a defined app API
Args:
app (str): The app to validate
actions (str): The action to validate
Returns:
set(str): The actions. Expanded to all known actions if `action` was 'all'
Raises:
UnknownApp: If the app specified is not found in all known app APIs or the app has no actions
UnknownAppAction: If the action is not found in the give app's actions
"""
try:
available_actions = set(
walkoff.config.app_apis[app]['actions'].keys())
if actions == 'all':
return available_actions
actions = set(convert_to_iterable(actions))
if actions - available_actions:
message = 'Unknown actions for app {0}: {1}'.format(
app, list(set(actions) - set(available_actions)))
_logger.error(message)
raise UnknownAppAction(app, actions)
return actions
except KeyError:
message = 'Unknown app {} or app has no actions'.format(app)
_logger.exception(message)
raise UnknownApp(app)
def get_app(self, app_name):
"""Gets the app class for a given app.
Args:
app_name (str): Name of the app to get
Returns:
cls: The app's class
Raises:
UnknownApp: If the app is not found in the cache or the app has only global actions
"""
try:
app_cache = self._cache[app_name]
except KeyError:
_logger.error('Cannot locate app {} in cache!'.format(app_name))
raise UnknownApp(app_name)
else:
if app_cache.main is not None:
return app_cache.main
else:
_logger.warning('App {} has no class.'.format(app_name))
raise UnknownApp(app_name)
def _get_function_type_names(self, app_name, function_type):
"""Gets all the names for a given function type ('action', 'condition', 'transform') for an app
Args:
app_name (str): The name of the app
function_type (WalkoffTag): tag to search for
Returns:
list[str]: List of all the names of the functions of the given type
Raises:
UnknownApp: If the app is not found in the cache
"""
try:
return self._cache[app_name].get_tagged_functions(function_type)
except KeyError:
_logger.error('Cannot locate app {} in cache!'.format(app_name))
raise UnknownApp(app_name)
def is_app_action_bound(self, app_name, action_name):
"""Determines if the action is bound (meaning it's inside a class) or not
Args:
app_name (str): Name of the app
action_name(str): Name of the action
Returns:
bool: Is the action bound?
Raises:
UnknownApp: If the app is not found in the cache
UnknownAppAction: If the app does not have the specified action
"""
try:
app_cache = self._cache[app_name]
if not app_cache.functions:
_logger.warning('App {} has no actions'.format(app_name))
raise UnknownAppAction(app_name, action_name)
except KeyError:
_logger.error('Cannot locate app {} in cache!'.format(app_name))
raise UnknownApp(app_name)
else:
return app_cache.is_bound(action_name)