Python HTTPServer.add_socket方法代码示例

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
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)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
def main():
    parse_command_line()
    sock = socket.fromfd(options.fd, socket.AF_UNIX, socket.SOCK_STREAM)
    server = HTTPServer(application)
    server.add_socket(sock)
    server.start(1)
    tornado.ioloop.IOLoop.instance().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
 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()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
class SyncHTTPClientTest(unittest.TestCase):
    def setUp(self):
        self.server_ioloop = IOLoop()
        event = threading.Event()

        @gen.coroutine
        def init_server():
            sock, self.port = bind_unused_port()
            app = Application([("/", HelloWorldHandler)])
            self.server = HTTPServer(app)
            self.server.add_socket(sock)
            event.set()

        def start():
            self.server_ioloop.run_sync(init_server)
            self.server_ioloop.start()

        self.server_thread = threading.Thread(target=start)
        self.server_thread.start()
        event.wait()

        self.http_client = HTTPClient()

    def tearDown(self):
        def stop_server():
            self.server.stop()
            # Delay the shutdown of the IOLoop by several iterations because
            # the server may still have some cleanup work left when
            # the client finishes with the response (this is noticeable
            # with http/2, which leaves a Future with an unexamined
            # StreamClosedError on the loop).

            @gen.coroutine
            def slow_stop():
                # The number of iterations is difficult to predict. Typically,
                # one is sufficient, although sometimes it needs more.
                for i in range(5):
                    yield
                self.server_ioloop.stop()

            self.server_ioloop.add_callback(slow_stop)

        self.server_ioloop.add_callback(stop_server)
        self.server_thread.join()
        self.http_client.close()
        self.server_ioloop.close(all_fds=True)

    def get_url(self, path):
        return "http://127.0.0.1:%d%s" % (self.port, path)

    def test_sync_client(self):
        response = self.http_client.fetch(self.get_url("/"))
        self.assertEqual(b"Hello world!", response.body)

    def test_sync_client_error(self):
        # Synchronous HTTPClient raises errors directly; no need for
        # response.rethrow()
        with self.assertRaises(HTTPError) as assertion:
            self.http_client.fetch(self.get_url("/notfound"))
        self.assertEqual(assertion.exception.code, 404)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
def main(arguments=None):
    """Runs thumbor server with the specified arguments."""

    server_parameters = get_server_parameters(arguments)

    lookup_paths = [os.curdir, expanduser("~"), "/etc/", dirname(__file__)]

    config = Config.load(
        server_parameters.config_path,
        conf_name="thumbor.conf",
        lookup_paths=lookup_paths,
    )

    logging.basicConfig(
        level=getattr(logging, server_parameters.log_level.upper()),
        format=config.THUMBOR_LOG_FORMAT,
        datefmt=config.THUMBOR_LOG_DATE_FORMAT,
    )

    importer = Importer(config)
    importer.import_modules()

    if importer.error_handler_class is not None:
        importer.error_handler = importer.error_handler_class(config)

    if server_parameters.security_key is None:
        server_parameters.security_key = config.SECURITY_KEY

    if not isinstance(server_parameters.security_key, basestring):
        raise RuntimeError(
            "No security key was found for this instance of thumbor. "
            + "Please provide one using the conf file or a security key file."
        )

    context = Context(server=server_parameters, config=config, importer=importer)

    application = importer.import_class(server_parameters.app_class)(context)

    server = HTTPServer(application)

    if context.server.fd is not None:
        fd_number = get_as_integer(context.server.fd)
        if fd_number is None:
            with open(context.server.fd, "r") as sock:
                fd_number = sock.fileno()

        sock = socket.fromfd(fd_number, socket.AF_UNIX, socket.SOCK_STREAM)
        server.add_socket(sock)
    else:
        server.bind(context.server.port, context.server.ip)

    server.start(1)

    try:
        logging.debug(
            "thumbor running at %s:%d" % (context.server.ip, context.server.port)
        )
        tornado.ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        print("-- thumbor closed by user interruption --")

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
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

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
class WebTest(AsyncTestCase):
    def setUp(self):
        super(WebTest, self).setUp()
        self.application = Application()
        self.server = HTTPServer(self.application)
        self.socket, self.port = testing.bind_unused_port()
        self.server.add_socket(self.socket)
        self.static_path = os.path.join(os.path.dirname(wsrpc.__file__), 'static')

    @coroutine
    def fetch(self, filename):
        response = yield AsyncHTTPClient().fetch("http://localhost:{0.port}/static/{1}".format(self, filename))
        self.assertTrue(response.code, 200)
        self.assertEqual(
            response.body.decode('utf-8'),
            codecs.open(os.path.join(self.static_path, filename), 'r', 'utf-8').read()
        )

    @gen_test
    def test_wsrpc_js(self):
        yield self.fetch('wsrpc.js')

    @gen_test
    def test_q_js(self):
        yield self.fetch('q.js')

    @gen_test
    def test_q_min_js(self):
        yield self.fetch('q.min.js')

    @gen_test
    def test_wsrpc_min_js(self):
        yield self.fetch('wsrpc.min.js')

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
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)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
 def setUp(self):
     super(AsyncHTTPTestCaseTest, self).setUp()
     # Bind a second port.
     sock, port = bind_unused_port()
     app = Application()
     server = HTTPServer(app, **self.get_httpserver_options())
     server.add_socket(sock)
     self.second_port = port
     self.second_server = server

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
    def listen(self, port, address="", **kwargs):
        if options.fd:
            from tornado.httpserver import HTTPServer
            sock = socket.fromfd(options.fd, socket.AF_INET, socket.SOCK_STREAM)

            server = HTTPServer(self, **kwargs)
            server.add_socket(sock)
        else:
            super(Application, self).listen(port, address, **kwargs)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
