本文整理汇总了Python中zmq.eventloop.zmqstream.ZMQStream.setsockopt方法的典型用法代码示例。如果您正苦于以下问题:Python ZMQStream.setsockopt方法的具体用法?Python ZMQStream.setsockopt怎么用?Python ZMQStream.setsockopt使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类zmq.eventloop.zmqstream.ZMQStream
的用法示例。
在下文中一共展示了ZMQStream.setsockopt方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Subscriber
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class Subscriber(object):
def __init__(self, context, sub_address, sub_topics):
self.context = context
self.subscriber_address = sub_address
self.subscriber_topics = sub_topics
socket = self.context.socket(zmq.SUB)
ioloop = IOLoop.instance()
self.subscriber = ZMQStream(socket, ioloop)
self.subscriber.setsockopt(zmq.LINGER, 0)
self.subscriber.on_recv(callback=self.subscriber_recv)
self.subscriber.setsockopt(zmq.SUBSCRIBE, "")
self.subscriber.connect(self.subscriber_address)
return
def shutdown(self):
self.subscriber.on_recv(callback=None)
self.subscriber.socket.disconnect(self.subscriber_address)
self.subscriber = None
return
def subscriber_recv(self, msg):
return
示例2: Broker
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class Broker (object):
def __init__(self,
pub_uri=defaults.broker_pub_uri,
sub_uri=defaults.broker_sub_uri,
patterns=None,
):
self.pub_uri = pub_uri
self.sub_uri = sub_uri
if patterns:
self.patterns = patterns
else:
self.patterns = []
self.setup_logging()
self.setup_zmq()
self.setup_sockets()
self.setup_subscriptions()
self.setup_events()
def setup_logging(self):
self.log = logging.getLogger('zmqevt.broker')
def setup_zmq(self):
self.context = zmq.Context()
def setup_sockets(self):
self.sub = ZMQStream(self.context.socket(zmq.SUB))
self.sub.bind(self.sub_uri)
self.pub = ZMQStream(self.context.socket(zmq.PUB))
self.pub.bind(self.pub_uri)
def setup_subscriptions(self):
if self.patterns:
for p in self.patterns:
self.subscribe(p)
def subscribe(self, pattern):
self.log.debug('Subcribe to "%s".' % pattern)
self.sub.setsockopt(zmq.SUBSCRIBE, pattern)
def setup_events(self):
self.sub.on_recv(self.publish)
def publish(self, msg):
assert len(msg) == 2, 'Received invalid message.'
# This regenerates the event to ensure that we don't
# pass on invalid data.
try:
evt = event.Event.load(msg)
except Exception, detail:
self.log.error('Error processing message: %s' % detail)
return
self.log.debug('Event: %s' % (str(evt.dump())))
self.pub.send_multipart(evt.dump())
示例3: __init__
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class RouterPubSubProxy:
'''
This is a proxy that has one front end socket, and two backend sockets. The
front end socket is a router that passes the messages to backend Pub. Pub
broadcasts them to all subscribers, which respond with results to backend
Sub. All communications on this proxy are done through IPC.
'''
def __init__(self,
front,
back_out,
back_in,
loop):
'''
Initializes the instance of RouterPubSubProxy.
@param front - channel name to be the routing stream
@param back_out - channel name of the publishing stream
@param back_in - channel name of result receiving stream
@param loop - IOLoop
'''
self._loop = loop
ctx = zmq.Context.instance()
# Create the front end stream
front_address = ZmqAddress(chan_name=front)
self._front_stream = ZMQStream(ctx.socket(zmq.ROUTER), io_loop=loop)
self._front_stream.setsockopt(zmq.ROUTER_MANDATORY, 1)
self._front_stream.bind(front_address.zmq_url())
# Create the back end streams
back_out_address = ZmqAddress(chan_name=back_out)
self._back_out_stream = ZMQStream(ctx.socket(zmq.PUB), io_loop=loop)
self._back_out_stream.bind(back_out_address.zmq_url())
back_in_address = ZmqAddress(chan_name=back_in)
self._back_in_stream = ZMQStream(ctx.socket(zmq.SUB), io_loop=loop)
self._back_in_stream.setsockopt(zmq.SUBSCRIBE, b'')
self._back_in_stream.bind(back_in_address.zmq_url())
def callback(from_name, to_name, zmq_stream, msgs):
log.info("Routing from {0} to {1} messages {2}"
.format(from_name, to_name, msgs))
zmq_stream.send_multipart(msgs)
zmq_stream.flush()
self._front_stream.on_recv(lambda msgs:
callback(front, back_out, self._back_out_stream, msgs))
self._back_in_stream.on_recv(lambda msgs:
callback(back_in, front, self._front_stream, msgs))
def start(self):
'''
Start this proxy.
'''
self._loop.start()
示例4: stream
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
def stream(self, sock_type, sock_addr, sock_bind,
callback=None, subscribe=''):
assert self.ctx is not None
sock_addr = sock_addr % {
'port': random.randint(1024,65535),
}
s = ZMQStream(
self.ctx.socket(sock_type))
if sock_type == zmq.SUB:
s.setsockopt(zmq.SUBSCRIBE, subscribe)
if sock_bind:
s.bind(sock_addr)
else:
s.connect(sock_addr)
if callback:
s.on_recv(callback)
return (s, sock_addr)
示例5: launch_scheduler
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
def launch_scheduler(in_addr, out_addr, mon_addr, not_addr, config=None,logname='ZMQ',
log_addr=None, loglevel=logging.DEBUG, scheme='lru',
identity=b'task'):
from zmq.eventloop import ioloop
from zmq.eventloop.zmqstream import ZMQStream
if config:
# unwrap dict back into Config
config = Config(config)
ctx = zmq.Context()
loop = ioloop.IOLoop()
ins = ZMQStream(ctx.socket(zmq.XREP),loop)
ins.setsockopt(zmq.IDENTITY, identity)
ins.bind(in_addr)
outs = ZMQStream(ctx.socket(zmq.XREP),loop)
outs.setsockopt(zmq.IDENTITY, identity)
outs.bind(out_addr)
mons = ZMQStream(ctx.socket(zmq.PUB),loop)
mons.connect(mon_addr)
nots = ZMQStream(ctx.socket(zmq.SUB),loop)
nots.setsockopt(zmq.SUBSCRIBE, '')
nots.connect(not_addr)
scheme = globals().get(scheme, None)
# setup logging
if log_addr:
connect_logger(logname, ctx, log_addr, root="scheduler", loglevel=loglevel)
else:
local_logger(logname, loglevel)
scheduler = TaskScheduler(client_stream=ins, engine_stream=outs,
mon_stream=mons, notifier_stream=nots,
scheme=scheme, loop=loop, logname=logname,
config=config)
scheduler.start()
try:
loop.start()
except KeyboardInterrupt:
print ("interrupted, exiting...", file=sys.__stderr__)
示例6: ZmqSubscriber
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class ZmqSubscriber(object):
def __init__(self,
moduleName,
centralHost=SUBSCRIBER_OPT_DEFAULTS['centralHost'],
context=None,
centralPublishEndpoint=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint'],
replay=None):
self.moduleName = moduleName
self.centralHost = centralHost
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralPublishEndpoint = parseEndpoint(centralPublishEndpoint,
defaultPort=DEFAULT_CENTRAL_PUBLISH_PORT,
centralHost=self.centralHost)
self.replayPaths = replay
if self.replayPaths is None:
self.replayPaths = []
self.handlers = {}
self.counter = 0
self.deserializer = serializers.get_deserializer('json')
self.stream = None
@classmethod
def addOptions(cls, parser, defaultModuleName):
if not parser.has_option('--centralHost'):
parser.add_option('--centralHost',
default=SUBSCRIBER_OPT_DEFAULTS['centralHost'],
help='Host where central runs [%default]')
if not parser.has_option('--moduleName'):
parser.add_option('--moduleName',
default=defaultModuleName,
help='Name to use for this module [%default]')
if not parser.has_option('--centralPublishEndpoint'):
parser.add_option('--centralPublishEndpoint',
default=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint'],
help='Endpoint where central publishes messages [%default]')
if not parser.has_option('--replay'):
parser.add_option('--replay',
action='append',
help='Replay specified message log (can specify multiple times), or use - to read from stdin')
@classmethod
def getOptionValues(cls, opts):
result = {}
for key in SUBSCRIBER_OPT_DEFAULTS.iterkeys():
val = getattr(opts, key, None)
if val is not None:
result[key] = val
return result
def start(self):
sock = self.context.socket(zmq.SUB)
self.stream = ZMQStream(sock)
# causes problems with multiple instances
#self.stream.setsockopt(zmq.IDENTITY, self.moduleName)
self.stream.connect(self.centralPublishEndpoint)
logging.info('zmq.subscriber: connected to central at %s', self.centralPublishEndpoint)
self.stream.on_recv(self.routeMessages)
def routeMessages(self, messages):
for msg in messages:
self.routeMessage(msg)
def routeMessage(self, msg):
colonIndex = msg.find(':')
topic = msg[:(colonIndex + 1)]
body = msg[(colonIndex + 1):]
handled = 0
for topicPrefix, registry in self.handlers.iteritems():
if topic.startswith(topicPrefix):
for handler in registry.itervalues():
handler(topic[:-1], body)
handled = 1
return handled
def subscribeRaw(self, topicPrefix, handler):
topicRegistry = self.handlers.setdefault(topicPrefix, {})
if not topicRegistry:
logging.info('zmq.subscriber: subscribe %s', topicPrefix)
self.stream.setsockopt(zmq.SUBSCRIBE, topicPrefix)
handlerId = (topicPrefix, self.counter)
topicRegistry[self.counter] = handler
self.counter += 1
return handlerId
def subscribeJson(self, topicPrefix, handler):
def jsonHandler(topicPrefix, body):
return handler(topicPrefix, convertToDotDictRecurse(json.loads(body)))
return self.subscribeRaw(topicPrefix, jsonHandler)
def subscribeDjango(self, topicPrefix, handler):
def djangoHandler(topicPrefix, body):
obj = json.loads(body)
dataText = json.dumps([obj['data']])
#.........这里部分代码省略.........
示例7: Subscriber
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class Subscriber (object):
def __init__(self,
sub_uri=defaults.subscriber_sub_uri,
patterns=None,
callbacks=None,
):
self.sub_uri = sub_uri
if patterns:
self.patterns = patterns
else:
self.patterns = []
if callbacks:
self.callbacks = callbacks
else:
self.callbacks = []
self.setup_logging()
self.setup_zmq()
self.setup_sockets()
self.setup_subscriptions()
self.setup_events()
def setup_logging(self):
self.log = logging.getLogger('zmqevt.subscriber')
def setup_zmq(self):
self.context = zmq.Context()
def setup_sockets(self):
self.sub = ZMQStream(self.context.socket(zmq.SUB))
self.sub.connect(self.sub_uri)
def setup_subscriptions(self):
if self.patterns:
for p in self.patterns:
self.subscribe(p)
def subscribe(self, pattern):
self.log.debug('Subcribe to "%s".' % pattern)
self.sub.setsockopt(zmq.SUBSCRIBE, pattern)
def setup_events(self):
self.sub.on_recv(self.on_recv)
def register_callback(self, func, data=None):
self.callbacks.append((func,data))
def unregister_callback(self, func):
self.callbacks = [x for x in self.callbacks if x[0] is not func]
def on_recv(self, msg):
self.log.debug('Receive: %s' % (str(msg)))
assert len(msg) == 2, 'Received invalid message.'
# This regenerates the event to ensure that we don't
# pass on invalid data.
try:
evt = event.Event.load(msg)
except Exception, detail:
self.log.error('Error processing message: %s' % detail)
return
self.log.debug('Event: %s' % (str(evt.dump())))
for func, data in self.callbacks:
func(evt, data=data)
示例8: ZmqSubscriber
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class ZmqSubscriber(object):
def __init__(self,
moduleName,
context=None,
centralPublishEndpoint=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint']):
self.moduleName = moduleName
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralPublishEndpoint = parseEndpoint(centralPublishEndpoint,
defaultPort=DEFAULT_CENTRAL_PUBLISH_PORT)
self.handlers = {}
self.counter = 0
self.deserializer = serializers.get_deserializer('json')
@classmethod
def addOptions(cls, parser, defaultModuleName):
if not parser.has_option('--moduleName'):
parser.add_option('--moduleName',
default=defaultModuleName,
help='Name to use for this module [%default]')
if not parser.has_option('--centralPublishEndpoint'):
parser.add_option('--centralPublishEndpoint',
default=SUBSCRIBER_OPT_DEFAULTS['centralPublishEndpoint'],
help='Endpoint where central publishes messages [%default]')
@classmethod
def getOptionValues(cls, opts):
result = {}
for key in SUBSCRIBER_OPT_DEFAULTS.iterkeys():
val = getattr(opts, key, None)
if val is not None:
result[key] = val
return result
def start(self):
sock = self.context.socket(zmq.SUB)
self.stream = ZMQStream(sock)
self.stream.setsockopt(zmq.IDENTITY, self.moduleName)
self.stream.connect(self.centralPublishEndpoint)
self.stream.on_recv(self.routeMessage)
def routeMessage(self, messages):
for msg in messages:
colonIndex = msg.find(':')
topic = msg[:(colonIndex + 1)]
body = msg[(colonIndex + 1):]
for topicPrefix, registry in self.handlers.iteritems():
if topic.startswith(topicPrefix):
topicRegistry = registry
break
for handler in topicRegistry.itervalues():
handler(topic[:-1], body)
def subscribeRaw(self, topic, handler):
topicRegistry = self.handlers.setdefault(topic, {})
if not topicRegistry:
self.stream.setsockopt(zmq.SUBSCRIBE, topic)
handlerId = (topic, self.counter)
topicRegistry[self.counter] = handler
self.counter += 1
return handlerId
def subscribeJson(self, topic, handler):
def jsonHandler(topic, body):
return handler(topic, json.loads(body))
return self.subscribeRaw(topic, jsonHandler)
def subscribeDjango(self, topic, handler):
def djangoHandler(topic, body):
obj = json.loads(body)
dataText = json.dumps([obj['data']])
modelInstance = self.deserializer(dataText)[0]
return handler(topic, modelInstance)
return self.subscribeRaw(topic, djangoHandler)
def unsubscribe(self, handlerId):
topic, index = handlerId
topicRegistry = self.handlers[topic]
del topicRegistry[index]
if not topicRegistry:
self.stream.setsockopt(zmq.UNSUBSCRIBE, topic)
def connect(self, endpoint):
self.stream.connect(endpoint)
示例9: init_hub
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
def init_hub(self):
"""construct"""
client_iface = "%s://%s:" % (self.client_transport, self.client_ip) + "%i"
engine_iface = "%s://%s:" % (self.engine_transport, self.engine_ip) + "%i"
ctx = self.context
loop = self.loop
# Registrar socket
q = ZMQStream(ctx.socket(zmq.ROUTER), loop)
q.bind(client_iface % self.regport)
self.log.info("Hub listening on %s for registration.", client_iface % self.regport)
if self.client_ip != self.engine_ip:
q.bind(engine_iface % self.regport)
self.log.info("Hub listening on %s for registration.", engine_iface % self.regport)
### Engine connections ###
# heartbeat
hpub = ctx.socket(zmq.PUB)
hpub.bind(engine_iface % self.hb[0])
hrep = ctx.socket(zmq.ROUTER)
hrep.bind(engine_iface % self.hb[1])
self.heartmonitor = HeartMonitor(loop=loop, config=self.config, log=self.log,
pingstream=ZMQStream(hpub,loop),
pongstream=ZMQStream(hrep,loop)
)
### Client connections ###
# Notifier socket
n = ZMQStream(ctx.socket(zmq.PUB), loop)
n.bind(client_iface%self.notifier_port)
### build and launch the queues ###
# monitor socket
sub = ctx.socket(zmq.SUB)
sub.setsockopt(zmq.SUBSCRIBE, b"")
sub.bind(self.monitor_url)
sub.bind('inproc://monitor')
sub = ZMQStream(sub, loop)
# connect the db
self.log.info('Hub using DB backend: %r'%(self.db_class.split()[-1]))
# cdir = self.config.Global.cluster_dir
self.db = import_item(str(self.db_class))(session=self.session.session,
config=self.config, log=self.log)
time.sleep(.25)
try:
scheme = self.config.TaskScheduler.scheme_name
except AttributeError:
from .scheduler import TaskScheduler
scheme = TaskScheduler.scheme_name.get_default_value()
# build connection dicts
self.engine_info = {
'control' : engine_iface%self.control[1],
'mux': engine_iface%self.mux[1],
'heartbeat': (engine_iface%self.hb[0], engine_iface%self.hb[1]),
'task' : engine_iface%self.task[1],
'iopub' : engine_iface%self.iopub[1],
# 'monitor' : engine_iface%self.mon_port,
}
self.client_info = {
'control' : client_iface%self.control[0],
'mux': client_iface%self.mux[0],
'task' : (scheme, client_iface%self.task[0]),
'iopub' : client_iface%self.iopub[0],
'notification': client_iface%self.notifier_port
}
self.log.debug("Hub engine addrs: %s", self.engine_info)
self.log.debug("Hub client addrs: %s", self.client_info)
# resubmit stream
r = ZMQStream(ctx.socket(zmq.DEALER), loop)
url = util.disambiguate_url(self.client_info['task'][-1])
r.setsockopt(zmq.IDENTITY, self.session.bsession)
r.connect(url)
self.hub = Hub(loop=loop, session=self.session, monitor=sub, heartmonitor=self.heartmonitor,
query=q, notifier=n, resubmit=r, db=self.db,
engine_info=self.engine_info, client_info=self.client_info,
log=self.log)
示例10: ZmqPublisher
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
class ZmqPublisher(object):
def __init__(self,
moduleName,
context=None,
centralSubscribeEndpoint=PUBLISHER_OPT_DEFAULTS['centralSubscribeEndpoint'],
publishEndpoint=PUBLISHER_OPT_DEFAULTS['publishEndpoint'],
heartbeatPeriodMsecs=PUBLISHER_OPT_DEFAULTS['heartbeatPeriodMsecs'],
highWaterMark=PUBLISHER_OPT_DEFAULTS['highWaterMark']):
self.moduleName = moduleName
if context is None:
context = zmq.Context.instance()
self.context = context
self.centralSubscribeEndpoint = parseEndpoint(centralSubscribeEndpoint,
defaultPort=DEFAULT_CENTRAL_SUBSCRIBE_PORT)
self.publishEndpoint = parseEndpoint(publishEndpoint,
defaultPort='random')
self.heartbeatPeriodMsecs = heartbeatPeriodMsecs
self.highWaterMark = highWaterMark
self.pubStream = None
self.heartbeatTimer = None
self.serializer = serializers.get_serializer('json')()
@classmethod
def addOptions(cls, parser, defaultModuleName):
if not parser.has_option('--moduleName'):
parser.add_option('--moduleName',
default=defaultModuleName,
help='Name to use for this module [%default]')
if not parser.has_option('--centralSubscribeEndpoint'):
parser.add_option('--centralSubcribeEndpoint',
default=PUBLISHER_OPT_DEFAULTS['centralSubscribeEndpoint'],
help='Endpoint where central listens for messages [%default]')
if not parser.has_option('--publishEndpoint'):
parser.add_option('--publishEndpoint',
default=PUBLISHER_OPT_DEFAULTS['publishEndpoint'],
help='Endpoint to publish messages on [%default]')
if not parser.has_option('--heartbeatPeriodMsecs'):
parser.add_option('--heartbeatPeriodMsecs',
default=PUBLISHER_OPT_DEFAULTS['heartbeatPeriodMsecs'],
type='int',
help='Period for sending heartbeats to central [%default]')
if not parser.has_option('--highWaterMark'):
parser.add_option('--highWaterMark',
default=PUBLISHER_OPT_DEFAULTS['highWaterMark'],
type='int',
help='High-water mark for publish socket (see 0MQ docs) [%default]')
@classmethod
def getOptionValues(cls, opts):
result = {}
for key in PUBLISHER_OPT_DEFAULTS.iterkeys():
val = getattr(opts, key, None)
if val is not None:
result[key] = val
return result
def heartbeat(self):
logging.debug('ZmqPublisher: heartbeat')
self.sendJson('central.heartbeat.%s' % self.moduleName,
{'host': getShortHostName(),
'pub': self.publishEndpoint})
def sendRaw(self, topic, body):
self.pubStream.send('%s:%s' % (topic, body))
def sendJson(self, topic, obj):
if isinstance(obj, dict):
obj.setdefault('module', self.moduleName)
obj.setdefault('timestamp', str(getTimestamp()))
self.sendRaw(topic, json.dumps(obj))
def sendDjango(self, modelInstance, topic=None, topicSuffix=None):
dataText = self.serializer.serialize([modelInstance])
data = json.loads(dataText)[0]
if topic is None:
topic = data['model'].encode('utf-8')
if topicSuffix is not None:
topic += topicSuffix
self.sendJson(topic, {'data': data})
def start(self):
pubSocket = self.context.socket(zmq.PUB)
self.pubStream = ZMQStream(pubSocket)
# self.pubStream.setsockopt(zmq.IDENTITY, self.moduleName)
self.pubStream.setsockopt(zmq.HWM, self.highWaterMark)
self.pubStream.connect(self.centralSubscribeEndpoint)
if self.publishEndpoint.endswith(':random'):
endpointWithoutPort = re.sub(r':random$', '', self.publishEndpoint)
port = self.pubStream.bind_to_random_port(endpointWithoutPort)
self.publishEndpoint = '%s:%d' % (endpointWithoutPort, port)
else:
self.pubStream.bind(self.publishEndpoint)
self.heartbeatTimer = ioloop.PeriodicCallback(self.heartbeat,
self.heartbeatPeriodMsecs)
#.........这里部分代码省略.........
示例11: ZmqCentral
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import setsockopt [as 别名]
#.........这里部分代码省略.........
logPath = os.path.join(self.logDir, logFile)
if '%s' in pathTemplate:
latestPath = os.path.join(self.logDir, pathTemplate % 'latest')
if os.path.islink(latestPath):
os.unlink(latestPath)
os.symlink(logFile, latestPath)
return logPath
def start(self):
# open log files
now = datetime.datetime.utcnow()
self.logDir = os.path.abspath(self.opts.logDir)
self.messageLogPath = self.readyLog(self.opts.messageLog, now)
self.messageLog = open(self.messageLogPath, 'a')
self.consoleLogPath = self.readyLog(self.opts.consoleLog, now)
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.DEBUG)
fmt = logging.Formatter('%(asctime)s - %(levelname)-7s - %(message)s')
fmt.converter = time.gmtime
fh = logging.FileHandler(self.consoleLogPath)
fh.setFormatter(fmt)
fh.setLevel(logging.DEBUG)
rootLogger.addHandler(fh)
if self.opts.foreground:
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
ch.setFormatter(fmt)
rootLogger.addHandler(ch)
# daemonize
if self.opts.foreground:
logging.info('staying in foreground')
else:
logging.info('daemonizing')
pid = os.fork()
if pid != 0:
os._exit(0)
os.setsid()
pid = os.fork()
if pid != 0:
os._exit(0)
os.chdir('/')
os.close(1)
os.close(2)
nullFd = os.open('/dev/null', os.O_RDWR)
os.dup2(nullFd, 1)
os.dup2(nullFd, 2)
try:
# set up zmq
self.context = zmq.Context.instance()
self.rpcStream = ZMQStream(self.context.socket(zmq.REP))
self.rpcStream.bind(self.opts.rpcEndpoint)
self.rpcStream.on_recv(self.handleRpcCall)
self.forwarder = ThreadDevice(zmq.FORWARDER, zmq.SUB, zmq.PUB)
self.forwarder.setsockopt_in(zmq.IDENTITY, THIS_MODULE)
self.forwarder.setsockopt_out(zmq.IDENTITY, THIS_MODULE)
self.forwarder.setsockopt_in(zmq.SUBSCRIBE, '')
self.forwarder.setsockopt_out(zmq.HWM, self.opts.highWaterMark)
self.forwarder.bind_in(self.opts.subscribeEndpoint)
self.forwarder.bind_in(INJECT_ENDPOINT)
self.forwarder.bind_out(self.opts.publishEndpoint)
self.forwarder.bind_out(MONITOR_ENDPOINT)
for entry in self.opts.subscribeTo:
try:
moduleName, endpoint = entry.split('@')
endpoint = parseEndpoint(endpoint)
except ValueError:
raise ValueError('--subscribeTo argument "%s" is not in the format "<moduleName>@<endpoint>"' % entry)
self.forwarder.connect_in(endpoint)
self.info[moduleName] = {'module': moduleName,
'pub': endpoint}
self.forwarder.start()
time.sleep(0.1) # wait for forwarder to bind sockets
self.monStream = ZMQStream(self.context.socket(zmq.SUB))
self.monStream.setsockopt(zmq.SUBSCRIBE, '')
self.monStream.connect(MONITOR_ENDPOINT)
self.monStream.on_recv(self.handleMessages)
self.injectStream = ZMQStream(self.context.socket(zmq.PUB))
self.injectStream.connect(INJECT_ENDPOINT)
self.disconnectTimer = ioloop.PeriodicCallback(self.handleDisconnectTimer, 5000)
self.disconnectTimer.start()
except: # pylint: disable=W0702
errClass, errObject, errTB = sys.exc_info()[:3]
errText = '%s.%s: %s' % (errClass.__module__,
errClass.__name__,
str(errObject))
logging.error(''.join(traceback.format_tb(errTB)))
logging.error(errText)
logging.error('[error during startup -- exiting]')
sys.exit(1)
def shutdown(self):
self.messageLog.flush()