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 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 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 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 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 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 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 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)
def post(self, customer):
LOG.info("CustomerController - CreateCustomer: " + str(customer))
authentication.authorize(request, 'customers:create')
try:
uuid = None
if not customer.custId:
uuid = utils.make_uuid()
else:
if not CustomerController.validate_cust_id(customer.custId):
utils.audit_trail('create customer',
request.transaction_id, request.headers,
customer.custId)
raise ErrorStatus('400', None)
try:
uuid = utils.create_existing_uuid(customer.custId)
except TypeError:
raise ErrorStatus(
409.1, 'Customer ID {0} already exists'.format(
customer.custId))
customer_logic = CustomerLogic()
try:
result = customer_logic.create_customer(
customer, uuid, request.transaction_id)
except oslo_db.exception.DBDuplicateEntry as exception:
raise ErrorStatus(
409.2, 'Customer field {0} already exists'.format(
exception.columns))
LOG.info("CustomerController - Customer Created: " + str(result))
event_details = 'Customer {} {} created in regions: {}, with users: {}'.format(
uuid, customer.name, [r.name for r in customer.regions],
[u.id for u in customer.users])
utils.audit_trail('create customer',
request.transaction_id,
request.headers,
uuid,
event_details=event_details)
return result
except ErrorStatus as exception:
LOG.log_exception("CustomerController - Failed to CreateCustomer",
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 CreateCustomer",
exception)
raise err_utils.get_error(request.transaction_id,
status_code=500,
error_details=exception.message)
def post(self, group_input):
"""Handle post request.
:param group_input: json data
:return: 201 created on success, 409 otherwise.
"""
logger.info("Entered Create Group")
logger.debug(
"id = {}, name = {}, description = {}, regions = {}".format(
group_input.id, group_input.name, group_input.description,
group_input.regions))
authentication.authorize(request, 'group:create')
try:
# May raise an exception which will return status code 400
GroupService.create_group_in_db(group_input.id, group_input.name,
group_input.description,
group_input.regions)
logger.debug("Group created successfully in DB")
# Create the group output data with the correct timestamp and link
group = OutputResource(
group_input.id, group_input.name,
repr(int(time.time() * 1000)), {
'self':
'{}/v2/orm/groups/{}'.format(request.application_url,
group_input.id)
})
event_details = 'Region group {} {} created with regions: {}'.format(
group_input.id, group_input.name, group_input.regions)
utils.audit_trail('create group',
request.transaction_id,
request.headers,
group_input.id,
event_details=event_details)
return Result(group)
except error_base.ErrorStatus as e:
logger.error("GroupsController - {}".format(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 test_audit_service_with_tracking(self, mock_audit, mock_init):
utils.audit_trail('create customer',
'1234', {
'X-RANGER-Client': 'Fred',
'X-RANGER-Tracking-Id': 'Track12'
},
'5678',
event_details='CMS')
self.assertEqual(mock_audit.call_args[0][1], 'Fred') # application_id
self.assertEqual(mock_audit.call_args[0][2], 'Track12') # tracking_id
self.assertEqual(mock_audit.call_args[0][3], '1234') # transaction_id
self.assertEqual(mock_audit.call_args[0][4],
'create customer') # transaction_type
self.assertEqual(mock_audit.call_args[0][5], '5678') # resource_id
# self.assertEqual(mock_audit.call_args[0][6], 'cms') # service
self.assertEqual(mock_audit.call_args[0][7], '') # user_id
self.assertEqual(mock_audit.call_args[0][8], 'NA') # external_id
self.assertEqual(mock_audit.call_args[0][9], 'CMS') # event_details
def put(self, region_id, region):
logger.info("API: update region")
authentication.authorize(request, 'region:update')
try:
logger.debug("region to update {} with{}".format(
region_id, region))
result = RegionService.update_region(region_id, region)
logger.debug("API: region {} updated".format(region_id))
event_details = 'Region {} {} modified: AICversion {}, OSversion {}, CLLI {}'.format(
region.name, region.design_type, region.ranger_agent_version,
region.open_stack_version, region.clli)
utils.audit_trail('update region',
request.transaction_id,
request.headers,
region_id,
event_details=event_details)
except error_base.NotFoundError as exp:
logger.exception("region {} not found".format(region_id))
raise err_utils.get_error(request.transaction_id,
status_code=exp.status_code,
message=exp.message)
except error_base.InputValueError as exp:
logger.exception("not valid input {}".format(exp.message))
raise err_utils.get_error(request.transaction_id,
status_code=exp.status_code,
message=exp.message)
except Exception as exp:
logger.exception(
"API: error in updating region {}.. reason:- {}".format(
region_id, exp))
raise err_utils.get_error(request.transaction_id,
status_code=500,
message=exp.message)
return result
def post(self, full_region_input):
logger.info("API: CreateRegion")
authentication.authorize(request, 'region:create')
try:
logger.debug(
"API: create region .. data = : {}".format(full_region_input))
result = RegionService.create_full_region(full_region_input)
logger.debug("API: region created : {}".format(result))
event_details = 'Region {} {} created: AICversion {}, OSversion {}, CLLI {}'.format(
full_region_input.name, full_region_input.design_type,
full_region_input.ranger_agent_version,
full_region_input.open_stack_version, full_region_input.clli)
utils.audit_trail('create region',
request.transaction_id,
request.headers,
full_region_input.id,
event_details=event_details)
except error_base.InputValueError as exp:
logger.exception("Error in save region {}".format(exp.message))
raise err_utils.get_error(request.transaction_id,
status_code=exp.status_code,
message=exp.message)
except error_base.ConflictError as exp:
logger.exception("Conflict error {}".format(exp.message))
raise err_utils.get_error(request.transaction_id,
message=exp.message,
status_code=exp.status_code)
except Exception as exp:
logger.exception(
"Error in creating region .. reason:- {}".format(exp))
raise err_utils.get_error(request.transaction_id,
status_code=500,
message=exp.message)
return result
def put(self, customer_uuid, enable):
authentication.authorize(request, 'customers:enable')
try:
LOG.info(
"EnabledController - (put) customer id {0} enable: {1}".format(
customer_uuid, enable))
customer_logic = CustomerLogic()
result = customer_logic.enable(customer_uuid, enable,
request.transaction_id)
LOG.info(
"EnabledController - change enable (put) finished well: " +
str(result))
event_details = 'Customer {} {}'.format(
customer_uuid, 'enabled' if enable.enabled else 'disabled')
utils.audit_trail('Change enable',
request.transaction_id,
request.headers,
customer_uuid,
event_details=event_details)
except ErrorStatus as exception:
LOG.log_exception("EnabledController - Failed to Change enable",
exception)
raise err_utils.get_error(request.transaction_id,
message=exception.message,
status_code=exception.status_code)
except Exception as exception:
LOG.log_exception(
"EnabledController - change enable (put) - Failed to Change enable",
exception)
raise err_utils.get_error(request.transaction_id,
status_code=500,
error_details=str(exception))
return result
def put(self, group_id, group):
logger.info("update group")
authentication.authorize(request, 'group:update')
try:
logger.debug("update group - id {}".format(group_id))
result = GroupService.update_group(group, group_id)
logger.debug("group updated to :- {}".format(result))
# build result
group_result = OutputResource(
result.id, result.name, repr(int(time.time() * 1000)), {
'self':
'{}/v2/orm/groups/{}'.format(request.application_url,
result.id)
})
event_details = 'Region group {} {} updated with regions: {}'.format(
group_id, group.name, group.regions)
utils.audit_trail('update group',
request.transaction_id,
request.headers,
group_id,
event_details=event_details)
except error_base.ErrorStatus as exp:
logger.error("group to update not found {}".format(exp))
logger.exception(exp)
raise err_utils.get_error(request.transaction_id,
message=exp.message,
status_code=exp.status_code)
except Exception as exp:
logger.error("fail to update groupt -- id {}".format(group_id))
logger.exception(exp)
raise
return Result(group_result)
def delete(self, group_id):
logger.info("delete group")
authentication.authorize(request, 'group:delete')
try:
logger.debug("delete group with id {}".format(group_id))
GroupService.delete_group(group_id)
logger.debug("done")
event_details = 'Region group {} deleted'.format(group_id)
utils.audit_trail('delete group',
request.transaction_id,
request.headers,
group_id,
event_details=event_details)
except Exception as exp:
logger.exception("fail to delete group :- {}".format(exp))
raise err_utils.get_error(request.transaction_id,
status_code=500,
error_details=exp.message)
return
def delete(self, region_id):
logger.info("Delete Region")
authentication.authorize(request, 'region:delete')
try:
logger.debug("delete region {}".format(region_id))
result = RegionService.delete_region(region_id)
logger.debug("region deleted")
event_details = 'Region {} deleted'.format(region_id)
utils.audit_trail('delete region',
request.transaction_id,
request.headers,
region_id,
event_details=event_details)
except Exception as exp:
logger.exception(
"error in deleting region .. reason:- {}".format(exp))
raise err_utils.get_error(request.transaction_id,
status_code=500,
message=exp.message)
return
def test_audit_trail_offline(self, mock_audit):
mock_audit.side_effect = Exception('boom')
resp = utils.audit_trail('create customer', '1234',
{'X-RANGER-Client': 'Fred'}, '5678')
self.assertEqual(resp, None)
def test_audit_trail(self, mock_init, mock_audit):
resp = utils.audit_trail('create customer', '1234',
{'X-RANGER-Client': 'Fred'}, '5678')
self.assertEqual(resp, 200)