def __check_if_db_is_up():
first = True
while True:
try:
PDPManager.get_pdp(user_id="admin", pdp_id=None)
except sqlalchemy.exc.ProgrammingError:
time.sleep(1)
if first:
logger.warning("Waiting for the database...")
first = False
else:
logger.warning("Database is up, resuming operations...")
break
def patch(self, uuid, user_id=None):
"""Update a pdp
:param uuid: uuid of the pdp to update
:param user_id: user ID who do the request
:return: {
"pdp_id1": {
"name": "name of the PDP",
"security_pipeline": ["may be empty"],
"keystone_project_id": "keystone_project_id1 (may be empty)",
"description": "description of the PDP (optional)",
}
}
:internal_api: update_pdp
"""
_data = dict(request.json)
if not _data.get("keystone_project_id"):
_data["keystone_project_id"] = None
else:
if check_keystone_pid(_data.get("keystone_project_id")):
raise exceptions.PdpKeystoneMappingConflict
data = PDPManager.update_pdp(
user_id=user_id, pdp_id=uuid, value=_data)
logger.debug("data={}".format(data))
logger.debug("uuid={}".format(uuid))
add_pod(uuid=uuid, data=data[uuid])
return {"pdps": data}
def patch(self, uuid=None, user_id=None):
"""Update a pdp
:param uuid: uuid of the pdp to update
:param user_id: user ID who do the request
:return: {
"pdp_id1": {
"name": "...",
"security_pipeline": [...],
"keystone_project_id": "keystone_project_id1",
"description": "...",
}
}
:internal_api: update_pdp
"""
try:
_data = dict(request.json)
if not _data.get("keystone_project_id"):
_data["keystone_project_id"] = None
else:
if check_keystone_pid(_data.get("keystone_project_id")):
raise exceptions.PdpKeystoneMappingConflict
data = PDPManager.update_pdp(user_id=user_id,
pdp_id=uuid,
value=_data)
logger.debug("data={}".format(data))
logger.debug("uuid={}".format(uuid))
add_pod(uuid=uuid, data=data[uuid])
except Exception as e:
logger.error(e, exc_info=True)
return {"result": False, "error": str(e)}, 500
return {"pdps": data}
def _export_pdps(self, json_content):
pdps = PDPManager.get_pdp(self._user_id)
pdps_array = []
for pdp_key in pdps:
logger.info("Exporting pdp {}".format(pdps[pdp_key]))
pdps_array.append(pdps[pdp_key])
if len(pdps_array) > 0:
json_content["pdps"] = pdps_array
def delete(self, uuid, user_id=None):
"""Delete a pdp
:param uuid: uuid of the pdp to delete
:param user_id: user ID who do the request
:return: {
"result": "True or False",
"message": "optional message (optional)"
}
:internal_api: delete_pdp
"""
data = PDPManager.delete_pdp(user_id=user_id, pdp_id=uuid)
delete_pod(uuid)
return {"result": True}
def _import_pdps(self, json_pdps):
if not isinstance(json_pdps, list):
raise InvalidJson("pdps shall be a list!")
for json_pdp in json_pdps:
json_to_use = dict()
JsonUtils.copy_field_if_exists(json_pdp, json_to_use, "name", str)
JsonUtils.copy_field_if_exists(json_pdp, json_to_use,
"keystone_project_id", str)
JsonUtils.copy_field_if_exists(json_pdp, json_to_use,
"security_pipeline", list)
JsonUtils.copy_field_if_exists(json_pdp, json_to_use,
"description", str)
pdps = PDPManager.get_pdp(self._user_id)
exists = False
for pdp_key in pdps:
if pdps[pdp_key]["name"] == json_to_use["name"]:
PDPManager.update_pdp(self._user_id,
pdp_id=pdp_key,
value=json_to_use)
exists = True
if exists is False:
PDPManager.add_pdp(self._user_id, value=json_to_use)
def delete(self, uuid=None, user_id=None):
"""Delete a pdp
:param uuid: uuid of the pdp to delete
:param user_id: user ID who do the request
:return: {
"result": "True or False",
"message": "optional message"
}
:internal_api: delete_pdp
"""
try:
data = PDPManager.delete_pdp(user_id=user_id, pdp_id=uuid)
delete_pod(uuid)
except Exception as e:
logger.error(e, exc_info=True)
return {"result": False, "error": str(e)}, 500
return {"result": True}
def get(self, uuid=None, user_id=None):
"""Retrieve all pdp
:param uuid: uuid of the pdp
:param user_id: user ID who do the request
:return: {
"pdp_id1": {
"name": "...",
"security_pipeline": [...],
"keystone_project_id": "keystone_project_id1",
"description": "... (optional)",
}
}
:internal_api: get_pdp
"""
data = PDPManager.get_pdp(user_id=user_id, pdp_id=uuid)
return {"pdps": data}
def get(self, uuid=None, user_id=None):
"""Retrieve all pdp
:param uuid: uuid of the pdp
:param user_id: user ID who do the request
:return: {
"pdp_id1": {
"name": "...",
"security_pipeline": [...],
"keystone_project_id": "keystone_project_id1",
"description": "...",
}
}
:internal_api: get_pdp
"""
try:
data = PDPManager.get_pdp(user_id=user_id, pdp_id=uuid)
except Exception as e:
logger.error(e, exc_info=True)
return {"result": False, "error": str(e)}, 500
return {"pdps": data}
def post(self, uuid=None, user_id=None):
"""Create pdp.
:param uuid: uuid of the pdp (not used here)
:param user_id: user ID who do the request
:request body: {
"name": "name of the PDP (mandatory)",
"security_pipeline": ["may be empty"],
"keystone_project_id": "keystone_project_id1 (may be empty)",
"description": "description of the PDP (optional)",
}
:return: {
"pdp_id1": {
"name": "...",
"security_pipeline": [...],
"keystone_project_id": "keystone_project_id1",
"description": "... (optional)",
}
}
:internal_api: add_pdp
"""
data = dict(request.json)
if not data.get("keystone_project_id"):
data["keystone_project_id"] = None
else:
if check_keystone_pid(data.get("keystone_project_id")):
raise exceptions.PdpKeystoneMappingConflict
data = PDPManager.add_pdp(
user_id=user_id, pdp_id=None, value=request.json)
uuid = list(data.keys())[0]
logger.debug("data={}".format(data))
logger.debug("uuid={}".format(uuid))
add_pod(uuid=uuid, data=data[uuid])
return {"pdps": data}
def check_keystone_pid(k_pid):
data = PDPManager.get_pdp(user_id="admin")
for pdp_key, pdp_value in data.items():
logger.info("pdp={}".format(pdp_value))
if pdp_value["keystone_project_id"] == k_pid:
return True
def delete_pdp(pdp_id):
from python_moondb.core import PDPManager
PDPManager.delete_pdp("", pdp_id)
def update_pdp(pdp_id, value):
from python_moondb.core import PDPManager
return PDPManager.update_pdp("", pdp_id, value)
def get_pdp(pdp_id=None):
from python_moondb.core import PDPManager
return PDPManager.get_pdp("", pdp_id)
def add_pdp(pdp_id=None, value=None):
from python_moondb.core import PDPManager
return PDPManager.add_pdp("", pdp_id, value)
