Python zmq.device函数代码示例

def main(pub_port=None, sub_port=None):
    '''main of forwarder

    :param sub_port: port for subscribers
    :param pub_port: port for publishers
    '''
    try:
        if sub_port is None:
            sub_port = get_sub_port()
        if pub_port is None:
            pub_port = get_pub_port()
        context = zmq.Context(1)
        frontend = context.socket(zmq.SUB)
        backend = context.socket(zmq.PUB)

        frontend.bind('tcp://*:{pub_port}'.format(pub_port=pub_port))
        frontend.setsockopt(zmq.SUBSCRIBE, b'')
        backend.bind('tcp://*:{sub_port}'.format(sub_port=sub_port))
        zmq.device(zmq.FORWARDER, frontend, backend)
    except KeyboardInterrupt:
        pass
    finally:
        frontend.close()
        backend.close()
        context.term()

 def run(self):
     self.socket = self.context.socket(zmq.REP)
     if self.port == 0:
         self.port = self.socket.bind_to_random_port('tcp://%s' % self.ip)
     else:
         self.socket.bind('tcp://%s:%i' % self.addr)
     zmq.device(zmq.FORWARDER, self.socket, self.socket)

def run_server(threads=10):
    """ server routine """
    signal.signal(signal.SIGINT, signal_handler)

    global clients
    global workers
    global context

    url_worker = "inproc://workers"
    url_client = "tcp://*:2112"

    context = zmq.Context(1)
    clients = context.socket(zmq.ROUTER)
    clients.bind(url_client)

    # Worker sockets
    workers = context.socket(zmq.DEALER)
    workers.bind(url_worker)

    for i in range(threads):
        thread = threading.Thread(target=worker_routine, args=(url_worker, context, ))
        thread.setDaemon(True)
        thread.start()

    zmq.device(zmq.QUEUE, clients, workers)

def LaunchBroker(config):
  """Start a set of intermediate devices for the cluster on this machine.

  This method does not return.

  :param ConfigParser config: Configuration information for cluster.

  """
  cmd_frontend_url = config.get('server', 'command_frontend_url')
  cmd_backend_url = config.get('server', 'command_backend_url')
  log_frontend_url = config.get('server', 'log_frontend_url')
  log_backend_url = config.get('server', 'log_backend_url')
  def thread_target():
    context = zmq.Context()
    log_be_socket = MakeSocket(context, url = log_backend_url, type = zmq.PUB,
        bind = True)
    log_fe_socket = MakeSocket(context, url = log_frontend_url, type = zmq.SUB,
        bind = True, options = {zmq.SUBSCRIBE : ""})
    zmq.device(zmq.FORWARDER, log_fe_socket, log_be_socket)
  thread = threading.Thread(target = thread_target)
  thread.daemon = True
  logging.info("Launching logging forwarder -- clients should SUB to "
      "%s and PUB to %s" % (log_backend_url, log_frontend_url))
  thread.start()
  context = zmq.Context()
  cmd_be_socket = MakeSocket(context, url = cmd_backend_url, type = zmq.PUB,
      bind = True)
  cmd_fe_socket = MakeSocket(context, url = cmd_frontend_url, type = zmq.SUB,
      bind = True, options = {zmq.SUBSCRIBE : ""})
  logging.info("Launching command forwarder -- clients should SUB to "
      "%s and PUB to %s" % (cmd_backend_url, cmd_frontend_url))
  zmq.device(zmq.FORWARDER, cmd_fe_socket, cmd_be_socket)

 def thread_target():
   context = zmq.Context()
   log_be_socket = MakeSocket(context, url = log_backend_url, type = zmq.PUB,
       bind = True)
   log_fe_socket = MakeSocket(context, url = log_frontend_url, type = zmq.SUB,
       bind = True, options = {zmq.SUBSCRIBE : ""})
   zmq.device(zmq.FORWARDER, log_fe_socket, log_be_socket)

    def run(self):
        '''
        Start the ret port binding
        '''
        self.context = zmq.Context(self.opts['worker_threads'])
        self.uri = 'tcp://{interface}:{ret_port}'.format(**self.opts)
        log.info('ZMQ Ret port binding to {0}'.format(self.uri))
        self.clients = self.context.socket(zmq.ROUTER)
        if self.opts['ipv6'] is True and hasattr(zmq, 'IPV4ONLY'):
            # IPv6 sockets work for both IPv6 and IPv4 addresses
            self.clients.setsockopt(zmq.IPV4ONLY, 0)
        try:
            self.clients.setsockopt(zmq.HWM, self.opts['rep_hwm'])
        except AttributeError:
            self.clients.setsockopt(zmq.SNDHWM, self.opts['rep_hwm'])
            self.clients.setsockopt(zmq.RCVHWM, self.opts['rep_hwm'])
        self.workers = self.context.socket(zmq.DEALER)
        self.w_uri = 'ipc://{0}'.format(
            os.path.join(self.opts['sock_dir'], 'workers.ipc')
        )

        log.info('Setting up the master communication server')
        self.clients.bind(self.uri)

        self.workers.bind(self.w_uri)

        while True:
            try:
                zmq.device(zmq.QUEUE, self.clients, self.workers)
            except zmq.ZMQError as exc:
                if exc.errno == errno.EINTR:
                    continue
                raise exc

        def q(listen,worker_target):
            self.workers = self.context.socket(zmq.XREQ)
            self.workers.bind(worker_target);

            self.clients = self.context.socket(zmq.XREP)
            self.clients.bind(listen) 
            zmq.device(zmq.QUEUE, self.clients, self.workers)

