def get_pack_metadata(pack_dir):
"""
Return parsed metadata for a particular pack directory.
:rtype: ``dict``
"""
manifest_path = os.path.join(pack_dir, MANIFEST_FILE_NAME)
if not os.path.isfile(manifest_path):
raise ValueError('Pack "%s" is missing %s file' % (pack_dir, MANIFEST_FILE_NAME))
meta_loader = MetaLoader()
content = meta_loader.load(manifest_path)
if not content:
raise ValueError('Pack "%s" metadata file is empty' % (pack_dir))
return content
class RunnerTestCase(unittest2.TestCase):
meta_loader = MetaLoader()
def assertCommonSt2EnvVarsAvailableInEnv(self, env):
"""
Method which asserts that the common ST2 environment variables are present in the provided
environment.
"""
for var_name in COMMON_ACTION_ENV_VARIABLES:
self.assertIn(var_name, env)
self.assertEqual(env['ST2_ACTION_API_URL'], get_full_public_api_url())
self.assertIsNotNone(env[AUTH_TOKEN_ENV_VARIABLE_NAME])
def loader(self, path):
""" Load the runner config
"""
return self.meta_loader.load(path)
def __init__(self,
rule_file_path=None,
rule_ref=None,
trigger_instance_file_path=None,
trigger_instance_id=None):
"""
:param rule_file_path: Path to the file containing rule definition.
:type rule_file_path: ``str``
:param trigger_instance_file_path: Path to the file containg trigger instance definition.
:type trigger_instance_file_path: ``str``
"""
self._rule_file_path = rule_file_path
self._rule_ref = rule_ref
self._trigger_instance_file_path = trigger_instance_file_path
self._trigger_instance_id = trigger_instance_id
self._meta_loader = MetaLoader()
def register_runners(runner_dirs=None, experimental=False, fail_on_failure=True):
""" Register runners
"""
LOG.debug('Start : register runners')
runner_count = 0
runner_loader = RunnersLoader()
if not runner_dirs:
runner_dirs = content_utils.get_runners_base_paths()
runners = runner_loader.get_runners(runner_dirs)
for runner, path in runners.iteritems():
LOG.debug('Runner "%s"' % (runner))
runner_manifest = os.path.join(path, MANIFEST_FILE_NAME)
meta_loader = MetaLoader()
runner_types = meta_loader.load(runner_manifest)
for runner_type in runner_types:
runner_count += register_runner(runner_type, experimental)
LOG.debug('End : register runners')
return runner_count
def __init__(self):
self.meta_loader = MetaLoader()
from st2common.bootstrap.base import ResourceRegistrar
import st2common.content.utils as content_utils
from st2common.models.api.action import ActionAPI
from st2common.models.api.sensor import SensorTypeAPI
from st2common.models.api.rule import RuleAPI
from st2common.service_setup import db_setup
from st2common.service_setup import db_teardown
from st2common.models.system.common import ResourceReference
from st2common.persistence.rule import Rule
from st2common.persistence.sensor import SensorType
from st2common.persistence.action import Action
registrar = ResourceRegistrar()
registrar.ALLOWED_EXTENSIONS = ['.yaml', '.yml', '.json']
meta_loader = MetaLoader()
API_MODELS_ARTIFACT_TYPES = {
'actions': ActionAPI,
'sensors': SensorTypeAPI,
'rules': RuleAPI
}
API_MODELS_PERSISTENT_MODELS = {
Action: ActionAPI,
SensorType: SensorTypeAPI,
Rule: RuleAPI
}
def do_register_cli_opts(opts, ignore_errors=False):
def main(metadata_path, output_path, print_source=False):
metadata_path = os.path.abspath(metadata_path)
metadata_dir = os.path.dirname(metadata_path)
meta_loader = MetaLoader()
data = meta_loader.load(metadata_path)
action_name = data['name']
entry_point = data['entry_point']
workflow_metadata_path = os.path.join(metadata_dir, entry_point)
chainspec = meta_loader.load(workflow_metadata_path)
chain_holder = ChainHolder(chainspec, 'workflow')
graph_label = '%s action-chain workflow visualization' % (action_name)
graph_attr = {
'rankdir': 'TD',
'labelloc': 't',
'fontsize': '15',
'label': graph_label
}
node_attr = {}
dot = Digraph(comment='Action chain work-flow visualization',
node_attr=node_attr,
graph_attr=graph_attr,
format='png')
# dot.body.extend(['rankdir=TD', 'size="10,5"'])
# Add all nodes
node = chain_holder.get_next_node()
while node:
dot.node(node.name, node.name)
node = chain_holder.get_next_node(curr_node_name=node.name)
# Add connections
node = chain_holder.get_next_node()
processed_nodes = set([node.name])
nodes = [node]
while nodes:
previous_node = nodes.pop()
success_node = chain_holder.get_next_node(
curr_node_name=previous_node.name, condition='on-success')
failure_node = chain_holder.get_next_node(
curr_node_name=previous_node.name, condition='on-failure')
# Add success node (if any)
if success_node:
dot.edge(previous_node.name,
success_node.name,
constraint='true',
color='green',
label='on success')
if success_node.name not in processed_nodes:
nodes.append(success_node)
processed_nodes.add(success_node.name)
# Add failure node (if any)
if failure_node:
dot.edge(previous_node.name,
failure_node.name,
constraint='true',
color='red',
label='on failure')
if failure_node.name not in processed_nodes:
nodes.append(failure_node)
processed_nodes.add(failure_node.name)
if print_source:
print(dot.source)
if output_path:
output_path = os.path.join(output_path, action_name)
else:
output_path = output_path or os.path.join(os.getcwd(), action_name)
dot.format = 'png'
dot.render(output_path)
print('Graph saved at %s' % (output_path + '.png'))
def __init__(self, runner_id):
super(ActionChainRunner, self).__init__(runner_id=runner_id)
self.chain_holder = None
self._meta_loader = MetaLoader()
def __init__(self, id):
super(ActionChainRunner, self).__init__()
self.id = id
self.action_chain = None
self._meta_loader = MetaLoader()
def main(metadata_path, output_path, print_source=False):
metadata_path = os.path.abspath(metadata_path)
metadata_dir = os.path.dirname(metadata_path)
meta_loader = MetaLoader()
data = meta_loader.load(metadata_path)
action_name = data["name"]
entry_point = data["entry_point"]
workflow_metadata_path = os.path.join(metadata_dir, entry_point)
chainspec = meta_loader.load(workflow_metadata_path)
chain_holder = ChainHolder(chainspec, "workflow")
graph_label = "%s action-chain workflow visualization" % (action_name)
graph_attr = {
"rankdir": "TD",
"labelloc": "t",
"fontsize": "15",
"label": graph_label,
}
node_attr = {}
dot = Digraph(
comment="Action chain work-flow visualization",
node_attr=node_attr,
graph_attr=graph_attr,
format="png",
)
# dot.body.extend(['rankdir=TD', 'size="10,5"'])
# Add all nodes
node = chain_holder.get_next_node()
while node:
dot.node(node.name, node.name)
node = chain_holder.get_next_node(curr_node_name=node.name)
# Add connections
node = chain_holder.get_next_node()
processed_nodes = set([node.name])
nodes = [node]
while nodes:
previous_node = nodes.pop()
success_node = chain_holder.get_next_node(
curr_node_name=previous_node.name, condition="on-success")
failure_node = chain_holder.get_next_node(
curr_node_name=previous_node.name, condition="on-failure")
# Add success node (if any)
if success_node:
dot.edge(
previous_node.name,
success_node.name,
constraint="true",
color="green",
label="on success",
)
if success_node.name not in processed_nodes:
nodes.append(success_node)
processed_nodes.add(success_node.name)
# Add failure node (if any)
if failure_node:
dot.edge(
previous_node.name,
failure_node.name,
constraint="true",
color="red",
label="on failure",
)
if failure_node.name not in processed_nodes:
nodes.append(failure_node)
processed_nodes.add(failure_node.name)
if print_source:
print(dot.source)
if output_path:
output_path = os.path.join(output_path, action_name)
else:
output_path = output_path or os.path.join(os.getcwd(), action_name)
dot.format = "png"
dot.render(output_path)
print("Graph saved at %s" % (output_path + ".png"))
def __init__(self):
self._meta_loader = MetaLoader()
self._pack_loader = ContentPackLoader()
