keys = root, routes, kallithea, sqlalchemy, gearbox, beaker, templates, whoosh_indexer

# temporary aliasing to allow early introduction of imports like 'from tg import request'

import pylons

sys.modules['tg'] = pylons

import os

import kallithea

import pylons

import mako.lookup

import formencode

import kallithea.lib.app_globals as app_globals

from kallithea.config.routing import make_map

from kallithea.lib import helpers

from kallithea.lib.utils import repo2db_mapper, make_ui, set_app_settings, \

    load_rcextensions, check_git_version, set_vcs_config, set_indexer_config

from kallithea.lib.utils2 import engine_from_config, str2bool

from kallithea.model.base import init_model

from routes.middleware import RoutesMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

from paste.deploy.converters import asbool

from pylons.middleware import ErrorHandler, StatusCodeRedirect

from pylons.wsgiapp import PylonsApp

from kallithea.lib.middleware.simplehg import SimpleHg

from kallithea.lib.middleware.simplegit import SimpleGit

from kallithea.lib.middleware.https_fixup import HttpsFixup

from kallithea.lib.middleware.sessionmiddleware import SecureSessionMiddleware

from kallithea.lib.middleware.wrapper import RequestWrapper

def setup_configuration(config, paths, app_conf, test_env, test_index):

    config['routes.map'] = make_map(config)

    config['pylons.app_globals'] = app_globals.Globals(config)

    config['pylons.h'] = helpers

    kallithea.CONFIG = config

    # Setup cache object as early as possible

    pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping

    config['pylons.app_globals'].mako_lookup = mako.lookup.TemplateLookup(

        directories=paths['templates'],

        strict_undefined=True,

        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),

        input_encoding='utf-8', default_filters=['escape'],

        imports=['from webhelpers.html import escape'])

    # sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

        if test_env is None:

            test_env = not int(os.environ.get('KALLITHEA_NO_TMP_PATH', 0))

        if test_index is None:

            test_index = not int(os.environ.get('KALLITHEA_WHOOSH_TEST_DISABLE', 0))

            # swap config if we pass enviroment variable

    # MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    sa_engine = engine_from_config(config, 'sqlalchemy.')

    init_model(sa_engine)

    # CONFIGURATION OPTIONS HERE (note: all config options will override

    # any Pylons config options)

    # store config reference into our module to skip import magic of

    # pylons

    kallithea.CONFIG.update(config)

    #check git version

    return config

def setup_application(config, global_conf, full_stack, static_files):

    # The Pylons WSGI app

    app = PylonsApp(config=config)

    # Routing/Session/Cache Middleware

    app = RoutesMiddleware(app, config['routes.map'], use_method_override=False)

    app = SecureSessionMiddleware(app, config)

    # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)

    if asbool(config['pdebug']):

        from kallithea.lib.profiler import ProfilingMiddleware

        app = ProfilingMiddleware(app)

    if asbool(full_stack):

        from kallithea.lib.middleware.sentry import Sentry

        from kallithea.lib.middleware.appenlight import AppEnlight

        if AppEnlight and asbool(config['app_conf'].get('appenlight')):

            app = AppEnlight(app, config)

        elif Sentry:

            app = Sentry(app, config)

        # Handle Python exceptions

        app = ErrorHandler(app, global_conf, **config['pylons.errorware'])

        # Display error documents for 401, 403, 404 status codes (and

        # 500 when debug is disabled)

        # Note: will buffer the output in memory!

        if asbool(config['debug']):

            app = StatusCodeRedirect(app)

        else:

            app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])

        # we want our low level middleware to get to the request ASAP. We don't

        # need any pylons stack middleware in them - especially no StatusCodeRedirect buffering

        app = SimpleHg(app, config)

        app = SimpleGit(app, config)

        # Enable https redirects based on HTTP_X_URL_SCHEME set by proxy

        if any(asbool(config.get(x)) for x in ['https_fixup', 'force_https', 'use_htsts']):

            app = HttpsFixup(app, config)

        app = RequestWrapper(app, config) # logging

    # Establish the Registry for this application

    app = RegistryManager(app) # thread / request-local module globals / variables

    if asbool(static_files):

        # Serve static files

        static_app = StaticURLParser(config['pylons.paths']['static_files'])

        app = Cascade([static_app, app])

    app.config = config

    return app