def run_forwarder():
    sub_addr = 'tcp://*:5759'
    pub_addr = 'tcp://*:5760'
    print "starting forwarder device. sub: '%s', pub: '%s' " % (sub_addr, pub_addr)
    print os.getpid()

    backend = None
    frontend = None
    context = None

    try:
        context = zmq.Context(1)
        # Socket facing clients
        frontend = context.socket(zmq.SUB)
        frontend.bind(sub_addr)
        #print "started forwarder with subs bound at '%s'" % sub_addr

        frontend.setsockopt(zmq.SUBSCRIBE, "")

        # Socket facing services
        backend = context.socket(zmq.PUB)
        backend.bind(pub_addr)
        #print "started forwarder with pub bound at '%s'" % pub_addr

        zmq.device(zmq.FORWARDER, frontend, backend)
    except Exception, e:
        print e
        print "bringing down zmq device"

def main():
    """ server routine """

    url_worker = "inproc://workers"
    url_client = "tcp://*:5555"

    # Prepare our context and sockets
    context = zmq.Context(1)

    # Socket to talk to clients
    clients = context.socket(zmq.ROUTER)
    clients.bind(url_client)

    # Socket to talk to workers
    workers = context.socket(zmq.DEALER)
    workers.bind(url_worker)

    # Launch pool of worker threads
    for i in range(5):
        thread = threading.Thread(target=worker_routine, args=(url_worker, context, ))
        thread.start()

    zmq.device(zmq.QUEUE, clients, workers)

    # We never get here but clean up anyhow
    clients.close()
    workers.close()
    context.term()

def main(req_port=None, res_port=None, use_security=False):
    '''main of queue

    :param req_port: port for clients
    :param res_port: port for servers
    '''
    if req_port is None:
        req_port = env.get_req_port()
    if res_port is None:
        res_port = env.get_res_port()
    auth = None
    try:
        context = zmq.Context()
        frontend_service = context.socket(zmq.XREP)
        backend_service = context.socket(zmq.XREQ)
        if use_security:
            if not os.path.exists(env.get_server_public_key_dir()):
                create_certificates(env.get_server_public_key_dir())
            auth = Authenticator.instance(env.get_server_public_key_dir())
            auth.set_server_key(
                frontend_service, env.get_server_secret_key_path())
            auth.set_client_key(backend_service, env.get_client_secret_key_path(),
                                env.get_server_public_key_path())
        frontend_service.bind('tcp://*:{req_port}'.format(req_port=req_port))
        backend_service.bind('tcp://*:{res_port}'.format(res_port=res_port))
        zmq.device(zmq.QUEUE, frontend_service, backend_service)
    except KeyboardInterrupt:
        pass
    finally:
        frontend_service.close()
        backend_service.close()
        context.term()
        if use_security and auth is not None:
            auth.stop()

    def start(self):
        """
        Start the server.
        Note: this is a blocking call.
        """
        while True:
            try:
                print "Starting ZRPC server"
                self.ctx = zmq.Context()

                self.backend = self.ctx.socket(zmq.XREQ)
                print "Listening for server workers on %s" % self._get_server_addr()
                self.backend.bind(self._get_server_addr())

                self.frontend = self.ctx.socket(zmq.XREP)
                print "Listening for clients on %s" % self._get_client_addr()
                self.frontend.bind(self._get_client_addr())

                zmq.device(zmq.QUEUE, self.frontend, self.backend)

            except Exception as e:
                print 'Exception in ZRPC server: %s' % str(e)
                print 'Stopping ZRPC server'
                self.frontend.close()
                self.backend.close()
                self.ctx.term()
                time.sleep(3)

 def __init__(self, fan_in_port, fan_out_port):
     ctx = zmq.Context()
     front = ctx.socket(zmq.XREP)
     back = ctx.socket(zmq.XREQ)
     front.bind("tcp://*:{port}".format(port=int(fan_in_port)))
     back.bind("tcp://*:{port}".format(port=int(fan_out_port)))
     zmq.device(zmq.QUEUE, front, back)

def main():
    """Server routine"""

    url_worker = "inproc://workers"
    url_client = "tcp://*:5555"

    setup_buffers()

    # Prepare our context and sockets
    context = zmq.Context.instance()

    # Socket to talk to clients
    clients = context.socket(zmq.ROUTER)
    clients.bind(url_client)

    # Socket to talk to workers
    workers = context.socket(zmq.DEALER)
    workers.bind(url_worker)

    # Launch pool of worker threads
    for i in range(WORKER_NUM):
        thread = threading.Thread(target=worker_routine, args=(url_worker,))
        thread.start()

    try:
        zmq.device(zmq.QUEUE, clients, workers)
    except KeyboardInterrupt:
        pass

    # We never get here but clean up anyhow
    clients.close()
    workers.close()
    context.term()

    def run_device(self):
        """The runner method.

        Do not call me directly, instead call ``self.start()``, just like a Thread.
        """
        ins,outs = self._setup_sockets()
        device(self.device_type, ins, outs)

	def run(self):

		print("[*] Starting proxy")

		backend = None
		frontend = None
		context = None
		try:
			context = zmq.Context()
			# Socket facing clients
			frontend = context.socket(zmq.PULL)
			frontend.bind(self.listen_in)

			# Socket facing services
			backend = context.socket(zmq.PUSH)
			backend.bind(self.listen_out)

			zmq.device(zmq.FORWARDER, frontend, backend)
		except Exception as e:
			print("bringing down zmq device")
			print(e)
		finally:
			frontend.close()
			backend.close()
			context.term()