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, 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 testUnload(self):
        x = web.storage(a=0)

        urls = ("/foo", "foo", "/bar", "bar")

        class foo:
            def GET(self):
                return "foo"

        class bar:
            def GET(self):
                raise web.notfound()

        app = web.application(urls, locals())

        def unload():
            x.a += 1

        app.add_processor(web.unloadhook(unload))

        app.request("/foo")
        self.assertEquals(x.a, 1)

        app.request("/bar")
        self.assertEquals(x.a, 2)

def setup():
    import home, inlibrary, borrow_home, libraries, stats, support, events, status, merge_editions, authors
    
    home.setup()
    inlibrary.setup()
    borrow_home.setup()
    libraries.setup()
    stats.setup()
    support.setup()
    events.setup()
    status.setup()
    merge_editions.setup()
    authors.setup()
    
    import api
    api.setup()
    
    from stats import stats_hook
    delegate.app.add_processor(web.unloadhook(stats_hook))
    
    if infogami.config.get("dev_instance") is True:
        import dev_instance
        dev_instance.setup()

    setup_template_globals()
    setup_logging()
    logger = logging.getLogger("openlibrary")
    logger.info("Application init")

def setup():
    import home, inlibrary, borrow_home, libraries, stats, support, \
        events, status, merge_editions, authors

    home.setup()
    inlibrary.setup()
    borrow_home.setup()
    libraries.setup()
    stats.setup()
    support.setup()
    events.setup()
    status.setup()
    merge_editions.setup()
    authors.setup()

    import api
    from stats import stats_hook
    delegate.app.add_processor(web.unloadhook(stats_hook))

    if infogami.config.get("dev_instance") is True:
        import dev_instance
        dev_instance.setup()

    setup_context_defaults()
    setup_template_globals()

def setup():
    from openlibrary.plugins.openlibrary import (home, inlibrary, borrow_home, libraries,
                                                 stats, support, events, design, status,
                                                 merge_editions, authors)

    home.setup()
    design.setup()
    inlibrary.setup()
    borrow_home.setup()
    libraries.setup()
    stats.setup()
    support.setup()
    events.setup()
    status.setup()
    merge_editions.setup()
    authors.setup()

    from openlibrary.plugins.openlibrary import api
    delegate.app.add_processor(web.unloadhook(stats.stats_hook))

    if infogami.config.get("dev_instance") is True:
        from openlibrary.plugins.openlibrary import dev_instance
        dev_instance.setup()

    setup_context_defaults()
    setup_template_globals()

  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 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 set_webpy_hooks(self, app, shutdown, rollback):
     try:
         import web
     except ImportError:
         return
     if not hasattr(web, 'application'):
         return
     if not isinstance(app, web.application):
         return
     app.processors.append(0, web.unloadhook(shutdown))

def setup():
    import home, inlibrary, borrow_home, libraries
    
    home.setup()
    inlibrary.setup()
    borrow_home.setup()
    libraries.setup()
    
    from stats import stats_hook
    delegate.app.add_processor(web.unloadhook(stats_hook))
    
    setup_template_globals()

 def set_webpy_hooks(self, app, shutdown, rollback):
     """Setup the webpy-specific ``web.unloadhook`` to call
     ``db.session.remove()`` after each response.
     """
     try:
         import web
     except ImportError:
         return
     if not hasattr(web, 'application'):
         return
     if not isinstance(app, web.application):
         return
     app.processors.append(0, web.unloadhook(shutdown))

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

    "/([^/]*)/reindex", "reindex",    
    "/([^/]*)/new_key", "new_key",
    "/([^/]*)/things", "things",
    "/([^/]*)/versions", "versions",
    "/([^/]*)/write", "write",
    "/([^/]*)/account/(.*)", "account",
    "/([^/]*)/permission", "permission",
    "/([^/]*)/log/(\d\d\d\d-\d\d-\d\d:\d+)", 'readlog',
    "/_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:
    """JSON marker. instances of this class not escaped by jsonify.
    """
    def __init__(self, json):
        self.json = json

		"""
	#global session
	#session = s

if __name__ == "__main__":
	
	curdir = os.path.dirname(__file__)
	curdir=""
	web.config.debug = config.web_debug
	#web.config.debug = False
	
	app = rot(webctx.urls, globals())
	init_session(app)
	
	app.add_processor(web.loadhook(loadhook))
	app.add_processor(web.unloadhook(unloadhook))
	
	# web.myapp = app
	# web.init_session = init_session
	
	app.run(config.port, "0.0.0.0", Log)
else:
	
	web.config.debug = config.web_debug
	app = web.application(webctx.urls, globals())
	init_session(app)
	
	app.add_processor(web.loadhook(loadhook))
	app.add_processor(web.unloadhook(unloadhook))
	
	# web.myapp = app

"""
try:
	webctx.session
