implemented manual repo rescann and remapping

pylons_app/controllers/admin/settings.py

@@ -1,93 +1,109 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # settings controller for pylons
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
  
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 """
 Created on July 14, 2010
 settings controller for pylons
 @author: marcink
 """
 from formencode import htmlfill
-from pylons import request, session, tmpl_context as c, url
+from pylons import request, session, tmpl_context as c, url, app_globals as g
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 from pylons_app.lib import helpers as h
 from pylons_app.lib.auth import LoginRequired, HasPermissionAllDecorator
 from pylons_app.lib.base import BaseController, render
+from pylons_app.lib.utils import repo2db_mapper, invalidate_cache
 from pylons_app.model.db import User, UserLog
 from pylons_app.model.forms import UserForm
+from pylons_app.model.hg_model import HgModel
 from pylons_app.model.user_model import UserModel
 import formencode
 import logging
 
 log = logging.getLogger(__name__)
 
 
 class SettingsController(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('setting', 'settings', controller='admin/settings', 
     #         path_prefix='/admin', name_prefix='admin_')
 
 
     @LoginRequired()
     #@HasPermissionAllDecorator('hg.admin')
     def __before__(self):
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         super(SettingsController, self).__before__()
         
     def index(self, format='html'):
         """GET /admin/settings: All items in the collection"""
         # url('admin_settings')
         return render('admin/settings/settings.html')
     
     def create(self):
         """POST /admin/settings: Create a new item"""
         # url('admin_settings')
 
     def new(self, format='html'):
         """GET /admin/settings/new: Form to create a new item"""
         # url('admin_new_setting')
 
     def update(self, id):
         """PUT /admin/settings/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('admin_setting', id=ID),
         #           method='put')
         # url('admin_setting', id=ID)
+        if id == 'mapping':
+            rm_obsolete = request.POST.get('destroy', False)
+            log.debug('Rescanning directories with destroy=%s', rm_obsolete)
+
+            initial = HgModel.repo_scan(g.paths[0][0], g.paths[0][1], g.baseui)
+            repo2db_mapper(initial, rm_obsolete)
+            invalidate_cache('cached_repo_list')
+            
+            
+        return redirect(url('admin_settings'))
+
+
+
+
 
     def delete(self, id):
         """DELETE /admin/settings/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('admin_setting', id=ID),
         #           method='delete')
         # url('admin_setting', id=ID)
 
     def show(self, id, format='html'):
         """GET /admin/settings/id: Show a specific item"""
         # url('admin_setting', id=ID)
 
     def edit(self, id, format='html'):
         """GET /admin/settings/id/edit: Form to edit an existing item"""
         # url('admin_edit_setting', id=ID)

pylons_app/lib/utils.py

@@ -1,202 +1,210 b''
 #!/usr/bin/env python
 # encoding: utf-8
 # Utilities for hg app
 # Copyright (C) 2009-2010 Marcin Kuzminski <[e-mail]>
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
 # as published by the Free Software Foundation; version 2
 # of the License or (at your opinion) any later version of the license.
 # 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 # 
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 # MA  02110-1301, USA.
 from beaker.cache import cache_region
 
 """
 Created on April 18, 2010
 Utilities for hg app
 @author: marcink
 """
 
 import os
 import logging
 from mercurial import ui, config, hg
 from mercurial.error import RepoError
 from pylons_app.model.db import Repository, User, HgAppUi, HgAppSettings
 from pylons_app.model.meta import Session
 log = logging.getLogger(__name__)
 
 
 def get_repo_slug(request):
     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_fast(repo_name, base_path):
     if os.path.isdir(os.path.join(base_path, repo_name)):return False
     return True
 
 def check_repo(repo_name, base_path, verify=True):
 
     repo_path = os.path.join(base_path, repo_name)
 
     try:
         if not check_repo_fast(repo_name, base_path):
             return False
         r = hg.repository(ui.ui(), repo_path)
         if verify:
             hg.verify(r)
         #here we hnow that repo exists it was verified
         log.info('%s repo is already created', repo_name)
         return False
     except RepoError:
         #it means that there is no valid repo there...
         log.info('%s repo is free for creation', repo_name)
         return True
 
 
 @cache_region('super_short_term', 'cached_hg_ui')
 def get_hg_ui_cached():
     sa = Session()
     return sa.query(HgAppUi).all()    
 
 def get_hg_settings():
     sa = Session()
     ret = sa.query(HgAppSettings).scalar()
     if not ret:
         raise Exception('Could not get application settings !')
     return ret
     
 def make_ui(read_from='file', path=None, checkpaths=True):        
     """
     A function that will read python rc files or database
     and make an mercurial ui object from read options
     
     @param path: path to mercurial config file
     @param checkpaths: check the path
     @param read_from: read from 'file' or 'db'
     """
     #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()
 
                 
     if read_from == 'file':
         if not os.path.isfile(path):
             log.warning('Unable to read config file %s' % path)
             return False
         
         cfg = config.config()
         cfg.read(path)
         for section in sections:
             for k, v in cfg.items(section):
                 baseui.setconfig(section, k, v)
         if checkpaths:check_repo_dir(cfg.items('paths'))                
               
         
     elif read_from == 'db':
         hg_ui = get_hg_ui_cached()
         for ui_ in hg_ui:
             baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)
         
     
     return baseui
 
 
 def set_hg_app_config(config):
     hgsettings = get_hg_settings()
     config['hg_app_auth_realm'] = hgsettings.app_auth_realm
     config['hg_app_name'] = hgsettings.app_title
 
 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
     message = ''
     
     @LazyProperty
     def raw_id(self):
         """
         Returns raw string identifing this changeset, useful for web
         representation.
         """
         return '0' * 12
 
 
-def repo2db_mapper(initial_repo_list):
+def repo2db_mapper(initial_repo_list, remove_obsolete=False):
     """
     maps all found repositories into db
     """
-    from pylons_app.model.meta import Session
     from pylons_app.model.repo_model import RepoModel
     
     sa = Session()
     user = sa.query(User).filter(User.admin == True).first()
     
     rm = RepoModel()
     
     for name, repo in initial_repo_list.items():
         if not sa.query(Repository).get(name):
             log.info('repository %s not found creating default', name)
                 
             form_data = {
                          'repo_name':name,
                          'description':repo.description if repo.description != 'unknown' else \
                                         'auto description for %s' % name,
                          'private':False
                          }
             rm.create(form_data, user, just_db=True)
+
+
+    if remove_obsolete:
+        #remove from database those repositories that are not in the filesystem
+        for repo in sa.query(Repository).all():
+            if repo.repo_name not in initial_repo_list.keys():
+                sa.delete(repo)
+                sa.commit()
+

pylons_app/templates/admin/settings/settings.html

@@ -1,21 +1,53 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="/base/base.html"/>
 
 <%def name="title()">
     ${_('Settings administration')}
 </%def>
 <%def name="breadcrumbs()">
 	${h.link_to(u'Admin',h.url('admin_home'))}
 	 /  
 	 ${_('Settings')}
 </%def>
 <%def name="page_nav()">
 	${self.menu('admin')}
 	${self.submenu('settings')}
 </%def>
 <%def name="main()">
 	<div>
 	<h2>${_('Settings administration')}</h2>
-	
+
+     ${h.form(url('admin_setting', id='mapping'),method='put')}
+       <table class="table_disp">
+           <tr class="header">
+            <td colspan="2">${_('Remap andv rescan repositories')}</td>
+           </tr>
+           <tr align="right">
+            <td><span class="tooltip" tooltip_title="${h.tooltip(_('In case a repository was deleted from filesystem and there are leftovers in the database check this option to scan obsolete data in database and remove it.'))}">
+            ${_('destroy old data')}</span> ${h.checkbox('destroy',True)}</td>
+            <td>${h.submit('rescan','rescan repositories')}</td>   
+       </table>
+     ${h.end_form()}
+     <br/>	
+     ${h.form(url('admin_setting', id='global'),method='put')}
+	   <table class="table_disp">
+	       <tr class="header">
+	           <td colspan="3">${_('Global application settings')}</td>
+	       </tr>
+	       <tr>
+	           <td>${_('Application name')}</td>
+	           <td>${h.text('app_title')}</td>
+	       </tr>
+           <tr>
+               <td>${_('Realm text')}</td>
+               <td>${h.text('app_auth_realm')}</td>
+           </tr>
+           <tr>
+	           <td></td>
+	           <td>${h.submit('save','save settings')}</td>   
+           </tr>
+	   </table>
+     ${h.end_form()}
+    
     </div>
 </%def>