Python netutil.bind_unix_socket函数代码示例

 def start(self):
     self.tornadoApp=tornado.web.Application(self.handlers)
     self.tornadoApp.server=self
     if self.ssl_crt and self.ssl_key:
         import ssl
         ssl_options = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         ssl_options.load_cert_chain(self.ssl_crt,self.ssl_key)
     else:
         ssl_options = None
     server = HTTPServer(self.tornadoApp, ssl_options=ssl_options)
     if self.port:
         server.listen(int(self.port))
         #self.tornadoApp.listen(int(self.port))
     else:
         socket_path = os.path.join(gnrConfigPath(), 'sockets', '%s.tornado'%self.instance_name)
         main_socket = bind_unix_socket(socket_path)
         #server = HTTPServer(self.tornadoApp)
         server.add_socket(main_socket)
     debug_socket_path = os.path.join(gnrConfigPath(), 'sockets', '%s_debug.tornado'%self.instance_name)
     debug_socket = bind_unix_socket(debug_socket_path)
     debug_server = GnrDebugServer(self.io_loop)
     #debug_server.listen(8888)
     debug_server.add_socket(debug_socket)
     debug_server.application = self.tornadoApp
     signal.signal(signal.SIGTERM, self.onSignal)
     signal.signal(signal.SIGINT, self.onSignal)
     self.io_loop.start()

def setup_server():
    # Config tornado.curl_httpclient to use NullHandler
    tornado_logger = logging.getLogger('tornado.curl_httpclient')
    tornado_logger.addHandler(logging.NullHandler())
    tornado_logger.propagate = False

    settings = dict(
        autoreload=True,
        secret="ElasticKube",
    )

    configure(settings)

    handlers = [
        (r"/api/v1/auth/providers", AuthProvidersHandler),
        (r"/api/v1/auth/signup", SignupHandler),
        (r"/api/v1/auth/login", PasswordHandler),
        (r"/api/v1/auth/google", GoogleOAuth2LoginHandler),
        (r"/api/v1/ws", MainWebSocketHandler),
        (r"/icons/(?P<entity_id>[^\/]+)\/(?P<chart_id>[^\/]+)", IconGenerator)
    ]

    application = Application(handlers, **settings)

    server = HTTPServer(application)
    socket = bind_unix_socket("/var/run/elastickube-api.sock", mode=0777)
    server.add_socket(socket)

    IOLoop.current().add_callback(initialize, settings)

def unix_socket_server(application, options):
    """ unix socket server """

    log.info("Binding application to unix socket {0}".format(options.unix_socket))
    server = HTTPServer(application)
    socket = bind_unix_socket(options.unix_socket)
    server.add_socket(socket)

def bind(server, port, usocket, address=None):
    """Make server listen on port (inet socket).
    If given, prefer `usocket`, path to a unix socket.
    The latter is useful for reverse proxying.

    If listening on a inet socket, `address` might be
    given. `address` may be either an IP address or hostname.
    If it's a hostname, the server will listen on all IP addresses
    associated with the name. If not given (and not listening on a unix
    socket) will listen on all available interfaces."""

    # If we have a unix socket path
    if usocket:
        LOG.info('Starting on unix socket %r', usocket)
        try:
            socket = bind_unix_socket(usocket, mode=options.usocket_mode)
            os.chown(usocket, options.usocket_uid, options.usocket_gid)
        except OSError as error:
            LOG.error('Cannot create unix socket: %r', error)
        else:
            server.add_socket(socket)
            LOG.info('Started')
    else:
        LOG.info('Starting on port %d', port)
        sockets = bind_sockets(port, address=address)
        server.add_sockets(sockets)
        LOG.info('Started')