class HttpEndpoint(object):

    def __init__(self, uri='127.0.0.1:5000', backlog=128,
            ssl_options=None):
        # uri should be a list
        if isinstance(uri, six.string_types):
            self.uri = uri.split(",")
        else:
            self.uri = uri
        self.backlog = backlog
        self.ssl_options = ssl_options
        self.server = None
        self.loop = None
        self.io_loop = None

    def __str__(self):
        return ",".join(self.uri)

    def start(self, loop, app):
        for uri in self.uri:
            logger.info('Start new endpoint at http://%s', uri)
        self.loop = loop
        self.app = app
        self.io_loop = IOLoop(_loop=loop)
        self._start_server()

    def _start_server(self):
        self.server = HTTPServer(self.app, io_loop=self.io_loop,
                ssl_options=self.ssl_options)

        # bind the handler to needed interface
        for uri in self.uri:
            addr = parse_address(uri)
            if isinstance(addr, six.string_types):
                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=self.backlog)
            else:
                sock = netutil.bind_sockets(addr[1], backlog=self.backlog)

            if isinstance(sock, list):
                for s in sock:
                    self.server.add_socket(s)
            else:
                self.server.add_socket(sock)

        # start the server
        self.server.start()

    def stop(self):
        self.server.stop()
        self.io_loop.close()

    def restart(self):
        self.server.stop()
        self._start_server()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
