本文整理汇总了Python中zmq.eventloop.zmqstream.ZMQStream.send_multipart方法的典型用法代码示例。如果您正苦于以下问题:Python ZMQStream.send_multipart方法的具体用法?Python ZMQStream.send_multipart怎么用?Python ZMQStream.send_multipart使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类zmq.eventloop.zmqstream.ZMQStream
的用法示例。
在下文中一共展示了ZMQStream.send_multipart方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: ZBus
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [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)
示例2: Publisher
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class Publisher(object):
def __init__(self, context, pub_endpoint):
self.context = context
self.pub_endpoint = pub_endpoint
socket = self.context.socket(zmq.PUB)
ioloop = IOLoop.instance()
self.publisher = ZMQStream(socket, ioloop)
self.publisher.socket.setsockopt(zmq.LINGER, 0)
self.publisher.bind(self.pub_endpoint)
return
def shutdown(self):
self.publisher.socket.unbind(self.pub_endpoint)
self.publisher.socket.close()
self.publisher.close()
self.publisher = None
return
def send(self, msg):
logger.debug("Publisher sending: {0}".format(msg))
self.publisher.send_multipart(msg)
return
示例3: DeviceServicePublisher
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class DeviceServicePublisher(object):
def __init__(self, context, publisher_endpoint):
self.context = context
self.publisher_endpoint = publisher_endpoint
socket = self.context.socket(zmq.PUB)
ioloop = IOLoop.instance()
self.publisher = ZMQStream(socket, ioloop)
self.publisher.socket.setsockopt(zmq.LINGER, 0)
self.publisher.bind(self.publisher_endpoint)
return
def shutdown(self):
self.publisher.socket.close()
self.publisher.close()
self.publisher = None
return
def send(self, msg, topic='all'):
pub_msg = []
pub_msg.append(topic)
pub_msg.append(msg)
self.publisher.send_multipart(pub_msg)
return
示例4: TheWorker
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class TheWorker(object):
def __init__(self, context):
#context = zmq.Context(1)
self.frontend = ZMQStream(worker_socket(context))
self.frontend.on_recv(self.handle_frontend)
self.liveness = HEARTBEAT_LIVENESS
self.heartbeat = HEARTBEAT_INTERVAL
self.interval = INTERVAL_INIT
self.loop = IOLoop.instance()
self.time = self.interval * self.heartbeat
self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS
self.callback = None
self.timed_out = False
self.start()
def start(self):
self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
# try:
# IOLoop.instance().start()
# except KeyboardInterrupt:
# times_str('ctrlc')
def send_heartbeat(self):
if time.time() > self.heartbeat_at:
self.time *= 2 if self.time < INTERVAL_MAX else 1
times_str('W: Timed out.. Retrying in {} seconds..'.format(self.time))
self.callback = self.loop.add_timeout(time.time()+self.time*1, self.send_heartbeat)
self.timed_out = True
return
times_str('W: Sending Heartbeat..')
self.frontend.send(PPP_HEARTBEAT)
self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
def handle_frontend(self,msg):
m = msg[:]
if len(m) == 1:
times_str('W: Received Heartbeat')
if self.timed_out:
self.loop.add_timeout(time.time()+self.heartbeat, self.send_heartbeat)
self.timed_out = False
self.loop.remove_timeout(self.callback)
self.time = self.interval * self.heartbeat
elif len(m) == 3:
times_str('Received: '+str(m))
time.sleep(10)
times_str('Sending it back..')
self.frontend.send_multipart(m)
self.heartbeat_at = time.time() + self.heartbeat * HEARTBEAT_LIVENESS
示例5: test_that_creating_mgmt_works
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
def test_that_creating_mgmt_works(self):
ctx = zmq.Context()
io_loop = IOLoop.instance()
def stop_looping(_msg):
io_loop.stop()
settings = Settings()
settings.ZEROMQ_MASTER_PUSH = 'inproc://spyder-zmq-master-push'
settings.ZEROMQ_WORKER_PROC_FETCHER_PULL = \
settings.ZEROMQ_MASTER_PUSH
settings.ZEROMQ_MASTER_SUB = 'inproc://spyder-zmq-master-sub'
settings.ZEROMQ_WORKER_PROC_EXTRACTOR_PUB = \
settings.ZEROMQ_MASTER_SUB
settings.ZEROMQ_MGMT_MASTER = 'inproc://spyder-zmq-mgmt-master'
settings.ZEROMQ_MGMT_WORKER = 'inproc://spyder-zmq-mgmt-worker'
pubsocket = ctx.socket(zmq.PUB)
pubsocket.bind(settings.ZEROMQ_MGMT_MASTER)
pub_stream = ZMQStream(pubsocket, io_loop)
subsocket = ctx.socket(zmq.SUB)
subsocket.setsockopt(zmq.SUBSCRIBE, "")
subsocket.bind(settings.ZEROMQ_MGMT_WORKER)
sub_stream = ZMQStream(subsocket, io_loop)
mgmt = workerprocess.create_worker_management(settings, ctx, io_loop)
mgmt.add_callback(ZMQ_SPYDER_MGMT_WORKER, stop_looping)
mgmt.start()
def assert_quit_message(msg):
self.assertEqual(ZMQ_SPYDER_MGMT_WORKER_QUIT_ACK, msg.data)
sub_stream.on_recv(assert_quit_message)
death = MgmtMessage(topic=ZMQ_SPYDER_MGMT_WORKER,
data=ZMQ_SPYDER_MGMT_WORKER_QUIT)
pub_stream.send_multipart(death.serialize())
io_loop.start()
mgmt._out_stream.close()
mgmt._in_stream.close()
mgmt._publisher.close()
mgmt._subscriber.close()
pub_stream.close()
pubsocket.close()
sub_stream.close()
subsocket.close()
ctx.term()
示例6: _Messenger
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class _Messenger(object):
def __init__(self, in_sock, out_sock, context, io_loop=None):
self._context = context
self._io_loop = io_loop or IOLoop.instance()
self._create_socket(in_sock, out_sock)
self._in_stream = ZMQStream(self._in_socket, io_loop)
self._out_stream = ZMQStream(self._out_socket, io_loop)
self._callbacks = defaultdict(list)
def _create_socket(self, in_sock, out_sock):
raise NotImplementedError()
def start(self):
self._in_stream.on_recv(self._on_receive)
def stop(self):
self._in_stream.stop_on_recv()
# self._publish(CTRL_MSG_WORKER, None, CTRL_MSG_WORKER_QUIT_ACK)
#
def close(self):
self._in_stream.close()
self._in_socket.close()
self._out_stream.close()
self._out_socket.close()
def _on_receive(self, zmq_msg):
msg = CtrlMessage.deserialize(zmq_msg)
if msg.topic in self._callbacks:
for callback in self._callbacks[msg.topic]:
callback(msg)
# if msg.data == CTRL_MSG_WORKER_QUIT:
# self.stop()
def add_callback(self, topic, callback):
self._callbacks[topic].append(callback)
def remove_callback(self, topic, callback):
if topic in self._callbacks and callback in self._callbacks[topic]:
self._callbacks[topic].remove(callback)
def publish(self, topic, identity, data):
msg = CtrlMessage(topic, identity, data)
self._out_stream.send_multipart(msg.serialize())
示例7: LRUQueue
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class LRUQueue(object):
"""LRUQueue class using ZMQStream/IOLoop for event dispatching"""
def __init__(self, backend_socket, frontend_socket):
self.available_workers = 0
self.workers = []
self.client_nbr = NBR_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):
# Queue worker address for LRU routing
worker_addr, empty, client_addr = msg[:3]
assert self.available_workers < NBR_WORKERS
self.available_workers += 1
self.workers.append(worker_addr)
assert empty == b""
if client_addr != b"READY":
empty, reply = msg[3:]
assert empty == b""
self.frontend.send_multipart([client_addr, b'', reply])
self.client_nbr -= 1
if self.client_nbr == 0:
self.loop.add_timeout(time.time() + 1, self.loop.stop)
if self.available_workers == 1:
self.frontend.on_recv(self.handle_frontend)
def handle_frontend(self, msg):
client_addr, empty, request = msg
assert empty == b""
self.available_workers -= 1
worker_id = self.workers.pop()
self.backend.send_multipart([worker_id, b'', client_addr, b'', request])
if self.available_workers == 0:
self.frontend.stop_on_recv()
示例8: TornadoConnection
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class TornadoConnection(YakDBConnectionBase):
"""
A tornado IOLoop-based connection variant that uses a DEALER connection
with YakDB request IDs to support parallel requests without having to wait.
This class does not have special documentation. See YakDB.Connection for details
on function parameters. The purpose of this behaviour is to avoid having to update
duplicate content.
In addition to the YakDB.Connection arguments, simply supply a callback function.
It will be called with the result of the operation (or without parameter if the
operation has no result).
Also note that exception-based error reporting in this class
does not allow to backtrace the caller because the receipt handler
is called from the IO loop. This might be fixed in the future.
"""
def __init__(self, endpoints, context=None):
YakDBConnectionBase.__init__(self, context=context)
self.useDealerMode()
self.connect(endpoints)
self.requests = {} #Maps request ID to callback
self.nextRequestId = 0
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.__recvCallback)
def scan(self, tableNo, callback, startKey=None, endKey=None, limit=None, keyFilter=None, valueFilter=None, skip=0, invert=False, mapData=False):
requestId = self.__newRequest(callback, {"mapData": mapData})
msgParts = [""] + YakDBConnectionBase.buildScanRequest(self, tableNo, startKey, endKey, limit, keyFilter, valueFilter, skip, invert, requestId=requestId)
self.stream.send_multipart(msgParts)
def read(self, tableNo, keys, callback, mapKeys=False):
requestId = self.__newRequest(callback, {"keys": (keys if mapKeys else None), "mapKeys": mapKeys})
msgParts = [""] + YakDBConnectionBase.buildReadRequest(self, tableNo, keys, requestId)
self.stream.send_multipart(msgParts)
def __newRequest(self, callback, params={}):
"""Setup mapping for a new request. Returns the new request ID."""
self.nextRequestId += 1
self.requests[self.nextRequestId] = (callback, params)
return struct.pack("<I", self.nextRequestId)
def __recvCallback(self, msg):
#DEALER response contains empty delimiter!
if len(msg[0]) != 0:
print >>sys.stderr, "Received malformed message: ", msg
return
msg = msg[1:]
#Currently we don't check the response type
YakDBConnectionBase._checkHeaderFrame(msg)
#Struct unpack yields 1-element tuple!
headerFrame = msg[0]
assert(len(headerFrame) == 8) #4 bytes response + 4 bytes request ID
requestId = struct.unpack("<I", YakDBConnectionBase._extractRequestId(headerFrame))[0]
callback, params = self.requests[requestId]
#Postprocess, depending on request type.
responseType = headerFrame[2]
dataFrames = msg[1:]
if responseType == "\x13": #Scan
if params["mapData"]:
data = YakDBConnectionBase(dataFrames)
else:
data = YakDBConnectionBase._mapScanToTupleList(dataFrames)
elif responseType == "\x10": #Read
if params["mapKeys"]:
data = YakDBConnectionBase._mapReadKeyValues(params["keys"], dataFrames)
else:
data = dataFrames
else:
raise YakDBProtocolException("Received correct response, but cannot handle response code %d" % ord(responseType))
#Cleanup
del self.requests[requestId]
#Call original callback
callback(data)
示例9: MDPWorker
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class MDPWorker(object):
"""Class for the MDP worker side.
Thin encapsulation of a zmq.XREQ socket.
Provides a send method with optional timeout parameter.
Will use a timeout to indicate a broker failure.
"""
_proto_version = b'MDPW01'
# TODO: integrate that into API
HB_INTERVAL = 1000 # in milliseconds
HB_LIVENESS = 3 # HBs to miss before connection counts as dead
def __init__(self, context, endpoint, service):
"""Initialize the MDPWorker.
context is the zmq context to create the socket from.
service is a byte-string with the service name.
"""
self.context = context
self.endpoint = endpoint
self.service = service
self.stream = None
self._tmo = None
self.need_handshake = True
self.ticker = None
self._delayed_cb = None
self._create_stream()
return
def _create_stream(self):
"""Helper to create the socket and the stream.
"""
socket = self.context.socket(zmq.XREQ)
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 _send_ready(self):
"""Helper method to prepare and send the workers READY message.
"""
ready_msg = [ b'', self._proto_version, chr(1), self.service ]
self.stream.send_multipart(ready_msg)
self.curr_liveness = self.HB_LIVENESS
return
def _tick(self):
"""Method called every HB_INTERVAL milliseconds.
"""
self.curr_liveness -= 1
## print '%.3f tick - %d' % (time.time(), self.curr_liveness)
self.send_hb()
if self.curr_liveness >= 0:
return
print '%.3f lost connection' % time.time()
# ouch, connection seems to be dead
self.shutdown()
# try to recreate it
self._delayed_cb = DelayedCallback(self._create_stream, 5000)
self._delayed_cb.start()
return
def send_hb(self):
"""Construct and send HB message to broker.
"""
msg = [ b'', self._proto_version, chr(4) ]
self.stream.send_multipart(msg)
return
def shutdown(self):
"""Method to deactivate the worker connection completely.
Will delete the stream and the underlying socket.
"""
if self.ticker:
self.ticker.stop()
self.ticker = None
if not self.stream:
return
self.stream.socket.close()
self.stream.close()
self.stream = None
self.timed_out = False
self.need_handshake = True
self.connected = False
return
def reply(self, msg):
"""Send the given message.
msg can either be a byte-string or a list of byte-strings.
#.........这里部分代码省略.........
示例10: MDPBroker
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
#.........这里部分代码省略.........
:type wid: str
:rtype: None
"""
try:
wrep = self._workers[wid]
except KeyError:
# not registered, ignore
return
wrep.shutdown()
service = wrep.service
if service in self._services:
wq, wr = self._services[service]
wq.remove(wid)
del self._workers[wid]
return
def disconnect(self, wid):
"""Send disconnect command and unregister worker.
If the worker id is not registered, nothing happens.
:param wid: the worker id.
:type wid: str
:rtype: None
"""
try:
wrep = self._workers[wid]
except KeyError:
# not registered, ignore
return
to_send = [ wid, self.WORKER_PROTO, b'\x05' ]
self.main_stream.send_multipart(to_send)
self.unregister_worker(wid)
return
def client_response(self, rp, service, msg):
"""Package and send reply to client.
:param rp: return address stack
:type rp: list of str
:param service: name of service
:type service: str
:param msg: message parts
:type msg: list of str
:rtype: None
"""
to_send = rp[:]
to_send.extend([b'', self.CLIENT_PROTO, service])
to_send.extend(msg)
self.client_stream.send_multipart(to_send)
return
def shutdown(self):
"""Shutdown broker.
Will unregister all workers, stop all timers and ignore all further
messages.
.. warning:: The instance MUST not be used after :func:`shutdown` has been called.
:rtype: None
"""
if self.client_stream == self.main_stream:
示例11: PubSub
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class PubSub(BasePubSub):
"""
This class manages application PUB/SUB logic.
"""
def __init__(self, application):
super(PubSub, self).__init__(application)
self.sub_stream = None
def initialize(self):
self.zmq_context = zmq.Context()
options = self.application.settings["options"]
self.zmq_pub_sub_proxy = options.zmq_pub_sub_proxy
# create PUB socket to publish instance events into it
publish_socket = self.zmq_context.socket(zmq.PUB)
# do not try to send messages after closing
publish_socket.setsockopt(zmq.LINGER, 0)
if self.zmq_pub_sub_proxy:
# application started with XPUB/XSUB proxy
self.zmq_xsub = options.zmq_xsub
publish_socket.connect(self.zmq_xsub)
else:
# application started without XPUB/XSUB proxy
if options.zmq_pub_port_shift:
# calculate zmq pub port number
zmq_pub_port = options.port - options.zmq_pub_port_shift
else:
zmq_pub_port = options.zmq_pub_port
self.zmq_pub_port = zmq_pub_port
publish_socket.bind("tcp://%s:%s" % (options.zmq_pub_listen, str(self.zmq_pub_port)))
# wrap pub socket into ZeroMQ stream
self.pub_stream = ZMQStream(publish_socket)
# create SUB socket listening to all events from all app instances
subscribe_socket = self.zmq_context.socket(zmq.SUB)
if self.zmq_pub_sub_proxy:
# application started with XPUB/XSUB proxy
self.zmq_xpub = options.zmq_xpub
subscribe_socket.connect(self.zmq_xpub)
else:
# application started without XPUB/XSUB proxy
self.zmq_sub_address = options.zmq_sub_address
for address in self.zmq_sub_address:
subscribe_socket.connect(address)
subscribe_socket.setsockopt_string(zmq.SUBSCRIBE, six.u(CONTROL_CHANNEL))
subscribe_socket.setsockopt_string(zmq.SUBSCRIBE, six.u(ADMIN_CHANNEL))
def listen_socket():
# wrap sub socket into ZeroMQ stream and set its on_recv callback
self.sub_stream = ZMQStream(subscribe_socket)
self.sub_stream.on_recv(self.dispatch_published_message)
tornado.ioloop.IOLoop.instance().add_callback(listen_socket)
if self.zmq_pub_sub_proxy:
logger.info("ZeroMQ XPUB: {0}, XSUB: {1}".format(self.zmq_xpub, self.zmq_xsub))
else:
logger.info("ZeroMQ PUB - {0}; subscribed to {1}".format(self.zmq_pub_port, self.zmq_sub_address))
def publish(self, channel, message, method=None):
"""
Publish message into channel of stream.
"""
method = method or self.DEFAULT_PUBLISH_METHOD
message["message_type"] = method
message = json_encode(message)
to_publish = [utf8(channel), utf8(message)]
self.pub_stream.send_multipart(to_publish)
@coroutine
def dispatch_published_message(self, multipart_message):
"""
Got message, decide what is it and dispatch into right
application handler.
"""
channel = multipart_message[0]
message_data = multipart_message[1]
if six.PY3:
channel = channel.decode()
message_data = message_data.decode()
if channel == CONTROL_CHANNEL:
yield self.handle_control_message(message_data)
elif channel == ADMIN_CHANNEL:
yield self.handle_admin_message(message_data)
else:
yield self.handle_channel_message(channel, message_data)
def subscribe_key(self, subscription_key):
#.........这里部分代码省略.........
示例12: ZMQApplicationProxy
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class ZMQApplicationProxy(object):
"""A proxy for a ZeroMQ based ZMQApplication that is using ZMQHTTPRequest.
This class is a proxy for a backend that is running a
ZMQApplication and MUST be used with the ZMQHTTPRequest class. This
version sends the reply parts (each generated by RequestHandler.flush) as
a single multipart message for low latency replies. See
ZMQStreamingApplicationProxy, for a version that has higher latency, but
which sends each reply part as a separate zmq message.
"""
def __init__(self, loop=None, context=None):
self.loop = loop if loop is not None else IOLoop.instance()
self.context = context if context is not None else zmq.Context.instance()
self._callbacks = {}
self.socket = self.context.socket(zmq.DEALER)
self.stream = ZMQStream(self.socket, self.loop)
self.stream.on_recv(self._handle_reply)
self.urls = []
def connect(self, url):
"""Connect the service client to the proto://ip:port given in the url."""
self.urls.append(url)
self.socket.connect(url)
def bind(self, url):
"""Bind the service client to the proto://ip:port given in the url."""
self.urls.append(url)
self.socket.bind(url)
def send_request(self, request, args, kwargs, handler, timeout):
"""Send a request to the service."""
req = {}
req['method'] = request.method
req['uri'] = request.uri
req['version'] = request.version
req['headers'] = dict(request.headers)
body = request.body
req['remote_ip'] = request.remote_ip
req['protocol'] = request.protocol
req['host'] = request.host
req['files'] = request.files
req['arguments'] = request.arguments
req['args'] = args
req['kwargs'] = kwargs
msg_id = bytes(uuid.uuid4())
msg_list = [b'|', msg_id, jsonapi.dumps(req)]
if body:
msg_list.append(body)
logging.debug('Sending request: %r', msg_list)
self.stream.send_multipart(msg_list)
if timeout > 0:
def _handle_timeout():
handler.send_error(504) # Gateway timeout
try:
self._callbacks.pop(msg_id)
except KeyError:
logging.error('Unexpected error removing callbacks')
dc = DelayedCallback(_handle_timeout, timeout, self.loop)
dc.start()
else:
dc = None
self._callbacks[msg_id] = (handler, dc)
return msg_id
def _handle_reply(self, msg_list):
logging.debug('Handling reply: %r', msg_list)
len_msg_list = len(msg_list)
if len_msg_list < 3 or not msg_list[0] == b'|':
logging.error('Unexpected reply in ZMQApplicationProxy._handle_reply')
return
msg_id = msg_list[1]
replies = msg_list[2:]
cb = self._callbacks.pop(msg_id, None)
if cb is not None:
handler, dc = cb
if dc is not None:
dc.stop()
try:
for reply in replies:
handler.write(reply)
# The backend has already processed the headers and they are
# included in the above write calls, so we manually tell the
# handler that the headers are already written.
handler._headers_written = True
# We set transforms to an empty list because the backend
# has already applied all of the transforms.
handler._transforms = []
handler.finish()
except:
logging.error('Unexpected error in ZMQApplicationProxy._handle_reply', exc_info=True)
示例13: ManagementIntegrationTest
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class ManagementIntegrationTest(unittest.TestCase):
def setUp(self):
self._io_loop = IOLoop.instance()
self._ctx = zmq.Context(1)
sock = self._ctx.socket(zmq.PUB)
sock.bind('inproc://master/worker/coordination')
self._master_pub_sock = sock
self._master_pub = ZMQStream(sock, self._io_loop)
self._worker_sub = self._ctx.socket(zmq.SUB)
self._worker_sub.setsockopt(zmq.SUBSCRIBE, "")
self._worker_sub.connect('inproc://master/worker/coordination')
self._worker_pub = self._ctx.socket(zmq.PUB)
self._worker_pub.bind( 'inproc://worker/master/coordination' )
sock = self._ctx.socket(zmq.SUB)
sock.setsockopt(zmq.SUBSCRIBE, "")
sock.connect( 'inproc://worker/master/coordination' )
self._master_sub_sock = sock
self._master_sub = ZMQStream(sock, self._io_loop)
self._topic = ZMQ_SPYDER_MGMT_WORKER + 'testtopic'
def tearDown(self):
self._master_pub.close()
self._master_pub_sock.close()
self._worker_sub.close()
self._worker_pub.close()
self._master_sub.close()
self._master_sub_sock.close()
self._ctx.term()
def call_me(self, msg):
self.assertEqual(self._topic, msg.topic)
self.assertEqual('test'.encode(), msg.data)
death = MgmtMessage(topic=ZMQ_SPYDER_MGMT_WORKER,
data=ZMQ_SPYDER_MGMT_WORKER_QUIT)
self._master_pub.send_multipart(death.serialize())
def on_end(self, msg):
self.assertEqual(ZMQ_SPYDER_MGMT_WORKER_QUIT, msg.data)
self._io_loop.stop()
def test_simple_mgmt_session(self):
mgmt = ZmqMgmt(self._worker_sub, self._worker_pub, io_loop=self._io_loop)
mgmt.start()
self.assertRaises(ValueError, mgmt.add_callback, "test", "test")
mgmt.add_callback(self._topic, self.call_me)
mgmt.add_callback(ZMQ_SPYDER_MGMT_WORKER, self.on_end)
test_msg = MgmtMessage(topic=self._topic, data='test'.encode())
self._master_pub.send_multipart(test_msg.serialize())
def assert_correct_mgmt_answer(raw_msg):
msg = MgmtMessage(raw_msg)
self.assertEqual(ZMQ_SPYDER_MGMT_WORKER_QUIT_ACK, msg.data)
mgmt.remove_callback(self._topic, self.call_me)
mgmt.remove_callback(ZMQ_SPYDER_MGMT_WORKER, self.on_end)
self.assertEqual({}, mgmt._callbacks)
self._master_sub.on_recv(assert_correct_mgmt_answer)
self._io_loop.start()
示例14: LRUQueue
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class LRUQueue(object):
"""LRUQueue class using ZMQStream/IOLoop for event dispatching"""
def __init__(self, backend_socket, frontend_socket):
self.available_workers = 0
self.workers = []
self.client_nbr = NBR_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):
# Queue worker address for LRU routing
worker_addr, empty, client_addr = msg[:3]
assert self.available_workers < NBR_WORKERS
# add worker back to the list of workers
self.available_workers += 1
self.workers.append(worker_addr)
# Second frame is empty
assert empty == b""
# Third frame is READY or else a client reply address
# If client reply, send rest back to frontend
if client_addr != b"READY":
empty, reply = msg[3:]
# Following frame is empty
assert empty == b""
self.frontend.send_multipart([client_addr, b'', reply])
self.client_nbr -= 1
if self.client_nbr == 0:
# Exit after N messages
self.loop.add_timeout(time.time()+1, self.loop.stop)
if self.available_workers == 1:
# on first recv, start accepting frontend messages
self.frontend.on_recv(self.handle_frontend)
def handle_frontend(self, msg):
# Now get next client request, route to LRU worker
# Client request is [address][empty][request]
client_addr, empty, request = msg
assert empty == b""
# Dequeue and drop the next worker address
self.available_workers -= 1
worker_id = self.workers.pop()
self.backend.send_multipart([worker_id, b'', client_addr, b'', request])
if self.available_workers == 0:
# stop receiving until workers become available again
self.frontend.stop_on_recv()
示例15: GameManagerServer
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import send_multipart [as 别名]
class GameManagerServer(object):
client_router_sock = None
worker_router_sock = None
address = None
manager = None
io_loop = None
def __init__(self, addr="tcp://*:", port=config.GAME_MANAGER_PORT):
super(GameManagerServer, self).__init__()
self.context = zmq.Context()
self.io_loop = ZMQIOLoop.instance()
self.client_router_sock = self.context.socket(zmq.ROUTER)
self.address = addr + str(port)
self.client_router_sock.bind(self.address)
self.worker_router_sock = self.context.socket(zmq.ROUTER)
self.worker_router_sock.bind("tcp://*:6000")
self.client_router_sock = ZMQStream(self.client_router_sock)
self.client_router_sock.on_recv(self.recv_from_client)
self.worker_router_sock = ZMQStream(self.worker_router_sock)
self.worker_router_sock.on_recv(self.recv_from_game)
self.manager = GameManager(self.send_to_client, self.send_to_game)
def start(self):
try:
self.io_loop.start()
except KeyboardInterrupt:
pass
self.client_router_sock.close()
self.worker_router_sock.close()
def send_to_client(self, msg):
routable_msg = [msg[mpwp.MSG_TO]] + msg # prepend routing IDENTITY
self.client_router_sock.send_multipart(routable_msg)
def send_to_game(self, msg):
routable_msg = [msg[mpwp.MSG_TO]] + msg # prepend routing IDENTITY
self.worker_router_sock.send_multipart(routable_msg)
def recv_from_client(self, msg):
if msg:
router_id = msg[0]
actual_msg = msg[1:] # trim off router info
if router_id == actual_msg[mpwp.MSG_FROM]:
if actual_msg[mpwp.MSG_VERSION] == mpwp.VERSION:
self.manager.handle_client_incoming(actual_msg)
else:
pass # send VERSION_MISMATCH_ERROR
else:
if actual_msg[mpwp.MSG_TO] == mpwp.GAME_MANAGER_ID and actual_msg[mpwp.MSG_FROM] == mpwp.MATCHMAKER_ID:
to_id = router_id
from_id = actual_msg[mpwp.MSG_FROM]
msg_type = actual_msg[mpwp.MSG_TYPE]
msg_content = mpwp.msg_content(actual_msg)
self.manager.handle_matchmaker_incoming(to_id, from_id, msg_type, msg_content)
else:
pass # error, invalid message
else:
return # fatal error
def recv_from_game(self, msg):
router_id = msg[0]
actual_msg = msg[1:] # trim off router info
self.manager.recv_from_game(actual_msg)