def patch(self, blueprint_id):
"""
Set the blueprint's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_visibility(models.Blueprint,
blueprint_id, visibility)
def patch(self, deployment_id):
"""
Set the deployment's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_deployment_visibility(
deployment_id, visibility)
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 patch(self, key):
"""
Set the secret's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_visibility(models.Secret, key,
visibility)
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 patch(self, plugin_id):
"""
Set the plugin's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_visibility(models.Plugin, plugin_id,
visibility)
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 patch(self, key):
"""
Set the secret's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_visibility(models.Secret,
key,
visibility)
def patch(self, deployment_id):
"""
Set the deployment's visibility
"""
visibility = rest_utils.get_visibility_parameter(
valid_values=VisibilityState.TENANT)
return get_resource_manager().set_visibility(models.Deployment,
deployment_id, visibility)
def patch(self, blueprint_id):
"""
Set the blueprint's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_visibility(models.Blueprint,
blueprint_id,
visibility)
def patch(self, deployment_id):
"""
Set the deployment's visibility
"""
visibility = rest_utils.get_visibility_parameter()
return get_resource_manager().set_deployment_visibility(
deployment_id,
visibility
)
def post(self, **kwargs):
"""
Upload a plugin
"""
visibility = rest_utils.get_visibility_parameter(
optional=True,
is_argument=True,
valid_values=VisibilityState.STATES)
with rest_utils.skip_nested_marshalling():
return super(Plugins, self).post(visibility=visibility)
def put(self, blueprint_id, **kwargs):
"""
Upload a blueprint (id specified)
"""
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 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 _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, deployment_id, **kwargs):
"""
Create a deployment
"""
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=types.boolean)])
visibility = rest_utils.get_visibility_parameter(
optional=True,
valid_values=[VisibilityState.PRIVATE, VisibilityState.TENANT])
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))
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)
