Python Application.db方法代码示例

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
def main():

    from tank_maven.utils import setup_db

    app_settings = {
        'cookie_secret': settings.SECRET_KEY,
        'login_url': '/login/',
        'logout_url': '/logout/',
        'debug': settings.DEBUG,
        'template_path': settings.TEMPLATES_PATH,
        'static_path': settings.STATIC_PATH,
        'ui_modules': uimodules,
    }

    application = Application([
        url(r'/', handlers.HomeHandler, name='home'),
        url(r'^/login/$', handlers.LoginHandler, name='login'),
        url(r'^/logout/$', handlers.LogoutHandler, name='logout'),
        url(r'^/sign-up/$', handlers.SignupHandler, name='sign-up'),
        url(r'^/profile/edit/$', handlers.ProfileEditHandler, name='profile-edit'),
        url(r'^/settings/(.*)/$', handlers.SettingHandler,
            name='setting'),
        url(r'^/settings/$', handlers.SettingsHandler, name='settings-index'),
    ], **app_settings)
    application.db = setup_db()
    return application

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
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)

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
if __name__ == "__main__":
    parse_command_line()
    ioloop = IOLoop.instance()
    application = Application([
        (r"/", QuestionnaireListHandler),
        (r"/cat/(\d+)", QuestionHandler),
        (r"/result/(\d+)", ResultHandler)
    ],
        template_path=os.path.join(os.path.dirname(__file__), "templates"),
        static_path=os.path.join(os.path.dirname(__file__), "static"),
        cookie_secret=COOKIE_SECRET,
        debug=True,
        xsrf_cookies=True,
    )
    application.db = momoko.Pool(
        dsn=DSN,
        size=1,
        ioloop=ioloop,
        cursor_factory=NamedTupleCursor,
    )

    future = application.db.connect()
    ioloop.add_future(future, lambda f: ioloop.stop())
    ioloop.start()
    future.result()

    http_server = HTTPServer(application)
    http_server.listen(8000, 'localhost')
    ioloop.start()

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
from tornado.web import Application
from tornado.log import enable_pretty_logging
from tornado.ioloop import IOLoop

from api.utils.db import get_db_session
from api.utils.settings import get_normalized_settings
from api.v1_0.handlers.urls import APIUrls


if __name__ == "__main__":

    settings = get_normalized_settings()
    # APIUrls is in v1_0/handlers/urls.py -- path table
    application = Application(handlers=APIUrls, **settings)
    # attaching database here -- used to initialize request handlers
    # see base.py db property
    application.db = get_db_session(settings)

    if settings['debug']:
        enable_pretty_logging()
        # simple single process pattern
        application.listen(settings['bind_port'], settings['bind_addr'], )
    else:
        server = HTTPServer(application)
        # simple multi-process pattern
        server.bind(settings['bind_port'], settings['bind_addr'] )
        server.start(settings['tornado_start'])

    print 'starting server...'
    IOLoop.instance().start()

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
def main():
    application = Application(urls, **settings)
    application.db = Pool.instance(settings["dsn"])
    http_server = HTTPServer(application)
    http_server.listen(settings["port"], settings["host"])
    IOLoop.instance().start()

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
import routes
from common import settings 
from tornado.web import Application
from tornado.gen import IOLoop
from tornado.log import gen_log
from tornado.options import define,options ,parse_command_line

from motor.motor_tornado import MotorClient

define('port',default=11108,type=int,help='listen port')
define('debug',default=True,type=bool,help='running at debug mode?')

import logging
logging.basicConfig(level=logging.DEBUG)


if __name__ == '__main__':
	parse_command_line()

	client = MotorClient(host='192.168.2.14',port=27017)
	db=client['smscenter']

	handlers=[]
	handlers.extend(routes.routes)
	app = Application(handlers=handlers,**settings)
	app.db=db
	
	gen_log.info('server listening at '+str(options.port))
	app.listen(options.port)
	IOLoop.current().start()

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
        start, end = silence_gap(now)
        if start <= now <= end:
            return

    for stamp in stamps:
        if stamp.key in cfg.events:
            error, _ = thresholds(stamp, now, start, end)
            elapsed = now - stamp.timestamp
            if elapsed >= timedelta(seconds=error) and elapsed <= alert_duration:
                alert(stamp, **cfg.alert_options)


if os.path.exists(CONFIG):
    parse_config_file(CONFIG)
parse_command_line()

format = load_backend(cfg.format)
alert = load_backend(cfg.alert)
alert_duration = timedelta(seconds=cfg.alert_duration) if cfg.alert_duration else timedelta.max

app = Application([
    (r"/", MainHandler),
    (r"/([\w-]+)/?", EventHandler),
], debug=cfg.debug)

app.db = AsyncClient(cfg.database)

app.listen(cfg.port)
PeriodicCallback(monitor, cfg.monitor).start()
IOLoop.instance().start()

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]

def signal_term_handler(sig, _):
    logging.error("Got %s. Quit.", sig)
    exit(0)


if __name__ == '__main__':
    signal(SIGTERM, signal_term_handler)
    app = Application([
        (r"/websocket", Handler),
        (r"/()", StaticFileHandler, {'path': 'static/index.html'}),
        (r"/userpics/(.+)", StaticFileHandler, {'path': 'userpics/'}),
        (r"/static/(.+)", StaticFileHandler, {'path': 'static/'}),
    ])
    try:
        ioloop = IOLoop.instance()
        app.db = Pool(dsn="dbname=mol user=mol password=molpassword "
                          "host=localhost port=5432",
                      size=5, max_size=100, auto_shrink=True,
                      ioloop=ioloop)
        future = app.db.connect()
        ioloop.add_future(future, lambda _: ioloop.stop())
        app.wsPool = {}
        ioloop.start()
        future.result()
        app.listen(1984, address="127.0.0.1")
        ioloop.start()
    except KeyboardInterrupt:
        signal_term_handler(SIGTERM, None)

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
 def get_app(self):
         app = Application(urls.handlers, **config.settings)
         app.db = tornado.database.Connection(
             host=options.mysql_host, database=options.mysql_database,
             user=options.mysql_user, password=options.mysql_password)
         return app

# 需要导入模块: from tornado.web import Application [as 别名]
# 或者: from tornado.web.Application import db [as 别名]
                    result = len(user_1_ips & user_2_ips) > 0

        self.write(str(result or False))
        self.finish()


if __name__ == '__main__':
    application = Application([
        (r'/', MainHandler),
    ])
    conn_params = {
        'db_name': 'tornado',
        'username': 'tornado',
        'password': 'tornado',
        'host': 'localhost',
        'port': 5432,
    }
    ioloop = IOLoop.instance()
    application.db = Pool(dsn="dbname={db_name} "
                              "user={username} "
                              "password={password} "
                              "host={host} "
                              "port={port}".format(**conn_params),
                          size=1, ioloop=ioloop)
    future = application.db.connect()
    ioloop.add_future(future, lambda f: ioloop.stop())
    ioloop.start()

    application.listen(8888)
    ioloop.start()