def Run(): try: print "Running web server on port: "+str(Config["Web server"]["Port"]) sessionsManager = SessionsManager() socket = zmq.Context.instance().socket(zmq.SUB) socket.bind("tcp://*:"+str(Config["Web server"]["IncomingZmqPort"])) socket.setsockopt(zmq.SUBSCRIBE, "") stream = ZMQStream(socket) stream.on_recv(sessionsManager.ProcessZmqMessages) settings = { "debug" : False, "template_path":os.path.join(os.path.dirname(__file__), "../Frontend"), } app = tornado.web.Application([ (r'/Static/(.*)', tornado.web.StaticFileHandler, {'path': os.path.join(os.path.dirname(__file__), "../Frontend/Static")}), (r'/Tmp/(.*)', tornado.web.StaticFileHandler, {'path': Config["Web server"]["Temporary files folder"]}), (r'/RCP', IndexHandler), (r'/RCP/', IndexHandler), (r'/StreamsTree/(.*)', StreamsTreeRequestHandler, dict(sessionsManager=sessionsManager)), (r'/WebSockets/', WebSocketHandler, dict(sessionsManager=sessionsManager)), ], **settings) periodic = ioloop.PeriodicCallback(CheckServerStopRequests, 500) periodic.start() app.listen(Config["Web server"]["Port"]) tornado.ioloop.IOLoop.instance().start() except: print traceback.format_exc()
def enable_depth_frames(self, kinect_id): """Enable streaming of depth frames. *kinect_id* is the id of the device which should have streaming enabled. :raises ValueError: if *kinect_id* does not correspond to a connected device """ try: record = self._kinect_records[kinect_id] except KeyError: raise ValueError('Kinect id "{0}" does not correspond to a connected device'.format( kinect_id)) # Create subscriber stream socket = self._zmq_ctx.socket(zmq.SUB) socket.connect(record.endpoints[EndpointType.depth]) socket.setsockopt_string(zmq.SUBSCRIBE, u'') stream = ZMQStream(socket, self._io_loop) record.streams[EndpointType.depth] = stream # Fire signal on incoming depth frame def on_recv(msg, kinect_id=kinect_id): # TODO: decompress frame self.on_depth_frame.send(self, kinect_id=kinect_id, depth_frame=msg) # Wire up callback stream.on_recv(on_recv)
class Connection(object): """The base class for the connection between node and master """ def __init__(self, endpoint): self.endpoint = endpoint # init zeromq self.context = zmq.Context() self.socket = self.context.socket(zmq.REQ) self.stream = ZMQStream(self.socket) self.stream.on_recv(self.OnRecvMsg) # get local endpoint self.socket.bind("tcp://eth0:*") self.local_endpoint = str(self.socket.getsockopt(zmq.LAST_ENDPOINT)) print "Local endpoint [%s]" % self.local_endpoint # connect to target self.socket.connect(endpoint) print "Connected to [%s]" % endpoint def SendMsg(self, msg): self.socket.send(msg, copy=False) print "Sending message [%s]" % msg #msg_rsp = self.socket.recv( copy = False ) #print "Receiving message [%s]" % msg_rsp def OnRecvMsg(self, msg): #msg_rsp = self.socket.recv( copy = False ) #print "Receiving message [%s]" % msg_rsp print "Receiving message ========== [%s]" % msg def GetLocalEndpoint(self): return self.local_endpoint def GetEndpoint(self): return self.endpoint
def run(self): if self.filename == 'sys.stdout': self.file = sys.stdout elif self.filename == 'sys.stderr': self.file = sys.stderr else: self.file = open(self.filename, 'a+b') ioloop.install() loop = ioloop.IOLoop.instance() stream = None try: context = zmq.Context() socket = context.socket(zmq.SUB) socket.connect(self.addr) socket.setsockopt(zmq.SUBSCRIBE, '') stream = ZMQStream(socket) except Exception, err: print self.name, 'error getting outstream:', err exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception(exc_type, exc_value, exc_traceback) traceback.print_tb(exc_traceback, limit=30) if stream and not stream.closed(): stream.close()
class SoundServer(object): def __init__(self): self._context = zmq.Context() self._socket = self._context.socket(zmq.REP) self._socket.bind('tcp://127.0.0.1:{0}'.format(CONTROL_PORT)) self._stream = ZMQStream(self._socket) self._stream.on_recv(self._handle_msg) def start(self): IOLoop.instance().start() def _handle_msg(self, msg): method = '_handler_{0}'.format(msg[0].decode("utf-8")) try: print("Trying method {0}".format(method)) getattr(self, method)() except AttributeError: sys.exit(1) def _handler_hi(self): self._socket.send_string('sup?') def _handler_exit(self): pass
class InternalRouter(object): def __init__(self, context): socket = context.socket(zmq.ROUTER) socket.setsockopt(zmq.LINGER, 0) identity = 'router' socket.identity = identity.encode('ascii') session = Session() router_internal = session.query(RoutingDefiniton.route) \ .filter_by(name="internal_router") \ .scalar() session.close() socket.bind(router_internal) ioloop = IOLoop.instance() self.internal_router = ZMQStream(socket, ioloop) self.internal_router.on_recv(callback=self.router_recv) return def shutdown(self): self.internal_router.on_recv(callback=None) self.internal_router = None return def router_recv(self, msg): return
def main(pat): fname = find_connection_file(pat) with open(fname) as f: cfg = json.load(f) url = "%s://%s:%s" % (cfg.get('transport', 'tcp'), cfg['ip'], cfg['iopub_port']) session = Session(key=cfg['key']) ctx = zmq.Context.instance() sub = ctx.socket(zmq.SUB) sub.subscribe = b'' sub.connect(url) # import IPython # IPython.embed() # return stream = ZMQStream(sub) stream.on_recv(lambda msg_list: log_msg(session, msg_list)) pc = PeriodicCallback(print_time, 5 * 60 * 1000) pc.start() IOLoop.instance().start()
def main(): import sys from PyQt4 import QtGui, Qt from eventloop import QtLoop, ZMQLoop from kernel import Kernel from epubsub.hub import Hub import zmq from zmq.eventloop.zmqstream import ZMQStream def callback(stream, msg): print msg stream.send('OK') print 'running' #app = QtGui.QApplication(sys.argv) loop = ZMQLoop() loop.install() kernel = Kernel() ctx = zmq.Context() socket = ctx.socket(zmq.ROUTER) socket.bind('tcp://127.0.0.1:11111') stream = ZMQStream(socket) stream.on_recv_stream(callback) loop.start()
class UartzStream(object): def __init__(self, addr, io_loop=None): self.addr = addr self.ioloop = io_loop self.stream = None self.reset_stream() def reset_stream(self): ctx = zmq.Context.instance() sock = ctx.socket(zmq.SUB) sock.connect(self.addr) sock.setsockopt(zmq.SUBSCRIBE, b'') self.stream = ZMQStream(sock, self.ioloop) self.stream.on_recv(self._handle_msg) def _handle_msg(self, msg): assert len(msg) == 1 msg = msg[0] chan_idx = msg.index(b":") assert chan_idx > 0 self.handle_msg(UartzMsg(dev=msg[:chan_idx], msg=msg[chan_idx + 1:]))
def __init__(self, port=5556): self.port = port self.ctx = zmq.Context() self.kvmap = {} self.loop = IOLoop.instance() # Set up our clone server sockets self.snapshot = self.ctx.socket(zmq.ROUTER) self.publisher = self.ctx.socket(zmq.PUB) self.collector = self.ctx.socket(zmq.PULL) self.snapshot.bind("tcp://*:%d" % self.port) self.publisher.bind("tcp://*:%d" % (self.port + 1)) self.collector.bind("tcp://*:%d" % (self.port + 2)) # Wrap sockets in ZMQStreams for IOLoop handlers self.snapshot = ZMQStream(self.snapshot) self.publisher = ZMQStream(self.publisher) self.collector = ZMQStream(self.collector) # Register our handlers with reactor self.snapshot.on_recv(self.handle_snapshot) self.collector.on_recv(self.handle_collect) self.flush_callback = PeriodicCallback(self.flush_ttl, 1000) # basic log formatting: logging.basicConfig(format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=logging.INFO)
class LRUQueue(object): def __init__(self, backend_socket, frontend_socket, clients, workers): self.avaliable_workers = 0 self.workers = [] self.worker_num = workers self.client_num = clients self.backend = ZMQStream(backend_socket) self.frontend = ZMQStream(frontend_socket) self.backend.on_recv(self.handle_backend) self.loop = IOLoop.instance() def handle_backend(self, msg): worker_addr, empty, client_addr = msg[:3] assert self.avaliable_workers < self.worker_num self.avaliable_workers += 1 self.workers.append(worker_addr) assert empty == "" if client_addr != "READY": empty, reply = msg[3:] assert empty == "" self.frontend.send_multipart([client_addr, "", reply]) self.client_num -= 1 if 0 == self.client_num: self.loop.add_timeout(time.time() + 1, self.loop.stop) if self.avaliable_workers == 1: self.frontend.on_recv(self.handle_frontend) def handle_frontend(self, msg): client_addr, empty, request = msg assert empty == "" self.avaliable_workers -= 1 worker_id = self.workers.pop() self.backend.send_multipart([worker_id, "", client_addr, "", request]) if self.avaliable_workers == 0: self.frontend.stop_on_recv()
class ZBus(object): def __init__(self): self._context = zmq.Context() self._callback = {} self._zstream = None @staticmethod def instance(): if not hasattr(ZBus, '_instance'): ZBus._instance = ZBus() return ZBus._instance @staticmethod def initialized(): return hasattr(ZBus, '_instance') def connect(self, dist): if self._zstream: self._zstream.close() self._zsock = self._context.socket(zmq.XREQ) self._zsock.connect('tcp://{dist}'.format(dist=dist)) self._zstream = ZMQStream(self._zsock) self._zstream.on_recv(self.on_recv) def send(self, request, callback): self._callback[request.seed_id] = callback self._zstream.send_multipart(request.box()) def on_recv(self, frame): response = ZResponse(frame) callback = self._callback.pop(response.seed_id) if self._callback.get(response.seed_id) else None if callback and callable(callback): callback(response)
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
def __init__(self, robot, data_in_sock='ipc:///tmp/robot-data-m2w.sock', data_out_sock='ipc:///tmp/robot-data-w2m.sock', msg_in_sock='ipc:///tmp/robot-msg-m2w.sock', msg_out_sock='ipc:///tmp/robot-msg-w2m.sock', io_loop=None): self.identity = 'worker:%s:%s' % (socket.gethostname(), os.getpid()) context = zmq.Context() self._io_loop = io_loop or IOLoop.instance() self._in_socket = context.socket(zmq.PULL) self._in_socket.connect(data_in_sock) self._in_stream = ZMQStream(self._in_socket, io_loop) self._out_socket = context.socket(zmq.PUB) self._out_socket.connect(data_out_sock) self._out_stream = ZMQStream(self._out_socket, io_loop) self._running = False self.robot = robot self.robot.set_worker_identity(self.identity) self.messenger = ClientMessenger(msg_in_sock, msg_out_sock, context, io_loop)
def __init__(self, context, main_ep, opt_ep=None, worker_q=None): """Init MDPBroker instance. """ socket = context.socket(zmq.XREP) socket.bind(main_ep) self.main_stream = ZMQStream(socket) self.main_stream.on_recv(self.on_message) if opt_ep: socket = context.socket(zmq.XREP) socket.bind(opt_ep) self.client_stream = ZMQStream(socket) self.client_stream.on_recv(self.on_message) else: self.client_stream = self.main_stream self._workers = {} # services contain the worker queue and the request queue self._services = {} self._worker_cmds = { '\x01': self.on_ready, '\x03': self.on_reply, '\x04': self.on_heartbeat, '\x05': self.on_disconnect, } self.hb_check_timer = PeriodicCallback(self.on_timer, HB_INTERVAL) self.hb_check_timer.start() return
def __init__(self, context, front, back, top=True): self.workers = WorkerQueue() self.loop = IOLoop.instance() self.liveness = HEARTBEAT_LIVENESS self.heartbeat = HEARTBEAT_INTERVAL self.interval = INTERVAL_INIT self.time = self.interval * self.heartbeat self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS self.callback = None self.timed_out = False self.hearbeats = 0 if top: self.frontend_socket = context.socket(zmq.ROUTER) self.frontend_socket.bind(url_str(front,True)) else: self.frontend_socket = context.socket(zmq.DEALER) self.frontend_socket.connect(url_str(front)) self.frontend.send(PPP_READY) self.backend_socket = context.socket(zmq.ROUTER) self.backend_socket.bind(url_str(back,True)) self.frontend = ZMQStream(self.frontend_socket) self.backend = ZMQStream(self.backend_socket) self.start()
def __init__(self, front_end_name, back_end_name, loop): ''' Initializes an instance of LocalRequestProxy @param front_end_name - name of the front end socket. It will be initialized with the Router socket. @param back_end_name - name of the back end socket. It will be initialized with the Dealer socket. @param loop - zmq IOLoop ''' self._loop = loop ctx = zmq.Context.instance() # Create the front end stream front_address = ZmqAddress(chan_name=front_end_name, transport=INPROC) self._front_end = ZMQStream(ctx.socket(zmq.ROUTER), io_loop=loop) self._front_end.setsockopt(zmq.ROUTER_MANDATORY, 1) self._front_end.bind(front_address.zmq_url()) # Create the back end stream back_address = ZmqAddress(chan_name=back_end_name) self._back_end = ZMQStream(ctx.socket(zmq.DEALER), io_loop=loop) self._back_end.connect(back_address.zmq_url()) def callback(from_name, to_name, zmq_stream, msgs): log.debug("Routing from {0} to {1} messages {2}" .format(from_name, to_name, msgs)) zmq_stream.send_multipart(msgs) zmq_stream.flush() self._front_end.on_recv(lambda msgs: callback(front_end_name, back_end_name, self._back_end, msgs)) self._back_end.on_recv(lambda msgs: callback(back_end_name, front_end_name, self._front_end, msgs))
def __init__(self, settings, identity, insocket, outsocket, mgmt, frontier, log_handler, log_level, io_loop): """ Initialize the master. """ LoggingMixin.__init__(self, log_handler, log_level) self._identity = identity self._io_loop = io_loop or IOLoop.instance() self._in_stream = ZMQStream(insocket, io_loop) self._out_stream = ZMQStream(outsocket, io_loop) self._mgmt = mgmt self._frontier = frontier self._running = False self._available_workers = [] # periodically check if there are pending URIs to crawl self._periodic_update = PeriodicCallback(self._send_next_uri, settings.MASTER_PERIODIC_UPDATE_INTERVAL, io_loop=io_loop) # start this periodic callback when you are waiting for the workers to # finish self._periodic_shutdown = PeriodicCallback(self._shutdown_wait, 500, io_loop=io_loop) self._shutdown_counter = 0 self._logger.debug("zmqmaster::initialized")
class SwysSearchRequestHandler(BaseHandler): def initialize(self): socket = context.socket(zmq.REQ) socket.connect(conf.SEARCH_WORKER_ZMQ_ENDPOINT) self._zmq_stream = ZMQStream(socket) self._zmq_stream.on_recv(self._recv_result, copy=True) @tornado.web.asynchronous def handle_request_async(self, *args, **kwargs): files = self.request.files.get('image', []) if len(files) == 0: raise Exception("there is no file attached") file = files[0] temp_file = tempfile.NamedTemporaryFile('wb', delete=False) temp_file.write(file.body) self._zmq_stream.send_json({'filename': temp_file.name}) def _recv_result(self, msg): result_str = "".join(( part.decode('utf-8') for part in msg )) result = json.loads(result_str)['data'] return self.on_complete(result)
class MonitorEvents(SockJSConnection): def _zmq_msg(self, msg): #logging.debug(msg) try: msg_obj = json.loads(msg[0]) logging.debug(msg_obj) if self.monitor != 'All': if 'mon_id' in msg_obj and msg_obj['mon_id'] == self.monitor: self.send(msg_obj) else: self.send(msg_obj) except Exception as ex: logging.error(ex) def on_open(self, info): logging.debug("Monitor ticker open: "+self.monitor) zmq_socket = zmq.Context.instance().socket(zmq.SUB) zmq_socket.connect(zmq_local_endpoint) zmq_socket.setsockopt(zmq.SUBSCRIBE, '') self.stream = ZMQStream(zmq_socket) self.stream.on_recv(self._zmq_msg) def on_close(self): logging.debug("Monitor ticker close: "+self.monitor) self.stream.stop_on_recv()
def start(self): identifier = self.identifier job = self.job def execute_next(msg): # We can't use zodb object from outside here because # this code is executed in another thread (eventloop) # We don't have site or interaction, so the job must be created # before. # we can't use push_event_callback_after_commit here because # it will never commit in this thread (eventloop) if identifier in callbacks: callbacks[identifier].close() del callbacks[identifier] job.args = (msg, ) # wait 2s that the throw event transaction has committed dc = DelayedCallback(job, 2000) dc.start() ctx = get_zmq_context() s = ctx.socket(zmq.SUB) s.setsockopt_string(zmq.SUBSCRIBE, u'') s.connect(get_signal_socket_url()) stream = ZMQStream(s) callbacks[identifier] = stream stream.on_recv(execute_next)
def __init__(self, broker, service, io_loop=None): """Create and setup an MDP worker. @param broker A string containing the broker's URL @param service A string containing the service name @param io_loop An existing I/O loop object. If None, the default will be used. """ self.service=service self._broker = broker self.ctx = zmq.Context() sock = self.ctx.socket(zmq.DEALER) ZMQStream.__init__(self, sock, io_loop) # last watchdog timer tick self.watchdog = 0 # connection callback one-shot self._conncb = DelayedCallback(self.send_ready, 3000, self.io_loop) # heartbeat callback..runs continuous when connected self._hbcb = PeriodicCallback(self.send_heartbeat, 2000, self.io_loop) # number of connection attempts self._conn_attempt = 0 # waiting to connect state self._waiting_to_connect = True # have we been disconnected? (flags a reconnect attempt) self.disconnected = False # connect the socket and send a READY when the io_loop starts self.connect(self._broker) self._conncb.start()
def __init__(self, frontier, data_in_sock='ipc:///tmp/robot-data-w2m.sock', data_out_sock='ipc:///tmp/robot-data-m2w.sock', msg_in_sock='ipc:///tmp/robot-msg-w2m.sock', msg_out_sock='ipc:///tmp/robot-msg-m2w.sock', io_loop=None): self.identity = 'master:%s:%s' % (socket.gethostname(), os.getpid()) context = zmq.Context() self._io_loop = io_loop or IOLoop.instance() self._in_socket = context.socket(zmq.SUB) self._in_socket.setsockopt(zmq.SUBSCRIBE, '') self._in_socket.bind(data_in_sock) self._in_stream = ZMQStream(self._in_socket, io_loop) self._out_socket = context.socket(zmq.PUSH) self._out_socket.bind(data_out_sock) self._out_stream = ZMQStream(self._out_socket, io_loop) self._online_workers = set() self._running = False self._updater = PeriodicCallback(self._send_next, 100, io_loop=io_loop) self._reloader = PeriodicCallback(self.reload, 1000, io_loop=io_loop) self.frontier = frontier self.messenger = ServerMessenger(msg_in_sock, msg_out_sock, context, io_loop)
def connect_stream(self, sname, zmq_channel): socket = self.context.socket(zmq_channel.socket_type) if zmq_channel.bind: socket.bind(zmq_channel.endpoint) if zmq_channel.socket_type == zmq.SUB: # Workaround for https://zeromq.jira.com/browse/LIBZMQ-270 socket.getsockopt(zmq.EVENTS) else: socket.connect(zmq_channel.endpoint) if zmq_channel.socket_type == zmq.SUB and zmq_channel.subscription: for prefix in zmq_channel.subscription: socket.setsockopt(zmq.SUBSCRIBE, prefix.encode('utf8')) stream = ZMQStream(socket, io_loop=self.loop) stream.channel_name = sname # Wire up any defined handlers self.init_recv(sname, stream) tname = SOCKET_TYPES[zmq_channel.socket_type] ctype = 'Bound' if zmq_channel.bind else 'Connected' self.logger.debug("%s %s stream to address %s", ctype, tname, zmq_channel.endpoint) self.streams[sname] = stream
def __init__(self, context, main_ep, opt_ep=None): """Init MDPBroker instance. """ l = logger.Logger('mq_broker') self.log = l.get_logger() self.log.info("MDP broker startup...") socket = ZmqSocket(context, zmq.ROUTER) socket.bind(main_ep) self.main_stream = ZMQStream(socket) self.main_stream.on_recv(self.on_message) if opt_ep: socket = ZmqSocket(context, zmq.ROUTER) socket.bind(opt_ep) self.client_stream = ZMQStream(socket) self.client_stream.on_recv(self.on_message) else: self.client_stream = self.main_stream self.log.debug("Socket created...") self._workers = {} # services contain the worker queue and the request queue self._services = {} self._worker_cmds = { b'\x01': self.on_ready, b'\x03': self.on_reply, b'\x04': self.on_heartbeat, b'\x05': self.on_disconnect, } self.log.debug("Launch the timer...") self.hb_check_timer = PeriodicCallback(self.on_timer, HB_INTERVAL) self.hb_check_timer.start() self.log.info("MDP broker started") return
class SocketConnection(sockjs.tornado.SockJSConnection): clients = set() def on_open(self, request): self.clients.add(self) subscriber = context.socket(zmq.SUB) subscriber.connect("tcp://localhost:%s" % str(ZMQ_PORT)) subscriber.setsockopt(zmq.SUBSCRIBE, '') self.subscribe_stream = ZMQStream(subscriber) self.subscribe_stream.on_recv(self.on_message_published) def on_message(self, message): logging.info( 'message received, publish it to %d clients' % len(self.clients) ) publish_stream.send_unicode(message) def on_message_published(self, message): logging.info('client received new published message') self.send(message) def on_close(self): self.clients.remove(self) # Properly close ZMQ socket self.subscribe_stream.close()
class DevPort(object): def __init__(self, card, depth, rate): self.card = card self.depth = depth self.rate = rate self.running = False context = zmq.Context() self.prog_socket = context.socket(zmq.PUB) self.prog_socket.connect('ipc:///tmp/progressIn.ipc') self.prog_stream = ZMQStream(self.prog_socket, IOLoop.instance()) self.scheduleProgress() self.peak_socket = context.socket(zmq.PUB) self.peak_socket.bind('ipc:///tmp/peaks.ipc') self.peak_stream = ZMQStream(self.peak_socket, IOLoop.instance()) self.sendPeaks() def startRecording(self, path): self.curPath = path self.started = time() self.running = True def stopRecording(self): self.running = False def resetPeaks(self): pass def stop(self): self.stopRecording() def waitTillFinished(self): pass def gotSignal(self): return True def sendProgress(self): duration = 0 mode = 0 if self.running: duration = int((time() - self.started) * self.rate) mode = 1 d = {'t':duration, 'm': mode, 'b' : 0 } s = json.dumps(d) self.prog_stream.send(s) IOLoop.instance().add_timeout(time() + .333, self.sendProgress) def sendPeaks(self): l = [-140, -140, -140, -140] self.peak_stream.send(json.dumps(l)) IOLoop.instance().add_timeout(time() + .1, self.sendPeaks) def scheduleProgress(self): IOLoop.instance().add_timeout(time() + .333, self.sendProgress)
def connect(self): if self.connected: return self.socket = ctx.socket(zmq.SUBSCRIBE) self.socket.connect(self.socket_addr) stream = ZMQStream(self.socket, self.io_loop) stream.on_recv(self.on_message) self.connected = True
def call(self, message, callback): context = zmq.Context() socket = context.socket(zmq.DEALER) socket.connect(self.endpoint) stream = ZMQStream(socket) stream.on_recv(callback) socket.send(message)
class SubQueue(BaseQueue): def __init__(self, connect, callback, ioloop=None): super().__init__(zmq.PULL) self.socket.connect(connect) self.stream = ZMQStream(self.socket, ioloop) self.stream.on_recv(callback) self.stream.flush()
def start(self): loop = self.loop loop.add_handler(self.udp.handle.fileno(), self.handle_beacon, loop.READ) stream = ZMQStream(self.pipe, loop) stream.on_recv(self.control_message) pc = PeriodicCallback(self.send_ping, PING_INTERVAL * 1000, loop) pc.start() pc = PeriodicCallback(self.reap_peers, PING_INTERVAL * 1000, loop) pc.start() pc = PeriodicCallback(self.send_ports, PING_INTERVAL * 1000, loop) pc.start() loop.start()
def _start_broker(self, do_reply=False): """Helper activating a fake broker in the ioloop. """ socket = self.context.socket(zmq.XREP) self.broker = ZMQStream(socket) self.broker.socket.setsockopt(zmq.LINGER, 0) self.broker.bind(self.endpoint) self.broker.on_recv(self._on_msg) self.broker.do_reply = do_reply self.broker.ticker = PeriodicCallback(self._tick, MyWorker.HB_INTERVAL) self.broker.ticker.start() self.target = None return
class ReplyQueue(BaseQueue): def __init__(self, bind, callback, ioloop=None): super().__init__(zmq.REP) self.socket.bind(bind) self.socket.SNDTIMEO = 1000 self.socket.RCVTIMEO = 1000 self.stream = ZMQStream(self.socket, ioloop) self.stream.on_recv(callback) self.stream.flush() def __getattr__(self, name): return getattr(self.stream, name)
def _create_stream(self): """Helper to create the socket and the stream. """ socket = self.context.socket(zmq.DEALER) ioloop = IOLoop.instance() self.stream = ZMQStream(socket, ioloop) self.stream.on_recv(self._on_message) self.stream.socket.setsockopt(zmq.LINGER, 0) self.stream.connect(self.endpoint) self.ticker = PeriodicCallback(self._tick, self.HB_INTERVAL) self._send_ready() self.ticker.start() return
def connect(self, stream): self.context = zmq.Context() self.subscriber = self.context.socket(zmq.SUB) # self.subscriber.setsockopt(zmq.RCVHWM, 1) # self.subscriber.setsockopt(zmq.RCVBUF, 1*1024) self.subscriber.setsockopt(zmq.LINGER, 0) self.subscriber.connect(stream) self.subscriber = ZMQStream(self.subscriber) self.subscriber.on_recv(self.callback, copy=False) # self.request.linger = 0 self.subscriber.setsockopt(zmq.SUBSCRIBE, b"") self.subscriber.setsockopt(zmq.SUBSCRIBE, self.name.encode('ascii'))
class ZMQSubscriber(object): """ This class represents a subscriber socket connecting to a ZMQ Service. """ clients = set() stream = None def __init__(self, url, topics=None): self.url = url self.topics = topics def setup(self): """ Setup the subscriber connection on first use. """ print "Connecting to publisher: %s" % self.url ctxt = zmq.Context() subscriber = ctxt.socket(zmq.SUB) subscriber.connect(self.url) if self.topics: for topic in self.topics: subscriber.setsockopt(zmq.SUBSCRIBE, topic) else: subscriber.setsockopt(zmq.SUBSCRIBE, '') self.stream = ZMQStream(subscriber) self.stream.on_recv(self.on_recv_sub) def add(self, client): """ Add a new participant, setup on first access. """ if self.stream is None: self.setup() self.clients.add(client) def remove(self, client): """ Remove a participant, possibly disconnect when empty. """ self.clients.remove(client) if len(self.clients) == 0: print "Possibly close connection." def on_recv_sub(self, message): """ Send the message to all clients connected. """ print "Got a message:", message for conn in self.clients: conn.broadcast(self.clients, message) break
class MultiplexPubSub(object): def __init__(self): self.callbacks = set() def add_callback(self, callback): self.callbacks.add(callback) def remove_callback(self, callback): self.callbacks.remove(callback) @tornado.gen.coroutine def on_recv(self, data): data[2] = json.loads(data[2]) if data[2] == 1: data[2] = {"value": data[3]} if not "timestamp" in data[2]: data[2]['timestamp'] = time.time() # print("callback:",data,self.callbacks) for callback in self.callbacks: try: callback(data) except WebSocketClosedError: print("Closed by WebSocketClosedError!") self.callbacks.remove(callback) data.on_close() def connect(self): self.context = zmq.Context() self.socket = self.context.socket(zmq.SUB) self.socket.connect('tcp://house-nas:10900') self.send_socket = self.context.socket(zmq.PUB) self.send_socket.connect('tcp://house-nas:10901') print("socket connect:", self.socket, self.on_recv) self.stream = ZMQStream(self.socket) self.stream.on_recv(self.on_recv) def send(self, data): self.send_socket.send_multipart([str(i) for i in json.loads(data)]) def subscribe(self, channel_id): print("subscribe:", channel_id) self.socket.setsockopt(zmq.SUBSCRIBE, channel_id) def close(self): self.stream.close() print self.socket.close()
def __init__(self, root_dir): """Инициализирует uwsgi-emperor. :param root_dir: Полный путь к корневой директории uwsgi-emperor :type root_dir: str """ self.__root_dir__ = root_dir if not os.path.exists(self.vassal_dir): log_message("Vassal directory does not exist, creating one", component="Emperor") os.mkdir(self.vassal_dir) emperor_pid = 0 if os.path.exists(self.pidfile): with open(self.pidfile) as pid_file: try: emperor_pid = int(pid_file.read()) psutil.Process(emperor_pid) log_message("Found running emperor server", component="Emperor") except (ValueError, psutil.NoSuchProcess): os.remove(self.pidfile) if not emperor_pid: emperor = subprocess.Popen([ self.uwsgi_binary, "--plugins-dir", self.binary_dir, "--emperor", self.vassal_dir, "--pidfile", self.pidfile, "--logger", "zeromq:tcp://127.0.0.1:5123", "--daemonize", "/dev/null", "--emperor-stats", "127.0.0.1:1777", "--emperor-required-heartbeat", "40", "--emperor-throttle", "10000", "--vassal-set", "plugins-dir={}".format( self.binary_dir) ], bufsize=1, close_fds=True) code = emperor.wait() assert code == 0, "Error starting emperor server" log_message("Started emperor server", component="Emperor") self.vassals = {} ctx = zmq.Context() s = ctx.socket(zmq.PULL) s.bind('tcp://127.0.0.1:5123') self.stream = ZMQStream(s) self.stream.on_recv(self.log_message)
def run(self): self.context = zmq.Context() self.socket = self.context.socket(zmq.DEALER) self.socket.connect(self.controller_uri) self.stream = ZMQStream(self.socket) self.stream.on_recv(self.on_rcv) self.ioloop = ioloop.IOLoop.instance() self.ioloop.add_callback(self.on_start) tornado.ioloop.PeriodicCallback(self.on_ping, 1000).start() try: self.ioloop.start() except KeyboardInterrupt: self.shutdown() self.ioloop.close()
def open(self): stream = None try: context = zmq.Context() socket = context.socket(zmq.SUB) socket.connect(self.addr) socket.setsockopt(zmq.SUBSCRIBE, '') stream = ZMQStream(socket) except Exception, err: exc_type, exc_value, exc_traceback = sys.exc_info() print 'ZMQStreamHandler ERROR getting ZMQ stream:', err traceback.print_exception(exc_type, exc_value, exc_traceback) if stream and not stream.closed(): stream.close()
class WebSocketZMQBridgeHandler(websocket.WebSocketHandler): def open(self, *args, **kwargs): self.currentMessage = [] self.__endpoint = 'tcp://localhost:224' socket = zmq.Context().socket(zmq.DEALER) self.__stream = ZMQStream(socket, IOLoop.current()) self.__stream.on_recv(self.__onReceive) self.__stream.socket.setsockopt(zmq.LINGER, 0) self.__stream.connect(self.__endpoint) def on_close(self, *args, **kwargs): self.__stream.close() def on_message(self, message): hasMore = message[0] self.currentMessage.append(message[1:]) if not hasMore: sendingMessage = self.currentMessage self.currentMessage = [] self.__stream.send_multipart(sendingMessage) def __onReceive(self, msg): for frame in msg[:-1]: self.write_message(b'\x01' + frame, binary=True) self.write_message(b'\x00' + msg[-1], binary=True)
def setupZmqSubscriber(): ctx = zmq.Context() s = ctx.socket(zmq.SUB) s.connect('tcp://127.0.0.1:5000') s.setsockopt(zmq.SUBSCRIBE, "") stream = ZMQStream(s) def echo(product): print "receiving message: %s" % product for socket in socket_connections: socket.write_message(product[0]) stream.on_recv(echo)
def __init__(self, endpoint): self.endpoint = endpoint # init zeromq self.context = zmq.Context() self.socket = self.context.socket(zmq.REQ) self.stream = ZMQStream(self.socket) self.stream.on_recv(self.OnRecvMsg) # get local endpoint self.socket.bind("tcp://eth0:*") self.local_endpoint = str(self.socket.getsockopt(zmq.LAST_ENDPOINT)) print "Local endpoint [%s]" % self.local_endpoint # connect to target self.socket.connect(endpoint) print "Connected to [%s]" % endpoint
def on_open(self, info): self.prog_socket = context.socket(zmq.SUB) self.prog_socket.connect('ipc:///tmp/progressOut.ipc') self.prog_socket.setsockopt(zmq.SUBSCRIBE, '') self.prog_stream = ZMQStream(self.prog_socket, tornado.ioloop.IOLoop.instance()) self.prog_stream.on_recv(self.process_prog) self.peak_socket = context.socket(zmq.SUB) self.peak_socket.connect('ipc:///tmp/peaks.ipc') self.peak_socket.setsockopt(zmq.SUBSCRIBE, '') self.peak_stream = ZMQStream(self.peak_socket, tornado.ioloop.IOLoop.instance()) self.peak_stream.on_recv(self.process_peaks)
def _init_data_handler(self): """ Initialize data port handler. """ # Set the linger period to prevent hanging on unsent # messages when shutting down: self.logger.info('initializing data handler') self.sock_data = self.zmq_ctx.socket(zmq.ROUTER) self.sock_data.setsockopt(zmq.LINGER, LINGER_TIME) self.sock_data.bind("tcp://*:%i" % self.port_data) self.stream_data = ZMQStream(self.sock_data, self.ioloop) self.stream_data.on_recv(self._data_handler)
class ZMQDownlinkConnector: def __init__(self, connect_addr): self._zmq_sub_socket = zmq.Context.instance().socket(zmq.SUB) self._zmq_sub_socket.setsockopt(zmq.RCVHWM, 0) self._zmq_sub_socket.connect(connect_addr) self._zmq_sub_stream = ZMQStream(self._zmq_sub_socket) self._zmq_sub_socket.setsockopt_string( zmq.SUBSCRIBE, '') # Subscribing to every message def register_callback(self, callback): self._zmq_sub_stream.on_recv(callback) def close(self): self._zmq_sub_stream.close()
def __init__(self): self.ctx = zmq.Context() self.loop = IOLoop.instance() self.client = self.ctx.socket(zmq.DEALER) if self.crypto: self.keymonkey = KeyMonkey("client") self.client = self.keymonkey.setupClient(self.client, self.endpoint, "server") self.client.connect(self.endpoint) print("Connecting to", self.endpoint) self.client = ZMQStream(self.client) self.client.on_recv(self.on_recv) self.periodic = PeriodicCallback(self.periodictask, 1000) self.last_recv = None
def main(): print("Websocket Server Process ID: ", os.getpid()) print("Local IP Address: ", env_config.get_self_ip()) print("Now env_config SELF_IP is: ", env_config.SELF_IP) env_config.config_leds() print("Upper Pane: ", env_config.WIN_UPPER_PANE) print("Display type (0 = LEDs, 1 = DMX/Relays): ", env_config.PI_DISPLAY_TYPE) # set up Zero MQ connection to Flask server flask_context = zmq.Context() socket = flask_context.socket(zmq.PAIR) print("Binding to port 62830") #socket.bind("tcp://127.0.0.1:62830") socket.bind(env_config.ZMQ_SOCKET_IP + ":" + env_config.ZMQ_SOCKET_PORT) # set up multiprocessing pipes ws_ledp_conn, ledp_conn = multiprocessing.Pipe() if not env_config.PI_DISPLAY_TYPE: # initialize fadecandy led control class led_controller = fc.LEDController() else: # initialize dmx light control class led_controller = dmx.LEDController() # get new process ledp = multiprocessing.Process(target=led_controller.run, args=[ledp_conn]) # message callback flask_stream = ZMQStream(socket) flask_stream.on_recv(partial(process_zmq_message, conn=ws_ledp_conn), copy=True) ledp.start() # start led controller process # create websocket listener websocket_listener = tornado.web.Application([ (r"/ledctrl", WebSocketHandler, dict(ledp=ledp, conn=ws_ledp_conn)) ]) # # listen to websocket indefinitely # websocket_listener.listen(31415) websocket_listener.listen(env_config.TORNADO_PORT) tornado.ioloop.IOLoop.current().start()
def __init__(self, primary=True, ports=(5556, 5566)): self.primary = primary if primary: self.port, self.peer = ports frontend = "tcp://*:5003" backend = "tcp://localhost:5004" self.kvmap = {} else: self.peer, self.port = ports frontend = "tcp://*:5004" backend = "tcp://localhost:5003" self.ctx = zmq.Context.instance() self.pending = [] self.bstar = BinaryStar(primary, frontend, backend) self.bstar.register_voter("tcp://*:%i" % self.port, zmq.ROUTER, self.handle_snapshot) # Set up our clone server sockets self.publisher = self.ctx.socket(zmq.PUB) self.collector = self.ctx.socket(zmq.SUB) self.collector.setsockopt(zmq.SUBSCRIBE, b'') self.publisher.bind("tcp://*:%d" % (self.port + 1)) self.collector.bind("tcp://*:%d" % (self.port + 2)) # Set up our own clone client interface to peer self.subscriber = self.ctx.socket(zmq.SUB) self.subscriber.setsockopt(zmq.SUBSCRIBE, b'') self.subscriber.connect("tcp://localhost:%d" % (self.peer + 1)) # Register state change handlers self.bstar.master_callback = self.become_master self.bstar.slave_callback = self.become_slave # Wrap sockets in ZMQStreams for IOLoop handlers self.publisher = ZMQStream(self.publisher) self.subscriber = ZMQStream(self.subscriber) self.collector = ZMQStream(self.collector) # Register our handlers with reactor self.collector.on_recv(self.handle_collect) self.flush_callback = PeriodicCallback(self.flush_ttl, 1000) self.hugz_callback = PeriodicCallback(self.send_hugz, 1000) # basic log formatting: logging.basicConfig(format="%(asctime)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=logging.INFO)
class AnsibleKernelHelpersThread(object): def __init__(self, queue): self.queue = queue self.io_loop = IOLoop(make_current=False) context = zmq.Context.instance() self.pause_socket = context.socket(zmq.REP) self.pause_socket_port = self.pause_socket.bind_to_random_port( "tcp://127.0.0.1") self.status_socket = context.socket(zmq.PULL) self.status_socket_port = self.status_socket.bind_to_random_port( "tcp://127.0.0.1") self.pause_stream = ZMQStream(self.pause_socket, self.io_loop) self.status_stream = ZMQStream(self.status_socket, self.io_loop) self.pause_stream.on_recv(self.recv_pause) self.status_stream.on_recv(self.recv_status) self.thread = threading.Thread(target=self._thread_main) self.thread.daemon = True def start(self): logger.info('thread.start') self.thread.start() atexit.register(self.stop) def stop(self): logger.info('thread.stop start') if not self.thread.is_alive(): return self.io_loop.add_callback(self.io_loop.stop) self.thread.join() logger.info('thread.stop end') def recv_status(self, msg): logger = logging.getLogger('ansible_kernel.kernel.recv_status') logger.info(msg) self.queue.put(StatusMessage(json.loads(msg[0]))) def recv_pause(self, msg): logger = logging.getLogger('ansible_kernel.kernel.recv_pause') logger.info("completed %s waiting...", msg) self.queue.put(TaskCompletionMessage(json.loads(msg[0]))) def _thread_main(self): """The inner loop that's actually run in a thread""" self.io_loop.make_current() self.io_loop.start() self.io_loop.close(all_fds=True)
def set_resource(self, tree): """Set a resource on our JID""" bind_element = tree[0] if tree.get("type") != "set" or \ bind_element.tag != 'bind' or\ bind_element.get("xmlns") != BIND_NS: raise NotAuthorizedError resource_element = bind_element.find("resource") if resource_element is None: # No prefered resource was set, generate one self.jid.resource = uuid.uuid4().hex else: self.jid.resource = resource_element.text if not self.jid.validate(): raise BadRequestError # Check if given resource is already in use known_jids = get_known_jids() try: known_jids.append(self.jid) except ValueError: raise ConflictError log.info("Bound connection as %s" % str(self.jid)) # Connect to forwarder to receive stanzas sent back to client log.debug('Registering Client at forwarder..') self.pull_socket = zmq.Context().socket(zmq.PULL) self.processed_stream = ZMQStream(self.pull_socket, self.connection.stream.io_loop) self.processed_stream.on_recv(self.masked_send_list, False) port = self.pull_socket.bind_to_random_port('tcp://127.0.0.1') self.pull_url = 'tcp://127.0.0.1:' + str(port) reg_msg = ZMQForwarder_message('REGISTER') reg_msg.attributes = (config.get('ipc', 'password'), self.pull_url, self.jid) self.publisher.send_pyobj(reg_msg) # Send registered resource back to client response_element = ET.Element("iq") response_element.set("type", "result") response_element.set("id", tree.get("id")) bind_element = ET.SubElement(response_element, "bind") bind_element.set("xmlns", BIND_NS) jid_element = ET.SubElement(bind_element, "jid") jid_element.text = str(self.jid) self.send_element(response_element)
class Subscriber(object): u""" 本地订阅者 订阅topic匹配关系 订阅 ehr:api:1 匹配消息 'ehr', 'ehr:api', 'ehr:api:1' 实现直连推送,或者广播 """ def __init__(self, callback): self.callback = callback self.topic = '' self.sock = context.socket(zmq.SUB) self.sock.connect('inproc:///tmp/hub_{}'.format(pid)) self.stream = ZMQStream(self.sock) self.stream.on_recv(self.recv) def subscribe(self, topic): if not isinstance(topic, basestring) or not topic: return self.topic = topic self.sock.setsockopt(zmq.SUBSCRIBE, str(topic.split(':')[0])) def unsubscribe(self): if self.topic: self.sock.setsockopt(zmq.UNSUBSCRIBE, str(self.topic.split(':')[0])) self.topic = '' def recv(self, msg): _, body = msg try: data = json.loads(body) topic = data.get('topic', '') if not topic: return if re.match(r'^{}(:.+)?$'.format(topic), self.topic): self.callback(body) except: pass def close(self): self.topic = None self.callback = None self.stream.close()
class DeviceApp(object): # endpoint = "tcp://127.0.0.1:5556" # endpoint = "tcp://localhost:5556" endpoint = "tcp://165.227.24.226:5556" def __init__(self): self.ctx = zmq.Context() self.loop = IOLoop.instance() self.client = self.ctx.socket(zmq.DEALER) self.client.connect(self.endpoint) print("Connecting to", self.endpoint) self.client = ZMQStream(self.client) self.client.on_recv(self.on_recv) self.periodic = PeriodicCallback(self.periodictask, 1000) self.last_recv = None def periodictask(self): if not (self.last_recv) or (self.last_recv + timedelta(seconds=5)) < datetime.utcnow(): print( "Hmmm... haven't heard from the server in 5 seconds... Server unresponsive." ) print("Sending HELLO to server") msg = HelloMessage() print("msg=", msg) msg.send(self.client) def start(self): self.periodic.start() try: self.loop.start() except KeyboardInterrupt: pass def on_recv(self, msg): self.last_recv = datetime.utcnow() print("Received a message of type %s from server!" % msg[0])
def setupZmqSubscriber(address): ctx = zmq.Context() s = ctx.socket(zmq.SUB) s.connect(address) s.setsockopt(zmq.SUBSCRIBE, "") stream = ZMQStream(s) def echo(msg): print "receiving message: %s" % msg #stream.send_multipart(msg) for socket in socket_connections: socket.write_message(msg[0] + '\r\n\r\n') stream.on_recv(echo)
def _setup_streams(self): """ Setup ZMQ streams. These need to be constructed within the right active event loop, i.e. this must run in the background thread. """ assert threading.current_thread() is self.thread assert self.loop from zmq.eventloop.zmqstream import ZMQStream with self._condition: self._shell_stream = ZMQStream(self._shell_socket, io_loop=self.loop) self._control_stream = ZMQStream(self._control_socket, io_loop=self.loop) self._condition.notify_all()
def start(self): """ Initialize the zmq sockets on a ioloop stream. The separation of this part from the init is useful if we start the client on a separate thread with a new ioloop (for example to enable use in an ipython notebook) """ socket = self.context.socket(zmq.DEALER) ioloop = IOLoop.instance() self.stream = ZMQStream(socket, ioloop) self.stream.on_recv(self._on_message) self._proto_prefix = [EMPTY_FRAME, self._proto_version] self._delayed_timeout = None self.timed_out = False socket.connect(self.endpoint)
def setup(self): """ Setup the subscriber connection on first use. """ print "Connecting to publisher: %s" % self.url ctxt = zmq.Context() subscriber = ctxt.socket(zmq.SUB) subscriber.connect(self.url) if self.topics: for topic in self.topics: subscriber.setsockopt(zmq.SUBSCRIBE, topic) else: subscriber.setsockopt(zmq.SUBSCRIBE, '') self.stream = ZMQStream(subscriber) self.stream.on_recv(self.on_recv_sub)
def _init_ctrl_handler(self): """ Initialize control port handler. """ # Set the linger period to prevent hanging on unsent messages # when shutting down: self.logger.info('initializing ctrl handler') self.sock_ctrl = self.zmq_ctx.socket(zmq.DEALER) self.sock_ctrl.setsockopt(zmq.IDENTITY, self.id) self.sock_ctrl.setsockopt(zmq.LINGER, LINGER_TIME) self.sock_ctrl.connect('tcp://localhost:%i' % self.port_ctrl) self.stream_ctrl = ZMQStream(self.sock_ctrl, self.ioloop_ctrl) self.stream_ctrl.on_recv(self._ctrl_handler)
def __init__(self, game_id=b'0', port=5556): self.GID = game_id self.port = port self.ctx = zmq.Context() self.loop = IOLoop.instance() self.client_input_sock = self.ctx.socket(zmq.PULL) self.client_pub_sock = self.ctx.socket(zmq.PUB) self.command_enqueue, self.command_dequeue = zpipe(self.ctx, 1000) self.client_input_sock.bind("tcp://*:%d" % self.port) self.client_pub_sock.bind("tcp://*:%d" % (self.port + 1)) self.client_input_sock = ZMQStream(self.client_input_sock) self.client_input_sock.on_recv(self.handle_input)
def __init__(self, context, endpoint, service): """Initialize the MDPClient. """ socket = context.socket(zmq.REQ) ioloop = IOLoop.instance() self.service = service self.endpoint = endpoint self.stream = ZMQStream(socket, ioloop) self.stream.on_recv(self._on_message) self.can_send = True self._proto_prefix = [PROTO_VERSION, service] self._tmo = None self.timed_out = False socket.connect(endpoint) return