def __init__(self): #Initialize mappings manager and set main mappings self.mappings = mappings.Manager(self, API_URL, ADMIN_API_URL) #Initialize main web application here self.app = web.application(self.mappings.get_main_mappings(), fvars=globals()) #All Mappings must be done before web application instance #Admin mappings self.mappings.add_map_resource('/server/admin/app', 'Admin', api_class_prefix=API_CLASS_PREFIX) #Api mappings self.mappings.add_map_resource('/server/api/admin_resources', 'ApiAdminResources', api_class_prefix=API_CLASS_PREFIX) self.mappings.add_map_resource('/server/api/private_resources', 'ApiPrivateResources', api_class_prefix=API_CLASS_PREFIX) self.mappings.add_map_resource('/server/api/public_resources', 'ApiPublicResources', api_class_prefix=API_CLASS_PREFIX) #Site mappings self.mappings.add_map_resource('/server/app', 'Site', api_class_prefix=API_CLASS_PREFIX) #Set new session with initializers db = dbs.DBS.dbStore('mysql') store = web.session.DBStore(db, 'sessions') #Start session self.session = web.session.Session(self.app, store, initializer={ 'userid': 'anonymous', 'priv_lev':'', 'authenticated':False, 'language': quetzal_config['default_language'] } ) #Add login session & language hooks self.app.add_processor(web.loadhook(self.login_session_hook)) self.app.add_processor(web.loadhook(self.language_session_hook))
def run(self): """ 启动网站 """ # 初始化 Common.init(); # 创建web应用 Logger.info('创建web应用') Common.app = web.application(Common.urls, globals()) # 创建session Logger.info('创建session') Common.initSession(Common.app); Common.session.menu = MenuManagement(); # 加载模板 Logger.info('加载模板') Common.render = web.template.render('templates/', base='baseframe', globals={'context': Common.session}) # # 设置错误页面 # Common.app.notfound = Common.notfound # Common.app.internalerror = Common.internalerror # 加载设置 Logger.info('加载设置') # Common.app.add_processor(Common.error_precessor); Common.app.add_processor(web.loadhook(Common.session_hook)); # Common.app.add_processor(web.loadhook(Common.session.menu.setSelectedMenu)); Common.app.add_processor(web.loadhook(AuthorityManagement.checkAuthority)) # Common.app.add_processor(web.unloadhook(AuthorityManagement.checkAuthority)) Logger.debug('网站启动') Common.initFinish = True Common.app.run();
def test_processors(self): urls = ("/(.*)", "blog") class blog: def GET(self, path): return "blog " + path state = web.storage(x=0, y=0) def f(): state.x += 1 app_blog = web.application(urls, locals()) app_blog.add_processor(web.loadhook(f)) # fmt: off urls = ("/blog", app_blog, "/(.*)", "index") # fmt: on class index: def GET(self, path): return "hello " + path app = web.application(urls, locals()) def g(): state.y += 1 app.add_processor(web.loadhook(g)) app.request("/blog/foo") assert state.x == 1 and state.y == 1, repr(state) app.request("/foo") assert state.x == 1 and state.y == 2, repr(state)
def __init__(self, mapping, fvars): # Parent constructor web.application.__init__(self, mapping, fvars) #@UndefinedVariable # The views are bound once for all to the configuration config.views = web.template.render("app/views/", globals={ "all_seasons": lambda: Season.all(), "all_polls": lambda: Poll.all(), "webparts": webparts, "formatting": formatting, "dates": dates, "zip": zip, "getattr": getattr, "hasattr": hasattr, "class_name": lambda x: x.__class__.__name__, "namedtuple": collections.namedtuple, "config": config, "result_statuses": Result.STATUSES, "Events": Events }) # The ORM is bound once since it dynamically loads the engine from the configuration config.orm = meta.init_orm(lambda : config.engine) # Binds the hooking mechanism & the SQL Alchemy processor self.add_processor(web.loadhook(http.init_hooks)) self.add_processor(web.unloadhook(http.execute_hooks)) self.add_processor(http.sqlalchemy_processor) # Binds the webparts initialization mechanism self.add_processor(web.loadhook(webparts.init_webparts))
def app_factory(): """App factory.""" from app.database import create_session from app.logging import create_logger from app.tools.app_processors import load_logger from app.tools.app_processors import load_path_url from app.tools.app_processors import load_render from app.tools.app_processors import load_session from app.tools.app_processors import load_sqla from app.urls import URLS views = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'views') app = web.application(URLS, globals()) dbpath = web.config.DATABASE_URL.replace('sqlite:///', '') db = web.database(dbn='sqlite', db=dbpath) session = web.session.Session(app, web.session.DBStore(db, 'session')) app.add_processor(web.loadhook(load_path_url)) app.add_processor( web.loadhook(load_logger(lambda: create_logger(web.config)))) app.add_processor(web.loadhook(load_render(views))) app.add_processor(web.loadhook(load_session(session))) app.add_processor(load_sqla(create_session())) return app
def test_processors(self): urls = ( "/(.*)", "blog" ) class blog: def GET(self, path): return 'blog ' + path state = web.storage(x=0, y=0) def f(): state.x += 1 app_blog = web.application(urls, locals()) app_blog.add_processor(web.loadhook(f)) urls = ( "/blog", app_blog, "/(.*)", "index" ) class index: def GET(self, path): return "hello " + path app = web.application(urls, locals()) def g(): state.y += 1 app.add_processor(web.loadhook(g)) app.request('/blog/foo') assert state.x == 1 and state.y == 1, repr(state) app.request('/foo') assert state.x == 1 and state.y == 2, repr(state)
def setUp(self): ''' :return: ''' settings.DEBUG = True ''' 配置测试用的redis配置信息 ''' settings.REDIS_HOST = "localhost" settings.REDIS_PORT = 8911 # settings.REDIS_DB = 0 ''' redisco连接 ''' settings.rd = redisco.connection_setup(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB) # ''' 额外的redis连接 ''' self.redis = redis.StrictRedis(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB) ''' 启动服务 ''' web.config.debug = settings.DEBUG self.appM = web.application(URLS, HANDLER, autoreload=False) application = self.appM.wsgifunc() self.appM.notfound = notfound self.appM.internalerror = internalerror self.appM.add_processor(web.loadhook(header_html)) session.init( web.session.Session( self.appM, web.session.DiskStore('sessions'), initializer=Initializer( User=models.user.User, UserGroup=models.usergroup.UserGroup, BanLogin=controllers.login_handler.BanLogin, settings=settings, session=session, ))) ''' 校验session, 添加到app的 processor 流程中,顺序需要在 session初始化之后 ''' self.appM.add_processor(web.loadhook(verify_session)) ''' 初始化 html 头, 添加到app的 processor 流程中 ''' self.appM.add_processor(web.loadhook(header_html)) web.config.session_parameters['cookie_name'] = 'webpy_session_id' web.config.session_parameters['cookie_domain'] = None web.config.session_parameters['timeout'] = 10 web.config.session_parameters['ignore_expiry'] = True web.config.session_parameters['ignore_change_ip'] = False web.config.session_parameters['secret_key'] = 'akdnA0FJsdJFLSlvno92' web.config.session_parameters['expired_message'] = 'Session expired'
def main(): """ Main setup function """ def urlr(exp): return virtual_root + exp + "/*" # Redirect workarounds if enabled if config.ini.getboolean("cgi", "redirect-workaround"): os.environ["SCRIPT_NAME"] = '' os.environ["REAL_SCRIPT_NAME"] = '' web.config.debug = config.ini.getboolean("cgi", "web-debug-mode") web.config.session_parameters["timeout"] = config.ini.getint( "http", "session-timeout") web.config.session_parameters["cookie_name"] = config.ini.get( "http", "session-cookie-name") if config.ini.getboolean("cgi", "fastcgi"): web.wsgi.runwsgi = lambda func, addr=None: web.wsgi.runfcgi(func, addr) steam.api.key.set(config.ini.get("steam", "api-key")) # Cache file stuff cache_dir = config.ini.get("resources", "cache-dir") if not os.path.exists(cache_dir): os.makedirs(cache_dir) urls = (virtual_root + "api", api_views.subapplication, urlr("inv/(?:user/)?(.+)"), "optf2.inventory_views.sim_selector", urlr(""), "optf2.views.index", urlr("about"), "optf2.views.about", urlr("(\w+)/items"), "optf2.schema_views.items", urlr("(\w+)/attributes/?(\d*)"), "optf2.schema_views.attributes", urlr("(\w+)/particles"), "optf2.schema_views.particles", urlr("(\w+)/item/(-?\d+)"), "optf2.inventory_views.item", urlr("(\w+)/item/(\w+)/(-?\d+)"), "optf2.inventory_views.live_item", urlr("(\w+)/loadout/(\w+)/?(\d*)"), "optf2.inventory_views.loadout", urlr("(\w+)/feed/(.+)"), "optf2.inventory_views.feed", urlr("(\w+)/(?:user/)?(.+)"), "optf2.inventory_views.fetch") application = web.application(urls, globals()) application.notfound = notfound if not config.ini.getboolean("cgi", "web-debug-mode"): application.internalerror = internalerror application.add_processor(web.loadhook(lang_hook)) application.add_processor(web.loadhook(motd_hook)) application.add_processor(web.loadhook(conf_hook)) return application
def run_web_server(self): self.render = web.template.render('templates/') urls = ( '/', 'Home', '/api/color', 'API_Color', '/api/brightness', 'API_Brightness' ) self.app = web.application(urls, globals()) self.app.add_processor(web.loadhook(self.load_plasma_trim)) self.app.add_processor(web.loadhook(self.load_renderer)) self.app.add_processor(web.loadhook(self.load_main_thread_queue)) self.web_server_thread = Thread(None, self.app.run) self.web_server_thread.start()
def setUp(self): ''' :return: ''' settings.IS_UNITTEST = True settings.DEBUG = True ''' 配置测试用的redis配置信息 ''' settings.REDIS_HOST = "localhost" # settings.REDIS_PORT = 8911 # settings.REDIS_DB = 0 ''' redisco连接 ''' settings.rd = redisco.connection_setup(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB) # ''' 额外的redis连接 ''' self.redis = redis.StrictRedis(host=settings.REDIS_HOST, port=settings.REDIS_PORT, db=settings.REDIS_DB) ''' 启动服务 ''' web.config.debug = settings.DEBUG self.appM = web.application(URLS, HANDLER, autoreload=False) application = self.appM.wsgifunc() self.appM.notfound = notfound self.appM.internalerror = internalerror self.appM.add_processor(web.loadhook(header_html)) session.init(web.session.Session(self.appM, web.session.DiskStore('sessions'), initializer=Initializer( User=models.user.User, UserGroup=models.usergroup.UserGroup, BanLogin=controllers.login_handler.BanLogin, settings=settings, session=session, )) ) ''' 校验session, 添加到app的 processor 流程中,顺序需要在 session初始化之后 ''' self.appM.add_processor(web.loadhook(verify_session)) ''' 初始化 html 头, 添加到app的 processor 流程中 ''' self.appM.add_processor(web.loadhook(header_html)) web.config.session_parameters['cookie_name'] = 'webpy_session_id' web.config.session_parameters['cookie_domain'] = None web.config.session_parameters['timeout'] = 10 web.config.session_parameters['ignore_expiry'] = True web.config.session_parameters['ignore_change_ip'] = False web.config.session_parameters['secret_key'] = 'akdnA0FJsdJFLSlvno92' web.config.session_parameters['expired_message'] = 'Session expired'
def test_hook(self): app.add_processor(web.loadhook(before)) app.add_processor(web.unloadhook(after)) self.assertEqual(app.request('/hello').data, 'yx') global str self.assertEqual(str, 'yxz')
def init_app(): app = web.application(urls, globals()) #app.notfound = api_notfound #app.internalerror = api_internalerror app.add_processor(web.loadhook(api_loadhook)) app.add_processor(web.unloadhook(api_unloadhook)) return app
def web_thread(): web.config.debug = False urls = ( '/index.html','index', '/login.html','login', '/webui/(.+)/','webui', '/api/(.+)/','api', '(.+)','not_found' ) app = web.application(urls, globals()) #定义seesion模型 store = web.session.DBStore(web_db, 'sessions') session = web.session.Session(app, store, initializer = { "logged_in": False }) #hook seesion到所有的子应用 def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook)) app.run()
def __new__(cls, *args, **kwargs): app = web.application(*args, **kwargs) app.add_processor(web.loadhook(cls._connect)) app.add_processor(web.unloadhook(cls._disconnect)) return app
def application(urls, env): ''' A pythonic web.py application def hello(ctx, name): if not name: name = 'World' return 'Hello, ' + name + '!' urls = ('GET', '/(.*)', hello) app = application(urls, locals()) ''' def webpy_handler_class(method, pattern, handler): ''' convert functional view to class based view consumable by rest of webpy ''' class _Handler: pass def wrap(_handler): def wrapped(self, *args, **kwargs): return _handler(web.ctx, *args, **kwargs) return wrapped _Handler.__dict__[method] = wrap(handler) env[handler.__name__] = _Handler return pattern, handler.__name__ def compile_to_webpy(urls): ''' convert to webpy format ''' return [component for method, pattern, handler in urls for component in webpy_handler_class(method, pattern, handler) ] app = web.application(compile_to_webpy(chunk_urls(urls)), env) app.add_processor(web.loadhook(hook_less(app))) return app
def __init__(self, app): self.main_app = app self.session = web.session.Session(self.main_app, web.session.DiskStore('sessions')) def session_hook(): web.ctx.session = self.session self.main_app.add_processor(web.loadhook(session_hook))
class job_cancel: class app.add_processor(web.loadhook(hasmaster)) app.add_processor(ishuman) if __name__ == "__main__": app.run()
def setup_rendering(): html = partial(web.template.render, '%s/templates/' % _path) slender = html(globals=env) render = html(base='base', globals=env) def render_hook(): web.ctx.render = render web.ctx.slender = slender app.add_processor(web.loadhook(render_hook)) env['render'] = slender
def main(): urls = [ "/", TodosCollection, "/(.+)", TodoItem ] app = web.application(urls, globals()) app.add_processor(web.loadhook(cors_headers)) app.run()
def start_wsgi(): common.load_plugins() constants.init_urls() app = web.application(constants.urls, globals()) check_database() create_session(app) for hook in constants.plugin_hooks_server_start: hook() app.add_processor(web.loadhook(localization_hook)) return app.wsgifunc(httpserver.PluginStaticMiddleware)
def init_sessions(web, app, store, session): """kwargs is used to inject options like 'cart' into session.""" web.config.session_parameters['ignore_expiry'] = True session = web.session.Session(app, store, initializer=session) def inject_session(): """closure; uncalled function which wraps session is passed to the web loadhook and invoked elsewhere and at a later point in time """ web.ctx.session = session app.add_processor(web.loadhook(inject_session)) return session
class filetype: def add: def remove: class fetchall_page: def GET(self): app.add_processor(web.loadhook(ckauth_proc)) if __name__ == "__main__": app.run()
def run(self): ''' \brief Start the web server. ''' global session global sessionStore # log log.debug("starting server") # disable debug mode (which prevents sessions) web.config.debug = False # enable SSL, if required if self.keyFile and self.certFile: from web.wsgiserver import CherryPyWSGIServer CherryPyWSGIServer.ssl_private_key = self.keyFile CherryPyWSGIServer.ssl_certificate = self.certFile log.debug("enable SSL") # create main application self.webApp = web.application(self.getMappingUrlToHandlerName(), self.getHandlerNameToHandlerClass()) ''' for i in range(0,len(self.getMappingUrlToHandlerName()),2): print '{0} -> {1}'.format(self.getMappingUrlToHandlerName()[i],self.getMappingUrlToHandlerName()[i+1]) ''' # customize error handling #self.webApp.notfound = self._notfound #self.webApp.internalerror = self._internalerror # enable sessions web.config.session_parameters['cookie_name'] = 'dustLink_session_id' web.config.session_parameters['ignore_change_ip'] = False sessionStore = MemSessionStore.MemSessionStore() session = web.session.Session(self.webApp, sessionStore, initializer={'username': self.defaultUsername}) self.webApp.add_processor(web.loadhook(self._session_hook)) self.wsgifunc = self.webApp.wsgifunc() self.wsgifunc = web.httpserver.StaticMiddleware(self.wsgifunc) self.webserver = web.httpserver.WSGIServer(('0.0.0.0', 8080), self.wsgifunc) # start server self.webserver.start() # you reach this line once the server has been stopped # log log.debug("server stopped")
def create_application(): '''Initializes web.py application''' app = Application(urls, globals()) # Session initialization if web.config.get('_session') is None: # this is required to work with reloader web.config._session = web.session.Session( app, DBUserStore(db, 'sessions'), dict(forms={}), ) app.add_processor(web.loadhook(load_hook)) return app
def add_sessions_to_app(app): import os db = web.database(dbn='sqlite', db=os.path.join(site['db'], 'session.db')) store = web.session.DBStore(db, 'session') session = web.session.Session(app, store, initializer={ 'loggedin': False, 'username': ''}) def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook))
def createsession(): print 'createsession' db = myutil.db if db is None: print 'db error' sessiondb = web.session.DBStore(db, 'sessions') session = web.session.Session(app, sessiondb, initializer={"privilege": -1, "authcode": pic.picChecker().getPicString()}) def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook))
def app_factory(): """App factory.""" import weblib.db from app.urls import URLS from app.weblib.app_processors import load_logger from app.weblib.app_processors import load_path_url from app.weblib.app_processors import load_render from app.weblib.app_processors import load_session from app.weblib.app_processors import load_and_manage_orm views = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'views') app = web.application(URLS, globals()) dbpath = web.config.DATABASE_URL.replace('sqlite:///', '') db = web.database(dbn='sqlite', db=dbpath) session = web.session.Session(app, web.session.DBStore(db, 'session')) app.add_processor(web.loadhook(load_logger)) app.add_processor(web.loadhook(load_path_url)) app.add_processor(web.loadhook(load_render(views))) app.add_processor(web.loadhook(load_session(session))) app.add_processor(load_and_manage_orm(weblib.db.create_session())) return app
def main(args): def before_request(): """ " Called before handling each HTTP request. Inserts application variables " such as the name of the indices and elasticsearch client into web context. """ web.ctx['W2V4_ELASTICSEARCH'] = get_es_client(args.elasticsearch_url) web.ctx['W2V4_FACEBOOK_INDEX'] = args.facebook_index web.ctx['W2V4_OFFICIAL_INDEX'] = args.official_index web.ctx['W2V4_NYT_INDEX'] = args.nyt_index web.ctx['W2V4_TWITTER_INDEX'] = args.twitter_index web.ctx['W2V4_SENTIMENT_WEIGHT'] = args.sent_weight #end if # map paths to class names of request handlers mapping = ( '/','IndexView', '/(.+).html','HTMLView', '/document/(.+)/(.+)','Document', '/api/tool1/positions','Positions', '/api/tool2/question','QA', '/api/normalizer','NameNormalizer', '/api/whois','WhoIs', '/api/echo', 'Echo' ) indices = [ args.official_index, args.facebook_index, args.nyt_index, args.twitter_index ] # create application app = web.application(mapping,globals()) app.add_processor(web.loadhook(before_request)) func = app.wsgifunc() # run webserver on port specified by user if not args.testing: es = get_es_client(args.elasticsearch_url) open_indices(es,indices) web.httpserver.runsimple(func, ('localhost',args.port)) close_indices(es,indices) #end if return app
def setup(): """ This function is called from the main application startup routine to set things up. """ # Initialise the stats filters register_filter("all", stats_filters.all) register_filter("url", stats_filters.url) register_filter("loggedin", stats_filters.loggedin) register_filter("not_loggedin", stats_filters.not_loggedin) delegate.app.add_processor(web.loadhook(page_load_hook)) delegate.app.add_processor(web.unloadhook(page_unload_hook)) delegate.add_exception_hook(lambda: increment_error_count('ol.exceptions'))
def createprocessor(): createsession() def pre_hook(): mylog.loginfo() app.add_processor(web.loadhook(pre_hook)) def post_hook(): if web.ctx.fullpath[0:6] == "/rest/": if web.ctx.fullpath[6:14] != "resource" \ and web.ctx.fullpath[6:11] != "photo": web.header("content-type", "application/json") else: return else: web.header("content-type", "text/html; charset=utf-8") app.add_processor(web.unloadhook(post_hook))
def start_server(port): # some of the following lines are commented out because start_wsgi() # is run already when this module is loaded # TODO: make the above excuse removable # common.load_plugins() web.httpserver.StaticApp = httpserver.StaticApp # constants.init_urls() app = web.application(constants.urls, globals()) #check_database() #create_session(app) #for hook in constants.plugin_hooks_server_start: # hook() app.add_processor(web.loadhook(localization_hook)) httpserver.runwsgi(app.wsgifunc(httpserver.PluginStaticMiddleware), port) for hook in constants.plugin_hooks_server_stop: hook()
def init_session(app, session_dir, sessionid_name, initializer={'ip': 0, 'agent': 0}): """ Init sesstion, extend the original init process to make session shared by sub-app """ web.config.session_parameters['cookie_name'] = sessionid_name store = web.session.DiskStore(session_dir) session = web.session.Session(app, store, initializer) # make session avaliable to share in sub-app def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook)) return session
def setup_waltz(): def fcgi(func, addr=None): """nginx with spawn-fcgi""" return web.wsgi.runfcgi(func, addr) web.config.debug = debug if debug: PeriodicReloader() if kwargs.get('fcgi'): web.wsgi.runwsgi = fcgi db = kwargs.get('db', "%s/db" % _path) lgr = kwargs.get('logging', '%s/events.log' % _path) def waltz_hook(): web.ctx.waltz = {"debug": debug, "db": db, "logging": lgr } app.add_processor(web.loadhook(waltz_hook))
def get_session(app): """ 获取session :param app: :return: """ if web.config.get('_session') is None: session = web.session.Session(app, web.session.DiskStore('sessions')) web.config._session = session else: session = web.config._session def session_hook(): web.ctx.session = session # 使session可以在模板中使用 # web.template.Template.globals['session'] = session app.add_processor(web.loadhook(session_hook)) return session
def test_get_doc_type(self): from utils import get_doc_type def check_doc_types(): # check correct doc type is associated with correct index name self.assertEqual(get_doc_type('fb'),'fb_post') self.assertEqual(get_doc_type('nyt'),'article') self.assertEqual(get_doc_type('twitter'),'tweet') self.assertEqual(get_doc_type('official'),'webpage') #end before_request self.app.add_processor(web.loadhook(check_doc_types)) # Need make a request in order to check document types # web.ctx is visible in processors res = self.app.request('/document/nyt/1') self.assertEqual(res.status,"200 OK")
class index: def my_processor(handler): print('before handling') print('after handling') handler = 'hi' result = handler print(result) return result app.add_processor(my_processor) def my_loadhook(): web.header('Content-type', "text/html; charset=utf-8") input = web.input() print(input) def my_unloadhook(): print("my unload hook") app.add_processor(web.loadhook(my_loadhook)) app.add_processor(web.unloadhook(my_unloadhook))
def create_app(): """App factory.""" from app.database import create_session from app.logging import create_logger from app.tools.app_processor import load_keyvalue from app.tools.app_processor import load_logger from app.tools.app_processor import load_path_url from app.tools.app_processor import load_render from app.tools.app_processor import load_session from app.tools.app_processor import load_sqla from app.tools.app_processor import manage_content_exceptions from app.export import ExportManager from app.upload import UploadManager from app.urls import URLS workingdir = os.getcwd() views = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'views') app = web.application(URLS, globals()) dbpath = web.config.db.replace('sqlite:///', '') db = web.database(dbn='sqlite', db=dbpath) session = web.session.Session(app, web.session.DBStore(db, 'session')) uploadman = UploadManager(config.UPLOAD_DIR, workingdir) avatarman = UploadManager(config.AVATAR_DIR, workingdir) exportman = ExportManager(workingdir) app.add_processor(web.loadhook(load_path_url)) app.add_processor(web.loadhook(load_logger(create_logger(web.config)))) app.add_processor(web.loadhook(load_render(views))) app.add_processor(web.loadhook(load_session(session))) app.add_processor(web.loadhook(load_keyvalue('uploadman', uploadman))) app.add_processor(web.loadhook(load_keyvalue('avatarman', avatarman))) app.add_processor(web.loadhook(load_keyvalue('exportman', exportman))) app.add_processor(load_sqla(create_session())) app.add_processor(manage_content_exceptions) return app
:param X-Rucio-Auth-Account: Account identifier. :param X-Rucio-Auth-Token: As an 32 character hex string. :param account: Account name. :param rse: RSE name. """ try: delete_account_limit(account=account, rse=rse, issuer=ctx.env.get('issuer')) except AccessDenied as exception: raise generate_http_error(401, 'AccessDenied', exception.args[0]) except AccountNotFound as exception: raise generate_http_error(404, 'AccountNotFound', exception.args[0]) except RSENotFound as exception: raise generate_http_error(404, 'RSENotFound', exception.args[0]) except Exception as exception: print format_exc() raise InternalError(exception) raise OK() # ---------------------- # Web service startup # ---------------------- APP = application(URLS, globals()) APP.add_processor(loadhook(rucio_loadhook)) application = APP.wsgifunc()
web.header('Content-Type', out.content_type) if hasattr(out, 'rawtext'): html = out.rawtext else: html = view.render_site(config.site, out) # cleanup references to avoid memory leaks web.ctx.site._cache.clear() web.ctx.pop('site', None) web.ctx.env = {} context.clear() return html app.add_processor(web.loadhook(initialize_context)) app.add_processor(layout_processor) app.add_processor(web.loadhook(features.loadhook)) class RawText(web.storage): def __init__(self, text, **kw): web.storage.__init__(self, rawtext=text, **kw) plugins = [] @view.public def get_plugins(): """Return names of all the plugins.""" return [p.name for p in plugins] def _make_plugin(name): # plugin can be present in infogami/plugins directory or <pwd>/plugins directory.
Retrieve a subscription matching the given subscription id HTTP Success: 200 OK HTTP Error: 401 Unauthorized 404 Not Found """ header('Content-Type', 'application/json') try: subscription = get_subscription_by_id(subscription_id) except SubscriptionNotFound, e: raise generate_http_error(404, 'SubscriptionNotFound', e.args[0][0]) except RucioException, e: raise generate_http_error(500, e.__class__.__name__, e.args[0]) except Exception, e: raise InternalError(e) return render_json(**subscription) """---------------------- Web service startup ----------------------""" app = application(urls, globals()) app.add_processor(loadhook(rucio_loadhook)) application = app.wsgifunc()
class Code: def POST(self): data = web.input() # code = data.code print(data) all_key = data.code.split(',') all_code = [] for key in all_key: all_code.append(cal_google_code(key)) return json.dumps(all_code) def OPTIONS(self): pass def customhook(): web.header('Access-Control-Allow-Origin', '*') web.header( 'Access-Control-Allow-Headers', 'Content-Type, Access-Control-Allow-Origin, ' 'Access-Control-Allow-Headers, X-Requested-By, ' 'Access-Control-Allow-Methods') web.header('Access-Control-Allow-Methods', 'POST, GET, PUT, DELETE') if __name__ == "__main__": app = web.application(urls, globals()) app.add_processor(web.loadhook(customhook)) app.run()
from app.controllers import db, put_session, put_app logging.basicConfig(format='%(asctime)s:%(levelname)s:%(message)s', filename='/tmp/fcapp-web.log', datefmt='%Y-%m-%d %I:%M:%S', level=logging.DEBUG) web.config.debug = DEBUG app = web.application(URLS, globals(), autoreload=False) # store = web.session.DBStore(db, 'sessions') store = web.session.DiskStore('sessions') session = web.session.Session(app, store, initializer={'loggedin': False}) put_session(session) app.notfound = notfound app.internalerror = internalerror app.add_processor(web.loadhook(header_html)) def is_test(): if 'WEBPY_ENV' in os.environ: return os.environ['WEBPY_ENV'] == 'test' if (not is_test()) and __name__ == '__main__': put_app(app) app.run() application = app.wsgifunc()
# coding:utf-8 """ Created on 2017-02-16 @author: ysw """ import web import urls from module import interceptors def interceptor(): interceptors.interceptorHook(urls.interceptors) app = web.application(urls.urls, locals()) app.add_processor(web.loadhook(interceptor))
) except Exception: pass return None # Log error message. default log to sys.stderr. def log_error(*args): for s in args: try: print >> sys.stderr, web.safestr(s) except Exception, e: print >> sys.stderr, e # Load hooks app.add_processor(web.loadhook(hook_lang)) # Mail 500 error to webmaster. if settings.MAIL_ERROR_TO_WEBMASTER: app.internalerror = web.emailerrors(settings.webmaster, web.webapi._InternalError) # Store objects in 'web' module. web.app = app web.render = render_template web.logger = log_into_sql web.log_error = log_error web.session.SessionExpired = SessionExpired
def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook))
urls = ("/", "server", "/_echo", "echo", r"/([^_/][^/]*)", "db", r"/([^/]*)/get", "withkey", r"/([^/]*)/get_many", "get_many", r'/([^/]*)/save(/.*)', 'save', r'/([^/]*)/save_many', 'save_many', r"/([^/]*)/reindex", "reindex", r"/([^/]*)/new_key", "new_key", r"/([^/]*)/things", "things", r"/([^/]*)/versions", "versions", r"/([^/]*)/write", "write", r"/([^/]*)/account/(.*)", "account", r"/([^/]*)/permission", "permission", r"/([^/]*)/log/(\d\d\d\d-\d\d-\d\d:\d+)", "readlog", r"/([^/]*)/_store/(_.*)", "store_special", r"/([^/]*)/_store/(.*)", "store", r"/([^/]*)/_seq/(.*)", "seq", r"/([^/]*)/_recentchanges", "recentchanges", r"/([^/]*)/_recentchanges/(\d+)", "change", "/_invalidate", "invalidate") app = web.application(urls, globals(), autoreload=False) app.add_processor(web.loadhook(setup_remoteip)) app.add_processor(web.loadhook(cache.loadhook)) app.add_processor(web.unloadhook(cache.unloadhook)) def process_exception(e): if isinstance(e, common.InfobaseException): status = e.status else: status = "500 Internal Server Error" msg = str(e) raise web.HTTPError(status, {}, msg) class JSON:
web.ctx.site._cache.clear() web.ctx.pop('site', None) web.ctx.env = {} context.clear() return html def notfound(path=None, create=True): from infogami.utils import template path = path or web.ctx.path html = template.render_template("notfound", path, create=create) return web.notfound(render_site(config.site, html)) app.add_processor(web.loadhook(initialize_context)) app.add_processor(layout_processor) app.add_processor(web.loadhook(features.loadhook)) app.notfound = notfound class RawText(web.storage): def __init__(self, text, **kw): web.storage.__init__(self, rawtext=text, **kw) plugins = [] @public def get_plugins():
def internalerror(): "500" import settings return web.internalerror( str(settings.RENDER.internalerror(show_stats=False))) def loadhook(): web.ctx.session = web.config._session web.ctx.settings = settings web.ctx.params = {} web.ctx.config = config.config web.ctx.cache = cache.manager bm = web.application(urls, locals()) bm.add_processor(web.loadhook(loadhook)) # 初始化session session.session_init(bm) # 初始化模板 template.init({ #'skin': skin.manager, 'settings': settings, 'debug': web.config.debug, 'ctx': web.ctx, 'utils': utils, 'api': api, })
return json.dumps({"success": True}) urls = ("/?", "Index", "/dl/(.*)", "Download", "/help", "Help", "/mkdir/(.*)", "Mkdir", "/nodes", "Nodes", "/odp", "Odp", "/rm/(.*)", "Rm", "/rmdir/(.*)", "Rmdir", "/s/(.*)", "Search", "/upload", "Upload" ) def db_load_hook(): web.ctx.db = DB(os.path.join(config["juno-base"], ".db")) def db_unload_hook(): web.ctx.db.close() web.config.debug = False app = web.application(urls, globals()) app.add_processor(web.loadhook(db_load_hook)) app.add_processor(web.unloadhook(db_unload_hook)) application = app.wsgifunc() config = common.load_config() if __name__ == "__main__": app.run()
import web import settings from models.utils import Version from views import ( urls, views, ) web.config.debug = settings.DEBUG app = web.application(urls, views) def set_version(): web.ctx.version = Version.version app.add_processor(web.loadhook(set_version)) application = app.wsgifunc() if __name__ == "__main__": app.run()
#encoding:utf-8 #import os #os.path.join (os.path.dirname(os.path.abspath(__file__))) import web import urls urls = urls.urls web.config.debug = False app = web.application(urls, globals()) if web.config.get('_session') is None: session = web.session.Session(app, web.session.DiskStore('sessions')) web.config._session = session else: session = web.config._session def session_hook(): web.ctx.session = session app.add_processor(web.loadhook(session_hook)) if __name__ == "__main__": app.run()
post_params = web.input() MM = post_params['MM'] dd = post_params['dd'] yyyy = post_params['yyyy'] HH = post_params['HH'] mm = post_params['mm'] ss = post_params['ss'] enter_name = post_params['entername'] selected_time = '%s-%s-%s %s:%s:%s' % (yyyy, MM, dd, HH, mm, ss) update_message = '(Hello, %s. Previously selected time was: %s.)' % (enter_name, selected_time) # TODO: save the selected time as the current time in the database result, msg = sqlitedb.changeTime(selected_time) if result == -1: return render_template('select_time.html', message=msg) # Here, we assign `update_message' to `message', which means # we'll refer to it in our template as `message' return render_template('select_time.html', message = update_message) ########################################################################################### ##########################DO NOT CHANGE ANYTHING BELOW THIS LINE!########################## ########################################################################################### if __name__ == '__main__': web.internalerror = web.debugerror app = web.application(urls, globals()) app.add_processor(web.loadhook(sqlitedb.enforceForeignKey)) app.run()