Added support for repository located in subdirectories.

pylons_app/config/routing.py

@@ -1,67 +1,91
 """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
 
 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')
     
     
-    #REST controllers
-    map.resource('repo', 'repos', path_prefix='/_admin')
+    #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/{id:.*}",
+             action="update", conditions=dict(method=["PUT"]))
+        m.connect("/repos/{id:.*}",
+             action="delete", conditions=dict(method=["DELETE"]))
+        m.connect("edit_repo", "/repos/{id:.*}/edit",
+             action="edit", conditions=dict(method=["GET"]))
+        m.connect("formatted_edit_repo", "/repos/{id:.*}.{format}/edit",
+             action="edit", conditions=dict(method=["GET"]))
+        m.connect("repo", "/repos/{id:.*}",
+             action="show", conditions=dict(method=["GET"]))
+        m.connect("formatted_repo", "/repos/{id:.*}.{format}",
+             action="show", conditions=dict(method=["GET"]))
+
     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',
+    map.connect('rss_feed_home', '/{repo_name:.*}/feed/rss',
                 controller='feed', action='rss')
-    map.connect('atom_feed_home', '/{repo_name}/feed/atom',
+    map.connect('atom_feed_home', '/{repo_name:.*}/feed/atom',
                 controller='feed', action='atom')
     
     map.connect('login_home', '/login', controller='login')
     map.connect('logout_home', '/logout', controller='login', action='logout')
     
-    map.connect('changeset_home', '/{repo_name}/changeset/{revision}',
+    map.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',
                 controller='changeset', revision='tip')
-    map.connect('summary_home', '/{repo_name}/summary',
+    map.connect('summary_home', '/{repo_name:.*}/summary',
                 controller='summary')
-    map.connect('shortlog_home', '/{repo_name}/shortlog',
+    map.connect('shortlog_home', '/{repo_name:.*}/shortlog',
                 controller='shortlog')
-    map.connect('branches_home', '/{repo_name}/branches',
+    map.connect('branches_home', '/{repo_name:.*}/branches',
                 controller='branches')
-    map.connect('tags_home', '/{repo_name}/tags',
+    map.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags')
-    map.connect('changelog_home', '/{repo_name}/changelog',
+    map.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog')    
-    map.connect('files_home', '/{repo_name}/files/{revision}/{f_path:.*}',
+    map.connect('files_home', '/{repo_name:.*}/files/{revision}/{f_path:.*}',
                 controller='files', revision='tip', f_path='')
-    map.connect('files_diff_home', '/{repo_name}/diff/{f_path:.*}',
+    map.connect('files_diff_home', '/{repo_name:.*}/diff/{f_path:.*}',
                 controller='files', action='diff', revision='tip', f_path='')
-    map.connect('files_raw_home', '/{repo_name}/rawfile/{revision}/{f_path:.*}',
+    map.connect('files_raw_home', '/{repo_name:.*}/rawfile/{revision}/{f_path:.*}',
                 controller='files', action='rawfile', revision='tip', f_path='')
-    map.connect('files_annotate_home', '/{repo_name}/annotate/{revision}/{f_path:.*}',
+    map.connect('files_annotate_home', '/{repo_name:.*}/annotate/{revision}/{f_path:.*}',
                 controller='files', action='annotate', revision='tip', f_path='')    
-    map.connect('files_archive_home', '/{repo_name}/archive/{revision}/{fileformat}',
+    map.connect('files_archive_home', '/{repo_name:.*}/archive/{revision}/{fileformat}',
                 controller='files', action='archivefile', revision='tip')
     return map

pylons_app/controllers/repos.py

@@ -1,100 +1,103
 from pylons import request, response, session, tmpl_context as c, url, \
     app_globals as g
 from pylons.controllers.util import abort, redirect
 from pylons_app.lib.auth import LoginRequired
+from pylons.i18n.translation import _
+from pylons_app.lib import helpers as h
 from pylons_app.lib.base import BaseController, render
 from pylons_app.lib.filters import clean_repo
 from pylons_app.lib.utils import check_repo, invalidate_cache
 from pylons_app.model.hg_model import HgModel
 import logging
 import os
 import shutil
 from operator import itemgetter
 log = logging.getLogger(__name__)
 
 class ReposController(BaseController):
     """REST Controller styled on the Atom Publishing Protocol"""
     # To properly map this controller, ensure your config/routing.py
     # file has a resource setup:
     #     map.resource('repo', 'repos')
     @LoginRequired()
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(ReposController, self).__before__()
                 
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
         cached_repo_list = HgModel().get_repos()
         c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))
         return render('admin/repos/repos.html')
     
     def create(self):
         """POST /repos: Create a new item"""
         # url('repos')
         name = request.POST.get('name')
 
         try:
             self._create_repo(name)
             #clear our cached list for refresh with new repo
             invalidate_cache('cached_repo_list')
+            h.flash(_('created repository %s') % name, category='success')
         except Exception as e:
             log.error(e)
         
         return redirect('repos')
         
     def _create_repo(self, repo_name):        
         repo_path = os.path.join(g.base_path, repo_name)
         if check_repo(repo_name, g.base_path):
             log.info('creating repo %s in %s', repo_name, repo_path)
             from vcs.backends.hg import MercurialRepository
             MercurialRepository(repo_path, create=True)
                         
 
     def new(self, format='html'):
         """GET /repos/new: Form to create a new item"""
         new_repo = request.GET.get('repo', '')
         c.new_repo = clean_repo(new_repo)
 
         return render('admin/repos/repo_add.html')
 
     def update(self, id):
         """PUT /repos/id: Update an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="PUT" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='put')
         # url('repo', id=ID)
 
     def delete(self, id):
         """DELETE /repos/id: Delete an existing item"""
         # Forms posted to this method should contain a hidden field:
         #    <input type="hidden" name="_method" value="DELETE" />
         # Or using helpers:
         #    h.form(url('repo', id=ID),
         #           method='delete')
         # url('repo', id=ID)
         from datetime import datetime
         path = g.paths[0][1].replace('*', '')
         rm_path = os.path.join(path, id)
         log.info("Removing %s", rm_path)
         shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))
         shutil.move(rm_path, os.path.join(path, 'rm__%s-%s' % (datetime.today(), id)))
         
         #clear our cached list for refresh with new repo
         invalidate_cache('cached_repo_list')
