def main(): parse_command_line() settings = dict( pipeline_file=options.pipeline ) app = remotecontrol.app.Application(settings) options.logging = str('DEBUG') enable_pretty_logging(options) app_log.setLevel(logging.DEBUG) server = HTTPServer(app) server.listen(options.port, options.host) app_log.info("Version: %s from: %s" % (remotecontrol.VERSION, remotecontrol.VERSION_DATE)) app_log.info("Listen on http://%s:%d/" % ( options.host if options.host != "" else "localhost", options.port) ) # app.processor.start() second_tick = None try: tornado.autoreload.add_reload_hook(app.manager.stop) second_tick = tornado.ioloop.PeriodicCallback(lambda: app.second_tick(), 1000) second_tick.start() tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: second_tick.stop() app_log.info("stop second tick") app.manager.stop() tornado.ioloop.IOLoop.instance().stop() app_log.debug("Server shutdown.")
def init_logger(cls, port): formatter = LogFormatter(fmt=cls.__fmt.format(port=port), datefmt="", color=False) access_log_handler = ConcurrentRotatingFileHandler( filename=os.path.join(ServerConfig["log_dir"], "access.log")) access_log_handler.setFormatter(formatter) access_log.addHandler(access_log_handler) server_log_handler = ConcurrentRotatingFileHandler( filename=os.path.join(ServerConfig['log_dir'], 'server.log'), maxBytes=128 * 1024 * 1024, backupCount=5, encoding='utf8') server_log_handler.setFormatter(formatter) gen_log.addHandler(server_log_handler) app_log.addHandler(server_log_handler) access_log.setLevel(logging.INFO) gen_log.setLevel(getattr(logging, ServerConfig['log_level'].upper())) app_log.setLevel(getattr(logging, ServerConfig['log_level'].upper())) access_log.propagate = app_log.propagate = gen_log.propagate = False return
def main(): """ entry """ try: conf = __import__('conf') except ImportError as e: app_log.critical("Unable to load site config. ({})".format(e)) raise SystemExit() parse_command_line() if options.debug: app_log.setLevel(logging.DEBUG) if not options.debug: fork_processes(None) options.port += task_id() or 0 if not os.path.isdir(conf.app_path): app_log.critical("{p} isn't accessible, maybe " "create it?".format(p=conf.app_path)) raise SystemExit() app_log.debug("Starting {name} on port {port}".format(name=conf.name, port=options.port)) # initialize the application tornado.httpserver.HTTPServer(Application(options, conf)).listen(options.port, '0.0.0.0') ioloop = tornado.ioloop.IOLoop.instance() if options.debug: tornado.autoreload.start(ioloop) # enter the Tornado IO loop ioloop.start()
def server_thread(): from tornado.log import access_log, app_log, gen_log access_log.setLevel(logging.ERROR) app_log.setLevel(logging.ERROR) gen_log.setLevel(logging.ERROR) loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) set_ioloop(tornado.ioloop.IOLoop.current()) # to enable bokeh app port = 0 if os.environ.get("PYWEBIO_SCRIPT_MODE_PORT"): port = int(os.environ.get("PYWEBIO_SCRIPT_MODE_PORT")) server, port = _setup_server(webio_handler=SingleSessionWSHandler, port=port, host='localhost') tornado.ioloop.IOLoop.current().spawn_callback( partial(wait_to_stop_loop, server=server)) if "PYWEBIO_SCRIPT_MODE_PORT" not in os.environ: tornado.ioloop.IOLoop.current().spawn_callback( open_webbrowser_on_server_started, 'localhost', port) tornado.ioloop.IOLoop.current().start() logger.debug('Tornado server exit')
def serve(self, port: int = 5000, n_process: int = None): if n_process is None: n_process = 1 if sys.platform == 'win32' else 8 fmt = LogFormatter(fmt='%(asctime)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S', color=True) root_logger = logging.getLogger() console_handler = logging.StreamHandler() file_handler = logging.FileHandler('server.log') console_handler.setFormatter(fmt) file_handler.setFormatter(fmt) root_logger.addHandler(console_handler) root_logger.addHandler(file_handler) app_log.setLevel(logging.INFO) gen_log.setLevel(logging.INFO) access_log.setLevel(logging.INFO) app_log.info("Model is loading...") app_log.info("Model Has Been Loaded!") app = Application([(r"/.*", LTPHandler, dict(ltp=self))]) server = HTTPServer(app) server.bind(port) server.start(n_process) ioloop.IOLoop.instance().start()
def run(port, destport, ip, presentation_path, debug, authtype, request_timeout, last_activity_interval, force_alive, ready_check_path, command): if debug: print('Setting debug') app_log.setLevel(logging.DEBUG) prefix = os.environ.get('JUPYTERHUB_SERVICE_PREFIX', '/') if len(prefix) > 0 and prefix[-1] == '/': prefix = prefix[:-1] configure_http_client() app = make_app(destport, prefix, list(command), presentation_path, authtype, request_timeout, ready_check_path, debug) http_server = HTTPServer(app) http_server.listen(port, ip) print( "Starting jhsingle-native-proxy server on address {} port {}, proxying to port {}" .format(ip, port, destport)) print("URL Prefix: {}".format(prefix)) print("Auth Type: {}".format(authtype)) print("Command: {}".format(command)) if last_activity_interval > 0: start_keep_alive(last_activity_interval, force_alive, app.settings) ioloop.IOLoop.current().start()
def run(port, destport, ip, presentation_path, debug, logs, authtype, request_timeout, last_activity_interval, force_alive, ready_check_path, repo, repobranch, repofolder, conda_env, allow_root, notebookapp_allow_origin, forward_user_info, query_user_info, command): if debug: print('Setting debug') app_log.setLevel(logging.DEBUG) elif logs: app_log.setLevel(logging.INFO) prefix = os.environ.get('JUPYTERHUB_SERVICE_PREFIX', '/') if len(prefix) > 0 and prefix[-1] == '/': prefix = prefix[:-1] configure_http_client() app = make_app(destport, prefix, list(command), presentation_path, authtype, request_timeout, ready_check_path, repo, repobranch, repofolder, conda_env, debug, logs, forward_user_info, query_user_info) ssl_options = get_ssl_options() http_server = HTTPServer(app, ssl_options=ssl_options, xheaders=True) http_server.listen(port, ip) print("Starting jhsingle-native-proxy server on address {} port {}, proxying to port {}".format(ip, port, destport)) print("URL Prefix: {}".format(prefix)) print("Auth Type: {}".format(authtype)) print("Command: {}".format(command)) if last_activity_interval > 0: start_keep_alive(last_activity_interval, force_alive, app.settings) ioloop.IOLoop.current().start()
def run(port, ip, server_name, debug, command): if debug: app_log.setLevel(logging.DEBUG) print('Setting debug') app = make_app(command, server_name, debug) http_server = HTTPServer(app) http_server.listen(port, ip) ioloop.IOLoop.current().start()
def run(self): if options.debug: app_log.setLevel(logging.DEBUG) if not options.debug: fork_processes(None) options.port += task_id() or 0 app_log.debug("Starting %s on port %s" % (cfg.platform_name, options.port)) # initialize the application tornado.httpserver.HTTPServer(Application(self.commons)).listen(options.port, '0.0.0.0') ioloop = tornado.ioloop.IOLoop.instance() if options.debug: tornado.autoreload.start(ioloop) # enter the Tornado IO loop ioloop.start()
def run(self): if options.debug: app_log.setLevel(logging.DEBUG) if not options.debug: fork_processes(None) options.port += task_id() or 0 app_log.debug("Starting %s on port %s" % ('tornado skeleton', options.port)) # initialize the application tornado.httpserver.HTTPServer(Application(self.commons)).listen( options.port, '0.0.0.0') ioloop = tornado.ioloop.IOLoop.instance() if options.debug: tornado.autoreload.start(ioloop) # enter the Tornado IO loop ioloop.start()
def main(params): logging.getLogger('tornado.access').setLevel(logging.INFO) #logging.getLogger("tornado.application").setLevel(logging.INFO) from tornado.log import app_log #print app_log, app_log.setLevel, app_log.info app_log.setLevel(logging.INFO) app = make_app(params) app.listen(params.port) print 'started httpd on :%d' % params.port try: iptables.up(params) except Exception as e: print e.message exit(1) try: IOLoop.instance().start() except: iptables.down(params) raise
def main(): from argparse import ArgumentParser parser = ArgumentParser(prog="SimpleTornadoServer", description="A simple HTTP server based on tornado") parser.add_argument("-H", "--host", default="127.0.0.1", help="Host to bind to") parser.add_argument("-p", "--port", type=int, default=8000, help="Port to listen on") parser.add_argument("-r", "--root", default=".", help="Root directory of the server") parser.add_argument("-l", "--autoindex", action="store_true", help="List all files and dirs") parser.add_argument("-d", "--debug", action="store_true", help="Debug mode") options = parser.parse_args() if options.debug: log.setLevel(logging.DEBUG) else: log.setLevel(logging.INFO) enable_pretty_logging() log.info('Serving site from local directory: %s' % os.path.abspath(options.root)) handlers = [ (r'(.*)/$', IndexHandler, dict(root=options.root, autoindex=options.autoindex)), (r'/(.*)$', StaticFileHandler, dict(path=options.root)), ] settings = dict( debug=options.debug, compress_response=True, ) app = tornado.web.Application(handlers, **settings) http_server = tornado.httpserver.HTTPServer(app, xheaders=True) http_server.listen(options.port, options.host) log.info("The server is running at: http://{host}:{port}/".format(**vars(options))) signal.signal(signal.SIGINT, stop_server) tornado.ioloop.IOLoop.instance().start()
def enable_tornado_log(): """开启 Tornado 内置日志信息 * ``tornado.access``: Per-request logging for Tornado's HTTP servers (and potentially other servers in the future) * ``tornado.application``: Logging of errors from application code (i.e. uncaught exceptions from callbacks) * ``tornado.general``: General-purpose logging, including any errors or warnings from Tornado itself. """ try: access_log.addHandler(filehandler) access_log.setLevel(logger.level) app_log.addHandler(filehandler) app_log.setLevel(logger.level) gen_log.addHandler(filehandler) gen_log.setLevel(logger.level) except Exception: error_msg = traceback.format_exc() logger.warning(f'enable tornado log fail.\t{error_msg}') logger.error(f'enable tornado log fail.')
def run(port, destport, ip, debug, authtype, command): if debug: print('Setting debug') app_log.setLevel(logging.DEBUG) prefix = os.environ.get('JUPYTERHUB_SERVICE_PREFIX', '/') if len(prefix) > 0 and prefix[-1] == '/': prefix = prefix[:-1] app = make_app(destport, prefix, list(command), authtype, debug) http_server = HTTPServer(app) http_server.listen(port, ip) print( "Starting jhsingle-native-proxy server on address {} port {}, proxying to port {}" .format(ip, port, destport)) print("URL Prefix: {}".format(prefix)) print("Auth Type: {}".format(authtype)) print("Command: {}".format(command)) ioloop.IOLoop.current().start()
from models import Server from dateutil.parser import parse as parse_date from botocore.exceptions import ClientError, WaiterError from concurrent.futures import ThreadPoolExecutor from tornado.gen import coroutine, sleep from tornado.log import app_log from tornado.httpclient import AsyncHTTPClient, HTTPRequest, HTTPError from tornado.ioloop import IOLoop, PeriodicCallback from tornado.options import define, options, parse_command_line with open("/etc/jupyterhub/server_config.json", "r") as f: SERVER_PARAMS = json.load(f) # load local server parameters app_log.setLevel(logging.INFO) logging.getLogger('boto3').setLevel(logging.ERROR) logging.getLogger('botocore').setLevel(logging.ERROR) thread_pool = ThreadPoolExecutor(10) @coroutine def retry(function, *args, **kwargs): """ Retries a function up to max_retries, waiting `timeout` seconds between tries. This function is designed to retry both boto3 and fabric calls. In the case of boto3, it is necessary because sometimes aws calls return too early and a resource needed by the next call is not yet available. """ max_retries = kwargs.pop("max_retries", 20) timeout = kwargs.pop("timeout", 0.25) for attempt in range(max_retries): try:
from tornado.options import options from app_settings import settings from handlers.home_handler import HomeHandler from handlers.capture_handler import CaptureHandler from handlers.capture_stream_handler import CaptureStreamHandler from handlers.cast_handler import CastHandler from handlers.cast_stream_handler import CastStreamHandler application = tornado.web.Application( [(r"/scripts/(.*)", tornado.web.StaticFileHandler, { 'path': 'scripts' }), (r"/", HomeHandler), (r"/capture", CaptureHandler), (r"/capture-stream", CaptureStreamHandler), (r"/cast/(.*)", CastHandler), (r"/cast-stream/(.*)", CastStreamHandler)], **settings) if __name__ == "__main__": def stop_server(signum, frame): app_log.info('Stopping server') loop.stop() signal.signal(signal.SIGINT, stop_server) app_log.setLevel(options.loglevel) app_log.info('Starting Tornado {0} server'.format(tornado.version)) app_log.info('Press Ctrl+C to stop') application.listen(options.port) loop = tornado.ioloop.IOLoop.current() loop.start()
log_fds('start') log_mem('start') q = Q() s = Storage() parser = Parser(s) while True: log_fds('start loop') log_mem('start loop') task = q.get_parser_task() if task: yield parser.run(task[2]) q.complete_task(task[0]) else: app_log_process("not found task") time.sleep(options.parser_sleep_period_sec) app_log_process('end parser process') if __name__ == '__main__': parse_command_line() if options.debug: from tornado.log import app_log app_log.setLevel(logging.DEBUG) ioloop = tornado.ioloop.IOLoop() ioloop.make_current() ioloop.run_sync(parser_process)
q = Q() s = Storage() while True: log_fds('start loop') log_mem('start loop') task = q.get_crawler_task() if task: crawler = Crawler(task[2], q, s) yield crawler.run() q.complete_task(task[0]) del crawler else: app_log_process("not found task") time.sleep(options.crawler_sleep_period_sec) app_log_process('end crawler process') log_fds('end') if __name__ == '__main__': parse_command_line() if options.debug: from tornado.log import app_log app_log.setLevel(logging.DEBUG) ioloop = tornado.ioloop.IOLoop() ioloop.make_current() ioloop.run_sync(crawler_process)
from handlers.home_handler import HomeHandler from handlers.capture_handler import CaptureHandler from handlers.capture_stream_handler import CaptureStreamHandler from handlers.cast_handler import CastHandler from handlers.cast_stream_handler import CastStreamHandler application = tornado.web.Application([ (r"/scripts/(.*)", tornado.web.StaticFileHandler, {'path': 'scripts'}), (r"/", HomeHandler), (r"/capture", CaptureHandler), (r"/capture-stream", CaptureStreamHandler), (r"/cast/(.*)", CastHandler), (r"/cast-stream/(.*)", CastStreamHandler) ], **settings) if __name__ == "__main__": def stop_server(signum, frame): app_log.info('Stopping server') loop.stop() signal.signal(signal.SIGINT, stop_server) app_log.setLevel(options.loglevel) app_log.info('Starting Tornado {0} server'.format(tornado.version)) app_log.info('Press Ctrl+C to stop') application.listen(options.port) loop = tornado.ioloop.IOLoop.current() loop.start()
def main(): options.parse_command_line() if os.path.exists(options.configFile): try: options.parse_config_file(options.configFile) options.parse_command_line() except Exception, E: print("Invalid config file {0}".format(options.configFile)) print(E) sys.exit(1) # Set Log level log.setLevel(getLogLevel(options.logLevel)) if not options.cookieSecret: log.error("cookieSecret option required") sys.exit(1) detectProxy() mailer.setup(options.smtpServer, options.smtpPort, options.emailSender, options.smtpUseTLS) log.info("Server starting on {0}:{1}...".format(options.address, options.port)) http_server = Application() http_server.listen(options.port, options.address, xheaders=True) io_loop = tornado.ioloop.IOLoop.instance() if options.autoReload:
def main(): options.parse_command_line() if os.path.exists(options.configFile): try: options.parse_config_file(options.configFile) options.parse_command_line() except Exception, E: print("Invalid config file {0}".format(options.configFile)) print(E) sys.exit(1) # Set Log level log.setLevel(getLogLevel(options.logLevel)) detectProxy() # Load the credentials from file log.info("Loading credentials") try: credentialsFile = options.credentialsFile Keys.loadFromFile(credentialsFile) except Exception as E: log.error( "Error opening the credentials file: {0}".format(credentialsFile)) log.error(E) sys.exit(1) # TMP fix for 'ValueError: I/O operation on closed epoll fd'