我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用tornado.options.options.parse_command_line()。
def group_dict(self, group): """The names and values of options in a group. Useful for copying options into Application settings:: from tornado.options import define, parse_command_line, options define('template_path', group='application') define('static_path', group='application') parse_command_line() application = Application( handlers, **options.group_dict('application')) .. versionadded:: 3.1 """ return dict( (opt.name, opt.value()) for name, opt in self._options.items() if not group or group == opt.group_name)
def group_dict(self, group): """The names and values of options in a group. Useful for copying options into Application settings:: from tornado.options import define, parse_command_line, options define('template_path', group='application') define('static_path', group='application') parse_command_line() application = Application( handlers, **options.group_dict('application')) .. versionadded:: 3.1 """ return dict( (name, opt.value()) for name, opt in self._options.items() if not group or group == opt.group_name)
def main(): """Creates Tornado Application and starts the IO Loop """ # Get the Port and Debug mode from command line options options.parse_command_line() # create logger for app logger = logging.getLogger('app') logger.setLevel(logging.INFO) FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' logging.basicConfig(format=FORMAT) tic_tac_toe_game_manager = TicTacToeGameManager() urls = [ (r"/$", IndexHandler), (r"/tic-tac-toe$", TicTacToeHandler), (r"/tic-tac-toe/ws$", TicTacToeSocketHandler, dict(game_manager=tic_tac_toe_game_manager)) ] # Create Tornado application application = tornado.web.Application( urls, debug=options.debug, autoreload=options.debug, **settings) # Start Server logger.info("Starting App on Port: {} with Debug Mode: {}".format(options.port, options.debug)) application.listen(options.port) tornado.ioloop.IOLoop.current().start()
def parse_command_line(args=None, final=True): """Parses global options from the command line. See `OptionParser.parse_command_line`. """ return options.parse_command_line(args, final=final)
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: log.debug("Starting autoreloader") tornado.autoreload.watch(CONFIG_FILE) for f in os.listdir(http_server.settings["template_path"]): fn = os.path.join(http_server.settings["template_path"], f) if os.path.isfile(fn): tornado.autoreload.watch(fn) tornado.autoreload.start(io_loop) log.info("Server started. Listening on {0}:{1}".format(options.address, options.port)) io_loop.start()
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 startup(): define(r'port', 80, int, r'Server listen port') define(r'service', False, bool, r'Open Scheduled Tasks') options.parse_command_line() if(config.Static.Debug): options.parse_command_line([__file__, r'--service=true', r'--logging=debug']) settings = { r'handlers': router.urls, r'static_path': r'static', r'template_loader': Jinja2Loader(r'view'), r'debug': config.Static.Debug, r'gzip': config.Static.GZip, r'cookie_secret': config.Static.Secret, } sockets = bind_sockets(options.port) task_id = 0 if(platform.system() == r'Linux'): task_id = fork_processes(cpu_count()) server = HTTPServer(Application(**settings)) server.add_sockets(sockets) if(task_id == 0 and options.service): service.start() signal.signal(signal.SIGINT, lambda *args : shutdown(server)) signal.signal(signal.SIGTERM, lambda *args : shutdown(server)) app_log.info(r'Startup http server No.{0}'.format(task_id)) IOLoop.instance().start()
def parse_command_line(self, args=None, final=True): """Parses all options given on the command line (defaults to `sys.argv`). Note that ``args[0]`` is ignored since it is the program name in `sys.argv`. We return a list of all arguments that are not parsed as options. If ``final`` is ``False``, parse callbacks will not be run. This is useful for applications that wish to combine configurations from multiple sources. """ if args is None: args = sys.argv remaining = [] for i in range(1, len(args)): # All things after the last option are command line arguments if not args[i].startswith("-"): remaining = args[i:] break if args[i] == "--": remaining = args[i + 1:] break arg = args[i].lstrip("-") name, equals, value = arg.partition("=") name = self._normalize_name(name) if name not in self._options: self.print_help() raise Error('Unrecognized command line option: %r' % name) option = self._options[name] if not equals: if option.type == bool: value = "true" else: raise Error('Option %r requires a value' % name) option.parse(value) if final: self.run_parse_callbacks() return remaining
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' # Fixed in Tornado 4.2 tornado.ioloop.IOLoop.instance() # Sync time to CertiVox time server if options.syncTime: Time.getTime(wait=True) Keys.getAPISettings(wait=True) log.info("Server starting on {0}:{1}...".format(options.address, options.port)) http_server = Application() http_server.listen(options.port, options.address, xheaders=True) main_loop = tornado.ioloop.IOLoop.instance() http_server.io_loop = main_loop if options.autoReload: log.debug("Starting autoreloader") tornado.autoreload.watch(CONFIG_FILE) tornado.autoreload.start(main_loop) process_dynamic_options( DYNAMIC_OPTION_MAPPING, DYNAMIC_OPTION_HANDLERS, application=http_server, initial=True) log.info("Server started. Listening on {0}:{1}".format(options.address, options.port)) main_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)) 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' # Fixed in Tornado 4.2 tornado.ioloop.IOLoop.instance() # Sync time to CertiVox time server if options.syncTime: Time.getTime(wait=True) if options.backup and options.encrypt_master_secret and not options.passphrase: options.passphrase = getpass.getpass("Please enter passphrase:") http_server = Application() http_server.listen(options.port, options.address, xheaders=True) io_loop = tornado.ioloop.IOLoop.instance() if options.autoReload: log.debug("Starting autoreloader") tornado.autoreload.watch(CONFIG_FILE) tornado.autoreload.start(io_loop) if options.syncTime and (options.timePeriod > 0): scheduler = tornado.ioloop.PeriodicCallback(Time.getTime, options.timePeriod, io_loop=io_loop) scheduler.start() log.info("Server started. Listening on {0}:{1}".format(options.address, options.port)) io_loop.start()
def define(self, name, default=None, type=None, help=None, metavar=None, multiple=False, group=None, callback=None): """Defines a new command line option. If ``type`` is given (one of str, float, int, datetime, or timedelta) or can be inferred from the ``default``, we parse the command line arguments based on the given type. If ``multiple`` is True, we accept comma-separated values, and the option value is always a list. For multi-value integers, we also accept the syntax ``x:y``, which turns into ``range(x, y)`` - very useful for long integer ranges. ``help`` and ``metavar`` are used to construct the automatically generated command line help string. The help message is formatted like:: --name=METAVAR help string ``group`` is used to group the defined options in logical groups. By default, command line options are grouped by the file in which they are defined. Command line option names must be unique globally. They can be parsed from the command line with `parse_command_line` or parsed from a config file with `parse_config_file`. If a ``callback`` is given, it will be run with the new value whenever the option is changed. This can be used to combine command-line and file-based options:: define("config", type=str, help="path to config file", callback=lambda path: parse_config_file(path, final=False)) With this definition, options in the file specified by ``--config`` will override options set earlier on the command line, but can be overridden by later flags. """ if name in self._options: raise Error("Option %r already defined in %s" % (name, self._options[name].file_name)) frame = sys._getframe(0) options_file = frame.f_code.co_filename file_name = frame.f_back.f_code.co_filename if file_name == options_file: file_name = "" if type is None: if not multiple and default is not None: type = default.__class__ else: type = str if group: group_name = group else: group_name = file_name self._options[name] = _Option(name, file_name=file_name, default=default, type=type, help=help, metavar=metavar, multiple=multiple, group_name=group_name, callback=callback)
def parse_command_line(self, args=None, final=True): """Parses all options given on the command line (defaults to `sys.argv`). Note that ``args[0]`` is ignored since it is the program name in `sys.argv`. We return a list of all arguments that are not parsed as options. If ``final`` is ``False``, parse callbacks will not be run. This is useful for applications that wish to combine configurations from multiple sources. """ if args is None: args = sys.argv remaining = [] for i in range(1, len(args)): # All things after the last option are command line arguments if not args[i].startswith("-"): remaining = args[i:] break if args[i] == "--": remaining = args[i + 1:] break arg = args[i].lstrip("-") name, equals, value = arg.partition("=") name = name.replace('-', '_') if not name in self._options: self.print_help() raise Error('Unrecognized command line option: %r' % name) option = self._options[name] if not equals: if option.type == bool: value = "true" else: raise Error('Option %r requires a value' % name) option.parse(value) if final: self.run_parse_callbacks() return remaining
def parse_command_line(self, args=None, final=True): """Parses all options given on the command line (defaults to `sys.argv`). Note that ``args[0]`` is ignored since it is the program name in `sys.argv`. We return a list of all arguments that are not parsed as options. If ``final`` is ``False``, parse callbacks will not be run. This is useful for applications that wish to combine configurations from multiple sources. """ if args is None: args = sys.argv remaining = [] for i in range(1, len(args)): # All things after the last option are command line arguments if not args[i].startswith("-"): remaining = args[i:] break if args[i] == "--": remaining = args[i + 1:] break arg = args[i].lstrip("-") name, equals, value = arg.partition("=") name = name.replace('-', '_') if name not in self._options: self.print_help() raise Error('Unrecognized command line option: %r' % name) option = self._options[name] if not equals: if option.type == bool: value = "true" else: raise Error('Option %r requires a value' % name) option.parse(value) if final: self.run_parse_callbacks() return remaining
def define(self, name, default=None, type=None, help=None, metavar=None, multiple=False, group=None, callback=None): """Defines a new command line option. If ``type`` is given (one of str, float, int, datetime, or timedelta) or can be inferred from the ``default``, we parse the command line arguments based on the given type. If ``multiple`` is True, we accept comma-separated values, and the option value is always a list. For multi-value integers, we also accept the syntax ``x:y``, which turns into ``range(x, y)`` - very useful for long integer ranges. ``help`` and ``metavar`` are used to construct the automatically generated command line help string. The help message is formatted like:: --name=METAVAR help string ``group`` is used to group the defined options in logical groups. By default, command line options are grouped by the file in which they are defined. Command line option names must be unique globally. They can be parsed from the command line with `parse_command_line` or parsed from a config file with `parse_config_file`. If a ``callback`` is given, it will be run with the new value whenever the option is changed. This can be used to combine command-line and file-based options:: define("config", type=str, help="path to config file", callback=lambda path: parse_config_file(path, final=False)) With this definition, options in the file specified by ``--config`` will override options set earlier on the command line, but can be overridden by later flags. """ if name in self._options: raise Error("Option %r already defined in %s", name, self._options[name].file_name) frame = sys._getframe(0) options_file = frame.f_code.co_filename file_name = frame.f_back.f_code.co_filename if file_name == options_file: file_name = "" if type is None: if not multiple and default is not None: type = default.__class__ else: type = str if group: group_name = group else: group_name = file_name self._options[name] = _Option(name, file_name=file_name, default=default, type=type, help=help, metavar=metavar, multiple=multiple, group_name=group_name, callback=callback)
