Python netutil.bind_sockets函数代码示例

    def server_start(self):

        logging.info('server starting...')
        logger_module.logger.load_config()
        #tornado把默认的根logger加了handler
        #把根logger的handler去除，然后重新绑定在tornado的logger下
        logging.getLogger().handlers = []
        enable_pretty_logging(None, logging.getLogger('tornado'))

        #服务启动

        from tornado.netutil import bind_sockets

        if self.settings.IPV4_ONLY:
            import socket

            sockets = bind_sockets(options.port, options.address, family=socket.AF_INET)
        else:
            sockets = bind_sockets(options.port, options.address)

        self.print_settings_info()
        http_server = tornado.httpserver.HTTPServer(self.application)
        http_server.add_sockets(sockets)
        logging.info('tornado server started. listen port: %s ,host address: %s' % (options.port, options.address))
        tornado.ioloop.IOLoop.instance().start()

def main():

    # options
    parse_command_line()

    # Locale
    load_gettext_translations(settings.I18N_PATH, "luoyun")
    set_default_locale('zh_CN')

    logging.info("starting torando web server")

    if settings.IPV4_ONLY:
        import socket
        sockets = bind_sockets(options.port, family=socket.AF_INET)
    else:
        sockets = bind_sockets(options.port)

    if not settings.DEBUG:
        import tornado.process
        tornado.process.fork_processes(0)

    application = Application()
    server = HTTPServer(application, xheaders=True)
    server.add_sockets(sockets)
    IOLoop.instance().start()

def build_listener(address, backlog=0):
    address_type = get_address_type(address)
    if address_type == 'tcp':
        host, port = address
        socks = netutil.bind_sockets(port, address=host, backlog=backlog)
        return socks
    if address_type == 'uds':
        socks = netutil.bind_sockets(address, mode=0o600, backlog=backlog)
        return [socks]

def main(): 
    taskID = process.fork_processes(4)
    if taskID == 0:
        app = httpserver.HTTPServer(makeFrontend())
        app.add_sockets(netutil.bind_sockets(BASE_PORT))
        logging.info("Front end is listening on " + str(BASE_PORT))
    else:
        port = BASE_PORT + taskID
        app = httpserver.HTTPServer(makeBackend(port))
        app.add_sockets(netutil.bind_sockets(port))
        logging.info("Back end %d listening on %d" % (taskID, port))
    IOLoop.current().start()

def bind_sockets(addr, backlog=128, allows_unix_socket=False):
    # initialize the socket
    addr = parse_address(addr)
    if isinstance(addr, six.string_types):
        if not allows_unix_socket:
            raise RuntimeError("unix addresses aren't supported")

        sock = netutil.bind_unix_socket(addr)
    elif is_ipv6(addr[0]):
        sock = netutil.bind_sockets(addr[1], address=addr[0],
                family=socket.AF_INET6, backlog=backlog)
    else:
        sock = netutil.bind_sockets(addr[1], backlog=backlog)
    return sock

    def server_start(self):
        #服务启动
        if self.settings.IPV4_ONLY:
            import socket
            from tornado.netutil import bind_sockets

            sockets = bind_sockets(options.port, options.address, family=socket.AF_INET)
        else:
            sockets = bind_sockets(options.port, options.address)

        self.print_settings_info()
        http_server = tornado.httpserver.HTTPServer(self.application)
        http_server.add_sockets(sockets)
        tornado.ioloop.IOLoop.instance().start()
        print 'tornado server started. listen port: %s ,host address: %s' % (options.port, options.address)

def bind_unused_port():
    """Binds a server socket to an available port on localhost.
    Returns a tuple (socket, port).
    """
    [sock] = netutil.bind_sockets(None, 'localhost', family=socket.AF_INET)
    port = sock.getsockname()[1]
    return sock, port

