Python ZMQStream.on_recv方法代码示例

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
class Client(object):
    def __init__(self):
        self.stream = None
        self.result = None

    def connect(self, port):
        context = zmq.Context()
        socket = context.socket(zmq.REQ)
        socket.connect(port)
        self.stream = ZMQStream(socket)

    def __getattr__(self, item):
        def wrapper(*args):
            request = [item]
            for param in args:
                request.append(param)
            return self._run(tuple(request))
        return wrapper

    def _run(self, request):
        def on_response(message):
            response = msgpack.unpackb(message[0], use_list=False)
            if response[0] == 'OK':
                self.result = response[1]
            elif response[0] == 'ERR':
                raise Exception(response[2])
            ZMQIOLoop.instance().stop()

        self.stream.send(msgpack.packb(request))
        self.stream.on_recv(on_response)
        ZMQIOLoop.instance().start()
        return self.result

    def disconnect(self):
        self.stream.close()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
    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)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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:]))

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
    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)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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)

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [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

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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()

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [as 别名]
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

# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import on_recv [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())