本文整理汇总了Python中tornado.ioloop.start函数的典型用法代码示例。如果您正苦于以下问题:Python start函数的具体用法?Python start怎么用?Python start使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了start函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: main
def main():
try:
"""
defining/parsing the options
"""
define("port", default=8082, help="run on the given port", type=int)
define("debug", default=False, help="run in debug mode", type=bool)
tornado.options.parse_command_line()
logging.debug(options.logging)
"""
initalising applications
"""
app = MyApplication(options)
"""
starting tornado server
"""
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
ioloop = tornado.ioloop.IOLoop.instance()
tornado.autoreload.add_reload_hook(app.reloadTasks)
tornado.autoreload.start(ioloop)
ioloop.start()
except KeyboardInterrupt:
pass
except:
print traceback.format_exc()
示例2: run
def run():
tornado.httpclient.AsyncHTTPClient.configure("tornado.curl_httpclient.CurlAsyncHTTPClient")
xmpp = XMPPHandler('[email protected]', 'popcorn', 'http://localhost:8080/callback')
xmpp.register_plugin('xep_0030')
if xmpp.connect():
xmpp.process(block=False)
application = tornado.web.Application([
tornado.web.URLSpec(r"/send", SendHandler, {'xmpp': xmpp}),
tornado.web.URLSpec(r"/callback", CallbackProxyHandler, {'callback': "http://localhost:8080/testcallback"}),
tornado.web.URLSpec(r"/testcallback", TestCallbackHandler),
],
)
application.listen(8080)
ioloop = tornado.ioloop.IOLoop.instance()
try:
ioloop.start()
except KeyboardInterrupt:
print "I'm out"
xmpp.disconnect()
示例3: _actually_run
def _actually_run(self):
import logging
import tornado.options
logging.getLogger().setLevel(logging.INFO)
tornado.options.enable_pretty_logging()
import tornado.web
import tornado.httpserver
import tornado.ioloop
import tornado.autoreload
# import hashlib
# import random
# m = hashlib.md5()
# m.update((str(random.random()) + str(random.random())).encode('utf-8'))
# secret = m.digest()
# print("SECRET:", secret)
secret = random_key(100)
secret = "reiujgerjregiuj"
app = tornado.web.Application(self.handlers, static_path=self.static, cookie_secret=secret)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(self.port)
logging.info("waiting for requests on http://%s:%d" % (self.hostname or "localhost", self.port))
ioloop = tornado.ioloop.IOLoop.instance()
tornado.autoreload.start(ioloop)
ioloop.start()
示例4: main
def main(self):
#settings passed to tornado app
tornado_settings = {
"template_path": settings.template_path,
"static_path": settings.static_path,
"cookie_secret": settings.cookie_secret,
"login_url": settings.login_url,
}
#init a logger
self.init_logging(settings.log)
#routes
routes = self.init_routes()
self._application = web.Application(routes,**tornado_settings)
http_server = httpserver.HTTPServer(self._application)
http_server.listen(settings.port)
Log.info("Ready and listening")
ioloop = tornado.ioloop.IOLoop().instance()
autoreload.start(ioloop)
try:
ioloop.start()
except KeyboardInterrupt:
pass
示例5: main
def main():
pika_client = PikaClient()
database={}
database['g'] = 'f'
database['gg'] = 'ff'
database['ggg'] = 'gff'
global g_port;
application = tornado.web.Application(
[(r'/sensor/.*', SensorHandler,dict(database=database)),(r'/.*',MainHandler,dict(database=database))],
# [(r'/index.html',MainHandler)],
# [(r'/tom/*',SensorHandler),(r'/index.html',MainHandler)],
# **{'pika_client': pika_client, 'debug': True}
# **{'pika_client': pika_client, 'debug': True}
# [(r'/tom/*', Fib)],
**{'pika_client': pika_client, 'debug': True}
)
try:
port = int(sys.argv[1]) # $ python tornadoweb_pika.py 80
except:
port = 8000
g_port = port
application.listen(port)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.add_timeout(time.time() + .1, pika_client.connect)
ioloop.start()
示例6: run_service
def run_service(port, address='0.0.0.0', configuration=None):
ioloop = tornado.ioloop.IOLoop.instance()
app = create_service()
app.listen(port, address)
app.logger.info('Started THC service on %s:%s', address, port)
def discovered_service(index, fullname, host, port, txtRecord):
app.logger.info('Found service: %[email protected]%s:%s', fullname, host, port)
def lost_service(index, name, regtype, domain):
app.logger.info('Lost service: %s.%[email protected]%s', name, regtype, domain)
app.mdns = mdns_util.MDNS(ioloop)
app.mdns.register('TurretHostController', '_thc_http._tcp', 'local', port)
app.logger.info('Registered THC service.')
app.mdns.discover('_thc_http._tcp', discovered_service, lost_service)
app.logger.info('Listening for neighboring services.')
try:
ioloop.start()
except KeyboardInterrupt:
app.logger.info('Cancelling service discovery.')
app.mdns.disable_discovery('_thc_http._tcp')
app.logger.info('Cancelling service broadcast.')
app.mdns.unregister('TurretHostController', '_thc_http._tcp', 'local',
port)
app.logger.info('Shutting down.')
示例7: main
def main():
parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application())
http_server.listen(options.port)
ioloop = tornado.ioloop.IOLoop().instance()
autoreload.start(ioloop)
ioloop.start()
示例8: main
def main():
options.parse_command_line()
# set up database connection
client = pymongo.MongoClient(options.dbhost, options.dbport)
database = client[options.dbname]
# list of handlers
handlers = []
# generate list
for handler in settings.handlers:
# import the handler we need
handler_class = __import__(handler)
# register the URLS with the handler
for routes in handler_class.routes:
# each handler exports a urls list and class
endpoint, class_name = routes
url = ('/api' + endpoint, class_name, dict(database=database))
# append to our handlers list
handlers.append(url)
ioloop = tornado.ioloop.IOLoop.instance()
# register our handlers with our application and give it our settings
application = tornado.web.Application(handlers, **settings.settings)
http_server = tornado.httpserver.HTTPServer(application)
# listen on port defined in options
http_server.listen(options.port)
#start ioloop
ioloop.start()
示例9: run
def run():
logging.basicConfig(level=logging.DEBUG)
tornado.options.parse_command_line()
http_server = tornado.httpserver.HTTPServer(Application())
http_server.listen(options.port)
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.start()
示例10: __call__
def __call__(self,*args,**options):
from thepian.conf import structure
from os.path import join
sys.path.append(structure.PROJECT_DIR)
from thepian.conf import ensure_target_tree
ensure_target_tree(structure.PROJECT_DIR)
#TODO part add_themaestro functionality
import logging
LOG_FILENAME = join(structure.PROJECT_DIR,'testing.log')
logging.basicConfig(filename=LOG_FILENAME,level=logging.DEBUG)
from mediaserver import Application, HTTPServer
import tornado.httpserver
import tornado.ioloop
import tornado.autoreload
# print "js dir =", structure.JS_DIR
# tornado.options.parse_command_line()
ioloop = tornado.ioloop.IOLoop.instance()
sock_path = join(structure.PROJECT_DIR,"mediasite.sock")
port_no = structure.MEDIASERVER_PORT
if port_no:
http_server = tornado.httpserver.HTTPServer(Application(ioloop=ioloop))
http_server.listen(port_no)
else:
http_server = HTTPServer(Application(ioloop=ioloop))
http_server.listen(0,address = sock_path)
tornado.autoreload.start(io_loop=ioloop)
ioloop.start()
示例11: run_proxy
def run_proxy(bind, debug=False):
# /proxy/[?](?P<url>.*) # r'/proxy/[?](.*)' # r'/proxy/(.*)'
handler = [(r'/proxy/', ProxyHandler, {})]
app = tornado.web.Application(handler, debug=debug)
app.listen(bind[1], bind[0])
ioloop = tornado.ioloop.IOLoop.instance()
ioloop.start()
示例12: main
def main():
app = LetSpotify()
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
ioloop = tornado.ioloop.IOLoop.instance()
app.db = momoko.Pool(
dsn=settings['dsn'],
size=5,
raise_connect_errors=False,
reconnect_interval=50,
ioloop=ioloop,
)
future = app.db.connect()
ioloop.add_future(future, lambda f: ioloop.stop())
ioloop.start()
future.result() # raises exception on connection error
Service.users = Users(app.db)
Service.facebook = FacebookAPI(app.db)
Service.rooms = Rooms(app.db)
Service.login_token = LoginToken(app.db)
ioloop.start()
示例13: __init__
def __init__(self):
self.handlers = routs
ioloop = tornado.ioloop.IOLoop.instance()
self.settings = dict(
debug=config.debug,
template_path=config.template_path,
static_path=config.static_path,
cookie_secret=config.cookie_secret,
login_url=config.login_url
)
super(Application, self).__init__(self.handlers, **self.settings)
self.db_async = momoko.Pool(
dsn=config.get_db_url(options.db_name,
options.db_user_name,
options.db_host,
options.db_port,
options.db_password),
size=1,
ioloop=ioloop,
cursor_factory=DictCursor
)
future = self.db_async.connect()
ioloop.add_future(future, lambda x: ioloop.stop())
ioloop.start()
future.result()
示例14: main
def main():
try:
# create an api for the webserver
api = HotTubAPI();
app = tornado.web.Application(
handlers=[
(r"/images/(.*)", tornado.web.StaticFileHandler, {"path":"./images"}),
(r"/css/(.*)", tornado.web.StaticFileHandler, {"path":"./css"}),
(r"/js/(.*)", tornado.web.StaticFileHandler, {"path":"./js"}),
(r"/*", IndexHandler),
(r"/twilio.api", TwilioHandler, dict(api=api)),
(r"/ws", WebSocketHandler, dict(api=api))
]
)
server = tornado.httpserver.HTTPServer(app)
port = 9999
server.listen(port,address="0.0.0.0")
print "Tornado listening on port: %s" % port
ioloop = tornado.ioloop.IOLoop.instance()
set_ping(ioloop, timedelta(seconds=2))
ioloop.start()
except KeyboardInterrupt:
print '^C received, shutting down server'
api.close()
server.stop();
示例15: start_server
def start_server(args):
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'
app.jinja_env.globals['static'] = static
blueprint.url_prefix = args.url_prefix
app.register_blueprint(blueprint)
# app.run(port=args.port, debug=args.debug)
wsgi_app = tornado.wsgi.WSGIContainer(app)
condajs_ws = sockjs.tornado.SockJSRouter(views.CondaJsWebSocketRouter, '/condajs_ws')
routes = condajs_ws.urls
routes.append((r".*", tornado.web.FallbackHandler, dict(fallback=wsgi_app)))
application = tornado.web.Application(routes, debug=args.debug)
try:
application.listen(args.port)
except OSError as e:
print("There was an error starting the server:")
print(e)
return
ioloop = tornado.ioloop.IOLoop.instance()
if not args.debug:
callback = lambda: webbrowser.open_new_tab('http://localhost:%s' % args.port)
ioloop.add_callback(callback)
ioloop.start()