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 parser(): define('script', default='/var/maple/') define('dbhost', default='localhost') define('dbuser', default='root') define('dbpass', default='') define('db', default='maple') parse_config_file('/etc/maple/default.conf')
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 make_app(): parse_config_file('./config.py') assert options.db_url, "Need a database URL" session_factory = make_session_factory(options.db_url) # group is named (?P<name>group) handlers = [ url(r"/", MainHandler), url(r"/api/v1", InfoView, name='api'), url(r'/api/v1/assets', AssetListView), url(r'/api/v1/assets/(?P<asset_id>[0-9]+)', AssetView, name='asset'), url(r'/api/v1/layers', LayerListView), url(r'/api/v1/wells', WellListView), url(r'/api/v1/intersection', IntersectionListView), ] settings = { 'session_factory': session_factory, 'debug': options.debug, 'template_path': './template/', 'static_path': './static/', 'static_url_prefix': '/static/' } return Application(handlers, **settings )
def main(): parse_command_line() flagfile = os.path.join(os.path.dirname(__file__), options.flagfile) parse_config_file(flagfile) settings = dict( login_url='/todo/login', debug=True, template_path=os.path.join(os.path.dirname(__file__), 'templates'), static_path=os.path.join(os.path.dirname(__file__), 'static'), cookie_secret=options.cookie_secret, dropbox_consumer_key=options.dropbox_consumer_key, dropbox_consumer_secret=options.dropbox_consumer_secret, ) #print options.dropbox_consumer_key #print options.dropbox_consumer_secret app = Application([ ('/', RootHandler), ('/todo/?', TodoHandler), ('/todo/add', AddHandler), ('/delete', DeleteHandler), ('/create', CreateHandler), ('/todo/login', DropboxLoginHandler), ('/todo/logout', LogoutHandler), ], **settings) app.listen(options.port,address='127.0.0.1',xheaders=True) IOLoop.instance().start()
def run(self): from tornado import options control = Control(file_archive='',db_url=self.db_url) #control.api_logon(self.ims_user, self.password) #The config file is reloaded here, as some of the logging options could have been reset #when the feeds and filters were loaded if os.path.isfile(self.config_file): logging.debug("Loading options from: %s" % self.config_file) options.parse_config_file(self.config_file, final=False) else: logging.warning("The config file was not loaded: %s" % self.config_file) path, name = os.path.split(self.path) for prefix, funcname in self.cash_map.iteritems(): if name.lower().startswith(prefix.lower()): func = getattr(control, funcname) break else: msg = "Unknown file name [%s]" % name raise ValueError(msg) func(self.path,self.ims_user, self.recipents)
def make_server(config_path): root = path.dirname(__file__) static_path = path.join(root, 'static') template_path = path.join(root, 'template') define('port', default=7777, type=int) define('production', default=False, type=bool) define('mongo_db_name', default='open_wireless_map', type=str) define('mongo_host', default='localhost', type=str) define('mongo_port', default=27017, type=int) define('mongo_user', default=None, type=str) define('mongo_password', default=None, type=str) define('api_password_hash', default=None, type=str) parse_config_file(config_path) app_config = dict(static_path=static_path, template_path=template_path) if not options.production: app_config.update(debug=True) server = Application(url_map, **app_config) server.settings['api_password_hash'] = options.api_password_hash server.settings['mongo'] = get_mongo(db_name=options.mongo_db_name, host=options.mongo_host, port=options.mongo_port, user=options.mongo_user, password=options.mongo_password) return server
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 main(): if os.path.exists(options.config_file): parse_config_file(options.config_file) parse_command_line() app = Application( [ url(r'/token/?', auth.TokenHandler), url(r'/tasks/?', tasks.TaskHandler), url(r'/tasks/({uuid})/?'.format(uuid=UUID_PATTERN), tasks.TaskHandler), url(r'/domains/?', vms.DomainHandler), url(r'/domains/({uuid})/?'.format(uuid=UUID_PATTERN), vms.DomainHandler), url(r'/nodes/?', vms.NodeHandler), url(r'/nodes/([\d+])/?', vms.NodeHandler) ], template_path=os.path.join(BASE_DIR, 'templates'), static_path=os.path.join(BASE_DIR, 'static'), **options.group_dict('application') ) app.listen(options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.current().add_callback(start_queue, app) IOLoop.current().start()
def main(): global http_server try: signal(SIGTERM, on_signal) parse_command_line() if options.config != None: parse_config_file(options.config) path = join(dirname(__file__), "templates") application = Application( [(r"/", IndexHandler), (r"/stock", StockHandler)], template_path=path, static_path=join(dirname(__file__), "static"), ) application.db = motor.MotorClient(options.db_host, options.db_port).open_sync()[options.db_name] http_server = HTTPServer(application) http_server.listen(options.port, options.address) log().info("server listening on port %s:%d" % (options.address, options.port)) if log().isEnabledFor(DEBUG): log().debug("autoreload enabled") tornado.autoreload.start() IOLoop.instance().start() except KeyboardInterrupt: log().info("exiting...") except BaseException as ex: log().error("exiting due: [%s][%s]" % (str(ex), str(format_exc().splitlines()))) exit(1)
def load_config(path=None): ''' This extends the tornado parser to enable use in heroku where options are accessed through os.getenv Will read file at path if exists Will then read environment variables to override Will then parse command line to override ''' if path is not None and os.path.isfile(path): logging.info("loading config from %s", path) parse_config_file(path) for k in options.as_dict(): ''' danger: access of private variables ''' value = os.getenv(k) if value: name = options._normalize_name(k) option = options._options.get(name) option.parse(value) parse_command_line()
def parse_configs(config_files): """Reads command line options / config file and bootstraps logging. """ parse_command_line(final=False) if options.config: configs_to_read = options.config else: configs_to_read = config_files configs_to_read = filter( None, [configs_to_read] if not isinstance(configs_to_read, (list, tuple)) else configs_to_read ) for config in configs_to_read: parse_config_file(config, final=False) # override options from config with command line options parse_command_line(final=False) bootstrap_core_logging() for config in configs_to_read: log.debug('using config: %s', config) if options.autoreload: tornado.autoreload.watch(config)
def main(): # We have settings? if os.path.exists('settings.py'): parse_config_file('settings.py') # What about command line args? parse_command_line() ssl_options = {} # Check SSL options if (options.certfile and options.keyfile) and (os.path.exists( os.path.abspath(options.certfile)) and os.path.exists( os.path.abspath(options.keyfile))): ssl_options['certfile'] = os.path.abspath(options.certfile) ssl_options['keyfile'] = os.path.abspath(options.keyfile) server = HTTPServer(app(), ssl_options=ssl_options or None) if options.debug: options.address = '127.0.0.1' log.debug('Run application in debug mode on %s:%s.' % (options.address, options.port)) server.listen(options.port, options.address) else: log.debug('Run application in normal mode on %s:%s.' % (options.address, options.port)) server.bind(options.port, options.address) server.start(0) IOLoop.instance().start()
def __init__(self): define("xmpp_jid", help="XMPP JID. e.g.: [email protected]", type=str) define("xmpp_password", help="XMPP Password.", type=str) define("xmpp_host", help="XMPP Host", type=str) define("xmpp_port", help="XMPP Port", type=int) define("xmpp_relay_user", help="XMPP relay user", type=str) define("callback_port", help="HTTP callback port.", default=15827, type=int) config_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "upstream-config.py") parse_config_file(config_path) self.relay_user = options["xmpp_relay_user"].value() super(XMPPManager, self).__init__("XMPPManager(%s)", options["xmpp_jid"].value()) start = "http://127.0.0.1:%d/start/" % options["callback_port"].value() message = "http://127.0.0.1:%d/message/" % options["callback_port"].value() self.xmpp = XMPPProxyBot(options["xmpp_jid"].value(), options["xmpp_password"].value(), start, message) self.app = tornado.web.Application( [ (r"/start/", XMPPProxyCallback, {"callback": self.on_start}), (r"/message/", XMPPProxyCallback, {"callback": self.on_message}), ] ) if self.xmpp.connect((options["xmpp_host"].value(), options["xmpp_port"].value())): self.xmpp.process(block=False) self.streams = {} self.app.listen(options["callback_port"].value())
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
def main(): define("port", default=8888, type=int) define("db", default=":memory:") define("db_echo", default=True) parse_config_file("application.cfg") logging.info("Starting tornado server") Server.get_app().listen(options.port) tornado.ioloop.IOLoop.instance().start()
def main(): init_config() options.parse_config_file("/var/www/app/webssh.conf") http_server = tornado.httpserver.HTTPServer(Application()) http_server.listen(options.port) IOLoop.instance().start() tornado.ioloop.IOLoop.instance().start()
def config(): define('CACHE_TIME', default=5 * 60, help="The cached time for every news, in seconds") define('DEBUG', default=True, help="The global debug control") define("PORT", default=8000, help="PORT") if os.path.exists('config.py'): parse_config_file('config.py') options.log_to_stderr = False
def parse_file(filepath): try: parse_config_file(filepath) except IOError as e: pass except Error as e: print("Error parsing config file %s:" % filepath) print("\t%s" % e) sys.exit(-1)
def main(config_file="./kew_pe.conf"): ''' parse the command line - new up the appl and listen on port ''' if os.path.isfile(config_file): print("Loading config file %s" % os.path.abspath(config_file)) options.parse_config_file(config_file) options.parse_command_line() logging.basicConfig(level=logging.DEBUG, format="[%(levelname)1.1s %(asctime)s %(process)d %(module)s:%(lineno)d] %(message)s") run()
def main(config_file="./kew_register.conf"): ''' parse the command line - new up the appl and listen on port ''' if os.path.isfile(config_file): print ("Loading configuration file %s" % config_file) options.parse_config_file(config_file) options.parse_command_line() run('localhost', options.options.db_url)
def make_app(environ, argv1=None): parser = OptionParser() parser.add_option( "-c", "--config", dest="config_file", help="Configuration file", metavar="FILE") parser.add_option( "-d", "--data", dest="data", help="Data directory", metavar="FILE") parser.add_option( "-l", "--logfile", dest="log_file_prefix", help="Log file", metavar="FILE") parser.add_option( "-L", "--log-level", dest="logging", help="Log level", metavar="info|warning|error|none") parser.add_option( "-p", "--port", dest="port", help="Port", default="0") opts, args = parser.parse_args(argv1) name = args[0] if opts.data.startswith('/'): instance_path = os.path.join(opts.data, name) else: instance_path = os.path.join(os.getcwd(), opts.data, name) config_file = opts.config_file or os.path.join(os.path.abspath(instance_path), "etc", "vaytrou.conf") if config_file is not None: parse_config_file(config_file) parse_command_line([]) # Load command line options over Tornado options for k, v in options.items(): optv = getattr(opts, k, None) if optv is not None: try: options[k].set(v.type(optv)) except: import pdb; pdb.set_trace() raise finder = PersistentApplicationFinder( 'file://%s/%s/var/Data.fs' % (options.data, name), appmaker) index = finder(environ) index.fwd = Rtree('%s/%s/var/vrt1' % (options.data, name)) setattr(index, 'name', name) setattr(index, 'data', options.data) return Application(index, [ (r'/', MainHandler), (r'/intersection/?', IntersectionHandler), (r'/nearest/?', NearestHandler), (r'/distance/?', DistanceHandler), (r'/within/?', WithinHandler), (r'/item/([-\w]+);([-0-9\.]+),([-0-9\.]+),([-0-9\.]+),([-0-9\.]+)', SingleItemHandler), (r'/items/([-\w]+)', MultipleItemsHandler) ])
def run_from_argv(self, prog_name, argv=None, **_kwargs): app_settings = settings.APP_SETTINGS argv = list(filter(self.flower_option, argv)) try: parse_config_file('flowerconfig.py', final=False) print("Parsed Flower configfile") except IOError: print("Flower configfile not found") pass parse_command_line([prog_name] + argv) 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: logging.getLogger().setLevel(logging.DEBUG) #set the celery BROKER_URL based on the config broker value self.app.conf['BROKER_URL'] = options.broker #overwrite if environment variables REDIS_HOST, REDIS_PORT, REDIS_DB are set if os.environ.get('REDIS_HOST') and os.environ.get('REDIS_PORT') and os.environ.get('REDIS_DB'): self.app.conf['BROKER_URL'] = "redis://" + str(os.environ.get('REDIS_HOST')) + ":" + str(os.environ.get('REDIS_PORT')) + "/" + str(os.environ.get('REDIS_DB')) # Monkey-patch to support Celery 2.5.5 #self.app.connection = self.app.broker_connection flower = Flower(celery_app=self.app, options=options, **app_settings) atexit.register(flower.stop) # graceful shutdown on SIGTERM def signal_handler(signal, frame): logging.info('SIGTERM detected, shutting down') sys.exit(0) signal.signal(signal.SIGTERM, signal_handler) logging.info('Visit me at http%s://%s:%s', 's' if flower.ssl else '', options.address or 'localhost', options.port) logging.info('My Broker: %s', self.app.connection().as_uri()) logging.debug('Registered tasks: \n%s', pformat(sorted(self.app.tasks.keys()))) logging.debug('Settings: %s', pformat(app_settings)) try: flower.start() except (KeyboardInterrupt, SystemExit): pass
def main(): config_path = "simple.conf" if os.path.isfile(config_path): logging.info("loading config file") parse_config_file(config_path) parse_command_line() s3_config = AWSConfig(options.aws_access_key_id, os.environ.get("S3_CONFIG", options.aws_secret_access_key)) ws_config = { "google_key": options.google_key, "aws_access_key_id": options.aws_access_key_id, "aws_secret_access_key": options.aws_secret_access_key, "s3_bucket_region": options.upload_bucket_region, "s3_bucket": options.upload_bucket, "s3_base_url": "//" + options.upload_bucket + ".s3.amazonaws.com", "s3_upload_url": "/images/" } port = int(os.environ.get("PORT", options.port)) db_url = os.environ.get("CLEARDB_DATABASE_URL",options.db_url) control = Control(db_url=db_url,drop_all=True) handlers = [ (r"/websocket", WebsocketHandler), (r"/login(.*)", LoginHandler), (r"/logout", LogoutHandler), (r"/config", ConfigHandler, {"config": ws_config }), (r"/rest/(.*)", RestHandler,{"auth_header":'simple-auth-token'}), (r"/images/(.*)", S3UploadDirectHandler, { "bucket": options.upload_bucket, "s3_config": s3_config }), (r"/", IndexHandler), ] settings = { "static_path": resource_filename('examples.simple',"www/static"), "template_path": resource_filename('examples.simple',"www/templates"), "cookie_secret": 'blueshed.simple-secret', "cookie_name": 'blueshed.simple-user', "login_url": '/login', "gzip": True, "control": control, "ws_version": WS_VERSION, "ws_config": ws_config, "debug": options.debug } application = tornado.web.Application(handlers, **settings) application.listen(port) logging.info("listening on port {}".format(port)) logging.info("mode:{}".format("production" if options.debug=='no' else 'debug')) tornado.ioloop.IOLoop.instance().start()
def main(config_file="./kew_pe.conf"): from tornado import options ''' parse the command line - new up the appl and listen on port ''' if os.path.isfile(config_file): print ("Loading config file %s" % config_file) options.parse_config_file(config_file) options.parse_command_line() run()
def parse_options(): """优先级:命令行 > 安装目录/config.py > /etc/light/net_server.py""" if os.path.exists("/etc/light/net_server.py"): opts.parse_config_file("/etc/light/net_server.py") if os.path.exists(os.path.join(LOCAL_DIR, "config.py")): opts.parse_config_file(os.path.join(LOCAL_DIR, "config.py")) opts.parse_command_line() print "使用配置" for k, i in opts.options.as_dict().items(): print k, "->", i
def setUpClass(self): if "port" not in options: define("port", default=8888, type=int) if "db" not in options: define("db", default=":memory:") if "db_echo" not in options: define("db_echo", default=True) config_file = os.path.join(os.path.dirname(__file__), "test.cfg") parse_config_file(config_file) models_init()
def setUp(self): AsyncTestCase.setUp(self) for key in options.keys(): del options[key] define_common_options() define_node_options() parse_config_file(os.path.join(DIR, 'config_data.py')) self.init_storages() self.node_oid = str(uuid.uuid1()) Cluster.instance().init()
def main(): ''' parse the command line - new up the appl and listen on port ''' if os.path.isfile("kew_pe.conf"): print ("Loading config file ./kew_pe.conf") options.parse_config_file("kew_pe.conf") options.parse_command_line() logging.basicConfig(level=logging.DEBUG) index_control.run('localhost',8081)
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() # 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
#!/usr/bin/env python # -*- coding: utf-8 -*- from tornado import web, ioloop, options from server.chatroom import ChatRoomHandler if __name__ == '__main__': app = web.Application([ (r"/", ChatRoomHandler), ], websocket_ping_interval=3) options.parse_config_file("./config/logger.conf") app.listen(8080) ioloop.IOLoop.current().start()
#!/usr/bin/env python from os import path from sys import argv from pyPdf import PdfFileReader from tornado.options import define, options, parse_config_file from magpie.config import config_path define('repo', default=None, type=str) define('default_notebook', default='', type=str) parse_config_file(config_path.pdf_scraper) def scrape(file_path): pdf = PdfFileReader(file(file_path, 'rb')) content = '' for i in range(0, pdf.numPages): # TODO figure out why line breaks don't seem to be rendering content += pdf.getPage(i).extractText() + '\n' out_file = '.%s' % path.basename(file_path) out_path = path.join(path.dirname(file_path), out_file) if options.repo not in path.commonprefix([out_path, options.repo]): out_path = path.join(options.repo, options.default_notebook, out_file) content = content.encode('ascii', 'ignore') f = open(out_path, 'w') f.write(content) f.close() if __name__ == '__main__': for file_name in argv[1:]: scrape(file_name)
import os from tornado.ioloop import IOLoop from tornado.options import parse_command_line, parse_config_file, options from msched import make_app from msched.handlers import TaskHandler, TasksHandler routes = [(r'/task', TaskHandler), (r'/task/(.*)', TaskHandler), (r'/tasks', TasksHandler)] app = make_app(routes) if __name__ == '__main__': if os.path.exists('/etc/msched/proxy.conf'): parse_config_file('/etc/msched/proxy.conf') if os.path.exists('./application.conf'): parse_config_file('./application.conf') parse_command_line() app = make_app(routes, debug=True) app.listen(options.port, address=options.bind) try: app.zk.start() IOLoop().current().start() except KeyboardInterrupt: IOLoop().current().stop()
import logging import tornado.web import tornado.ioloop import tornado.websocket from tornado import gen, ioloop from tornado.httpclient import AsyncHTTPClient, HTTPError from tornado.options import define, options, \ parse_command_line, parse_config_file define("port", default=8888, help="run on the given port", type=int) define("benzinga_endpoint", default="http://data.benzinga.com/stock", help="benzinga stock base URL", type=str) base_dir = os.path.dirname(__file__) parse_config_file(os.path.join(base_dir, "settings.cfg")) # list of active trade websocket connections connections = [] class Main(tornado.web.RequestHandler): @tornado.web.asynchronous def get(self): self.render("index.html") class Trade(tornado.web.RequestHandler): @tornado.web.asynchronous def get(self): self.render("trade.html")
define("http_port", default=5000, help="HTTP Port") define("tornado_secret", help="Tornado Secret") define("tornado_translations", help="Tornado translations path") define("tornado_templates", help="Tornado templates path") define("tornado_static", help="Tornado static path") define("evesso_clientid", help="EVE SSO client ID") define("evesso_secretkey", help="EVE SSO secret key") define("evesso_callback", help="EVE SSO callback URI") options.define("slack_apitoken", help="Slack API Token") options.define("slack_username", help="Slack username", default="apoptosis") parse_config_file("/home/user/apoptosis.conf") # XXX correct location auth_name = options.auth_name redis_host = options.redis_host redis_port = options.redis_port redis_database = options.redis_database redis_password = options.redis_password database_uri = options.database_uri http_port = options.http_port tornado_secret = options.tornado_secret tornado_translations = options.tornado_translations tornado_templates = options.tornado_templates
def main(): try: parse_config_file('/home/wormhole-tracker/wormhole-tracker.conf') except Exception as e: # TODO: specify correct exception here logging.warning(e) parse_command_line() if (not options.client_id or not options.client_key or not options.redirect_uri or not options.cookie_secret): error = """ Please create configuration file /home/wormhole-tracker/wormhole-tracker.conf and fill it as follows: client_id = "your_eve_app_id" client_key = "your_eve_app_key" redirect_uri = "http://your-domain-or-ip.com" cookie_secret = "my_secret_secret" For example: client_id = "334jjnn32i23yv23592352352sa3n52b" client_key = "3534ui32b5223yu5u2v35v23v523v3fg" redirect_uri = "http://my-awesome-eve-app.com" # "http(s)://" IS required! cookie_secret = "WYkRXG1RJhmpYlYCA2D99EFRz9lt709t" Or, if you launch the application via terminal, provide this data as command line arguments as follows: wormhole-tracker --client_id="eve_app_id" \\ --client_key="eve_app_key" \\ --redirect_uri="https://domain-or-ip.com" \\ --cookie_secret="my_secret" """ logging.error(error) sys.exit(1) settings['cookie_secret'] = options.cookie_secret app = App(options.client_id, options.client_key, routes, settings) http_server = HTTPServer(app, xheaders=True) # TODO: uncomment when obtain db #http_server.bind(options.port) #http_server.start(0) # Use one IOLoop per CPU core http_server.listen(options.port) try: logging.info("Starting server...") IOLoop.current().start() except (SystemExit, KeyboardInterrupt): logging.info("Stopping server.") IOLoop.current().stop() http_client.close() sys.exit() except Exception as e: logging.error(e) IOLoop.current().stop() http_client.close() sys.exit(1)
import json import click import tornado.ioloop import tornado.web import tornado.websocket import tornado.template from tornado.options import define, options, parse_config_file __version__ = '0.0.10' webhook_cnt = 0 # webhook 计数,每次重启都清空 webhook_last = '' webhook_repo = '' # webhook hook 哪一个 git 仓库 config_path = '/webhookit/tests/config.py' define('WEBHOOKIT_CONFIGURE', type=dict) parse_config_file(config_path) WEBHOOKIT_CONFIGURE = options.WEBHOOKIT_CONFIGURE class IndexPageHandler(tornado.web.RequestHandler): def get(self): global webhook_cnt, webhook_last, webhook_repo, WEBHOOKIT_CONFIGURE config = WEBHOOKIT_CONFIGURE or {} config = utils.filter_sensitive(config) t = tornado.template.Template(temp.INDEX_HTML_TEMP) self.write( t.generate(version=__version__, count=webhook_cnt, date=webhook_last, repo=webhook_repo, logs=WSHandler.logs,
def get_options(env): parse_config_file('./algorithm_services/config/{env}.conf'.format( env=env, )) return options
import os import json import datetime from tornado import web from tornado import gen from tornado import escape from tornado.web import asynchronous from tornado.options import parse_command_line, options, parse_config_file import tornado.ioloop import tornado.log from tornado.websocket import WebSocketHandler from libs.geo import GeoFetch from tornado.httpclient import AsyncHTTPClient github_data = {} parse_config_file("config.py") parse_config_file("settings.py") import workers class ApiHandler(web.RequestHandler): def __init__(self, *args, **kwargs): super(ApiHandler, self).__init__(*args, **kwargs) super(ApiHandler, self).set_header('Content-Type', 'application/json; charset=UTF-8') def prepare(self): """do something before request comming""" #options.logger.debug(self.request) pass
self.write('<a href="/python">hello python</a>') # 响应以post方式发送的请求 def post(self, *args, **kwargs): pass # 演示配置文件配置 # 定义一个变量,用来代表端口号,若配置文件中找不到port,则使用default multiple 是否为多个元素 define('port', type=int, default=11111, multiple=False) # 再定义一个变量,用来代表连接数据库的连接信息(用户名,密码,端口,数据库名称) define('db', multiple=True, default=[]) # 从指定的配置文件中,读取配置文件中的内容 parse_config_file('configure') print(options.db) print(options.port) # 演示路由列表 # 创建application对象,进行对若干个服务器的设置 # 例如,路由列表 静态资源路径 模板路径 app = Application([ ('/', IndexHandler), ]) # 演示服务器配置 # 创建服务器程序
from modelrunner import (config, WorkerServer, Dispatcher, __version__) from modelrunner.settings import (initialize, redis_connection, job_queue_name, node_channel_name, all_nodes_channel_name) from tornado.options import parse_command_line, parse_config_file # setup log logger = logging.getLogger('modelrunner') logger.info("modelrunner %s (Python %s)" % (__version__, '.'.join(map(str, sys.version_info[:3])))) # so we can load config via cmd line args parse_command_line() parse_config_file(config.options.config_file) # initialize the global application settings initialize(config.options.redis_url) # get the command_ keys command_dict = config.options.group_dict("model_command") worker_handler = WorkerServer(config.options.worker_url, config.options.data_dir, config.options.model, command_dict) channels = [ node_channel_name(worker_handler.node.name), all_nodes_channel_name() ] worker = Dispatcher(redis_connection(), worker_handler,
import tornado.escape import tornado.gen import tornado.httpclient import tornado.httpserver import tornado.ioloop import tornado.options import tornado.web import urlparse from image import Image, ImageFormatError from signature import verify_signature from tornado.options import define, options, parse_config_file define("config", help="path to configuration file", type=str, callback=lambda path: parse_config_file(path, final=False)) define("debug", default=False, help="run in debug mode", type=bool) define("port", default=8888, help="run on the given port", type=int) define("client_name", help="client name", type=str) define("client_key", help="client key", type=str) define("allowed_hosts", default=[], help="list of allowed image hosts", type=str, multiple=True) logger = logging.getLogger("tornado.application") class PilboxApplication(tornado.web.Application): TESTDATADIR = os.path.join(os.path.dirname(__file__), "test", "data") def __init__(self, **kwargs):
#msg=empty #msg=duplicate print('query', q) #msg = q.split('=')[1] #msg = q[4:] msg = q[q.find('=') + 1:] if msg == 'empty': result = '请输入完整' if msg == 'duplicate': result = '用户名重复' return self.render_string('mymodule/regist_module.html', result=result) define('port', type=int, default=8888) parse_config_file('config/config') app = Application( [('/', IndexHandler), ('/login', LoginHandler), ('/blog', BlogHandler), ('/regist', RegistHandler)], template_path=join(dirname(__file__), 'mytemplate'), ui_modules={ 'loginmodule': LoginModule, 'blogmodule': BlogModule, 'registmodule': RegistModule }, static_path='mystatics') server = HTTPServer(app) server.listen(options.port) IOLoop().current().start()
def create_router(): from dispatcher.patientapi import PatientRouter app_router = PatientRouter() from dispatcher.nursepanel import NurseRouter app_router.append(NurseRouter()) from dispatcher.adminpanel import AdminRouter app_router.append(AdminRouter()) return app_router if __name__ == '__main__': """Serves as the main entry point to launch the webservice.""" if options.mode is 'test': parse_config_file(os.path.join('.', 'config', 'testconfig.py')) else: parse_config_file(os.path.join('.', 'config', 'devconfig.py')) parse_command_line() from tornado_sqlalchemy import make_session_factory factory = make_session_factory(options.db) # Assemble the tornado application with its submodules app_router = None try: app_router = create_router() except KeyError as e: print(e) exit(1)
# 用来定义变量的 class IndexHandler(web.RequestHandler): def data_received(self, chunk): pass def get(self, *args, **kwargs): self.write('<h1 align="center">你说的和你表达的不一样:app_8000</h1>') if __name__ == '__main__': # 转换命令行参数 # options.parse_command_line() options.parse_config_file('config.cfg') # options.options.logging = 'INFO' log_config = yaml.load(open('logging.yaml', 'r')) print(log_config) config.dictConfig(log_config) # print(options.options.list) app = web.Application([(r'/index', IndexHandler)]) # app.listen(port=8000, address='0.0.0.0') # 实例化一个httpServer http_server = httpserver.HTTPServer(app)
"SELECT host(ip) FROM %s where user_id=%i;" % (options.TABLE_NAME, uid)) for ips in cursor.fetchall(): self.rc.sadd(uid, ips[0]) if self.rc.scard(first_user_id) > self.rc.scard(second_user_id): self.rc.sadd('Related', sstring) result = True self.write("Users %i and %i are related: %s." % ( first_user_id, second_user_id, result )) self.finish() if __name__ == "__main__": try: parse_config_file('config.conf') except: logging.info('Config file ./config.conf not found') application = tornado.web.Application([ (r"/user_relations/", MainHandler), ]) ioloop = tornado.ioloop.IOLoop.instance() if options.USE_RC: redisConnectionPool = redis.ConnectionPool( host='localhost', port=6379, db=12 ) application.rc = redis.Redis(connection_pool=redisConnectionPool)
settings = dict( ui_modules={}, debug=True, ) super(Application, self).__init__(handlers, **settings) if __name__ == "__main__": # judger = subprocess.Popen( ['./tradiJudger', \ # '--tl=1', '--ml=256', '--ol=64',\ # '--in-pre=test', '--in-suf=in',\ # '--out-pre=test', '--out-suf=out',\ # '--Lang=C++',\ # '--data-dir=/home/ycdfwzy/myworkspace/tinyjudger/test/',\ # '--checker=ncmp', '--n-tests=2', '--source-name=test',\ # '--source-dir=/home/ycdfwzy/myworkspace/tinyjudger/test/' # ], stdout=subprocess.PIPE) # time.sleep(1) # judger.kill() tornado.options.parse_command_line() options.parse_config_file('configs.py') # print(options.domain) traditioanlJudgerThread = Thread(target=handleTraditionalJudger) scriptJudgerJudgerThread = Thread(target=handleScriptJudger) traditioanlJudgerThread.start() scriptJudgerJudgerThread.start() app = Application() app.listen(options.port) tornado.ioloop.IOLoop.current().start()
""" # DO NOT REMOVE import bitsd.properties from bitsd.persistence.engine import session_scope from bitsd.persistence import start from bitsd.server.auth import useradd, userdel, usermod from tornado.options import parse_config_file import sys from getpass import getpass if __name__ == '__main__': try: parse_config_file('/etc/bitsd.conf') except IOError: print("[INFO] No /etc/bitsd.conf found, ignoring.") action = sys.argv[1] username = sys.argv[2] start() with session_scope() as session: if action == 'add': password = getpass('Password for `{}`:'.format(username)) useradd(session, username, password) elif action == 'delete': userdel(session, username) elif action == 'modify':
define('notify_errors', True) define('error_email', [ '*****@*****.**', ], multiple=True) define('feedback_email', [ '*****@*****.**', ], multiple=True) # Email AWS SES define('from_email', '*****@*****.**') define('aws_access_key_id', '') define('aws_secret_access_key', '') define('aws_region', 'us-east-1') # load the local override config local_override = os.path.join(CONFIGS_DIR, '{}.config.py'.format(ENVIRONMENT)) if os.path.isfile(local_override): parse_config_file(local_override, final=False) # load the cli flags to override pre-defined config settings # remove app.py if it is the first arg. This is done because starting the sever # by running python app.py start_server --arg=value is not parsable by # tornado's parse_command_line function args = sys.argv[:] if args[0] == 'app.py': args = args[1:] parse_command_line(args=args)
define("db_name", type=str) define("db_user", type=str) define("db_password", type=str) define("db_host", type=str) define("db_port", type=str) define("template_path", type=str) define("debug", type=str) define("filestore", type=str) define("size_db_connection_pool", type=int) define("cache_host", type=str) define("cache_port", type=int) define("cache_db", type=int) parse_config_file("application.conf") tornado.options.parse_command_line() import urls if __name__ == '__main__': tornado.log.enable_pretty_logging() if options.debug == "yes": tornado.log.app_log.setLevel(logging.DEBUG) elif options.debug == "no": tornado.log.app_log.setLevel(logging.INFO) tornado.platform.asyncio.AsyncIOMainLoop().install() application = Application(
from magpie.config import config_path class EmailNotesError(Exception): pass define('imap_server', default=None, type=str) define('username', default=None, type=str) define('password', default=None, type=str) define('folder', default=None, type=str) define('repo', default=None, type=str) define('use_ssl', default=True, type=bool) define('default_notebook', default='', type=str) parse_config_file(config_path.email_notes) if options.use_ssl: imap = IMAP4_SSL(options.imap_server) else: imap = IMAP4(options.imap_server) imap.login(options.username, options.password) result, data = imap.select(options.folder) if result != 'OK': raise EmailNotesError(result) result, messages = imap.search(None, '(UNSEEN)') if result != 'OK': raise EmailNotesError(result) if messages[0] == '':
import json from random import randint from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado.options import define, parse_config_file, options from tornado.web import Application, RequestHandler define("PORT",type=int,default=8888) parse_config_file("../config/config") class IndexHandler(RequestHandler): def get(self, *args, **kwargs): res = '' msg = self.get_query_argument("msg", None) if msg: res = '用户名或密码错误' self.render('login.html',result=res) class LoginHandler(RequestHandler): def post(self, *args, **kwargs): username = self.get_body_argument("username") pwd = self.get_body_argument("pwd") if username=="ding" and pwd=="123": files = self.request.files if files: avatars = files.get("avatar") for avatar in avatars: filename = avatar.get("filename")
logging.debug('Message will be sent on url %s' % options.serverurl) httpClient = tornado.httpclient.AsyncHTTPClient() postRequest = tornado.httpclient.HTTPRequest( url=options.serverurl, method="POST", body=json.dumps(response), headers=tornado.httputil.HTTPHeaders({ "content-type": "application/json", "method": "POST" })) response = yield httpClient.fetch(postRequest) self.sendedMessage(response) if __name__ == '__main__': parse_config_file(os.path.abspath('') + '/options.conf') logging.basicConfig(level=logging.DEBUG) tornado.httpclient.AsyncHTTPClient.configure( "tornado.curl_httpclient.CurlAsyncHTTPClient") ioloop = tornado.ioloop.IOLoop.instance() api = requests.Session() application = app([ (r"/", mainHandler), ]) url = options.url % options.token + "setWebhook?url=%s" % options.myurl files = { 'certificate': open('/usr/share/nginx/qa_bot/qa_bot_company.pem', 'rb') } set_hook = api.post(url, files=files) if set_hook.status_code != 200:
define("cache_engine", default="apps.core.cache.memory.MemoryCache") define("cache_options", default=dict()) define("process_num", default=0) # 0即CPU个数 define("broker_transport", default="redis") define("broker_url", default="redis://127.0.0.1:6379/0") define("result_backend", default="redis://127.0.0.1:6379/0") define("celery_task_result_expires", type=int, default=1800) define("celery_max_cached_results", type=int, default=300) define("celery_timezone", default='Asia/Shanghai') define("celeryd_concurrency", type=int, default=6) define("accept_content", type=list, default=['pickle', 'json']) define("task_serializer", default='pickle') parse_config_file("conf/app.conf") class LogOption(dict): def __missing__(self, key): return dict.get(self, key) def __getattr__(self, key): return self.get(key) def __setattr__(self, key, value): if key in self: self[key] = value else: return super(LogOption, self).__setattr__(key)
def get(self): self.write('Hello Python') #GET获取参数 http://127.0.0.1:9999/python?day=111111111 day = self.get_query_argument('day', default='0000000', strip=False) print(self.request) self.write('Hello Python' + day) #/python?day=1&day=2&day=3&day=4&day=5 day = self.get_query_arguments('day', strip=False) print(day) #[1,2,3,4,5] #覆盖RequestHandler post方法,响应post请求 def post(self): day = self.get_body_argument('day', default='0000000', strip=False) self.write('Hello Python' + day) day = self.get_body_arguments('day', strip=False) print(day) define('port', type=int, default=8888) parse_config_file('config/config.txt') app = Application(handlers=[('/', IndexHandler), ( '/java', JavaHandler), ('/java/([0-9]*)/([a-z0-9]*)', JavaHandler), ('/python', PythonHandler)]) server = HTTPServer(app) server.listen(options.port) IOLoop.current().start()
def options(): ''' Fiorella monkey configuration options ''' tornado.options.define('ensure_indexes', default=True, type=bool, help=('Ensure collection indexes')) # Set config and stuff tornado.options.define('config', type=str, help='path to config file', callback=lambda path: parse_config_file(path, final=False)) # debugging tornado.options.define('debug', default=False, type=bool, help=('Turn on autoreload and log to stderr only')) # logging dir tornado.options.define('logdir', type=str, default='log', help=('Location of logging (if debug mode is off)')) tornado.options.define('domain', default='iofun.io', type=str, help='Application domain, e.g: "example.com"') # Server settings tornado.options.define('host', default='127.0.0.1', type=str, help=('Server hostname')) tornado.options.define('port', default=8888, type=int, help=('Server port')) # Overlord node settings tornado.options.define('overlord_host', default='127.0.0.1', type=str, help=('Overlord hostname or ip address')) tornado.options.define('overlord_port', default=8899, type=int, help=('Overlord port')) # MongoDB database settings tornado.options.define('mongo_host', type=str, help=('MongoDB hostname or ip address')) tornado.options.define('mongo_port', default=27017, type=int, help=('MongoDB port')) # PostgreSQL database settings tornado.options.define('sql_host', type=str, help=('PostgreSQL hostname or ip address')) tornado.options.define('sql_port', default=5432, type=int, help=('PostgreSQL port')) tornado.options.define('sql_database', type=str, help=('PostgreSQL database')) tornado.options.define('sql_user', type=str, help=('PostgreSQL username')) tornado.options.define('sql_password', type=str, help=('PostgreSQL username password')) tornado.options.define('memcached_host', default='127.0.0.1', type=str, help=('Memcached host')) tornado.options.define('memcached_port', default=11211, type=int, help=('Memcached port')) tornado.options.define('memcached_binary', default=True, type=bool, help=('Memcached binary')) tornado.options.define('memcached_tcp_nodelay', default=True, type=bool, help=('Memcached tcp_nodelay')) tornado.options.define('memcached_ketama', default=True, type=bool, help=('Memcached ketama')) tornado.options.define('cache_enabled', default=False, type=bool, help=('Enable cache')) # ZMQ external PUB logger tornado.options.define('external_log', default=False, type=bool, help=('External logger')) tornado.options.define('base_url', default='api', type=str, help=('Base url, e.g. "api"')) tornado.options.define('page_size', default=20, type=int, help=('Set a custom page size up to 100')) tornado.options.define('cookie_secret', default=secret, type=str, help=('Secure cookie secret string')) # this need to change to mailgun_key and mailgun_api tornado.options.define('api_key', default='key-348c3d4a39568cd19c1c7e41ff6944d4', type=str, help=('Secure key mailgun')) tornado.options.define('api_url', default="https://api.mailgun.net/v3/codemachine.io/messages", type=str, help=('Mail API URL')) tornado.options.define('max_retries', default=2, type=int, help=('Max retries')) tornado.options.define('retry_time', default=300, type=int, help=('Outbound calling retry time')) tornado.options.define('wait_time', default=45, type=int, help=('Wait time')) tornado.options.define('max_calls', default=10, type=int, help=('Maximum number of concurrent calls')) tornado.options.define('asterisk_user', default='asterisk', type=str, help=('non-root Asterisk user')) tornado.options.define('asterisk_group', default='asterisk', type=str, help=('non-root Asterisk group')) tornado.options.define('spool_dir', default='/var/spool/asterisk/outgoing/', type=str, help=('Asterisk spool dir')) tornado.options.define('tmp_dir', default='/tmp/', type=str, help=('tmp outbound call files')) tornado.options.define('server_delay', default=2.0) tornado.options.define('client_delay', default=1.0) tornado.options.define('num_chunks', default=40) # Parse config file, then command line... # so command line switches take precedence if os.path.exists(config_path): print('Loading', config_path) tornado.options.parse_config_file(config_path) else: print('No config file at', config_path) tornado.options.parse_command_line() result = tornado.options.options for required in ( 'domain', 'host', 'port', 'base_url', ): if not result[required]: raise Exception('%s required' % required) return result
def get_options(): #Application options.define("configfilename", default="tpaste.conf", type=str, help="Configuration filename") options.define('debug', default=True, type=bool, help="Turn on autoreload, log to stderr only") options.define("port", default=8888, type=int, help="Tornado server port") options.define('cookie_secret', default=base64.b64encode(os.urandom(32)), type=str, help="Secret seed for cookies") options.define('static_url_prefix', default=None, type=str, help="Useful for serve static files from separate server.") options.define("theme_path", default="theme", type=str, help="Theme path with static files and templates") options.define("googleanalytics_enabled", default=True, type=bool, help="Enable Google Analytics module") options.define("googleanalytics_trackercode", default="", type=str, help="Set Google Analytics tracker code") options.define('base_url', default="http://localhost", type=str, help="Base url host") options.define('slogan', default="Web application for saving and sharing " "text snippets. Using Tornado, MongoDB and Motor.", type=str, help="Slogan") #MongoDB options.define('db_uri', default='mongodb://*****:*****@puentesarr.in", type=str, help="SMTP username connection") options.define('smtp_password', default="fonoavisos", type=str, help="SMTP password connection") if os.path.exists(options.options.configfilename): options.parse_config_file(options.options.configfilename) else: raise Exception( 'No config file at %s.' % os.path.join(os.getcwd(), options.options.configfilename)) options.parse_command_line() return options.options
def load_options(args=None): parse_command_line(args=args) if options.config_file: parse_config_file(options.config_file)
pass class PythonHandler(RequestHandler): def get(self, p1=None, p2=None, *args, **kwargs): self.write('hello python <br>') if p1: self.write('date:' + p1 + '<br>') if p2: self.write('subject:' + p2 + '<br>') def post(self, *args, **kwargs): pass # 定义配置文件中的内容 define('port', type=int, default=8888) # 指定配置文件路径 parse_config_file('../config/conf') # 创建Application对象,Application是Tornado最核心的类 # 所有关于服务器的配置信息都要写在Application构造器中 # 以构造器的参数形式传入 # 比如:路由列表 # 路由列表的作用是告诉Tornado,对特定路径的请求,由哪个类进行响应 app = Application([('/', IndexHandler), ('/python', PythonHandler), ('/python/([0-9a-zA-Z]+)', PythonHandler), ('/python/([0-9a-zA-Z]+)/([a-zA-Z]+)', PythonHandler), ]) # 创建真正的服务器程序 server = HTTPServer(app) server.listen(options.port) # 从配置文件中读取port
def main(): parse_config_file(os.path.abspath('') + '/options.conf') print(options.serverurl)