def get_filter_rules_from_filter_id(filter_id, filters_model):
if not filter_id:
return None
validate_inputs({'filter_id': filter_id})
filter_elem = get_storage_manager().get(filters_model, filter_id)
return filter_elem.value
def put(self, name):
"""
Create a new agent
"""
request_dict = get_json_and_verify_params({
'node_instance_id': {
'type': unicode
},
'state': {
'type': unicode
},
'create_rabbitmq_user': {
'type': bool
}
})
validate_inputs({'name': name})
state = request_dict.get('state')
self._validate_state(state)
response = {}
try:
new_agent = self._create_agent(name, state, request_dict)
response = new_agent
except manager_exceptions.ConflictError:
# Assuming the agent was already created in cases of reinstalling
# or healing
current_app.logger.info("Not creating agent {0} because it "
"already exists".format(name))
new_agent = get_storage_manager().get(models.Agent, name)
if request_dict.get('create_rabbitmq_user'):
# Create rabbitmq user
self._get_amqp_manager().create_agent_user(new_agent)
return response
def put(self, name):
"""
Create a new agent
"""
request_dict = get_json_and_verify_params({
'node_instance_id': {'type': unicode},
'state': {'type': unicode},
'create_rabbitmq_user': {'type': bool}
})
validate_inputs({'name': name})
state = request_dict.get('state')
self._validate_state(state)
response = {}
try:
new_agent = self._create_agent(name, state, request_dict)
response = new_agent
except manager_exceptions.ConflictError:
# Assuming the agent was already created in cases of reinstalling
# or healing
current_app.logger.info("Not creating agent {0} because it "
"already exists".format(name))
new_agent = get_storage_manager().get(models.Agent, name)
if request_dict.get('create_rabbitmq_user'):
# Create rabbitmq user
self._get_amqp_manager().create_agent_user(new_agent)
return response
def put(self, snapshot_id):
rest_utils.validate_inputs({'snapshot_id': snapshot_id})
request_dict = rest_utils.get_json_and_verify_params()
include_metrics = rest_utils.verify_and_convert_bool(
'include_metrics',
request_dict.get('include_metrics', 'false')
)
include_credentials = rest_utils.verify_and_convert_bool(
'include_credentials',
request_dict.get('include_credentials', 'true')
)
include_logs = rest_utils.verify_and_convert_bool(
'include_logs',
request_dict.get('include_logs', 'true')
)
include_events = rest_utils.verify_and_convert_bool(
'include_events',
request_dict.get('include_events', 'true')
)
queue = rest_utils.verify_and_convert_bool(
'queue',
request_dict.get('queue', 'false')
)
execution = get_resource_manager().create_snapshot(
snapshot_id,
include_metrics,
include_credentials,
include_logs,
include_events,
True,
queue
)
return execution, 201
def _get_secret_params(self, key):
rest_utils.validate_inputs({'key': key})
request_dict = rest_utils.get_json_and_verify_params({
'value': {'type': unicode}
})
update_if_exists = rest_utils.verify_and_convert_bool(
'update_if_exists',
request_dict.get('update_if_exists', False),
)
is_hidden_value = rest_utils.verify_and_convert_bool(
'is_hidden_value',
request_dict.get('is_hidden_value', False),
)
visibility_param = rest_utils.get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES,
)
visibility = get_resource_manager().get_resource_visibility(
models.Secret,
key,
visibility_param
)
secret_params = {
'value': request_dict['value'],
'update_if_exists': update_if_exists,
'visibility': visibility,
'is_hidden_value': is_hidden_value
}
return secret_params
def put(self, deployment_id, **kwargs):
"""
Create a deployment
"""
validate_inputs({'deployment_id': deployment_id})
request_schema = self.create_request_schema()
request_dict = get_json_and_verify_params(request_schema)
blueprint_id = request_dict['blueprint_id']
bypass_maintenance = is_bypass_maintenance_mode()
args = get_args_and_verify_arguments(
[Argument('private_resource', type=boolean,
default=False)]
)
skip_plugins_validation = self.get_skip_plugin_validation_flag(
request_dict)
rm = get_resource_manager()
sm = get_storage_manager()
blueprint = sm.get(models.Blueprint, blueprint_id)
rm.cleanup_failed_deployment(deployment_id)
if not skip_plugins_validation:
rm.check_blueprint_plugins_installed(blueprint.plan)
deployment = rm.create_deployment(
blueprint,
deployment_id,
private_resource=args.private_resource,
visibility=None,
)
try:
rm.execute_workflow(deployment.make_create_environment_execution(
inputs=request_dict.get('inputs', {}),
), bypass_maintenance=bypass_maintenance)
except manager_exceptions.ExistingRunningExecutionError:
rm.delete_deployment(deployment)
raise
return deployment, 201
def _get_site_name(request_dict):
site_name = request_dict.get('site_name')
if site_name:
rest_utils.validate_inputs(
{'site_name': request_dict['site_name']}
)
return site_name
def put(self, deployment_id, **kwargs):
"""
Create a deployment
"""
rest_utils.validate_inputs({'deployment_id': deployment_id})
request_schema = self.create_request_schema()
request_dict = rest_utils.get_json_and_verify_params(request_schema)
blueprint_id = request_dict['blueprint_id']
bypass_maintenance = is_bypass_maintenance_mode()
args = rest_utils.get_args_and_verify_arguments(
[Argument('private_resource', type=boolean)]
)
visibility = rest_utils.get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES
)
deployment = get_resource_manager().create_deployment(
blueprint_id,
deployment_id,
inputs=request_dict.get('inputs', {}),
bypass_maintenance=bypass_maintenance,
private_resource=args.private_resource,
visibility=visibility,
skip_plugins_validation=self.get_skip_plugin_validation_flag(
request_dict),
site_name=_get_site_name(request_dict)
)
return deployment, 201
def put(self, deployment_id, **kwargs):
"""
Create a deployment
"""
rest_utils.validate_inputs({'deployment_id': deployment_id})
request_schema = self.create_request_schema()
request_dict = rest_utils.get_json_and_verify_params(request_schema)
blueprint_id = request_dict['blueprint_id']
bypass_maintenance = is_bypass_maintenance_mode()
args = rest_utils.get_args_and_verify_arguments(
[Argument('private_resource', type=boolean)]
)
visibility = rest_utils.get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES
)
deployment = get_resource_manager().create_deployment(
blueprint_id,
deployment_id,
inputs=request_dict.get('inputs', {}),
bypass_maintenance=bypass_maintenance,
private_resource=args.private_resource,
visibility=visibility,
skip_plugins_validation=self.get_skip_plugin_validation_flag(
request_dict),
site_name=_get_site_name(request_dict),
runtime_only_evaluation=request_dict.get(
'runtime_only_evaluation', False)
)
return deployment, 201
def _get_secret_params(self, key):
rest_utils.validate_inputs({'key': key})
request_dict = rest_utils.get_json_and_verify_params(
{'value': {
'type': unicode
}})
update_if_exists = rest_utils.verify_and_convert_bool(
'update_if_exists',
request_dict.get('update_if_exists', False),
)
is_hidden_value = rest_utils.verify_and_convert_bool(
'is_hidden_value',
request_dict.get('is_hidden_value', False),
)
visibility_param = rest_utils.get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES,
)
visibility = get_resource_manager().get_resource_visibility(
models.Secret, key, visibility_param)
secret_params = {
'value': request_dict['value'],
'update_if_exists': update_if_exists,
'visibility': visibility,
'is_hidden_value': is_hidden_value
}
return secret_params
def _get_site_name(request_dict):
if 'site_name' not in request_dict:
return None
site_name = request_dict['site_name']
rest_utils.validate_inputs({'site_name': site_name})
return site_name
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
rest_utils.validate_inputs({'blueprint_id': blueprint_id})
visibility = rest_utils.get_visibility_parameter(
optional=True,
is_argument=True,
valid_values=VisibilityState.STATES)
# Fail fast if trying to upload a duplicate blueprint
current_tenant = request.headers.get('tenant')
if visibility == VisibilityState.GLOBAL:
existing_duplicates = get_storage_manager().list(
models.Blueprint, filters={'id': blueprint_id})
if existing_duplicates:
raise IllegalActionError(
"Can't set or create the resource `{0}`, it's visibility "
"can't be global because it also exists in other "
"tenants".format(blueprint_id))
else:
existing_duplicates = get_storage_manager().list(models.Blueprint,
filters={
'id':
blueprint_id,
'tenant_name':
current_tenant
})
if existing_duplicates:
raise ConflictError(
'blueprint with id={0} already exists on tenant {1} or '
'with global visibility'.format(blueprint_id,
current_tenant))
return UploadedBlueprintsManager().\
receive_uploaded_data(data_id=blueprint_id,
visibility=visibility)
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
rest_utils.validate_inputs({'blueprint_id': blueprint_id})
args = get_args_and_verify_arguments([
Argument('async_upload', type=boolean, default=False),
Argument('labels')
])
async_upload = args.async_upload
visibility = rest_utils.get_visibility_parameter(
optional=True,
is_argument=True,
valid_values=VisibilityState.STATES)
labels = self._get_labels_from_args(args)
# Fail fast if trying to upload a duplicate blueprint.
# Allow overriding an existing blueprint which failed to upload
current_tenant = request.headers.get('tenant')
override_failed = False
if visibility == VisibilityState.GLOBAL:
existing_duplicates = get_storage_manager().list(
models.Blueprint, filters={'id': blueprint_id})
if existing_duplicates:
if existing_duplicates[0].state in \
BlueprintUploadState.FAILED_STATES:
override_failed = True
else:
raise IllegalActionError(
"Can't set or create the resource `{0}`, it's "
"visibility can't be global because it also exists in "
"other tenants".format(blueprint_id))
else:
existing_duplicates = get_storage_manager().list(models.Blueprint,
filters={
'id':
blueprint_id,
'tenant_name':
current_tenant
})
if existing_duplicates:
if existing_duplicates[0].state in \
BlueprintUploadState.FAILED_STATES:
override_failed = True
else:
raise ConflictError(
'blueprint with id={0} already exists on tenant {1} '
'or with global visibility'.format(
blueprint_id, current_tenant))
response = UploadedBlueprintsManager().\
receive_uploaded_data(data_id=blueprint_id,
visibility=visibility,
override_failed=override_failed,
labels=labels)
if not async_upload:
sm = get_storage_manager()
blueprint, _ = response
response = rest_utils.get_uploaded_blueprint(sm, blueprint)
return response
def get(self, filters_model, filter_id, _include=None):
"""
Get a filter by ID
"""
rest_utils.validate_inputs({'filter_id': filter_id})
return get_storage_manager().get(filters_model,
filter_id,
include=_include)
def patch(self, name):
"""
Update an existing agent
"""
request_dict = get_json_and_verify_params({'state': {'type': unicode}})
validate_inputs({'name': name})
state = request_dict['state']
self._validate_state(state)
return self._update_agent(name, state)
def get(self, name):
"""
Get agent by name
"""
validate_inputs({'name': name})
agent = get_storage_manager().get(models.Agent, name)
agent_dict = agent.to_dict()
if agent.rabbitmq_password:
agent_dict['rabbitmq_password'] = decrypt(agent.rabbitmq_password)
return agent_dict
def get(self, name):
"""
Get agent by name
"""
validate_inputs({'name': name})
agent = get_storage_manager().get(models.Agent, name)
agent_dict = agent.to_dict()
if agent.rabbitmq_password:
agent_dict['rabbitmq_password'] = decrypt(agent.rabbitmq_password)
return agent_dict
def delete(self, filters_model, filter_id):
"""
Delete a filter by ID
"""
rest_utils.validate_inputs({'filter_id': filter_id})
storage_manager = get_storage_manager()
filter_elem = storage_manager.get(filters_model, filter_id)
_verify_not_a_system_filter(filter_elem, 'delete')
storage_manager.delete(filter_elem, validate_global=True)
return None, 204
def _validate_new_name(self, request_dict, storage_manager, current_name):
new_name = request_dict.get('new_name')
if not new_name or current_name == new_name:
return
validate_inputs({'new_name': new_name})
if storage_manager.exists(models.Site, new_name):
raise manager_exceptions.ConflictError(
'Invalid new name `{0}`, it already exists on {1} or '
'with global visibility'.format(new_name,
utils.current_tenant))
def _validate_new_name(self, request_dict, storage_manager, current_name):
new_name = request_dict.get('new_name')
if not new_name or current_name == new_name:
return
validate_inputs({'new_name': new_name})
if storage_manager.exists(models.Site, new_name):
raise manager_exceptions.ConflictError(
'Invalid new name `{0}`, it already exists on {1} or '
'with global visibility'.format(new_name, utils.current_tenant)
)
def patch(self, name):
"""
Update an existing agent
"""
request_dict = get_json_and_verify_params({
'state': {'type': unicode}
})
validate_inputs({'name': name})
state = request_dict['state']
self._validate_state(state)
return self._update_agent(name, state)
def patch(self, filters_model, filter_id, filtered_resource):
"""Update a filter by its ID
This function updates the filter rules and visibility
"""
rest_utils.validate_inputs({'filter_id': filter_id})
if not request.json:
raise manager_exceptions.IllegalActionError(
'Update a filter request must include at least one parameter '
'to update')
request_dict = rest_utils.get_json_and_verify_params(
{'filter_rules': {
'type': list,
'optional': True
}})
filter_rules = request_dict.get('filter_rules')
visibility = rest_utils.get_visibility_parameter(
optional=True, valid_values=VisibilityState.STATES)
storage_manager = get_storage_manager()
filter_elem = storage_manager.get(filters_model, filter_id)
_verify_not_a_system_filter(filter_elem, 'update')
if visibility:
get_resource_manager().validate_visibility_value(
filters_model, filter_elem, visibility)
filter_elem.visibility = visibility
if filter_rules:
new_filter_rules = create_filter_rules_list(
filter_rules, filtered_resource)
new_attrs_filter_rules = _get_filter_rules_by_type(
new_filter_rules, 'attribute')
new_labels_filter_rules = _get_filter_rules_by_type(
new_filter_rules, 'label')
if new_attrs_filter_rules:
if new_labels_filter_rules: # Both need to be updated
filter_elem.value = new_filter_rules
else: # Only labels filter rules should be saved
filter_elem.value = (filter_elem.labels_filter_rules +
new_filter_rules)
elif new_labels_filter_rules:
# Only attributes filter rules should be saved
filter_elem.value = (filter_elem.attrs_filter_rules +
new_filter_rules)
else: # Should not get here
raise manager_exceptions.BadParametersError(
'Unknown filter rules type')
filter_elem.updated_at = get_formatted_timestamp()
return storage_manager.update(filter_elem)
def put(self, blueprint_id, **kwargs):
"""
Validate a blueprint (id specified)
"""
rest_utils.validate_inputs({'blueprint_id': blueprint_id})
visibility = rest_utils.get_visibility_parameter(
optional=True,
is_argument=True,
valid_values=VisibilityState.STATES)
return UploadedBlueprintsValidator().\
receive_uploaded_data(data_id=blueprint_id,
visibility=visibility)
def _validate_site_params(self, name):
validate_inputs({'name': name})
visibility = get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES,
)
request_dict = get_json_and_verify_params({
'location': {'type': unicode, 'optional': True},
'new_name': {'type': unicode, 'optional': True}
})
request_dict['visibility'] = visibility
self._validate_location(request_dict)
return request_dict
def _validate_site_params(self, name):
validate_inputs({'name': name})
visibility = get_visibility_parameter(
optional=True,
valid_values=VisibilityState.STATES,
)
request_dict = get_json_and_verify_params({
'location': {'type': text_type, 'optional': True},
'new_name': {'type': text_type, 'optional': True}
})
request_dict['visibility'] = visibility
self._validate_location(request_dict)
return request_dict
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
rest_utils.validate_inputs({'blueprint_id': blueprint_id})
visibility = rest_utils.get_visibility_parameter(
optional=True,
is_argument=True,
valid_values=VisibilityState.STATES
)
return UploadedBlueprintsManager().\
receive_uploaded_data(data_id=blueprint_id,
visibility=visibility)
def put(self, schedule_id, **kwargs):
"""Schedule a workflow execution"""
validate_inputs({'schedule_id': schedule_id})
deployment_id = get_args_and_verify_arguments([
Argument('deployment_id', type=text_type, required=True)
])['deployment_id']
request_dict = get_json_and_verify_params({'workflow_id',
'since'})
workflow_id = request_dict['workflow_id']
execution_arguments = self._get_execution_arguments(request_dict)
parameters = request_dict.get('parameters', None)
if parameters is not None and not isinstance(parameters, dict):
raise manager_exceptions.BadParametersError(
"parameters: expected a dict, but got: {0}".format(parameters))
rm = get_resource_manager()
deployment = rm.sm.get(models.Deployment, deployment_id)
rm._verify_workflow_in_deployment(workflow_id,
deployment,
deployment_id)
since = request_dict['since']
until = request_dict.get('until')
if since:
since = parse_datetime_multiple_formats(since)
if until:
until = parse_datetime_multiple_formats(until)
rule = compute_rule_from_scheduling_params(request_dict)
slip = request_dict.get('slip', 0)
stop_on_fail = verify_and_convert_bool(
'stop_on_fail', request_dict.get('stop_on_fail', False))
now = get_formatted_timestamp()
schedule = models.ExecutionSchedule(
id=schedule_id,
deployment=deployment,
created_at=now,
since=since,
until=until,
rule=rule,
slip=slip,
workflow_id=workflow_id,
parameters=parameters,
execution_arguments=execution_arguments,
stop_on_fail=stop_on_fail,
)
schedule.next_occurrence = schedule.compute_next_occurrence()
return rm.sm.put(schedule), 201
def put(self, name):
"""
Create a new agent or update its state if exists
"""
request_dict = get_json_and_verify_params({
'node_instance_id': {
'type': unicode
},
'state': {
'type': unicode
}
})
validate_inputs({'name': name})
state = request_dict.get('state')
self._validate_state(state)
try:
return self._create_agent(name, state, request_dict)
except manager_exceptions.ConflictError:
return self._update_agent(name, state)
def put(self, deployment_id, **kwargs):
"""
Create a deployment
"""
validate_inputs({'deployment_id': deployment_id})
request_schema = self.create_request_schema()
request_dict = get_json_and_verify_params(request_schema)
blueprint_id = request_dict['blueprint_id']
bypass_maintenance = is_bypass_maintenance_mode()
args = get_args_and_verify_arguments(
[Argument('private_resource', type=boolean, default=False)])
deployment = get_resource_manager().create_deployment(
blueprint_id,
deployment_id,
private_resource=args.private_resource,
visibility=None,
inputs=request_dict.get('inputs', {}),
bypass_maintenance=bypass_maintenance,
skip_plugins_validation=self.get_skip_plugin_validation_flag(
request_dict))
return deployment, 201
def put(self, deployment_id, **kwargs):
"""
Create a deployment
"""
validate_inputs({'deployment_id': deployment_id})
request_schema = self.create_request_schema()
request_dict = get_json_and_verify_params(request_schema)
blueprint_id = request_dict['blueprint_id']
bypass_maintenance = is_bypass_maintenance_mode()
args = get_args_and_verify_arguments(
[Argument('private_resource', type=boolean,
default=False)]
)
deployment = get_resource_manager().create_deployment(
blueprint_id,
deployment_id,
private_resource=args.private_resource,
visibility=None,
inputs=request_dict.get('inputs', {}),
bypass_maintenance=bypass_maintenance,
skip_plugins_validation=self.get_skip_plugin_validation_flag(
request_dict)
)
return deployment, 201
def put(self, filters_model, filter_id, filtered_resource):
"""Create a filter"""
rest_utils.validate_inputs({'filter_id': filter_id})
if filter_id.lower().startswith(RESERVED_PREFIX):
raise manager_exceptions.BadParametersError(
f'All filters with a `{RESERVED_PREFIX}` prefix are reserved '
f'for internal use.')
request_dict = rest_utils.get_json_and_verify_params(
{'filter_rules': {
'type': list
}})
filter_rules = create_filter_rules_list(request_dict['filter_rules'],
filtered_resource)
visibility = rest_utils.get_visibility_parameter(
optional=True, valid_values=VisibilityState.STATES)
now = get_formatted_timestamp()
new_filter = filters_model(id=filter_id,
value=filter_rules,
created_at=now,
updated_at=now,
visibility=visibility)
return get_storage_manager().put(new_filter)
def create_filter_rules_list(raw_filter_rules: List[dict],
resource_model: FilteredModels):
"""Validate the raw filter rules list and return a FilterRule items list.
:param raw_filter_rules: A list of filter rules. A filter rule is a
dictionary of the following form:
{
key: <key>,
values: [<list of values>],
operator: <LabelsOperator> or <AttrsOperator>,
type: <FilterRuleType>
}
:param resource_model: One of FilteredModels
:return: A list of FilterRule items
"""
filter_rules_list = []
for filter_rule in raw_filter_rules:
_assert_filter_rule_structure(filter_rule)
filter_rule_key = filter_rule['key']
filter_rule_values = filter_rule['values']
filter_rule_type = filter_rule['type']
filter_rule_operator = filter_rule['operator']
if not isinstance(filter_rule_key, text_type):
raise BadFilterRule(filter_rule,
'The filter rule key must be a string')
if not isinstance(filter_rule_values, list):
raise BadFilterRule(filter_rule,
'The filter rule values must be a list')
if filter_rule_type == FilterRuleType.LABEL:
null_operators = [
LabelsOperator.IS_NULL, LabelsOperator.IS_NOT_NULL
]
multiple_values_operators = [
LabelsOperator.ANY_OF, LabelsOperator.NOT_ANY_OF,
LabelsOperator.IS_NOT
]
if filter_rule_operator not in LABELS_OPERATORS:
raise BadFilterRule(
filter_rule, f"The operator for filtering by labels must "
f"be one of {', '.join(LABELS_OPERATORS)}")
if filter_rule_operator in null_operators:
if len(filter_rule_values) > 0:
raise BadFilterRule(
filter_rule,
f"Values list must be empty if the operator is one of "
f"{', '.join(null_operators)}")
else:
if len(filter_rule_values) == 0:
raise BadFilterRule(
filter_rule,
f"Values list must include at least one item if the "
f"operator is one of "
f"{', '.join(multiple_values_operators)}")
elif filter_rule_type == FilterRuleType.ATTRIBUTE:
err_attr_msg = f"Allowed attributes to filter " \
f"{resource_model.__tablename__} by are " \
f"{', '.join(resource_model.allowed_filter_attrs)}"
if filter_rule_operator not in ATTRS_OPERATORS:
raise BadFilterRule(
filter_rule,
f"The operator for filtering by attributes must be one"
f" of {', '.join(ATTRS_OPERATORS)}")
if filter_rule_operator == AttrsOperator.IS_NOT_EMPTY:
if len(filter_rule_values) > 0:
raise BadFilterRule(
filter_rule,
f"Values list must be empty if the operator is "
f"{AttrsOperator.IS_NOT_EMPTY}")
if filter_rule_key not in resource_model.allowed_filter_attrs:
raise BadFilterRule(filter_rule, err_attr_msg)
if (filter_rule_key == 'schedules'
and filter_rule_operator != AttrsOperator.IS_NOT_EMPTY):
raise BadFilterRule(
filter_rule,
f"Filtering by deployment schedules is only possible with "
f"the {AttrsOperator.IS_NOT_EMPTY} operator")
else:
raise BadFilterRule(
filter_rule, f"Filter rule type must be one of "
f"{', '.join(FILTER_RULE_TYPES)}")
for value in filter_rule_values:
try:
if filter_rule_type == FilterRuleType.LABEL:
parse_label(filter_rule_key, value)
else:
validate_inputs({"attributes' filter rule value": value})
except BadParametersError as e:
raise BadFilterRule(filter_rule, str(e))
new_filter_rule = FilterRule(filter_rule_key, filter_rule_values,
filter_rule_operator, filter_rule_type)
if new_filter_rule in filter_rules_list:
continue
filter_rules_list.append(new_filter_rule)
return filter_rules_list
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
validate_inputs({'blueprint_id': blueprint_id})
return UploadedBlueprintsManager().receive_uploaded_data(blueprint_id)
def get(self, name):
"""
Get site by name
"""
validate_inputs({'name': name})
return get_storage_manager().get(models.Site, name)
def get(self, name):
"""
Get agent by name
"""
validate_inputs({'name': name})
return get_storage_manager().get(models.Agent, name)
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
validate_inputs({'blueprint_id': blueprint_id})
return UploadedBlueprintsManager().receive_uploaded_data(blueprint_id)
def get(self, name):
"""
Get site by name
"""
validate_inputs({'name': name})
return get_storage_manager().get(models.Site, name)
