class PolicyTypeAPI(BaseAPI, APIUIDMixin):
model = PolicyTypeDB
schema = {
"title": "Policy Type",
"type": "object",
"properties": {
"id": {"type": "string", "default": None},
"uid": {"type": "string"},
"name": {"type": "string", "required": True},
"resource_type": {"enum": ["action"], "required": True},
"ref": {"type": "string"},
"description": {"type": "string"},
"enabled": {"type": "boolean", "default": True},
"module": {"type": "string", "required": True},
"parameters": {
"type": "object",
"patternProperties": {r"^\w+$": util_schema.get_draft_schema()},
"additionalProperties": False,
},
},
"additionalProperties": False,
}
@classmethod
def to_model(cls, instance):
return cls.model(
name=str(instance.name),
description=getattr(instance, "description", None),
resource_type=str(instance.resource_type),
ref=getattr(instance, "ref", None),
enabled=getattr(instance, "enabled", None),
module=str(instance.module),
parameters=getattr(instance, "parameters", dict()),
)
class RunnerTypeAPI(BaseAPI):
"""
The representation of an RunnerType in the system. An RunnerType
has a one-to-one mapping to a particular ActionRunner implementation.
"""
model = RunnerTypeDB
schema = {
"title": "Runner",
"description": "A handler for a specific type of actions.",
"type": "object",
"properties": {
"id": {
"description": "The unique identifier for the action runner.",
"type": "string",
"default": None
},
"name": {
"description": "The name of the action runner.",
"type": "string",
"required": True
},
"description": {
"description": "The description of the action runner.",
"type": "string"
},
"enabled": {
"description": "Enable or disable the action runner.",
"type": "boolean",
"default": True
},
"runner_module": {
"description": "The python module that implements the "
"action runner for this type.",
"type": "string",
"required": True
},
"query_module": {
"description": "The python module that implements the "
"results tracker (querier) for the runner.",
"type": "string",
"required": False
},
"runner_parameters": {
"description": "Input parameters for the action runner.",
"type": "object",
"patternProperties": {
"^\w+$": util_schema.get_draft_schema()
}
}
},
"additionalProperties": False
}
def __init__(self, **kw):
# Ideally, you should not do that. You should not redefine __init__ to validate and then set
# default values, instead you should define defaults in schema and use BaseAPI __init__
# validator to unwrap them. The problem here is that draft schema also contains default
# values and we don't want them to be unwrapped at the same time. I've tried to remove the
# default values from draft schema, but, either because of a bug or some weird intention, it
# has continued to resolve $ref'erenced properties against the initial draft schema, not the
# modified one
for key, value in kw.items():
setattr(self, key, value)
if not hasattr(self, 'runner_parameters'):
setattr(self, 'runner_parameters', dict())
@classmethod
def to_model(cls, runnertype):
model = super(cls, cls).to_model(runnertype)
model.enabled = bool(runnertype.enabled)
model.runner_module = str(runnertype.runner_module)
if getattr(runnertype, 'query_module', None):
model.query_module = str(runnertype.query_module)
model.runner_parameters = getattr(runnertype, 'runner_parameters',
dict())
return model
class ActionAPI(BaseAPI):
"""The system entity that represents a Stack Action/Automation in the system."""
model = ActionDB
schema = {
"title": "Action",
"description":
"An activity that happens as a response to the external event.",
"type": "object",
"properties": {
"id": {
"description": "The unique identifier for the action.",
"type": "string"
},
"ref": {
"description":
"System computed user friendly reference for the action. \
Provided value will be overridden by computed value.",
"type": "string"
},
"name": {
"description": "The name of the action.",
"type": "string",
"required": True
},
"description": {
"description": "The description of the action.",
"type": "string"
},
"enabled": {
"description": "Enable or disable the action from invocation.",
"type": "boolean",
"default": True
},
"runner_type": {
"description": "The type of runner that executes the action.",
"type": "string",
"required": True
},
"entry_point": {
"description": "The entry point for the action.",
"type": "string",
"default": ""
},
"pack": {
"description": "The content pack this action belongs to.",
"type": "string"
},
"parameters": {
"description": "Input parameters for the action.",
"type": "object",
"patternProperties": {
"^\w+$": util_schema.get_draft_schema()
},
"default": {}
},
"tags": {
"description":
"User associated metadata assigned to this object.",
"type": "array",
"items": {
"type": "object"
}
},
"notify": {
"description": "Notification settings for action.",
"type": "object",
"properties": {
"on_complete": NotificationSubSchemaAPI,
"on_failure": NotificationSubSchemaAPI,
"on_success": NotificationSubSchemaAPI
},
"additionalProperties": False
}
},
"additionalProperties": False
}
def __init__(self, **kw):
for key, value in kw.items():
setattr(self, key, value)
if not hasattr(self, 'parameters'):
setattr(self, 'parameters', dict())
if not hasattr(self, 'entry_point'):
setattr(self, 'entry_point', '')
@classmethod
def from_model(cls, model):
action = cls._from_model(model)
action['runner_type'] = action['runner_type']['name']
action['tags'] = TagsHelper.from_model(model.tags)
if getattr(model, 'notify', None):
action['notify'] = NotificationsHelper.from_model(model.notify)
return cls(**action)
@classmethod
def to_model(cls, action):
model = super(cls, cls).to_model(action)
model.enabled = bool(action.enabled)
model.entry_point = str(action.entry_point)
model.pack = str(action.pack)
model.runner_type = {'name': str(action.runner_type)}
model.parameters = getattr(action, 'parameters', dict())
model.tags = TagsHelper.to_model(getattr(action, 'tags', []))
model.ref = ResourceReference.to_string_reference(pack=model.pack,
name=model.name)
if getattr(action, 'notify', None):
model.notify = NotificationsHelper.to_model(action.notify)
return model
class ActionAPI(BaseAPI):
"""The system entity that represents a Stack Action/Automation in the system."""
model = ActionDB
schema = {
"title": "Action",
"description": "An activity that happens as a response to the external event.",
"type": "object",
"properties": {
"id": {
"description": "The unique identifier for the action.",
"type": "string"
},
"name": {
"description": "The name of the action.",
"type": "string",
"required": True
},
"description": {
"description": "The description of the action.",
"type": "string"
},
"enabled": {
"description": "Enable or disable the action from invocation.",
"type": "boolean",
"default": True
},
"runner_type": {
"description": "The type of runner that executes the action.",
"type": "string",
"required": True
},
"entry_point": {
"description": "The entry point for the action.",
"type": "string",
"default": ""
},
"pack": {
"description": "The content pack this action belongs to.",
"type": "string"
},
"parameters": {
"description": "Input parameters for the action.",
"type": "object",
"patternProperties": {
"^\w+$": util_schema.get_draft_schema()
},
"default": {}
},
"tags": {
"description": "User associated metadata assigned to this object.",
"type": "array",
"items": {"type": "object"}
}
},
"additionalProperties": False
}
def __init__(self, **kw):
jsonschema.validate(kw, self.schema, util_schema.get_validator())
for key, value in kw.items():
setattr(self, key, value)
if not hasattr(self, 'parameters'):
setattr(self, 'parameters', dict())
if not hasattr(self, 'entry_point'):
setattr(self, 'entry_point', '')
@classmethod
def from_model(cls, model):
action = cls._from_model(model)
action['runner_type'] = action['runner_type']['name']
action['tags'] = TagsHelper.from_model(model.tags)
return cls(**action)
@classmethod
def to_model(cls, action):
model = super(cls, cls).to_model(action)
model.enabled = bool(action.enabled)
model.entry_point = str(action.entry_point)
model.pack = str(action.pack)
model.runner_type = {'name': str(action.runner_type)}
model.parameters = getattr(action, 'parameters', dict())
model.tags = TagsHelper.to_model(getattr(action, 'tags', []))
return model
