def load_logger_config(self):
        """
        重定义tornado自带的logger，可重写
        """
        config = self.settings.LOG_CONFIG
        options.logging = config["level"]
        options.log_to_stderr = config["log_to_stderr"]
        options.log_file_max_size = config["filesize"]
        options.log_file_num_backups = config["backup_num"]
        #tornado把默认的根logger加了handler
        #把根logger的handler去除，然后重新绑定在tornado的logger下
        logging.getLogger().handlers = []
        tornado_logpath = os.path.join(options.log_prefix,
                                       'tornado_access_log')
        if not os.path.exists(tornado_logpath):
            os.makedirs(tornado_logpath)
        file_name = "%s_access_log.%s.log" % ('tornado', str(options.port))
        options.log_file_prefix = os.path.join(tornado_logpath, file_name)
        enable_pretty_logging(None, logging.getLogger('tornado'))
        if self.settings.LOG_RELATED_NAME:
            for k, log in self.settings.LOG_RELATED_NAME.items():
                path = os.path.join(options.log_prefix, k)
                if not os.path.exists(path):
                    os.makedirs(path)

                options.log_file_prefix = os.path.join(path, "%s_log.%s.log" % (log, str(options.port)))
                enable_pretty_logging(None, logging.getLogger(log))
        return self

    def load_application(self, default_host='', transforms=None, wsgi=False):
        #加载app，进行初始化配置,如无ap参数，则使用内置app初始化
        logger_module.logger.load_config()
        tornado.options.parse_command_line()
        #tornado把默认的根logger加了handler
        #把根logger的handler去除，然后重新绑定在tornado的logger下
        logging.getLogger().handlers = []
        enable_pretty_logging(None, logging.getLogger('tornado'))
        #加载本地化配置
        if self.settings.TRANSLATIONS:
            try:
                tornado.locale.load_translations(self.settings.TRANSLATIONS_CONF.translations_dir)
            except:
                warnings.warn('locale dir load failure,maybe your config file is not set correctly.')

        #初始化app
        if not self.application:
            self.application = application_module.AppApplication(handlers=self.urls, default_host=default_host,
                                                                 transforms=transforms, wsgi=wsgi,
                                                                  **self.settings.get_settings('TORNADO_CONF'))


        self.application.project_path = self.proj_path if self.proj_path.endswith('/') else self.proj_path + '/'
        self.application.tmpl = import_object(self.settings.TEMPLATE_ENGINE) if self.settings.TEMPLATE_ENGINE else None
        return self.application

def main(urls):
  class BatchFetcher:
    n = 0
    def __call__(self, title, fetcher):
      if isinstance(title, bytes):
        try:
          title = title.decode('gb18030')
        except UnicodeDecodeError:
          pass
      url = ' <- '.join(reversed(fetcher.url_visited))
      logger.info('done: [%d] %s <- %s' % (fetcher.status_code, title, url))
      self.n -= 1
      if not self.n:
        tornado.ioloop.IOLoop.instance().stop()

    def add(self, url):
      TitleFetcher(url, self, url_finders=(GithubFinder,))
      self.n += 1

  from tornado.log import enable_pretty_logging
  enable_pretty_logging()
  f = BatchFetcher()
  for u in urls:
    f.add(u)
  tornado.ioloop.IOLoop.instance().start()

def start():
    from tornado.log import enable_pretty_logging
    enable_pretty_logging()
    tornado.options.parse_command_line()

    import_object('devsniff.proxy')
    import_object('devsniff.admin')

    server_root = dirname(__file__)
    proxy_settings = dict(
        debug=tornado_options.debug,
        template_path=path_join(server_root, "templates"),
        static_path=path_join(server_root, "static"),
    )
    proxy_app = TornadoWebApplication(route.get_routes(), **proxy_settings)
    proxy_bind = parse_bind_address(tornado_options.bind)

    if tornado_options.debug:
        proxy_app.listen(proxy_bind[1], proxy_bind[0])
    else:
        server = tornado.httpserver.HTTPServer(proxy_app)
        server.bind(proxy_bind[1], proxy_bind[0])
        server.start(0)

    io_loop = tornado.ioloop.IOLoop.instance()
    io_loop.add_callback(init_app)
    io_loop.start()

def config_logger(namespace=NETLOGGER_NAMESPACE, level = None, filename = None):
    tmpLog = nllog.get_logger(namespace)
    tmpLog.propagate = False
    nllog.PROJECT_NAMESPACE = namespace

    if filename:
        add_filehandler(tmpLog, filename)
    else:
        handler = logging.StreamHandler()
        handler.setFormatter(LogFormatter("%(message)s"))
        tmpLog.addHandler(handler)

    if level == "WARN":
        tmpLog.setLevel(logging.WARN)
    elif level == "TRACE":
        tmpLog.setLevel(nllog.TRACE)
    elif level == "DEBUG":
        tmpLog.setLevel(logging.DEBUG)
        if not filename:
            enable_pretty_logging()
    elif level == "CONSOLE":
        tmpLog.setLevel(25)
    else:
        tmpLog.setLevel(logging.INFO)
        
    return tmpLog

