Python HTTPServer.listen方法代码示例

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
 def run(self):
   try:
     has_deps = True
     try:
       from tornado.wsgi import WSGIContainer
       from tornado.httpserver import HTTPServer
       from tornado.ioloop import IOLoop
     except: 
       print('- !! Unable to run local server; missing dependency: tornado')
       has_deps = False
     try:
       from werkzeug import SharedDataMiddleware
       from flask import Flask
     except: 
       print('- !! Unable to run local server; missing dependency: flask')
       has_deps = False
     if not has_deps:
       return
     http_server = HTTPServer(WSGIContainer(self.app))
     http_server.listen(self.port)
     IOLoop.instance().start()
   except Exception as e:
     print('Failed to run flask server: {0}'.format(e))
     import traceback
     traceback.print_exc()
     os._exit(0)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def startTornado():
    global http_server
    http_server = HTTPServer(WSGIContainer(create_app("settings.DevelopmentConfig")))
    http_server.listen(80)
    ioloop = IOLoop.instance()
    autoreload.start(ioloop)
    ioloop.start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
class Proxy:

    def __init__(self, proxy_port, app_port):
        self._proxy_port = proxy_port
        self._app_port = app_port

    def _create_app(self):
        app = tornado.web.Application(
            [
                (r"/.*", MainHandler, dict(app_port=self._app_port))
            ],
            xsrf_cookies=False,
            debug=True)
        return app

    def serve_forever(self):
        app = self._create_app()
        self._server = HTTPServer(app)
        self._server.listen(port=self._proxy_port, address='127.0.0.1')
        self._ioloop = tornado.ioloop.IOLoop.instance()
        self._ioloop.start()  # this is a blocking call, server has stopped on next line
        self._ioloop = None

    def shutdown(self):
        if self._ioloop:
            self._server.stop()
            self._ioloop.stop()

    def run_on_a_thread(self):
        process = multiprocessing.Process(target=self.serve_forever)
        process.start()
        time.sleep(1)  # just let it start
        return lambda: process.terminate()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main():
    global http_server

    try:
        signal(SIGTERM, on_signal)

        parse_command_line()
        if options.config != None:
            parse_config_file(options.config)

        path = join(dirname(__file__), "templates")

        application = Application(
            [(r"/", IndexHandler), (r"/stock", StockHandler)],
            template_path=path,
            static_path=join(dirname(__file__), "static"),
        )

        application.db = motor.MotorClient(options.db_host, options.db_port).open_sync()[options.db_name]

        http_server = HTTPServer(application)
        http_server.listen(options.port, options.address)
        log().info("server listening on port %s:%d" % (options.address, options.port))
        if log().isEnabledFor(DEBUG):
            log().debug("autoreload enabled")
            tornado.autoreload.start()
        IOLoop.instance().start()

    except KeyboardInterrupt:
        log().info("exiting...")

    except BaseException as ex:
        log().error("exiting due: [%s][%s]" % (str(ex), str(format_exc().splitlines())))
        exit(1)

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
 def build_webapp_thread(self, port=26000):
     app.session = self
     http_server = HTTPServer(WSGIContainer(app))
     http_server.listen(port)
     flask_thread = threading.Thread(target=IOLoop.instance().start)
     flask_thread.daemon = True
     return flask_thread

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main():
    port = int(os.environ['CTPLOT_PORT']) if 'CTPLOT_PORT' in os.environ else 8080
    print 'listening on', port

    http_server = HTTPServer(WSGIContainer(application))
    http_server.listen(port)
    IOLoop.instance().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main():

    global NODES_DATABASE

    ###--log_file_prefix=./server.log
    ###--logging=debug
    enable_pretty_logging()
    options.parse_command_line()

    cur_dir = os.path.split(os.path.realpath(__file__))[0]

    if options.mode == 'online':
        fetch_node_info()
    else:
        db_file_path = '%s/nodes_db_lean.json' % cur_dir

        if not os.path.exists(db_file_path):
            fetch_node_info()
        else:
            NODES_DATABASE = json.load(open(db_file_path))
            gen_log.info('load nodes database from json done!')
            gen_log.debug(NODES_DATABASE)


    app = myApplication()
    http_server = HTTPServer(app)
    http_server.listen(8080)


    tcp_server = DeviceServer()
    tcp_server.listen(8000)

    gen_log.info("server's running in lean mode ...")

    ioloop.IOLoop.current().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
