kallithea Changeset - 910ad1ffee99

Changeset - 910ad1ffee99

Parent rev.

Child rev.

[Not reviewed]

beta

0 5 0

Mads Kiilerich - 13 years ago 2013-04-03 15:56:12
madski@unity3d.com

Grafted from: fe9c99ee2d1e

invalidation: merge .invalidate and .set_valid as .test_and_set_valid

This simplifies the internal API and avoids leaking CacheInvalidation instances
and cache keys.

5 files changed with 44 insertions and 94 deletions:

rhodecode/controllers/feed.py

rhodecode/controllers/summary.py

rhodecode/lib/utils.py

rhodecode/model/db.py

rhodecode/model/scm.py

0 comments (0 inline, 0 general)

rhodecode/controllers/feed.py

➞

Show inline comments

@@ @@ -132,28 +132,27 @@ class FeedController(BaseRepoController) @@
                 feed.add_item(title=self._get_title(cs),
                               link=url('changeset_home', repo_name=repo_name,
                                        revision=cs.raw_id, qualified=True),
                               author_name=cs.author,
                               description=''.join(self.__get_desc(cs)),
                               pubdate=cs.date,
+                              )
             response.content_type = feed.mime_type
             return feed.writeString('utf-8')
         key = repo_name + '_ATOM'
         inv = CacheInvalidation.invalidate(key)
         if inv is not None:
         valid = CacheInvalidation.test_and_set_valid(key)
         if not valid:
             region_invalidate(_get_feed_from_cache, None, key)
             CacheInvalidation.set_valid(inv.cache_key)
         return _get_feed_from_cache(key)
     def rss(self, repo_name):
         """Produce an rss2 feed via feedgenerator module"""
         @cache_region('long_term')
         def _get_feed_from_cache(key):
             feed = Rss201rev2Feed(
                 title=self.title % repo_name,
                 link=url('summary_home', repo_name=repo_name,
                          qualified=True),
                 description=self.description % repo_name,
@@ @@ -165,17 +164,16 @@ class FeedController(BaseRepoController) @@
                 feed.add_item(title=self._get_title(cs),
                               link=url('changeset_home', repo_name=repo_name,
                                        revision=cs.raw_id, qualified=True),
                               author_name=cs.author,
                               description=''.join(self.__get_desc(cs)),
                               pubdate=cs.date,
+                             )
             response.content_type = feed.mime_type
             return feed.writeString('utf-8')
         key = repo_name + '_RSS'
         inv = CacheInvalidation.invalidate(key)
         if inv is not None:
         valid = CacheInvalidation.test_and_set_valid(key)
         if not valid:
             region_invalidate(_get_feed_from_cache, None, key)
             CacheInvalidation.set_valid(inv.cache_key)
         return _get_feed_from_cache(key)

rhodecode/controllers/summary.py

➞

Show inline comments

@@ @@ -79,25 +79,24 @@ class SummaryController(BaseRepoControll @@
         for name, chs in c.rhodecode_repo.branches.items():
             #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         download_l.append(branches_group)
         for name, chs in c.rhodecode_repo.tags.items():
             #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         download_l.append(tags_group)
         return download_l
     def __get_readme_data(self, db_repo):
         repo_name = db_repo.repo_name
         @cache_region('long_term')
         def _get_readme_from_cache(key):
             readme_data = None
             readme_file = None
             log.debug('Looking for README file')
             try:
                 # get's the landing revision! or tip if fails
                 cs = db_repo.get_landing_changeset()
                 if isinstance(cs, EmptyChangeset):
@@ @@ -117,28 +116,27 @@ class SummaryController(BaseRepoControll @@
                         continue
             except ChangesetError:
                 log.error(traceback.format_exc())
                 pass
             except EmptyRepositoryError:
                 pass
             except Exception:
                 log.error(traceback.format_exc())
             return readme_data, readme_file
         key = repo_name + '_README'
         inv = CacheInvalidation.invalidate(key)
         if inv is not None:
         valid = CacheInvalidation.test_and_set_valid(key)
         if not valid:
             region_invalidate(_get_readme_from_cache, None, key)
             CacheInvalidation.set_valid(inv.cache_key)
         return _get_readme_from_cache(key)
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, repo_name):
         c.dbrepo = dbrepo = c.rhodecode_db_repo
         _load_changelog_summary()
         if self.rhodecode_user.username == 'default':
             # for default(anonymous) user we don't need to pass credentials
             username = ''
             password = ''

rhodecode/lib/utils.py

➞

Show inline comments

@@ @@ -467,25 +467,25 @@ def repo2db_mapper(initial_repo_list, re @@
             # we added that repo just now, and make sure it has githook
             # installed
             if new_repo.repo_type == 'git':
                 ScmModel().install_git_hook(new_repo.scm_instance)
             new_repo.update_changeset_cache()
         elif install_git_hook:
             if db_repo.repo_type == 'git':
                 ScmModel().install_git_hook(db_repo.scm_instance)
         # during starting install all cache keys for all repositories in the
         # system, this will register all repos and multiple instances
         cache_key = CacheInvalidation._get_cache_key(name)
         log.debug("Creating invalidation cache key for %s: %s", name, cache_key)
-        CacheInvalidation.invalidate(name)
+        CacheInvalidation.test_and_set_valid(name)
     sa.commit()
     removed = []
     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():
                 log.debug("Removing non-existing repository found in db `%s`" %
                           repo.repo_name)
                 try:
                     removed.append(repo.repo_name)
                     RepoModel(sa).delete(repo, forks='detach', fs_remove=False)

rhodecode/model/db.py

➞

Show inline comments

@@ @@ -1154,66 +1154,51 @@ class Repository(Base, BaseModel): @@
                                       pr_id, pr_repo]
         return grouped
     def _repo_size(self):
         from rhodecode.lib import helpers as h
         log.debug('calculating repository size...')
         return h.format_byte_size(self.scm_instance.size)
     #==========================================================================
     # SCM CACHE INSTANCE
     #==========================================================================
     @property
     def invalidate(self):
         return CacheInvalidation.invalidate(self.repo_name)
     def set_invalidate(self):
         """
         Mark caches of this repo as invalid.
         """
         CacheInvalidation.set_invalidate(self.repo_name)
     def scm_instance_no_cache(self):
         return self.__get_instance()
     @property
     def scm_instance(self):
         import rhodecode
         full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))
         if full_cache:
             return self.scm_instance_cached()
         return self.__get_instance()
