log.error("message got here without the later-init")
sleepsecs = int(content['work_amount'])
extradict = {
"batchid": content['batchid'],
"jobid": content['jobid'],
"work_amount": sleepsecs
}
cei_events.event("worker", "job_begin", extra=extradict)
log.info("WORK: sleeping for %d seconds ---" % sleepsecs)
yield pu.asleep(sleepsecs)
yield self.reply(msg, 'result', {'result': 'work_complete'}, {})
cei_events.event("worker", "job_end", extra=extradict)
# Direct start of the service as a process with its default name
factory = ProcessFactory(EPUWorkerService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
log.info('EPU Worker starting, startup type "%s"' % starttype)
conf = ioninit.config(__name__)
spawnargs = {'queue_name_work': conf['queue_name_work']}
# Required services.
proc = [{
'name': 'epu_worker',
'module': __name__,
'class': EPUWorkerService.__name__,
'spawnargs': spawnargs
def read_cookie(path=None):
"""Reads Erlang cookie file
"""
cookie_path = path or DEFAULT_COOKIE_PATH
log.debug('Reading erlang cookie from ' + cookie_path)
f = open(os.path.expanduser(cookie_path))
try:
return f.read().strip()
finally:
if f:
f.close()
# Direct start of the service as a process with its default name
factory = ProcessFactory(QueueStatService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
log.info('EPU Queuestat starting, startup type "%s"' % starttype)
conf = ioninit.config(__name__)
proc = [
{
'name': 'queuestat',
'module': __name__,
'class': QueueStatService.__name__,
'spawnargs': {
'interval_seconds': conf.getValue('interval_seconds')
See the NPreservingEngine class notes for reconfiguration details.
"""
pass
def op_find_workers(self, content, headers, msg):
"""Interact with the provisioner to discover any new worker nodes
that were launched in the system since the last query.
Input: optionally filter by a particular HA service.
Returns the newest workers, before return it has updated the
datastore with any new information.
"""
pass
def op_service_status(self, content, headers, msg):
"""Return the status of one or more services. Each service status
will list the:
1) Known workers, past and present. Instance information, time of
launch (and failure/termination if applicable), hostnames.
2) Worker status: IaaS status as well as the more "semantic" knowledge
of health that is acquired via heartbeats (or the lack thereof).
"""
pass
# Direct start of the service as a process with its default name
factory = ProcessFactory(EPUManagementService)
Note it does not update the SQL files on disk, so if the AppControllerService is
restarted, it will need to be updated with the current defs again.
This method expects that the only key in content, also named content, is a full
SQL definition (the concatenation of "catalog.sqlt" and "detections.sqlt") with
Python string.Template vars as substitution points for the following variables:
* inp_queue - The input queue name to read messages from.
* inp_queue_autodelete - The input queue's auto_delete setting.
* inp_queue_durable - The input queue's durable setting.
* inp_exchange - The exchange where the input queue resides.
* inp_exchange_type - The exchange's type (topic/fanout/direct).
* inp_exchange_durable - The exchange's durable setting.
* inp_exchange_autodelete - The exchange's auto_delete setting.
* det_topic - The topic string that should be used for detections.
* det_exchange - The exchange where detections should be published.
* det_exchange_type - The detection exchange's type (topic/fanout/direct).
* det_exchange_durable - The detection exchange's durable setting.
* det_exchange_autodelete - The detection exchange's auto_delete setting.
If these variables are not present, no error is thrown - it will use whatever you
gave it. So your updated SQL definitions may hardcode the variables above.
"""
defs = content['content']
self.attribute_store_client.put(SQLTDEFS_KEY, defs)
self.reply_ok(msg, {'value': 'ok'}, {})
# Spawn of the process using the module name
factory = ProcessFactory(AppControllerService)
# must simulate processEnded callback value
cba = {
'exitcode': 0,
'outlines': self.outlines,
'errlines': self.errlines
}
self.ready_deferred.callback(cba)
#yield self.ready_callback(**self.ready_callbackargs)
def processEnded(self, reason):
# Process ended override.
# This override is to signal ready deferred if we never did, just in case.
if self.ready_deferred and not self.ready_deferred.called:
# must simulate processEnded callback value
cba = {
'exitcode': 0,
'outlines': self.outlines,
'errlines': self.errlines
}
self.ready_deferred.callback(cba)
EnvOSProcess.processEnded(self, reason)
# Spawn of the process using the module name
factory = ProcessFactory(AppAgent)
e,
exc_info=True)
@defer.inlineCallbacks
def _do_query(self):
log.debug("Sending query request to provisioner")
yield self.client.query()
# This is an unfortunate hack to work around a memory leak in ion.
# Some caches are only cleared after a received message is handled.
# Since this process sends messages "spontaneously" -- triggered by a
# LoopingCall -- we must manually clear the cache.
self.message_client.workbench.manage_workbench_cache('Default Context')
factory = ProcessFactory(ProvisionerQueryService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
proc = [{
'name': 'provisioner',
'module': __name__,
'class': ProvisionerQueryService.__name__,
'spawnargs': {}
}]
app_supv_desc = ProcessDesc(name='Provisioner Query app supervisor',
module=app_supervisor.__name__,
spawnargs={'spawn-procs': proc})
(content, headers, msg) = yield self.rpc_send('node_error', node_id)
defer.returnValue(content)
class EPUControllerClientSample(ServiceProcess):
declare = ServiceProcess.service_declare(name='epu_reconfigure_sample',
version='0.1.0',
dependencies=[])
def slc_init(self, proc=None, **kwargs):
self.client = EPUControllerClient()
reactor.callLater(5, self.send_reconfigure)
@defer.inlineCallbacks
def send_reconfigure(self):
newconf = {}
newconf["preserve_n"] = "%s" % self.spawn_args["preserve_n"]
newconf["unique_instances"] = {
'b2db408e': {
'some_unique_name': 'some_unique_value123'
},
'3633541e': {
'some_unique_name': 'some_other_unique_value456'
}
}
self.client.reconfigure(newconf)
factory = ProcessFactory(EPUControllerClientSample)
"""
log.debug('Sending state %s record for node %s to %s', record['state'],
record['node_id'], repr(subscribers))
for sub in subscribers:
yield self.process.send(sub, operation, record)
@defer.inlineCallbacks
def send_records(self, records, subscribers, operation='instance_state'):
"""Send a set of node records to all subscribers.
"""
for rec in records:
yield self.send_record(rec, subscribers, operation)
# Spawn of the process using the module name
factory = ProcessFactory(ProvisionerService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
log.info('EPU Provisioner starting, startup type "%s"' % starttype)
conf = ioninit.config(__name__)
proc = [{
'name': 'provisioner',
'module': __name__,
'class': ProvisionerService.__name__,
'spawnargs': {
'query_period': conf.getValue('query_period'),
'store': get_provisioner_store(conf),
# This is an unfortunate hack to work around a memory leak in ion.
# Some caches are only cleared after a received message is handled.
# Since this process sends messages "spontaneously" -- triggered by a
# LoopingCall -- we must manually clear the cache.
self.message_client.workbench.manage_workbench_cache(
'Default Context')
except Queue.Empty:
return
except Exception, e:
# unhandled exceptions will terminate the LoopingCall
log.error("Error adding work: %s", e, exc_info=True)
# Direct start of the service as a process with its default name
factory = ProcessFactory(EPUWorkProducer)
class SleepJob:
def __init__(self, jobid, batchid, length):
self.jobid = jobid
self.batchid = batchid
self.length = int(length)
# Sidechannel access to tell service what to do
class Sidechannel(resource.Resource):
isLeaf = True
def __init__(self):
self.queue = Queue.Queue()
@return: a list with expected id's that have not been received.
"""
# note: we pass the timeout as it is directly to our own payload:
payload = {'timeout':timeout}
# but we need to explicitly indicate it for purposes of ION processing:
if timeout is None:
timeout = 15.0
(content, headers, payload) = yield self.rpc_send('getExpected', payload, timeout=timeout)
log.debug('getExpected service reply: ' + str(content))
defer.returnValue(content)
@defer.inlineCallbacks
def getAccepted(self, publish_id):
"""
Returns the content received for a given publish_id; None if not received yet.
"""
if publish_id is None:
raise Exception("publish_id cannot be None")
payload = {'publish_id':publish_id}
(content, headers, payload) = yield self.rpc_send('getAccepted', payload)
log.debug('getAccepted service reply: ' + str(content))
defer.returnValue(content)
# Spawn of the process using the module name
factory = ProcessFactory(SiamCiReceiverService)
})
except ReceivedError, re:
raise DeployableTypeLookupError(re.msg_content)
defer.returnValue({
'document' : content.get('document'),
'nodes' : content.get('nodes')
})
class DeployableTypeLookupError(Exception):
"""Error resolving or interpolating deployable type
"""
pass
# Direct start of the service as a process with its default name
factory = ProcessFactory(DeployableTypeRegistryService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
log.info('EPU DTRS starting, startup type "%s"' % starttype)
conf = ioninit.config(__name__)
dt_dir = conf.getValue('registry_dir', '/opt/dt-data/dt')
# Required services.
proc = [{'name': 'dtrs',
'module': __name__,
'class': DeployableTypeRegistryService.__name__,
'spawnargs': {'registry_dir' : dt_dir}
}]
The client class for the instrument driver. This is the client that the
instrument agent can use for communicating with the driver.
In this case, this is the driver interface to a SIAM enabled instrument.
Operations are mainly supported by the SiamCiAdapterProxy class.
"""
@defer.inlineCallbacks
def set_publish_stream(self, publish_stream):
"""
Sets the publish stream. This is a convenience to allow the testing of
reception of asynchronous notifications from the SIAM-CI adapter service.
The expected mechanism would be that an associated InstrumentAgent
would get those notifications directly (eg., via the op_publish operation),
but this is not clear yet (2011-05-12).
@param publish_stream: the publish stream name. Can be None.
"""
log.debug("SiamInstrumentDriverClient set_publish_stream " +
str(publish_stream))
content_outgoing = {'publish_stream': publish_stream}
(content, headers,
message) = yield self.rpc_send('set_publish_stream', content_outgoing)
defer.returnValue(content)
# Spawn of the process using the module name
factory = ProcessFactory(SiamInstrumentDriver)
continue
controller_list.append(name)
return controller_list
def plc_terminate(self):
log.debug('EPU Controller List service: shutdown triggered')
@defer.inlineCallbacks
def op_list(self, content, headers, msg):
"""Return a list of zero to N controller names
"""
yield self.reply_ok(msg, self.controller_list)
# Direct start of the service as a process with its default name
factory = ProcessFactory(EPUControllerListService)
@defer.inlineCallbacks
def start(container, starttype, *args, **kwargs):
log.info('EPU Controller List service starting, startup type "%s"' %
starttype)
conf = ioninit.config(__name__)
controller_list_path = conf.getValue('controller_list_path', None)
proc = [
{
'name': 'epu_controller_list',
'module': __name__,
'class': EPUControllerListService.__name__,