def get_mock_customer_logic():
global metadata_logic_mock
metadata_logic_mock = mock.MagicMock()
if metadata.logic.return_error == 0:
res = Models.CustomerResultWrapper(transaction_id='1',
id='1',
links={},
updated=None,
created='1')
metadata_logic_mock.add_customer_metadata.return_value = res
metadata_logic_mock.update_customer_metadata.return_value = res
elif metadata.logic.return_error == 1:
metadata_logic_mock.add_customer_metadata.side_effect = SystemError()
metadata_logic_mock.update_customer_metadata.side_effect = SystemError()
elif metadata.logic.return_error == 2:
metadata_logic_mock.add_customer_metadata.side_effect = ErrorStatus(status_code=404)
metadata_logic_mock.update_customer_metadata.side_effect = ErrorStatus(status_code=404)
elif metadata.logic.return_error == 3:
metadata_logic_mock.add_customer_metadata.side_effect = LookupError()
metadata_logic_mock.update_customer_metadata.side_effect = LookupError()
elif metadata.logic.return_error == 4:
metadata_logic_mock.add_customer_metadata.side_effect = AttributeError()
metadata_logic_mock.update_customer_metadata.side_effect = AttributeError()
elif metadata.logic.return_error == 5:
metadata_logic_mock.add_customer_metadata.side_effect = ValueError()
metadata_logic_mock.update_customer_metadata.side_effect = ValueError()
return metadata_logic_mock
def replace_users(self, customer_uuid, region_name, users, transaction_id):
datamanager = None
try:
datamanager = DataManager()
datamanager.begin_transaction()
customer_id = datamanager.get_customer_id_by_uuid(customer_uuid)
if customer_id is None:
raise ErrorStatus(
404, "customer {} does not exist".format(customer_uuid))
region_id = datamanager.get_region_id_by_name(region_name)
if region_id is None:
raise ErrorStatus(404,
"region {} not found".format(region_name))
# delete older default user
user_role_record = datamanager.get_record('user_role')
user_role_record.delete_all_users_from_region(
customer_uuid, region_name) # -1 is default region
result = self.add_users(customer_uuid, region_name, users,
transaction_id, datamanager)
datamanager.commit()
return result
except Exception as exception:
datamanager.rollback()
LOG.log_exception("Failed to replace_default_users", exception)
raise
def get_mock_customer_logic():
global customer_logic_mock
customer_logic_mock = mock.MagicMock()
if root.CustomerLogic.return_error == 0:
res = Models.CustomerResultWrapper(transaction_id='1',
id='1',
links={},
updated=None,
created='1')
list_res = Models.CustomerSummaryResponse()
list_res.customers.append(Models.CustomerSummary(name='1', id='1', description='1'))
customer_logic_mock.create_customer.return_value = res
customer_logic_mock.update_customer.return_value = res
customer_logic_mock.get_customer.return_value = Models.Customer(**RET_CUSTOMER_JSON)
customer_logic_mock.get_customer_list_by_criteria.return_value = list_res
elif root.CustomerLogic.return_error == 1:
customer_logic_mock.create_customer.side_effect = SystemError()
customer_logic_mock.update_customer.side_effect = SystemError()
customer_logic_mock.get_customer.side_effect = SystemError()
customer_logic_mock.delete_customer_by_uuid.side_effect = SystemError()
customer_logic_mock.get_customer_list_by_criteria.side_effect = SystemError()
else:
customer_logic_mock.create_customer.side_effect = ErrorStatus(status_code=404)
customer_logic_mock.update_customer.side_effect = ErrorStatus(status_code=404)
customer_logic_mock.get_customer.side_effect = ErrorStatus(status_code=404)
customer_logic_mock.delete_customer_by_uuid.side_effect = ErrorStatus(
status_code=409)
customer_logic_mock.get_customer_list_by_criteria.side_effect = ErrorStatus(status_code=404)
return customer_logic_mock
def add_default_users(self,
customer_uuid,
users,
transaction_id,
p_datamanager=None):
datamanager = None
try:
if p_datamanager is None:
datamanager = DataManager()
datamanager.begin_transaction()
else:
datamanager = p_datamanager
customer_id = datamanager.get_customer_id_by_uuid(customer_uuid)
if customer_id is None:
raise ErrorStatus(
404, "customer {} does not exist".format(customer_uuid))
self.add_users_to_db(datamanager,
customer_id,
-1,
users,
adding=True)
customer_record = datamanager.get_record('customer')
customer = customer_record.read_customer(customer_id)
timestamp = utils.get_time_human()
datamanager.flush(
) # i want to get any exception created by this insert
if len(customer.customer_customer_regions) > 1:
RdsProxy.send_customer(customer, transaction_id, "PUT")
if p_datamanager is None:
datamanager.commit()
base_link = '{0}{1}/'.format(conf.server.host_ip,
pecan.request.path)
result_users = [{
'id': user.id,
'added': timestamp,
'links': {
'self': base_link + user.id
}
} for user in users]
user_result_wrapper = UserResultWrapper(
transaction_id=transaction_id, users=result_users)
return user_result_wrapper
except Exception as exception:
datamanager.rollback()
if 'Duplicate' in exception.message:
raise ErrorStatus(409, exception.message)
LOG.log_exception("Failed to add_default_users", exception)
raise
def replace_regions(self, customer_uuid, regions, transaction_id):
datamanager = DataManager()
customer_record = datamanager.get_record('customer')
customer_region = datamanager.get_record('customer_region')
try:
customer_id = datamanager.get_customer_id_by_uuid(customer_uuid)
if customer_id is None:
raise ErrorStatus(
404,
"customer with id {} does not exist".format(customer_uuid))
old_sql_customer = customer_record.read_customer_by_uuid(
customer_uuid)
if old_sql_customer is None:
raise ErrorStatus(
404,
"customer with id {} does not exist".format(customer_id))
old_customer_dict = old_sql_customer.get_proxy_dict()
datamanager.session.expire(old_sql_customer)
customer_region.delete_all_regions_for_customer(customer_id)
self.add_regions_to_db(regions, customer_id, datamanager)
timestamp = utils.get_time_human()
new_sql_customer = datamanager.get_cusomer_by_id(customer_id)
new_sql_customer = self.add_default_users_to_empty_regions(
new_sql_customer)
new_customer_dict = new_sql_customer.get_proxy_dict()
datamanager.flush(
) # i want to get any exception created by this insert
new_customer_dict["regions"] = self.resolve_regions_actions(
old_customer_dict["regions"], new_customer_dict["regions"])
RdsProxy.send_customer_dict(new_customer_dict, transaction_id,
"PUT")
datamanager.commit()
base_link = '{0}{1}/'.format(conf.server.host_ip,
pecan.request.path)
result_regions = [{
'id': region.name,
'added': timestamp,
'links': {
'self': base_link + region.name
}
} for region in regions]
region_result_wrapper = RegionResultWrapper(
transaction_id=transaction_id, regions=result_regions)
return region_result_wrapper
except Exception as exp:
datamanager.rollback()
raise exp
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 flush(self):
try:
self.session.flush()
except oslo_db.exception.DBDuplicateEntry as exception:
raise ErrorStatus(409.2, 'Duplicate Entry {0} already exist'.format(exception.columns))
except Exception:
raise
def get_customer(self, customer):
datamanager = DataManager()
sql_customer = datamanager.get_cusomer_by_uuid_or_name(customer)
if not sql_customer:
raise ErrorStatus(404, 'customer: {0} not found'.format(customer))
ret_customer = sql_customer.to_wsme()
if sql_customer.get_real_customer_regions():
# if we have regions in sql_customer
resp = requests.get(conf.api.rds_server.base +
conf.api.rds_server.status + sql_customer.uuid,
verify=conf.verify).json()
for item in ret_customer.regions:
for status in resp['regions']:
if status['region'] == item.name:
item.status = status['status']
if status['error_msg']:
item.error_message = status['error_msg']
ret_customer.status = resp['status']
else:
ret_customer.status = 'no regions'
return ret_customer
def delete_default_users(self, customer_uuid, user_id, transaction_id):
datamanager = DataManager()
try:
customer = datamanager.get_cusomer_by_uuid(customer_uuid)
if customer is None:
raise ErrorStatus(
404, "customer {} does not exist".format(customer_uuid))
user_role_record = datamanager.get_record('user_role')
result = user_role_record.delete_user_from_region(
customer_uuid, 'DEFAULT', user_id)
if result.rowcount == 0:
raise NotFound("user {} is not found".format(user_id))
datamanager.commit()
print "User {0} from region {1} in customer {2} deleted".format(
user_id, 'DEFAULT', customer_uuid)
except NotFound as e:
datamanager.rollback()
LOG.log_exception("Failed to delete_users, user not found",
e.message)
raise NotFound("Failed to delete users, %s not found" % e.message)
except Exception as exp:
datamanager.rollback()
raise exp
def validate_model(self, context=None):
"""this function check if the customer model meet the demands
:param context: i.e. 'create 'update'
:return: none
"""
if context == "update":
for region in self.regions:
if region.type == "group":
raise ErrorStatus(
400,
"region type is invalid for update, \'group\' can be only in create"
)
def get_mock_customer_logic():
global customer_logic_mock
customer_logic_mock = mock.MagicMock()
if users.CustomerLogic.return_error == 0:
res = Models.UserResultWrapper(transaction_id='1', users=[])
customer_logic_mock.add_default_users.return_value = res
customer_logic_mock.add_users.return_value = res
customer_logic_mock.replace_default_users.return_value = res
customer_logic_mock.replace_users.return_value = res
elif users.CustomerLogic.return_error == 1:
customer_logic_mock.add_users.side_effect = SystemError()
customer_logic_mock.add_default_users.side_effect = SystemError()
customer_logic_mock.replace_users.side_effect = SystemError()
customer_logic_mock.replace_default_users.side_effect = SystemError()
customer_logic_mock.delete_users.side_effect = SystemError()
customer_logic_mock.delete_default_users.side_effect = SystemError()
else:
customer_logic_mock.add_users.side_effect = ErrorStatus(
status_code=404)
customer_logic_mock.add_default_users.side_effect = ErrorStatus(
status_code=404)
customer_logic_mock.replace_users.side_effect = ErrorStatus(
status_code=404)
customer_logic_mock.replace_default_users.side_effect = ErrorStatus(
status_code=404)
customer_logic_mock.delete_users.side_effect = ErrorStatus(
status_code=404)
customer_logic_mock.delete_default_users.side_effect = ErrorStatus(
status_code=404)
return customer_logic_mock
def add_regions(self, customer_uuid, regions, transaction_id):
datamanager = DataManager()
customer_record = datamanager.get_record('customer')
try:
# TODO DataBase action
customer_id = datamanager.get_customer_id_by_uuid(customer_uuid)
if customer_id is None:
raise ErrorStatus(
404,
"customer with id {} does not exist".format(customer_uuid))
self.add_regions_to_db(regions, customer_id, datamanager)
sql_customer = customer_record.read_customer_by_uuid(customer_uuid)
sql_customer = self.add_default_users_to_empty_regions(
sql_customer)
new_customer_dict = sql_customer.get_proxy_dict()
for region in new_customer_dict["regions"]:
new_region = next(
(r for r in regions if r.name == region["name"]), None)
if new_region:
region["action"] = "create"
else:
region["action"] = "modify"
timestamp = utils.get_time_human()
datamanager.flush(
) # i want to get any exception created by this insert
RdsProxy.send_customer_dict(new_customer_dict, transaction_id,
"POST")
datamanager.commit()
base_link = '{0}{1}/'.format(conf.server.host_ip,
pecan.request.path)
result_regions = [{
'id': region.name,
'added': timestamp,
'links': {
'self': base_link + region.name
}
} for region in regions]
region_result_wrapper = RegionResultWrapper(
transaction_id=transaction_id, regions=result_regions)
return region_result_wrapper
except Exception as exp:
datamanager.rollback()
raise
def handle_region_group(self):
regions_to_add = []
for region in self.regions[:]: # get copy of it to be able to delete from the origin
if region.type == "group":
group_regions = self.get_regions_for_group(region.name)
if not group_regions:
raise ErrorStatus(404,
'Group {} Not found'.format(region.name))
for group_region in group_regions:
regions_to_add.append(
Region(name=group_region,
type='single',
quotas=region.quotas,
users=region.users))
self.regions.remove(region)
self.regions.extend(set(regions_to_add)) # remove duplicates if exist
def get_mock_customer_logic():
global customer_logic_mock
customer_logic_mock = mock.MagicMock()
if enabled.CustomerLogic.return_error == 0:
res = Models.CustomerResultWrapper(transaction_id='1',
id='1',
links={},
updated=None,
created='1')
customer_logic_mock.enable.return_value = res
elif enabled.CustomerLogic.return_error == 1:
customer_logic_mock.enable.side_effect = SystemError()
elif enabled.CustomerLogic.return_error == 2:
customer_logic_mock.enable.side_effect = ErrorStatus(status_code=404)
return customer_logic_mock
def enable(self, customer_uuid, enabled, transaction_id):
try:
datamanager = DataManager()
customer_record = datamanager.get_record('customer')
sql_customer = customer_record.read_customer_by_uuid(customer_uuid)
if not sql_customer:
raise ErrorStatus(
404, 'customer: {0} not found'.format(customer_uuid))
sql_customer.enabled = 1 if enabled.enabled else 0
RdsProxy.send_customer(sql_customer, transaction_id, "PUT")
datamanager.flush() # get any exception created by this action
datamanager.commit()
except Exception as exp:
datamanager.rollback()
raise exp
def delete_region(self, customer_id, region_id, transaction_id):
datamanager = DataManager()
try:
customer_region = datamanager.get_record('customer_region')
sql_customer = datamanager.get_cusomer_by_uuid(customer_id)
if sql_customer is None:
raise ErrorStatus(
404,
"customer with id {} does not exist".format(customer_id))
customer_dict = sql_customer.get_proxy_dict()
customer_region.delete_region_for_customer(customer_id, region_id)
datamanager.flush(
) # i want to get any exception created by this insert
# i want to get any exception created by this insert
datamanager.flush()
region = next((r.region
for r in sql_customer.customer_customer_regions
if r.region.name == region_id), None)
if region:
if region.type == 'group':
set_utils_conf(conf)
regions = get_regions_of_group(region.name)
else:
regions = [region_id]
for region in customer_dict['regions']:
if region['name'] in regions:
region['action'] = 'delete'
RdsProxy.send_customer_dict(customer_dict, transaction_id, "PUT")
datamanager.commit()
LOG.debug("Region {0} in customer {1} deleted".format(
region_id, customer_id))
except Exception as exp:
datamanager.rollback()
raise
def update_customer(self, customer, customer_uuid, transaction_id):
datamanager = DataManager()
try:
customer.validate_model('update')
customer_record = datamanager.get_record('customer')
cutomer_id = customer_record.get_customer_id_from_uuid(
customer_uuid)
sql_customer = customer_record.read_customer_by_uuid(customer_uuid)
if not sql_customer:
raise ErrorStatus(
404, 'customer {0} was not found'.format(customer_uuid))
old_customer_dict = sql_customer.get_proxy_dict()
customer_record.delete_by_primary_key(cutomer_id)
datamanager.flush()
sql_customer = self.build_full_customer(customer, customer_uuid,
datamanager)
sql_customer = self.add_default_users_to_empty_regions(
sql_customer)
new_customer_dict = sql_customer.get_proxy_dict()
new_customer_dict["regions"] = self.resolve_regions_actions(
old_customer_dict["regions"], new_customer_dict["regions"])
customer_result_wrapper = build_response(customer_uuid,
transaction_id, 'update')
datamanager.flush(
) # i want to get any exception created by this insert
if not len(new_customer_dict['regions']) == 0:
RdsProxy.send_customer_dict(new_customer_dict, transaction_id,
"PUT")
datamanager.commit()
return customer_result_wrapper
except Exception as exp:
LOG.log_exception("CustomerLogic - Failed to CreateCustomer", exp)
datamanager.rollback()
raise
def delete_customer_by_uuid(self, customer_id):
datamanager = DataManager()
try:
datamanager.begin_transaction()
customer_record = datamanager.get_record('customer')
sql_customer = customer_record.read_customer_by_uuid(customer_id)
if sql_customer is None:
# The customer does not exist, so the delete operation is
# considered successful
return
real_regions = sql_customer.get_real_customer_regions()
if len(real_regions) > 0:
# Do not delete a customer that still has some regions
raise ErrorStatus(
405, "Cannot delete a customer that has regions. "
"Please delete the regions first and then "
"delete the customer.")
else:
expected_status = 'Success'
invalid_status = 'N/A'
# Get status from RDS
resp = RdsProxy.get_status(sql_customer.uuid)
if resp.status_code == 200:
status_resp = resp.json()
if 'status' in status_resp.keys():
LOG.debug('RDS returned status: {}'.format(
status_resp['status']))
status = status_resp['status']
else:
# Invalid response from RDS
LOG.error('Response from RDS did not contain status')
status = invalid_status
elif resp.status_code == 404:
# Customer not found in RDS, that means it never had any regions
# So it is OK to delete it
LOG.debug(
'Resource not found in RDS, so it is OK to delete')
status = expected_status
else:
# Invalid status code from RDS
log_message = 'Invalid response code from RDS: {}'.format(
resp.status_code)
log_message = log_message.replace('\n',
'_').replace('\r', '_')
LOG.warning(log_message)
status = invalid_status
if status == invalid_status:
raise ErrorStatus(500, "Could not get customer status")
elif status != expected_status:
raise ErrorStatus(
409, "The customer has not been deleted "
"successfully from all of its regions "
"(either the deletion failed on one of the "
"regions or it is still in progress)")
# OK to delete
customer_record.delete_customer_by_uuid(customer_id)
datamanager.flush(
) # i want to get any exception created by this delete
datamanager.commit()
except Exception as exp:
LOG.log_exception("CustomerLogic - Failed to delete customer", exp)
datamanager.rollback()
raise
def send_customer_dict(customer_dict, transaction_id,
method): # method is "POST" or "PUT"
data = {
"service_template": {
"resource": {
"resource_type": "customer"
},
"model": str(json.dumps(customer_dict)),
"tracking": {
"external_id": "",
"tracking_id": transaction_id
}
}
}
data_to_display = {
"service_template": {
"resource": {
"resource_type": "customer"
},
"model": customer_dict,
"tracking": {
"external_id": "",
"tracking_id": transaction_id
}
}
}
pp = pprint.PrettyPrinter(width=30)
pretty_text = pp.pformat(data_to_display)
wrapper_json = json.dumps(data)
headers['X-RANGER-Client'] = request.headers[
'X-RANGER-Client'] if 'X-RANGER-Client' in request.headers else \
'NA'
headers['X-RANGER-Requester'] = request.headers[
'X-RANGER-Requester'] if 'X-RANGER-Requester' in request.headers else \
''
LOG.debug(
"Wrapper JSON before sending action: {0} to Rds Proxy\n{1}".format(
method, pretty_text))
LOG.info("Sending to RDS Server: " + conf.api.rds_server.base +
conf.api.rds_server.resources)
wrapper_json = json.dumps(data)
if method == "POST":
resp = requests.post(conf.api.rds_server.base +
conf.api.rds_server.resources,
data=wrapper_json,
headers=headers,
verify=conf.verify)
else:
resp = requests.put(conf.api.rds_server.base +
conf.api.rds_server.resources,
data=wrapper_json,
headers=headers,
verify=conf.verify)
if resp.content:
LOG.debug("Response Content from rds server: {0}".format(
resp.content))
content = resp.content
if resp.content:
content = resp.json()
if resp.content and 200 <= resp.status_code < 300:
content = resp.json()
return content
raise ErrorStatus(resp.status_code, content)