def setup_logger():
    # tornado
    log.enable_pretty_logging()

    # the logger used in this daemon
    logger = logging.getLogger('tmacd')
    logger.propagate = False
    logger.setLevel(logging.DEBUG)
    # rotate on Sunday
    handler = logging.handlers.TimedRotatingFileHandler('/tmp/tmacd.log',
                                                        when='w6',
                                                        atTime=datetime.time())
    handler.setLevel(logging.DEBUG)
    # align columns for my eyes
    formatter = logging.Formatter('{asctime}|{levelname:_<8}|{message}',
                                  style='{')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    # the logger used for acd_cli
    logger = logging.getLogger('acd')
    logger.propagate = False
    logger.setLevel(logging.DEBUG)
    # rotate on Sunday
    handler = logging.handlers.TimedRotatingFileHandler('/tmp/acd.log',
                                                        when='w6',
                                                        atTime=datetime.time())
    handler.setLevel(logging.DEBUG)
    # the message already has timestamp
    formatter = logging.Formatter('%(message)s')
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    def server_start(self):

        logging.info('server starting...')
        logger_module.logger.load_config()
        #tornado把默认的根logger加了handler
        #把根logger的handler去除，然后重新绑定在tornado的logger下
        logging.getLogger().handlers = []
        enable_pretty_logging(None, logging.getLogger('tornado'))

        #服务启动

        from tornado.netutil import bind_sockets

        if self.settings.IPV4_ONLY:
            import socket

            sockets = bind_sockets(options.port, options.address, family=socket.AF_INET)
        else:
            sockets = bind_sockets(options.port, options.address)

        self.print_settings_info()
        http_server = tornado.httpserver.HTTPServer(self.application)
        http_server.add_sockets(sockets)
        logging.info('tornado server started. listen port: %s ,host address: %s' % (options.port, options.address))
        tornado.ioloop.IOLoop.instance().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():
    """Entry point for bitsd."""
    enable_pretty_logging()

    try:
        parse_config_file('/etc/bitsd.conf')
    except IOError:
        LOG.warning('Config file not found, using defaults and command line.')

    try:
        parse_command_line()
    except tornado.options.Error as error:
        sys.stderr.write('{}\n'.format(error))
        sys.exit(0)

    persistence.start()
    server.start()
    listener.start()

    # Add signal handlers...
    signal.signal(signal.SIGTERM, sig_handler)
    signal.signal(signal.SIGINT, sig_handler)

    if not options.log_requests:
        logging.getLogger("tornado.access").setLevel(logging.WARNING)

    tornado.ioloop.IOLoop.instance().start()

