def update_group(self, group_id, group_name, group_description,
group_regions):
try:
session = self._engine_facade.get_session()
with session.begin():
# in update scenario delete all child records
session.query(GroupRegion).filter_by(
group_id=group_id).delete()
group_record = session.query(Group).filter_by(
group_id=group_id).first()
if group_record is None:
raise error_base.NotFoundError(
message="Group {} not found".format(group_id))
# only desc and regions can be changed
group_record.description = group_description
group_record.name = group_name
regions = []
for region_id in group_regions:
regions.append(
GroupRegion(region_id=region_id, group_id=group_id))
session.add_all(regions)
except error_base.NotFoundError as exp:
logger.error(exp.message)
raise
except oslo_db.exception.DBReferenceError as e:
logger.error("Reference error: {}".format(str(e)))
raise error_base.InputValueError("Reference error")
except Exception as exp:
logger.error("failed to update group {}".format(group_id))
logger.exception(exp)
raise
return
def add_group(self, group_id, group_name, group_description,
region_ids_list):
session = self._engine_facade.get_session()
try:
with session.begin():
session.add(
Group(group_id=group_id,
name=group_name,
description=group_description))
session.flush() # add the groupe if not rollback
if region_ids_list is not None:
group_regions = []
for region_id in region_ids_list:
group_regions.append(
GroupRegion(group_id=group_id,
region_id=region_id))
session.add_all(group_regions)
except oslo_db.exception.DBReferenceError as e:
logger.error("Reference error: {}".format(str(e)))
raise error_base.InputValueError("Reference error")
except oslo_db.exception.DBDuplicateEntry as e:
logger.error("Duplicate entry: {}".format(str(e)))
raise error_base.ConflictError("Duplicate entry error")
def _validate_end_points(self, endpoints_types_must_have):
ep_duplicate = []
for endpoint in self.endpoints:
if endpoint.type not in ep_duplicate:
ep_duplicate.append(endpoint.type)
else:
raise error_base.InputValueError(
message="Invalid endpoints. Duplicate endpoint "
"type {}".format(endpoint.type))
try:
endpoints_types_must_have.remove(endpoint.type)
except Exception:
pass
if len(endpoints_types_must_have) > 0:
raise error_base.InputValueError(
message="Invalid endpoints. Endpoint type '{}' "
"is missing".format(endpoints_types_must_have))
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 _validate_status(self, allowed_status):
if self.status not in allowed_status:
raise error_base.InputValueError(
message="Invalid status. Region status must be "
"one of {}".format(allowed_status))
return