} class ThreadMixin(object): executor = ThreadPoolExecutor(max_workers=4) class FallbackHandler(ThreadMixin, web.FallbackHandler): @run_on_executor def prepare(self): self.fallback(self.request) self._finished = True application = web.Application([ url(r'/media/(.*)', web.StaticFileHandler, {'path': settings.MEDIA_ROOT}), url(r'.*', FallbackHandler, {'fallback': wsgi.WSGIContainer(django_app)}) ], **APP_SETTINGS) def main(): if APP_SETTINGS['debug']: sys.stdout.write('Host: {}\n'.format(options.host)) sys.stdout.write('Port: {}\n\n'.format(options.port)) application.listen(options.port, options.host) try: IOLoop.instance().start() except KeyboardInterrupt: IOLoop.instance().stop() if __name__ == '__main__':
class PeopleIdHandler(web.RequestHandler): def initialize(self, name): self.name = name def get(self, id, *args, **kwargs): # self.write("用户id:{}".format(id)) self.redirect(self.reverse_url("people_name", "bobby")) class PeopleNameHandler(web.RequestHandler): def get(self, name, *args, **kwargs): self.write("用户姓名:{}".format(name)) class PeopleInfoHanler(web.RequestHandler): def get(self, name, age, gender, *args, **kwargs): self.write("用户姓名:{}, 用户年龄:{}, 用户性别:{}".format(name, age, gender)) urls = [ web.URLSpec(r'/', MainHandler, name="index"), web.URLSpec(r'/people/(?P<id>\d+)/?', PeopleIdHandler, {"name": "wanlaji"}, name="people_id"), web.URLSpec(r'/people/(?P<name>\w+)/?', PeopleNameHandler, name="people_name"), web.URLSpec(r'/people/(\w+)/(\d+)/(\w+)/?', PeopleInfoHanler, name="people_info"), ] if __name__ == "__main__": app = web.Application(urls, debug=True) app.listen(8888) ioloop.IOLoop.current().start()
def create_preload_application(): app = web.Application([(r"/preload", MyHandler)]) server = app.listen(12345, address="127.0.0.1") tornado.ioloop.IOLoop.instance().start()
self.router = router def post(self): obj = json.loads(self.request.body) for client in clients: if client.is_closed: clients.remove(client) else: client.send(self.request.body) print "[{}] {}".format(OnBarsHandler.i, self.request.body) OnBarsHandler.i = OnBarsHandler.i+1 def put(self): # TODO(max): sanity checks, security checks for client in clients: if client.is_closed: clients.remove(client) else: client.send(self.request.body) if __name__ == '__main__': ClientRouter = SockJSRouter(ClientConnection, '/echo') app = web.Application( [(r"/", IndexHandler)] + [(r"/onbars", OnBarsHandler, dict(router=ClientRouter))] + ClientRouter.urls) app.listen(9999) ioloop.IOLoop.instance().start()
f"INSERT INTO msg(name, email, address, msg) " f"VALUES('{name}', '{email}', '{address}', '{msg}')" ) else: await cur.execute( f"UPDATE msg SET " f"name='{name}', email='{email}', address='{address}', msg='{msg}' WHERE id='{sid}'" ) await conn.commit() settings = { "static_path": "/home/zpf/workarea/realForum/MsgBoard/static", "static_prefix": "/static/", "template_path": "templates", "db": { 'host': '127.0.0.1', 'user': '******', 'password': '******', 'po rt': 3306, 'db': 'rfm' } } if __name__ == "__main__": app = web.Application([ web.URLSpec("/", IndexHandler, {"db": settings["db"]}, name="index"), ], debug=True, **settings) app.listen(8080) ioloop.IOLoop.current().start()
def run(self): application = web.Application(self.__handlers, **self.__settings) logger.info("Server started at {}:{}", self.address, self.port) application.listen(self.port, address=self.address) io_loop = ioloop.IOLoop.instance() io_loop.start()
cid = self.get_argument('id') if cid: method_name = self.request.uri.split('/')[2] + '_service' method = getattr(self._nc, method_name) yield gen.Task(method, cid) self.redirect('/') class TLocatorServer(TTornado.TTornadoServer): def __init__(self): handler = ServiceLocator() processor = TServiceLocator.Processor(handler) pfactory = TBinaryProtocol.TBinaryProtocolFactory() super(TLocatorServer, self).__init__(processor, pfactory) application = web.Application(handlers=[ (r"/", MainHandler), (r"/service/.*", ServiceHandler), ], template_path=os.path.join(APP_ROOT, 'views')) if __name__ == "__main__": application.listen(HTTP_PORT) tserver = TLocatorServer() tserver.bind(THRIFT_PORT) tserver.start(1) ioloop.IOLoop.instance().start()
try: port = int(args[1]) except IndexError: port = 8000 conn = sqlite3.connect(dbpath) conn.enable_load_extension(True) conn.load_extension("mod_spatialite.so") application = web.Application([ (r'/view/(?P<tag>.*)', MapViewHandler), (r'/summits/(?P<prefix>[0-9a-f]*)', SummitsHandler, { 'mode': 'up' }), (r'/sinks/(?P<prefix>[0-9a-f]*)', SummitsHandler, { 'mode': 'down' }), (r'/(.*)', web.StaticFileHandler, { 'path': 'static' }), ], template_path='templates', debug=True) application.listen(port) try: IOLoop.instance().start() except KeyboardInterrupt: pass except Exception, e: print e raise
logger.info(self.request.body.decode("utf-8")) res = yield gen.Task(bert_align_tasks_enzh.alignment.apply_async, args=[self.request.body]) ret = res.result self.write(ret) logger.info(ret) self.finish() if __name__ == '__main__': log_format = "%(asctime)s-%(levelname)s-%(message)s" os.makedirs("align_bert_enzh_logs", exist_ok=True) handler = TimedRotatingFileHandler( 'align_bert_enzh_logs/alignment_enzh_bert.log', backupCount=30, when='midnight', interval=1, encoding="utf-8") formatter = logging.Formatter(log_format) handler.setFormatter(formatter) handler.suffix = "%Y%m%d" logger = logging.getLogger("alignment_enzh_bert") logger.setLevel(logging.INFO) logger.addHandler(handler) application = web.Application([(r"/align_bert", AsyncAppBertHandler)]) application.listen(port=args.port, address=args.host) ioloop.IOLoop.instance().start()
""" import os import sys import tornado from tornado.options import options import pymongo sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)))) from tornado import ioloop, web # Handling the configuration import config from handler_list import handler_list app = web.Application(handler_list, static_path=options.static_path, autoreload=True, cookie_secret=options.cookie_secret) if __name__ == '__main__': print('$appname$ is running on http://localhost:{}/'.format( options.app_port)) app.listen(options.app_port, xheaders=True) ioloop = ioloop.IOLoop.instance() tornado.autoreload.start() tornado.autoreload.watch('web/tester.html') ioloop.start()
class PeopleUserCenter(web.RequestHandler): def initialize(self, name): # **kwargs 中的参数会映射进来 self.db_name = name async def get(self, age, name, *args, **kwargs): print(self.db_name) self.write("Usercenter of {}:Age:{}".format(name, age)) people_db = {"name": "people"} urls = [ (r'/', MainHandler), (r'/people/(\d+)/?', PeopleIdHandler), # 不指定对应参数,后面的问号可以在链接没有'/'的时候补全 (r'/people/(\w+)/(\d+)/(\w+)/?', PeopleInfoHandler), # 直接通过 web 中的 URLSpec 实例化,好处是可以传入 name,在 redirect 的时候比较方便 tornado.web.URLSpec(r'/people/(?P<name>\w+)/center/(?P<age>\d+)/?', PeopleUserCenter, people_db, name="usercenter"), ] settings = {"template_path": "templates", "debug": True} if __name__ == "__main__": app = web.Application(urls, **settings) app.listen(8888) tornado.ioloop.IOLoop.current().start()
if found_one_term == False: self.write('exception: term not found in document') print ('could not find term ' + str(doc_id) + ' ' + str(term)) self.write(MyText) print (MyText) print (len(result)) RS = [MyDict] self.write(json.JSONEncoder().encode({"results": RS})) ### print as a dictionary else: ### Raise exception self.write('exception: document not found') ### print as a dictionary print ('could not find ' + str(doc_id)) ### ## ##print 'well, \033[1m' + 'Hello \033[0m there' #### #The output should be JSON-encoded if __name__ == "__main__": task_id = process.fork_processes(inventory.num_doc) D_BASE_PORT = inventory.port2 port = D_BASE_PORT + task_id app = httpserver.HTTPServer(web.Application([web.url(r"/doc", DocHandler, dict(port=port))])) app.add_sockets(netutil.bind_sockets(port)) print ('docServer' + str(task_id) + ' at port: ' + str(port)) tornado.ioloop.IOLoop.current().start()
from apps.hotels.urls import url_patterns as hotels_urls from apps.reports.urls import url_patterns as reports_urls from apps.admin.urls import url_patterns as admin_urls from settings import settings import ui_methods define("port", default=8000, help="run on the given port", type=int) define("debug", default=True, help="debug mode", type=bool) if __name__ == "__main__": print("Run server") parse_command_line() # add url patterns handlers = [] handlers.extend(main_urls) handlers.extend(user_urls) handlers.extend(hotels_urls) handlers.extend(reports_urls) handlers.extend(admin_urls) # create tornado web app app = web.Application(handlers=handlers, ui_methods=ui_methods, autoreload=True, debug=options.debug, **settings) http_server = httpserver.HTTPServer(app) http_server.listen(options.port) ioloop.IOLoop.instance().start()
class ImagesUploadRequestHandler(web.RequestHandler): """ test for multiple file upload """ def post(self): global received_files received_files = self.request.files['images'] """ global variables """ pet_db = create_pet_db() app = web.Application( [(r'/api/pet', PetRequestHandler, dict(db=pet_db)), (r'/api/pet/(\d+)', PetIdRequestHandler, dict(db=pet_db)), (r'/api/pet/uploadImage', ImageRequestHandler), (r'/upload', ImagesUploadRequestHandler)], debug=True) class TornadoTestCase(testing.AsyncHTTPTestCase): """ """ def setUp(self): global received_file global received_meta # reset global received_file = received_meta = None super(TornadoTestCase, self).setUp()
def init_tornado_application(self): """Instantiate the tornado Application object""" self.tornado_application = web.Application(self.handlers, **self.tornado_settings)
from tornado.ioloop import IOLoop from tornado import gen, web class ExampleHandler(web.RequestHandler): @gen.coroutine def get(self): delay = self.get_argument('delay', 5) yield gen.sleep(int(delay)) self.write({"status": 1, "msg": "success"}) self.finish() # @gen.coroutine() # def post(self): # pass application = web.Application( [ (r"/example", ExampleHandler), #(r"/other", OtherHandler), ], autoreload=True) application.listen(8765) IOLoop.current().start()
if not storage.websockets: storage.websockets = set() storage.websockets.add(self) def on_message(self, message): pass def on_close(self): log("WebSocket closed") storage.websockets.remove(self) lamp_client = web.Application([ (r'/ws', SocketHandler), (r'/(.*)', web.StaticFileHandler, { 'path': os.path.join(os.path.dirname(__file__), "static"), 'default_filename': 'index.html' }), ]) @gen.coroutine def tcp_client_coroutine(): """Setup the connection to the echo server and wait for user input. """ stream = None try: stream = yield tcp_client.connect( os.environ.get('LAMP_ADDRESS') or '127.0.0.1', int(os.environ.get('LAMP_PORT') or 9999))
def start(): app = web.Application([("/", MainHandler)]) app.listen(8080) ioloop.IOLoop.current().start()
def main(): # command-line options define("debug", default=False, help="run in debug mode", type=bool) define("no_cache", default=False, help="Do not cache results", type=bool) define("localfiles", default="", help="Allow to serve local files under /localfile/* this can be a security risk", type=str) define("port", default=5000, help="run on the given port", type=int) define("cache_expiry_min", default=10*60, help="minimum cache expiry (seconds)", type=int) define("cache_expiry_max", default=2*60*60, help="maximum cache expiry (seconds)", type=int) define("mc_threads", default=1, help="number of threads to use for Async Memcache", type=int) define("threads", default=1, help="number of threads to use for rendering", type=int) define("processes", default=0, help="use processes instead of threads for rendering", type=int) define("frontpage", default=FRONTPAGE_JSON, help="path to json file containing frontpage content", type=str) define("sslcert", help="path to ssl .crt file", type=str) define("sslkey", help="path to ssl .key file", type=str) tornado.options.parse_command_line() # NBConvert config config = Config() config.HTMLExporter.template_file = 'basic' config.NbconvertApp.fileext = 'html' config.CSSHTMLHeaderTransformer.enabled = False # don't strip the files prefix - we use it for redirects # config.Exporter.filters = {'strip_files_prefix': lambda s: s} # DEBUG env implies both autoreload and log-level if os.environ.get("DEBUG"): options.debug = True logging.getLogger().setLevel(logging.DEBUG) # setup memcache mc_pool = ThreadPoolExecutor(options.mc_threads) if options.processes: # can't pickle exporter instances, exporter = HTMLExporter pool = ProcessPoolExecutor(options.processes) else: exporter = HTMLExporter(config=config, log=log.app_log) pool = ThreadPoolExecutor(options.threads) memcache_urls = os.environ.get('MEMCACHIER_SERVERS', os.environ.get('MEMCACHE_SERVERS') ) # Handle linked Docker containers if(os.environ.get('NBCACHE_PORT')): tcp_memcache = os.environ.get('NBCACHE_PORT') memcache_urls = tcp_memcache.split('tcp://')[1] if(os.environ.get('NBINDEX_PORT')): log.app_log.info("Indexing notebooks") tcp_index = os.environ.get('NBINDEX_PORT') index_url = tcp_index.split('tcp://')[1] index_host, index_port = index_url.split(":") indexer = ElasticSearch(index_host, index_port) else: log.app_log.info("Not indexing notebooks") indexer = NoSearch() if options.no_cache: log.app_log.info("Not using cache") cache = MockCache() elif pylibmc and memcache_urls: kwargs = dict(pool=mc_pool) username = os.environ.get('MEMCACHIER_USERNAME', '') password = os.environ.get('MEMCACHIER_PASSWORD', '') if username and password: kwargs['binary'] = True kwargs['username'] = username kwargs['password'] = password log.app_log.info("Using SASL memcache") else: log.app_log.info("Using plain memecache") cache = AsyncMultipartMemcache(memcache_urls.split(','), **kwargs) else: log.app_log.info("Using in-memory cache") cache = DummyAsyncCache() # setup tornado handlers and settings template_path = pjoin(here, 'templates') static_path = pjoin(here, 'static') env = Environment(loader=FileSystemLoader(template_path)) env.filters['markdown'] = markdown.markdown try: git_data = git_info(here) except Exception as e: app_log.error("Failed to get git info: %s", e) git_data = {} else: git_data['msg'] = escape(git_data['msg']) if options.no_cache: # force jinja to recompile template every time env.globals.update(cache_size=0) env.globals.update(nrhead=nrhead, nrfoot=nrfoot, git_data=git_data, ipython_info=ipython_info(), len=len, ) AsyncHTTPClient.configure(HTTPClientClass) client = AsyncHTTPClient() github_client = AsyncGitHubClient(client) # load frontpage sections with io.open(options.frontpage, 'r') as f: frontpage_sections = json.load(f) # cache frontpage links for the maximum allowed time max_cache_uris = {''} for section in frontpage_sections: for link in section['links']: max_cache_uris.add('/' + link['target']) settings = dict( log_function=log_request, jinja2_env=env, static_path=static_path, client=client, github_client=github_client, exporter=exporter, config=config, index=indexer, cache=cache, cache_expiry_min=options.cache_expiry_min, cache_expiry_max=options.cache_expiry_max, max_cache_uris=max_cache_uris, frontpage_sections=frontpage_sections, pool=pool, gzip=True, render_timeout=20, localfile_path=os.path.abspath(options.localfiles), fetch_kwargs=dict( connect_timeout=10, ), ) # create and start the app if options.localfiles: log.app_log.warning("Serving local notebooks in %s, this can be a security risk", options.localfiles) # use absolute or relative paths: handlers.insert(0, (r'/localfile/(.*)', LocalFileHandler)) # load ssl options ssl_options = None if options.sslcert: ssl_options = { 'certfile' : options.sslcert, 'keyfile' : options.sslkey, } app = web.Application(handlers, debug=options.debug, **settings) http_server = httpserver.HTTPServer(app, xheaders=True, ssl_options=ssl_options) log.app_log.info("Listening on port %i", options.port) http_server.listen(options.port) ioloop.IOLoop.instance().start()
app = web.Application( [ (r'/', MainHandler), (r'/test', TestHandler), (r'/news', NewsHandler), (r'/signup', SignupHandler), (r'/deauth', UserDeauth), (r'/leave', UserUnauth), (r'/policy', PolicyHandler), (r'/about', AboutHandler), (r'/auth/google', GoogleAuth), (r'/auth/facebook', FacebookAuth), (r'/auth/spotify', SpotifyAuth), (r'/auth/twitter', TwitterAuth), (r'/auth/reddit', RedditAuth), (r'/auth/tumblr', TumblrAuth), (r'/auth/instagram', InstagramAuth), (r'/auth/close', CloseWindow), (r'/user/info', UserAuth), (r'/api/showtimes', ListShowtimesHandler), (r'/api/showtimes/access_tokens', ShowtimeAccessTokens), (r'/api/showtimes/create', CreateShowtimeHandler), (r"/favicon.ico", web.StaticFileHandler, {"path": ""}), ], template_path="./templates/", static_path="./static/", debug=debug, cookie_secret=CONFIG.get('cookie_secret'), base_url=CONFIG.get('base_url'), **oauth_creds )
imgs = searchSoup.select("img ") for m in imgs: print(m.get('src')) elements = searchSoup.select('meta[name="viewport"]') if len(elements) > 0: return "true" # 2 .富门户移动化过的标志 fmhmark = searchSoup.find_all( src=re.compile("http://gmwz-1251053291.file.myqcloud.com/")) if len(fmhmark) > 0: return "true" return "false" ##截取网页移动端浏览快照 def get_html_image(self, chrome): return chrome.get_screenshot_as_base64() #启动服务 监听mobile_check路径 application = server.Application([ (r"/mobile_check", MainHandler), ]) if __name__ == "__main__": application.listen(18114) loop.IOLoop.instance().start()
def make_app(): return web.Application([ (r"/login", LoginHandler), (r"/files(/.+)?", FileHandler), ])
'db': 'testdb' } class GetUserHandler(web.RequestHandler): POOL = pools.Pool( connParam, max_idle_connections=1, max_recycle_sec=3, ) @gen.coroutine def get(self): userid = self.get_argument('id') cursor = yield self.POOL.execute( """select name from user where id = {}""".format(userid)) if cursor.rowcount > 0: self.write({"status": 1, "name": cursor.fetchone()[0]}) else: self.write({"status": 0, "name": ""}) self.finish() if __name__ == '__main__': application = web.Application([ (r"/getuser", GetUserHandler), ], autoreload=True) application.listen(8765) IOLoop.current().start()
super(RequestHandler, self).__init__(*args, **kwargs) def prepare(self): uniq_id = self.request.headers.get('X-UniqID', uuid.uuid4().hex) self.logger = logging.LoggerAdapter( self.parent_log.getChild('RequestHandler'), extra={'context': uniq_id}) def get(self, object_id): self.logger.debug('fetchin %s', object_id) self.set_status(200) return self.finish() def sig_handler(signo, frame): logging.info('caught signal %d, stopping IO loop', signo) iol = ioloop.IOLoop.instance() iol.add_callback_from_signal(iol.stop) if __name__ == '__main__': logging.config.dictConfig(LOG_CONFIG) logger = logging.getLogger('app') app = web.Application([ web.url('/(?P<object_id>\w+)', RequestHandler, kwargs={'parent_log': logger}), ]) app.listen(8000) signal.signal(signal.SIGINT, sig_handler) signal.signal(signal.SIGTERM, sig_handler) ioloop.IOLoop.instance().start() logger.info('IO loop stopped, exiting')
def Main(): """Entrant function.""" parser = optparse.OptionParser() parser.add_option('-c', '--cluster', metavar='CLUSTER_MANAGER', action='store', type='string', dest='cluster', help='specify cluster manager', default='GoogleCompute') parser.add_option('-p', '--http-port', metavar='PORT_NUM', action='store', type='string', dest='http_port', help='port to start http server on', default='12345') parser.add_option('-P', '--sim-port', metavar='SIMULATOR_PORT_NUM', action='store', type='string', dest='bigbrain_port', help='port that bigbrain instances run on', default='32123') parser.add_option('-b', '--heartbeat', metavar='SECONDS', action='store', type='float', dest='heartbeat_timeout', help='duration between cluster manager heartbeats', default='3.0') (options, args) = parser.parse_args() # pylint: disable-msg=W0612 # Spin up database dbconn = pymongo.connection.Connection() database = dbconn.bigbrain # Initialize Cluster Manager cluster_type = { 'Localhost': lcm.LocalhostClusterManager, 'GoogleCompute': gccm.GoogleComputeClusterManager } if options.cluster not in cluster_type: print 'Unable to instantiate cluster manager of type "%s"' % ( options.cluster) sys.exit(2) print 'Initializing ' + options.cluster cluster_manager = cluster_type[options.cluster]() cluster_manager.Initialize(socket.gethostname(), options.http_port, options.bigbrain_port) cluster_manager.Heartbeat() # Initialize RPC engine rpc_manager = bigbrain.rpc.AsyncSimulatorRPC(cluster_manager, options.bigbrain_port, 'msgpack', True) # Start up resource controller resource_controller = bigbrain.resourcecontroller.ResourceController( cluster_manager, rpc_manager, database) # Set up web handlers handler_params = dict(db=database, cluster=cluster_manager, rpc=rpc_manager, rc=resource_controller) url_handlers = [(r'/agent/(msgpack|json)/(.*)', AgentUpdate, handler_params), (r'/viewstream', viewstream.ViewStream, handler_params), (r'/experiments', MockExperiments, handler_params), (r'/experiments/(.*)', MockExperiments, handler_params), (r'/social/?(.*)', MockSocial, handler_params), (r'/static/(.*)', web.StaticFileHandler, { 'path': './static' }), (r'/login', Login, handler_params), (r'/logout', Logout, handler_params), (r'/(.*)', MockHome, handler_params)] application = web.Application(url_handlers, template_path='./templates/', cookie_secret='batsbatsbatsEVERYWHEREB@Tbot', debug=True) application.listen(options.http_port) def InstanceHeartbeatCallback(): InstanceHeartbeat(cluster_manager, rpc_manager, resource_controller) ioloop.IOLoop.instance().add_timeout( time.time() + options.heartbeat_timeout, InstanceHeartbeatCallback) ioloop.IOLoop.instance().add_timeout( time.time() + options.heartbeat_timeout, InstanceHeartbeatCallback) ioloop.IOLoop.instance().start() logging.debug('Server shutdown')
def consume(): # Start a tornado IOLoop for reading/writing to the process in this thread ioloop.IOLoop() reader = streams.JsonRpcStreamReader(proc.stdout) reader.listen(lambda msg: self.write_message(json.dumps(msg))) thread = threading.Thread(target=consume) thread.daemon = True thread.start() def on_message(self, message): """Forward client->server messages to the endpoint.""" print(message) self.writer.write(json.loads(message)) def check_origin(self, origin): return True if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--host", type=str, default="127.0.0.1") parser.add_argument("--port", type=int, default=3000) args = parser.parse_args() app = web.Application([ (r"/cpp", LanguageServerWebSocketHandler), ]) print("Started Web Socket at ws://{}:{}/cpp".format(args.host, args.port)) app.listen(args.port, address=args.host) ioloop.IOLoop.current().start()
def _start_server(cls): cls.io_loop = ioloop.IOLoop.current() app = web.Application([(r".*", TestingApp)]) cls.server, cls.port = run_tornado_app(app, cls.io_loop, cls.certs, cls.scheme, cls.host) cls.server_thread = run_loop_in_thread(cls.io_loop)
'digrams': digrams, 'trigrams': trigrams, 'check_links': check_links, 'article': { 'title': article.title, 'desc': article.meta_description, 'text': article.cleaned_text, 'top_image': img, } } self.write_message(json.dumps(result)) self.close() app = web.Application( [ (r'/', IndexHandler), (r'/ws', SocketHandler), # (r'/api', ApiHandler), # (r'/(favicon.ico)', web.StaticFileHandler, {'path': '../'}), # (r'/(rest_api_example.png)', web.StaticFileHandler, {'path': './'}), ], autoreload=True, debug=True, compiled_template_cache=False, serve_traceback=True) if __name__ == '__main__': app.listen(8888) ioloop.IOLoop.instance().start()
def create_worker_preload_application(): application = web.Application([(r"/preload", WorkerPreloadHandler)]) server = application.listen(12346, address="127.0.0.1") tornado.ioloop.IOLoop.instance().start()
def commandline(argv): from . import bgtasks version_string, git_hash = get_version_info() logger.info('starting up Librarian %s (%s)', version_string, git_hash) app.config['_version_string'] = version_string app.config['_git_hash'] = git_hash server = app.config.get('server', 'flask') host = app.config.get('host', None) port = app.config.get('port', 21106) debug = app.config.get('flask_debug', False) n_server_processes = app.config.get('n_server_processes', 1) if host is None: print( 'note: no "host" set in configuration; server will not be remotely accessible', file=sys.stderr) maybe_add_stores() if n_server_processes > 1: if server != 'tornado': print('error: can only use multiple processes with Tornado server', file=sys.stderr) sys.exit(1) if server == 'tornado': # Need to set up HTTP server and fork subprocesses before doing # anything with the IOLoop. from tornado.wsgi import WSGIContainer from tornado.httpserver import HTTPServer from tornado.ioloop import IOLoop from tornado import web from .webutil import StreamFile flask_app = WSGIContainer(app) tornado_app = web.Application([ (r'/stream/.*', StreamFile), (r'.*', web.FallbackHandler, { 'fallback': flask_app }), ]) http_server = HTTPServer(tornado_app) http_server.bind(port, address=host) http_server.start(n_server_processes) db.engine.dispose() # force new connection after potentially forking do_mandc = app.config.get('report_to_mandc', False) if do_mandc: from . import mc_integration mc_integration.register_callbacks(version_string, git_hash) if server == 'tornado': # Set up periodic report on background task status; also reminds us # that the server is alive. bgtasks.register_background_task_reporter() if is_primary_server(): # Primary server is also in charge of checking out whether there's # anything to do with our standing orders. from tornado.ioloop import IOLoop from . import search IOLoop.current().add_callback(search.queue_standing_order_copies) search.register_standing_order_checkin() # Hack the logger to indicate which server we are. import tornado.process taskid = tornado.process.task_id() if taskid is not None: fmtr = logging.getLogger('').handlers[0].formatter fmtr._fmt = fmtr._fmt.replace(': ', ' #%d: ' % taskid) if server == 'flask': print( 'note: using "flask" server, so background operations will not work', file=sys.stderr) app.run(host=host, port=port, debug=debug) elif server == 'tornado': from tornado.ioloop import IOLoop IOLoop.current().start() else: print('error: unknown server type %r' % server, file=sys.stderr) sys.exit(1) bgtasks.maybe_wait_for_threads_to_finish()