rhodecode config module refactoring

rhodecode/config/environment.py

@@ -1,86 +1,86 b''
 """Pylons environment configuration"""
 
 import os
 import logging
 
 from mako.lookup import TemplateLookup
 from pylons.configuration import PylonsConfig
 from pylons.error import handle_mako_error
+from sqlalchemy import engine_from_config
 
 import rhodecode.lib.app_globals as app_globals
 import rhodecode.lib.helpers
 
 from rhodecode.config.routing import make_map
 from rhodecode.lib import celerypylons
 from rhodecode.lib.auth import set_available_permissions, set_base_path
 from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config
 from rhodecode.model import init_model
 from rhodecode.model.scm import ScmModel
-from sqlalchemy import engine_from_config
+from rhodecode.lib.timerproxy import TimerProxy
 
 log = logging.getLogger(__name__)
 
 def load_environment(global_conf, app_conf, initial=False):
     """Configure the Pylons environment via the ``pylons.config``
     object
     """
     config = 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='rhodecode', paths=paths)
 
     config['routes.map'] = make_map(config)
     config['pylons.app_globals'] = app_globals.Globals(config)
     config['pylons.h'] = rhodecode.lib.helpers
 
     # Setup cache object as early as possible
     import pylons
     pylons.cache._push_object(config['pylons.app_globals'].cache)
 
     # Create the Mako TemplateLookup, with the default auto-escaping
     config['pylons.app_globals'].mako_lookup = TemplateLookup(
         directories=paths['templates'],
         error_handler=handle_mako_error,
         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
     test = os.path.split(config['__file__'])[-1] == 'test.ini'
     if test:
         from rhodecode.lib.utils import create_test_env, create_test_index
         from rhodecode.tests import  TESTS_TMP_PATH
         create_test_env(TESTS_TMP_PATH, config)
         create_test_index(TESTS_TMP_PATH, True)
 
     #MULTIPLE DB configs
     # Setup the SQLAlchemy database engine
     if config['debug'] and not test:
         #use query time debugging.
-        from rhodecode.lib.timerproxy import TimerProxy
         sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.',
                                                             proxy=TimerProxy())
     else:
         sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')
 
     init_model(sa_engine_db1)
     #init baseui
     config['pylons.app_globals'].baseui = make_ui('db')
 
     g = config['pylons.app_globals']
     repo2db_mapper(ScmModel().repo_scan(g.paths[0][1], g.baseui))
     set_available_permissions(config)
     set_base_path(config)
     set_rhodecode_config(config)
     # CONFIGURATION OPTIONS HERE (note: all config options will override
     # any Pylons config options)
 
     return config

rhodecode/config/middleware.py

@@ -1,76 +1,79 b''
 """Pylons middleware initialization"""
+
 from beaker.middleware import SessionMiddleware
+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 paste.gzipper import make_gzip_middleware
+
 from pylons.middleware import ErrorHandler, StatusCodeRedirect
 from pylons.wsgiapp import PylonsApp
-from routes.middleware import RoutesMiddleware
+
 from rhodecode.lib.middleware.simplehg import SimpleHg
 from rhodecode.lib.middleware.simplegit import SimpleGit
 from rhodecode.lib.middleware.https_fixup import HttpsFixup
 from rhodecode.config.environment import load_environment
-from paste.gzipper import make_gzip_middleware
 
 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)
 
     # The Pylons WSGI app
     app = PylonsApp(config=config)
 
     # Routing/Session/Cache Middleware
     app = RoutesMiddleware(app, config['routes.map'])
     app = SessionMiddleware(app, config)
 
     # CUSTOM MIDDLEWARE HERE (filtered by error handling middlewares)
 
     app = SimpleHg(app, config)
     app = SimpleGit(app, config)
 
     if asbool(full_stack):
         # 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)
         if asbool(config['debug']):
             app = StatusCodeRedirect(app)
         else:
             app = StatusCodeRedirect(app, [400, 401, 403, 404, 500])
 
     #enable https redirets based on HTTP_X_URL_SCHEME set by proxy
     app = HttpsFixup(app, config)
 
     # Establish the Registry for this application
     app = RegistryManager(app)
 
     if asbool(static_files):
         # Serve static files
         static_app = StaticURLParser(config['pylons.paths']['static_files'])
         app = Cascade([static_app, app])
         app = make_gzip_middleware(app, global_conf, compress_level=1)
 
     app.config = config
 
     return app
 

