def __init__(self,
in_addr,
out_addr,
mon_addr=None,
in_type=zmq.SUB,
out_type=zmq.DEALER,
mon_type=zmq.PUB,
heart_id=None):
if mon_addr is None:
self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
else:
self.device = ThreadMonitoredQueue(in_type,
out_type,
mon_type,
in_prefix=b"",
out_prefix=b"")
# do not allow the device to share global Context.instance,
# which is the default behavior in pyzmq > 2.1.10
self.device.context_factory = zmq.Context
self.device.daemon = True
self.device.connect_in(in_addr)
self.device.connect_out(out_addr)
if mon_addr is not None:
self.device.connect_mon(mon_addr)
if in_type == zmq.SUB:
self.device.setsockopt_in(zmq.SUBSCRIBE, b"")
if heart_id is None:
heart_id = uuid.uuid4().bytes
self.device.setsockopt_out(zmq.IDENTITY, heart_id)
self.id = heart_id
def start_proxy():
logger.info("Starting proxy")
device = ThreadDevice(zmq.FORWARDER, zmq.XSUB, zmq.XPUB)
device.bind_in(PROXY_BACKEND)
device.bind_out(PROXY_FRONTEND)
device.start()
return device
def run(self, *args, **kwargs):
frontend_address = kwargs['frontend-address']
assert frontend_address
backend_address = kwargs['backend-address']
assert backend_address
device = ThreadDevice(zmq.QUEUE, zmq.ROUTER, zmq.DEALER)
device.bind_in(frontend_address)
device.setsockopt_in(zmq.IDENTITY, 'ROUTER')
device.bind_out(backend_address)
device.setsockopt_out(zmq.IDENTITY, 'DEALER')
device.start()
def __init__(self,
in_addr,
out_addr,
in_type=zmq.SUB,
out_type=zmq.XREQ,
heart_id=None):
self.device = ThreadDevice(zmq.FORWARDER, in_type, out_type)
self.device.daemon = True
self.device.connect_in(in_addr)
self.device.connect_out(out_addr)
if in_type == zmq.SUB:
self.device.setsockopt_in(zmq.SUBSCRIBE, "")
if heart_id is None:
heart_id = str(uuid.uuid4())
self.device.setsockopt_out(zmq.IDENTITY, heart_id)
self.id = heart_id
def start(self):
# Launch two proxy sockets, one for remote communication, and one for in-process communication.
self.device_thread = ThreadDevice(zmq.FORWARDER, zmq.XSUB, zmq.XPUB)
self.device_thread.bind_in("tcp://*:" + str(MessageProxy.SUB_PORT))
self.device_thread.bind_out("tcp://*:" + str(MessageProxy.PUB_PORT))
self.device_thread.start()
# TODO Finish in-process communication
"""
self.local_frontend = self.context.socket(zmq.XSUB)
self.local_frontend.bind("inproc://" + MessageProxy.INPROC_SUB_ID)
self.local_backend = self.context.socket(zmq.XPUB)
self.local_backend.bind("inproc://" + MessageProxy.INPROC_PUB_ID)
zmq.device(zmq.FORWARDER, self.local_frontend, self.local_backend)
"""
self.initialized = True
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)