def run_server(
        django_host='http://127.0.0.1:8000',
        listen_address='0.0.0.0',
        listen_port=22000,
        unix_socket=None,
        socket_mode=0o600,
        socket_group=None):

    subscribed_channels_url = django_host + reverse('luna_websockets_channels')
    BrokerConnection.subscribed_channels_url = subscribed_channels_url

    BrokerRouter = sockjs.tornado.SockJSRouter(BrokerConnection, '/ws')

    app = tornado.web.Application(BrokerRouter.urls)

    if unix_socket:
        server = tornado.httpserver.HTTPServer(app)
        socket = bind_unix_socket(unix_socket, mode=socket_mode)
        if socket_group is not None:
            gid = grp.getgrnam(socket_group).gr_gid
            os.chown(unix_socket, -1, gid)

        server.add_socket(socket)
        logging.info('Listening on %s' % unix_socket)
    else:
        app.listen(listen_port, address=listen_address)
        logging.info('Listening on %s:%d' % (listen_address, listen_port))

    tornado.ioloop.IOLoop.instance().start()

 def __init__(self, unixsocket, io_loop=None):
     super(RuntimeMock, self).__init__(io_loop=io_loop or ioloop.IOLoop.current())
     self.io_loop = io_loop or ioloop.IOLoop.current()
     self.actions = list()
     self.counter = 1
     self.endpoint = unixsocket
     self.add_socket(netutil.bind_unix_socket(unixsocket))

 def launch(self):
     import signal
     import tornado.httpserver
     signal.signal(signal.SIGTERM, self.sig_handler)
     signal.signal(signal.SIGINT, self.sig_handler)
     if os.name == "posix":
         signal.signal(signal.SIGTSTP, self.sig_handler)
     self.http_server = tornado.httpserver.HTTPServer(self.application)
     if firenado.conf.app['socket'] or self.socket:
         from tornado.netutil import bind_unix_socket
         socket_path = firenado.conf.app['socket']
         if self.socket:
             socket_path = self.socket
         socket = bind_unix_socket(socket_path)
         self.http_server.add_socket(socket)
         logger.info("Firenado listening at socket ""%s" %
                     socket.getsockname())
     else:
         addresses = self.addresses
         if addresses is None:
             addresses = firenado.conf.app['addresses']
         port = self.port
         if port is None:
             port = firenado.conf.app['port']
         for address in addresses:
             self.http_server.listen(port, address)
             logger.info("Firenado listening at ""http://%s:%s" % (address,
                                                                   port))
     logger.info("Firenado server started successfully.")
     tornado.ioloop.IOLoop.instance().start()

    def launch(self):
        import signal

        # TODO: Resolve module if doesn't exists
        if firenado.conf.app['pythonpath']:
            sys.path.append(firenado.conf.app['pythonpath'])

        signal.signal(signal.SIGTERM, self.sig_handler)
        signal.signal(signal.SIGINT, self.sig_handler)
        if os.name == "posix":
            signal.signal(signal.SIGTSTP, self.sig_handler)
        self.application = TornadoApplication(debug=firenado.conf.app['debug'])
        self.http_server = tornado.httpserver.HTTPServer(
            self.application)
        if firenado.conf.app['socket']:
            from tornado.netutil import bind_unix_socket
            socket = bind_unix_socket(firenado.conf.app['socket'])
            self.http_server.add_socket(socket)
        else:
            addresses = firenado.conf.app['addresses']
            port = firenado.conf.app['port']
            for address in addresses:
                self.http_server.listen(port, address)
                logger.info("Firenado listening at ""http://%s:%s" % (address,
                                                                      port))
        tornado.ioloop.IOLoop.instance().start()

