def inner_run() -> None: from django.conf import settings from django.utils import translation translation.activate(settings.LANGUAGE_CODE) print("Validating Django models.py...") self.check(display_num_errors=True) print("\nDjango version %s" % (django.get_version())) print("Tornado server is running at http://%s:%s/" % (addr, port)) print("Quit the server with %s." % (quit_command,)) if settings.USING_RABBITMQ: queue_client = get_queue_client() # Process notifications received via RabbitMQ queue_client.register_json_consumer(notify_tornado_queue_name(int(port)), process_notification) queue_client.register_json_consumer(tornado_return_queue_name(int(port)), respond_send_message) try: # Application is an instance of Django's standard wsgi handler. application = create_tornado_application(int(port)) if settings.AUTORELOAD: zulip_autoreload_start() # start tornado web server in single-threaded mode http_server = httpserver.HTTPServer(application, xheaders=xheaders, no_keep_alive=no_keep_alive) http_server.listen(int(port), address=addr) setup_event_queue(int(port)) add_client_gc_hook(missedmessage_hook) setup_tornado_rabbitmq() instance = ioloop.IOLoop.instance() if django.conf.settings.DEBUG: instance.set_blocking_log_threshold(5) instance.handle_callback_exception = handle_callback_exception instance.start() except KeyboardInterrupt: sys.exit(0)
def serve(self): ''' Start server listening on port, launch browser if requested, and start the ioloop. ''' self.http_server = httpserver.HTTPServer(self.app) for retry in range(3): try: if self.options.external: self.http_server.listen(self.options.port) else: self.http_server.listen(self.options.port, address='localhost') except socket.error: # Possibly 'Address already in use', try finding another port. if self.options.orig_port < 1 and retry < 2: self.options.port = get_unused_ip_port() else: raise else: break if not self.options.serveronly: launch_browser(self.options.port, self.options.browser) if self.options.external: print '***********************************************************' print '** WARNING: You have exposed the server to the external **' print '** network. THIS IS NOT SAFE!! Clients will **' print '** have access to a command prompt on the host **' print '** computer with the identity and privileges of **' print '** the userid under which the server was run. **' print '** **' print '** This is very dangerous and you should NOT do it. **' print '** You exercise this option at your own risk!!! **' print '** (Ctrl-C to terminate server) **' print '***********************************************************' DEBUG('Serving on port %d' % self.options.port) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: DEBUG('interrupt received, shutting down.')
def main(): args = parse_arg() config = Config() if args.template != default_template: app_log.info("Using custom template: %s", args.template) config.HTMLExporter.template_file = args.template config.NbconvertApp.fileext = 'html' # config.CSSHTMLHeaderTransformer.enabled = False template_path = pjoin(here, 'templates') static_path = pjoin(here, 'static') document_path = current_path exporter = HTMLExporter(config=config, log=app_log) env = Environment(loader=FileSystemLoader(template_path)) env.filters['markdown'] = markdown.markdown # notebook notebook_manager = FileNotebookManager(notebook_dir=current_path, log=app_log) settings = dict( jinja2_env=env, static_path=static_path, exporter=exporter, config=config, pool=ThreadPoolExecutor(threads), gzip=True, log=app_log, render_timeout=20, document_path=document_path, notebook_manager=notebook_manager, ) app = web.Application(handlers, debug=True, **settings) http_server = httpserver.HTTPServer(app, xheaders=True) app_log.info("Listening on port %i", args.port) http_server.listen(args.port) instance = ioloop.IOLoop.instance() tornado.autoreload.start(instance) instance.start()
def init_webapp(self): """initialize tornado webapp and httpserver""" self.web_app = NotebookWebApplication(self, self.kernel_manager, self.notebook_manager, self.cluster_manager, self.log, self.base_project_url, self.webapp_settings) if self.certfile: ssl_options = dict(certfile=self.certfile) if self.keyfile: ssl_options['keyfile'] = self.keyfile else: ssl_options = None self.web_app.password = self.password self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options) if ssl_options is None and not self.ip and not (self.read_only and not self.password): self.log.critical( 'WARNING: the notebook server is listening on all IP addresses ' 'but not using any encryption or authentication. This is highly ' 'insecure and not recommended.') success = None for port in random_ports(self.port, self.port_retries + 1): try: self.http_server.listen(port, self.ip) except socket.error as e: if e.errno != errno.EADDRINUSE: raise self.log.info( 'The port %i is already in use, trying another random port.' % port) else: self.port = port success = True break if not success: self.log.critical( 'ERROR: the notebook server could not be started because ' 'no available port could be found.') self.exit(1)
def __init__(self, ioloop=None, aioloop=None, mosquittoClient=None): self.ioloop = ioloop self.aioloop = aioloop self.mosquittoClient = mosquittoClient if self.ioloop == None: raise TypeError('ioloop error') if self.aioloop == None: raise TypeError('aioloop error') self.clientObjectSet = set() self.urlpatterns = [ (r'/', WebsocketClient, { 'server': self }), # 提供静态资源,调试时使用 # (r'/(.*)', StaticFileHandler,{'path': os.path.join(os.path.dirname(__file__), 'static/html'), 'default_filename': 'index.html'}) ] # self.ioloop.add_timeout(self.ioloop.time()+1,self.checkWebsocketClientHeart) ssl_options = { 'certfile': '/ssl_file/websocket.pem', 'keyfile': '/ssl_file/websocket.key' } app = web.Application( self.urlpatterns, debug=DEBUG, # autoreload=True, # compiled_template_cache=False, # static_hash_cache=False, # serve_traceback=True, static_path=os.path.join(os.path.dirname(__file__), 'static'), template_path=os.path.join(os.path.dirname(__file__), 'template'), autoescape=None, # 全局关闭模板转义功能 ) # if DEBUG: wsServer = httpserver.HTTPServer(app) # else: # wsServer = httpserver.HTTPServer(app, ssl_options=ssl_options) wsServer.listen(options.websocket_service_port) self.ioloop.add_timeout(self.ioloop.time() + 10, self.checkWebsocketClientHeart)
def postprocess(self, input): """Serve the build directory with a webserver.""" dirname, filename = os.path.split(input) handlers = [(r"/(.+)", web.StaticFileHandler, { 'path': dirname }), (r"/", web.RedirectHandler, { "url": "/%s" % filename })] if ('://' in self.reveal_prefix or self.reveal_prefix.startswith("//")): # reveal specifically from CDN, nothing to do pass elif os.path.isdir(os.path.join(dirname, self.reveal_prefix)): # reveal prefix exists self.log.info("Serving local %s", self.reveal_prefix) else: self.log.info("Redirecting %s requests to %s", self.reveal_prefix, self.reveal_cdn) handlers.insert(0, (r"/(%s)/(.*)" % self.reveal_prefix, ProxyHandler)) app = web.Application( handlers, cdn=self.reveal_cdn, client=AsyncHTTPClient(), ) # hook up tornado logging to our logger log.app_log = self.log http_server = httpserver.HTTPServer(app) http_server.listen(self.port, address=self.ip) url = "http://%s:%i/%s" % (self.ip, self.port, filename) print("Serving your slides at %s" % url) print("Use Control-C to stop this server") if self.open_in_browser: webbrowser.open(url, new=2) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: print("\nInterrupted")
def main(): parse_command_line() app = tornado.web.Application([ (r"/api/get_domain", DomainListHandler), (r"/api/get_record", RecordListHandler), (r"/api/create_record", RecordCreateHandler), (r"/api/remove_record", RecordRemoveHandler), (r"/api/update_record", RecordIPUpdateHandler), ], cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), xsrf_cookies=False, debug=options.debug, ) server = httpserver.HTTPServer(app) server.bind(options.port) server.start(1) print('%s Godaddy server start listening at: %s' % (Tool.current_time(), options.port)) ioloop.IOLoop.current().start()
def main(argv=None): init_options() tornado.options.parse_command_line(argv) # create and start the app app = make_app() # load ssl options ssl_options = None if options.sslcert: ssl_options = { 'certfile' : options.sslcert, 'keyfile' : options.sslkey, } http_server = httpserver.HTTPServer(app, xheaders=True, ssl_options=ssl_options) log.app_log.info("Listening on %s:%i, path %s", options.host, options.port, app.settings['base_url']) http_server.listen(options.port, options.host) ioloop.IOLoop.current().start()
def main(): port = int(sys.argv[1]) work_dir = sys.argv[2] kernel_manager = MultiKernelManager(connection_dir=work_dir) # we are only using one kernel: kernel_id = '1' kernel_manager.start_kernel(kernel_id=kernel_id) logging.basicConfig(level=logging.INFO) app = WebApp(kernel_manager) server = httpserver.HTTPServer(app) server.listen(port, '127.0.0.1') app_log.info("Serving at http://127.0.0.1:%s" % port) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: app_log.info("Interrupted...") finally: kernel_manager.shutdown_all()
def main(): if not options.remote_url or not validators.url(options.remote_url): parser.print_help() return app = tornado.web.Application([ (r'.*', ProxyHandler), ]) global PARSED_REMOTE_URL PARSED_REMOTE_URL = urlparse.urlparse(options.remote_url) logger.info('reverse proxy is running...') logger.info('%s:%s <---> %s' % (options.host, options.port, options.remote_url)) signal.signal(signal.SIGINT, signal_handler) server = httpserver.HTTPServer(app, xheaders=True) server.listen(options.port, options.host) # 支持 CTRL+C 退出程序 ioloop.PeriodicCallback(try_exit, 100).start() tornado.ioloop.IOLoop.instance().start()
def main(): ''' run the web server ''' print '<<<' + str(os.getpid()) + '>>> main' settings = { 'template_path': os.path.dirname(os.path.abspath(__file__)), 'debug': True, } application = web.Application([ web.url(r'/', IndexHandler), web.url(r'/floats/?', FloatHandler), web.url(r'/server/?', ServerHandler), web.url(r'/(.*)', SamplesFileHandler), ], **settings) print 'running web server on port:', WEB_SERVER_PORT print "(that's your cue to point your Chrome browser at http://localhost:%d)" % WEB_SERVER_PORT http_server = httpserver.HTTPServer(application) http_server.listen(WEB_SERVER_PORT) ioloop.IOLoop.instance().start()
def _bootstrap_web_server(self): self._bootstrap_action('config') self._bootstrap_action('log') tornado_application = tornado.web.Application( handlers=[ (r"/alarm_status", alarm.AlarmStatusHandler, dict(registry=self.registry)), (r"/text_to_speech", text_to_speech.TextToSpeechHandler, dict(registry=self.registry)), ], template_path=os.path.join(self.registry['project_path'], "templates"), static_path=os.path.join(self.registry['project_path'], "static"), ui_modules={} ) http_server = httpserver.HTTPServer(tornado_application, xheaders=True) http_server.listen(self.registry['config'].get('webserver.port')) self.registry['log'].info('HAL startup') ioloop.IOLoop.instance().start()
def main(): """main""" parser = configargparse.ArgParser(default_config_files=[ os.path.join(CURRENT_DIR, "server.conf"), "server.conf", "/etc/skynet/server.conf" ]) parser.add("--debug", dest="debug", default=False, action="store_true") parser.add("--no-debug", dest="debug", action="store_false") parser.add("--log", dest="log", default="") parser.add("--host", dest="host", default=os.environ.get("BIND", "127.0.0.1")) parser.add("--port", dest="port", type=int, default=int(os.environ.get("PORT", 80))) parser.add("--model", dest="model", required=True) parser.add("--gpu", dest="gpu", default=True, action="store_true") parser.add("--no-gpu", dest="gpu", action="store_false") parser.add("--gpu-memory-fraction", type=float, default=0.40, dest="gpu_memory_fraction") config = vars(parser.parse_args()) setup_log(config["log"]) logging.info("config: %s", config) app = App(config) server = httpserver.HTTPServer(app.http_app()) server.bind(config["port"], address=config["host"]) server.start() logging.info("Server Start! Listen: %s", [x.getsockname() for x in server._sockets.values()]) # pylint: disable=protected-access tornado.ioloop.IOLoop.current().start()
def main(): # 重新设置一下日志级别,默认情况下,tornado 是 info # py2 下 options.logging 不能是 Unicode options.logging = native_str(settings.LOGGING_LEVEL) # parse_command_line 的时候将 logging 的根级别设置为 info options.parse_command_line() # 如果是在 gitlab-ci 环境下运行,redis 的主机需要设置为 redis,同时没有密码 if options.gitlab_ci is not None: settings.REDIS_HOST = 'redis' settings.REDIS_PASSWORD = None # 启动 tornado 之前,先测试 redis 是否能正常工作 RedisHelper.ping_redis() global server app = Application() server = httpserver.HTTPServer(app, xheaders=True) server.listen(options.port, options.host) logger.info('fomalhaut is running on %s:%s' % (options.host, options.port)) signal.signal(signal.SIGTERM, sig_handler) signal.signal(signal.SIGINT, sig_handler) # ioloop.IOLoop.instance().start() if sys.version_info >= (3, 5) and not PYPY: # python 3.5 以上版本,可以使用 uvloop 来加速 # https://github.com/MagicStack/uvloop/issues/35 from tornado.platform.asyncio import AsyncIOMainLoop import asyncio try: import uvloop logger.info('use uvloop as ioloop') asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) AsyncIOMainLoop().install() asyncio.get_event_loop().run_forever() except: ioloop.IOLoop.instance().start() else: ioloop.IOLoop.instance().start()
def start_server(self, port_number, number_of_procs=0): """ Create a HTTP server and start it. :param int port_number: the port number to bind the server to :param int number_of_procs: number of processes to pass to Tornado's ``httpserver.HTTPServer.start``. If the application's ``debug`` setting is ``True``, then we are going to run in a single-process mode; otherwise, we'll let tornado decide how many sub-processes to spawn. The following additional configuration parameters can be set on the ``httpserver.HTTPServer`` instance by setting them in the application settings: ``xheaders``, ``max_body_size``, ``max_buffer_size``. """ signal.signal(signal.SIGTERM, self._on_signal) signal.signal(signal.SIGINT, self._on_signal) xheaders = self.application.settings.get('xheaders', False) max_body_size = self.application.settings.get('max_body_size', None) max_buffer_size = self.application.settings.get( 'max_buffer_size', None) self.server = httpserver.HTTPServer( self.application.tornado_application, xheaders=xheaders, max_body_size=max_body_size, max_buffer_size=max_buffer_size) if self.application.settings.get('debug', False): self.logger.info('starting 1 process on port %d', port_number) self.server.listen(port_number) else: self.logger.info('starting processes on port %d', port_number) if tornado.version_info >= (4, 4): self.server.bind(port_number, reuse_port=True) else: self.logger.warning('port reuse disabled, please upgrade to' 'at least Tornado 4.4') self.server.bind(port_number) self.server.start(number_of_procs)
def main(args, ws_args, server_type, *url_fmt_args): import webbrowser url = 'visualisation/{}.html?' + url_quote( 'ws_port={}&server_type={}&min_angle={}&max_angle={}&model_length={}'. format(args.ws_port, server_type, *url_fmt_args)) default_url = url.format(args.type) type_redirects = [('/' + t, web.RedirectHandler, { 'url': url.format(t), 'permanent': False }) for t in PLOT_TYPES] app = web.Application( type_redirects + [('/', web.RedirectHandler, { 'url': default_url, 'permanent': False }), ('/ws', ) + ws_args, ('/(.*)', web.StaticFileHandler, { 'path': os.path.dirname(__file__) })], # static_hash_cache=False allows changes to be seen on page reload; see # http://www.tornadoweb.org/en/stable/web.html#tornado.web.Application static_hash_cache=args.cache, ) app.listen(args.ws_port, address=args.host) http_server = httpserver.HTTPServer(app) http_server.listen(args.http_port, address=args.host) webbrowser.register('dwb', None, webbrowser.BackgroundBrowser('dwb')) webbrowser.register('rekonq', None, webbrowser.BackgroundBrowser('rekonq')) if not args.no_browser: browser = webbrowser.get(args.browser) browser.open('http://{}:{}/{}'.format( (args.host if args.host else 'localhost'), args.http_port, default_url)) ioloop.IOLoop.current().start()
def main(argv=sys.argv): parser, opts = parseopts() if not opts.config and not opts.files: parser.print_help() print( '\nError: must specify files on the command line or through a config file' ) sys.exit(1) if opts.debug: log.setLevel(logging.DEBUG) applog.setLevel(logging.DEBUG) weblog.setLevel(logging.DEBUG) try: template_dir = pkg_resources.resource_filename('tailon', '../templates') assets_dir = pkg_resources.resource_filename('tailon', '../assets') except ImportError: template_dir, assets_dir = None, None config = main_config(opts) application = Application(config, {}, template_dir, assets_dir) server = httpserver.HTTPServer(application) server.listen(config['port'], config['addr']) lines = [] for group, files in config['files'].items(): group = group if group != '__ungrouped__' else 'ungrouped' lines.append('%s:' % group) for fn in files: lines.append(fn) log.debug('Config:\n%s', pprint.pformat(config)) log.debug('Files:\n%s', '\n - '.join(lines)) loop = ioloop.IOLoop.instance() msg = 'Listening on %s:%s' % (config['addr'], config['port']) loop.add_callback(log.info, msg) loop.start()
def listen(self): """ Starts a website to listen on a port """ # TODO: Actually kill the server instead of sending 500 # See https://gist.github.com/mywaiting/4643396 mainly server.stop # and ioloop.kill for this instance application = web.Application([ (r"/", SiteHandler, dict(variables=self.data_manager.variable_map, index=self.id, status=self.get_status())) ]) http_server = httpserver.HTTPServer(application) http_server.add_sockets( netutil.bind_sockets(self.BASE_PORT + 20 * self.id)) log.debug("Site %d listening on %d" % (self.id, self.BASE_PORT + 20 * self.id)) self.set_status(SiteStatus.UP)
def main(): pprint.pprint(dict(os.environ), stream=sys.stderr) if os.getenv('JUPYTERHUB_SERVICE_URL'): url = urlparse(os.environ['JUPYTERHUB_SERVICE_URL']) app = web.Application([ (r'.*/env', EnvHandler), (r'.*/api/(.*)', APIHandler), (r'.*/whoami/?', WhoAmIHandler), (r'.*/owhoami/?', OWhoAmIHandler), (r'.*/oauth_callback', HubOAuthCallbackHandler), (r'.*', EchoHandler), ], cookie_secret=os.urandom(32)) server = httpserver.HTTPServer(app) server.listen(url.port, url.hostname) try: ioloop.IOLoop.instance().start() except KeyboardInterrupt: print('\nInterrupted')
def main(): init_options() tornado.options.parse_command_line() # create and start the app app = make_app() # load ssl options ssl_options = None if options.sslcert: ssl_options = { 'certfile': options.sslcert, 'keyfile': options.sslkey, } http_server = httpserver.HTTPServer(app, xheaders=True, ssl_options=ssl_options) log.app_log.info("Listening on port %i", options.port) http_server.listen(options.port) ioloop.IOLoop.instance().start()
def launch_server(): state = State(get_client(options.hdfs_host, options.use_kerberos)) application = tornado.web.Application([ (r"/v1/completetions", GetCompletetionsHandler, dict(state=state)), (r"/v1/list", ListHandler, dict(state=state)), ]) if options.unix_socket: sockets = [netutil.bind_unix_socket(options.unix_socket)] elif options.port_file: sockets = netutil.bind_sockets(0, address=options.local_host) port = sockets[0].getsockname()[1] with open(options.port_file, "w+") as port_file: port_file.write(str(port)) else: sys.stderr.write("Use either --unix_socket or --port_file\n") return server = httpserver.HTTPServer(application) server.add_sockets(sockets) tornado.ioloop.IOLoop.current().start()
def __init__(self, bot: Life): self.bot = bot self.endpoints = [main, dashboard, metrics, websocket] self.application = web.Application( [ endpoint for endpoints in [endpoint.setup(bot=self.bot) for endpoint in self.endpoints] for endpoint in endpoints ], static_path=os.path.join(os.path.dirname(__file__), 'static/'), template_path=os.path.join(os.path.dirname(__file__), 'templates/'), cookie_secret=self.bot.config.cookie_secret, default_host='0.0.0.0', debug=True) self.bot.http_server = httpserver.HTTPServer(self.application, xheaders=True) self.bot.http_client = http.HTTPClient(bot=self.bot)
def __init__(self, host='127.0.0.1', port=8080, **options): ## Generic Variables ## super(CustomTornado, self).__init__(host=host, port=port, **options) ## Extras ## self.handlers = [] # Web Socket Handlers # self.handlers.append((r'/status', WebsocketHandler, { 'ws_manager': self.options['ws_manager0'] })) self.handlers.append((r'/traps', WebsocketHandler, { 'ws_manager': self.options['ws_manager1'] })) # HTML Handler # self.handlers.append((r".*", web.FallbackHandler, { 'fallback': wsgi.WSGIContainer(self.options['web_app']) })) # Server Instances # self.tornado_app = web.Application(self.handlers) self.server = httpserver.HTTPServer(self.tornado_app) self.ioloop = ioloop.IOLoop.instance()
def run_from_argv(self, prog_name, argv=None): argv = list(filter(self.tornado_option, argv)) parse_command_line([prog_name] + argv) logging.info("Starting http server on port %s..." % options.port) application = Application(celery_app=self.app) http_server = httpserver.HTTPServer(application) http_server.listen(options.port, options.address) bloader = BaseLoader(self.app) bloader.import_default_modules() logging.info("Registered tasks:") logging.info(pformat(list(self.app.tasks.keys()))) logging.info("Setting up non-blocking producer...") setup_nonblocking_producer() loop = asyncio.get_event_loop() application.init_with_loop(loop) loop.run_forever()
def init_app(on_port=None, closable=False, **params): _logger.debug('Using params: %s', params) params.update({'closable': closable}) port = params.pop('port', 0) ip = params.pop('ip', '127.0.0.1') app = make_app(**params) #pin remote access app.settings['allow_remote_access'] = True if port != 0: server = app.listen(port, address=ip) _logger.info('Listening on %s, port %d', ip, port) else: sockets = netutil.bind_sockets(0, ip) server = httpserver.HTTPServer(app) server.add_sockets(sockets) for s in sockets: _logger.info('Listening on %s, port %d', *s.getsockname()[:2]) port = s.getsockname()[1] if on_port is not None: on_port(port) return app, server
def main(): log.enable_pretty_logging() username = os.environ['SHARDER_DB_USERNAME'] password = os.environ['SHARDER_DB_PASSWORD'] dbname = os.environ['SHARDER_DB_NAME'] consumers = {os.environ['LTI_KEY']: os.environ['LTI_SECRET']} # Stringify each line so we can use it as keys sharder_buckets = [ l for l in json.loads(os.environ['SHARDER_BUCKETS']).split('\n') if l.strip() ] sharder = Sharder('localhost', username, password, dbname, 'hub', sharder_buckets, log.app_log) dbpool = psycopg2.pool.ThreadedConnectionPool(1, 4, user=username, host='localhost', password=password, dbname=dbname) with dbpool.getconn() as conn: try: with conn.cursor() as cur: cur.execute(SCHEMA) conn.commit() log.app_log.info('Finished running schema creation SQL') finally: dbpool.putconn(conn) application = web.Application([ (r"/hub/lti/launch", ShardHandler), ], sharder=sharder, consumers=consumers, debug=True, dbpool=dbpool) http_server = httpserver.HTTPServer(application) http_server.listen(8888) ioloop.IOLoop.current().start()
def init_webapp(self): """initialize tornado webapp and httpserver""" self.web_app = NotebookWebApplication(self, self.kernel_manager, self.notebook_manager, self.cluster_manager, self.log, self.base_project_url, self.webapp_settings) if self.certfile: ssl_options = dict(certfile=self.certfile) if self.keyfile: ssl_options['keyfile'] = self.keyfile else: ssl_options = None self.web_app.password = self.password self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options) if ssl_options is None and not self.ip and not (self.read_only and not self.password): self.log.critical( 'WARNING: the notebook server is listening on all IP addresses ' 'but not using any encryption or authentication. This is highly ' 'insecure and not recommended.') # Try random ports centered around the default. from random import randint n = 50 # Max number of attempts, keep reasonably large. for port in range(self.port, self.port + 5) + [ self.port + randint(-2 * n, 2 * n) for i in range(n - 5) ]: try: self.http_server.listen(port, self.ip) except socket.error, e: if e.errno != errno.EADDRINUSE: raise self.log.info( 'The port %i is already in use, trying another random port.' % port) else: self.port = port break
def main(): """Esign DB program main function.""" handlers = [ (r'/', IndexHandler), (r'/text', TextHandler), (r'/back/api/explain', TextHandler), (r'/test(?P<path>.*)?', TestHandler), (r'/service-worker.js', ServiceWorkerHandler), ] handlers += [(f'/middle{handler[0]}', handler[1]) for handler in HANDLER_LIST] # handlers += PAY_URLS tornado_app = web.Application( handlers=handlers, template_path=os.path.join(os.path.dirname(__file__), 'templates'), static_path=os.path.join(os.path.dirname(__file__), 'static'), cookie_secret='QiNDQXm6ReOfl1VOGhdLoZ0f3ZucyEg6psGNLu1tWZE=', ) tornado_server = httpserver.HTTPServer( tornado_app, xheaders=True, ) # if options.port == 0: # options.port = config.server.port # else: # config.server.port = options.port tornado_server.listen(config.server.port) print('start listen...') sys.stdout.write('\nconfig:\n') json.dump(config.traverse(), sys.stdout, indent=4, sort_keys=True) sys.stdout.write('\n\n\n') sys.stdout.flush() ioloop.IOLoop.instance().start()
def start_server(self): logging.basicConfig( level=self.config['log']['level'], # Set to 10 for debug. filename=self.config['log']['file'], format= '%(asctime)s (%(filename)s:%(lineno)s)- %(levelname)s - %(message)s', ) logging.Formatter.converter = time.gmtime logging.getLogger('requests').setLevel(logging.WARNING) logging.getLogger('tornado').setLevel(logging.WARNING) logging.info('=' * 80) port = self.get_port() # We need to have a fixed port in both forks. logging.info('Listening on port {}'.format(port)) if os.fork(): server = httpserver.HTTPServer(self) server.bind(self.get_port(), address=self.config.get('ip', '0.0.0.0')) server.start(self.config['threads_nb']) ioloop.IOLoop.current().start() elif os.fork(): time.sleep( 2) # We sleep for a few seconds to let the registry start. # Send a heartbeat callback cb = Callback(self, '/heartbeat', sleep_duration=0) cb() else: time.sleep( 2) # We sleep for a few seconds to let the registry start. if self.config.get('callbacks', None) is not None: for key, val in self.config['callbacks'].items(): if os.fork(): if val['threads']: process.fork_processes(val['threads']) ioloop.PeriodicCallback( Callback(self, val['uri'], sleep_duration=val.get('sleep', 0)), val['period'] * 1000).start() ioloop.IOLoop.instance().start()
def init_webapp(self): """initialize tornado webapp and httpserver""" self.web_app = NotebookWebApplication(self, self.kernel_manager, self.notebook_manager, self.cluster_manager, self.log, self.base_project_url, self.webapp_settings) if self.certfile: ssl_options = dict(certfile=self.certfile) if self.keyfile: ssl_options['keyfile'] = self.keyfile else: ssl_options = None self.web_app.password = self.password self.http_server = httpserver.HTTPServer(self.web_app, ssl_options=ssl_options) if not self.ip: warning = "WARNING: The notebook server is listening on all IP addresses" if ssl_options is None: self.log.critical(warning + " and not using encryption. This" "is not recommended.") if not self.password and not self.read_only: self.log.critical( warning + "and not using authentication." "This is highly insecure and not recommended.") success = None for port in random_ports(self.port, self.port_retries + 1): try: self.http_server.listen(port, self.ip) except socket.error, e: if e.errno != errno.EADDRINUSE: raise self.log.info( 'The port %i is already in use, trying another random port.' % port) else: self.port = port success = True break