def main():
_register_cli_opts()
cfg.CONF(args=None, version=VERSION_STRING)
schema_path = os.path.abspath(cfg.CONF.schema_path)
config_path = os.path.abspath(cfg.CONF.config_path)
print('Validating config "%s" against schema in "%s"' %
(config_path, schema_path))
with open(schema_path, "r") as fp:
config_schema = yaml.safe_load(fp.read())
with open(config_path, "r") as fp:
config_object = yaml.safe_load(fp.read())
try:
validate_config_against_schema(
config_schema=config_schema,
config_object=config_object,
config_path=config_path,
)
except Exception as e:
print("Failed to validate pack config.\n%s" % six.text_type(e))
return FAILURE_EXIT_CODE
print('Config "%s" successfully validated against schema in %s.' %
(config_path, schema_path))
return SUCCESS_EXIT_CODE
def main():
_register_cli_opts()
cfg.CONF(args=None, version=VERSION_STRING)
schema_path = os.path.abspath(cfg.CONF.schema_path)
config_path = os.path.abspath(cfg.CONF.config_path)
print('Validating config "%s" against schema in "%s"' % (config_path, schema_path))
with open(schema_path, 'r') as fp:
config_schema = yaml.safe_load(fp.read())
with open(config_path, 'r') as fp:
config_object = yaml.safe_load(fp.read())
try:
validate_config_against_schema(config_schema=config_schema, config_object=config_object,
config_path=config_path)
except Exception as e:
print('Failed to validate pack config.\n%s' % str(e))
return FAILURE_EXIT_CODE
print('Config "%s" successfuly validated against schema in %s.' % (config_path, schema_path))
return SUCCESS_EXIT_CODE
def _validate_config_values_against_schema(self):
try:
config_schema_db = ConfigSchema.get_by_pack(value=self.pack)
except StackStormDBObjectNotFoundError:
# Config schema is optional
return
# Note: We are doing optional validation so for now, we do allow additional properties
instance = self.values or {}
schema = config_schema_db.attributes or {}
configs_path = os.path.join(cfg.CONF.system.base_path, 'configs/')
config_path = os.path.join(configs_path, '%s.yaml' % (self.pack))
cleaned = validate_config_against_schema(config_schema=schema,
config_object=instance,
config_path=config_path,
pack_name=self.pack)
return cleaned
def _validate_config_values_against_schema(self):
try:
config_schema_db = ConfigSchema.get_by_pack(value=self.pack)
except StackStormDBObjectNotFoundError:
# Config schema is optional
return
# Note: We are doing optional validation so for now, we do allow additional properties
instance = self.values or {}
schema = config_schema_db.attributes or {}
configs_path = os.path.join(cfg.CONF.system.base_path, 'configs/')
config_path = os.path.join(configs_path, '%s.yaml' % (self.pack))
cleaned = validate_config_against_schema(config_schema=schema,
config_object=instance,
config_path=config_path,
pack_name=self.pack)
return cleaned
def base(event, context, passthrough=False):
# Set up logging
logger = logging.getLogger()
# Read DEBUG value from the environment variable
debug = os.environ.get('ST2_DEBUG', False)
if str(debug).lower() in ['true', '1']:
debug = True
if debug:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
if isinstance(event, basestring):
try:
event = json.loads(event)
except ValueError as e:
LOG.error("ERROR: Can not parse `event`: '{}'\n{}".format(
str(event), str(e)))
raise e
LOG.info("Received event: " + json.dumps(event, indent=2))
# Special case for Lambda function being called over HTTP via API gateway
# See
# https://serverless.com/framework/docs/providers/aws/events/apigateway
# #example-lambda-proxy-event-default
# for details
is_event_body_string = (isinstance(event.get('body'), basestring) is True)
content_type = event.get('headers', {}).get('content-type', '').lower()
if is_event_body_string:
if content_type == 'application/json':
try:
event['body'] = json.loads(event['body'])
except Exception as e:
LOG.warn('`event` has `body` which is not JSON: %s',
str(e.message))
elif content_type == 'application/x-www-form-urlencoded':
try:
event['body'] = dict(
parse_qsl(['body'], keep_blank_values=True))
except Exception as e:
LOG.warn('`event` has `body` which is not `%s`: %s',
content_type, str(e.message))
else:
LOG.warn('Unsupported event content type: %s' % (content_type))
action_name = os.environ['ST2_ACTION']
try:
action_db = ACTIONS[action_name]
except KeyError:
raise ValueError('No action named "%s" has been installed.' %
(action_name))
manager = DriverManager(namespace='st2common.runners.runner',
invoke_on_load=False,
name=action_db.runner_type['name'])
runnertype_db = RunnerTypeAPI.to_model(
RunnerTypeAPI(**manager.driver.get_metadata()[0]))
if passthrough:
runner = PassthroughRunner()
else:
runner = manager.driver.get_runner()
runner._sandbox = False
runner.runner_type_db = runnertype_db
runner.action = action_db
runner.action_name = action_db.name
# runner.liveaction = liveaction_db
# runner.liveaction_id = str(liveaction_db.id)
# runner.execution = ActionExecution.get(liveaction__id=runner.liveaction_id)
# runner.execution_id = str(runner.execution.id)
runner.entry_point = content_utils.get_entry_point_abs_path(
pack=action_db.pack, entry_point=action_db.entry_point)
runner.context = {} # getattr(liveaction_db, 'context', dict())
# runner.callback = getattr(liveaction_db, 'callback', dict())
runner.libs_dir_path = content_utils.get_action_libs_abs_path(
pack=action_db.pack, entry_point=action_db.entry_point)
# For re-run, get the ActionExecutionDB in which the re-run is based on.
# rerun_ref_id = runner.context.get('re-run', {}).get('ref')
# runner.rerun_ex_ref = ActionExecution.get(id=rerun_ref_id) if rerun_ref_id else None
config_schema = CONFIG_SCHEMAS.get(action_db.pack, None)
config_values = os.environ.get('ST2_CONFIG', None)
if config_schema and config_values:
runner._config = validate_config_against_schema(
config_schema=config_schema,
config_object=json.loads(config_values),
config_path=None,
pack_name=action_db.pack)
param_values = os.environ.get('ST2_PARAMETERS', None)
try:
if param_values:
live_params = param_utils.render_live_params(
runner_parameters=runnertype_db.runner_parameters,
action_parameters=action_db.parameters,
params=json.loads(param_values),
action_context={},
additional_contexts={'input': event})
else:
live_params = event
if debug and 'log_level' not in live_params:
# Set log_level runner parameter
live_params['log_level'] = 'DEBUG'
runner_params, action_params = param_utils.render_final_params(
runner_parameters=runnertype_db.runner_parameters,
action_parameters=action_db.parameters,
params=live_params,
action_context={})
except ParamException as e:
raise actionrunner.ActionRunnerException(str(e))
runner.runner_parameters = runner_params
LOG.debug('Performing pre-run for runner: %s', runner.runner_id)
runner.pre_run()
(status, output, context) = runner.run(action_params)
output_values = os.environ.get('ST2_OUTPUT', None)
if output_values:
try:
result = param_utils.render_live_params(
runner_parameters=runnertype_db.runner_parameters,
action_parameters=action_db.parameters,
params=json.loads(output_values),
action_context={},
additional_contexts={
'input': event,
'output': output
})
except ParamException as e:
raise actionrunner.ActionRunnerException(str(e))
else:
result = output
# Log the logs generated by the action. We do that so the actual action logs
# (action stderr) end up in CloudWatch
output = output or {}
if output.get('stdout', None):
LOG.info('Action stdout: %s' % (output['stdout']))
if output.get('stderr', None):
LOG.info('Action stderr and logs: %s' % (output['stderr']))
return {
'event': event,
'live_params': live_params,
'output': output,
'result': result
}
def main():
# Read DEBUG value from the environment variable
debug = os.environ.get('ST2_DEBUG', False)
if str(debug).lower() in ['true', '1']:
debug = True
if debug:
LOG.setLevel(logging.DEBUG)
else:
LOG.setLevel(logging.INFO)
# Read
input = os.environ.get('ST2_INPUT', {})
if isinstance(input, six.string_types):
try:
input = json.loads(input)
except ValueError as e:
LOG.error("ERROR: Can not parse `input`: '{}'\n{}".format(str(input), str(e)))
raise e
LOG.debug("Received input: " + json.dumps(input, indent=2))
# Read action name from environment variable
action_name = os.environ['ST2_ACTION']
try:
action_db = ACTIONS[action_name]
except KeyError:
raise ValueError('No action named "%s" has been installed.' % (action_name))
# Initialize runner
manager = DriverManager(namespace='st2common.runners.runner', invoke_on_load=False,
name=action_db.runner_type['name'])
runnertype_db = RunnerTypeAPI.to_model(RunnerTypeAPI(**manager.driver.get_metadata()))
runner = manager.driver.get_runner()
runner._sandbox = False
runner.runner_type_db = runnertype_db
runner.action = action_db
runner.action_name = action_db.name
runner.entry_point = content_utils.get_entry_point_abs_path(pack=action_db.pack,
entry_point=action_db.entry_point)
runner.context = {}
runner.libs_dir_path = content_utils.get_action_libs_abs_path(pack=action_db.pack,
entry_point=action_db.entry_point)
config_schema = CONFIG_SCHEMAS.get(action_db.pack, None)
config_values = os.environ.get('ST2_CONFIG', None)
if config_schema and config_values:
runner._config = validate_config_against_schema(config_schema=config_schema,
config_object=json.loads(config_values),
config_path=None,
pack_name=action_db.pack)
param_values = os.environ.get('ST2_PARAMETERS', None)
try:
if param_values:
live_params = param_utils.render_live_params(
runner_parameters=runnertype_db.runner_parameters,
action_parameters=action_db.parameters,
params=json.loads(param_values),
action_context={},
additional_contexts={
'input': input
})
else:
live_params = input
if debug and 'log_level' not in live_params:
# Set log_level runner parameter
live_params['log_level'] = 'DEBUG'
runner_params, action_params = param_utils.render_final_params(
runner_parameters=runnertype_db.runner_parameters,
action_parameters=action_db.parameters,
params=live_params,
action_context={})
except ParamException as e:
raise actionrunner.ActionRunnerException(str(e))
runner.runner_parameters = runner_params
LOG.debug('Performing pre-run for runner: %s', runner.runner_id)
runner.pre_run()
(status, output, context) = runner.run(action_params)
try:
output['result'] = json.loads(output['result'])
except Exception:
pass
output_values = os.environ.get('ST2_OUTPUT', None)
if output_values:
try:
result = param_utils.render_live_params(
runner_parameters={},
action_parameters={},
params=json.loads(output_values),
action_context={},
additional_contexts={
'input': input,
'output': output
})
except ParamException as e:
raise actionrunner.ActionRunnerException(str(e))
else:
result = output
output = output or {}
if output.get('stdout', None):
LOG.info('Action stdout: %s' % (output['stdout']))
if output.get('stderr', None):
LOG.info('Action stderr and logs: %s' % (output['stderr']))
print(json.dumps(result))