def _resource_advance_lcs(self, cfg, res_id):
"""
Change lifecycle state of object to requested state. Supports bulk.
"""
res_obj = self._get_resource_obj(res_id)
restype = res_obj.type_
lcsm = get_restype_lcsm(restype)
initial_lcmat = lcsm.initial_state if lcsm else LCS.DEPLOYED
initial_lcav = lcsm.initial_availability if lcsm else AS.AVAILABLE
lcstate = cfg.get(KEY_LCSTATE, None)
if lcstate:
row_lcmat, row_lcav = lcstate.split("_", 1)
if self.bulk and res_id in self.bulk_resources:
self.bulk_resources[res_id].lcstate = row_lcmat
self.bulk_resources[res_id].availability = row_lcav
else:
if row_lcmat != initial_lcmat: # Vertical transition
self.rr.set_lifecycle_state(res_id, row_lcmat)
if row_lcav != initial_lcav: # Horizontal transition
self.rr.set_lifecycle_state(res_id, row_lcav)
elif self.bulk and res_id in self.bulk_resources:
# Set the lcs to resource type appropriate initial values
self.bulk_resources[res_id].lcstate = initial_lcmat
self.bulk_resources[res_id].availability = initial_lcav
def execute_lifecycle_transition(self,
resource_id='',
transition_event=''):
res_obj = self.read(resource_id)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" %
(resource_id, restype))
old_state = res_obj.lcstate
new_state = restype_workflow.get_successor(old_state, transition_event)
if not new_state:
raise BadRequest(
"Resource id=%s, type=%s, lcstate=%s has no transition for event %s"
% (resource_id, restype, res_obj.lcstate, transition_event))
res_obj.lcstate = new_state
res_obj.ts_updated = get_ion_ts()
self.rr_store.update(res_obj)
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id,
origin_type=res_obj._get_type(),
sub_type=new_state,
old_state=old_state,
new_state=new_state,
transition_event=transition_event)
return new_state
def _resource_advance_lcs(self, cfg, res_id):
"""
Change lifecycle state of object to requested state. Supports bulk.
"""
res_obj = self._get_resource_obj(res_id)
restype = res_obj.type_
lcsm = get_restype_lcsm(restype)
initial_lcmat = lcsm.initial_state if lcsm else LCS.DEPLOYED
initial_lcav = lcsm.initial_availability if lcsm else AS.AVAILABLE
lcstate = cfg.get(KEY_LCSTATE, None)
if lcstate:
row_lcmat, row_lcav = lcstate.split("_", 1)
if self.bulk and res_id in self.bulk_resources:
self.bulk_resources[res_id].lcstate = row_lcmat
self.bulk_resources[res_id].availability = row_lcav
else:
if row_lcmat != initial_lcmat: # Vertical transition
self.rr.set_lifecycle_state(res_id, row_lcmat)
if row_lcav != initial_lcav: # Horizontal transition
self.rr.set_lifecycle_state(res_id, row_lcav)
elif self.bulk and res_id in self.bulk_resources:
# Set the lcs to resource type appropriate initial values
self.bulk_resources[res_id].lcstate = initial_lcmat
self.bulk_resources[res_id].availability = initial_lcav
def create(self, object=None, actor_id=None):
if object is None:
raise BadRequest("Object not present")
if not isinstance(object, IonObjectBase):
raise BadRequest("Object is not an IonObject")
if not is_resource(object):
raise BadRequest("Object is not a Resource")
lcsm = get_restype_lcsm(object._get_type())
object.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
cur_time = get_ion_ts()
object.ts_created = cur_time
object.ts_updated = cur_time
new_res_id = create_unique_resource_id()
res = self.rr_store.create(object, new_res_id)
res_id, rev = res
if actor_id and actor_id != 'anonymous':
log.debug("Associate resource_id=%s with owner=%s" % (res_id, actor_id))
self.rr_store.create_association(res_id, PRED.hasOwner, actor_id)
self.event_pub.publish_event(event_type="ResourceModifiedEvent",
origin=res_id, origin_type=object._get_type(),
sub_type="CREATE",
mod_type=ResourceModificationType.CREATE)
return res
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
if not target_lcstate or target_lcstate not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
res_obj = self.read(resource_id)
old_state = res_obj.lcstate
if target_lcstate != LCS.RETIRED:
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
# Check that target state is allowed
if not target_lcstate in restype_workflow.get_successors(res_obj.lcstate).values():
raise BadRequest("Target state %s not reachable for resource in state %s" % (target_lcstate, res_obj.lcstate))
res_obj.lcstate = target_lcstate
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj._get_type(),
sub_type=target_lcstate,
old_state=old_state, new_state=target_lcstate)
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
if not target_lcstate or target_lcstate not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
res_obj = self.read(resource_id)
old_state = res_obj.lcstate
if target_lcstate != LCS.RETIRED:
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
# Check that target state is allowed
if not target_lcstate in restype_workflow.get_successors(res_obj.lcstate).values():
raise BadRequest("Target state %s not reachable for resource in state %s" % (target_lcstate, res_obj.lcstate))
res_obj.lcstate = target_lcstate
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj._get_type(),
sub_type=target_lcstate,
old_state=old_state, new_state=target_lcstate)
def create_mult(self, res_list, actor_id=None):
"""Creates a list of resources from objects. Objects may have _id in it to predetermine their ID.
Returns a list of 2-tuples (resource_id, rev)"""
cur_time = get_ion_ts()
id_list = []
for resobj in res_list:
lcsm = get_restype_lcsm(resobj.type_)
resobj.lcstate = lcsm.initial_state if lcsm else LCS.DEPLOYED
resobj.availability = lcsm.initial_availability if lcsm else AS.AVAILABLE
resobj.ts_created = cur_time
resobj.ts_updated = cur_time
id_list.append(resobj._id if "_id" in resobj else create_unique_resource_id())
res = self.rr_store.create_mult(res_list, id_list, allow_ids=True)
rid_list = [(rid, rrv) for success, rid, rrv in res]
# Associations with owners
if actor_id and actor_id != 'anonymous':
assoc_list = []
for resobj, (rid, rrv) in zip(res_list, rid_list):
resobj._id = rid
assoc_list.append((resobj, PRED.hasOwner, actor_id))
self.create_association_mult(assoc_list)
# Publish events
for resobj, (rid, rrv) in zip(res_list, rid_list):
self.event_pub.publish_event(event_type="ResourceModifiedEvent",
origin=rid, origin_type=resobj.type_,
mod_type=ResourceModificationType.CREATE)
return rid_list
def create_dummy_resources(res_list, assoc_list=None, container=None):
"""
Creates all resources of res_list. The names of the resources will be the keys in the returned dict
The elements of the list are tuples with resource object as first element and optional actor name as second element.
Can also create associations linking resources by name.
Assoc_list is a list of 3-tuples subject name, predicate, object name.
"""
container = container or bootstrap.container_instance
rr = container.resource_registry
res_by_name = {}
for res_entry in res_list:
if isinstance(res_entry, dict):
res_obj = res_entry["res"]
actor_id = res_by_name[
res_entry["act"]] if "act" in res_entry else None
elif type(res_entry) in (list, tuple):
res_obj = res_entry[0]
actor_id = res_by_name[
res_entry[1]] if len(res_entry) > 1 else None
else:
raise BadRequest("Unknown resource entry format")
res_name = res_obj.name
res_obj.alt_ids.append("TEST:%s" % res_name)
res_lcstate = res_obj.lcstate
rid, _ = rr.create(res_obj, actor_id=actor_id)
res_by_name[res_name] = rid
lcsm = get_restype_lcsm(res_obj.type_)
if lcsm and res_lcstate != lcsm.initial_state:
rr.set_lifecycle_state(rid, res_lcstate)
if isinstance(res_entry, dict):
if "org" in res_entry:
rr.create_association(res_by_name[res_entry["org"]],
PRED.hasResource, rid)
if assoc_list:
for assoc in assoc_list:
sname, p, oname = assoc
if type(sname) in (list, tuple) and type(oname) in (list, tuple):
for sname1 in sname:
for oname1 in oname:
s, o = res_by_name[sname1], res_by_name[oname1]
rr.create_association(s, p, o)
elif type(oname) in (list, tuple):
for oname1 in oname:
s, o = res_by_name[sname], res_by_name[oname1]
rr.create_association(s, p, o)
elif type(sname) in (list, tuple):
for sname1 in sname:
s, o = res_by_name[sname1], res_by_name[oname]
rr.create_association(s, p, o)
else:
s, o = res_by_name[sname], res_by_name[oname]
rr.create_association(s, p, o)
return res_by_name
def _create_mult(self, res_list):
cur_time = get_ion_ts()
for resobj in res_list:
lcsm = get_restype_lcsm(resobj._get_type())
resobj.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
resobj.ts_created = cur_time
resobj.ts_updated = cur_time
res = self.rr_store.create_mult(res_list)
return [(rid,rrv) for success,rid,rrv in res]
def create_dummy_resources(res_list, assoc_list=None, container=None):
"""
Creates all resources of res_list. The names of the resources will be the keys in the returned dict
The elements of the list are tuples with resource object as first element and optional actor name as second element.
Can also create associations linking resources by name.
Assoc_list is a list of 3-tuples subject name, predicate, object name.
"""
container = container or bootstrap.container_instance
rr = container.resource_registry
res_by_name = {}
for res_entry in res_list:
if isinstance(res_entry, dict):
res_obj = res_entry["res"]
actor_id = res_by_name[res_entry["act"]] if "act" in res_entry else None
elif type(res_entry) in (list, tuple):
res_obj = res_entry[0]
actor_id = res_by_name[res_entry[1]] if len(res_entry) > 1 else None
else:
raise BadRequest("Unknown resource entry format")
res_name = res_obj.name
res_obj.alt_ids.append("TEST:%s" % res_name)
res_lcstate = res_obj.lcstate
rid, _ = rr.create(res_obj, actor_id=actor_id)
res_by_name[res_name] = rid
lcsm = get_restype_lcsm(res_obj.type_)
if lcsm and res_lcstate != lcsm.initial_state:
rr.set_lifecycle_state(rid, res_lcstate)
if isinstance(res_entry, dict):
if "org" in res_entry:
rr.create_association(res_by_name[res_entry["org"]], PRED.hasResource, rid)
if assoc_list:
for assoc in assoc_list:
sname, p, oname = assoc
if type(sname) in (list, tuple) and type(oname) in (list, tuple):
for sname1 in sname:
for oname1 in oname:
s, o = res_by_name[sname1], res_by_name[oname1]
rr.create_association(s, p, o)
elif type(oname) in (list, tuple):
for oname1 in oname:
s, o = res_by_name[sname], res_by_name[oname1]
rr.create_association(s, p, o)
elif type(sname) in (list, tuple):
for sname1 in sname:
s, o = res_by_name[sname1], res_by_name[oname]
rr.create_association(s, p, o)
else:
s, o = res_by_name[sname], res_by_name[oname]
rr.create_association(s, p, o)
return res_by_name
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
"""Sets the lifecycle state (if possible) to the target state. Supports compound states"""
if not target_lcstate:
raise BadRequest("Bad life-cycle state %s" % target_lcstate)
if target_lcstate.startswith(LCS.DELETED):
self.lcs_delete(resource_id)
if target_lcstate.startswith(LCS.RETIRED):
self.execute_lifecycle_transition(resource_id, LCE.RETIRE)
res_obj = self.read(resource_id)
old_lcstate = res_obj.lcstate
old_availability = res_obj.availability
restype = res_obj.type_
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
if '_' in target_lcstate: # Support compound
target_lcs, target_av = lcsplit(target_lcstate)
if target_lcs not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcs)
if target_av and target_av not in AS:
raise BadRequest("Unknown life-cycle availability %s" % target_av)
elif target_lcstate in LCS:
target_lcs, target_av = target_lcstate, res_obj.availability
elif target_lcstate in AS:
target_lcs, target_av = res_obj.lcstate, target_lcstate
else:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
# Check that target state is allowed
lcs_successors = restype_workflow.get_lcstate_successors(old_lcstate)
av_successors = restype_workflow.get_availability_successors(old_availability)
found_lcs, found_av = target_lcs in lcs_successors.values(), target_av in av_successors.values()
if not found_lcs and not found_av:
raise BadRequest("Target state %s not reachable for resource in state %s_%s" % (
target_lcstate, old_lcstate, old_availability))
res_obj.lcstate = target_lcs
res_obj.availability = target_av
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
log.debug("set_lifecycle_state(res_id=%s, target=%s). Change %s_%s to %s_%s", resource_id, target_lcstate,
old_lcstate, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_lcstate, availability_before=old_availability)
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
"""Sets the lifecycle state (if possible) to the target state. Supports compound states"""
if not target_lcstate:
raise BadRequest("Bad life-cycle state %s" % target_lcstate)
if target_lcstate.startswith('RETIRED'):
return self.retire(resource_id)
res_obj = self.read(resource_id)
old_target = target_lcstate
old_state = res_obj.lcstate
old_availability = res_obj.availability
old_lcs = lcstate(old_state, old_availability)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
if '_' in target_lcstate: # Support compound
target_lcmat, target_lcav = lcsplit(target_lcstate)
if target_lcmat not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcmat)
if target_lcav and target_lcav not in AS:
raise BadRequest("Unknown life-cycle availability %s" % target_lcav)
elif target_lcstate in LCS:
target_lcmat, target_lcav = target_lcstate, res_obj.availability
target_lcstate = lcstate(target_lcmat, target_lcav)
elif target_lcstate in AS:
target_lcmat, target_lcav = res_obj.lcstate, target_lcstate
target_lcstate = lcstate(target_lcmat, target_lcav)
else:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
# Check that target state is allowed
if not target_lcstate in restype_workflow.get_successors(old_lcs).values():
raise BadRequest("Target state %s not reachable for resource in state %s" % (target_lcstate, old_lcs))
res_obj.lcstate = target_lcmat
res_obj.availability = target_lcav
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
log.debug("set_lifecycle_state(res_id=%s, target=%s). Change %s_%s to %s_%s", resource_id, old_target,
old_state, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_state, availability_before=old_availability)
def _resource_advance_lcs(self, row, res_id, restype=None):
lcsm = get_restype_lcsm(restype)
initial_lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
svc_client = self._get_service_client("resource_registry")
lcstate = row.get(self.COL_LCSTATE, None)
if lcstate:
imat, ivis = initial_lcstate.split("_")
mat, vis = lcstate.split("_")
if mat != imat:
svc_client.set_lifecycle_state(res_id, "%s_PRIVATE" % mat)
if vis != ivis:
svc_client.set_lifecycle_state(res_id, "%s_%s" % (mat, vis))
def _resource_advance_lcs(self, row, res_id, restype=None):
lcsm = get_restype_lcsm(restype)
initial_lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
svc_client = self._get_service_client("resource_registry")
lcstate = row.get(self.COL_LCSTATE, None)
if lcstate:
imat, ivis = initial_lcstate.split("_")
mat, vis = lcstate.split("_")
if mat != imat:
svc_client.set_lifecycle_state(res_id, "%s_PRIVATE" % mat)
if vis != ivis:
svc_client.set_lifecycle_state(res_id, "%s_%s" % (mat, vis))
def set_lifecycle_state(self, resource_id='', target_lcstate=''):
if not target_lcstate or target_lcstate not in LCS:
raise BadRequest("Unknown life-cycle state %s" % target_lcstate)
res_obj = self.read(resource_id)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
# Check that target state is allowed
if not target_lcstate in restype_workflow.get_successors(res_obj.lcstate).values():
raise BadRequest("Target state %s not reachable for resource in state %s" % (target_lcstate, res_obj.lcstate))
res_obj.lcstate = target_lcstate
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
def execute_lifecycle_transition(self, resource_id='', transition_event=''):
res_obj = self.read(resource_id)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
new_state = restype_workflow.get_successor(res_obj.lcstate, transition_event)
if not new_state:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s has no transition for event %s" % (
resource_id, restype, res_obj.lcstate, transition_event))
res_obj.lcstate = new_state
res_obj.ts_updated = get_ion_ts()
updres = self.rr_store.update(res_obj)
return new_state
def create(self, object=None, actor_id=None, object_id=None, attachments=None):
"""
Accepts object that is to be stored in the data store and tags them with additional data
(timestamp and such) If actor_id is provided, creates hasOwner association with objects.
If attachments are provided
(in dict(att1=dict(data=xyz), att2=dict(data=aaa, content_type='text/plain') form)
they get attached to the object.
Returns a tuple containing object and revision identifiers.
"""
if object is None:
raise BadRequest("Object not present")
if not isinstance(object, IonObjectBase):
raise BadRequest("Object is not an IonObject")
if not is_resource(object):
raise BadRequest("Object is not a Resource")
if "_id" in object:
raise BadRequest("Object must not contain _id")
if "_rev" in object:
raise BadRequest("Object must not contain _rev")
lcsm = get_restype_lcsm(object._get_type())
object.lcstate = lcsm.initial_state if lcsm else LCS.DEPLOYED
object.availability = lcsm.initial_availability if lcsm else AS.AVAILABLE
cur_time = get_ion_ts()
object.ts_created = cur_time
object.ts_updated = cur_time
if object_id is None:
new_res_id = create_unique_resource_id()
else:
new_res_id = object_id
res = self.rr_store.create(object, new_res_id, attachments=attachments)
res_id, rev = res
if actor_id and actor_id != 'anonymous':
log.debug("Associate resource_id=%s with owner=%s", res_id, actor_id)
self.create_association(res_id, PRED.hasOwner, actor_id)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceModifiedEvent",
origin=res_id, origin_type=object._get_type(),
sub_type="CREATE",
mod_type=ResourceModificationType.CREATE)
return res
def _create_mult(self, res_list):
cur_time = get_ion_ts()
for resobj in res_list:
lcsm = get_restype_lcsm(resobj._get_type())
resobj.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
resobj.ts_created = cur_time
resobj.ts_updated = cur_time
res = self.rr_store.create_mult(res_list)
res_list = [(rid,rrv) for success,rid,rrv in res]
# TODO: Publish events (skipped, because this is inefficent one by one for a large list
# for rid,rrv in res_list:
# self.event_pub.publish_event(event_type="ResourceModifiedEvent",
# origin=res_id, origin_type=object._get_type(),
# mod_type=ResourceModificationType.CREATE)
return res_list
def _create_mult(self, res_list):
cur_time = get_ion_ts()
for resobj in res_list:
lcsm = get_restype_lcsm(resobj._get_type())
resobj.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
resobj.ts_created = cur_time
resobj.ts_updated = cur_time
res = self.rr_store.create_mult(res_list)
res_list = [(rid,rrv) for success,rid,rrv in res]
# TODO: Publish events (skipped, because this is inefficent one by one for a large list
# for rid,rrv in res_list:
# self.event_pub.publish_event(event_type="ResourceModifiedEvent",
# origin=res_id, origin_type=object._get_type(),
# mod_type=ResourceModificationType.CREATE)
return res_list
def execute_lifecycle_transition(self, resource_id='', transition_event=''):
if transition_event == LCE.DELETE:
return self.lcs_delete(resource_id)
res_obj = self.read(resource_id)
old_lcstate = res_obj.lcstate
old_availability = res_obj.availability
if transition_event == LCE.RETIRE:
if res_obj.lcstate == LCS.RETIRED or res_obj.lcstate == LCS.DELETED:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s, availability=%s has no transition for event %s" % (
resource_id, res_obj.type_, old_lcstate, old_availability, transition_event))
res_obj.lcstate = LCS.RETIRED
else:
restype = res_obj.type_
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
new_lcstate = restype_workflow.get_lcstate_successor(old_lcstate, transition_event)
new_availability = restype_workflow.get_availability_successor(old_availability, transition_event)
if not new_lcstate and not new_availability:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s, availability=%s has no transition for event %s" % (
resource_id, restype, old_lcstate, old_availability, transition_event))
if new_lcstate:
res_obj.lcstate = new_lcstate
if new_availability:
res_obj.availability = new_availability
res_obj.ts_updated = get_ion_ts()
self.rr_store.update(res_obj)
log.debug("execute_lifecycle_transition(res_id=%s, event=%s). Change %s_%s to %s_%s", resource_id, transition_event,
old_lcstate, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_lcstate, availability_before=old_availability,
transition_event=transition_event)
return "%s_%s" % (res_obj.lcstate, res_obj.availability)
def create(self,
object=None,
actor_id=None,
object_id=None,
attachments=None):
"""
Accepts object that is to be stored in the data store and tags them with additional data
(timestamp and such) If actor_id is provided, creates hasOwner association with objects.
If attachments are provided
(in dict(att1=dict(data=xyz), att2=dict(data=aaa, content_type='text/plain') form)
they get attached to the object.
Returns a tuple containing object and revision identifiers.
"""
if object is None:
raise BadRequest("Object not present")
if not isinstance(object, IonObjectBase):
raise BadRequest("Object is not an IonObject")
if not is_resource(object):
raise BadRequest("Object is not a Resource")
lcsm = get_restype_lcsm(object._get_type())
object.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
cur_time = get_ion_ts()
object.ts_created = cur_time
object.ts_updated = cur_time
if object_id is None:
new_res_id = create_unique_resource_id()
else:
new_res_id = object_id
res = self.rr_store.create(object, new_res_id, attachments=attachments)
res_id, rev = res
if actor_id and actor_id != 'anonymous':
log.debug("Associate resource_id=%s with owner=%s" %
(res_id, actor_id))
self.rr_store.create_association(res_id, PRED.hasOwner, actor_id)
self.event_pub.publish_event(event_type="ResourceModifiedEvent",
origin=res_id,
origin_type=object._get_type(),
sub_type="CREATE",
mod_type=ResourceModificationType.CREATE)
return res
def create(self, object=None, actor_id=None):
if object is None:
raise BadRequest("Object not present")
if not isinstance(object, IonObjectBase):
raise BadRequest("Object is not an IonObject")
if not is_resource(object):
raise BadRequest("Object is not a Resource")
lcsm = get_restype_lcsm(object._get_type())
object.lcstate = lcsm.initial_state if lcsm else "DEPLOYED_AVAILABLE"
cur_time = get_ion_ts()
object.ts_created = cur_time
object.ts_updated = cur_time
res = self.rr_store.create(object)
res_id, rev = res
if actor_id and actor_id != 'anonymous':
log.debug("Associate resource_id=%s with owner=%s" % (res_id, actor_id))
self.rr_store.create_association(res_id, PRED.hasOwner, actor_id)
return res
def execute_lifecycle_transition(self, resource_id='', transition_event=''):
if transition_event == LCE.RETIRE:
return self.retire(resource_id)
res_obj = self.read(resource_id)
old_state = res_obj.lcstate
old_availability = res_obj.availability
old_lcs = lcstate(old_state, old_availability)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
new_state = restype_workflow.get_successor(old_lcs, transition_event)
if not new_state:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s has no transition for event %s" % (
resource_id, restype, old_lcs, transition_event))
lcmat, lcav = lcsplit(new_state)
res_obj.lcstate = lcmat
res_obj.availability = lcav
res_obj.ts_updated = get_ion_ts()
self.rr_store.update(res_obj)
log.debug("execute_lifecycle_transition(res_id=%s, event=%s). Change %s_%s to %s_%s", resource_id, transition_event,
old_state, old_availability, res_obj.lcstate, res_obj.availability)
if self.container.has_capability(self.container.CCAP.EVENT_PUBLISHER):
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj.type_,
sub_type="%s.%s" % (res_obj.lcstate, res_obj.availability),
lcstate=res_obj.lcstate, availability=res_obj.availability,
lcstate_before=old_state, availability_before=old_availability,
transition_event=transition_event)
return lcstate(res_obj.lcstate, res_obj.availability)
def create_mult(self, res_list):
cur_time = get_ion_ts()
id_list = []
for resobj in res_list:
lcsm = get_restype_lcsm(resobj._get_type())
resobj.lcstate = lcsm.initial_state if lcsm else LCS.DEPLOYED
resobj.availability = lcsm.initial_availability if lcsm else AS.AVAILABLE
resobj.ts_created = cur_time
resobj.ts_updated = cur_time
id_list.append(resobj._id if "_id" in resobj else create_unique_resource_id())
res = self.rr_store.create_mult(res_list, id_list, allow_ids=True)
res_list = [(rid, rrv) for success, rid, rrv in res]
# TODO: Associations with owners
# TODO: Publish events (skipped, because this is inefficient one by one for a large list
# for rid,rrv in res_list:
# self.event_pub.publish_event(event_type="ResourceModifiedEvent",
# origin=res_id, origin_type=object._get_type(),
# mod_type=ResourceModificationType.CREATE)
return res_list
def execute_lifecycle_transition(self, resource_id='', transition_event=''):
res_obj = self.read(resource_id)
restype = res_obj._get_type()
restype_workflow = get_restype_lcsm(restype)
if not restype_workflow:
raise BadRequest("Resource id=%s type=%s has no lifecycle" % (resource_id, restype))
old_state = res_obj.lcstate
new_state = restype_workflow.get_successor(old_state, transition_event)
if not new_state:
raise BadRequest("Resource id=%s, type=%s, lcstate=%s has no transition for event %s" % (
resource_id, restype, res_obj.lcstate, transition_event))
res_obj.lcstate = new_state
res_obj.ts_updated = get_ion_ts()
self.rr_store.update(res_obj)
self.event_pub.publish_event(event_type="ResourceLifecycleEvent",
origin=res_obj._id, origin_type=res_obj._get_type(),
sub_type=new_state,
old_state=old_state, new_state=new_state, transition_event=transition_event)
return new_state
