def update_region_meta_data(self, region_id, metadata_dict):
"""Replace existing metadata for given region_id
:param region_id:
:param metadata_dict:
:return:
"""
session = self._engine_facade.get_session()
with session.begin():
record = session.query(Region). \
filter_by(region_id=region_id).first()
if not record:
msg = "Region {} not found".format(region_id)
logger.info(msg)
raise error_base.NotFoundError(message=msg)
session.query(RegionMetaData).\
filter_by(region_id=region_id).delete()
region_metadata = []
for k, v in metadata_dict.iteritems():
for list_item in v:
region_metadata.append(
RegionMetaData(region_id=region_id,
meta_data_key=k,
meta_data_value=list_item))
session.add_all(region_metadata)
return record.to_wsme()
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 delete_region_metadata(self, region_id, key):
session = self._engine_facade.get_session()
with session.begin():
record = session.query(Region). \
filter_by(region_id=region_id).first()
if not record:
msg = "Region {} not found".format(region_id)
logger.info(msg)
raise error_base.NotFoundError(message=msg)
session.query(RegionMetaData).filter_by(
region_id=region_id, meta_data_key=key).delete()
def get_groups_data(name):
"""get group from db.
:param name: groupe name
:return: groupe object with its regions
:raise: NoContentError( status code 404)
"""
db = data_manager_factory.get_data_manager()
groups = db.get_group(name)
if not groups:
raise error_base.NotFoundError(
message="Group {} not found".format(name))
return Groups(**groups)
def get_regions_data(url_parms):
"""get region from db.
:param url_parms: the parameters got in the url to make the query
:return: region model for json output
:raise: NoContentError( status code 404)
"""
region_dict, metadata_dict, end_point = url_parms._build_query()
db = data_manager_factory.get_data_manager()
regions = db.get_regions(region_dict, metadata_dict, end_point)
if not regions:
raise error_base.NotFoundError(
message="No regions found for the given search parameters")
return Regions(regions)
def update_region_metadata(region_id, metadata_dict):
LOG.debug("Update metadata to region id : {}. "
"New metadata: {}".format(region_id, metadata_dict))
try:
db = data_manager_factory.get_data_manager()
result = db.update_region_meta_data(region_id, metadata_dict)
if not result:
raise error_base.NotFoundError(message="Region {} not "
"found".format(region_id))
else:
return result.metadata
except Exception as exp:
LOG.exception(
"Error getting metadata for region id:".format(region_id))
raise
def add_region_metadata(region_id, metadata_dict):
LOG.debug("Add metadata: {} to region id : {}".format(
metadata_dict, region_id))
try:
db = data_manager_factory.get_data_manager()
result = db.add_meta_data_to_region(region_id, metadata_dict)
if not result:
raise error_base.NotFoundError(
message="Region {} not found".format(region_id))
else:
return result.metadata
except Exception as exp:
LOG.exception(
"Error getting metadata for region id:".format(region_id))
raise
def update_region_status(self, region_id, region_status):
try:
session = self._engine_facade.get_session()
with session.begin():
record = session.query(Region).filter_by(
region_id=region_id).first()
if record is not None:
record.region_status = region_status
else:
msg = "Region {} not found".format(region_id)
logger.info(msg)
raise error_base.NotFoundError(message=msg)
return record.region_status
except Exception as exp:
logger.exception("failed to update region {}".format(str(exp)))
raise
def create_group_in_db(group_id, group_name, description, regions):
"""Create a region group in the database.
:param group_id: The ID of the group to create
:param group_name: The name of the group to create
:param description: The group description
:param regions: A list of regions inside the group
:raise: GroupExistsError (status code 400) if the group already exists
"""
try:
manager = data_manager_factory.get_data_manager()
manager.add_group(group_id, group_name, description, regions)
except error_base.ConflictError:
LOG.exception("Group {} already exists".format(group_id))
raise error_base.ConflictError(
message="Group {} already exists".format(group_id))
except error_base.InputValueError:
LOG.exception("Some of the regions not found")
raise error_base.NotFoundError(message="Some of the regions not found")
def get_region_by_id_or_name(region_id_or_name):
"""get region by id
:param region_id_or_name:
:return: region object (wsme format)
"""
LOG.debug(
"LOGIC:- get region data by id or name {}".format(region_id_or_name))
try:
db = data_manager_factory.get_data_manager()
region = db.get_region_by_id_or_name(region_id_or_name)
if not region:
raise error_base.NotFoundError(
message="Region {} not found".format(region_id_or_name))
except Exception as exp:
LOG.exception("error in get region by id/name")
raise
return region
def update_group(group, group_id):
result = None
LOG.debug("update group logic")
try:
group = group._to_python_obj()
db_manager = data_manager_factory.get_data_manager()
LOG.debug("update group to {}".format(group._to_db_model_dict()))
db_manager.update_group(group_id=group_id, **group._to_db_model_dict())
LOG.debug("group updated")
# make sure it updated
groups = db_manager.get_group(group_id)
except error_base.NotFoundError:
LOG.error("Group {} not found")
raise
except error_base.InputValueError:
LOG.exception("Some of the regions not found")
raise error_base.NotFoundError(message="Some of the regions not found")
except Exception as exp:
LOG.error("Failed to update group {}".format(group.group_id))
LOG.exception(exp)
raise
return Groups(**groups)
def update_region(
self,
region_to_update,
region_id,
name,
address_state,
address_country,
address_city,
address_street,
address_zip,
region_status,
ranger_agent_version,
open_stack_version,
design_type,
location_type,
vlcp_name,
clli,
# a list of dictionaries of format
# {"type":"", "url":"", "description":""
end_point_list,
# a list of dictionaries of format
# {"key":"", "value":"", "description":""
meta_data_dict,
description=""):
""" add a new region to the `region` table
add also the regions give meta_data and end_points to the `region_end_point` and
`region_meta_data` tables if given.
handle duplicate errors if raised
"""
try:
session = self._engine_facade.get_session()
with session.begin():
# remove all childs as with update need to replace them
session.query(RegionMetaData).filter_by(
region_id=region_to_update).delete()
session.query(RegionEndPoint).filter_by(
region_id=region_to_update).delete()
record = session.query(Region).filter_by(
region_id=region_to_update).first()
if record is not None:
# record.region_id = region_id # ignore id and name when update
# record.name = name
record.address_state = address_state
record.address_country = address_country
record.address_city = address_city
record.address_street = address_street
record.address_zip = address_zip
record.region_status = region_status
record.ranger_agent_version = ranger_agent_version
record.open_stack_version = open_stack_version
record.design_type = design_type
record.location_type = location_type
record.vlcp_name = vlcp_name
record.clli = clli
record.description = description
if end_point_list is not None:
for end_point in end_point_list:
region_end_point = RegionEndPoint(
end_point_type=end_point["type"],
public_url=end_point["url"])
record.end_points.append(region_end_point)
if meta_data_dict is not None:
for k, v in meta_data_dict.iteritems():
for list_item in v:
record.meta_data.append(
RegionMetaData(region_id=region_id,
meta_data_key=k,
meta_data_value=list_item))
else:
raise EntityNotFound(
"Region {} not found".format(region_to_update))
except EntityNotFound as exp:
logger.exception(
"fail to update entity with id {} not found".format(
region_to_update))
raise error_base.NotFoundError(message=exp.message)
except Exception as exp:
logger.exception("fail to update region {}".format(str(exp)))
raise