-                    
+        h.flash(_('deleted repository %s') % rm_path, category='success')            
         return redirect(url('repos'))
         
 
     def show(self, id, format='html'):
         """GET /repos/id: Show a specific item"""
         # url('repo', id=ID)
         
     def edit(self, id, format='html'):
         """GET /repos/id/edit: Form to edit an existing item"""
         # url('edit_repo', id=ID)
         c.new_repo = id
         return render('admin/repos/repo_edit.html')

pylons_app/lib/middleware/simplehg.py

@@ -1,136 +1,138
 #!/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 datetime import datetime
 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.auth import authfunc
 from pylons_app.lib.utils import is_mercurial, make_ui, invalidate_cache
 from pylons_app.model import meta
 from pylons_app.model.db import UserLog, User
 from webob.exc import HTTPNotFound
 import logging
 import os
 log = logging.getLogger(__name__)
 
 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:
+                repo_name = '/'.join(environ['PATH_INFO'].split('/')[1:])
+            except Exception as e:
+                log.error(e)
                 return HTTPNotFound()(environ, start_response)
             
             #since we wrap into hgweb, just reset the path
             environ['PATH_INFO'] = '/'
             self.baseui = make_ui(self.config['hg_app_repo_conf'])
             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:
+                log.error(e)
                 return HTTPNotFound()(environ, start_response)
             action = self.__get_action(environ)            
             #invalidate cache on push
             if action == 'push':
                 self.__invalidate_cache(repo_name)
             
             if action:
                 username = self.__get_environ_user(environ)
                 self.__log_user_action(username, action, repo_name)
                          
             return app(environ, start_response)            
 
     def __make_app(self):
         hgserve = hgweb(self.repo_path)
         return  self.__load_web_settings(hgserve)
     
     def __get_environ_user(self, environ):
         return environ.get('REMOTE_USER')
         
     def __get_action(self, environ):
         """
         Maps mercurial request commands into a pull or push command.
         @param environ:
         """
         mapping = {
             'changegroup': 'pull',
             'changegroupsubset': 'pull',
             'unbundle': 'push',
             'stream_out': 'pull',
         }                    
         for qry in environ['QUERY_STRING'].split('&'):
             if qry.startswith('cmd'):
                 cmd = qry.split('=')[-1]
                 if mapping.has_key(cmd):
                     return mapping[cmd]
     
     def __log_user_action(self, username, action, repo):
         sa = meta.Session
         try:
             user = sa.query(User).filter(User.username == username).one()
             user_log = UserLog()
             user_log.user_id = user.user_id
             user_log.action = action
             user_log.repository = repo.replace('/', '')
             user_log.action_date = datetime.now()
             sa.add(user_log)
             sa.commit()
             log.info('Adding user %s, action %s on %s',
                                             username, action, repo)
         except Exception as e:
             sa.rollback()
             log.error('could not log user action:%s', str(e))
     
     def __invalidate_cache(self, repo_name):
         """we know that some change was made to repositories and we should
         invalidate the cache to see the changes right away but only for
         push requests"""
         invalidate_cache('cached_repo_list')
         invalidate_cache('full_changelog', repo_name)
            
                    
     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,144 +1,134
 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
