class AssociationService(BaseService): """Example service implementation """ # Declaration of service declare = BaseService.service_declare(name='associations', version='0.1.0', dependencies=[]) # def __init__(self, receiver, spawnArgs=None): # BaseService.__init__(self, receiver, spawnArgs) # logging.info('HelloService.__init__()') def slc_init(self): self.store = Store() @defer.inlineCallbacks def op_put_association(self, content, headers, msg): ''' content is a DataObject encoding - a Dictionary! For storing blobs, we really just want to store it encoded. Can we get the serialized value from the messaging layer? ''' logging.info('op_put_association: '+str(content)) association = ValueObject(content) yield self.store.put(association.identity, association.value) # @ TODO add References! # The following line shows how to reply to a message yield self.reply(msg, 'reply', {'Stored Key':association.identity}, {}) @defer.inlineCallbacks def op_get_association(self, content, headers, msg): ''' ''' association = yield self.store.get(content['key']) # The following line shows how to reply to a message yield self.reply(msg, 'reply', association, {}) @defer.inlineCallbacks def op_del_association(self, content, headers, msg): ''' ''' # @ TODO remove References! yield self.store.delete(content['key']) # The following line shows how to reply to a message yield self.reply(msg, 'reply', {'result':'success'}, {})
class ServiceRegistryService(BaseService): """ Service registry service interface @todo a service is a resource and should also be living in the resource registry """ # Declaration of service declare = BaseService.service_declare(name='service_registry', version='0.1.0', dependencies=[]) def slc_init(self): self.datastore = Store() @defer.inlineCallbacks def op_register_service(self, content, headers, msg): """ Service operation: register a service by name """ svcdesc = content['svc_desc'].copy() logging.info('op_register_service: '+str(svcdesc)) yield self.datastore.put(svcdesc['name'],svcdesc) yield self.reply_ok(msg) def op_get_service_desc(self, content, headers, msg): """ Service operation: Get service description. May include a service specification. """ @defer.inlineCallbacks def op_register_instance(self, content, headers, msg): """ Service operation: """ svcinstdesc = content['svcinst_desc'].copy() logging.info('op_register_instance: '+str(svcinstdesc)) yield self.datastore.put(svcinstdesc['svc_name'], svcinstdesc) yield self.reply_ok(msg) @defer.inlineCallbacks def op_get_instance(self, content, headers, msg): """ Service operation: Returns the exchange name of the service """ svcname = str(content['svc_name']) logging.info('op_get_instance: '+str(svcname)) svcid = yield self.datastore.get(svcname) yield self.reply_ok(msg, {'svcinst_desc':svcid})
class ResourceRegistryService(BaseService): """ Resource registry service interface """ # Declaration of service declare = BaseService.service_declare(name='resource_registry', version='0.1.0', dependencies=[]) # For now, keep registration in local memory store. def slc_init(self): self.datastore = Store() @defer.inlineCallbacks def op_register_resource(self, content, headers, msg): """ Service operation: Register a resource instance with the registry. """ resdesc = content['res_desc'].copy() logging.info('op_register_resource: '+str(resdesc)) resdesc['lifecycle_state'] = ResourceLCState.RESLCS_NEW resid = pu.create_unique_id('R:') yield self.datastore.put(resid, resdesc) yield self.reply_ok(msg, {'res_id':str(resid)},) def op_define_resource_type(self, content, headers, msg): """ Service operation: Create or update a resource type with the registry. """ @defer.inlineCallbacks def op_get_resource_desc(self, content, headers, msg): """ Service operation: Get description for a resource instance. """ resid = content['res_id'] logging.info('op_get_resource_desc: '+str(resid)) res_desc = yield self.datastore.get(resid) yield self.reply_ok(msg, {'res_desc':res_desc}) def op_set_resource_lcstate(self, content, headers, msg): """ Service operation: set the life cycle state of resource """ def op_find_resources(self, content, headers, msg): """
class DataPubsubService(BaseService): """Data publish/subscribe service interface """ # Declaration of service declare = BaseService.service_declare(name='data_pubsub', version='0.1.0', dependencies=[]) def slc_init(self): self.topics = Store() @defer.inlineCallbacks def op_define_topic(self, content, headers, msg): """Service operation: Register a "topic" that can be published on and that can be subscribed to. Note: this has no direct connection to any AMQP topic notion. A topic is basically a data stream. """ topic_name = content['topic_name'] topic = {topic_name:{'name_type':'fanout', 'args':{'scope':'system'}}} yield bootstrap.declare_messaging(topic) qtopic_name = self.get_scoped_name('system',topic_name) yield self.topics.put(topic_name, topic[topic_name]) yield self.reply_ok(msg, {'topic_name':qtopic_name}, {}) def op_define_publisher(self, content, headers, msg): """Service operation: Register a publisher that subsequently is authorized to publish on a topic. """ def op_subscribe(self, content, headers, msg): """Service operation: Register a subscriber's intent to receive subscriptions on a topic, with additional filter and delivery method details. """ subscriber = None topic = None eventOnly = False def op_unsubscribe(self, content, headers, msg): """Service operation: Stop one's existing subscription to a topic. """ @defer.inlineCallbacks def op_publish(self, content, headers, msg): """Service operation: Publish data message on a topic """ topic_name = content['topic_name'] headers = content['msg_headers'] op = content['msg_op'] msg = content['msg'] qtopic = self.get_scoped_name('system',topic_name) # Todo: impersonate message as from sender yield self.send(qtopic, op, msg, headers) def find_topic(self, content, headers, msg): """Service operation: For a given resource, find the topic that contains
def reset_container(): """ Resets the container for warm restart. Simple implementation currently. Used for testing only. """ # The following is extremely hacky. Reset static module and classvariables # to their defaults. Even further, reset imported names in other modules # to the new objects. base_process.procRegistry = Store() base_process.processes = {} base_process.receivers = [] spawnable.store = Container.store spawnable.Spawnable.progeny = {}
def _stop_container(self): """ Taking down the container's connection to the broker an preparing for reinitialization. """ logging.info("Closing ION container") self.test_sup = None dcs = reactor.getDelayedCalls() logging.info("Cancelling %s delayed reactor calls!" % len(dcs)) for dc in dcs: dc.cancel() self.cont_conn.transport.loseConnection() container.Container._started = False container.Container.store = Store() bootstrap.reset_container() logging.info("============ION container closed============")
def currenttime(): """ @retval current UTC time as float with seconds in epoch and fraction """ return time.time() def currenttime_ms(): """ @retval current UTC time as int with milliseconds in epoch """ return int(currenttime() * 1000) # Stuff for testing: Stubs, mock objects fakeStore = Store() class FakeMessage(object): """Instances of this object are given to receive functions and handlers by test cases, in lieu of carrot BaseMessage instances. Production code detects these and no send is done. """ def __init__(self, payload=None): self.payload = payload @defer.inlineCallbacks def send(self, to, msg): self.sendto = to self.sendmsg = msg # Need to be a generator
def slc_init(self): self.datastore = Store()
def slc_init(self): self.store = Store()
def _setup_backend(self): """return a deferred which returns a initiated instance of a backend """ d = Store.create_store() return d
def slc_init(self): self.topics = Store()