def main():
    log.enable_pretty_logging()

    # construct OAuth URLs from jupyterhub base URL
    hub_api = os.environ['JUPYTERHUB_URL'].rstrip('/') + '/hub/api'
    authorize_url = hub_api + '/oauth2/authorize'
    token_url = hub_api + '/oauth2/token'
    user_url = hub_api + '/user'

    app = web.Application(
        [('/oauth_callback', JupyterHubLoginHandler), ('/', WhoAmIHandler)],
        login_url='/oauth_callback',
        cookie_secret=os.urandom(32),
        api_token=os.environ['JUPYTERHUB_API_TOKEN'],
        client_id=os.environ['JUPYTERHUB_CLIENT_ID'],
        redirect_uri=os.environ['JUPYTERHUB_SERVICE_URL'].rstrip('/')
        + '/oauth_callback',
        authorize_url=authorize_url,
        token_url=token_url,
        user_url=user_url,
    )

    url = urlparse(os.environ['JUPYTERHUB_SERVICE_URL'])
    log.app_log.info(
        "Running basic whoami service on %s", os.environ['JUPYTERHUB_SERVICE_URL']
    )
    app.listen(url.port, url.hostname)
    IOLoop.current().start()

    def run_from_argv(self, prog_name, argv=None, **_kwargs):
        app_settings = settings.APP_SETTINGS
        argv = list(filter(self.flower_option, argv))
        # parse the command line to get --conf option
        parse_command_line([prog_name] + argv)
        try:
            parse_config_file(options.conf, final=False)
            parse_command_line([prog_name] + argv)
        except IOError:
            if options.conf != settings.CONFIG_FILE:
                raise

        app_settings["debug"] = options.debug
        if options.cookie_secret:
            app_settings["cookie_secret"] = options.cookie_secret

        if options.url_prefix:
            prefix = options.url_prefix.strip("/")
            app_settings["static_url_prefix"] = "/{0}/static/".format(prefix)
            app_settings["login_url"] = "/{0}/login".format(prefix)
            settings.URL_PREFIX = prefix
        settings.CELERY_INSPECT_TIMEOUT = options.inspect_timeout
        settings.AUTO_REFRESH = options.auto_refresh

        if options.debug and options.logging == "info":
            options.logging = "debug"
            enable_pretty_logging()

        if options.auth:
            app_settings[GoogleOAuth2Mixin._OAUTH_SETTINGS_KEY] = {
                "key": options.oauth2_key or os.environ.get("GOOGLE_OAUTH2_KEY"),
                "secret": options.oauth2_secret or os.environ.get("GOOGLE_OAUTH2_SECRET"),
                "redirect_uri": options.oauth2_redirect_uri or os.environ.get("GOOGLE_OAUTH2_REDIRECT_URI"),
            }

        # Monkey-patch to support Celery 2.5.5
        self.app.connection = self.app.broker_connection

        self.app.loader.import_default_modules()
        flower = Flower(celery_app=self.app, options=options, **app_settings)
        atexit.register(flower.stop)

        # graceful shutdown on SIGTERM
        def signal_handler(signal, frame):
            logger.info("SIGTERM detected, shutting down")
            sys.exit(0)

        signal.signal(signal.SIGTERM, signal_handler)

        logger.info(
            "Visit me at http%s://%s:%s", "s" if flower.ssl else "", options.address or "localhost", options.port
        )
        logger.info("Broker: %s", self.app.connection().as_uri())
        logger.debug("Registered tasks: \n%s", pformat(sorted(self.app.tasks.keys())))
        logger.debug("Settings: %s", pformat(app_settings))

        try:
            flower.start()
        except (KeyboardInterrupt, SystemExit):
            pass

def load_settings():
    '''
        Load settings from command line and config file.
    '''

    # Parse command line
    options.logging = 'none' # To turn off logging settings
    options.log_to_stderr = True # Log to stderr
    parse_command_line()

    # Load settings from another config file if given
    if options.config:
        parse_config_file(options.config + '.conf')

    # Log file prefix
    options.log_file_prefix = ''.join((
        'log/',
        options.name,
        '-',
        str(options.port),
        '.log',
    ))

    # Logging settings
    if options.logging == 'none': # There are no logging settings before
        options.logging = 'debug' if options.debug else 'info'
        enable_pretty_logging(options=options)

    pretty_options_output()

 def setup_logging(self):
     if options.debug and options.logging == 'info':
         options.logging = 'debug'
         enable_pretty_logging()
     else:
         logging.getLogger("tornado.access").addHandler(NullHandler())
         logging.getLogger("tornado.access").propagate = False

def mitmweb(args=None):  # pragma: nocover
    from . import web

    # 输出请求日志
    from tornado.log import enable_pretty_logging
    enable_pretty_logging()

    check_versions()
    parser = cmdline.mitmweb()

    options = parser.parse_args(args)
    if options.quiet:
        options.verbose = 0

    proxy_config = process_proxy_options(parser, options)
    web_options = web.Options(**cmdline.get_common_options(options))
    web_options.intercept = options.intercept
    web_options.wdebug = options.wdebug
    web_options.wiface = options.wiface
    web_options.wport = options.wport

    server = get_server(web_options.no_server, proxy_config)

    m = web.WebMaster(server, web_options)
    try:
        m.run()
    except KeyboardInterrupt:
        pass

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 main():
    parse_command_line()
    enable_pretty_logging()
    wsgi_app = wsgi.WSGIContainer(django.core.handlers.wsgi.WSGIHandler())
    staticpath = [
        _HERE + "/static/",
        _HERE + "/deb/",
        "/usr/local/lib/python2.7/dist-packages/django/contrib/admin/static/",
        "/usr/local/lib/python2.7/dist-packages/django_admin_bootstrapped/static/",
        "/usr/local/lib/python2.7/dist-packages/bootstrap_markdown/static/",
    ]
    mapping = [
        (r"/(favicon.ico)", web.StaticFileHandler, {"path": _HERE + "/static"}),
        (r"/static/(.*)", MultiStaticFileHandler, {"paths": staticpath}),
        (r"/deb/(.*)", MultiStaticFileHandler, {"paths": staticpath}),
        (".*", web.FallbackHandler, dict(fallback=wsgi_app)),
    ]
    tornado_app = web.Application(mapping, debug=True)
    server = httpserver.HTTPServer(tornado_app)
    server.listen(options.port)
    print "http://{}:{}".format(LOCALIP, options.port)
    try:
        ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        ioloop.IOLoop.instance().stop()
    print "Finished"

