本文整理汇总了Python中zmq.eventloop.zmqstream.ZMQStream.close方法的典型用法代码示例。如果您正苦于以下问题:Python ZMQStream.close方法的具体用法?Python ZMQStream.close怎么用?Python ZMQStream.close使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类zmq.eventloop.zmqstream.ZMQStream
的用法示例。
在下文中一共展示了ZMQStream.close方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
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()
示例2: SocketConnection
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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: DeviceServicePublisher
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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: Client
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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()
示例5: Publisher
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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
示例6: ManagerControlled
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class ManagerControlled(object):
def __init__(self, *args, **kwargs):
self.context = Context.instance()
self.loop = IOLoop.instance()
self.control_socket = self.context.socket(SUB)
self.control_socket.setsockopt(LINGER, 0) # discard unsent messages on close
self.control_socket.setsockopt(SUBSCRIBE, '')
self.control_socket.connect('tcp://{}:{}'.format(MANAGER_PUB_ADDRESS, MANAGER_PUB_PORT))
self.control_stream = ZMQStream(self.control_socket, self.loop)
self.control_stream.on_recv_stream(self.control_handler)
def control_handler(self, stream, message_list):
for message in message_list:
try:
notification, data = message.split()
except ValueError:
notification = message
if notification == NOTIFICATION_PROCESS_STOP:
self.stop()
def stop(self):
self.control_stream.stop_on_recv()
self.control_stream.close()
self.control_socket.close()
示例7: AsyncCircusClient
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class AsyncCircusClient(object):
def __init__(self, context=None, endpoint=DEFAULT_ENDPOINT_DEALER,
timeout=5.0, ssh_server=None, ssh_keyfile=None):
self._init_context(context)
self.endpoint = endpoint
self._id = b(uuid.uuid4().hex)
self.socket = self.context.socket(zmq.DEALER)
self.socket.setsockopt(zmq.IDENTITY, self._id)
self.socket.setsockopt(zmq.LINGER, 0)
get_connection(self.socket, endpoint, ssh_server, ssh_keyfile)
self._timeout = timeout
self.timeout = timeout * 1000
self.stream = ZMQStream(self.socket, tornado.ioloop.IOLoop.instance())
def _init_context(self, context):
self.context = context or zmq.Context.instance()
def stop(self):
self.stream.stop_on_recv()
# only supported by libzmq >= 3
if hasattr(self.socket, 'disconnect'):
self.socket.disconnect(self.endpoint)
self.stream.close()
@tornado.gen.coroutine
def send_message(self, command, **props):
res = yield self.call(make_message(command, **props))
raise tornado.gen.Return(res)
@tornado.gen.coroutine
def call(self, cmd):
if isinstance(cmd, string_types):
raise DeprecationWarning('call() takes a mapping')
call_id = uuid.uuid4().hex
cmd['id'] = call_id
try:
cmd = json.dumps(cmd)
except ValueError as e:
raise CallError(str(e))
try:
yield tornado.gen.Task(self.stream.send, cmd)
except zmq.ZMQError as e:
raise CallError(str(e))
while True:
messages = yield tornado.gen.Task(self.stream.on_recv)
for message in messages:
try:
res = json.loads(message)
if res.get('id') != call_id:
# we got the wrong message
continue
raise tornado.gen.Return(res)
except ValueError as e:
raise CallError(str(e))
示例8: MainHandler
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class MainHandler(websocket.WebSocketHandler):
_first = True
@property
def ref(self):
return id(self)
def initialize(self):
print "WebSocket initialize"
self.push_socket = ctx.socket(zmq.PUSH)
self.sub_socket = ctx.socket(zmq.SUB)
self.push_socket.connect("ipc:///tmp/ws_push")
#self.sub_socket.connect("ipc:///tmp/ws_sub")
self.sub_socket.bind("ipc:///tmp/ws_sub")
self.sub_socket.setsockopt(zmq.SUBSCRIBE, "")
self.zmq_stream = ZMQStream(self.sub_socket)
self.zmq_stream.on_recv(self.zmq_msg_recv)
def open(self, *args, **kwargs):
print "WebSocket opened", args, kwargs
def on_message(self, message):
print "WebSocket on_message"
if self._first:
msg = {'message': message, 'id':self.ref, 'action':'connect'}
self._first = False
else:
msg = {'message': message, 'id':self.ref, 'action':'message'}
self.push_socket.send_pyobj(msg)
def on_close(self):
print "WebSocket closed"
msg = {'message': '', 'id': id(self), 'action': 'close'}
self.push_socket.send_pyobj(msg)
self.zmq_stream.close()
self.sub_socket.close()
self.push_socket.close()
def zmq_msg_recv(self, data):
print "zmq_msg_recv: %s" % repr(data)
for message in data:
message = pickle.loads(message)
#_id, _msg = message['id'], message['message']
print ' = ', repr(message)
#if _id != self.ref:
# continue
#self.write_message(_msg)
self.write_message(json.dumps(message, indent=4))
示例9: Worker
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class Worker(object):
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 start(self):
logging.info('[%s] starting', self.identity)
self.messenger.start()
self.messenger.publish(CTRL_MSG_WORKER, self.identity,
CTRL_MSG_WORKER_ONLINE)
self._in_stream.on_recv(self._on_receive_request)
self._running = True
def stop(self):
self._running = False
self.messenger.stop()
def close(self):
self._in_stream.close()
self._in_socket.close()
self._out_stream.close()
self._out_socket.close()
self.messenger.close()
def _on_receive_request(self, zmq_msg):
msg = RequestMessage.deserialize(zmq_msg)
request = msg.request
logging.debug('[%s] receive request(%s)', self.identity, request.url)
self.robot.fetch(request)
示例10: test_that_creating_mgmt_works
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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()
示例11: open
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
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()
示例12: _Messenger
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [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())
示例13: open
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
def open(self):
self.time_opened = time.time()
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 "Error getting ZMQ stream:", 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()
示例14: Msglet
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class Msglet(object):
def __init__(self, callback):
self.callback = callback
self.bind()
def bind(self):
self.socket = ctx.socket(zmq.SUB)
self.socket.connect(config['protocol'])
self.stream = ZMQStream(self.socket)
self.stream.on_recv(self.callback)
def subscribe(self, channel):
self.socket.setsockopt_string(zmq.SUBSCRIBE, channel)
def close(self):
self.stream.close()
示例15: LiveLogHandler
# 需要导入模块: from zmq.eventloop.zmqstream import ZMQStream [as 别名]
# 或者: from zmq.eventloop.zmqstream.ZMQStream import close [as 别名]
class LiveLogHandler(WebSocketHandler):
def open(self, network, channel):
self.context = zmq.Context()
self.socket = self.context.socket(zmq.SUB)
self.socket.connect("tcp://127.0.0.1:{0}".format(config.ZEROMQ_PORT))
self.socket.setsockopt(zmq.SUBSCRIBE, "{0}~{1}".format(network,channel))
self.zmq_stream = ZMQStream(self.socket)
self.zmq_stream.on_recv(self.on_zmq_msg_receive)
def on_close(self):
self.zmq_stream.close()
self.socket.close()
def on_zmq_msg_receive(self, data):
data = data[0]
lines = data.split("\n")[1:]
self.write_message("\n".join([irc_format(line) for line in lines]))