def __init__(self): settings = dict( # static_path = os.path.join(os.path.dirname(__file__), "static"), # template_path = os.path.join(os.path.dirname(__file__), "templates"), debug=tornado.options.options.debug, ) context_data = ContextData() context_data.open_connection() attribute_product_data = AttributeProductData() attribute_product_data.open_connection() contextualizer = Contextualizer(context_data, attribute_product_data) tornado.web.Application.__init__( self, [ url( r"/([0-9a-fA-F]+)?", handlers.ContextHandler, dict(contextualizer=contextualizer), name="context" ), url(r"/([0-9a-fA-F]+)/messages", handlers.MessagesHandler, name="messages"), url( r"/([0-9a-fA-F]+)/messages/", handlers.MessageHandler, dict(contextualizer=contextualizer), name="message" ), url(r"/([0-9a-fA-F]+)/feedback/", handlers.FeedbackHandler, name="feedback"), url(r"/status", handlers.StatusHandler, name="status") ], **settings )
def make_app( url_prefix="/qcache", debug=False, max_cache_size=1000000000, max_age=0, statistics_buffer_size=1000, basic_auth=None, default_filter_engine=FILTER_ENGINE_NUMEXPR, ): if basic_auth: global auth_user, auth_password auth_user, auth_password = basic_auth.split(":", 2) stats = Statistics(buffer_size=statistics_buffer_size) cache = DatasetCache(max_size=max_cache_size, max_age=max_age) return Application( [ url( r"{url_prefix}/dataset/([A-Za-z0-9\-_]+)/?(q)?".format(url_prefix=url_prefix), DatasetHandler, dict(dataset_cache=cache, state=AppState(), stats=stats, default_filter_engine=default_filter_engine), name="dataset", ), url(r"{url_prefix}/status".format(url_prefix=url_prefix), StatusHandler, dict(), name="status"), url( r"{url_prefix}/statistics".format(url_prefix=url_prefix), StatisticsHandler, dict(dataset_cache=cache, stats=stats), name="statistics", ), ], debug=debug, transforms=[CompressedContentEncoding], )
def main(): pid_fname = "host.pid" p = open(pid_fname, 'w') try: log.portalocker.lock(p, log.portalocker.LOCK_EX | log.portalocker.LOCK_NB) except Exception as e: print e print 'ERR: only one instance can be started!!!' return app = Application([ url(r'/host/util', HostUtilsHandler), url(r'/host/internal', InternalHandler), url(r'/host/help', HelpHandler), ]) app.listen(10004) rh = RegHt([ { 'type':'host', 'id':'0', 'url':'http://<ip>:10004/host' } ]) global _pm _pm = PerformanceMonitor() _pm.start() global _ioloop _ioloop = IOLoop.instance() _ioloop.start()
def start_http_server(port): application = Application([ url(r'/health', HealthHandler), url(r'/metrics', MetricsHandler), url(r'/connectors', ConnectorsHandler) ]) HTTPServer(application).listen(port)
def __init__(self, **kwargs): prefix = "/{0}/".format(kwargs.get('prefix', "").strip("/")).replace("//", "/") handlers = [ url(r"{0}".format(prefix), RootHandler, name='index'), url(r"{0}host/(.*)".format(prefix), HostHandler, name='host-detail'), url(r"{0}api/(.*)/(.*)".format(prefix), MetricAPIHandler, name='api-detail'), ] # Default settings settings = dict( template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), static_url_prefix="{0}static/".format(prefix), ) settings.update(kwargs) super(APIApplication, self).__init__(handlers, **settings) rrd_directory = os.path.abspath(self.settings['rrd_directory']) # From base directory: host/plugin/instance.rrd self.plugin_info = {} # Host --> Plugins --> Instances for name in glob.glob(u"%s/*/*/*.rrd" % rrd_directory): name = name.replace(u"%s/" % rrd_directory, '') host, plugin = os.path.split(os.path.dirname(name)) instance, _ = os.path.splitext(os.path.basename(name)) info = self.plugin_info.get(host, {}) plugins = info.get('plugins', {}) instances = plugins.get(plugin, []) instances.append(instance) plugins[plugin] = instances self.plugin_info[host] = {'plugins': plugins}
def create_app(version): app0 = Application([ url(r"/", TestHandler0), ]) app1 = Application([ url(r"/", TestHandler1), ]) if version == "0": return app0 elif version == "1": return app1
def make_app(): return Application([ url(r'/auth/twitter', TwitterLoginHandler), url(r'/ws', RobustWebSocket) ], twitter_consumer_key=properties.twitter_key, twitter_consumer_secret=properties.twitter_secret)
def get_app(self): loader = DictLoader({ "linkify.html": "{% module linkify(message) %}", "page.html": """\ <html><head></head><body> {% for e in entries %} {% module Template("entry.html", entry=e) %} {% end %} </body></html>""", "entry.html": """\ {{ set_resources(embedded_css=".entry { margin-bottom: 1em; }", embedded_javascript="js_embed()", css_files=["/base.css", "/foo.css"], javascript_files="/common.js", html_head="<meta>", html_body='<script src="/analytics.js"/>') }} <div class="entry">...</div>""", }) urls = [ url("/typecheck/(.*)", TypeCheckHandler, name='typecheck'), url("/decode_arg/(.*)", DecodeArgHandler), url("/decode_arg_kw/(?P<arg>.*)", DecodeArgHandler), url("/linkify", LinkifyHandler), url("/uimodule_resources", UIModuleResourceHandler), url("/optional_path/(.+)?", OptionalPathHandler), url("/flow_control", FlowControlHandler), url("/multi_header", MultiHeaderHandler), url("/redirect", RedirectHandler), url("/header_injection", HeaderInjectionHandler), ] return Application(urls, template_loader=loader, autoescape="xhtml_escape")
def run_auth_server(): client_store = ClientStore() client_store.add_client(client_id="abc", client_secret="xyz", redirect_uris=["http://localhost:8081/callback"]) token_store = TokenStore() provider = Provider( access_token_store=token_store, auth_code_store=token_store, client_store=client_store, token_generator=Uuid4() ) provider.add_grant(AuthorizationCodeGrant(site_adapter=TestSiteAdapter())) try: app = Application( [ url(provider.authorize_path, OAuth2Handler, dict(provider=provider)), url(provider.token_path, OAuth2Handler, dict(provider=provider)), ] ) app.listen(8080) print("Starting OAuth2 server on http://localhost:8080/...") IOLoop.current().start() except KeyboardInterrupt: IOLoop.close()
def run_auth_server(): client_store = ClientStore() client_store.add_client(client_id="abc", client_secret="xyz", redirect_uris=[], authorized_grants=[oauth2.grant.ClientCredentialsGrant.grant_type]) token_store = TokenStore() # Generator of tokens token_generator = oauth2.tokengenerator.Uuid4() token_generator.expires_in[oauth2.grant.ClientCredentialsGrant.grant_type] = 3600 provider = Provider(access_token_store=token_store, auth_code_store=token_store, client_store=client_store, token_generator=token_generator) # provider.add_grant(AuthorizationCodeGrant(site_adapter=TestSiteAdapter())) provider.add_grant(ClientCredentialsGrant()) try: app = Application([ url(provider.authorize_path, OAuth2Handler, dict(provider=provider)), url(provider.token_path, OAuth2Handler, dict(provider=provider)), ]) app.listen(8080) print("Starting OAuth2 server on http://localhost:8080/...") IOLoop.current().start() except KeyboardInterrupt: IOLoop.close()
def make_app(): return Application([ url(r'/ptz/help', HelpHandler), url(r"/ptz/config(/?)", GetConfigHandler), url(r'/ptz/([^\/]+)/([^\/]+)/([^\?]+)', ControllingHandler), url(r'/ptz/internal', InternalHandler), ])
def __init__(self): handlers = [ (r'/', IndexHandler), (r'/home', HomeHandler), url(r'/addresses', ListAddressHandler, name='addresses'), url(r'/addresses/new', NewAddressHandler, name='new_address'), url(r'/addresses/edit', EditAddressHandler, name='edit_address'), url(r'/addresses/delete', DeleteAddressHandler, name='delete_address'), url(r'/addresses/([^/]+)/messages', ListMessagesHandlers, name='messages'), # Inbound (r'/_ah/mail/.+', InboundHandler), # Tasks (r'/tasks/transmit_message', TransmitMessageHandler), ] settings = dict( debug=IS_DEV, static_path=os.path.join(os.path.dirname(__file__), "static"), template_path=os.path.join(os.path.dirname(__file__), 'templates'), xsrf_cookies=True, cookie_secret="m9i-asdj123ansdnzxjch7o23ij09iaodljansdiu123ojadsoo", ui_modules=uimodules, ) tornado.wsgi.WSGIApplication.__init__(self, handlers, **settings)
def main(): arr_threads = [] #TODO: rebuild RequestQueue from log, and set currentJobID #prepare Thread to Consume RequestQueue and Produce ProcessQueue for i in range(nr_jobSaver): arr_threads.append(JobSaver(i)) #prepare Thread to Consume ProcessQueue for i in range(nr_jobConsumer): arr_threads.append(JobConsumer(i)) #start threads for t in arr_threads: t.start() #start server for incoming jobs app = Application([ url(r"/", JobHandler), url(r"/status", StatusHandler), url(r"/stop", StopServerHandler), ]) app.listen(8888) ioloop.IOLoop.current().start()
def runserver(args): # set up logging to std out as default logging.getLogger().setLevel(logging.DEBUG) tornado.options.enable_pretty_logging() # set up the Django app, TODO: move to webui module wsgi_app = tornado.wsgi.WSGIContainer(django.core.handlers.wsgi.WSGIHandler()) # this guy tracks all the Remote Players player_state = dict(state=ps.PlayerState()) application = tornado.web.Application([ (r'/api/1/content/(\d+)/data', StreamingContentHandler), (r'/api/1/playback/players', ps.RemotePlayerListHandler , player_state), url(r'/api/1/playback/players/(\d+)', ps.RemotePlayerHandler, player_state, 'player'), (r'/api/1/playback/players/register', ps.RemotePlayerSocket, player_state), (r'/api/1/playback/sessions', ps.SessionListHandler, player_state), url(r'/api/1/playback/sessions/(\d+)', ps.SessionHandler, player_state, 'session'), (r'.*', FallbackHandler, dict(fallback=wsgi_app)) ], static_path=resource_filename('krum.webui', 'static'), # TODO: move to webui module debug=True ) server = HTTPServer(application) server.bind(args.port) server.start(1) tornado.ioloop.IOLoop.instance().start()
def __init__(self): urlpatterns = ( url(r"/image/(\w+\.(?:jpg|png))$", ImageHandler, name="image"), ) if options.debug: urlpatterns += ( url(r"/static/(.*)", tornado.web.StaticFileHandler, {"path": root("static")}), ) settings = dict( cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", login_url="/auth/login", template_path=root("templates"), static_path=root("static"), static_url_prefix="/static/", xsrf_cookies=True, # facebook_api_key=options.facebook_api_key, # facebook_secret=options.facebook_secret, # ui_modules={"Post": PostModule}, debug=options.debug, # autoescape=None, compress_response=True, ) super(Application, self).__init__(urlpatterns, **settings)
def __init__(self): dialog_service = Dialog( username=WATSON_USERNAME, password=WATSON_PASSWORD ) dialog_id = WATSON_DIALOG_ID # # CREATE A DIALOG # with open(join(dirname(__file__), '../dialog_files/jemboo-dialog-file.xml')) as dialog_file: # create_dialog_response = dialog_service.update_content(dialog_file=dialog_file, name='jemboo-dialog') # UPDATE A DIALOG # with open(join(dirname(__file__), '../dialog_files/jemboo-dialog-file.xml')) as dialog_file: # # create_dialog_response = dialog_service.update_dialog(dialog_file=dialog_file, dialog_id=dialog_id) handlers = [ url(r"/api/bluemix/initChat", InitChat, dict(dialog_service=dialog_service, dialog_id=dialog_id), name="root"), url(r"/api/bluemix/postConversation", Conversation, dict(dialog_service=dialog_service, dialog_id=dialog_id), name="conversation"), (r'/()', tornado.web.StaticFileHandler, {'path': "static/index.html"}), (r'/(.*)', tornado.web.StaticFileHandler, {'path': "static/"}), # (r'/static/(.*)', tornado.web.StaticFileHandler, {'path': static_path}), ] settings = dict( template_path=join(dirname(__file__), "../templates"), # static_path=os.path.join(os.path.dirname(__file__), "../static"), debug=tornado.options.options.debug, ) tornado.web.Application.__init__(self, handlers, **settings)
def main(): # pragma: no cover """ Actually fire up the web server. Listens on 4096. """ define('port', default=4096) define('style_host', default='localhost') define('style_port', default=4097) define('log_level', default='INFO') define('log_format', default='%(asctime)s %(levelname)s [%(thread)d] ' + '[%(X-Socrata-RequestId)s] %(name)s %(message)s') parse_command_line() init_logging() routes = [ web.url(r'/', web.RedirectHandler, {'url': '/version'}), web.url(r'/version', VersionHandler), web.url(r'/render', RenderHandler, { 'style_host': options.style_host, 'style_port': options.style_port, 'http_client': AsyncHTTPClient() }), ] app = web.Application(routes) app.listen(options.port) logger = get_logger() logger.info('Listening on localhost:4096...') IOLoop.instance().start()
def __init__(self): settings = setting_from_object(config) handlers = [ url(r"/static/download/(.*)", tornado.web.StaticFileHandler, dict(path=settings['upload_path']), name='upload_path'), url(r"/static/js/(.+)", tornado.web.StaticFileHandler, dict(path=settings['js_path']), name='js_path'), url(r"/static/css/(.+)", tornado.web.StaticFileHandler, dict(path=settings['css_path']), name='css_path'), url(r"/static/img/(.+)", tornado.web.StaticFileHandler, dict(path=settings['img_path']), name='img_path'), url(r"/static/fonts/(.+)", tornado.web.StaticFileHandler, dict(path=settings['fonts_path']), name='fonts_path'), ] handlers += Route.routes() handlers.append((r"/(.*)", ErrorHandler)) # Custom 404 ErrorHandler # static_path 的设置和StaticFileHandler,以及static_url函数有关 # settings['static_path'] = settings['project_path'] settings.update(dict( gzip = True, ui_modules = uimodules, autoescape = None )) if 'default_locale' in settings: tornado.locale.load_gettext_translations( os.path.join(os.path.dirname(__file__), 'translations'), 'messages') tornado.web.Application.__init__(self, handlers, **settings) self.forms = create_forms() pool = redis.ConnectionPool(host=settings['redis_host'], port=settings['redis_port'], db=settings['redis_db']) self.redis = redis.Redis(connection_pool=pool) self.session_store = RedisSessionStore(self.redis) configure_signals(db.sender)
def make_app(): return Application([ url(r'/', HelloHandler), url(r'/comments.json', CommentsHandler), url(r'/comments.ws', CommentsHandlerWS), ], debug=True)
def get_app(self): self.packages = spy(mappers.PackageMapper(empty_stub())) self.cache = spy(cache.Cache(self.packages, None, None)) self.pypi_fallback = "http://pypi.python.org/simple/%s/" return web.Application([ web.url(r'/distutils/', handlers.DistutilsDownloadHandler, dict(packages=self.packages, cache=self.cache) ), web.url(r'/distutils/(?P<id_>%s)/' % viper.identifier(), handlers.DistutilsDownloadHandler, dict(packages=self.packages, cache=self.cache), name='distutils_package' ), web.url(r'/distutils/(?P<id_>%s)/(?P<version>%s)' % (viper.identifier(), viper.identifier()), handlers.DistutilsDownloadHandler, dict(packages=self.packages, cache=self.cache), name='distutils_package_with_version' ), web.url(r'/packages/(?P<id_>%s)' % viper.identifier(), handlers.PackageHandler, dict(packages=self.packages, cache=self.cache), name='package' ), web.url(r'/files/(?P<id_>%s)' % viper.identifier(), handlers.FileHandler, dict(files=None), name='file' ) ], debug=True, template_path=os.path.join(os.path.dirname(handlers.__file__), 'templates'), static_path=os.path.join(os.path.dirname(handlers.__file__), 'static'), pypi_fallback=self.pypi_fallback )
def make_app(): return Application([ url(r"/login", Login), url(r"/logout", Logout), url(r"/.*", HelloHandler)], cookie_secret="4") # Choosen by a fair dice roll
def __init__(self): settings = setting_from_object(config) handlers = [ # other handlers... url(r"/theme/(.+)", tornado.web.StaticFileHandler, dict(path=settings['theme_path']), name='theme_path'), url(r"/upload/(.+)", tornado.web.StaticFileHandler, dict(path=settings['upload_path']), name='upload_path') ] + Route.routes() # Custom 404 ErrorHandler handlers.append((r"/(.*)", ErrorHandler)) settings.update(dict( ui_modules = uimodules, autoescape = None )) if 'default_locale' in settings: tornado.locale.load_gettext_translations( os.path.join(os.path.dirname(__file__), 'translations'), 'messages') tornado.web.Application.__init__(self, handlers, **settings) self.forms = create_forms() self.redis = redis.StrictRedis() self.session_store = RedisSessionStore(self.redis) configure_signals(db.sender)
def main(): # Creating a Room Handler instance rh = RoomHandler() # app settings settings = { "static_path": os.path.join(os.path.dirname(__file__), "static"), "static_path": os.path.join(os.path.dirname(__file__), "static"), "template_path": os.path.join(os.path.dirname(__file__), "templates"), "autoreload": True, "debug": True } # Creating the app instance app = tornado.web.Application([ url(r"/", MainHandler, {'room_handler': rh}, name="index"), url(r"/existing", ExistingRooms, {'room_handler': rh}, name="existing"), url(r"/ws/(.*)", ClientWSConnection, {'room_handler': rh}), ], **settings ) # Starting the server app.listen(8888) print 'Clam Chat Server started.' print 'listening on 8888 ...' tornado.ioloop.IOLoop.instance().start()
def main(): app = web.Application([ web.url(r'/sub', SubscribeSocket), web.url(r'/pub', PublishHandler) ]) try: app.listen(8085) except OSError as e: print(str.format( '[%] {}', e )) sys.exit(1) ioloop.IOLoop.configure('tornado.platform.asyncio.AsyncIOLoop') loop = ioloop.IOLoop.current() try: print('[*] Starting tornado application on [localhost: 8085]...') loop.start() except Exception as e: print(str.format( '[%] {}', e )) loop.stop()
def __init__(self): # self.config = self._get_config() handlers = [ url(r"/", IndexHandler, name="index"), url(r"/hello", HelloWorldHandler, name="hello"), url(r"/single", SingleFieldHandler, name="single"), url(r"/price", PriceHandler, name="price"), url(r"/postcode", PostcodeHandler, name="postcode"), ] # xsrf_cookies is for XSS protection add this to all forms: {{ xsrf_form_html() }} settings = { "static_path": os.path.join(os.path.dirname(__file__), "static"), "template_path": os.path.join(os.path.dirname(__file__), "templates"), "cookie_secret": base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes), #'xsrf_cookies': True, "debug": False, "log_file_prefix": "tornado.log", } tornado.web.Application.__init__(self, handlers, **settings) # debug=True , # Connect to mongodb self.connection = pymongo.Connection(MONGO_SERVER, 27017, max_pool_size=1000) self.db = self.connection["houseprices"] # we preload dates & postcode_parts self.legal_dates = self.db.houses.distinct("dateadded") legal_postcodes_results = self.db.houses.distinct("postcode_part") self.legal_postcodes = [] for p in legal_postcodes_results: self.legal_postcodes.append(p) self.legal_postcodes.sort()
def make_app(): base_dir = path.dirname(path.abspath(__file__)) media_path = path.join(base_dir, "files") debug = True #redis = tornadoredis.ConnectionPool(max_connections=10, wait_for_available=True) redis = tornadoredis.Client() redis.connect() cache = DataManager() cache.redis = redis # cache.initialize() global_vars = dict(cache=cache) return Application([ url(r"/", IndexHandler,global_vars, name="index"), url(r"/thread", ThreadHandler, global_vars, name="thread"), url(r"/ws", WsHandler, global_vars, name="ws"), url(r'/files/(.*)', StaticFileHandler, {'path': media_path}, name="files"), # url(r"/(?P<param1>.*)", HelloHandler, global_vars, name='home'), ], debug=debug, xsrf_cookies=False, template_path=path.join(base_dir, "templates"), static_path=path.join(base_dir, "static"), media_path=media_path, cookie_secret='secret', redis=redis, cache=cache, )
def configure_app(self, config=None, log_level='INFO', debug=False, static_path=None): template_path = abspath(join(dirname(__file__), 'templates')) static_path = abspath(join(dirname(__file__), 'static')) self.config = config handlers = [ url(r'/', HomeHandler, name="home"), url(r'/locations', LocationsHandler, name="location"), ] self.redis = redis.StrictRedis( host=self.config.REDIS_HOST, port=self.config.REDIS_PORT, db=self.config.REDIS_DB_COUNT, password=self.config.REDIS_PASSWORD ) options = { "cookie_secret": self.config.COOKIE_SECRET, "template_path": template_path, "static_path": static_path, "static_url_prefix": self.config.STATIC_URL } if debug: options['debug'] = True return handlers, options
def make_app(): return Application([ url(r"/", HomeHandler), url(r"/v1/targets/add", AddHandler), url(r"/v1/targets/remove", RemoveHandler), url(r"/v1/targets", ListHandler), ])
def reset_handlers(cls,application): settings = application.settings # 重置 handlers if settings.get("static_path") : path = settings["static_path"] static_url_prefix = settings.get("static_url_prefix", "/static/") static_handler_class = settings.get("static_handler_class", StaticFileHandler) static_handler_args = settings.get("static_handler_args", {}) static_handler_args['path'] = path for pattern in [re.escape(static_url_prefix) + r"(.*)", r"/(favicon\.ico)", r"/(robots\.txt)"]: item = url(pattern, static_handler_class, static_handler_args) cls._routes.setdefault('.*$', []) if item not in cls._routes['.*$'] : cls._routes['.*$'].insert(0, item) # 404 item = url(r"/(.+)$", _404Handler) if item not in cls._routes['.*$'] : cls._routes['.*$'].append(item)
def main(): parse_command_line() client = AsyncHTTPClient(max_clients = 100) template_path = os.path.join(os.path.dirname(__file__), 'templates') static_path = os.path.join(os.path.dirname(__file__), 'static') template_loader_factory = lambda: template.Loader(template_path) handlers = [ url(r'/$', RootHandler), url(r'/logout$', LogoutHandler), url(r'/submityelp$', SubmitYelpHandler), url(r'/matchvenues$', MatchVenuesHandler), url(r'%s$' % OAuthLoginHandler.URI, OAuthLoginHandler) ] app = Application( handlers, debug = options.debug, xsrf_cookies = False, # TODO cookie_secret = 'deadb33fd00dc9234adeda42777', template_path = template_path, static_path = static_path, memcache_client = memcache.Client([options.memcache_host], debug = 0), httpclient = client ) logging.info('starting on port %d' % options.port) server = tornado.httpserver.HTTPServer(app) server.listen(options.port) tornado.ioloop.IOLoop.instance().start()
def get_app(self): return Application([ url("/hello", HelloWorldHandler), ])
def get_app(self): # callable objects to finish pending /trigger requests self.triggers = collections.deque() return Application([ url("/trigger", TriggerHandler, dict(queue=self.triggers, wake_callback=self.stop)), url("/chunk", ChunkHandler), url("/countdown/([0-9]+)", CountdownHandler, name="countdown"), url("/hang", HangHandler), url("/hello", HelloWorldHandler), url("/content_length", ContentLengthHandler), url("/head", HeadHandler), url("/options", OptionsHandler), url("/no_content", NoContentHandler), url("/see_other_post", SeeOtherPostHandler), url("/see_other_get", SeeOtherGetHandler), url("/host_echo", HostEchoHandler), url("/no_content_length", NoContentLengthHandler), url("/echo_post", EchoPostHandler), url("/respond_in_prepare", RespondInPrepareHandler), ], gzip=True)
from tornado.web import url from codebase.controllers import ( default, token, user, app ) HANDLERS = [ url(r"/", default.SpecHandler), url(r"/_health", default.HealthHandler), # Token url(r"/token", token.UserTokenHandler), url(r"/token/refresh", token.UserTokenRefreshHandler), url(r"/app_token", token.SingleAppTokenHandler), url(r"/app_token/refresh", token.SingleAppTokenRefreshHandler),
def __init__(self): handlers = [ (r'/', IndexHandler), (r'/join/', JoinHandler), (r'/login/', LoginHandler), (r'/logout/', LogoutHandler), (r'/settings/', SettingsHandler), (r'/settings/pwd/', PasswordHandler), (r'/settings/icon/', IconHandler), (r'/settings/crop/', CropIconHandler), #(r'/open/google', GoogleLoginHandler), #(r'/open/weibo', WeiboLoginHandler), #(r'/open/qq', QQLoginHandler), #(r'/open/renren', RenrenLoginHandler), #(r'/logout', LogoutHandler), (r'/upload/', UploadHandler), url(r'/image/(?P<category>\w+)/(?P<filename>\w+\.jpg)', ImageRenderHandler, name='image_render'), (r'/user/(\w+)/', UserHandler), #(r'/user/(\d+)/do_follow', FollowHandler), #(r'/item/(\d+)', ItemHandler), (r'/j/like/', LikeHandler), #(r'/comment', CommentHandler), #(r'/settings', SettingsHandler), #(r'/settings/pwd', PasswordHandler), #(r'/settings/icon', IconHandler), #(r'/settings/crop', CropIconHandler), #(r'/notice', NoticeHandler), #(r'/user/(\d+)/followers', FollowerHandler), #(r'/user/(\d+)/friends', FriendHandler), #(r'/users', UsersHandler), #(r'/cmtdel', DeleteCommentHandler), (r'/j/photos/', IndexPhotoHandler), #(r'/ajax/re', AjaxRelationHandler), #(r'/ajax/likers', AjaxEntryLikerHandler), #(r'/ajax/tops', AjaxUserTopsHandler), #(r'/about', AboutHandler), #(r'/about/help', HelpHandler), #(r'/about/team', TeamHandler), #(r'/a/comment/new', AjaxCommentHandler), #(r'/all', CategoryHandler), #(r'/search', SearchHandler), ] ui_modules = { 'Account': AccountModule, 'Notice': NoticeModule, 'Entry': EntryModule, 'UserBoard': UserBoardModule, 'UserProfile': UserProfileModule, 'Person': PersonModule, 'Pager': PagerModule, 'Comment': CommentModule, 'Header': HeaderModule, 'CategoriesBar': CategoriesBarModule, } settings = dict( template_path=os.path.join(os.path.dirname(__file__), 'templates'), static_path=os.path.join(os.path.dirname(__file__), 'static'), xsrf_cookies=True, cookie_secret='11oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=', diggit_title='Diggit', login_url='/login', autoescape=None, ui_modules=ui_modules, weibo_consumer_key=options.weibo_consumer_key, weibo_consumer_secret=options.weibo_consumer_secret, qq_consumer_key=options.qq_consumer_key, qq_consumer_secret=options.qq_consumer_secret, renren_key=options.renren_key, renren_secret=options.renren_secret, ) tornado.web.Application.__init__(self, handlers, **settings)
# !/usr/bin/python # -*- coding:utf-8 -*- from tornado.web import url from web import BaseHandler class IndexHandler(BaseHandler): def get(self): self.redirect(self.reverse_url('backoffice_index')) return URL_MAPPING_LIST = [ url(r'/', IndexHandler, name='index'), ]
# coding: utf-8 from tornado.web import url from . import views handlers = [ url(r'/auth/signup/identifier', views.SignUpIdentifier), url(r'/auth/signup', views.SignUp), url(r'/auth/signin', views.SignIn), url(r'/auth/signout', views.SignOut), url(r'/auth/forget_password/identifier', views.ForgetPasswordIdentifier), url(r'/auth/forget_password', views.ForgetPassword) ]
def __init__(self): handlers = [ url(r"/", HomeHandler), #注册,登录,登出,账号删除,个人资料展示页面,个人资料编辑-丰玉霖 url(r"/signup", UserCreateHandler), url(r"/login", UserLoginHandler), url(r"/logout", UserLogoutHandler), url(r"/close", UserDeleteHandler), url(r"/u/([0-9]+)/profile/*", ProfileHandler), url(r"/u/([0-9]+)/profile/edit", ProfileEditHandler), #新建相册,相册列表,相册编辑,相册删除-阙中元,魏晓飞 url(r"/albums/new", AlbumCreateHandler, name="AlbumCreate"), url(r"/u/([0-9]+)/albums/*", AlbumsListHandler), url(r"/u/([0-9]+)/albums/([0-9]+)/edit", AlbumEditHandler), url(r"/u/([0-9]+)/albums/([0-9]+)/delete", AlbumDeleteHandler), #上传相片,相片列表,单个相片显示页面,相片删除,朋友圈-唐永剑,贾超,姚彬,徐怡阳,张光伟,李佳袁 url(r"/photos/new", PhotosUploadHandler, name="PhotosUpload"), url(r"/u/([0-9]+)/albums/([0-9]+)", PhotosListHandler), url(r"/u/([0-9]+)/albums/([0-9]+)/([0-9]+)", PhotoHandler), url(r"/u/([0-9]+)/albums/([0-9]+)/([0-9]+)/delete", PhotoDeleteHandler), url(r"/feed/*", FeedHandler, name="feed"), url(r"/myform", MyFormHandler, name="myform") ] settings = dict( website_title=u"剑哥相册", template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), ui_modules={ "Navbar": uimodules.Navbar, "Bottom": uimodules.Bottom }, xsrf_cookies=False, #cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", cookie_secret="1234567892015neuee", login_url="/login", debug=True, ) super(Application, self).__init__(handlers, **settings) # Have one global connection to the blog DB across all handlers self.db = torndb.Connection(host=options.mysql_host, database=options.mysql_database, user=options.mysql_user, password=options.mysql_password) self.maybe_create_tables()
import tornado.ioloop import tornado.web import tornado.options from tornado.web import Application, url class AjaxHandler(tornado.web.RequestHandler): def get(self): self.render('ajax.html') def post(self): word = self.get_argument('w') print('SUBMITTED: ', word) msg = '<p>Output: ' + word + '<p>' print('RETURNED: ', msg) self.write(msg) if __name__ == "__main__": app = Application([url(r"/", AjaxHandler)], debug=True) app.listen(8888) tornado.ioloop.IOLoop.current().start()
# coding=utf-8 import app.index import app.user from tornado.web import url # url映射 handlers = [ url(r"/", app.index.MainHandler, name="index"), url(r"/user", app.user.UserHandler, name="user"), ]
self.send_error(400) # bad request class WorkspaceHandler(ReqHandler): ''' GET: render the workspace. ''' @web.authenticated def get(self): cserver = self.get_server() project = cserver.get_current_project() self.render('workspace/workspace.html', project=project) handlers = [ web.url(r'/workspace/?', WorkspaceHandler, name='workspace'), web.url(r'/workspace/base/?', ReqHandler), web.url(r'/workspace/command', CommandHandler), web.url(r'/workspace/files/?', FilesHandler), web.url(r'/workspace/file/(.*)', FileHandler), web.url(r'/workspace/objects/?', ObjectsHandler), web.url(r'/workspace/object/(?P<pathname>[^\/]+)/?(?P<attr>[^\/]+)?', ObjectHandler), web.url(r'/workspace/project', ProjectHandler), web.url(r'/workspace/stream/(.*)', StreamHandler), web.url(r'/workspace/subscription/(.*)', SubscriptionHandler),
from tornado.web import url from . import views handlers = [ # url( r'/register', views.RegisterApply, name='register'), url( r'/register', views.Register, name='register'), ]
from tornado.web import url from apps.community.handler import * urlpattern = ( url("/groups/", GroupHandler), url("/groups/([0-9]+)/", GroupDetailHanlder), url("/groups/([0-9]+)/members/", GroupMemberHandler), url("/groups/([0-9]+)/posts/", PostHandler), url("/posts/([0-9]+)/", PostDetailHandler), #评论 url("/posts/([0-9]+)/comments/", PostCommentHanlder), url("/comments/([0-9]+)/replys/", CommentReplyHandler), url("/comments/([0-9]+)/likes/", CommentsLikeHanlder), )
from tornado.web import url from . import views from . import admin_views handlers = [ url(r'/register', views.Register, name='register'), # admin url(r'/admin/registration', admin_views.Index, name='admin:registration'), url(r'/admin/registration/status_toggle', admin_views.RegistrationStatusToggle, name='admin:registration:status_toggle'), ]
if vcslist: vcs = vcslist[0](unique) else: vcs = DumbRepo(unique) vcs.init_repo() # Update project settings. proj = Project(project['projpath']) dummy = proj.get_info() # Just to get required keys. info = {} for key in dummy: info[key] = project[key] proj.set_info(info) pdb.new(project) self.redirect("/workspace/project?projpath=" + quote_plus(project['projpath'])) self.redirect("/") handlers = [ web.url(r'/projects/?', IndexHandler), web.url(r'/projects/(?P<project_id>\d+)/?', DetailHandler), web.url(r'/projects/new/$', NewHandler), web.url(r'/projects/import/$', ImportHandler), web.url(r'/projects/delete/(?P<project_id>\d+)/?', DeleteHandler), web.url(r'/projects/download/(?P<project_id>\d+)/?', DownloadHandler), ]
from .views.dashboard import DashboardView from .utils import gen_cookie_secret settings = dict( template_path=os.path.join(os.path.dirname(__file__), "templates"), static_path=os.path.join(os.path.dirname(__file__), "static"), cookie_secret=gen_cookie_secret(), static_url_prefix='/static/', login_url='/login', ) handlers = [ # App url(r"/", DashboardView, name='main'), url(r"/dashboard", DashboardView, name='dashboard'), url(r"/worker/(.+)", WorkerView, name='worker'), url(r"/task/(.+)", TaskView, name='task'), url(r"/tasks", TasksView, name='tasks'), url(r"/tasks/datatable", TasksDataTable), url(r"/broker", BrokerView, name='broker'), # Worker API (r"/api/workers", workers.ListWorkers), (r"/api/worker/shutdown/(.+)", control.WorkerShutDown), (r"/api/worker/pool/restart/(.+)", control.WorkerPoolRestart), (r"/api/worker/pool/grow/(.+)", control.WorkerPoolGrow), (r"/api/worker/pool/shrink/(.+)", control.WorkerPoolShrink), (r"/api/worker/pool/autoscale/(.+)", control.WorkerPoolAutoscale), (r"/api/worker/queue/add-consumer/(.+)", control.WorkerQueueAddConsumer), (r"/api/worker/queue/cancel-consumer/(.+)",
for opt in subject.options: options.append({'id': opt.cid, 'title': opt.title, 'true_answer': opt.correct, 'show_false': ''}) question['option_list'] = options question['category_name'] = CATEGORY_SUBJECT_KNOWLEDGE_DICT.get(subject.category) question['knowledge_first'] = KNOWLEDGE_FIRST_LEVEL_DICT.get(subject.knowledge_first) question['knowledge_second'] = KNOWLEDGE_FIRST_LEVEL_DICT.get(subject.knowledge_second) question['difficulty'] = subject.difficulty question['correct_percent'] = await self.get_correct_percent(subject.cid) title_picture = subject.file_list[0].title if subject.file_list else '' if title_picture: title_picture_url = '%s://%s%s%s%s' % (SERVER_PROTOCOL, SERVER_HOST, STATIC_URL_PREFIX, 'files/', title_picture) else: title_picture_url = '' question['picture_url'] = title_picture_url questions.append(question) return questions URL_MAPPING_LIST = [ url(r'/wechat/applet/testing/questions/', AppletTestingQuestionsHandler, name='wechat_applet_testing_questions'), url(r'/wechat/applet/testing/answers/save/', AppletTestingAnswersSaveHandler, name='wechat_applet_testing_answers_save'), url(r'/wechat/applet/testing/subject/resolving/get/', AppletTestingSubjectResolvingGetHandler, name='wechat_applet_testing_subject_resolving_get') ]
__author__ = 'wangjinkuan' from apps_admin.banner.banner_handler import BannerTypeHandler,\ BannerTypeListHandler,CreateBannerHandler,BannerListHandler from tornado.web import url _handlers = [ url(r'/gzh/ops/create/b_type', BannerTypeHandler, name='create_banner_type'), url(r'/ghz/ops/create/banner', CreateBannerHandler), url(r'/gzh/ops/query/banner/types', BannerTypeListHandler), url(r'/gzh/ops/query/banners', BannerListHandler), ]
"""Webpage urls and handlers""" from tornado.web import url from models.home.handlers import HomeHandler from models.users.handlers import RegisterHandler, LogoutHandler, LoginHandler from models.datasets.handlers import DatasetsHandler from models.ml_models.handlers import MLModelsHandler from models.trained_ml_models.handlers import TrainedMLModelsHandler URL_PATTERNS = [ # Home url(r"/", HomeHandler, name="home"), # Auth url(r"/auth/register", RegisterHandler, name="register"), url(r"/auth/login", LoginHandler, name="login"), url(r"/auth/logout", LogoutHandler, name="logout"), # datasets url(r"/datasets", DatasetsHandler, name="datasets"), # ml_models url(r"/ml_models", MLModelsHandler, name="ml_models"), # trained_ml_models url(r"/trained_ml_models", TrainedMLModelsHandler, name="trained_ml_models"), ]
#!/usr/bin/env python # _*_coding:utf-8_*_ """ @Datetime : 2020/3/9 下午9:52 @Author : Fangyang """ from tornado.web import url from jnpy.WebTrader.apps.dataloader.handler import DataloaderWssHandler dataloader_urls_tuple = ( url('/dataloader', DataloaderWssHandler), ) if __name__ == "__main__": pass
__author__ = 'adrian' from os import listdir, path from tornado.ioloop import IOLoop from tornado.web import RequestHandler, Application, url class BotsListHandler(RequestHandler): def get(self): bots = [{'id': path.splitext(f)[0]} for f in listdir('bots')] self.write(json.dumps(bots)) class BotsHandler(RequestHandler): def get(self, bot_id): try: f = open('bots/%s.py' % bot_id) self.write(f.read()) except IOError as e: self.write(json.dumps({'error': str(e)})) application = Application([ url(r"/rest/bots", BotsListHandler), url(r"/rest/bots/(.+)", BotsHandler), ]) if __name__ == "__main__": application.listen(8888) IOLoop.instance().start()
#!/usr/bin/python3 # -*- coding: utf-8 """ @author: [email protected] @file: urls.py @time: 2020/2/21 18:17 """ from tornado.web import url import handlers.test_kong.views as vw urls = [ url(r"^/v1/test_kong", vw.TestKong), ]
from handlers.auth_handler import LoginHandler, LogoutHandler, SignupHandler from handlers.index_handler import IndexHandler from handlers.user_handler import UsersHandler, UserHandler from handlers.group_handler import GroupsHandler, GroupHandler, GroupUserHandler, GroupEditHandler, GroupMemberAdditionHandler, GroupDeleteHandler from handlers.room_handler import RoomsHandler, RoomHandler, RoomEditHandler, RoomDeleteHandler, RoomSocketHandler, BrainstormingHandler from tornado.web import url url_patterns = ( url(r'/', IndexHandler, name='index'), url(r'/auth/login/', LoginHandler, name='login'), url(r'/auth/logout/', LogoutHandler, name='logout'), url(r'/auth/signup/', SignupHandler, name='signup'), url(r'/users/', UsersHandler, name='users'), url(r'/users/([0-9]+)/', UserHandler, name='user'), url(r'/groups/', GroupsHandler, name='groups'), url(r'/groups/([0-9]+)/', GroupHandler, name='group'), url(r'/groups/([0-9]+)/edit', GroupEditHandler, name='group_edit'), url(r'/groups/([0-9]+)/delete', GroupDeleteHandler, name='group_delete'), url(r'/groups/([0-9]+)/members/', GroupUserHandler, name='group_user'), url(r'/groups/([0-9]+)/search_new_members/', GroupMemberAdditionHandler, name='member_addition'), url(r'/groups/([0-9]+)/rooms/', RoomsHandler, name='rooms'), url(r'/groups/([0-9]+)/rooms/([0-9]+)/', RoomHandler, name='room'), url(r'/groups/([0-9]+)/rooms/([0-9]+)/edit', RoomEditHandler, name='room_edit'), url(r'/groups/([0-9]+)/rooms/([0-9]+)/delete', RoomDeleteHandler, name='room_delete'),
""" # without legacy event self.add_log_event({'msg': 'Hi again!'}, use_legacy_event=False) """ This will insert a record in the database like { "_id" : ObjectId("5bb759395bbc6d4570f892dd"), "msg" : "Hi again!" } """ self.finish() handlers = [ url(r"/", MainPageHandler, name='MainPageHandler'), ] class EventServer(TorskelServer): def __init__(self, handlers, **settings): super().__init__(handlers, **settings) if __name__ == "__main__": my_server = EventServer(handlers, **settings) my_server.listen(8889) loop = asyncio.get_event_loop() my_server.init_with_loop(loop) loop.run_forever() tornado.ioloop.IOLoop.current().start()
def __init__(self, options, database, settings=None): import gprime.const from gprime.utils.locale import Locale, _ self.options = options if settings is None: settings = self.default_settings() if options.language is None: self.glocale = Locale self._ = _ else: self.glocale = Locale(lang=options.language) self._ = self.glocale.translation.gettext self.database = database self.sitename = self.options.sitename super().__init__([ url(r"/", HomeHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="main"), url(r'/login', LoginHandler, { "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="login"), url(r'/logout', LogoutHandler, { "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="logout"), url(r'/(.*)/(.*)/delete', DeleteHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, ), url(r'/action/?(.*)', ActionHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="action"), url(r'/person/?(.*)', PersonHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="person"), url(r'/note/?(.*)', NoteHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="note"), url(r'/family/?(.*)', FamilyHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="family"), url(r'/citation/?(.*)', CitationHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="citation"), url(r'/event/?(.*)', EventHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="event"), url(r'/media/?(.*)', MediaHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="media"), url(r'/place/?(.*)', PlaceHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="place"), url(r'/repository/?(.*)', RepositoryHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="repository"), url(r'/source/?(.*)', SourceHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="source"), url(r'/tag/?(.*)', TagHandler, { "database": self.database, "sitename": self.sitename, "opts" : self.options, "glocale": self.glocale, "_": self._, }, name="tag"), url(r'/imageserver/(.*)', ImageHandler, { "database": self.database, "opts" : self.options, "SITE_DIR": self.options.site_dir, "PORT": self.options.port, "HOSTNAME": self.options.hostname, "GET_IMAGE_FN": self.get_image_path_from_handle, "sitename": self.sitename, "glocale": self.glocale, "_": self._, }, name="imageserver", ), url(r"/json/", JsonHandler, { "database": self.database, } ), url(r"/data/(.*)", StaticFileHandler, { 'path': gprime.const.DATA_DIR, }), url(r"/css/(.*)", StaticFileHandler, { 'path': os.path.join(gprime.const.DATA_DIR, "css"), }), url(r"/js/(.*)", StaticFileHandler, { 'path': os.path.join(gprime.const.DATA_DIR, "javascript"), }), url(r"/images/(.*)", StaticFileHandler, { 'path': gprime.const.IMAGE_DIR, }), url(r"/img/(.*)", StaticFileHandler, # CSS images { 'path': os.path.join(gprime.const.DATA_DIR, "img"), }), ], **settings)
} logger.info('Websocket published to redis: ' + json.dumps(data)) connect.publish('simple-chat', json.dumps(data)) def on_close(self): logger.info('WebSocket closed') websocket_list.remove(self) if __name__ == '__main__': redis_host = os.environ.get('REDIS_HOST', '192.168.33.203') websocket_list = [] connect = redis.StrictRedis(host=redis_host, port=6379) application = tornado.web.Application( [ url(r'/', TopHandler, name='index'), url(r'/internal', InternalHandler, name='internal'), url(r'/ws', WebSocketHandler, name='ws'), url(r'/favicon.ico', tornado.web.StaticFileHandler, {'path': 'favicon.ico'}), ], template_path=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates'), static_path=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static'), ) server = tornado.httpserver.HTTPServer(application) server.listen(80) tornado.ioloop.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 initialize(connection_string): database = MotorClient(connection_string).experiment database.add_son_manipulator(ObjectIdAsTimestamp()) session_status = model.SessionStatus() sessions = model.Sessions(database) seeder = model.Final() snippets = model.Snippets() emails = model.Emails(database) trials = model.Trials(database) template_path = './static/templates/' def static(pattern): return url(pattern, web.Page, dict(path=template_path)) def template(file_, **kwargs): t = dict(path=template_path + '%s' % file_) t.update(kwargs) return t routes = [ url(r'/', web.Home, template('home.html', sessions=sessions, trials=trials)), static(r'/(questions)/?'), static(r'/(tutorial)/?'), static(r'/(experiment)/?'), url(r'/(complete)/?', web.CompletePage, dict(path=template_path)), url(r'/admin/?', web.Admin, template('admin.html', sessions=sessions)), url(r'/admin/login?', web.AdminLogin), url(r'/admin/logout?', web.AdminLogout), url(r'/admin/clear?', web.AdminClearUserCookie), url(r'/api/trial/?', api.Trial, dict(sessions=sessions, trials=trials)), url(r'/api/sessions/?', api.Sessions, dict(sessions=sessions)), #Test url( r'/api/form/?', api.Form, dict(sessions=sessions, session_status=session_status, trials=trials)), # post url(r'/api/email/?', api.EmailForm, dict(emails=emails)), # post url(r'/api/admin/db\.json', api.AdminDbDump, dict(sessions=sessions)), url(r'/api/admin/sessions/?', api.AdminSessions, dict(sessions=sessions)), url(r'/api/admin/emails/?', api.AdminEmails, dict(emails=emails)), url(r'/api/admin/sessions/([\w^/]+)?', api.AdminSessionData, dict(sessions=sessions)), url(r'/api/admin/trials/?', api.AdminTrials, dict(trials=trials, seeder=seeder)), url(r'/api/admin/trials/([\w^/]+)?', api.AdminUpdateTrials, dict(trials=trials)), url(r'/api/admin/duplicates/?', api.Duplicates, dict(sessions=sessions, trials=trials)), url(r'/api/admin/missing/?', api.Missing, dict(sessions=sessions, trials=trials)), url(r'/api/admin/snippets/?', api.AdminSnippets, dict(snippets=snippets)), ] return routes
def static(pattern): return url(pattern, web.Page, dict(path=template_path))
from tornado.web import url import app.message.views as msg handlers = [ url(r'/message', msg.Index, name='message:index'), url(r'/message/inbox', msg.Inbox, name='message:inbox'), url(r'/message/outbox', msg.Outbox, name='message:outbox'), url(r'/message/([0-9]+)', msg.View, name='message:view'), url(r'/message/([0-9]+)/delete', msg.Delete, name='message:delete'), url(r'/message/([0-9]+)/reply', msg.Reply, name='message:reply'), url(r'/message/new', msg.New, name='message:new'), url(r'/message/send_notice', msg.SendNotice, name='message:send_notice'), url(r'/notice', msg.NoticeHome, name='message:notice'), url(r'/notice/([0-9]+)/delete', msg.NoticeDelete, name='message:notice:delete'), ]
def route_patterns(): return [ url(r'^/?$', handlers.IndexHandler, name='index'), url(r'^/deployments/?$', handlers.IndexHandler, name='deployment_list'), url(r'^/deployments/(?P<deployment_id>[^/]+)/?$', handlers.DeploymentDetailHandler, name='deployment_detail'), url(r'^/servers/?$', handlers.ServerListHandler, name='server_list'), url(r'^/servers/(?P<server_id>[^/]+)/?$', handlers.ServerDetailHandler, name='server_detail'), url(r'^/regions/?$', handlers.RegionListHandler, name='region_list'), url(r'^/regions/(?P<region_id>[^/]+)/?$', handlers.RegionDetailHandler, name='region_detail'), url(r'^/game_versions/?$', handlers.GameVersionListHandler, name='game_version_list'), url(r'^/game_versions/(?P<game_version_id>[^/]+)/?$', handlers.GameVersionDetailHandler, name='game_version_detail'), url(r'^/game_rooms/?$', handlers.GameRoomListHandler, name='game_room_list'), url(r'^/game_rooms/(?P<game_room_id>[^/]+)/?$', handlers.GameRoomDetailHandler, name='game_room_detail'), url(r'^/games/?$', handlers.GameListHandler, name='game_list'), url(r'^/games/(?P<game_id>[^/]+)/?$', handlers.GameDetailHandler, name='game_detail'), url(r'^/game_configs/?$', handlers.GameConfigListHandler, name='game_config_list'), url(r'^/game_configs/(?P<game_config_id>[^/]+)/?$', handlers.GameConfigDetailHandler, name='game_config_detail'), url(r'^/log/?$', LogRequestHandler, {'service_name': 'game_master'}, name='log') ]