"""

    Pylons environment configuration

"""

import os

import kallithea

import pylons

from kallithea.config.app_cfg import setup_configuration

def load_environment(global_conf, app_conf,

                     test_env=None, test_index=None):

    """

    Configure the Pylons environment via the ``pylons.config``

    object

    """

    config = pylons.configuration.PylonsConfig()

    # Pylons paths

    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    paths = dict(

        root=root,

        controllers=os.path.join(root, 'controllers'),

        static_files=os.path.join(root, 'public'),

        templates=[os.path.join(root, 'templates')]

    )

    # Initialize config with the basic options

    config.init_app(global_conf, app_conf, package='kallithea', paths=paths)

    return setup_configuration(config, paths, app_conf, test_env, test_index)

"""

    Pylons middleware initialization

"""

from kallithea.config.app_cfg import setup_application

def make_app(global_conf, full_stack=True, static_files=True, **app_conf):

    """Create a Pylons WSGI application and return it

    ``global_conf``

        The inherited configuration for this application. Normally from

        the [DEFAULT] section of the Paste ini file.

    ``full_stack``

        Whether or not this application provides a full WSGI stack (by

        default, meaning it handles its own exceptions and errors).

        Disable full_stack when this application is "managed" by

        another WSGI middleware.

    ``app_conf``

        The application's local configuration. Normally specified in

        the [app:<name>] section of the Paste ini file (where <name>

        defaults to main).

    # Configure the Pylons environment

    config = load_environment(global_conf, app_conf)

    return setup_application(config, global_conf, full_stack, static_files)

    rmap = Mapper(directory=config['pylons.paths']['controllers'],

            #fix for multiple initial slashes that causes errors

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    rmap.connect('/error/{action}', controller='error')

    rmap.connect('/error/{action}/{id}', controller='error')

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='api/api') as m:

from tg import request, tmpl_context as c

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

from tg import request, tmpl_context as c, config

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

from tg import request, tmpl_context as c, config

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

from paste.response import replace_header

from pylons.controllers import WSGIController

from pylons.controllers.util import Response

from tg import request

from webob.exc import HTTPError

class JSONRPCErrorResponse(Response, Exception):

                          body=json.dumps(dict(id=retid, result=None, error=message)),

class JSONRPCController(WSGIController):

    def __call__(self, environ, start_response):

        try:

            return self._handle_request(environ, start_response)

        except JSONRPCErrorResponse as e:

            return e

        finally:

            meta.Session.remove()

    def _handle_request(self, environ, start_response):

        self._rpc_args['start_response'] = start_response

        status = []

        headers = []

        exc_info = []

        def change_content(new_status, new_headers, new_exc_info=None):

            status.append(new_status)

            headers.extend(new_headers)

            exc_info.append(new_exc_info)

        output = WSGIController.__call__(self, environ, change_content)

        output = list(output) # expand iterator - just to ensure exact timing

        replace_header(headers, 'Content-Type', 'application/json')

        start_response(status[0], headers, exc_info[0])

        return output

    def _dispatch_call(self):

        Implement dispatch interface specified by WSGIController

            raw_response = self._inspect_call(self._func)

from tg import tmpl_context as c, request, config

from pylons.middleware import media_path

    def document(self):

        resp = request.environ.get('pylons.original_response')

        return render('/errors/error_document.html')

from beaker.cache import CacheManager

from beaker.util import parse_cache_config_options

    def __init__(self, config):

        self.cache = CacheManager(**parse_cache_config_options(config))

from tg import config, tmpl_context as c, request, response, session

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render  # don't remove this import

    org_req = environ.get('pylons.original_request')

class BaseController(WSGIController):

        pass

    def __before__(self):

        __before__ is called before controller methods and after __call__

        # __before__ in Pylons is called _before in TurboGears2. As preparation

        # to the migration to TurboGears2, all __before__ methods were already

        # renamed to _before.  We call them from here to keep the behavior.

        # This is a temporary call that will be removed in the real TurboGears2

        # migration commit.

        self._before()

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

            return WSGIController.__call__(self, environ, start_response)

            return e(environ, start_response)

        finally:

            meta.Session.remove()