except NameError:
	web.debug("Resetting session ...")
	webctx.session = None
"""

app = None
if __name__ == "__main__":
	web.config.debug = False

	app = service(urls, globals())
	# session setup, make sure to call it only once if in debug mode
	init_session(app)
	
	app.add_processor(web.loadhook(hooks.load))
	app.add_processor(web.unloadhook(hooks.unload))

	#webctx.session["pid"] += 1
	#print "starting ..."
	#app.add_processor(web.loadhook(loadhook))
	#app.add_processor(web.unloadhook(unloadhook))
	#app.run(config.port, "0.0.0.0")
	
	#webctx.session = get_session(app)

	app.run(config.port, "0.0.0.0", Log)

      yield packer.pack(names)
      for row in result:
        resultTuple = (
            row.uid,
            calendar.timegm(row.created_at.timetuple()),
            calendar.timegm(row.agg_ts.timetuple()),
            row.text,
            row.username,
            row.userid
          )
        yield packer.pack(resultTuple)
    else:
      results = {"names": ["uid", "created_at", "agg_ts", "text", "username",
                           "userid"],
                 "data": [(row.uid,
                           row.created_at.strftime("%Y-%m-%d %H:%M:%S"),
                           row.agg_ts.strftime("%Y-%m-%d %H:%M:%S"),
                           row.text,
                           row.username,
                           row.userid) for row in result]}
      self.addStandardHeaders()
      yield utils.jsonEncode(results)



app = ManagedConnectionWebapp(urls, globals())
app.add_processor(web.loadhook(_connect))
app.add_processor(web.unloadhook(_disconnect))

    def my_unloadhook():
        print "my unload hook"

        app.add_processor(web.loadhook(my_loadhook))
        app.add_processor(web.unloadhook(my_unloadhook))

	if False != session.set_flash:
		session.flash = session.set_flash
		session.set_flash = False
	if False != session.set_error_flash:
		session.error_flash = session.set_error_flash
		session.set_error_flash = False

def feeder_loadhook ():
	session.feeder = feeder.is_alive()

def flash_unloadhook ():
	session.flash = False
	session.error_flash = False

app.add_processor( web.loadhook( permission_loadhook ) )
app.add_processor( web.loadhook( flash_loadhook ) )
app.add_processor( web.loadhook( feeder_loadhook ) )
app.add_processor( web.unloadhook( flash_unloadhook ) )

####### Start the Feeder #######

feeder = Process( target=smf.feeder.run, args=( constants.DEFAULT_CONFIG, ) )
feeder.daemon = True
feeder.start()

####### Start the Server #######
try:
	app.run()
except Exception, e:
	feeder.terminate()
	feeder.join()

    if web.ctx.status == '200 OK' and accept and not pattern.search(accept):
        web.header('Content-Type', 'text/xml')
    
urls = (
    '/?', 'Service',
    '/category', 'Category',
    '/collection/(.*)', 'Collection',
    '/document/(.*)', 'Document',
)

connection = Connection()
db_name = 'test' if sys.argv[-1] == '--test' else 'test_database'
db = connection[db_name]
app_atom = web.application(urls, locals())
app_atom.add_processor(web.unloadhook(my_unloadhook))

class Service:
    def GET(self):
        """
        Returns a service entity conforming to RFC ...
        >>> req = app_atom.request('/', method='GET')
        >>> req.status
        '200 OK'
        >>> req.headers['Content-Type']
        'application/atomsvc+xml;charset=\"utf-8\"'
        """
        collections = []        
        for name in db.collection_names():
            if not name == 'system.indexes':
                collections.append(E.collection(

        header('Content-Type', 'application/x-json-stream')
        try:
            params = parse_response(json_data)
            if 'pfns' in params:
                pfns = params['pfns']
            if 'rse' in params:
                rse = params['rse']
        except ValueError:
            raise generate_http_error(400, 'ValueError', 'Cannot decode json parameter list')

        try:
            declare_bad_file_replicas(rse=rse, pfns=pfns, issuer=ctx.env.get('issuer'))
        except ReplicaNotFound, e:
            raise generate_http_error(404, 'ReplicaNotFound', e.args[0][0])
        except RucioException, e:
            raise generate_http_error(500, e.__class__.__name__, e.args[0][0])
        except Exception, e:
            print format_exc()
            raise InternalError(e)
        raise Created()


"""----------------------
   Web service startup
----------------------"""

app = application(urls, globals())
app.add_processor(loadhook(rucio_loadhook))
app.add_processor(unloadhook(rucio_unloadhook))
application = app.wsgifunc()