def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.jungler_p = PathManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.jungler_p = PathManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def __init__(self):
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
class PathManager(object):
"""
Handles operations concerning Paths
"""
def __init__(self):
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_get_on_path(self, req_path, terms):
"""
Channel get on path request to the manager responsible
Args:
@param req_path: Address to which this post request was sent
@param terms: Data provided for filtering
"""
locations = list()
#Step[1]: get the necessary data from DB
occi_loc = self.rd_baker.bake_to_get_on_path()
if terms is "":
#Step[2a]: Get on path without filtering
if occi_loc is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
for str_loc in occi_loc:
if str_loc.find(req_path) is not -1:
locations.append(str_loc)
logger.debug("===== Channel_get_on_Path: Finished with success ===== ")
return locations, return_code['OK']
else:
#Step[2b]: Get on path with filtering
for str_loc in occi_loc:
if str_loc.endswith("/") is False and str_loc.find(req_path) is not -1:
locations.append(str_loc)
descriptions = self.rd_baker.bake_to_get_on_path_filtered(locations)
if descriptions is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
if terms.has_key('resources'):
result_res, resp_code_r = get_filtered(terms['resources'], descriptions)
else:
result_res = list()
resp_code_r = return_code['OK']
if terms.has_key('links'):
result_link, resp_code_l = get_filtered(terms['links'], descriptions)
else:
result_link = list()
resp_code_l = return_code['OK']
if resp_code_l is not return_code['OK'] or resp_code_r is not return_code['OK']:
return "An error has occurred, please check logs for more details", return_code[
'Internal Server Error']
result = result_res + result_link
logger.debug("===== Channel_get_on_Path: Finished with success ===== ")
return result, return_code['OK']
def channel_delete_on_path(self, req_path):
"""
Channel the delete resources request to the path manager
Args:
@param req_path: Address to which this post request was sent
"""
occi_loc,doc_loc = self.rd_baker.bake_to_delete_on_path()
if occi_loc is None or doc_loc is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
to_delete = list()
for i in range(len(occi_loc)):
str_loc = str(occi_loc[i])
if str_loc.find(req_path) is not -1:
to_delete.append(doc_loc[i])
self.PostMan.delete_entities_in_db(to_delete)
logger.debug("===== Channel Delete on Path: Finished with success =====")
return "", return_code['OK']
class SingleEntityJungler(object):
"""
Handles requests concerning single entities
"""
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_put_single_resource(self, jBody, path_url):
"""
Creates a new resource or performs a full update of the resource description
Args:
@param jBody: Data contained in the request body
@param path_url: URL of the request
"""
#Step[1]: Get the data necessary from the database
db_occi_ids_locs,db_resources_nb = self.rd_baker.bake_to_put_single(path_url)
if db_occi_ids_locs is None or db_resources_nb is None:
return "An error has occurred, please check log for more details",return_code['Internal Server Error']
else:
if db_resources_nb is 0:
#Step[2a]: This is a create a new resource request with a custom URL
if jBody.has_key('resources'):
logger.debug("===== Channel_put_single_resources ==== : Resource custom creation channeled")
entity, resp_code_r = self.manager_r.register_custom_resource(jBody['resources'][0],path_url,db_occi_ids_locs)
else:
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug("===== Channel_put_single_resources ==== : Link custom creation channeled")
entity, resp_code_l = self.manager_l.register_custom_link(jBody['links'][0],path_url,db_occi_ids_locs)
else:
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code['OK, and location returned'] or resp_code_l is not return_code['OK, and location returned']:
return "An error has occurred, please check log for more details",return_code['Bad Request']
self.PostMan.save_custom_resource(entity)
logger.debug("===== Channel_put_single_resource ==== : Finished (2a) with success")
backend_m.create_entity(entity)
#Step[3a]: Return the locations of the resources
return entity['OCCI_Location'],return_code['OK, and location returned']
else:
#Step[2b]: This is a full update resource request (More data is needed)
olddoc = self.rd_baker.bake_to_put_single_updateCase(path_url)
if olddoc is None:
return "An error has occurred, please check log for more details",return_code['Bad Request']
else:
if jBody.has_key('resources'):
logger.debug("===== Channel_put_single_resources ==== : Resource full update channeled")
entity, resp_code_r = self.manager_r.update_resource(olddoc,jBody['resources'][0])
else:
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug("===== Channel_put_single_resources ==== : Link full update channeled")
entity, resp_code_l = self.manager_l.update_link(olddoc,jBody['links'][0])
else:
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code['OK, and location returned'] or resp_code_l is not return_code['OK, and location returned']:
return "An error has occurred, please check log for more details",return_code['Bad Request']
self.PostMan.save_updated_doc_in_db(entity)
logger.debug("===== Channel_put_single_resource ==== : Finished (2b) with success")
#return the locations of the resources
backend_m.update_entity(olddoc['OCCI_Description'],entity['OCCI_Description'])
return olddoc['OCCI_Location'],return_code['OK, and location returned']
def channel_get_single_resource(self, path_url):
"""
Retrieve the description of a resource related to the URL provided
Args:
@param path_url: URL of the request
"""
#Step[1]: Get data from the database
res,entity = self.rd_baker.bake_to_get_single_res(path_url)
if res is None:
return "An error has occured, please check logs for more details", return_code['Internal Server Error']
elif res is 0:
logger.warning("===== Channel_get_single_resource ==== : Resource not found")
else:
logger.debug("===== Channel_get_single_resource ==== : Finished with success")
#Step[2]: return OCCI resource description to the dispatcher
return res,return_code['OK']
def channel_post_single_resource(self, jBody, path_url):
"""
Performs a partial description update of the resource
Args:
@param jBody: New OCCI values
@param path_url: URL of the request
"""
#Step[1]: Get the necessary data from the database
db_occi_ids_locs,old_doc = self.rd_baker.bake_to_post_single(path_url)
if old_doc is 0:
logger.error("===== Channel_post_single_resource ==== : Resource not found")
return "An error has occurred, please check logs for more details",return_code['Internal Server Error']
else:
old_data = old_doc['OCCI_Description']
entity = dict()
#Step[2]: update only the part that exist in both the new values and the old resource description
if jBody.has_key('resources'):
logger.debug("===== Channel_post_single_resource ==== : Resource was found and channeled")
entity, resp_code_r = self.manager_r.partial_resource_update(old_doc['OCCI_Description'],jBody['resources'][0])
else:
logger.debug("===== Channel_post_single_resource ==== : No Resource was found")
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug("===== Channel_post_single_resource ==== : Link was found and channeled")
entity, resp_code_l = self.manager_l.partial_link_update(old_doc['OCCI_Description'],jBody['links'][0])
else:
logger.debug("===== Channel_post_single_resource ==== : No Link was found")
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code['OK, and location returned'] or resp_code_l is not return_code['OK, and location returned']:
return "An error has occurred, please check log for more details",return_code['Bad Request']
old_doc['OCCI_Description'] = entity
self.PostMan.save_partial_updated_doc_in_db(old_doc)
logger.debug("===== Channel_post_single_resource ==== : Finished with success")
backend_m.update_entity(old_data,entity)
#Step[3]: Return the locations of the resource
return old_doc['OCCI_Location'],return_code['OK, and location returned']
def channel_delete_single_resource(self, path_url):
"""
Delete a resource instance
Args:
@param path_url: URL of the resource
"""
#Step[1]: Get the necessary data from the database
res,res_value = self.rd_baker.bake_to_delete_single_resource(path_url)
if res is None:
return "An error has occured, please check logs for more details", return_code['Internal Server Error']
elif res is 0:
logger.warning("===== Channel_delete_single_resource ==== : Resource not found")
else:
#Step[2]: Instruct the post man to delete the OCCI resource from the database
self.PostMan.delete_single_resource_in_db(res_value)
#Note: Save the entity description to send it to the backend
entity = res_value['OCCI_Description']
backend_m.delete_entity(entity,entity['kind'])
logger.debug("===== Channel_delete_single_resource ==== : Finished with success")
return "",return_code['OK']
def channel_triggered_action_single(self, jBody, path_url, triggered_action):
"""
Trigger the action on the resource
Args:
@param jBody: Data provided
@param path_url: URL of the request
@param triggered_action: Action name to trigger
"""
#Step[1]: Get the necessary data from DB
nb_res, value_res = self.rd_baker.bake_to_trigger_action_on_single_resource(path_url)
if nb_res is None:
return "An error has occurred, please check log for more details",return_code['Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details",return_code['Not Found']
else:
#Step[2]: Identify the provider
provider = self.rd_baker.bake_to_get_provider(value_res[0])
#Step[3]: Get the attributes if there are ones
if jBody.has_key('attributes') is True:
parameters = jBody['attributes']
else:
parameters = None
if provider is None:
return "An error has occurred, please check log for more details",return_code['Internal Server Error']
else:
#Step[4]: Trigger the action on the resources
resp, resp_code = backend_m.trigger_action_on_a_resource(value_res[1],triggered_action,provider['local'][0],parameters)
logger.debug("===== Channel_triggered_action_single ==== : Finished with success")
return resp,return_code['OK']
class SingleEntityJungler(object):
"""
Handles requests concerning single entities
"""
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_put_single_resource(self, jBody, path_url):
"""
Creates a new resource or performs a full update of the resource description
Args:
@param jBody: Data contained in the request body
@param path_url: URL of the request
"""
#Step[1]: Get the data necessary from the database
db_occi_ids_locs, db_resources_nb = self.rd_baker.bake_to_put_single(
path_url)
if db_occi_ids_locs is None or db_resources_nb is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
if db_resources_nb is 0:
#Step[2a]: This is a create a new resource request with a custom URL
if jBody.has_key('resources'):
logger.debug(
"===== Channel_put_single_resources ==== : Resource custom creation channeled"
)
entity, resp_code_r = self.manager_r.register_custom_resource(
jBody['resources'][0], path_url, db_occi_ids_locs)
else:
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug(
"===== Channel_put_single_resources ==== : Link custom creation channeled"
)
entity, resp_code_l = self.manager_l.register_custom_link(
jBody['links'][0], path_url, db_occi_ids_locs)
else:
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code[
'OK, and location returned'] or resp_code_l is not return_code[
'OK, and location returned']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
self.PostMan.save_custom_resource(entity)
logger.debug(
"===== Channel_put_single_resource ==== : Finished (2a) with success"
)
backend_m.create_entity(entity)
#Step[3a]: Return the locations of the resources
return entity['OCCI_Location'], return_code[
'OK, and location returned']
else:
#Step[2b]: This is a full update resource request (More data is needed)
olddoc = self.rd_baker.bake_to_put_single_updateCase(path_url)
if olddoc is None:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
else:
if jBody.has_key('resources'):
logger.debug(
"===== Channel_put_single_resources ==== : Resource full update channeled"
)
entity, resp_code_r = self.manager_r.update_resource(
olddoc, jBody['resources'][0])
else:
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug(
"===== Channel_put_single_resources ==== : Link full update channeled"
)
entity, resp_code_l = self.manager_l.update_link(
olddoc, jBody['links'][0])
else:
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code[
'OK, and location returned'] or resp_code_l is not return_code[
'OK, and location returned']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
self.PostMan.save_updated_doc_in_db(entity)
logger.debug(
"===== Channel_put_single_resource ==== : Finished (2b) with success"
)
#return the locations of the resources
backend_m.update_entity(olddoc['OCCI_Description'],
entity['OCCI_Description'])
return olddoc['OCCI_Location'], return_code[
'OK, and location returned']
def channel_get_single_resource(self, path_url):
"""
Retrieve the description of a resource related to the URL provided
Args:
@param path_url: URL of the request
"""
#Step[1]: Get data from the database
res, entity = self.rd_baker.bake_to_get_single_res(path_url)
if res is None:
return "An error has occured, please check logs for more details", return_code[
'Internal Server Error']
elif res is 0:
logger.warning(
"===== Channel_get_single_resource ==== : Resource not found")
else:
logger.debug(
"===== Channel_get_single_resource ==== : Finished with success"
)
#Step[2]: return OCCI resource description to the dispatcher
return res, return_code['OK']
def channel_post_single_resource(self, jBody, path_url):
"""
Performs a partial description update of the resource
Args:
@param jBody: New OCCI values
@param path_url: URL of the request
"""
#Step[1]: Get the necessary data from the database
db_occi_ids_locs, old_doc = self.rd_baker.bake_to_post_single(path_url)
if old_doc is 0:
logger.error(
"===== Channel_post_single_resource ==== : Resource not found")
return "An error has occurred, please check logs for more details", return_code[
'Internal Server Error']
else:
old_data = old_doc['OCCI_Description']
entity = dict()
#Step[2]: update only the part that exist in both the new values and the old resource description
if jBody.has_key('resources'):
logger.debug(
"===== Channel_post_single_resource ==== : Resource was found and channeled"
)
entity, resp_code_r = self.manager_r.partial_resource_update(
old_doc['OCCI_Description'], jBody['resources'][0])
else:
logger.debug(
"===== Channel_post_single_resource ==== : No Resource was found"
)
resp_code_r = return_code['OK, and location returned']
if jBody.has_key('links'):
logger.debug(
"===== Channel_post_single_resource ==== : Link was found and channeled"
)
entity, resp_code_l = self.manager_l.partial_link_update(
old_doc['OCCI_Description'], jBody['links'][0])
else:
logger.debug(
"===== Channel_post_single_resource ==== : No Link was found"
)
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code[
'OK, and location returned'] or resp_code_l is not return_code[
'OK, and location returned']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
old_doc['OCCI_Description'] = entity
self.PostMan.save_partial_updated_doc_in_db(old_doc)
logger.debug(
"===== Channel_post_single_resource ==== : Finished with success"
)
backend_m.update_entity(old_data, entity)
#Step[3]: Return the locations of the resource
return old_doc['OCCI_Location'], return_code[
'OK, and location returned']
def channel_delete_single_resource(self, path_url):
"""
Delete a resource instance
Args:
@param path_url: URL of the resource
"""
#Step[1]: Get the necessary data from the database
res, res_value = self.rd_baker.bake_to_delete_single_resource(path_url)
if res is None:
return "An error has occured, please check logs for more details", return_code[
'Internal Server Error']
elif res is 0:
logger.warning(
"===== Channel_delete_single_resource ==== : Resource not found"
)
else:
#Step[2]: Instruct the post man to delete the OCCI resource from the database
self.PostMan.delete_single_resource_in_db(res_value)
#Note: Save the entity description to send it to the backend
entity = res_value['OCCI_Description']
backend_m.delete_entity(entity, entity['kind'])
logger.debug(
"===== Channel_delete_single_resource ==== : Finished with success"
)
return "", return_code['OK']
def channel_triggered_action_single(self, jBody, path_url,
triggered_action):
"""
Trigger the action on the resource
Args:
@param jBody: Data provided
@param path_url: URL of the request
@param triggered_action: Action name to trigger
"""
#Step[1]: Get the necessary data from DB
nb_res, value_res = self.rd_baker.bake_to_trigger_action_on_single_resource(
path_url)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
else:
#Step[2]: Identify the provider
provider = self.rd_baker.bake_to_get_provider(value_res[0])
#Step[3]: Get the attributes if there are ones
if jBody.has_key('attributes') is True:
parameters = jBody['attributes']
else:
parameters = None
if provider is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[4]: Trigger the action on the resources
resp, resp_code = backend_m.trigger_action_on_a_resource(
value_res[1], triggered_action, provider['local'][0],
parameters)
logger.debug(
"===== Channel_triggered_action_single ==== : Finished with success"
)
return resp, return_code['OK']
class MultiEntityJungler(object):
"""
Handles requests concerning multiple entities
"""
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.jungler_p = PathManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_post_multi_resources(self, jreq, req_path):
"""
Identifies the post path's goal : create a resource instance or update a mixin collection
Args:
@param jreq: Body content of the post request
@param req_path: Address to which this post request was sent
"""
# Step[1]: detect the goal of the request
if jreq.has_key("resources") or jreq.has_key("links"):
is_kind_loc = True
else:
is_kind_loc = False
if is_kind_loc is True:
# Step[2a]: This is a create new resources request
db_occi_ids_locs = self.rd_baker.bake_to_post_multi_resources_2a()
# Step[3a]: Look for the default attributes to complete the attribute description of the resource:
default_attributes = self.rd_baker.bake_to_get_default_attributes(req_path)
if db_occi_ids_locs is None or default_attributes is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
else:
# Step[4a]: Ask the managers to create the new resources
if jreq.has_key("resources"):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new resource channeled"
)
new_resources, resp_code_r = self.manager_r.register_resources(
jreq["resources"], req_path, db_occi_ids_locs, default_attributes
)
else:
new_resources = list()
resp_code_r = return_code["OK, and location returned"]
if jreq.has_key("links"):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new link channeled"
)
new_links, resp_code_l = self.manager_l.register_links_explicit(
jreq["links"], req_path, db_occi_ids_locs, default_attributes
)
else:
new_links = list()
resp_code_l = return_code["OK, and location returned"]
if (
resp_code_r is not return_code["OK, and location returned"]
or resp_code_l is not return_code["OK, and location returned"]
):
return "An error has occurred, please check log for more details", return_code["Bad Request"]
# Step[5a]: Save the new resources
entities = new_resources + new_links
self.PostMan.save_registered_docs_in_db(entities)
logger.debug("===== Channel_post_multi_resources ==== : Finished (2a) with success")
locations = list()
for item in entities:
locations.append(item["OCCI_Location"])
backend_m.create_entities(entities)
return locations, return_code["OK, and location returned"]
# Step[2b]: This is an associate mixins to resources request
elif jreq.has_key("X-OCCI-Location"):
# Step[3b]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_path)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
else:
to_search_for = jreq["X-OCCI-Location"]
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
elif db_docs is None:
return (
"An error has occurred, please check log for more details",
return_code["Internal Server Error"],
)
else:
# Step[4b]: Ask the managers to associate mixins to resources
logger.debug(
"===== Channel_post_multi_resources ==== : Post on mixin path to associate a mixin channeled"
)
updated_entities, resp_code_e = associate_entities_to_a_mixin(mix_id, db_docs)
self.PostMan.save_updated_docs_in_db(updated_entities)
logger.debug("===== Channel_post_multi_resources ==== : Finished (2b) with success")
backend_m.update_entities(db_docs, updated_entities)
return "", return_code["OK"]
else:
return "An error has occurred, please check log for more details", return_code["Bad Request"]
def channel_get_all_entities(self, req_path, jreq):
"""
Retrieve all entities belonging to a kind or a mixin or get on a path
Args:
@param req_path: Address to which this post request was sent
@param jreq: Data provided for filtering
"""
# Step[1]: Retrieve the kind/mixin from DB
res = self.rd_baker.bake_to_channel_get_all_entities(req_path)
if res is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
elif res is 0:
logger.warning("===== Channel_get_all_multi_entities ===== : This is a get on a path " + req_path)
# Step[1b]: Get on path to retrieve the entities under that path
var, resp_code = self.jungler_p.channel_get_on_path(req_path, jreq)
return var, resp_code
else:
q = res.first()
# Step[2]: Retrieve the entities related to the kind/mixin
entities = self.rd_baker.bake_to_get_all_entities(q["value"][1], q["value"][0])
if entities is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
else:
logger.debug("===== Channel_get_all_entities ==== : Finished with success")
return entities, return_code["OK"]
def channel_get_filtered_entities(self, req_path, terms):
"""
Retrieve entities belonging to a kind or a mixin matching the terms specified or get entities on a path with filtering
Args:
@param req_path: Address to which this post request was sent
@param terms: Terms to filter entities
"""
# Step[1]: Get all the entities related to kind/mixin or get on a path with filtering
entities, ok = self.channel_get_all_entities(req_path, terms)
if ok == return_code["OK"]:
# Note: We now need the resources OCCI descriptions so we go back to the database
descriptions_res, descriptions_link = self.rd_baker.bake_to_get_filtered_entities(entities)
if descriptions_res is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
else:
# Step[2]: Ask the managers to do the filtering
if terms.has_key("resources"):
logger.debug("===== Channel_get_filtered: Resources are sent to filter =====")
filtered_res, resp_code_r = self.manager_r.get_filtered_resources(
terms["resources"], descriptions_res
)
else:
logger.debug("===== Channel_get_filtered: No Resource filter =====")
filtered_res = list()
resp_code_r = return_code["OK"]
if terms.has_key("links"):
logger.debug("===== Channel_get_filtered: Links are sent to filter =====")
filtered_links, resp_code_l = self.manager_l.get_filtered_links(terms["links"], descriptions_link)
else:
logger.debug("===== Channel_get_filtered: No Links filter =====")
filtered_links = list()
resp_code_l = return_code["OK"]
if resp_code_l is not return_code["OK"] or resp_code_r is not return_code["OK"]:
return "An error has occurred, please check log for more details", return_code["Bad Request"]
result = filtered_res + filtered_links
logger.debug("===== Channel_get_filtered_entities ==== : Finished with success")
return result, return_code["OK"]
def channel_put_multi(self, jreq, req_url):
"""
Update the mixin collection of resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
# Step[1]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_url)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
else:
to_search_for = jreq["X-OCCI-Location"]
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
else:
# Step[2]: Ask the managers to associate mixins to resources
logger.debug(
"===== Channel_put_multi_resources ==== : Put on mixin path to associate a mixin channeled"
)
updated_entities, resp_code_e = associate_entities_to_a_mixin(mix_id, db_docs)
self.PostMan.save_updated_docs_in_db(updated_entities)
logger.debug("===== Channel_put_multi_resources ==== : Finished (2b) with success")
backend_m.update_entities(db_docs, updated_entities)
return "", return_code["OK"]
def channel_delete_multi(self, jreq, req_url):
"""
Remove the mixin from the resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
# Step[1]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_url)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
else:
to_search_for = jreq["X-OCCI-Location"]
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code["Not Found"]
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
else:
logger.debug(" ===== Delete_multi_entities : Delete on mixin to Dissociate mixins channeled =====")
updated_entities, resp_code_e = dissociate_entities_from_a_mixin(mix_id, db_docs)
if resp_code_e is not return_code["OK"]:
return "An error has occurred, please check log for more details", return_code["Bad Request"]
self.PostMan.save_updated_docs_in_db(updated_entities)
backend_m.update_entities(db_docs, updated_entities)
return "", return_code["OK"]
def channel_trigger_actions(self, jBody, req_url, triggered_action):
"""
Trigger action on a collection of resources related to a kind or mixin
Args:
@param jBody: Action provided
@param req_url: URL of the request
@param triggered_action: Action name
"""
# Step[1]: Get the necessary data:
kind_ids, entities = self.rd_baker.bake_to_channel_trigger_actions(req_url)
if kind_ids is None:
return "An error has occurred, please check log for more details", return_code["Internal Server Error"]
if kind_ids is 0:
return "An error has occured, please check log for more details", return_code["Not Found"]
else:
providers = list()
# Step[2]: Get the providers of the instances
for item in kind_ids:
provider = self.rd_baker.bake_to_get_provider(item)
providers.append(provider)
if jBody.has_key("attributes") is True:
parameters = jBody["attributes"]
else:
parameters = None
# Step[3]: Ask the backend to trigger the action on the resources
backend_m.trigger_action_on_multi_resource(entities, providers, jBody["actions"][0], parameters)
return "", return_code["OK"]
class MultiEntityJungler(object):
"""
Handles requests concerning multiple entities
"""
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.jungler_p = PathManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_post_multi_resources(self, jreq, req_path):
"""
Identifies the post path's goal : create a resource instance or update a mixin collection
Args:
@param jreq: Body content of the post request
@param req_path: Address to which this post request was sent
"""
#Step[1]: detect the goal of the request
if jreq.has_key('resources') or jreq.has_key('links'):
is_kind_loc = True
else:
is_kind_loc = False
if is_kind_loc is True:
#Step[2a]: This is a create new resources request
db_occi_ids_locs = self.rd_baker.bake_to_post_multi_resources_2a()
#Step[3a]: Look for the default attributes to complete the attribute description of the resource:
default_attributes = self.rd_baker.bake_to_get_default_attributes(
req_path)
if db_occi_ids_locs is None or default_attributes is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[4a]: Ask the managers to create the new resources
if jreq.has_key('resources'):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new resource channeled"
)
new_resources, resp_code_r = self.manager_r.register_resources(
jreq['resources'], req_path, db_occi_ids_locs,
default_attributes)
else:
new_resources = list()
resp_code_r = return_code['OK, and location returned']
if jreq.has_key('links'):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new link channeled"
)
new_links, resp_code_l = self.manager_l.register_links_explicit(
jreq['links'], req_path, db_occi_ids_locs,
default_attributes)
else:
new_links = list()
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code['OK, and location returned']\
or resp_code_l is not return_code['OK, and location returned']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
#Step[5a]: Save the new resources
entities = new_resources + new_links
self.PostMan.save_registered_docs_in_db(entities)
logger.debug(
"===== Channel_post_multi_resources ==== : Finished (2a) with success"
)
locations = list()
for item in entities:
locations.append(item['OCCI_Location'])
backend_m.create_entities(entities)
return locations, return_code['OK, and location returned']
#Step[2b]: This is an associate mixins to resources request
elif jreq.has_key('X-OCCI-Location'):
#Step[3b]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(
req_path)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
else:
to_search_for = jreq['X-OCCI-Location']
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(
to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[4b]: Ask the managers to associate mixins to resources
logger.debug(
"===== Channel_post_multi_resources ==== : Post on mixin path to associate a mixin channeled"
)
updated_entities, resp_code_e = associate_entities_to_a_mixin(
mix_id, db_docs)
self.PostMan.save_updated_docs_in_db(updated_entities)
logger.debug(
"===== Channel_post_multi_resources ==== : Finished (2b) with success"
)
backend_m.update_entities(db_docs, updated_entities)
return "", return_code['OK']
else:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
def channel_get_all_entities(self, req_path, jreq):
"""
Retrieve all entities belonging to a kind or a mixin or get on a path
Args:
@param req_path: Address to which this post request was sent
@param jreq: Data provided for filtering
"""
#Step[1]: Retrieve the kind/mixin from DB
res = self.rd_baker.bake_to_channel_get_all_entities(req_path)
if res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
elif res is 0:
logger.warning(
"===== Channel_get_all_multi_entities ===== : This is a get on a path "
+ req_path)
#Step[1b]: Get on path to retrieve the entities under that path
var, resp_code = self.jungler_p.channel_get_on_path(req_path, jreq)
return var, resp_code
else:
q = res.first()
#Step[2]: Retrieve the entities related to the kind/mixin
entities = self.rd_baker.bake_to_get_all_entities(
q['value'][1], q['value'][0])
if entities is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
logger.debug(
"===== Channel_get_all_entities ==== : Finished with success"
)
return entities, return_code['OK']
def channel_get_filtered_entities(self, req_path, terms):
"""
Retrieve entities belonging to a kind or a mixin matching the terms specified or get entities on a path with filtering
Args:
@param req_path: Address to which this post request was sent
@param terms: Terms to filter entities
"""
#Step[1]: Get all the entities related to kind/mixin or get on a path with filtering
entities, ok = self.channel_get_all_entities(req_path, terms)
if ok == return_code['OK']:
#Note: We now need the resources OCCI descriptions so we go back to the database
descriptions_res, descriptions_link = self.rd_baker.bake_to_get_filtered_entities(
entities)
if descriptions_res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[2]: Ask the managers to do the filtering
if terms.has_key('resources'):
logger.debug(
"===== Channel_get_filtered: Resources are sent to filter ====="
)
filtered_res, resp_code_r = self.manager_r.get_filtered_resources(
terms['resources'], descriptions_res)
else:
logger.debug(
"===== Channel_get_filtered: No Resource filter =====")
filtered_res = list()
resp_code_r = return_code['OK']
if terms.has_key('links'):
logger.debug(
"===== Channel_get_filtered: Links are sent to filter ====="
)
filtered_links, resp_code_l = self.manager_l.get_filtered_links(
terms['links'], descriptions_link)
else:
logger.debug(
"===== Channel_get_filtered: No Links filter =====")
filtered_links = list()
resp_code_l = return_code['OK']
if resp_code_l is not return_code[
'OK'] or resp_code_r is not return_code['OK']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
result = filtered_res + filtered_links
logger.debug(
"===== Channel_get_filtered_entities ==== : Finished with success"
)
return result, return_code['OK']
def channel_put_multi(self, jreq, req_url):
"""
Update the mixin collection of resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
#Step[1]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_url)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
else:
to_search_for = jreq['X-OCCI-Location']
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(
to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[2]: Ask the managers to associate mixins to resources
logger.debug(
"===== Channel_put_multi_resources ==== : Put on mixin path to associate a mixin channeled"
)
updated_entities, resp_code_e = associate_entities_to_a_mixin(
mix_id, db_docs)
self.PostMan.save_updated_docs_in_db(updated_entities)
logger.debug(
"===== Channel_put_multi_resources ==== : Finished (2b) with success"
)
backend_m.update_entities(db_docs, updated_entities)
return "", return_code['OK']
def channel_delete_multi(self, jreq, req_url):
"""
Remove the mixin from the resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
#Step[1]: Get the necessary data from DB
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_url)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
else:
to_search_for = jreq['X-OCCI-Location']
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(
to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code[
'Not Found']
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
logger.debug(
" ===== Delete_multi_entities : Delete on mixin to Dissociate mixins channeled ====="
)
updated_entities, resp_code_e = dissociate_entities_from_a_mixin(
mix_id, db_docs)
if resp_code_e is not return_code['OK']:
return "An error has occurred, please check log for more details", return_code[
'Bad Request']
self.PostMan.save_updated_docs_in_db(updated_entities)
backend_m.update_entities(db_docs, updated_entities)
return "", return_code['OK']
def channel_trigger_actions(self, jBody, req_url, triggered_action):
"""
Trigger action on a collection of resources related to a kind or mixin
Args:
@param jBody: Action provided
@param req_url: URL of the request
@param triggered_action: Action name
"""
#Step[1]: Get the necessary data:
kind_ids, entities = self.rd_baker.bake_to_channel_trigger_actions(
req_url)
if kind_ids is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
if kind_ids is 0:
return "An error has occured, please check log for more details", return_code[
'Not Found']
else:
providers = list()
#Step[2]: Get the providers of the instances
for item in kind_ids:
provider = self.rd_baker.bake_to_get_provider(item)
providers.append(provider)
if jBody.has_key('attributes') is True:
parameters = jBody['attributes']
else:
parameters = None
#Step[3]: Ask the backend to trigger the action on the resources
backend_m.trigger_action_on_multi_resource(entities, providers,
jBody['actions'][0],
parameters)
return "", return_code['OK']
class PathManager(object):
"""
dispachers operations on Path
"""
def __init__(self):
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_get_on_path(self, req_path, terms):
"""
Channel the get request to the right method
Args:
@param req_path: Address to which this post request was sent
@param terms: Data provided for filtering
"""
locations = list()
query = self.rd_baker.bake_to_get_on_path()
if terms is "":
if query is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
for q in query:
str_loc = str(q['key'])
if str_loc.endswith("/"):
str_loc = joker.format_url_path(str_loc)
if str_loc.find(req_path) is not -1:
locations.append(str_loc)
logger.debug("===== Channel_get_on_Path: Finished with success ===== ")
return locations, return_code['OK']
else:
for q in query:
str_loc = str(q['key'])
if str_loc.endswith("/") is False and str_loc.find(req_path) is not -1:
locations.append(str_loc)
descriptions = self.rd_baker.bake_to_get_on_path_filtered(locations)
if descriptions is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
if terms.has_key('resources'):
result_res, resp_code_r = get_filtered(terms['resources'], descriptions)
else:
result_res = list()
resp_code_r = return_code['OK']
if terms.has_key('links'):
result_link, resp_code_l = get_filtered(terms['links'], descriptions)
else:
result_link = list()
resp_code_l = return_code['OK']
if resp_code_l is not return_code['OK'] or resp_code_r is not return_code['OK']:
return "An error has occurred, please check logs for more details", return_code[
'Internal Server Error']
result = result_res + result_link
logger.debug("===== Channel_get_on_Path: Finished with success ===== ")
return result, return_code['OK']
def channel_delete_on_path(self, req_path, user_id):
"""
Channel the get request to the right method
Args:
@param user_id: ID of the issuer of the post request
@param req_path: Address to which this post request was sent
"""
database = config.prepare_PyOCNI_db()
locations = list()
try:
query = database.view('/db_views/for_delete_entities', key=user_id)
except Exception as e:
logger.error("Delete on Path: " + e.message)
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
for q in query:
str_loc = str(q['value'][0])
if str_loc.find(req_path) is not -1:
locations.append({'_id': q['value'][1], '_rev': q['value'][2]})
logger.debug("Delete on Path: done with success")
database.delete_docs(locations)
return "", return_code['OK']
class MultiEntityJungler(object):
"""
"""
def __init__(self):
self.manager_r = ResourceManager()
self.manager_l = LinkManager()
self.jungler_p = PathManager()
self.rd_baker = ResourceDataBaker()
self.PostMan = PostMan()
def channel_post_multi_resources(self, jreq, req_path):
"""
Identifies the post path's goal : create a resource instance or update a mixin collection
Args:
@param jreq: Body content of the post request
@param req_path: Address to which this post request was sent
"""
#Step[1]: detect the request's goal
if jreq.has_key('resources') or jreq.has_key('links'):
is_kind_loc = True
else:
is_kind_loc = False
if is_kind_loc is True:
#Step[2a]: This is a create new resources request
db_occi_ids_locs = self.rd_baker.bake_to_post_multi_resources_2a()
default_attributes = self.rd_baker.bake_to_get_default_attributes(req_path)
if db_occi_ids_locs is None or default_attributes is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
#Look for the default attributes to complete the attribute description of the resource:
if jreq.has_key('resources'):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new resource channeled")
new_resources, resp_code_r = self.manager_r.register_resources(jreq['resources'], req_path,
db_occi_ids_locs, default_attributes)
else:
new_resources = list()
resp_code_r = return_code['OK, and location returned']
if jreq.has_key('links'):
logger.debug(
"===== Channel_post_multi_resources ==== : Post on kind path to create a new link channeled")
new_links, resp_code_l = self.manager_l.register_links_explicit(jreq['links'], req_path,
db_occi_ids_locs)
else:
new_links = list()
resp_code_l = return_code['OK, and location returned']
if resp_code_r is not return_code['OK, and location returned']\
or resp_code_l is not return_code['OK, and location returned']:
return "An error has occurred, please check log for more details", return_code['Bad Request']
#Step[3a]: Save the new resources
entities = new_resources + new_links
self.PostMan.save_registered_docs_in_db(entities)
logger.debug("===== Channel_post_multi_resources ==== : Finished (2a) with success")
locations = list()
for item in entities:
locations.append(item['OCCI_Location'])
#return the locations of the resources
backend_m.create_entities(entities, locations)
return locations, return_code['OK, and location returned']
#Step[2b]: This is an associate mixins to resources request
elif jreq.has_key('X-OCCI-Location'):
nb_res, mix_id = self.rd_baker.bake_to_post_multi_resources_2b(req_path)
if nb_res is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
elif nb_res is 0:
return "An error has occurred, please check log for more details", return_code['Not Found']
else:
to_search_for = jreq['X-OCCI-Location']
db_docs = self.rd_baker.bake_to_post_multi_resources_2b2(to_search_for)
if db_docs is 0:
return "An error has occurred, please check log for more details", return_code['Not Found']
elif db_docs is None:
return "An error has occurred, please check log for more details", return_code[
'Internal Server Error']
else:
#Step[3b]: Treat the data to associate mixins to resources
logger.debug(
"===== Channel_post_multi_resources ==== : Post on mixin path to associate a mixin channeled")
updated_entities, resp_code_e = associate_entities_to_a_mixin(mix_id, db_docs)
self.PostMan.save_updated_docs_in_db(updated_entities)
logger.debug("===== Channel_post_multi_resources ==== : Finished (2b) with success")
backend_m.update_entities(db_docs, updated_entities)
return "", return_code['OK']
else:
return "An error has occurred, please check log for more details", return_code['Bad Request']
def channel_get_all_entities(self, req_path, jreq):
"""
retrieve all entities belonging to a kind or a mixin
Args:
@param req_path: Address to which this post request was sent
@param jreq: Data provided for filtering
"""
res = self.rd_baker.bake_to_channel_get_all_entities(req_path)
if res is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
elif res is 0:
# Retrieve the state of the name space hierarchy
logger.warning("===== Channel_get_all_multi_entities ===== : This is a get on a path " + req_path)
var, resp_code = self.jungler_p.channel_get_on_path(req_path, jreq)
return var, resp_code
else:
q = res.first()
entities = self.rd_baker.bake_to_get_all_entities(q['value'][1], q['value'][0])
if entities is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
#backend_m.read_entities(occi_descriptions)
logger.debug("===== Channel_get_all_entities ==== : Finished with success")
return entities, return_code['OK']
def channel_get_filtered_entities(self, req_path, terms):
"""
Retrieve entities belonging to a kind or a mixin matching the terms specified
Args:
@param req_path: Address to which this post request was sent
@param terms: Terms to filter entities
"""
entities, ok = self.channel_get_all_entities(req_path, terms)
if ok == return_code['OK']:
descriptions_res, descriptions_link = self.rd_baker.bake_to_get_filtered_entities(entities)
if descriptions_res is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
else:
if terms.has_key('resources'):
logger.debug("===== Channel_get_filtered: Resources are sent to filter =====")
filtered_res, resp_code_r = self.manager_r.get_filtered_resources(terms['resources'],
descriptions_res)
else:
logger.debug("===== Channel_get_filtered: No Resource filter =====")
filtered_res = list()
resp_code_r = return_code['OK']
if terms.has_key('links'):
logger.debug("===== Channel_get_filtered: Links are sent to filter =====")
filtered_links, resp_code_l = self.manager_l.get_filtered_links(terms['links'], descriptions_link)
else:
logger.debug("===== Channel_get_filtered: No Links filter =====")
filtered_links = list()
resp_code_l = return_code['OK']
if resp_code_l is not return_code['OK'] or resp_code_r is not return_code['OK']:
return "An error has occurred, please check log for more details", return_code['Bad Request']
result = filtered_res + filtered_links
logger.debug("===== Channel_get_filtered_entities ==== : Finished with success")
#occi_descriptions = self.rd_baker.bake_to_get_filtered_entities_2(result)
#backend_m.read_entities(occi_descriptions)
return result, return_code['OK']
def channel_put_multi(self, jreq, req_url):
"""
Update the mixin collection of resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
return "This method is under reconstruction", return_code['Not Implemented']
# database = config.prepare_PyOCNI_db()
#
# if jreq.has_key('Resource_Locations') and jreq.has_key('Mixin_Locations'):
# url_path = joker.reformat_url_path(req_url)
# db_docs = list()
# to_validate = jreq['Mixin_Locations']
# to_validate.append(url_path)
# mix_ids = list()
# for occi_loc in to_validate:
# try:
# query = database.view('/db_views/my_mixins',key = occi_loc)
# except Exception as e:
# logger.error("Associate mixins : " + e.message)
# return "An error has occurred, please check log for more details",return_code['Internal Server Error']
# if query.count() is 0:
# logger.error("Associate mixins : " + occi_loc)
# return "An error has occurred, please check log for more details",return_code['Internal Server Error']
# else:
# mix_ids.append(query.first()['value'])
#
# to_search_for = jreq['Resource_Locations']
# for item in to_search_for:
# try:
# query = database.view('/db_views/for_associate_mixin',key=[item,user_id])
# except Exception as e:
# logger.error("Associate mixins : " + e.message)
# return "An error has occurred, please check log for more details",return_code['Internal Server Error']
# if query.count() is 0:
# logger.error("Associate mixins : " + item)
# return "An error has occurred, please check log for more details",return_code['Not Found']
# else:
# q = query.first()
# db_docs.append(q['value'])
#
# logger.debug("Post path : Post on mixin path to associate mixins channeled")
# updated_entities,resp_code_e = associate_entities_to_mixins(mix_ids,db_docs)
# else:
# updated_entities = list()
# resp_code_e = return_code['Bad Request']
#
# if resp_code_e is not return_code['OK']:
# return "An error has occurred, please check log for more details",return_code['Bad Request']
#
# database.save_docs(updated_entities,force_update=True,all_or_nothing=True)
# backend_m.update_entities(db_docs,updated_entities)
# return "",return_code['OK']
def channel_delete_multi(self, jreq, req_url):
"""
Update the mixin collection of resources
Args:
@param jreq: OCCI_Locations of the resources
@param req_url: URL of the request
"""
return "This method is under reconstruction", return_code['Not Implemented']
# if jreq.has_key('X-OCCI-Location'):
#
# url_path = joker.reformat_url_path(req_url)
# db_docs = list()
#
# try:
# query = database.view('/db_views/my_mixins',key = url_path)
# except Exception as e:
# logger.error("Dissociate mixins : " + e.message)
# return "An error has occurred, please check log for more details",return_code['Internal Server Error']
#
#
# mix_id = query.first()['value']
#
# to_search_for = jreq['X-OCCI-Location']
# for item in to_search_for:
# try:
# query = database.view('/db_views/for_associate_mixin',key=item)
# except Exception as e:
# logger.error("Associate mixins : " + e.message)
# return "An error has occurred, please check log for more details",return_code['Internal Server Error']
# if query.count() is 0:
# logger.error("Associate mixins : " + item)
# return "An error has occurred, please check log for more details",return_code['Not Found']
# else:
# q = query.first()
# db_docs.append(q['value'])
#
# logger.debug("Delete path: delete on mixin path to Dissociate mixins channeled")
# updated_entities,resp_code_e = dissociate_entities_from_a_mixin(mix_id,db_docs)
# else:
# updated_entities = list()
# resp_code_e = return_code['Bad Request']
#
# if resp_code_e is not return_code['OK']:
# return "An error has occurred, please check log for more details",return_code['Bad Request']
#
# database.save_docs(updated_entities,force_update=True,all_or_nothing=True)
# backend_m.update_entities(db_docs,updated_entities)
# return "",return_code['OK']
def channel_trigger_actions(self, jBody, req_url, triggered_action):
"""
Trigger action on a collection of kind or mixin
Args:
@param jBody: Action provided
@param req_url: URL of the request
@param triggered_action: Action name
"""
kind_ids, entities = self.rd_baker.bake_to_channel_trigger_actions(req_url)
# Get OCCI_ID from OCCI_Location
if kind_ids is None:
return "An error has occurred, please check log for more details", return_code['Internal Server Error']
if kind_ids is 0:
return "An error has occured, please check log for more details", return_code['Not Found']
else:
providers = list()
for item in kind_ids:
provider = self.rd_baker.bake_to_get_provider(item)
providers.append(provider)
backend_m.trigger_action_on_multi_resource(entities, providers, jBody['action'][0])
return "", return_code['OK']
