Python ZMQStream.close方法代码示例

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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

# 需要导入模块: 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()

# 需要导入模块: 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

# 需要导入模块: 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()

# 需要导入模块: 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))

# 需要导入模块: 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))

# 需要导入模块: 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)

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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())

# 需要导入模块: 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()

# 需要导入模块: 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()

# 需要导入模块: 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]))