def main():
    import getpass
    from tornado import options
    from tornado.log import enable_pretty_logging

    options.define("xmpp", default=None, help="XMPP Account", metavar="XMPP")
    options.define("qq", default=None, type=int, help="QQ Account",
                   metavar="QQ")
    options.define("debug", type=bool, default=False, help="Show debug info")
    options.define("control", default=None, help="XMPP Control Account",
                   metavar="CONTROL")
    options.parse_command_line()

    xmpp = options.options.xmpp
    qq = options.options.qq
    control = options.options.control
    debug = options.options.debug
    if not xmpp or not qq or not control:
        options.print_help()
        return

    xmpp_pwd = getpass.getpass(u"Enter XMPP Password: ")
    qq_pwd = getpass.getpass(u"Enter QQ Password: ")

    enable_pretty_logging()
    client = MagpieClient(qq, qq_pwd, xmpp, xmpp_pwd, control, debug)
    client.run()

def run(filedict, port=None, debug=False):
    # print args

    # Set logging level
    options.logging = 'INFO'
    if debug:
        print 'Enter debug mode'
        options.logging = 'DEBUG'
    enable_pretty_logging(options)

    application = Application(
        [
            (r'/', IndexHandler),
        ],
        static_path=os.path.join(root_path, 'static'),
        template_path=os.path.join(root_path, 'template'),
        debug=debug,
    )
    for host, rules in application.handlers:
        for i in rules:
            logging.debug('URL rule %s', i.regex.pattern)

    application.yaml_filedict = filedict

    http_server = httpserver.HTTPServer(application)
    http_server.listen(port)
    print 'Colordesk server started: http://127.0.0.1:%s' % port

    try:
        ioloop.IOLoop.instance().start()
    except KeyboardInterrupt:
        print 'Stop colordesk server.'

def main(args=None):
    if args is None:
        args = sys.argv

    options.define('root', default='.', help='document root')
    options.define('proxy', default='', help='http proxy')

    options.parse_command_line()

    log.enable_pretty_logging()

    main_loop = ioloop.IOLoop.instance()

    pool = cf.ThreadPoolExecutor(max_workers=4)

    application = web.Application([
        (r'/(.*)', IndexHandler, {
            'root': options.options.root,
            'pool': pool,
            'proxy': options.options.proxy,
        }),
    ], debug=True)

    application.listen(8000)

    main_loop.start()
    pool.shutdown()
    main_loop.close()

    return 0

    def run_from_argv(self, prog_name, argv=None, **_kwargs):
        app_settings = settings.APP_SETTINGS
        argv = list(filter(self.flower_option, argv))
        # parse the command line to get --conf option
        parse_command_line([prog_name] + argv)
        try:
            parse_config_file(options.conf, final=False)
            parse_command_line([prog_name] + argv)
        except IOError:
            if options.conf != settings.CONFIG_FILE:
                raise

        app_settings['debug'] = options.debug
        if options.cookie_secret:
            app_settings['cookie_secret'] = options.cookie_secret

        if options.url_prefix:
            logger.error('url_prefix option is not supported anymore')

        settings.AUTO_REFRESH = options.auto_refresh

        if options.debug and options.logging == 'info':
            options.logging = 'debug'
            enable_pretty_logging()

        if options.auth:
            app_settings[GoogleOAuth2Mixin._OAUTH_SETTINGS_KEY] = {
              'key': options.oauth2_key or os.environ.get('GOOGLE_OAUTH2_KEY'),
              'secret': options.oauth2_secret or os.environ.get('GOOGLE_OAUTH2_SECRET'),
              'redirect_uri': options.oauth2_redirect_uri or os.environ.get('GOOGLE_OAUTH2_REDIRECT_URI'),
            }

        # Monkey-patch to support Celery 2.5.5
        self.app.connection = self.app.broker_connection

        self.app.loader.import_default_modules()
        flower = Flower(celery_app=self.app, options=options,
                        **app_settings)
        atexit.register(flower.stop)

        # graceful shutdown on SIGTERM
        def signal_handler(signal, frame):
            logger.info('SIGTERM detected, shutting down')
            sys.exit(0)
        signal.signal(signal.SIGTERM, signal_handler)

        logger.info('Visit me at http%s://%s:%s',
                    's' if flower.ssl else '',
                    options.address or 'localhost',
                    options.port)
        logger.info('Broker: %s', self.app.connection().as_uri())
        logger.debug('Registered tasks: \n%s',
                     pformat(sorted(self.app.tasks.keys())))
        logger.debug('Settings: %s', pformat(app_settings))

        try:
            flower.start()
        except (KeyboardInterrupt, SystemExit):
            pass