Changed auth basic handler only for mercurial request.

pylons_app/config/middleware.py

@@ -1,72 +1,70 b''
 """Pylons middleware initialization"""
 from beaker.middleware import SessionMiddleware
 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 routes.middleware import RoutesMiddleware
 from paste.auth.basic import AuthBasicHandler
 from pylons_app.lib.simplehg import SimpleHg
 from pylons_app.config.environment import load_environment
-from pylons_app.lib.auth import authfunc 
 
 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 = AuthBasicHandler(app, config['repos_name'] + ' mercurial repository', authfunc)    
     
     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])
     
     # 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.config = config
 
     return app
 

pylons_app/lib/simplehg.py

@@ -1,64 +1,85 b''
-import os
 from mercurial.hgweb import hgweb
 from mercurial.hgweb.request import wsgiapplication
-from pylons_app.lib.utils import make_ui, invalidate_cache
+from paste.auth.basic import AuthBasicAuthenticator
+from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 from pylons.controllers.util import abort
+from pylons_app.lib.auth import authfunc
+from pylons_app.lib.utils import make_ui, invalidate_cache
 from webob.exc import HTTPNotFound
+import os
+
 class SimpleHg(object):
 
     def __init__(self, application, config):
         self.application = application
         self.config = config
+        #authenticate this mercurial request using 
+        realm = '%s %s' % (config['repos_name'], 'mercurial repository')
+        self.authenticate = AuthBasicAuthenticator(realm, authfunc)
         
     def __call__(self, environ, start_response):
         if not is_mercurial(environ):
             return self.application(environ, start_response)
         else:
+            #===================================================================
+            # AUTHENTICATE THIS MERCURIAL REQUEST
+            #===================================================================
+            username = REMOTE_USER(environ)
+            if not username:
+                result = self.authenticate(environ)
+                if isinstance(result, str):
+                    AUTH_TYPE.update(environ, 'basic')
+                    REMOTE_USER.update(environ, result)
+                else:
+                    return result.wsgi_application(environ, start_response)
+            
             try:
                 repo_name = environ['PATH_INFO'].split('/')[1]
             except:
                 return HTTPNotFound()(environ, start_response)
             
             #since we wrap into hgweb, just reset the path
             environ['PATH_INFO'] = '/'
             self.baseui = make_ui()
             self.basepath = self.baseui.configitems('paths')[0][1]\
                                                             .replace('*', '')
             self.repo_path = os.path.join(self.basepath, repo_name)
             try:
                 app = wsgiapplication(self._make_app)
             except Exception as e:
                 return HTTPNotFound()(environ, start_response)
             
             """we know that some change was made to repositories and we should
             invalidate the cache to see the changes right away"""
             invalidate_cache('full_changelog', repo_name)
             return app(environ, start_response)            
 
     def _make_app(self):
         hgserve = hgweb(self.repo_path)
         return  self.load_web_settings(hgserve)
         
                 
     def load_web_settings(self, hgserve):
         repoui = make_ui(os.path.join(self.repo_path, '.hg', 'hgrc'), False)
         #set the global ui for hgserve
         hgserve.repo.ui = self.baseui
         
         if repoui:
             #set the repository based config
             hgserve.repo.ui = repoui
             
         return hgserve
+
+
                                 
 def is_mercurial(environ):
     """
     Returns True if request's target is mercurial server - header
     ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.
     """
     http_accept = environ.get('HTTP_ACCEPT')
     if http_accept and http_accept.startswith('application/mercurial'):
         return True
     return False