def start_game():
    ''' Main entry point for the application '''
    cache_actions()
    sockets = netutil.bind_sockets(8888)
    #if process.task_id() == None:
    #    tornado.process.fork_processes(-1, max_restarts = 10)
    server = HTTPServer(application)
    server.add_sockets(sockets)
    io_loop = IOLoop.instance()
    session_manager = SessionManager.Instance()
    if process.task_id() == None:
        scoring = PeriodicCallback(scoring_round, application.settings['ticks'], io_loop = io_loop)
        session_clean_up = PeriodicCallback(session_manager.clean_up, application.settings['clean_up_timeout'], io_loop = io_loop)
        scoring.start()
        session_clean_up.start()
    try:
        for count in range(3, 0, -1):
            logging.info("The game will begin in ... %d" % (count,))
            sleep(1)
        logging.info("Good hunting!")
        io_loop.start()
    except KeyboardInterrupt:
        if process.task_id() == 0:
            print '\r[!] Shutdown Everything!'
            session_clean_up.stop()
            io_loop.stop()

    def initialize(self, cfg):
        self.cfg = cfg

        # Check we have a certificate and key defines
        if not cfg.ssl_cert_file or not cfg.ssl_key_file:
            log.error('a valid ssl_cert_file and ssl_key_file are required, '
                      'aborting')
            sys.exit(1)

        # Set up the SSL context
        try:
            ssl_context = ssl.create_default_context(
                purpose=ssl.Purpose.CLIENT_AUTH,
                cafile=cfg.ssl_ca_file)
        except IOError as e:
            log.error('cannot read ssl_ca_file: {}'.format(e.args[1]))
            sys.exit(1)
        self.ssl_context = ssl_context

        # Enable client certificate verification if wanted
        if cfg.ssl_verify_client:
            ssl_context.verify_mode = ssl.CERT_REQUIRED

        # Load our own certificate into the server
        try:
            ssl_context.load_cert_chain(
                certfile=cfg.ssl_cert_file,
                keyfile=cfg.ssl_key_file)
        except IOError as e:
            log.error('cannot read ssl_cert_file or ssl_key_file: {}'
                      .format(e.args[1]))
            sys.exit(1)

        self.app = NrpeApplication(cfg)

        # Set up the HTTPServer instance
        super(NrpeHTTPServer, self).initialize(
            self.app, no_keep_alive=True, ssl_options=ssl_context,
            idle_connection_timeout=cfg.connection_timeout,
            body_timeout=cfg.connection_timeout)

        # Because Tornado unconditionally sets IPV6_V6ONLY on IPv6 sockets, we
        # need a means to preserve old behaviour. This should only be an issue
        # when listening to '::' for IPv6 any-address. Tornado will listen both
        # the IPv4 and IPv6 any-address when the bind address is blank, so just
        # set the address to be empty if we encounter '::'.
        server_address = cfg.server_address
        if server_address == '::':
            server_address = ''

        try:
            self.sockets = bind_sockets(port=cfg.server_port,
                                        address=server_address)
        except socket.error as e:
            log.error('failed to bind socket: {}'.format(e.args[1]))
            sys.exit(1)

        # Prevent tornado from logging HTTP requests
        if not self.cfg.debug:
            logging.getLogger('tornado.access').disabled = True

