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 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 __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 __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 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 __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 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()
