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

 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

 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 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 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 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 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