def add_pod(uuid, data):
if not data.get("keystone_project_id"):
return
logger.info("Add a new pod {}".format(data))
if "pdp_id" not in data:
data["pdp_id"] = uuid
data['policies'] = PolicyManager.get_policies(user_id="admin")
data['models'] = ModelManager.get_models(user_id="admin")
conf = configuration.get_configuration("components/orchestrator")
hostname = conf["components/orchestrator"].get("hostname", "orchestrator")
port = conf["components/orchestrator"].get("port", 80)
proto = conf["components/orchestrator"].get("protocol", "http")
while True:
try:
req = requests.post(
"{}://{}:{}/pods".format(proto, hostname, port),
json=data,
headers={"content-type": "application/json"})
except requests.exceptions.ConnectionError as e:
logger.warning("add_pod: Orchestrator is not ready, standby...")
logger.exception(e)
time.sleep(1)
else:
break
logger.info("Pod add request answer : {}".format(req.text))
def _import_models_with_new_meta_rules(self, json_models):
if not isinstance(json_models, list):
raise InvalidJson("models shall be a list!")
for json_model in json_models:
logger.debug("json_model {}".format(json_model))
models = ModelManager.get_models(self._user_id)
model_in_db = None
model_id = None
for model_key in models:
if ("id" in json_model and model_key == json_model["id"]) or (
"name" in json_model
and models[model_key]["name"] == json_model["name"]):
model_in_db = models[model_key]
model_id = model_key
# this should not occur as the model has been put in db previously in _import_models_without_new_meta_rules
if model_in_db is None:
raise UnknownModel("Unknown model ")
json_key = dict()
JsonUtils.convert_names_to_ids(json_model, json_key, "meta_rules",
"meta_rule_id", "meta_rule",
ModelManager, self._user_id)
for meta_rule_id in json_key["meta_rule_id"]:
if meta_rule_id not in model_in_db["meta_rules"]:
model_in_db["meta_rules"].append(meta_rule_id)
ModelManager.update_model(self._user_id, model_id, model_in_db)
def _export_models(self, json_content):
models = ModelManager.get_models(self._user_id)
models_array = []
for model_key in models:
model = dict()
JsonUtils.copy_field_if_exists(models[model_key], model, "name",
str)
JsonUtils.copy_field_if_exists(models[model_key], model,
"description", str)
# logger.info(models[model_key]["meta_rules"])
JsonUtils.convert_ids_to_names(models[model_key]["meta_rules"],
model, "meta_rules", "meta_rule",
ModelManager, self._user_id)
logger.info("Exporting model {}".format(model))
models_array.append(model)
if len(models_array) > 0:
json_content["models"] = models_array
def get(self, uuid=None, user_id=None):
"""Retrieve all models
:param uuid: uuid of the model
:param user_id: user ID who do the request
:return: {
"model_id1": {
"name": "...",
"description": "... (optional)",
"meta_rules": ["meta_rule_id1", ]
}
}
:internal_api: get_models
"""
data = ModelManager.get_models(user_id=user_id, model_id=uuid)
return {"models": data}
def get(self, uuid=None, user_id=None):
"""Retrieve all models
:param uuid: uuid of the model
:param user_id: user ID who do the request
:return: {
"model_id1": {
"name": "...",
"description": "...",
"meta_rules": ["meta_rule_id1", ]
}
}
:internal_api: get_models
"""
try:
data = ModelManager.get_models(user_id=user_id, model_id=uuid)
except Exception as e:
logger.error(e, exc_info=True)
return {"result": False, "error": str(e)}, 500
return {"models": data}
def _import_models_without_new_meta_rules(self, json_models):
if not isinstance(json_models, list):
raise InvalidJson("models shall be a list!")
for json_model in json_models:
json_without_new_metarules = dict()
JsonUtils.copy_field_if_exists(json_model,
json_without_new_metarules, "name",
str)
# TODO put this in moondb
# model_in_db = ModelManager.get_models_by_name(json_without_new_metarules["name"])
models = ModelManager.get_models(self._user_id)
model_in_db = None
for model_key in models:
if models[model_key]["name"] == json_without_new_metarules[
"name"]:
model_in_db = models[model_key]
model_id = model_key
# end TODO
JsonUtils.copy_field_if_exists(json_model,
json_without_new_metarules,
"description", str)
if model_in_db is None:
model_does_exist = False
else:
json_without_new_metarules["meta_rules"] = model_in_db[
"meta_rules"]
model_does_exist = True
model_override = JsonUtils.get_override(json_model)
if not model_does_exist:
logger.debug(
"Creating model {} ".format(json_without_new_metarules))
ModelManager.add_model(self._user_id, None,
json_without_new_metarules)
elif model_override is True:
logger.debug("Updating model with id {} : {} ".format(
model_id, json_without_new_metarules))
ModelManager.update_model(self._user_id, model_id,
json_without_new_metarules)
def get_models(model_id=None):
from python_moondb.core import ModelManager
return ModelManager.get_models(user_id=None, model_id=model_id)