-    def scm_instance_cached(self, cache_map=None):
+    def scm_instance_cached(self, valid_cache_keys=None):
         @cache_region('long_term')
         def _c(repo_name):
             return self.__get_instance()
         rn = self.repo_name
         if cache_map:
             # get using prefilled cache_map
             invalidate_repo = cache_map[self.repo_name]
             if invalidate_repo:
                 invalidate_repo = (None if invalidate_repo.cache_active
                                    else invalidate_repo)
         else:
             # get from invalidate
             invalidate_repo = self.invalidate
         if invalidate_repo is not None:
         valid = CacheInvalidation.test_and_set_valid(rn, valid_cache_keys=valid_cache_keys)
         if not valid:
             log.debug('Cache for %s invalidated, getting new object' % (rn))
             region_invalidate(_c, None, rn)
             log.debug('Cache for %s invalidated, getting new object' % (rn))
             # update our cache
             CacheInvalidation.set_valid(invalidate_repo.cache_key)
         else:
             log.debug('Getting obj for %s from cache' % (rn))
         return _c(rn)
     def __get_instance(self):
         repo_full_path = self.repo_full_path
         try:
             alias = get_scm(repo_full_path)[0]
             log.debug('Creating instance of %s repository from %s'
                       % (alias, repo_full_path))
             backend = get_backend(alias)
         except VCSError:
