def post(self, image_id, region_name, metadata_wrapper): # add metadata to region metadata_logic, utils = di.resolver.unpack(MetadataController) auth.authorize(request, "metadata:create") try: LOG.info("MetadataController - add metadata: " + str(metadata_wrapper)) metadata_logic.add_metadata(image_id, region_name, metadata_wrapper) LOG.info("MetadataController - metadata added") return "OK" except ErrorStatus as exception: LOG.log_exception("MetadataController - Failed to add metadata", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("MetadataController - Failed to add metadata", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def get(self, customer_uuid): LOG.info("CustomerController - GetCustomerDetails: uuid is " + customer_uuid) authentication.authorize(request, 'customers:get_one') try: customer_logic = CustomerLogic() result = customer_logic.get_customer(customer_uuid) LOG.info( "CustomerController - GetCustomerDetails finished well: " + str(result)) except ErrorStatus as exception: LOG.log_exception( "CustomerController - Failed to GetCustomerDetails", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception( "CustomerController - Failed to GetCustomerDetails", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message) return result
def delete(self, customer_id): authentication.authorize(request, 'customers:delete') customer_logic = CustomerLogic() try: LOG.info("CustomerController - DeleteCustomer: uuid is " + customer_id) customer_logic.delete_customer_by_uuid(customer_id) LOG.info("CustomerController - DeleteCustomer finished well") event_details = 'Customer {} deleted'.format(customer_id) utils.audit_trail('delete customer', request.transaction_id, request.headers, customer_id, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("CustomerController - Failed to DeleteCustomer", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("CustomerController - Failed to DeleteCustomer", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def get_all(self, region=None, user=None, starts_with=None, contains=None, metadata=None): LOG.info("CustomerController - GetCustomerlist") authentication.authorize(request, 'customers:get_all') try: customer_logic = CustomerLogic() result = customer_logic.get_customer_list_by_criteria( region, user, starts_with, contains, metadata) return result except ErrorStatus as exception: LOG.log_exception("CustomerController - Failed to GetCustomerlist", exception) raise err_utils.get_error(request.transaction_id, status_code=exception.status_code) except Exception as exception: LOG.log_exception("CustomerController - Failed to GetCustomerlist", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def delete(self, image_uuid): image_logic, utils = di.resolver.unpack(ImageController) LOG.info("Got image delete request") auth.authorize(request, "image:delete") try: LOG.info("ImageController - delete image: image id:" + image_uuid) image_logic.delete_image_by_uuid(image_uuid, request.transaction_id) LOG.info("ImageController - delete image finished well: ") event_details = 'Image {} deleted'.format(image_uuid) utils.audit_trail('delete image', request.transaction_id, request.headers, image_uuid, event_details=event_details) except ErrorStatus as exp: LOG.log_exception("ImageController - Failed to delete image", exp) raise err_utils.get_error(request.transaction_id, message=exp.message, status_code=exp.status_code) except Exception as exp: LOG.log_exception("ImageController - Failed to delete image", exp) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exp))
def get(self, flavor_id): flavor_logic, utils = di.resolver.unpack(OsExtraSpecsController) LOG.info( "OsExtraSpecsController - get all extra specs for flavor: {} ". format(flavor_id)) authentication.authorize(request, 'flavor:get_flavor_extra_specs') try: result = flavor_logic.get_extra_specs_uuid(flavor_id, request.transaction_id) LOG.info( "OsExtraSpecsController - GOT extra specs: {} ".format(result)) utils.audit_trail("get extra specs", request.transaction_id, request.headers, flavor_id) return result except ErrorStatus as exception: LOG.log_exception( "OsExtraSpecsController - Failed to get extra specs", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception( "OsExtraSpecsController - Failed to get extra specs", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, flavor_id, tenant_id): flavor_logic, utils = di.resolver.unpack(TenantController) LOG.info("TenantController - delete tenant: " + str(tenant_id)) authentication.authorize(request, 'flavor:delete_flavor_tenant') try: result = flavor_logic.delete_tenant(flavor_id, tenant_id, request.transaction_id) LOG.info("TenantController - tenant deleted: " + str(result)) event_details = 'Flavor {} tenant {} deleted'.format( flavor_id, tenant_id) utils.audit_trail('delete tenant', request.transaction_id, request.headers, flavor_id, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("TenantController - Failed to delete tenant", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("TenantController - Failed to delete tenant", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, image_id, region_name): image_logic, utils = di.resolver.unpack(RegionController) auth.authorize(request, "region:delete") try: LOG.info("RegionController - delete region: " + str(region_name)) result = image_logic.delete_region(image_id, region_name, request.transaction_id) LOG.info("RegionController - region deleted: " + str(result)) event_details = 'Image {} region {} deleted'.format( image_id, region_name) utils.audit_trail('delete region', request.transaction_id, request.headers, image_id, event_details=event_details) except ErrorStatus as exception: # include NotFoundError LOG.log_exception("RegionController - Failed to delete region", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("RegionController - Failed to delete region", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def post(self, flavor_id, region_wrapper): flavor_logic, utils = di.resolver.unpack(RegionController) LOG.info("RegionController - add regions: " + str(region_wrapper)) authentication.authorize(request, 'flavor:add_flavor_regions') try: result = flavor_logic.add_regions(flavor_id, region_wrapper, request.transaction_id) LOG.info("RegionController - regions added: " + str(result)) event_details = 'Flavor {} regions: {} added'.format( flavor_id, [r.name for r in region_wrapper.regions]) utils.audit_trail('add regions', request.transaction_id, request.headers, flavor_id, event_details=event_details) return result except ErrorStatus as exception: LOG.log_exception("RegionController - Failed to add region", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("RegionController - Failed to add region", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def get_all(self, visibility=None, region=None, tenant=None, series=None, starts_with=None, contains=None, alias=None): flavor_logic, utils = di.resolver.unpack(FlavorController) LOG.info("FlavorController - GetFlavorlist") authentication.authorize(request, 'flavor:get_all') try: result = flavor_logic.get_flavor_list_by_params( visibility, region, tenant, series, starts_with, contains, alias) return result except ErrorStatus as exception: LOG.log_exception("FlavorController - Failed to GetFlavorlist", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("FlavorController - Failed to GetFlavorlist", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, customer_id, region_id): LOG.info("RegionController - Delete Region (delete) customer id {0} region_id: {1}".format(customer_id, region_id)) authentication.authorize(request, 'customers:delete_region') try: customer_logic = CustomerLogic() customer_logic.delete_region(customer_id, region_id, request.transaction_id) LOG.info("RegionController - Delete Region (delete) finished well") event_details = 'Customer {} region: {} deleted'.format( customer_id, region_id) utils.audit_trail('delete region', request.transaction_id, request.headers, customer_id, event_details=event_details) except ValueError as exception: raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=404) except ErrorStatus as exception: LOG.log_exception("CustomerController - Failed to delete region", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("RegionController - Failed in delete Region", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def put(self, flavor_id, tags_wrapper): LOG.info("TagsController - update tags of flavor {}".format(flavor_id)) flavor_logic, utils = di.resolver.unpack(TagsController) LOG.info("TagsController - update tags with {} ".format( tags_wrapper.tags)) authentication.authorize(request, 'flavor:replace_flavor_tags') try: result = flavor_logic.update_tags(flavor_id, tags_wrapper, request.transaction_id) LOG.info("TagsController - tags updated") utils.audit_trail('update tags', request.transaction_id, request.headers, flavor_id) return result except ErrorStatus as exception: LOG.log_exception("TagsController - Failed to update tags", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("TagsController - Failed to update tags", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def put(self, region_id, metadata_input): """Handle put request. :param region_id: region_id to update metadata to. :param metadata_input: json data :return: 201 created on success, 404 not found """ logger.info("Entered update region metadata") logger.debug("Got metadata: {}".format(metadata_input)) authentication.authorize(request, 'metadata:update') try: self._validate_request_input() # May raise an exception which will return status code 400 result = RegionService.update_region_metadata(region_id, metadata_input.metadata) logger.debug("Metadata was successfully added to " "region: {}. New metadata: {}".format(region_id, result)) event_details = 'Region {} metadata updated'.format(region_id) utils.audit_trail('update metadata', request.transaction_id, request.headers, region_id, event_details=event_details) return MetaData(result) except error_base.ErrorStatus as e: logger.error(e.message) raise err_utils.get_error(request.transaction_id, message=e.message, status_code=e.status_code) except Exception as exception: logger.error(exception.message) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def delete(self, flavor_id, extra_spec=None): flavor_logic, utils = di.resolver.unpack(OsExtraSpecsController) LOG.info("OsExtraSpecsController - delete flavor {} extra spec".format( flavor_id)) authentication.authorize(request, 'flavor:delete_flavor_extra_specs') try: flavor_logic.delete_extra_specs(flavor_id, request.transaction_id, extra_spec) LOG.info( "OsExtraSpecsController - extra spec was deleted for flavor {} c" .format(flavor_id)) utils.audit_trail('delete extra spec', request.transaction_id, request.headers, flavor_id) return except ErrorStatus as exception: LOG.log_exception( "OsExtraSpecsController - Failed to delete extra specs", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception( "OsExtraSpecsController - Failed to delete extra specs", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def post(self, flavor_id, tags_wrapper): flavor_logic, utils = di.resolver.unpack(TagsController) LOG.info("TagsController - add tags: " + str(tags_wrapper.tags)) authentication.authorize(request, 'flavor:add_flavor_tags') try: result = flavor_logic.add_tags(flavor_id, tags_wrapper, request.transaction_id) LOG.info("TagsController - tags added") utils.audit_trail('add tags', request.transaction_id, request.headers, flavor_id) return result except ErrorStatus as exception: LOG.log_exception("TagsController - Failed to add tags", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("TagsController - Failed to add tags", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def put(self, image_id, cust_wrapper): image_logic, utils = di.resolver.unpack(CustomerController) auth.authorize(request, "tenant:update") try: LOG.info("CustomerController - replace tenants: " + str(cust_wrapper)) result = image_logic.replace_customers(image_id, cust_wrapper, request.transaction_id) LOG.info("CustomerController - tenants replaced: " + str(result)) event_details = 'Image {} tenants: {} updated'.format( image_id, cust_wrapper.customers) utils.audit_trail('replace tenants', request.transaction_id, request.headers, image_id, event_details=event_details) return result except ErrorStatus as exception: LOG.log_exception("TenantController - Failed to replace tenants", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("TenantController - Failed to replace tenants", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, image_id, cust_id): image_logic, utils = di.resolver.unpack(CustomerController) auth.authorize(request, "tenant:delete") try: LOG.info("TenantController - delete tenant: " + str(cust_id)) result = image_logic.delete_customer(image_id, cust_id, request.transaction_id) LOG.info("TenantController - tenant deleted: " + str(result)) event_details = 'Image {} tenant {} deleted'.format( image_id, cust_id) utils.audit_trail('delete tenant', request.transaction_id, request.headers, image_id, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("TenantController - Failed to delete tenant", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("TenantController - Failed to delete tenant", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def get(self, id=None): """Handle get request. :param id: Group ID :return: 200 OK on success, 404 Not Found otherwise. """ logger.info("Entered Get Group: id = {}".format(id)) authentication.authorize(request, 'group:get_one') try: result = GroupService.get_groups_data(id) logger.debug('Returning group, regions: {}'.format(result.regions)) return result except error_base.NotFoundError as e: logger.error("GroupsController - Group not found") raise err_utils.get_error(request.transaction_id, message=e.message, status_code=404) except Exception as exception: logger.error(exception.message) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def get(self, flavor_uuid_or_name): flavor_logic, utils = di.resolver.unpack(FlavorController) LOG.info("FlavorController - GetFlavorDetails: uuid or name is " + flavor_uuid_or_name) authentication.authorize(request, 'flavor:get_one') try: result = flavor_logic.get_flavor_by_uuid_or_name( flavor_uuid_or_name) LOG.info("FlavorController - GetFlavorDetails finished well: " + str(result)) return result except ErrorStatus as exception: LOG.log_exception("FlavorController - Failed to GetFlavorDetails", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("FlavorController - Failed to GetFlavorDetails", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, flavor_uuid=None): authentication.authorize(request, 'flavor:delete') flavor_logic, utils = di.resolver.unpack(FlavorController) try: LOG.info("FlavorController - delete: uuid is " + flavor_uuid) flavor_logic.delete_flavor_by_uuid(flavor_uuid) LOG.info("FlavorController - delete flavor finished well") event_details = 'Flavor {} deleted'.format(flavor_uuid) utils.audit_trail('delete flavor by uuid', request.transaction_id, request.headers, flavor_uuid, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("FlavorController - Failed to delete flavor", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("FlavorController - Failed to delete flavor", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def get_one(self, lcp_id): logger.info('Received a GET request for LCP %s' % (id, )) authentication.authorize(request, 'lcp:get_one') zones = [] try: zones = get_zones() except Exception as exception: logger.error(exception.message) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message) for zone in zones: if zone["id"] == lcp_id: logger.debug('Returning: %s' % (zone, )) return zone error_msg = 'LCP %s not found' % (lcp_id, ) logger.info(error_msg) raise err_utils.get_error(request.transaction_id, message=error_msg, status_code=404)
def put(self, customer_id, customer): LOG.info("CustomerController - UpdateCustomer: " + str(customer)) authentication.authorize(request, 'customers:update') try: customer_logic = CustomerLogic() result = customer_logic.update_customer(customer, customer_id, request.transaction_id) response.status = 200 LOG.info("CustomerController - UpdateCustomer finished well: " + str(customer)) event_details = 'Customer {} {} updated in regions: {}, with users: {}'.format( customer_id, customer.name, [r.name for r in customer.regions], [u.id for u in customer.users]) utils.audit_trail('update customer', request.transaction_id, request.headers, customer_id, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("Failed in UpdateCustomer", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("CustomerController - Failed to UpdateCustomer", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message) return result
def put(self, image_id, enabled): image_logic, utils = di.resolver.unpack(EnabledController) auth.authorize(request, "image:enable") try: LOG.info("EnabledController - received enabled = {}".format( enabled.enabled)) result = image_logic.enable_image(image_id, enabled.enabled * 1, request.transaction_id) status = "activated" if not enabled.enabled: status = "deactivated" LOG.info( "EnabledController - Image was successfully {}".format(status)) event_details = 'Image {} {}'.format( image_id, 'active' if enabled.enabled else 'inactive') utils.audit_trail('activate image', request.transaction_id, request.headers, image_id, event_details=event_details) return result except ErrorStatus as exception: LOG.log_exception("Failed in EnableImage", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("Failed in EnableImage", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def post(self, flavor_id, extra_specs_wrapper): flavor_logic, utils = di.resolver.unpack(OsExtraSpecsController) LOG.info("OsExtraSpecsController - add extra specs: " + str(extra_specs_wrapper.os_extra_specs)) authentication.authorize(request, 'flavor:add_flavor_extra_specs') try: # for backward_compatibility extra_specs_wrapper = self._extra_specs_redefined( extra_specs_wrapper) result = flavor_logic.add_extra_specs(flavor_id, extra_specs_wrapper, request.transaction_id) LOG.info("OsExtraSpecsController - extra specs added ") utils.audit_trail('add extra specs', request.transaction_id, request.headers, flavor_id) return result except ErrorStatus as exception: LOG.log_exception( "OsExtraSpecsController - Failed to add extra specs", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception( "OsExtraSpecsController - Failed to add extra specs", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception))
def delete(self, flavor_id, tag_to_delete=None): flavor_logic, utils = di.resolver.unpack(TagsController) LOG.info("TagsController - delete flavor {} tags".format(flavor_id)) authentication.authorize(request, 'flavor:delete_flavor_tags') try: flavor_logic.delete_tags(flavor_id, tag_to_delete, request.transaction_id) LOG.info("TagsController - tags deleted for flavor {}".format( flavor_id)) utils.audit_trail('delete tags', request.transaction_id, request.headers, flavor_id, 'Saved to DB') except ErrorStatus as exp: LOG.log_exception("TagsController - Failed to delete tags", exp) utils.audit_trail('delete tags', request.transaction_id, request.headers, flavor_id) raise err_utils.get_error(request.transaction_id, message=exp.message, status_code=exp.status_code) except Exception as exp: LOG.log_exception("TagsController - Failed to delete tags", exp) utils.audit_trail('delete tags', request.transaction_id, request.headers, flavor_id) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exp)) return
def post(self, customer_id, regions): LOG.info("RegionController - Add Regions (post) customer id {0} regions: {1}".format(customer_id, str(regions))) authentication.authorize(request, 'customers:add_region') try: customer_logic = CustomerLogic() result = customer_logic.add_regions(customer_id, regions, request.transaction_id) LOG.info("RegionController - Add Regions (post) finished well: " + str(result)) event_details = 'Customer {} regions: {} added'.format( customer_id, [r.name for r in regions]) utils.audit_trail('add regions', request.transaction_id, request.headers, customer_id, event_details=event_details) except DBDuplicateEntry as exception: LOG.log_exception("RegionController - Add Regions (post) - region already exists", exception) raise err_utils.get_error(request.transaction_id, status_code=409, message='Region already exists', error_details=exception.message) except ErrorStatus as exception: LOG.log_exception("CustomerController - Failed to update regions", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("RegionController - Add Regions (post) - Failed to update regions", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception)) return result
def delete(self, region_id, metadata_key): """Handle delete request. :param region_id: region_id to update metadata to. :param metadata_key: metadata key to be deleted :return: 204 deleted """ logger.info("Entered delete region metadata with " "key: {}".format(metadata_key)) authentication.authorize(request, 'metadata:delete') try: # May raise an exception which will return status code 400 result = RegionService.delete_metadata_from_region(region_id, metadata_key) logger.debug("Metadata was successfully deleted.") event_details = 'Region {} metadata {} deleted'.format( region_id, metadata_key) utils.audit_trail('delete metadata', request.transaction_id, request.headers, region_id, event_details=event_details) except error_base.ErrorStatus as e: logger.error(e.message) raise err_utils.get_error(request.transaction_id, message=e.message, status_code=e.status_code) except Exception as exception: logger.error(exception.message) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)
def put(self, customer_id, regions): LOG.info("RegionController - Replace Regions (put) customer id {0} regions: {1}".format(customer_id, str(regions))) authentication.authorize(request, 'customers:update_region') self.validate_put_url() try: customer_logic = CustomerLogic() result = customer_logic.replace_regions(customer_id, regions, request.transaction_id) LOG.info("RegionController - Replace Regions (put) finished well: " + str(result)) event_details = 'Customer {} regions: {} updated'.format( customer_id, [r.name for r in regions]) utils.audit_trail('Replace regions', request.transaction_id, request.headers, customer_id, event_details=event_details) except ErrorStatus as exception: LOG.log_exception("CustomerController - Failed to Replace regions", exception) raise err_utils.get_error(request.transaction_id, message=exception.message, status_code=exception.status_code) except Exception as exception: LOG.log_exception("RegionController - Replace Regions (put) - Failed to replace regions", exception) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(exception)) return result
def put(self, customer_uuid, metadata): authentication.authorize(request, 'customers:update_metadata') try: res = logic.update_customer_metadata(customer_uuid, metadata, request.transaction_id) event_details = 'Customer {} metadata updated'.format(customer_uuid) utils.audit_trail('update customer metadata', request.transaction_id, request.headers, customer_uuid, event_details=event_details) return res except AttributeError as ex: raise err_utils.get_error(request.transaction_id, message=ex.message, status_code=400) except ValueError as ex: raise err_utils.get_error(request.transaction_id, message=ex.message, status_code=404) except ErrorStatus as ex: LOG.log_exception("MetaDataController - Failed to add metadata", ex) raise err_utils.get_error(request.transaction_id, status_code=ex.status_code) except LookupError as ex: LOG.log_exception("MetaDataController - {0}".format(ex.message), ex) raise err_utils.get_error(request.transaction_id, message=ex.message, status_code=400) except Exception as ex: LOG.log_exception("MetaDataController - Failed to add metadata", ex) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=str(ex))
def put(self, region_id, new_status): """Handle put request to modify region status :param region_id: :param new_status: :return: 200 for updated, 404 for region not found 400 invalid status """ logger.info("Entered update region status") logger.debug("Got status: {}".format(new_status.status)) authentication.authorize(request, 'status:put') try: allowed_status = conf.region_options.allowed_status_values[:] if new_status.status not in allowed_status: logger.error("Invalid status. Region status " "must be one of {}".format(allowed_status)) raise error_base.InputValueError( message="Invalid status. Region status " "must be one of {}".format(allowed_status)) # May raise an exception which will return status code 400 status = RegionService.update_region_status( region_id, new_status.status) base_link = 'https://{0}:{1}{2}'.format(conf.server.host, conf.server.port, pecan.request.path) link = {'self': base_link} logger.debug("Region status for region id {}, was successfully " "changed to: {}.".format(region_id, new_status.status)) event_details = 'Region {} status updated to {}'.format( region_id, new_status.status) utils.audit_trail('Update status', request.transaction_id, request.headers, region_id, event_details=event_details) return RegionStatus(status, link) except error_base.ErrorStatus as e: logger.error(e.message) raise err_utils.get_error(request.transaction_id, message=e.message, status_code=e.status_code) except Exception as exception: logger.error(exception.message) raise err_utils.get_error(request.transaction_id, status_code=500, error_details=exception.message)