class WebsocketServer(tornado.web.Application):
    def __init__(self, client_handler=ClientHandler, settings={}):
        tornado.web.Application.__init__(
            self,
            [(WEBSOCKET_APPLICATION, client_handler, settings)],
            debug=True)
        self._loop = tornado.ioloop.IOLoop.instance()
        self._listen(WEBSOCKET_PORT)
        self.client_handlers = set()

    def _listen(self, port, address="", **kwargs):
        self._server = HTTPServer(self, **kwargs)
        self._server.listen(port, address)

    def start(self):
        self._loop.start()

    def stop(self):
        self._loop.stop()
        self._server.stop()

    def add_periodic_callback(self, callback, callback_time):
        periodic_callback = tornado.ioloop.PeriodicCallback(callback, callback_time, self._loop)
        periodic_callback.start()

    def client_subscribes_to(self, event_type):
        for handler in self.client_handlers:
            if event_type in handler.subscribed_events:
                return True

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def run_tornado(addr, port):
    # Don't try to read the command line args from openslides
    parse_command_line(args=[])

    # Print listening address and port to command line
    if addr == '0.0.0.0':
        url_string = "the machine's local ip address"
    else:
        url_string = 'http://%s:%s' % (addr, port)
    # TODO: don't use print, use django logging
    print("Starting OpenSlides' tornado webserver listening to %(url_string)s" % {'url_string': url_string})

    # Setup WSGIContainer
    app = WSGIContainer(get_wsgi_application())

    # Collect urls
    projectpr_socket_js_router = SockJSRouter(ProjectorSocketHandler, '/projector/socket')
    from openslides.core.chatbox import ChatboxSocketHandler
    chatbox_socket_js_router = SockJSRouter(ChatboxSocketHandler, '/core/chatbox')
    other_urls = [
        (r"%s(.*)" % settings.STATIC_URL, DjangoStaticFileHandler),
        (r'%s(.*)' % settings.MEDIA_URL, StaticFileHandler, {'path': settings.MEDIA_ROOT}),
        ('.*', FallbackHandler, dict(fallback=app))]

    # Start the application
    debug = settings.DEBUG
    tornado_app = Application(projectpr_socket_js_router.urls + chatbox_socket_js_router.urls + other_urls, debug=debug)
    server = HTTPServer(tornado_app)
    server.listen(port=port, address=addr)
    IOLoop.instance().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main():
    tornado.options.parse_command_line()
    app = Application()
    app.load()
    server = HTTPServer(app)
    server.listen(3000, '127.0.1.4')
    tornado.ioloop.IOLoop.current().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main(args=None):
    
    pid = os.getpid()

    logging.basicConfig(filename=conf.DEPLOYER_LOG_FILE, level=getattr(logging, conf.DEPLOYER_LOGLEVEL.upper()))

    #Replace with SSLContext (this option is maintained for compatibility reasons)
    httpServer = HTTPServer(app, ssl_options={ 
        "certfile": conf.APPCERT,
        "keyfile": conf.APPKEY,
    })

    httpServer.listen(conf.DEPLOYER_PORT)

    nonsecure_app.listen(conf.NON_SECURE_DEPLOYER_PORT)
    
    while True:
        try:
            Polo().publish_service(conf.DEPLOYER_SERVICE_NAME, root=True)
            break
        except PoloInternalException as e:
            logging.warning(e)
            time.sleep(1)
        except PoloException as i:
            logging.warning(i)
            break

    logging.info("Serving on port %d" % conf.DEPLOYER_PORT)
    io_loop.start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def StartFrontend(front, rootPath=None):
    from os import path
    # Получаем настройки фронтэнда   
    if isinstance(front, dict) is False:
        raise Exception('Invalid frontend settings')

    #включаем отладку торнадо не в продакшн
    if not RUNTYPE_PRODUCTION:
        logging.root = servlog.logger
        #from tornado.options import options
        #options.logging = 'error'

    # Создаем торнадо-приложение
    # к маршрутам добавлется маска статических данных, загружаемых напрямую из папки static
    application = tornado.web.Application(
        [
            (r"/(.*\.(css|xml|html|swf|swc|js|jpg|png|gif|ico))$", tornado.web.StaticFileHandler,
             {"path": path.join(rootPath, 'static')}),
            (r"/statistics", StatisticsHandler, dict(dataprov=DataProvider())),
            (r"/$", MainHandler)
        ],
        template_path=path.join(rootPath, 'templates')
    )

    # Запускаем фронтэнд
    try:
        servlog.info('Starting frontend on port %s' % str(front['WebPort']))
        server = HTTPServer(application)
        server.listen(front['WebPort'])
        tornado.ioloop.IOLoop.instance().start()
    except Exception as ex:
        from traceback import format_exc

        servlog.error(': '.join(['Frontend Exception caught', str(ex)]), details='Traceback: %s' % format_exc())

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def main():

    application = Application([
        (r"/apps/(?P<organization>.+)/(?P<repo>.+)/status", GithubStatusHandler),
        (r"/apps/(?P<organization>.+)/(?P<repo>.+)/logs/static", StaticLogsHandler),
        (r"/apps/(?P<organization>.+)/(?P<repo>.+)/logs/live", LiveLogsHandler),
        (r"/apps/(?P<organization>.+)/(?P<repo>.+)", GithubBuildHandler),
        (r"/apps/(?P<app_id>.+)", OtherSourceHandler),
        (r"/running", RunningAppsHandler),
        (r"/services", ServicesHandler),
        (r"/apps", AppsHandler),
        (r"/capacity", CapacityHandler)
    ], debug=False)

    global builder
    builder = Builder(build_queue, PRELOAD)
    builder.start()

    http_server = HTTPServer(application)
    http_server.listen(PORT)

    signal.signal(signal.SIGTERM, sig_handler)
    signal.signal(signal.SIGINT, sig_handler)

    print("Binder API server running on port {}".format(PORT))
    IOLoop.current().set_blocking_log_threshold(3)
    IOLoop.current().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
class TornadoServer(object):
    def __init__(self):
        """
        Initializes the server params
        """
        container = WSGIContainer(app)
        path = self._get_static_path()
        settings = {'template_path': path, 'static_path': path, 'debug': True}
        application = WSGIApplication(
            [(r"/", _MainHandler),
             ('.*', FallbackHandler, dict(fallback=container)), ],
            **settings)

        self._server = HTTPServer(application)

    @staticmethod
    def _get_static_path():
        """ Get the location of the service configuration folder """

        folder = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'app')
        return folder

    def start_server(self):
        port = 8080
        self._server.listen(port)
        print '>>> Tornado Server started on port : {port} <<<'.format(port=port)
        IOLoop.instance().start()

# 需要导入模块: from tornado.httpserver import HTTPServer [as 别名]
# 或者: from tornado.httpserver.HTTPServer import listen [as 别名]
def runserver():
    tornado.options.parse_command_line()
    http_server = HTTPServer(Application(), xheaders=True)
    http_server.listen(options.port)
    loop = tornado.ioloop.IOLoop.instance()
    print 'Server running on http://localhost:%d' % (options.port)
    loop.start()