rhodecode/config/routing.py

@@ -1,224 +1,225 b''
 """
 Routes configuration
 
 The more specific and detailed routes should be defined first so they
 may take precedent over the more generic routes. For more information
 refer to the routes manual at http://routes.groovie.org/docs/
 """
 from __future__ import with_statement
 from routes import Mapper
 from rhodecode.lib.utils import check_repo_fast as cr
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
-    map = Mapper(directory=config['pylons.paths']['controllers'],
+    routes_map = Mapper(directory=config['pylons.paths']['controllers'],
                  always_scan=config['debug'])
-    map.minimization = False
-    map.explicit = False
+    routes_map.minimization = False
+    routes_map.explicit = False
 
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
+        
         :param environ:
         :param match_dict:
         """
         repo_name = match_dict.get('repo_name')
         return not cr(repo_name, config['base_path'])
 
     # The ErrorController route (handles 404/500 error pages); it should
     # likely stay at the top, ensuring it can always be resolved
-    map.connect('/error/{action}', controller='error')
-    map.connect('/error/{action}/{id}', controller='error')
+    routes_map.connect('/error/{action}', controller='error')
+    routes_map.connect('/error/{action}/{id}', controller='error')
 
     #==========================================================================
     # CUSTOM ROUTES HERE
     #==========================================================================
 
     #MAIN PAGE
-    map.connect('home', '/', controller='home', action='index')
-    map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)
-    map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)
+    routes_map.connect('home', '/', controller='home', action='index')
+    routes_map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)
+    routes_map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)
     #ADMIN REPOSITORY REST ROUTES
-    with map.submapper(path_prefix='/_admin', controller='admin/repos') as m:
+    with routes_map.submapper(path_prefix='/_admin', controller='admin/repos') as m:
         m.connect("repos", "/repos",
              action="create", conditions=dict(method=["POST"]))
         m.connect("repos", "/repos",
              action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_repos", "/repos.{format}",
              action="index",
             conditions=dict(method=["GET"]))
         m.connect("new_repo", "/repos/new",
              action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_new_repo", "/repos/new.{format}",
              action="new", conditions=dict(method=["GET"]))
         m.connect("/repos/{repo_name:.*}",
              action="update", conditions=dict(method=["PUT"],
                                               function=check_repo))
         m.connect("/repos/{repo_name:.*}",
              action="delete", conditions=dict(method=["DELETE"],
                                               function=check_repo))
         m.connect("edit_repo", "/repos/{repo_name:.*}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",
              action="edit", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("repo", "/repos/{repo_name:.*}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",
              action="show", conditions=dict(method=["GET"],
                                             function=check_repo))
         #ajax delete repo perm user
         m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",
              action="delete_perm_user", conditions=dict(method=["DELETE"],
                                                         function=check_repo))
         #ajax delete repo perm users_group
         m.connect('delete_repo_users_group', "/repos_delete_users_group/{repo_name:.*}",
              action="delete_perm_users_group", conditions=dict(method=["DELETE"],
                                                         function=check_repo))
 
         #settings actions
         m.connect('repo_stats', "/repos_stats/{repo_name:.*}",
              action="repo_stats", conditions=dict(method=["DELETE"],
                                                         function=check_repo))
         m.connect('repo_cache', "/repos_cache/{repo_name:.*}",
              action="repo_cache", conditions=dict(method=["DELETE"],
                                                         function=check_repo))
 
     #ADMIN USER REST ROUTES
-    map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')
+    routes_map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')
 
     #ADMIN USER REST ROUTES
-    map.resource('users_group', 'users_groups', controller='admin/users_groups', path_prefix='/_admin')
+    routes_map.resource('users_group', 'users_groups', controller='admin/users_groups', path_prefix='/_admin')
 
     #ADMIN GROUP REST ROUTES
-    map.resource('group', 'groups', controller='admin/groups', path_prefix='/_admin')
+    routes_map.resource('group', 'groups', controller='admin/groups', path_prefix='/_admin')
 
     #ADMIN PERMISSIONS REST ROUTES
-    map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')
+    routes_map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')
 
     ##ADMIN LDAP SETTINGS
-    map.connect('ldap_settings', '/_admin/ldap', controller='admin/ldap_settings',
+    routes_map.connect('ldap_settings', '/_admin/ldap', controller='admin/ldap_settings',
                 action='ldap_settings', conditions=dict(method=["POST"]))
-    map.connect('ldap_home', '/_admin/ldap', controller='admin/ldap_settings',)
+    routes_map.connect('ldap_home', '/_admin/ldap', controller='admin/ldap_settings',)
 
 
     #ADMIN SETTINGS REST ROUTES
-    with map.submapper(path_prefix='/_admin', controller='admin/settings') as m:
+    with routes_map.submapper(path_prefix='/_admin', controller='admin/settings') as m:
         m.connect("admin_settings", "/settings",
              action="create", conditions=dict(method=["POST"]))
         m.connect("admin_settings", "/settings",
              action="index", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_settings", "/settings.{format}",
              action="index", conditions=dict(method=["GET"]))
         m.connect("admin_new_setting", "/settings/new",
              action="new", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_new_setting", "/settings/new.{format}",
              action="new", conditions=dict(method=["GET"]))
         m.connect("/settings/{setting_id}",
              action="update", conditions=dict(method=["PUT"]))
         m.connect("/settings/{setting_id}",
              action="delete", conditions=dict(method=["DELETE"]))
         m.connect("admin_edit_setting", "/settings/{setting_id}/edit",
              action="edit", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_edit_setting", "/settings/{setting_id}.{format}/edit",
              action="edit", conditions=dict(method=["GET"]))
         m.connect("admin_setting", "/settings/{setting_id}",
              action="show", conditions=dict(method=["GET"]))
         m.connect("formatted_admin_setting", "/settings/{setting_id}.{format}",
              action="show", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account", "/my_account",
              action="my_account", conditions=dict(method=["GET"]))
         m.connect("admin_settings_my_account_update", "/my_account_update",
              action="my_account_update", conditions=dict(method=["PUT"]))
         m.connect("admin_settings_create_repository", "/create_repository",
              action="create_repository", conditions=dict(method=["GET"]))
 
     #ADMIN MAIN PAGES
-    with map.submapper(path_prefix='/_admin', controller='admin/admin') as m:
+    with routes_map.submapper(path_prefix='/_admin', controller='admin/admin') as m:
         m.connect('admin_home', '', action='index')#main page
         m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',
                   action='add_repo')
 
 
     #USER JOURNAL
-    map.connect('journal', '/_admin/journal', controller='journal',)
-    map.connect('toggle_following', '/_admin/toggle_following', controller='journal',
+    routes_map.connect('journal', '/_admin/journal', controller='journal',)
+    routes_map.connect('toggle_following', '/_admin/toggle_following', controller='journal',
                 action='toggle_following', conditions=dict(method=["POST"]))
 
 
     #SEARCH
-    map.connect('search', '/_admin/search', controller='search',)
-    map.connect('search_repo', '/_admin/search/{search_repo:.*}', controller='search')
+    routes_map.connect('search', '/_admin/search', controller='search',)
+    routes_map.connect('search_repo', '/_admin/search/{search_repo:.*}', controller='search')
 
     #LOGIN/LOGOUT/REGISTER/SIGN IN
-    map.connect('login_home', '/_admin/login', controller='login')
-    map.connect('logout_home', '/_admin/logout', controller='login', action='logout')
-    map.connect('register', '/_admin/register', controller='login', action='register')
-    map.connect('reset_password', '/_admin/password_reset', controller='login', action='password_reset')
+    routes_map.connect('login_home', '/_admin/login', controller='login')
+    routes_map.connect('logout_home', '/_admin/logout', controller='login', action='logout')
+    routes_map.connect('register', '/_admin/register', controller='login', action='register')
+    routes_map.connect('reset_password', '/_admin/password_reset', controller='login', action='password_reset')
 
     #FEEDS
-    map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
+    routes_map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
                 controller='feed', action='rss',
                 conditions=dict(function=check_repo))
-    map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
+    routes_map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
                 controller='feed', action='atom',
                 conditions=dict(function=check_repo))
 
 
     #REPOSITORY ROUTES
-    map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
+    routes_map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
-    map.connect('raw_changeset_home', '/{repo_name:.*}/raw-changeset/{revision}',
+    routes_map.connect('raw_changeset_home', '/{repo_name:.*}/raw-changeset/{revision}',
                 controller='changeset', action='raw_changeset', revision='tip',
                 conditions=dict(function=check_repo))
-    map.connect('summary_home', '/{repo_name:.*}',
+    routes_map.connect('summary_home', '/{repo_name:.*}',
                 controller='summary', conditions=dict(function=check_repo))
-    map.connect('summary_home', '/{repo_name:.*}/summary',
+    routes_map.connect('summary_home', '/{repo_name:.*}/summary',
                 controller='summary', conditions=dict(function=check_repo))
-    map.connect('shortlog_home', '/{repo_name:.*}/shortlog',
+    routes_map.connect('shortlog_home', '/{repo_name:.*}/shortlog',
                 controller='shortlog', conditions=dict(function=check_repo))
-    map.connect('branches_home', '/{repo_name:.*}/branches',
+    routes_map.connect('branches_home', '/{repo_name:.*}/branches',
                 controller='branches', conditions=dict(function=check_repo))
-    map.connect('tags_home', '/{repo_name:.*}/tags',
+    routes_map.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags', conditions=dict(function=check_repo))
-    map.connect('changelog_home', '/{repo_name:.*}/changelog',
+    routes_map.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
-    map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
+    routes_map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
-    map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
+    routes_map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
-    map.connect('files_rawfile_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
+    routes_map.connect('files_rawfile_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
                 controller='files', action='rawfile', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
-    map.connect('files_raw_home', '/{repo_name:.*}/raw/{revision}/{f_path:.*}',
+    routes_map.connect('files_raw_home', '/{repo_name:.*}/raw/{revision}/{f_path:.*}',
                 controller='files', action='raw', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
-    map.connect('files_annotate_home', '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
+    routes_map.connect('files_annotate_home', '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
                 controller='files', action='annotate', revision='tip', f_path='',
                 conditions=dict(function=check_repo))
-    map.connect('files_archive_home', '/{repo_name:.*}/archive/{fname}',
+    routes_map.connect('files_archive_home', '/{repo_name:.*}/archive/{fname}',
                 controller='files', action='archivefile',
                 conditions=dict(function=check_repo))
-    map.connect('repo_settings_delete', '/{repo_name:.*}/settings',
+    routes_map.connect('repo_settings_delete', '/{repo_name:.*}/settings',
                 controller='settings', action="delete",
                 conditions=dict(method=["DELETE"], function=check_repo))
-    map.connect('repo_settings_update', '/{repo_name:.*}/settings',
+    routes_map.connect('repo_settings_update', '/{repo_name:.*}/settings',
                 controller='settings', action="update",
                 conditions=dict(method=["PUT"], function=check_repo))
-    map.connect('repo_settings_home', '/{repo_name:.*}/settings',
+    routes_map.connect('repo_settings_home', '/{repo_name:.*}/settings',
                 controller='settings', action='index',
                 conditions=dict(function=check_repo))
 
-    map.connect('repo_fork_create_home', '/{repo_name:.*}/fork',
+    routes_map.connect('repo_fork_create_home', '/{repo_name:.*}/fork',
                 controller='settings', action='fork_create',
                 conditions=dict(function=check_repo, method=["POST"]))
-    map.connect('repo_fork_home', '/{repo_name:.*}/fork',
+    routes_map.connect('repo_fork_home', '/{repo_name:.*}/fork',
                 controller='settings', action='fork',
                 conditions=dict(function=check_repo))
 
-    return map
+    return routes_map