+    return request.environ['pylons.routes_dict'].get('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=None, 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 path:
         log.error('repos config path is empty !')
     
     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)
     
     """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.model.hg_model import _get_repos_cached
         region_invalidate(_get_repos_cached, None, *args)
         
     if name == 'full_changelog':
         from pylons_app.model.hg_model 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
 
 
 def repo2db_mapper():
     """
-    put !
+    scann all dirs for .hgdbid
+    if some dir doesn't have one generate one.
     """
-    pass
-    #scann all dirs for .hgdbid
-    #if some dir doesn't have one generate one.
-    #
-    
-    
-    
-    
-    
+    pass
  No newline at end of file

pylons_app/model/hg_model.py

@@ -1,120 +1,126
 #!/usr/bin/env python
 # encoding: utf-8
 #
 # Copyright (c) 2010 marcink.  All rights reserved.
 #
 '''
 Created on Apr 9, 2010
 
 @author: marcink
 '''
 
 from beaker.cache import cache_region
 from mercurial import ui
 from mercurial.hgweb.hgwebdir_mod import findrepos
 from pylons import app_globals as g
 from vcs.exceptions import RepositoryError, VCSError
 import logging
 import os
 import sys
 log = logging.getLogger(__name__)
 
 try:
     from vcs.backends.hg import MercurialRepository
 except ImportError:
     sys.stderr.write('You have to import vcs module')
     raise Exception('Unable to import vcs')
 
 
 @cache_region('long_term', 'cached_repo_list')
 def _get_repos_cached():
     """
     return cached dict with repos
     """
     return HgModel.repo_scan(g.paths[0][0], g.paths[0][1], g.baseui)
 
 @cache_region('long_term', 'full_changelog')
 def _full_changelog_cached(repo_name):
     log.info('getting full changelog for %s', repo_name)
     return list(reversed(list(HgModel().get_repo(repo_name))))
 
 class HgModel(object):
     """
     Mercurial Model
     """
 
     def __init__(self):
         """
         Constructor
         """
         pass
     
     @staticmethod
     def repo_scan(repos_prefix, repos_path, baseui):
         """
         Listing of repositories in given path. This path should not be a 
         repository itself. Return a dictionary of repository objects
         :param repos_path: path to directory it could take syntax with 
         * or ** for deep recursive displaying repositories
         """
         def check_repo_dir(path):
             """
             Checks the repository
             :param path:
             """
             repos_path = path.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 RepositoryError('Not a valid repository in %s' % path[0][1])        
         if not repos_path.endswith('*'):
             raise VCSError('You need to specify * or ** at the end of path '
                             'for recursive scanning')
             
         check_repo_dir(repos_path)
         log.info('scanning for repositories in %s', repos_path)
         repos = findrepos([(repos_prefix, repos_path)])
         if not isinstance(baseui, ui.ui):
             baseui = ui.ui()
     
         repos_list = {}
         for name, path in repos:
             try:
-                repos_list[name] = MercurialRepository(path, baseui=baseui)
+                #name = name.split('/')[-1]
+                if repos_list.has_key(name):
+                    raise RepositoryError('Duplicate repository name %s found in'
+                                    ' %s' % (name, path))
+                else:
+                    repos_list[name] = MercurialRepository(path, baseui=baseui)
+                    repos_list[name].name = name
             except OSError:
                 continue
         return repos_list
         
     def get_repos(self):
         for name, repo in _get_repos_cached().items():
             if repo._get_hidden():
                 #skip hidden web repository
                 continue
             
             last_change = repo.last_change
             try:
                 tip = repo.get_changeset('tip')
             except RepositoryError:
                 from pylons_app.lib.utils import EmptyChangeset
                 tip = EmptyChangeset()
                 
             tmp_d = {}
             tmp_d['name'] = repo.name
             tmp_d['name_sort'] = tmp_d['name'].lower()
             tmp_d['description'] = repo.description
             tmp_d['description_sort'] = tmp_d['description']
             tmp_d['last_change'] = last_change
             tmp_d['last_change_sort'] = last_change[1] - last_change[0]
             tmp_d['tip'] = tip.raw_id
             tmp_d['tip_sort'] = tip.revision 
             tmp_d['rev'] = tip.revision
             tmp_d['contact'] = repo.contact
             tmp_d['contact_sort'] = tmp_d['contact']
             tmp_d['repo_archives'] = list(repo._get_archives())
             
             yield tmp_d
 
     def get_repo(self, repo_name):
         return _get_repos_cached()[repo_name]