class TestWebSocketBase(AsyncTestCase):
    def setUp(self):
        super(TestWebSocketBase, self).setUp()
        self.application = Application()
        self.server = HTTPServer(self.application)
        self.socket, self.port = testing.bind_unused_port()
        self.server.add_socket(self.socket)
        self.instance = WebSocketBase(self.application, HTTPServerRequest(
            method="GET",
            uri='/',
            version="HTTP/1.0",
            headers=HTTPHeaders(),
            body=BytesIO(),
            host=None,
            files=None,
            connection=HTTP1Connection(
                stream=IOStream(socket.socket()),
                is_client=False
            ),
            start_line=RequestStartLine(method='GET', path='/', version='HTTP/1.1'),
        ))
        self.instance.open()

    def test_configure(self):
        keepalive_timeout = randint(999, 9999)
        client_timeout = randint(999, 9999)
        WebSocketBase.configure(keepalive_timeout=keepalive_timeout, client_timeout=client_timeout)
        self.assertEqual(WebSocketBase._CLIENT_TIMEOUT, client_timeout)
        self.assertEqual(WebSocketBase._KEEPALIVE_PING_TIMEOUT, keepalive_timeout)

    def test_authorize(self):
        self.assertEqual(self.instance.authorize(), True)

    def test_execute(self):
        resp = self.instance._execute([])
        self.assertTrue(isinstance(resp, Future))

        resp = self.instance._execute(None)
        self.assertTrue(isinstance(resp, Future))

    def test_allowdraft76(self):
        self.assertEqual(self.instance.allow_draft76(), True)

    def send_message(self, msg):
        return self.instance.on_message(json.dumps(msg))

    @gen_test
    def test_on_message(self):
        try:
            yield self.send_message({})
        except Exception as e:
            self.assertEqual(type(e), AssertionError)

        result = yield self.send_message({'serial': 999, 'type': 'call'})
        result = yield self.send_message({'serial': 999, 'type': 'callback'})
        result = yield self.send_message({'serial': 999, 'type': 'error'})

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
def _init(index, crc, settings_path, server_id):
    global log, game_server_process, _loop
    game_server_process = GameProcess(index, crc, settings_path, server_id, loop=_loop)
    settings = game_server_process.settings

    setup_logger(settings)
    log = game_server_process.logger = getLogger('process')

    tornado_port = game_server_process.ports['tornado']
    unix_socket = game_server_process.sockets['tornado']
    environment_variables = setup_game_server(settings, tornado_port)
    environment_variables['data_format'] = settings['data_format']
    environment_variables['game_settings'] = settings
    environment_variables['logger'] = log
    environment_variables['server_process'] = game_server_process

    handlers = [
        (r'/crossdomain.xml', CrossDomainHandler),
        (r'/data/(.*)', StaticDataHandler, environment_variables),
        (r'/', GameServerHandler, environment_variables),

    ]
    app_settings = {}
    if settings['development_mode']:
        log.info('Development mode on')
        development_handlers = [
            (r'/static/(.+)', DevelopmentStaticHandler, {
                'path': [
                    norm_path('engine', 'social', 'static'),
                    norm_path('..', 'static'),
                    norm_path('..', 'data')
                ]
            }),
            # THIS IS TEMPORARY
            (r'/(.+)', DevelopmentStaticHandler, {
                'path': [
                    norm_path('engine', 'social', 'static'),
                    norm_path('..', 'static')
                ]
            })
        ]
        handlers += development_handlers
        app_settings['debug'] = True

    game_server_application = Application(handlers, app_settings)

    if unix_socket:
        server = HTTPServer(game_server_application)
        log.info('Tornado running through socket {0}'.format(unix_socket))
        socket = tornado.netutil.bind_unix_socket(unix_socket, mode=0o757)
        server.add_socket(socket)
    else:
        log.info('Tornado listening to {0}'.format(tornado_port))
        game_server_application.listen(tornado_port, address=settings['machine_address'])
    log.info('game.{} : Game server started.'.format(server_id))
    game_server_process.start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
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)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import add_socket [as 别名]
def main(arguments=None):
    '''Runs thumbor server with the specified arguments.'''

    server_parameters = get_server_parameters(arguments)

    lookup_paths = [os.curdir,
                    expanduser('~'),
                    '/etc/',
                    dirname(__file__)]

    config = Config.load(server_parameters.config_path, conf_name='thumbor.conf', lookup_paths=lookup_paths)

    logging.basicConfig(
        level=getattr(logging, server_parameters.log_level.upper()),
        format=config.THUMBOR_LOG_FORMAT,
        datefmt=config.THUMBOR_LOG_DATE_FORMAT
    )

    importer = Importer(config)
    importer.import_modules()

    if importer.error_handler_class is not None:
        importer.error_handler = importer.error_handler_class(config)

    if server_parameters.security_key is None:
        server_parameters.security_key = config.SECURITY_KEY

    if not isinstance(server_parameters.security_key, basestring):
        raise RuntimeError(
            'No security key was found for this instance of thumbor. ' +
            'Please provide one using the conf file or a security key file.')

    context = Context(server=server_parameters, config=config, importer=importer)

    application = importer.import_class(server_parameters.app_class)(context)

    server = HTTPServer(application)

    if context.server.fd is not None:
        sock = socket.fromfd(context.server.fd,
                             socket.AF_INET | socket.AF_INET6,
                             socket.SOCK_STREAM)
        server.add_socket(sock)
    else:
        server.bind(context.server.port, context.server.ip)

    server.start(1)

    try:
        logging.debug('thumbor running at %s:%d' % (context.server.ip, context.server.port))
        tornado.ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        print
        print "-- thumbor closed by user interruption --"