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)
