invalidate the repo list also for online changes. Small fixes in LoginRequired decorator.

Cleaned hgwebdir config.

hgwebdir.config

@@ -1,20 +1,16 b''
 [hooks]
 #to do push with autoupdate
 changegroup = hg update >&2
 
 [extensions]
 hgext.highlight=
 #hgk=
 
 [web]
 push_ssl = false
 allow_archive = gz zip bz2
 allow_push = *
-templates=/home/marcink/python_workspace/hg_app/pylons_app/templates/
-style = monoblue_custom
-pygments_style = trac
-staticurl = /hg_static/
 baseurl = /
 
 [paths]
 / = /home/marcink/python_workspace/**

pylons_app/lib/auth.py

@@ -1,98 +1,98 b''
 from datetime import datetime
 from decorator import decorator
 from functools import wraps
 from pylons import session, url
 from pylons.controllers.util import abort, redirect
 from pylons_app.model import meta
 from pylons_app.model.db import Users, UserLogs
 from sqlalchemy.exc import OperationalError
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 import crypt
 import logging
 log = logging.getLogger(__name__)
 
 def get_crypt_password(password):
     """
     Cryptographic function used for password hashing
     @param password: password to hash
     """
     return crypt.crypt(password, '6a')
 
 def authfunc(environ, username, password):
     sa = meta.Session
     password_crypt = get_crypt_password(password)
     try:
         user = sa.query(Users).filter(Users.username == username).one()
     except (NoResultFound, MultipleResultsFound, OperationalError) as e:
         log.error(e)
         user = None
         
     if user:
         if user.active:
             if user.username == username and user.password == password_crypt:
                 log.info('user %s authenticated correctly', username)
                 if environ:
                     http_accept = environ.get('HTTP_ACCEPT')
             
                     if http_accept.startswith('application/mercurial') or \
                         environ['PATH_INFO'].find('raw-file') != -1:
                         repo = environ['PATH_INFO']
                         for qry in environ['QUERY_STRING'].split('&'):
                             if qry.startswith('cmd'):
                                 
                                 try:
                                     user_log = UserLogs()
                                     user_log.user_id = user.user_id
                                     user_log.action = qry
                                     user_log.repository = repo
                                     user_log.action_date = datetime.now()
                                     sa.add(user_log)
                                     sa.commit()
                                     log.info('Adding user %s, action %s', username, qry)
                                 except Exception as e:
                                     sa.rollback()
                                     log.error(e)
                                   
                 return True
         else:
             log.error('user %s is disabled', username)
             
     return False
 
 class  AuthUser(object):
     """
     A simple object that handles a mercurial username for authentication
     """
     username = 'Empty'
     is_authenticated = False
     is_admin = False
     permissions = set()
     group = set()
     
     def __init__(self):
         pass
     
 #===============================================================================
 # DECORATORS
 #===============================================================================
 class LoginRequired(object):
     """
     Must be logged in to execute this function else redirect to login page
     """
     def __init__(self):
         pass
     
     def __call__(self, func):
-        log.info('Checking login required')
+        user = session.get('hg_app_user', AuthUser())
+        log.info('Checking login required for %s', user.username)
         
         @wraps(func)
         def _wrapper(*fargs, **fkwargs):
-            user = session.get('hg_app_user', AuthUser())
             if user.is_authenticated:
                     log.info('user %s is authenticated', user.username)
                     func(*fargs)
             else:
                 logging.info('user %s not authenticated', user.username)
                 return redirect(url('login_home'))
 
         return _wrapper

pylons_app/lib/simplehg.py

@@ -1,86 +1,87 b''
 #!/usr/bin/env python
 # encoding: utf-8
 #
 # Copyright (c) 2010 marcink.  All rights reserved.
 #
 """
 Created on 2010-04-28
 
 @author: marcink
 SimpleHG middleware for handling mercurial protocol request (push/clone etc.)
 It's implemented with basic auth function
 """
 
 from mercurial.hgweb import hgweb
 from mercurial.hgweb.request import wsgiapplication
 from paste.auth.basic import AuthBasicAuthenticator
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 from pylons_app.lib.utils import is_mercurial
 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['hg_app_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)
+            invalidate_cache('cached_repo_list')
             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
 
 

pylons_app/lib/utils.py

@@ -1,125 +1,127 b''
 import os
 import logging
 from mercurial import ui, config, hg
 from mercurial.error import RepoError
 log = logging.getLogger(__name__)
 
 
 def get_repo_slug(request):
     path_info = request.environ.get('PATH_INFO')
     uri_lst = path_info.split('/')   
     repo_name = uri_lst[1]
     return repo_name
 
 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
 
 def check_repo_dir(paths):
     repos_path = paths[0][1].split('/')
     if repos_path[-1] in ['*', '**']:
         repos_path = repos_path[:-1]
     if repos_path[0] != '/':
         repos_path[0] = '/'
     if not os.path.isdir(os.path.join(*repos_path)):
         raise Exception('Not a valid repository in %s' % paths[0][1])
 
 def check_repo(repo_name, base_path):
 
     repo_path = os.path.join(base_path, repo_name)
 
     try:
         r = hg.repository(ui.ui(), repo_path)
         hg.verify(r)
         #here we hnow that repo exists it was verified
         log.info('%s repo is already created', repo_name)
         return False
         #raise Exception('Repo exists')
     except RepoError:
         log.info('%s repo is free for creation', repo_name)
         #it means that there is no valid repo there...
         return True
                 
 def make_ui(path='hgwebdir.config', checkpaths=True):        
     """
     A funcion that will read python rc files and make an ui from read options
     
     @param path: path to mercurial config file
     """
     if not os.path.isfile(path):
         log.warning('Unable to read config file %s' % path)
         return False
     #propagated from mercurial documentation
     sections = [
                 'alias',
                 'auth',
                 'decode/encode',
                 'defaults',
                 'diff',
                 'email',
                 'extensions',
                 'format',
                 'merge-patterns',
                 'merge-tools',
                 'hooks',
                 'http_proxy',
                 'smtp',
                 'patch',
                 'paths',
                 'profiling',
                 'server',
                 'trusted',
                 'ui',
                 'web',
                 ]
 
     baseui = ui.ui()
     cfg = config.config()
     cfg.read(path)
     if checkpaths:check_repo_dir(cfg.items('paths'))
 
     for section in sections:
         for k, v in cfg.items(section):
             baseui.setconfig(section, k, v)
     
     return baseui
 
 def invalidate_cache(name, *args):
+    """Invalidates given name cache"""
+    
     from beaker.cache import region_invalidate
     log.info('INVALIDATING CACHE FOR %s', name)
     
-    """propaget our arguments to make sure invalidation works. First
+    """propagate our arguments to make sure invalidation works. First
     argument has to be the name of cached func name give to cache decorator
     without that the invalidation would not work"""
     tmp = [name]
     tmp.extend(args)
     args = tuple(tmp)
     
     if name == 'cached_repo_list':
         from pylons_app.lib.base import _get_repos_cached
         region_invalidate(_get_repos_cached, None, *args)
         
     if name == 'full_changelog':
         from pylons_app.controllers.changelog import _full_changelog_cached
         region_invalidate(_full_changelog_cached, None, *args)
         
 from vcs.backends.base import BaseChangeset
 from vcs.utils.lazy import LazyProperty
 class EmptyChangeset(BaseChangeset):
     
     revision = -1
 
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifing this changeset, useful for web
         representation.
         """
         return '0' * 12