def main():
    define('ip', default=None, help='IP to listen on')
    define('port', default=None, help='port to listen on')
    define('socket', default=None, help='unix socket path to bind (instead of ip:port)')
    define('group', default='', help='comma separated group list for new users `students,other`')
    define('skeldir', default='', help='skeleton directory that will be used for new homedirs')
    define('shell', default='/bin/bash', help='default shell')
    
    parse_command_line()
    
    if not options.socket and not (options.port):
        options.socket = '/var/run/restuser.sock'
    
    app = web.Application(
        [(r'/([^/]+)', UserHandler)],
        group=options.group,
        skeldir=options.skeldir,
        shell=options.shell)
    if options.socket:
        socket = bind_unix_socket(options.socket, mode=0o600)
        server = HTTPServer(app)
        server.add_socket(socket)
    else:
        app.listen(options.port, options.ip)
    try:
        IOLoop.current().start()
    except KeyboardInterrupt:
        print("\ninterrupted\n", file=sys.stderr)
        return

 def setUp(self):
     super(HTTPUnixClientTestCase, self).setUp()
     self.socket_path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
                                     "test_socket")
     self.http_server = self.get_http_server()
     sock = netutil.bind_unix_socket(self.socket_path)
     self.http_server.add_sockets([sock])

 def listen(self, port, address=""):
     """Bind to a unix domain socket and add to self.
     Note that port in our case actually contains the uds file name"""
     
     # Create a Unix domain socket and bind
     socket = bind_unix_socket(port)
     
     # Add to self
     self.add_socket(socket)

def unix_socket(path, u, g):
    uid = pwd.getpwnam(u).pw_uid
    gid = grp.getgrnam(g).gr_gid
    with netutil.bind_unix_socket(path) as socket:
        os.chown(path, uid, gid)
        try:
            yield socket
        finally:
            os.remove(path)

def standalone():
    """
    Initializes Tornado and our application.  Forks worker processes to handle
    requests.  Does not return until all child processes exit normally.
    """

    # Parse arguments
    parser = argparse.ArgumentParser(description="Ellis web server")
    parser.add_argument("--background", action="store_true", help="Detach and run server in background")
    args = parser.parse_args()

    # We don't initialize logging until we fork because we want each child to
    # have its own logging and it's awkward to reconfigure logging that is
    # defined by the parent.
    application = create_application()

    if args.background:
        # Get a new logfile, rotating the old one if present.
        err_log_name = os.path.join(settings.LOGS_DIR, settings.LOG_FILE_PREFIX + "-err.log")
        try:
            os.rename(err_log_name, err_log_name + ".old")
        except OSError:
            pass
        # Fork into background.
        utils.daemonize(err_log_name)

    utils.install_sigusr1_handler(settings.LOG_FILE_PREFIX)

    # Drop a pidfile.
    pid = os.getpid()
    with open(settings.PID_FILE, "w") as pidfile:
        pidfile.write(str(pid) + "\n")

    # Fork off a child process per core.  In the parent process, the
    # fork_processes call blocks until the children exit.
    num_processes = settings.TORNADO_PROCESSES_PER_CORE * tornado.process.cpu_count()
    task_id = tornado.process.fork_processes(num_processes)
    if task_id is not None:
        logging_config.configure_logging(settings.LOG_LEVEL, settings.LOGS_DIR, settings.LOG_FILE_PREFIX, task_id)
        # We're a child process, start up.
        _log.info("Process %s starting up", task_id)
        connection.init_connection()

        http_server = httpserver.HTTPServer(application)
        unix_socket = bind_unix_socket(settings.HTTP_UNIX + "-" + str(task_id),
                                       0666);
        http_server.add_socket(unix_socket)

        homestead.ping()
        background.start_background_worker_io_loop()
        io_loop = tornado.ioloop.IOLoop.instance()
        io_loop.start()
    else:
        # This shouldn't happen since the children should run their IOLoops
        # forever.
        _log.critical("Children all exited")

def run_server(application, context):
    server = HTTPServer(application)
    define(
        'unix_socket',
        group='webserver',
        default=thumbor_socket,
        help='Path to unix socket to bind')
    socket = bind_unix_socket(options.unix_socket)
    server.add_socket(socket)
    server.start(1)

 def setUp(self):
     super(UnixSocketTest, self).setUp()
     self.tmpdir = tempfile.mkdtemp()
     self.sockfile = os.path.join(self.tmpdir, "test.sock")
     sock = netutil.bind_unix_socket(self.sockfile)
     app = Application([("/hello", HelloWorldRequestHandler)])
     self.server = HTTPServer(app)
     self.server.add_socket(sock)
     self.stream = IOStream(socket.socket(socket.AF_UNIX))
     self.io_loop.run_sync(lambda: self.stream.connect(self.sockfile))