def main():
    script_path = os.path.dirname(os.path.realpath(__file__))
    config_path = os.path.join(script_path, 'etc/harvest.cfg')

    config = ConfigParser()
    config.read(config_path)

    sockets = bind_sockets(config.get('server', 'port'),
                           config.get('server', 'address'))
    fork_processes(config.getint('server', 'instances'))

    datastore = DataStore(config.get('datastore', 'host'),
                          config.getint('datastore', 'port'),
                          config.get('datastore', 'username'),
                          config.get('datastore', 'password'),
                          config.get('datastore', 'database'))

    app = Application([(r"/rpc/store", Handler,
                       {'datastore': datastore,
                        'api_key': config.get('server', 'api_key')})])

    server = HTTPServer(app,
                        no_keep_alive=config.get('server', 'no_keep_alive'),
                        ssl_options={
                            'certfile': config.get('server', 'certfile'),
                            'keyfile': config.get('server', 'keyfile')})

    server.add_sockets(sockets)
    IOLoop.instance().start()

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 start_server():
    ''' Main entry point for the application '''
    if options.debug:
        logging.warn("%sDebug mode is enabled; DO NOT USE THIS IN PRODUCTION%s" % (
            bold + R, W
        ))
    if options.autostart_game:
        logging.info("The game is about to begin, good hunting!")
        app.settings['history_callback'].start()
        if options.use_bots:
            app.settings['score_bots_callback'].start()
    # Setup server object
    if options.ssl:
        server = HTTPServer(app,
                            ssl_options={
                                "certfile": options.certfile,
                                "keyfile": options.keyfile,
                            },
                            xheaders=options.x_headers
                            )
    else:
        server = HTTPServer(app, xheaders=options.x_headers)
    sockets = netutil.bind_sockets(options.listen_port, options.listen_interface)
    server.add_sockets(sockets)
    Scoreboard.now(app)
    try:
        io_loop.start()
    except KeyboardInterrupt:
        sys.stdout.write('\r' + WARN + 'Shutdown Everything!\n')
    except:
        logging.exception("Main i/o loop threw exception")
    finally:
        io_loop.stop()
        _exit(0)

def make_http_server(loop, request_handler):
    server = HTTPServer(request_handler, io_loop=loop)
    sockets = bind_sockets(0, HOST, family=FAMILY)
    assert len(sockets) == 1
    server.add_sockets(sockets)
    sock = sockets[0]
    return sock

    def test_chunked_close(self):
        # test case in which chunks spread read-callback processing
        # over several ioloop iterations, but the connection is already closed.
        port = get_unused_port()
        (sock,) = netutil.bind_sockets(port, address="127.0.0.1")
        with closing(sock):
            def write_response(stream, request_data):
                stream.write(b("""\
HTTP/1.1 200 OK
Transfer-Encoding: chunked

1
1
1
2
0

""").replace(b("\n"), b("\r\n")), callback=stream.close)
            def accept_callback(conn, address):
                # fake an HTTP server using chunked encoding where the final chunks
                # and connection close all happen at once
                stream = IOStream(conn, io_loop=self.io_loop)
                stream.read_until(b("\r\n\r\n"),
                                  functools.partial(write_response, stream))
            netutil.add_accept_handler(sock, accept_callback, self.io_loop)
            self.http_client.fetch("http://127.0.0.1:%d/" % port, self.stop)
            resp = self.wait()
            resp.rethrow()
            self.assertEqual(resp.body, b("12"))

    def make_iostream_pair(self, **kwargs):
        port = get_unused_port()
        [listener] = netutil.bind_sockets(port, '127.0.0.1',
                                          family=socket.AF_INET)
        streams = [None, None]

        def accept_callback(connection, address):
            streams[0] = self._make_server_iostream(connection, **kwargs)
            if isinstance(streams[0], SSLIOStream):
                # HACK: The SSL handshake won't complete (and
                # therefore the client connect callback won't be
                # run)until the server side has tried to do something
                # with the connection.  For these tests we want both
                # sides to connect before we do anything else with the
                # connection, so we must cause some dummy activity on the
                # server.  If this turns out to be useful for real apps
                # it should have a cleaner interface.
                streams[0]._add_io_state(IOLoop.READ)
            self.stop()

        def connect_callback():
            streams[1] = client_stream
            self.stop()
        netutil.add_accept_handler(listener, accept_callback,
                                   io_loop=self.io_loop)
        client_stream = self._make_client_iostream(socket.socket(), **kwargs)
        client_stream.connect(('127.0.0.1', port),
                              callback=connect_callback)
        self.wait(condition=lambda: all(streams))
        self.io_loop.remove_handler(listener.fileno())
        listener.close()
        return streams