def main(): define("port", default=8000, help="run on the port", type=int) define("debug", default=False, help="run in debug mode", type=bool) options.parse_command_line() # ===== global_scope = globals() handlers = [] for key in global_scope: if key.endswith("_handlers"): handlers.extend(global_scope[key]) # ===== class Main(tornado.web.Application): def __init__(self, *args, **kwargs): super(Main, self).__init__(*args, **kwargs) self.config = config @property def db(self): return DbHelper() app = Main( handlers, cookie_secret="config.COOKIE_SECRET", login_url="/login", static_path=os.path.join(os.path.dirname(__file__), "static"), xsrf_cookies=True, debug=options.debug, gzip=True, ) server = HTTPServer(app) server.listen(options.port) print "tornado launched!" IOLoop.current().start()
def run_app(): options.parse_command_line() # 1. Create sync router sync_router = sockjs.tornado.SockJSRouter(SyncConnection, '/sync') # 2. Create Tornado application app = Application( [ (r'/', IndexHandler), (r'/(?P<pad_id>[0-9a-z\-]+)', PadHandler), (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': STATIC_ROOT}) ] + sync_router.urls, cookie_secret=options.cookie_secret, static_url_prefix='/static/', template_path=TEMPLATES_ROOT, pad_lifetime=options.pad_lifetime, ) # 3. Make Tornado app listen on port 8080 app.listen(options.port) logging.info("App started, visit http://localhost:%s" % options.port) logging.info("App started with options: %r" % options.as_dict()) # 4. Start IOLoop tornado.ioloop.IOLoop.instance().start()
def main(): print("starting web.py on port %s" % options.port) options.parse_command_line() application = _create_tornado_app() server = HTTPServer(application) server.listen(options.port) IOLoop.instance().start()
def main() -> None: '''Runs server''' # Parse options define('production', default = False, help = 'run in production mode', type = bool) options.parse_command_line() # Set server name pname = settings.process_name if settings.process_name else None if pname: setproctitle(pname) # Register IRC server server = IRCServer(settings = ircdsettings) for address, port in ircdsettings['listen']: server.listen(port, address = address) # Start profiling if settings.profiling: import yappi yappi.start() # Setup autoreload autoreload.start() # Run application IOLoop.instance().start()
def run(): define('day', help="The base date",default=None) define('f', help="From date", default=None) define('t', help="To date", default=None) options.parse_command_line() bday = options.day and datetime.strptime(options.day, config.DATE_FORMAT) or datetime.today() fday = options.f and datetime.strptime(options.f, config.DATE_FORMAT) or 0 tday = options.t and datetime.strptime(options.t, config.DATE_FORMAT) or 0 redis_cli = get_redis_client() filters = dwarf.daux.Filter(redis_cli).expand(gender=1).overlap(regu=2) filters = filters.filter(dwarf.daux.Filter(redis_cli).expand(gender=2).overlap(regu=2)) filters = None au = dwarf.daux.AUstat(bday, redis_cli, filters= filters) print "baseDay:", bday , "from:" , fday, "to:", tday # s = time.time() # print "dau:", au.get_dau(), time.time()-s # s = time.time() # print "dnu:", au.get_dnu(bday), time.time()-s # s = time.time() # print "listdau:", au.list_dau(fday=fday, tday=tday), time.time()-s s = time.time() print "listdnu:", au.list_dnu(fday=fday, tday=tday), time.time()-s # s = time.time() # print "mau:", au.mau(fday=fday, tday=tday), time.time()-s # s = time.time() # print "retained:" , au.get_month_retained(fday=fday, tday=tday), time.time()-s s = time.time() print "new user retained:", au.get_retained_nu(fday=fday, tday=tday), time.time()-s
def start_with_options(self): """ 从命令行参数启动 """ from tornado.options import options, define define("includes", default="", help="specify tasks and tickers to run") define("excludes", default="", help="specify tasks and tickers not to run") options.parse_command_line() tasks = {} tickers = [] if options.includes: tps = options.includes.split(",") for tp in tps: pair = tp.split(":") if len(pair) == 2: tasks[pair[0]] = int(pair[1]) else: tickers.append(pair[0]) tasks[IdleTask.name] = 1 else: tasks = {name: num for name, (task_cls, num, standalone) in self.tasks_cls.items() if not standalone} tickers = self.all_tickers.keys() if options.excludes: tps = options.excludes.split(",") for tp in tps: tasks.pop(tp, None) if tp in tickers: tickers.remove(tp) self.start_all(tasks, tickers)
def main(): define("port", default=Config.data['web']['port'], help="run on the given port", type=int) options.parse_command_line() logger.set_logger('web-{}.log'.format(options.port)) http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): options.define("port", default="8888") options.define("watch", type=str, multiple=True, default=".", help="watch file or directory") options.define("htdoc", type=str, default=".", help="root directory of HTML documents") options.define("command", type=str, multiple=True, metavar="COMMAND", help="run COMMAND when file or directory is changed") options.parse_command_line() mypath = os.path.dirname(os.path.abspath(__file__)) assets_path = os.path.join(mypath, 'assets') for f in options.watch: watcher.watch(f) watcher.add_hook(_run_cmd) watcher.start() application = tornado.web.Application([ (r"/ws", WebSocketHandler), (r"/assets/(.*)", tornado.web.StaticFileHandler, {"path": assets_path}), (r"/(.*\.html)", MainHandler), (r"/(.*)", tornado.web.StaticFileHandler, {"path": options.htdoc}), ]) application.listen(8888) logging.info('starting application') try: tornado.ioloop.IOLoop.instance().start() except KeyboardInterrupt: logging.info('bye')
def boreas(): from tornado.options import define, options from boreas import server define("config", help="Configuration module", type=str) define("debug", default=True, help="Enable debugging urls", type=bool) define("api_port", default=8001, help="API port", type=int) define("api_host", default='127.0.0.1', help="API host", type=str) define("ws_port", default=8002, help="Websocket port", type=int) define("ws_host", default='127.0.0.1', help="Websocket host", type=str) define("token_provider", default='boreas.utils.tokens:no_tokens', help="Function providing initial tokens", type=str) define("require_auth", default=True, help="Flag indicating if user has to authenticate", type=bool) options.parse_command_line() if options.config is None: # assume boreas.conf in working directory conf_file = 'boreas.conf' try: options.parse_config_file(conf_file) except IOError: pass # just use defaults else: conf_file = options.config options.parse_config_file(conf_file) server.run(options)
def run(): options.parse_command_line() http_server = HTTPServer(SiteApplication()) http_server.listen(options.port) print "running on %s:%d" % (options.host, options.port) IOLoop.instance().start()
def __init__(self, extra_handlers): '''Expects a list of tuple handlers like: [(r"/", MainHandler), (r"/chatsocket", ChatSocketHandler),] ''' url = settings._server_str % (settings.PROTOCOL, settings.HOSTNAME, settings.AUTHSERVERPORT) app_settings = { "cookie_secret": settings.COOKIE_SECRET, "login_url": ''.join((url, "/login")), } handlers = [] handlers.append((r"/version", VersionHandler)) handlers.append((r"/source", SelfServe)) handlers.append((r"/ping", PingHandler)) handlers.append((r"/", PingHandler)) handlers.extend(extra_handlers) options.parse_command_line() dburi = options.dburi # Connect to the elixir db setup(db_uri=dburi) Application.__init__(self, handlers, debug=True, **app_settings)
def main(): options.parse_command_line() App().listen(options.port, options.host, xheaders=True) print "VANELLOPE running on %s:%d" % (options.host, options.port) schedule = ioloop.PeriodicCallback(scan_session_store, 1000 * 5) schedule.start() ioloop.IOLoop.instance().start()
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()
def main(): server_path = path.dirname(__file__) template_path = path.join(server_path, 'templates') static_path = path.normpath(path.join(server_path, '..', 'client')) settings = { 'static_path': static_path, 'template_path': template_path, 'xsrf_cookies': False, # TODO: Enable 'login_url': '/', 'db': motor.MotorClient().chessrank, } app_settings = load_app_settings() settings.update(app_settings) handlers = [ (r'/api/tournaments(?:/([0-9a-fA-F]{24}))?.*', TournamentHandler), (r'/api/sections(?:/([0-9a-fA-F]{24}))?.*', SectionHandler), (r'/api/players(?:/([0-9a-fA-F]{24}))?.*', PlayerHandler), (r'/api/users(?:/([0-9a-fA-F]{24}))?.*', UserHandler), (r'/api/session', SessionHandler), (r'/api/lookups', LookupsHandler), (r'/api.*', ApiHandler), (r'/verify/(.+)', VerifyPageHandler), (r'/', IndexPageHandler) ] options.parse_command_line() app = CustomApp(handlers, 'localhost', **settings) app.listen(options.port) IOLoop.instance().start()
def main(): define('listen', metavar='IP', default='127.0.0.1', help='listen on IP address (default 127.0.0.1)') define('port', metavar='PORT', default=8888, type=int, help='listen on PORT (default 8888)') define('debug', metavar='True|False', default=False, type=bool, help='enable Tornado debug mode: templates will not be cached ' 'and the app will watch for changes to its source files ' 'and reload itself when anything changes') options.parse_command_line() settings = dict( template_path=rel('templates'), static_path=rel('static'), debug=options.debug ) application = Application([ (r'/', MainHandler), (r'/ws', EchoWebSocket), (r'/websocket', SignallingHandler), (r'/webrtc', WebRTCHandler) ], **settings) #application.listen(address=options.listen, port=options.port) application.listen(7080) IOLoop.instance().start()
def run_server(): parse_configure_file(options, define, join_path(__file__, './chat.conf')) options.parse_command_line() http_server = tornado.httpserver.HTTPServer( Application(), xheaders=options.xheaders) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): # Get the Port and Debug mode from command line options or default in settings.py options.parse_command_line() # logging.config.dictConfig(LOG_SETTINGS) logger = logging.getLogger("app") # Load ML Models logger.info("Loading IRIS Prediction Model...") MODELS["iris"] = load_model(os.path.join(MODEL_DIR, "iris", "model.pkl")) urls = [ (r"/live$", handler.LiveHandler), (r"/api/iris/(?P<action>[a-zA-Z]+)?", handler.IrisPredictionHandler, { "model": MODELS["iris"]}), ] application = tornado.web.Application( urls, debug=options.debug, autoreload=options.debug) logger.info("Starting App on Port: {} with Debug Mode: {}".format(options.port, options.debug)) application.listen(options.port) tornado.ioloop.IOLoop.current().start()
def main(): # Defines define("port", default=8082, help="run on the given port", type=int) define("log_level", default="INFO", type=str, help="[NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL]") define("dbconf", default="sqlite:///vanzilla.db", type=str, help="sqlalchemy db config string") define("mail_server", default="localhost", help="server mail", type=str) define("mail_from", default="", help="sender address for mail error reports", type=str) define("mail_to", default="", help="recipient addresses for mail error reports", type=str) define("root_ips", default=[], help="IPs with global access", type=list) define("promiscuous_load", default=False, help="load all apps, whether they are enabled or not", type=bool) options.parse_config_file("vanzilla.conf") options.parse_command_line() logging.debug(options.logging) # Initalising applications apps = AppsLoader(options) # Starting tornado server http_server = tornado.httpserver.HTTPServer(apps) http_server.listen(options.port) ioloop = tornado.ioloop.IOLoop.instance() tornado.autoreload.add_reload_hook(apps.reload_tasks) tornado.autoreload.start(ioloop) ioloop.start()
def main(): options.parse_command_line() app = Application() server = tornado.httpserver.HTTPServer(app, xheaders=True) server.bind(options.port) server.start() tornado.ioloop.IOLoop.current().start()
def main(): options.parse_command_line() # set up database connection client = pymongo.MongoClient(options.dbhost, options.dbport) database = client[options.dbname] # list of handlers handlers = [] # generate list for handler in settings.handlers: # import the handler we need handler_class = __import__(handler) # register the URLS with the handler for routes in handler_class.routes: # each handler exports a urls list and class endpoint, class_name = routes url = ('/api' + endpoint, class_name, dict(database=database)) # append to our handlers list handlers.append(url) ioloop = tornado.ioloop.IOLoop.instance() # register our handlers with our application and give it our settings application = tornado.web.Application(handlers, **settings.settings) http_server = tornado.httpserver.HTTPServer(application) # listen on port defined in options http_server.listen(options.port) #start ioloop ioloop.start()
def parse_options(args, err_func): define('ports', multiple=True, type=int, help='listen ports (one or more)', metavar='PORT[,PORT,...]', default=[8001]) define('config', type=str, help='zaglushka config path') define('watch', type=bool, help='watch config and stubs for changes', default=True) from tornado.options import options options.logging = 'debug' enable_pretty_logging(options) script_name = args[0] simple_args = list(takewhile(lambda i: not i.startswith('--'), args[1:])) other_args = args[len(simple_args) + 1:] other_args.insert(0, script_name) if simple_args: if len(simple_args) > 2: err_func('More than two simple args') return None elif len(simple_args) == 2: config, ports = simple_args else: config = simple_args[0] ports = None options.config = config if ports: ports = (i.strip() for i in ports.split(',')) try: ports = map(int, ports) except (TypeError, ValueError): err_func('Wrong port value') return None options.ports = ports options.logging = 'debug' options.parse_command_line(args=other_args) return options
def main(): router = [ (r'/', HomeHandler), ] options.parse_command_line() http_server = tornado.httpserver.HTTPServer(Application(router, My404, debug=(options.env == 'dev'))) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
def main(): options.parse_command_line() app = App() server = HTTPServer(app) server.listen(options.port) ioloop.IOLoop.instance().start()
def main(): options.parse_command_line() handlers = [(r"/send_mail/", MainHandler)] application = tornado.web.Application(handlers) application.listen(options.port, options.host) tornado.ioloop.IOLoop.instance().start()
def main(): options.parse_command_line() # 实例化一个httpserver对象 http_server = tornado.httpserver.HTTPServer(CustomApplication()) # 监听8888 套接字端口 http_server.listen(options.port) # 启动事件循环 tornado.ioloop.IOLoop.instance().start()
def main(): tornado.web.Application(debug=env) http_server = HTTPServer(WSGIContainer(app)) enable_pretty_logging() options.parse_command_line() http_server.listen(options.port) IOLoop.instance().start() print('Quit the server with CONTROL-C')
def run(): define("host", default=settings.HOST, help="Served host") define("port", default=settings.PORT, help="Served port", type=int) options.parse_command_line() http_server = HTTPServer(MyApplication()) http_server.listen(address=options.host, port=options.port) IOLoop.instance().start()
def main(): options.parse_command_line() app = Application() http_server = HTTPServer(app) http_server.listen(options.port) #print app_path tornado.ioloop.IOLoop.instance().start() print "Quit the server with CONTORL-C"
def run(self): options.log_file_prefix = "/opt/f5backup/log/api.log" options.log_file_num_backups = 3 options.log_file_max_size = 10485760 options.parse_command_line() http_server = HTTPServer(WSGIContainer(app)) http_server.listen(5380, address="127.0.0.1") IOLoop.instance().start()
def main(): define('port', default=8080, type=int, help='run on the given port') options.parse_command_line() app = BlogApp(options) http_server = httpserver.HTTPServer(app) http_server.listen(options.port) ioloop.IOLoop.instance().start()
print('-->initialize()') self.title = title def get(self): self.write('你正在查看文章:%s' %self.title) class RegistHandler(RequestHandler): def initialize(self, title): self.title = title def get(self, *args, **kwargs): self.write("注册业务处理:" + str(self.title)) class LoginHandler(RequestHandler): def get(self, *args, **kwargs): self.write("用户登录页面展示") def post(self, *args, **kwargs): self.post("用户登录功能处理") if __name__ == '__main__': options.parse_command_line() # 命令行参数转换 app = Application([ (r'/', MainHandler), (r'/article', ArticleHandler,{'title':'你希望自己成为什么样的人,最终就会成为那样的人。'}), (r'/regist', RegistHandler, {'title':'会员注册'}), url(r'/login', LoginHandler, name="login"), ], debug=True) #Application 路由器设置 url(r'', handler, {k,v}, name='') http_server = HTTPServer(app) http_server.bind(options.port) http_server.start(1) IOLoop.current().start()#current() 返回当前线程的IOLoop实力对象,start() 启动IOLoop实例对象的IO循环,开启监听
def main(): options.parse_command_line() app = Application() app.listen(config.localport) IOLoop.instance().start()
#!/usr/bin/env python # -*- coding:utf-8 -*- import os from tornado.wsgi import WSGIApplication from tornado.options import options # 解析tornado启动参数, 设置日志debug级别 options.parse_command_line(['', '--logging=debug']) game_env = os.getenv('game_env') server_name = os.getenv('server_name') print 'game_env: %s, server_name: %s' % (game_env, server_name) import settings settings.set_evn(game_env, server_name) settings.ENVPROCS = 'wsgi' from handlers import APIRequestHandler from handlers import ConfigHandler from handlers import AdminHandler from handlers import Login from handlers import Pay, PayCallBack from handlers import AdClick from handlers import ZhiChong360Handler from handlers import CMGEHandler from handlers import AdvertHandler class Application(WSGIApplication):
from tornado.options import define, options from config import settings from handlers.main.main_urls import handlers from models.account.account_user_model import User from models.files.upload_file_model import Files from models.article import article_model from libs.db import create_talbes from libs.db.dbsession import dbSession #定义一个默认的端口 define("port", default=8000, help="run port ", type=int) define("runserver", default=False, help="start server", type=bool) define("t", default=False, help="create table", type=bool) define("u", default=False, help="create user", type=bool) if __name__ == "__main__": options.parse_command_line() if options.t: create_talbes.run() if options.u: user = User() user.name = 'zhangsan' user.password = '******' dbSession.add(user) dbSession.commit() if options.runserver: app = tornado.web.Application(handlers, **settings) #创建应用实例 http_server = tornado.httpserver.HTTPServer(app) #通过应用实例创建服务器实例 http_server.listen(options.port) #监听9000端口 print 'start server...' tornado.ioloop.IOLoop.instance().start() #启动服务器
# # logfile = 'log/debug.log' # # #启动的进程数 # workers = multiprocessing.cpu_count() * 2 + 1 # worker_class = 'gunicorn.workers.ggevent.GeventWorker' # # x_forwarded_for_header = 'X-FORWARDED-FOR' # from gevent.wsgi import WSGIServer # from index import app # http_server = WSGIServer(('', 5058), app) # http_server.serve_forever() from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from index import app from tornado.options import options if __name__ == '__main__': args = options.parse_command_line() if len(args) == 0: port = 5098 else: port = args[0] http_server = HTTPServer(WSGIContainer(app), xheaders=True) http_server.listen(port) IOLoop.instance().start()
loglevel = 'info' elif libiisi.m_config.getData('log_level') == '30': loglevel = 'warring' elif libiisi.m_config.getData('log_level') == '40': loglevel = 'error' else: loglevel = 'info' opt_args = [ '', '--logging={0}'.format(loglevel), '--log_file_prefix={0}'.format( os.path.join(libiisi.m_logdir, 'iisi{0}.debug.log'.format( libiisi.cfg_bind_port))) ] if results.debug: opt_args.append('--log_to_stderr') options.parse_command_line(args=opt_args, final=True) if results.hp: tornado.process.fork_processes(0) libiisi.m_debug = results.debug libiisi.m_sql = MXMariadb( host=libiisi.m_config.getData('db_host').split(':')[0], port=3306 if len(libiisi.m_config.getData('db_host').split(':')) == 1 else int(libiisi.m_config.getData('db_host').split(':')[1]), user=libiisi.m_config.getData('db_user'), pwd=mx.decode_string(libiisi.m_config.getData('db_pwd')), maxconn=int(libiisi.m_config.getData('max_db_conn'))) libiisi.m_sql.set_debug(results.debug) # 开启后台线程
import json import sys import logging from tornado.options import define, options from griotte.websocket import WebSocket from griotte.config import Config import tornado.ioloop Config("DEFAULT") define("watchdog", default=0.1, help="Watchdog interval") if __name__ == "__main__": def on_message(channel, message): logging.info(" >>> On channel \"%s\" : %s" % (channel, message)) channels = () channels = options.parse_command_line() if not channels: logging.warning("No channel specified, watching meta.presence") channels.append("meta.presence") ws = WebSocket() for chan in channels: ws.add_listener(chan, on_message) ws.start(detach=False, watchdog_interval=options.watchdog)
def main(): options.parse_command_line() IOLoop().start(Application(), options.port)
def main(): options.parse_command_line() http_server = HTTPServer(WSGIContainer(app)) http_server.listen(options.port) logging.warn("[UOP] App is running on: localhost:%d", options.port) IOLoop.instance().start()
import sys import time import tornado.ioloop from tornado.options import define, options from config import PORT_COUNT, TCP_PORT, WS_PORT # For displaying throughput processed_requests, processed_bytes = 0, 0 last_display_time = time.time() # Ports for TCP and WS (8001~8200, 8501~8700) define("tcpport", default=TCP_PORT, help="TCP port", type=int) define("wsport", default=WS_PORT, help="WebSocket port", type=int) options.parse_command_line(sys.argv) from socket_connection import WebSocketApp, TCPSockServer tcpserver = None webapp = None # Just notifies reloading def reload_main(): logging.warn("") logging.warn("Reload...") def display_stats(): global tcpserver global webapp
def main(port, host =''): print('start listen port is {}'.format(port)) options.parse_command_line() Application().listen(port) tornado.ioloop.IOLoop.instance().start()
__author__ = 'grigory51' CURRENT_DIR = os.path.dirname(os.path.abspath(__file__)) def parse_config(path): try: options.parse_config_file(path=path, final=False) except IOError: print('[WARNING] File no readable, run with default settings') define('host', type=str, group='Server', default='127.0.0.1', help='Listen host') define('port', type=int, group='Server', default=8080, help='Listen port') define('server_name', type=str, group='Server', default='https://bot.team.ktsstudio.ru') define('debug', default=False, help='Tornado debug mode') define('config', type=str, help='Path to config file', callback=parse_config) define('runtime', type=str, help='Data dir', default=CURRENT_DIR + '/runtime/') options.parse_command_line(final=True)
def main(): options.parse_command_line() app = App() app.listen(options.port) IOLoop.current().start()
def put(filenames): client = httpclient.AsyncHTTPClient() for filename in filenames: mtype = mimetypes.guess_type(filename)[0] or 'application/octet-stream' headers = {'Content-Type': mtype} producer = partial(raw_producer, filename) url_path = quote(os.path.basename(filename)) response = yield client.fetch('http://localhost:8888/%s' % url_path, method='PUT', headers=headers, body_producer=producer, timeout=18000) print(response.body) define("put", type=bool, help="Use PUT instead of POST", group="file uploader") # Tornado configures logging from command line opts and returns remaining args. filenames = options.parse_command_line() if not filenames: print("Provide a list of filenames to upload.", file=sys.stderr) sys.exit(1) for filename in filenames: with open(filename) as f: content = f.read() method = put if options.put else post name = 'pdf' ioloop.IOLoop.current().run_sync(lambda: method(content, name))
def main(): options.parse_command_line() print "Starting tornado web server on http://127.0.0.1:%s" % options.port print 'Quit the server with CONTROL-C' app.listen(options.port, xheaders=True) tornado.ioloop.IOLoop.instance().start()
def run(): options.parse_command_line() if options.config: options.parse_config_file(options.config) options.storage = os.path.abspath(options.storage) if os.getuid() == 0 and options.user: pw = pwd.getpwnam(options.user) uid, gid = pw.pw_uid, pw.pw_gid log.info("Changind user to %s [%s:%s]", options.user, uid, gid) os.setgid(uid) os.setuid(uid) try: if not all(f(options.storage) for f in (os.path.exists, os.path.isdir)): log.info('Creating new package storage directory: "%s"', options.storage) os.makedirs(options.storage) def on_interrupt(*args): log.warning("Receiving interrupt signal. Application will be stopped.") exit(errno.EINTR) log.debug("Preparing signal handling") for sig in (signal.SIGINT, signal.SIGTERM, signal.SIGQUIT): signal.signal(sig, on_interrupt) def handle_pdb(sig, frame): import pdb pdb.Pdb().set_trace(frame) if options.debug: signal.signal(signal.SIGUSR2, handle_pdb) log.debug("Creating application instance") app = create_app( options.debug, options.secret, options.gzip, ) log.debug("Creating IOLoop instance.") io_loop = IOLoop.current() io_loop.run_sync(lambda: init_db(options.database)) if not (os.path.exists(options.cache_dir) and os.path.isdir(options.cache_dir)): os.makedirs(options.cache_dir) Cache.CACHE_DIR = options.cache_dir log.info("Init thread pool with %d threads", options.pool_size) handlers.base.BaseHandler.THREAD_POOL = futures.ThreadPoolExecutor(options.pool_size) AsyncHTTPClient.configure(None, max_clients=options.max_http_clients) proxy_url = URL(os.getenv('{0}_proxy'.format(options.pypi_server.scheme))) if proxy_url: log.debug("Configuring for proxy: %s", proxy_url) AsyncHTTPClient.configure( 'tornado.curl_httpclient.CurlAsyncHTTPClient', defaults={ 'proxy_host': proxy_url.host, 'proxy_port': proxy_url.port, 'proxy_username': proxy_url.user, 'proxy_password': proxy_url.password, } ) PYPIClient.configure( options.pypi_server, handlers.base.BaseHandler.THREAD_POOL ) if options.pypi_proxy: pypi_updater = PeriodicCallback(PYPIClient.packages, HOUR * 1000, io_loop) io_loop.add_callback(PYPIClient.packages) io_loop.add_callback(pypi_updater.start) log.info("Starting server http://%s:%d/", options.address, options.port) http_server = HTTPServer(app, xheaders=options.proxy_mode) http_server.listen(options.port, address=options.address) log.debug('Setting "%s" as storage', options.storage) PackageFile.set_storage(options.storage) log.debug("Starting main loop") io_loop.start() except Exception as e: log.fatal("Exception on main loop:") log.exception(e) exit(1) else: exit(0)
def load_app_options(): load_default_options() options.parse_command_line(final=False) # 读取命令行参数 options.parse_config_file(os.path.join( os.path.dirname(os.path.abspath(__file__)), options.conf_file), final=True) # 读取文件配置
def main(): options.parse_command_line() print("Starting tornado web server on http://127.0.0.1:%s" % options.port) print("Quit the server with CONTROL-C") svr.listen(options.port, xheaders=True) tornado.ioloop.IOLoop.current().start()
def main(): options.parse_command_line() app = Application() app.listen(options.server_port, address=options.server_address) ioloop.IOLoop.instance().start()
def main(*args, **kwargs): options.parse_command_line() app = Application() app.listen(options.port) ioloop.IOLoop.instance().start()
def main(): options.parse_command_line() app = Application() http_server = tornado.httpserver.HTTPServer(app) http_server.listen(options.port) tornado.ioloop.IOLoop.current().start()
def main(): options.parse_command_line() Application().start()
def on_disconnect(self): pass def on_peers(self, data): print("peers", data) if __name__ == "__main__": define("ip", default='127.0.0.1', help="Server IP to connect to, default 127.0.0.1") define("verbose", default=False, help="verbose") options.parse_command_line( final=False ) # final False is required or it activates the client logger. if options.ip != '127.0.0.1': URL = "ws://{}:{}/chat/".format(options.ip, DEFAULT_PORT) print("Using {}".format(URL)) # See options https://python-socketio.readthedocs.io/en/latest/api.html sio = Client(logger=False) sio.register_namespace(ChatNamespace('/chat')) sio.connect('http://{}:{}'.format(options.ip, DEFAULT_PORT), namespaces=['/chat']) sleep(1) # not needed # We have to id ourselve first of all sio.emit('hello',
def parse_arguments(argv): if len(argv) == 2 and not argv[1].startswith('--'): options.parse_config_file(argv[1]) else: options.parse_command_line()
def main(): options.parse_command_line() # 读取命令行参数 且自动开启log app = Application(urls, **settings) # 生成application对象 http_server = tornado.httpserver.HTTPServer(app) # 生成http_server对象 http_server.listen(options.port, address="127.0.0.1") # 定义监听端口 tornado.ioloop.IOLoop.current().start() # 启动服务器 开启监听
import tornado.ioloop import tornado.web from app.settings import SETTINGS, APP_PATH from app.routes import ROUTES import sys from tornado.options import options, define from os.path import join, dirname import logging logging.basicConfig(filename=join(dirname(APP_PATH), 'logs', 'server.log'), level=logging.INFO) define('port', 8888) def make_app(): return tornado.web.Application(ROUTES, **SETTINGS) if __name__ == "__main__": args = sys.argv options.parse_command_line(args) app = make_app() app.listen(options.port) tornado.ioloop.IOLoop.current().start()
required_options = [ 'address', 'port', 'database_engine', 'database_name', ] required_options_without_default = [ 'database_engine', 'database_name', ] # Parse options.parse_command_line(final=False) if options.config: try: parse_config_file(options, options.config, 'JET', final=False) except IOError as e: if options.config != DEFAULT_CONFIG_PATH: raise e parse_environment(options, final=True) missing_options = list( filter(lambda x: x not in options or options[x] is None, required_options)) # Settings
def main(): options.parse_command_line() http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): ws_app = make_app() options.parse_command_line() server = httpserver.HTTPServer(ws_app) server.listen(options.port) ioloop.IOLoop.current().start()
def main(): options.parse_command_line() app = create_app() server = HTTPServer(app) server.listen(options.port) IOLoop.instance().start()