Esempio n. 1
0
    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
        )
Esempio n. 2
0
File: app.py Progetto: tobgu/qcache
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],
    )
Esempio n. 3
0
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()
Esempio n. 4
0
def start_http_server(port):
    application = Application([
        url(r'/health', HealthHandler),
        url(r'/metrics', MetricsHandler),
        url(r'/connectors', ConnectorsHandler)
    ])
    HTTPServer(application).listen(port)
Esempio n. 5
0
 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}
Esempio n. 6
0
def create_app(version):
    app0 = Application([ url(r"/", TestHandler0), ])
    app1 = Application([ url(r"/", TestHandler1), ])
    if version == "0":
        return app0
    elif version == "1":
        return app1
Esempio n. 7
0
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)
Esempio n. 8
0
    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")
Esempio n. 9
0
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()
Esempio n. 10
0
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()
Esempio n. 11
0
def make_app():
    return Application([
            url(r'/ptz/help', HelpHandler),
            url(r"/ptz/config(/?)", GetConfigHandler),
            url(r'/ptz/([^\/]+)/([^\/]+)/([^\?]+)', ControllingHandler),
            url(r'/ptz/internal', InternalHandler),
            ])
Esempio n. 12
0
  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)
Esempio n. 13
0
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()
Esempio n. 14
0
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()
Esempio n. 15
0
File: main.py Progetto: yxy/liveimg
 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)
Esempio n. 16
0
    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)
Esempio n. 17
0
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()
Esempio n. 18
0
    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)
Esempio n. 19
0
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
        )
Esempio n. 21
0
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
Esempio n. 22
0
    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)
Esempio n. 23
0
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()
Esempio n. 24
0
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()
Esempio n. 25
0
    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()
Esempio n. 26
0
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,
    )
Esempio n. 27
0
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
Esempio n. 28
0
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),
    ])
Esempio n. 29
0
    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) 
Esempio n. 30
0
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()
Esempio n. 31
0
 def get_app(self):
     return Application([
         url("/hello", HelloWorldHandler),
     ])
Esempio n. 32
0
 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)
Esempio n. 33
0
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),
Esempio n. 34
0
 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)
Esempio n. 35
0
# !/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'),
]
Esempio n. 36
0
# 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)
]
Esempio n. 37
0
    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()
Esempio n. 38
0
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()
Esempio n. 39
0
# 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"),
]
Esempio n. 40
0
            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),
Esempio n. 41
0
from tornado.web import url
from . import views

handlers = [
#    url( r'/register', views.RegisterApply, name='register'),
    url( r'/register', views.Register, name='register'),
]
Esempio n. 42
0
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),
)
Esempio n. 43
0
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'),
]
Esempio n. 44
0
                    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),
]
Esempio n. 45
0
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/(.+)",
Esempio n. 46
0
            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')
]
Esempio n. 47
0
__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),
]
Esempio n. 48
0
"""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"),
]
Esempio n. 49
0
#!/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
Esempio n. 50
0
__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()
Esempio n. 51
0
#!/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),
]
Esempio n. 52
0
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'),
Esempio n. 53
0
        """

        # 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()
Esempio n. 54
0
 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)
Esempio n. 55
0
        }

        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')
Esempio n. 57
0
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
Esempio n. 58
0
 def static(pattern):
     return url(pattern, web.Page, dict(path=template_path))
Esempio n. 59
0
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'),
]
Esempio n. 60
0
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')
    ]