moved cache invalidating to utils, as seperate function. Implemented invalidating in

pylons_app/controllers/admin.py

@@ -1,102 +1,101
 import logging
 import os
 
 from pylons import request, response, session, tmpl_context as c, url, app_globals as g
 from pylons.controllers.util import abort, redirect
-from beaker.cache import region_invalidate
 from pylons_app.lib.base import BaseController, render
 from pylons_app.lib import auth
 from pylons_app.model.forms import LoginForm
 import formencode
 import formencode.htmlfill as htmlfill
 from pylons_app.model import meta
 from pylons_app.model.db import Users, UserLogs
 from webhelpers.paginate import Page
-from pylons_app.lib.utils import check_repo
+from pylons_app.lib.utils import check_repo, invalidate_cache
+
 log = logging.getLogger(__name__)
 
 class AdminController(BaseController):
 
     def __before__(self):
         c.admin_user = session.get('admin_user', False)
         c.admin_username = session.get('admin_username')
         
     def index(self):
         # Return a rendered template
         if request.POST:
             #import Login Form validator class
             login_form = LoginForm()
 
             try:
                 c.form_result = login_form.to_python(dict(request.params))
                 if auth.admin_auth(c.form_result['username'], c.form_result['password']):
                     session['admin_user'] = True
                     session['admin_username'] = c.form_result['username']
                     session.save()
                     return redirect(url('admin_home'))
                 else:
                     raise formencode.Invalid('Login Error', None, None,
                                              error_dict={'username':'invalid login',
                                                          'password':'invalid password'})
                                       
             except formencode.Invalid, error:
                 c.form_result = error.value
                 c.form_errors = error.error_dict or {}
                 html = render('admin/admin.html')
 
                 return htmlfill.render(
                     html,
                     defaults=c.form_result,
                     encoding="UTF-8"
                 )
         if c.admin_user:
             sa = meta.Session
                              
             users_log = sa.query(UserLogs)\
                 .order_by(UserLogs.action_date.desc())
             p = int(request.params.get('page', 1))
             c.users_log = Page(users_log, page=p, items_per_page=10)
             c.log_data = render('admin/admin_log.html')
             if request.params.get('partial'):
                 return c.log_data
         return render('admin/admin.html')
 
     def hgrc(self, dirname):
         filename = os.path.join(dirname, '.hg', 'hgrc')
         return filename
 
     def add_repo(self, new_repo):
         
 
         #extra check it can be add since it's the command
         if new_repo == '_admin':
             c.msg = 'DENIED'
             c.new_repo = ''
             return render('admin/add.html')
 
         new_repo = new_repo.replace(" ", "_")
         new_repo = new_repo.replace("-", "_")
 
         try:
             self._create_repo(new_repo)
             c.new_repo = new_repo
             c.msg = 'added repo'
-            from pylons_app.lib.base import _get_repos
             #clear our cached list for refresh with new repo
-            region_invalidate(_get_repos, None, 'repo_list_2')
+            invalidate_cache('repo_list_2')
         except Exception as e:
             c.new_repo = 'Exception when adding: %s' % new_repo
             c.msg = str(e)
 
         return render('admin/add.html')
 
 
     def _create_repo(self, repo_name):
         if repo_name in [None, '', 'add']:
             raise Exception('undefined repo_name of repo')
         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)        
                 

pylons_app/controllers/repos.py

@@ -1,76 +1,81
 import logging
 import os
 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 import auth
 from pylons_app.lib.base import BaseController, render
 from pylons_app.model import meta
 from pylons_app.model.db import Users, UserLogs
 from pylons_app.lib.auth import authenticate
 from pylons_app.model.hg_model import HgModel
 from operator import itemgetter
 import shutil
+from pylons_app.lib.utils import invalidate_cache
 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')
     
     @authenticate
     def __before__(self):
         
         c.admin_user = session.get('admin_user')
         c.admin_username = session.get('admin_username')
         self.sa = meta.Session
                 
     def index(self, format='html'):
         """GET /repos: All items in the collection"""
         # url('repos')
         hg_model = HgModel()
         c.repos_list = list(hg_model.get_repos())
         c.repos_list.sort(key=itemgetter('name'))
         return render('admin/repos/repos.html')
     
     def create(self):
         """POST /repos: Create a new item"""
         # url('repos')
 
     def new(self, format='html'):
         """GET /repos/new: Form to create a new item"""
         # url('new_repo')
 
     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('repo_list_2')
+                    
         return redirect(url('repos'))
         
 
     def show(self, id, format='html'):
         """GET /repos/id: Show a specific item"""
         # url('repo', id=ID)
         return render('/repos_show.html')
     def edit(self, id, format='html'):
         """GET /repos/id/edit: Form to edit an existing item"""
         # url('edit_repo', id=ID)

pylons_app/lib/utils.py

@@ -1,106 +1,114
 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.error('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):
+    from beaker.cache import region_invalidate
+    if name == 'repo_list_2':
+        log.info('INVALIDATING CACHE FOR %s', name)
+        from pylons_app.lib.base import _get_repos
+        #clear our cached list for refresh with new repo
+        region_invalidate(_get_repos, None, 'repo_list_2')
+
 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