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)