def main():
tcelery.setup_nonblocking_producer()
tornado.options.define("port", default=DEFAULT_PORT, help="run on the given port", type=int)
tornado.options.parse_command_line()
app = application.Application()
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(tornado.options.options.port)
tornado.ioloop.IOLoop.instance().start()
def server_start():
app = tornado.web.Application(urls, debug=options.debug)
enable_pretty_logging()
parse_command_line()
server = tornado.httpserver.HTTPServer(app)
server.bind(options.port)
server.start(2)
tcelery.setup_nonblocking_producer(limit=2)
tonado.ioloop.IOLoop.current().start()
def main():
app = make_app()
if DEBUG:
app.listen(8080)
else:
server = HTTPServer(app)
server.bind(8080)
server.start(0) # forks one process per cpu
ioloop.IOLoop.instance().start()
import tcelery
tcelery.setup_nonblocking_producer(celery_app=tasks.celery)
def main():
import tcelery
from tornado.options import define, options, parse_command_line
tcelery.setup_nonblocking_producer()
define("port", default=8000, help="run on the given port", type=int)
options.parse_command_line()
app = tornado.web.Application(handlers=[
('/do_job/(?P<worker>.*)/.*', WorkerHanler),
('/justnow', JustNowHandler),
],
debug=True)
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(options.port)
tornado.ioloop.IOLoop.instance().start()
def bench_apply_async_nonblocking(ntimes, stop_io_loop=False):
io_loop = ioloop.IOLoop.instance()
def publish():
time_start = time.time()
for i in range(ntimes):
echo.apply_async(args=[i])
print("non blocking apply_async called {} times in {} seconds".format(
ntimes, time.time() - time_start))
if stop_io_loop:
io_loop.stop()
import tcelery
tcelery.setup_nonblocking_producer(celery_app=celery2,
io_loop=io_loop,
on_ready=publish)
io_loop.start()
def run(sess):
cfg = make_config_dict(sess.reg.settings, 'netprofile.rt.')
sslopts = None
if cfg.get('ssl'):
sslopts = {}
if 'certfile' in cfg:
sslopts['certfile'] = cfg['certfile']
if 'keyfile' in cfg:
sslopts['keyfile'] = cfg['keyfile']
app = sess.app()
http_server = tornado.httpserver.HTTPServer(app, ssl_options=sslopts)
http_server.bind(int(cfg.get('port', 8808)))
http_server.start(int(cfg.get('processes', 0)))
sess.add_sockjs_routes(app)
iol = tornado.ioloop.IOLoop.current()
setup_celery(sess.reg)
tcelery.setup_nonblocking_producer(celery_app, io_loop=iol)
iol.start()
return 0
def run(sess):
cfg = make_config_dict(sess.reg.settings, 'netprofile.rt.')
sslopts = None
if cfg.get('ssl'):
sslopts = {}
if 'certfile' in cfg:
sslopts['certfile'] = cfg['certfile']
if 'keyfile' in cfg:
sslopts['keyfile'] = cfg['keyfile']
app = sess.app()
http_server = tornado.httpserver.HTTPServer(app, ssl_options=sslopts)
http_server.bind(int(cfg.get('port', 8808)))
http_server.start(int(cfg.get('processes', 0)))
sess.add_sockjs_routes(app)
iol = tornado.ioloop.IOLoop.current()
setup_celery(sess.reg)
tcelery.setup_nonblocking_producer(celery_app, io_loop=iol)
iol.start()
return 0
def main():
tornado.options.parse_command_line()
routes = get_routes(picture)
print("Routes\n======\n\n" + json.dumps(
[(url, repr(rh)) for url, rh in routes],
indent=2)
)
application = Application(routes=routes, settings={"debug": True, })
application.objects = peewee_async.Manager(database)
application.listen(8080)
tcelery.setup_nonblocking_producer(on_ready=call_task)
io_loop = tornado.ioloop.IOLoop.instance()
# connect("nero_gate", host="192.168.1.5", port=27017, connect=False, io_loop=io_loop) 4
# connect("nero_gate", host="192.168.1.5", port=27017, connect=False, io_loop=io_loop) 3
connect("nero_gate", host="192.168.1.5", port=27017)
io_loop.start()
import json
import logging
import traceback
from tornado import web, ioloop, gen
from logging.handlers import TimedRotatingFileHandler
import os
"""Tornado Web Application"""
parser = argparse.ArgumentParser(description='nmt web application')
parser.add_argument('--host', type=str, default=None,
help='host')
parser.add_argument('--port', type=int, default=None,
help='port')
args = parser.parse_args()
tcelery.setup_nonblocking_producer()
class MyAppException(web.HTTPError):
pass
class MyAppBaseHandler(web.RequestHandler):
def write_error(self, status_code, **kwargs):
self.set_header('Content-Type', 'application/json')
if self.settings.get("serve_traceback") and "exc_info" in kwargs:
# in debug mode, try to send a traceback
lines = []
import tornado.web from tornado import gen import tcelery import redis from whatsup.cookies import Cookies from whatsup.task_queue import DecodeGenerateFrontpage PATH_TO_SITE = "../" HOMEPAGE = "home.html" HOME_NUM_EVENTS_TO_DISPLAY = 10 tcelery.setup_nonblocking_producer() class BaseHandler(tornado.web.RequestHandler): def get_current_user(self): return self.get_secure_cookie(Cookies.LoginUsername) class HomeHandler(BaseHandler): """ Handler for the homepage. Extends a Tornado RequestHandler. """ _featured_list = [] _all_list = [] _redis = redis.StrictRedis(host='localhost', port=6379, db=0) @property def redis(self): return self._redis
def setUp(self):
tcelery.setup_nonblocking_producer()
logging.info(settings_path)
app = make_application(
scloud,
# debug=CONF("DEBUG_PAGE"),
debug=False,
wsgi=False,
settings_path=settings_path,
url_root=CONF("URL_ROOT"),
**tornado_settings)
from scloud.async_services.listener import init_listener
from scloud.views.admin.ws.pubsub import redis_listener
init_listener()
if options.cmd == "runserver":
import tcelery
from scloud import celeryapp
tcelery.setup_nonblocking_producer(celery_app=celeryapp.celery)
# threading.Thread(target=redis_listener).start()
# run_torweb.run(app, port=CONF("PORT"))
run_torweb.run(app, port=CONF("PORT"))
elif options.cmd == "syncdb":
logging.info("** start sycndb ... **")
# from scloud.models.user import User
# BaseModel.metadata.create_all(db_engine)
logging.info("** end sycndb ... **")
else:
run_torweb.show_urls(scloud)
logging.info(settings_path)
app = make_application(
scloud,
# debug=CONF("DEBUG_PAGE"),
debug=False,
wsgi=False,
settings_path=settings_path,
url_root=CONF("URL_ROOT"),
**tornado_settings
)
from scloud.async_services.listener import init_listener
from scloud.views.admin.ws.pubsub import redis_listener
init_listener()
if options.cmd == "runserver":
import tcelery
from scloud import celeryapp
tcelery.setup_nonblocking_producer(celery_app=celeryapp.celery)
threading.Thread(target=redis_listener).start()
# run_torweb.run(app, port=CONF("PORT"))
run_torweb.run(app, port=CONF("WEBSOCKET_PORT"))
elif options.cmd == "syncdb":
logging.info("** start sycndb ... **")
# from scloud.models.user import User
# BaseModel.metadata.create_all(db_engine)
logging.info("** end sycndb ... **")
else:
run_torweb.show_urls(scloud)
import tasks
import tcelery
from tornado import ioloop
def handle_result(result):
print(result.result)
ioloop.IOLoop.instance().stop()
def call_task():
tasks.add.apply_async(args=[1, 2], callback=handle_result)
tcelery.setup_nonblocking_producer(on_ready=call_task)
ioloop.IOLoop.instance().start()
def setUp(self):
tcelery.setup_nonblocking_producer()
