fixed 404s added extra validator for magic repo_name path in routes

pylons_app/config/environment.py

@@ -1,69 +1,70 b''
 """Pylons environment configuration"""
 from mako.lookup import TemplateLookup
 from pylons.configuration import PylonsConfig
 from pylons.error import handle_mako_error
 from pylons_app.config.routing import make_map
 from pylons_app.lib.auth import set_available_permissions
 from pylons_app.lib.utils import repo2db_mapper
 from pylons_app.model import init_model
 from pylons_app.model.hg_model import _get_repos_cached_initial
 from sqlalchemy import engine_from_config
 import logging
 import os
 import pylons_app.lib.app_globals as app_globals
 import pylons_app.lib.helpers
 
 log = logging.getLogger(__name__)
 
 def load_environment(global_conf, app_conf):
     """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='pylons_app', paths=paths)
 
     config['routes.map'] = make_map(config)
     config['pylons.app_globals'] = app_globals.Globals(config)
     config['pylons.h'] = pylons_app.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
     
     #MULTIPLE DB configs
     # Setup the SQLAlchemy database engine
     if config['debug']:
         #use query time debugging.
         from pylons_app.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)
     repo2db_mapper(_get_repos_cached_initial(config['pylons.app_globals']))
     set_available_permissions(config)
+    config['base_path'] = config['pylons.app_globals'].base_path
     # CONFIGURATION OPTIONS HERE (note: all config options will override
     # any Pylons config options)
     
     return config

pylons_app/config/routing.py

@@ -1,94 +1,118 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 routes import Mapper
+from pylons_app.lib.utils import check_repo as cr
 
 def make_map(config):
     """Create, configure and return the routes Mapper"""
     map = Mapper(directory=config['pylons.paths']['controllers'],
                  always_scan=config['debug'])
     map.minimization = False
     map.explicit = False
 
     # 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')
 
     # CUSTOM ROUTES HERE
     map.connect('hg_home', '/', controller='hg', action='index')
     
+    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'])
     
     #REST routes
     with map.submapper(path_prefix='/_admin', controller='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"]))
+             action="update", conditions=dict(method=["PUT"],
+                                              function=check_repo))
         m.connect("/repos/{repo_name:.*}",
-             action="delete", conditions=dict(method=["DELETE"]))
+             action="delete", conditions=dict(method=["DELETE"],
+                                              function=check_repo))
         m.connect("edit_repo", "/repos/{repo_name:.*}/edit",
-             action="edit", conditions=dict(method=["GET"]))
+             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"]))
+             action="edit", conditions=dict(method=["GET"],
+                                            function=check_repo))
         m.connect("repo", "/repos/{repo_name:.*}",
-             action="show", conditions=dict(method=["GET"]))
+             action="show", conditions=dict(method=["GET"],
+                                            function=check_repo))
         m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",
-             action="show", conditions=dict(method=["GET"]))
+             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"]))
+             action="delete_perm_user", conditions=dict(method=["DELETE"],
+                                                        function=check_repo))
         
     map.resource('user', 'users', path_prefix='/_admin')
     map.resource('permission', 'permissions', path_prefix='/_admin')
     
     #ADMIN
     with map.submapper(path_prefix='/_admin', controller='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')
     
     #FEEDS
     map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
-                controller='feed', action='rss')
+                controller='feed', action='rss',
+                conditions=dict(function=check_repo))
     map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
-                controller='feed', action='atom')
+                controller='feed', action='atom',
+                conditions=dict(function=check_repo))
     
     map.connect('login_home', '/login', controller='login')
     map.connect('logout_home', '/logout', controller='login', action='logout')
     
     map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
-                controller='changeset', revision='tip')
+                controller='changeset', revision='tip',
+                conditions=dict(function=check_repo))
     map.connect('summary_home', '/{repo_name:.*}/summary',
-                controller='summary')
+                controller='summary', conditions=dict(function=check_repo))
     map.connect('shortlog_home', '/{repo_name:.*}/shortlog',
-                controller='shortlog')
+                controller='shortlog', conditions=dict(function=check_repo))
     map.connect('branches_home', '/{repo_name:.*}/branches',
-                controller='branches')
+                controller='branches', conditions=dict(function=check_repo))
     map.connect('tags_home', '/{repo_name:.*}/tags',
-                controller='tags')
+                controller='tags', conditions=dict(function=check_repo))
     map.connect('changelog_home', '/{repo_name:.*}/changelog',
-                controller='changelog')    
+                controller='changelog', conditions=dict(function=check_repo))    
     map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
-                controller='files', revision='tip', f_path='')
+                controller='files', revision='tip', f_path='',
+                conditions=dict(function=check_repo))
     map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
-                controller='files', action='diff', revision='tip', f_path='')
+                controller='files', action='diff', revision='tip', f_path='',
+                conditions=dict(function=check_repo))
     map.connect('files_raw_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
-                controller='files', action='rawfile', revision='tip', f_path='')
+                controller='files', action='rawfile', revision='tip', f_path='',
+                conditions=dict(function=check_repo))
     map.connect('files_annotate_home', '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
-                controller='files', action='annotate', revision='tip', f_path='')    
+                controller='files', action='annotate', revision='tip', f_path='',
+                conditions=dict(function=check_repo))    
     map.connect('files_archive_home', '/{repo_name:.*}/archive/{revision}/{fileformat}',
-                controller='files', action='archivefile', revision='tip')
+                controller='files', action='archivefile', revision='tip',
+                conditions=dict(function=check_repo))
     return map