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