@@ @@ -1816,110 +1801,79 @@ class CacheInvalidation(Base, BaseModel) @@
     @classmethod
     def _get_cache_key(cls, key):
         """
         Wrapper for generating a unique cache key for this instance and "key".
         key must / will start with a repo_name which will be stored in .cache_args .
         """
         import rhodecode
         prefix = rhodecode.CONFIG.get('instance_id', '')
         return "%s%s" % (prefix, key)
     @classmethod
     def invalidate(cls, key):
         """
         Returns Invalidation object if the local cache with the given key is invalid,
         None otherwise.
         """
         repo_name = key
         repo_name = remove_suffix(repo_name, '_README')
         repo_name = remove_suffix(repo_name, '_RSS')
         repo_name = remove_suffix(repo_name, '_ATOM')
         cache_key = cls._get_cache_key(key)
         inv_obj = Session().query(cls).filter(cls.cache_key == cache_key).scalar()
         if not inv_obj:
             try:
                 inv_obj = CacheInvalidation(cache_key, repo_name)
                 Session().add(inv_obj)
                 Session().commit()
             except Exception:
                 log.error(traceback.format_exc())
                 Session().rollback()
                 return
         if not inv_obj.cache_active:
             # `cache_active = False` means that this cache
             # no longer is valid
             return inv_obj
     @classmethod
     def set_invalidate(cls, repo_name):
         """
         Mark all caches of a repo as invalid in the database.
         """
         inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()
         try:
             for inv_obj in inv_objs:
                 log.debug('marking %s key for invalidation based on repo_name=%s'
                           % (inv_obj, safe_str(repo_name)))
                 inv_obj.cache_active = False
                 Session().add(inv_obj)
             Session().commit()
         except Exception:
             log.error(traceback.format_exc())
             Session().rollback()
     @classmethod
     def set_valid(cls, cache_key):
     def test_and_set_valid(cls, key, valid_cache_keys=None):
         """
         Mark this cache key as active and currently cached.
         Return True if the existing cache registration still was valid.
         Return False to indicate that it had been invalidated and caches should be refreshed.
         """
         Mark this cache key as active and currently cached
         """
         cache_key = cls._get_cache_key(key)
         if valid_cache_keys and cache_key in valid_cache_keys:
             return True
         repo_name = key
         repo_name = remove_suffix(repo_name, '_README')
         repo_name = remove_suffix(repo_name, '_RSS')
         repo_name = remove_suffix(repo_name, '_ATOM')
         try:
         inv_obj = cls.query().filter(cls.cache_key == cache_key).scalar()
             if not inv_obj:
                 inv_obj = CacheInvalidation(cache_key, repo_name)
             was_valid = inv_obj.cache_active
         inv_obj.cache_active = True
         Session().add(inv_obj)
         Session().commit()
             return was_valid
         except Exception:
             log.error(traceback.format_exc())
             Session().rollback()
             return False
     @classmethod
     def get_cache_map(cls):
         class cachemapdict(dict):
             def __init__(self, *args, **kwargs):
                 self.fixkey = kwargs.pop('fixkey', False)
                 super(cachemapdict, self).__init__(*args, **kwargs)
             def __getattr__(self, name):
                 cache_key = name
                 if self.fixkey:
                     cache_key = cls._get_cache_key(name)
                 if cache_key in self.__dict__:
                     return self.__dict__[cache_key]
                 else:
                     return self[cache_key]
             def __getitem__(self, name):
                 cache_key = name
                 if self.fixkey:
                     cache_key = cls._get_cache_key(name)
                 try:
                     return super(cachemapdict, self).__getitem__(cache_key)
                 except KeyError:
                     return None
         cache_map = cachemapdict(fixkey=True)
         for obj in cls.query().all():
             cache_map[obj.cache_key] = cachemapdict(obj.get_dict())
         return cache_map
     def get_valid_cache_keys(cls):
         """
         Return opaque object with information of which caches still are valid
         and can be used without checking for invalidation.
         """
         return set(inv_obj.cache_key for inv_obj in cls.query().filter(cls.cache_active).all())
 class ChangesetComment(Base, BaseModel):
     __tablename__ = 'changeset_comments'
     __table_args__ = (
         Index('cc_revision_idx', 'revision'),
         {'extend_existing': True, 'mysql_engine': 'InnoDB',
          'mysql_charset': 'utf8'},
+    )
     comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)
     repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)
     revision = Column('revision', String(40), nullable=True)

rhodecode/model/scm.py

➞

Show inline comments

@@ @@ -88,30 +88,30 @@ class CachedRepoList(object): @@
         if not perm_set:
             perm_set = ['repository.read', 'repository.write',
                         'repository.admin']
         self.perm_set = perm_set
     def __len__(self):
         return len(self.db_repo_list)
     def __repr__(self):
         return '<%s (%s)>' % (self.__class__.__name__, self.__len__())
     def __iter__(self):
-        # pre-propagated cache_map to save executing select statements
+        # pre-propagated valid_cache_keys to save executing select statements
         # for each repo
-        cache_map = CacheInvalidation.get_cache_map()
+        valid_cache_keys = CacheInvalidation.get_valid_cache_keys()
         for dbr in self.db_repo_list:
-            scmr = dbr.scm_instance_cached(cache_map)
+            scmr = dbr.scm_instance_cached(valid_cache_keys)
             # check permission at this level
             if not HasRepoPermissionAny(
                 *self.perm_set)(dbr.repo_name, 'get repo check'):
                 continue
             try:
                 last_change = scmr.last_change
                 tip = h.get_changeset_safe(scmr, 'tip')
             except Exception:
                 log.error(
                     '%s this repository is present in database but it '
                     'cannot be created as an scm instance, org_exc:%s'

0 comments (0 inline, 0 general)