本文整理汇总了Python中zmq.eventloop.zmqstream.ZMQStream.on_recv方法的典型用法代码示例。如果您正苦于以下问题:Python ZMQStream.on_recv方法的具体用法?Python ZMQStream.on_recv怎么用?Python ZMQStream.on_recv使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类zmq.eventloop.zmqstream.ZMQStream
的用法示例。
在下文中一共展示了ZMQStream.on_recv方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: InternalRouter
# 需要导入模块: 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
示例2: SocketConnection
# 需要导入模块: 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()
示例3: Run
# 需要导入模块: 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()
示例4: MonitorEvents
# 需要导入模块: 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()
示例5: SwysSearchRequestHandler
# 需要导入模块: 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)
示例6: Client
# 需要导入模块: 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()
示例7: SoundServer
# 需要导入模块: 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
示例8: enable_depth_frames
# 需要导入模块: 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)
示例9: UartzStream
# 需要导入模块: 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:]))
示例10: start
# 需要导入模块: 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)
示例11: ZBus
# 需要导入模块: 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)
示例12: Subscriber
# 需要导入模块: 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
示例13: main
# 需要导入模块: 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()
示例14: Connection
# 需要导入模块: 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
示例15: Broker
# 需要导入模块: 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())