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()

    def __bind(self):
        '''
        Binds the reply server
        '''
        log.info('Setting up the master communication server')
        self.clients.bind(self.uri)
        self.work_procs = []

        for ind in range(int(self.opts['worker_threads'])):
            self.work_procs.append(MWorker(self.opts,
                    self.master_key,
                    self.key,
                    self.crypticle))

        for ind, proc in enumerate(self.work_procs):
            log.info('Starting Salt worker process {0}'.format(ind))
            proc.start()

        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 start(self):
        """
            Main execution.
            Instantiate workers, Accept client connections,
            distribute computation requests among workers and route computed results back to clients.
        """

        print("Starting server...")

        # Front facing socket to accept client connections.
        socket_front = self.zmq_context.socket(zmq.ROUTER)
        socket_front.bind('tcp://127.0.0.1:5010')

        # Backend socket to distribute work.
        socket_back = self.zmq_context.socket(zmq.DEALER)
        socket_back.bind('inproc://backend')

        # Start three workers.
        for i in range(1,2):
            worker = Worker(self.zmq_context, i, self._stree)
            worker.start()
            print("Threaded worker %d started..." % i)

        # Use built in queue device to distribute requests among workers.
        # What queue device does internally is,
        #   1. Read a client's socket ID and request.
        #   2. Send socket ID and request to a worker.
        #   3. Read a client's socket ID and result from a worker.
        #   4. Route result back to the client using socket ID.
        zmq.device(zmq.QUEUE, socket_front, socket_back)

 def forward_modules_to_clients_raw( self ):     
    self.log.info("Starting SUB->PUB forward from socket %d to %d " % (self.port_module_sub, self.port_client_pub ))
    #import pdb; pdb.set_trace()
    frontend = None
    backend = None
    try:
      # Socket facing clients
      context = zmq.Context(1)
      frontend = context.socket(zmq.SUB)
      frontend.bind("%s:%d" % ( self.protocol, self.port_module_sub ) )
      # No filtering of messages please
      frontend.setsockopt(zmq.SUBSCRIBE, "")
      
      # Socket facing services
      backend = context.socket(zmq.PUB)
      backend.bind("%s:%d" % ( self.protocol, self.port_client_pub  ) )

      zmq.device( zmq.FORWARDER, frontend, backend )
      print("FAIL")
      
    except Exception as e:
       self.log.error("Exception while running forward: " + str(e))
       raise Exception("Forwarder failed")
    
    finally:
        pass
        if frontend: 
           frontend.close()
        if backend:
           backend.close()

def forward(front_port, backend_port):

    context = zmq.Context(1)
    # Socket facing clients
    frontend = context.socket(zmq.SUB)
    frontend.bind("tcp://*:%s" % front_port)

    frontend.setsockopt(zmq.SUBSCRIBE, b"")

    # Socket facing services
    backend = context.socket(zmq.PUB)
    backend.bind("tcp://*:%s" % backend_port)
    
    try:
        log.logging.info("Start forwarding from %s to %s", front_port, backend_port)
        zmq.device(zmq.FORWARDER, frontend, backend)

    except Exception as e:
        log.logging.error(e)
        print("[bringing down zmq device]")

    finally:
        frontend.close()
        backend.close()
        context.term()

 def run(self):
     logger.debug('Starting {} device'.format(self._name))
     try:
         self.frontend, self.backend = self.get_sockets()
         zmq.device(zmq.QUEUE, self.frontend, self.backend)
     except KeyboardInterrupt:
         pass