Changeset - c8ecfe42b285
Parent rev.
Child rev.
[Not reviewed]
beta
0 3 0
Mads Kiilerich - 13 years ago 2013-03-26 23:15:16
madski@unity3d.com
invalidation: some documentation and refactoring
3 files changed with 37 insertions and 56 deletions:
rhodecode/lib/utils.py
2
8
rhodecode/model/db.py
34
47
rhodecode/templates/admin/repos/repo_edit.html
1
1
0 comments (0 inline, 0 general)
rhodecode/lib/utils.py
➞
Show inline comments
 
@@ -426,17 +426,12 @@ def repo2db_mapper(initial_repo_list, re
 
    rm = RepoModel()
 
    user = sa.query(User).filter(User.admin == True).first()
 
    if user is None:
 
        raise Exception('Missing administrative account!')
 
    added = []
 

			




	
	
	
		
 
#    # clear cache keys

			




	
	
	
		
 
#    log.debug("Clearing cache keys now...")

			




	
	
	
		
 
#    CacheInvalidation.clear_cache()

			




	
	
	
		
 
#    sa.commit()

			




	
	
	
		
 

			




	
	
	
		
 
    ##creation defaults

			




	
	
	
		
 
    defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

			




	
	
	
		
 
    enable_statistics = defs.get('repo_enable_statistics')

			




	
	
	
		
 
    enable_locking = defs.get('repo_enable_locking')

			




	
	
	
		
 
    enable_downloads = defs.get('repo_enable_downloads')

			




	
	
	
		
 
    private = defs.get('repo_private')

			




	
	
		
 
@@ -471,16 +466,15 @@ def repo2db_mapper(initial_repo_list, re

			




	
	
	
		
 
            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

			




	
	
	
		
 
        key, _prefix, _org_key = CacheInvalidation._get_key(name)

			




	
	
	
		
 
        cache_key = CacheInvalidation._get_cache_key(name)

			




	
	
	
		
 
        log.debug("Creating invalidation cache key for %s: %s", name, cache_key)

			




	
	
	
		
 
        CacheInvalidation.invalidate(name)

			




	
	
	
		
 
        log.debug("Creating a cache key for %s, instance_id %s"

			




	
	
	
		
 
                  % (name, _prefix or 'unknown'))

			




	
	
	
		
 

			




	
	
	
		
 
    sa.commit()

			




	
	
	
		
 
    removed = []

			




	
	
	
		
 
    if remove_obsolete:

			




	
	
	
		
 
        # remove from database those repositories that are not in the filesystem

			




	
	
	
		
 
        for repo in sa.query(Repository).all():

			




        

    


    
    

    

        

                

                    rhodecode/model/db.py
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -1627,63 +1627,51 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
    __table_args__ = (

			




	
	
	
		
 
        UniqueConstraint('cache_key'),

			




	
	
	
		
 
        Index('key_idx', 'cache_key'),

			




	
	
	
		
 
        {'extend_existing': True, 'mysql_engine': 'InnoDB',

			




	
	
	
		
 
         'mysql_charset': 'utf8'},

			




	
	
	
		
 
    )

			




	
	
	
		
 
    # cache_id, not used

			




	
	
	
		
 
    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

			




	
	
	
		
 
    # cache_key as created by _get_cache_key

			




	
	
	
		
 
    cache_key = Column("cache_key", String(255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    # cache_args is usually a repo_name, possibly with _README/_RSS/_ATOM suffix

			




	
	
	
		
 
    cache_args = Column("cache_args", String(255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

			




	
	
	
		
 
    # instance sets cache_active True when it is caching, other instances set cache_active to False to invalidate

			




	
	
	
		
 
    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

			




	
	
	
		
 

			




	
	
	
		
 
    def __init__(self, cache_key, cache_args=''):

			




	
	
	
		
 
        self.cache_key = cache_key

			




	
	
	
		
 
        self.cache_args = cache_args

			




	
	
	
		
 
        self.cache_active = False

			




	
	
	
		
 

			




	
	
	
		
 
    def __unicode__(self):

			




	
	
	
		
 
        return u"<%s('%s:%s')>" % (self.__class__.__name__,

			




	
	
	
		
 
                                  self.cache_id, self.cache_key)

			




	
	
	
		
 

			




	
	
	
		
 
    @property

			




	
	
	
		
 
    def prefix(self):

			




	
	
	
		
 
    def get_prefix(self):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Guess prefix that might have been used in _get_cache_key to generate self.cache_key .

			




	
	
	
		
 
        Only used for informational purposes in repo_edit.html .

			




	
	
	
		
 
        """

			




	
	
	
		
 
        _split = self.cache_key.split(self.cache_args, 1)

			




	
	
	
		
 
        if _split and len(_split) == 2:

			




	
	
	
		
 
        if len(_split) == 2:

			




	
	
	
		
 
            return _split[0]

			




	
	
	
		
 
        return ''

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def clear_cache(cls):

			




	
	
	
		
 
        cls.query().delete()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _get_key(cls, key):

			




	
	
	
		
 
    def _get_cache_key(cls, key):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Wrapper for generating a key, together with a prefix

			




	
	
	
		
 

			




	
	
	
		
 
        :param key:

			




	
	
	
		
 
        Wrapper for generating a unique cache key for this instance and "key".

			




	
	
	
		
 
        """

			




	
	
	
		
 
        import rhodecode

			




	
	
	
		
 
        prefix = ''

			




	
	
	
		
 
        org_key = key

			




	
	
	
		
 
        iid = rhodecode.CONFIG.get('instance_id')

			




	
	
	
		
 
        if iid:

			




	
	
	
		
 
            prefix = iid

			




	
	
	
		
 

			




	
	
	
		
 
        return "%s%s" % (prefix, key), prefix, org_key

			




	
	
	
		
 
        prefix = rhodecode.CONFIG.get('instance_id', '')

			




	
	
	
		
 
        return "%s%s" % (prefix, key)

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_key(cls, key):

			




	
	
	
		
 
        return cls.query().filter(cls.cache_key == key).scalar()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_by_repo_name(cls, repo_name):

			




	
	
	
		
 
        return cls.query().filter(cls.cache_args == repo_name).all()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def _get_or_create_key(cls, key, repo_name, commit=True):

			




	
	
	
		
 
    def _get_or_create_inv_obj(cls, key, repo_name, commit=True):

			




	
	
	
		
 
        inv_obj = Session().query(cls).filter(cls.cache_key == key).scalar()

			




	
	
	
		
 
        if not inv_obj:

			




	
	
	
		
 
            try:

			




	
	
	
		
 
                inv_obj = CacheInvalidation(key, repo_name)

			




	
	
	
		
 
                Session().add(inv_obj)

			




	
	
	
		
 
                if commit:

			




	
	
		
 
@@ -1704,15 +1692,14 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
        """

			




	
	
	
		
 
        repo_name = key

			




	
	
	
		
 
        repo_name = remove_suffix(repo_name, '_README')

			




	
	
	
		
 
        repo_name = remove_suffix(repo_name, '_RSS')

			




	
	
	
		
 
        repo_name = remove_suffix(repo_name, '_ATOM')

			




	
	
	
		
 

			




	
	
	
		
 
        # adds instance prefix

			




	
	
	
		
 
        key, _prefix, _org_key = cls._get_key(key)

			




	
	
	
		
 
        inv = cls._get_or_create_key(key, repo_name)

			




	
	
	
		
 
        cache_key = cls._get_cache_key(key)

			




	
	
	
		
 
        inv = cls._get_or_create_inv_obj(cache_key, repo_name)

			




	
	
	
		
 

			




	
	
	
		
 
        if inv and inv.cache_active is False:

			




	
	
	
		
 
            return inv

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def set_invalidate(cls, key=None, repo_name=None):

			




	
	
		
 
@@ -1721,15 +1708,17 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
        cache sets based on repo_name

			




	
	
	
		
 

			




	
	
	
		
 
        :param key:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        invalidated_keys = []

			




	
	
	
		
 
        if key:

			




	
	
	
		
 
            key, _prefix, _org_key = cls._get_key(key)

			




	
	
	
		
 
            inv_objs = Session().query(cls).filter(cls.cache_key == key).all()

			




	
	
	
		
 
        elif repo_name:

			




	
	
	
		
 
            assert not repo_name

			




	
	
	
		
 
            cache_key = cls._get_cache_key(key)

			




	
	
	
		
 
            inv_objs = Session().query(cls).filter(cls.cache_key == cache_key).all()

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            assert repo_name

			




	
	
	
		
 
            inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

			




	
	
	
		
 

			




	
	
	
		
 
        try:

			




	
	
	
		
 
            for inv_obj in inv_objs:

			




	
	
	
		
 
                inv_obj.cache_active = False

			




	
	
	
		
 
                log.debug('marking %s key for invalidation based on key=%s,repo_name=%s'

			




	
	
		
 
@@ -1746,45 +1735,43 @@ class CacheInvalidation(Base, BaseModel)

			




	
	
	
		
 
    def set_valid(cls, key):

			




	
	
	
		
 
        """

			




	
	
	
		
 
        Mark this cache key as active and currently cached

			




	
	
	
		
 

			




	
	
	
		
 
        :param key:

			




	
	
	
		
 
        """

			




	
	
	
		
 
        inv_obj = cls.get_by_key(key)

			




	
	
	
		
 
        inv_obj = cls.query().filter(cls.cache_key == key).scalar()

			




	
	
	
		
 
        inv_obj.cache_active = True

			




	
	
	
		
 
        Session().add(inv_obj)

			




	
	
	
		
 
        Session().commit()

			




	
	
	
		
 

			




	
	
	
		
 
    @classmethod

			




	
	
	
		
 
    def get_cache_map(cls):

			




	
	
	
		
 

			




	
	
	
		
 
        class cachemapdict(dict):

			




	
	
	
		
 

			




	
	
	
		
 
            def __init__(self, *args, **kwargs):

			




	
	
	
		
 
                fixkey = kwargs.get('fixkey')

			




	
	
	
		
 
                if fixkey:

			




	
	
	
		
 
                    del kwargs['fixkey']

			




	
	
	
		
 
                self.fixkey = fixkey

			




	
	
	
		
 
                self.fixkey = kwargs.pop('fixkey', False)

			




	
	
	
		
 
                super(cachemapdict, self).__init__(*args, **kwargs)

			




	
	
	
		
 

			




	
	
	
		
 
            def __getattr__(self, name):

			




	
	
	
		
 
                key = name

			




	
	
	
		
 
                cache_key = name

			




	
	
	
		
 
                if self.fixkey:

			




	
	
	
		
 
                    key, _prefix, _org_key = cls._get_key(key)

			




	
	
	
		
 
                if key in self.__dict__:

			




	
	
	
		
 
                    return self.__dict__[key]

			




	
	
	
		
 
                    cache_key = cls._get_cache_key(name)

			




	
	
	
		
 
                if cache_key in self.__dict__:

			




	
	
	
		
 
                    return self.__dict__[cache_key]

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    return self[key]

			




	
	
	
		
 
                    return self[cache_key]

			




	
	
	
		
 

			




	
	
	
		
 
            def __getitem__(self, key):

			




	
	
	
		
 
            def __getitem__(self, name):

			




	
	
	
		
 
                cache_key = name

			




	
	
	
		
 
                if self.fixkey:

			




	
	
	
		
 
                    key, _prefix, _org_key = cls._get_key(key)

			




	
	
	
		
 
                    cache_key = cls._get_cache_key(name)

			




	
	
	
		
 
                try:

			




	
	
	
		
 
                    return super(cachemapdict, self).__getitem__(key)

			




	
	
	
		
 
                    return super(cachemapdict, self).__getitem__(cache_key)

			




	
	
	
		
 
                except KeyError:

			




	
	
	
		
 
                    return

			




	
	
	
		
 
                    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

			




	
	
	
		
 

			




        

    


    
    

    

        

                

                    rhodecode/templates/admin/repos/repo_edit.html
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -216,13 +216,13 @@ ${self.context_bar('options')}

			




	
	
	
		
 
                <th>${_('Prefix')}</th>

			




	
	
	
		
 
                <th>${_('Key')}</th>

			




	
	
	
		
 
                <th>${_('Active')}</th>

			




	
	
	
		
 
                </tr>

			




	
	
	
		
 
              %for cache in c.repo_info.cache_keys:

			




	
	
	
		
 
                  <tr>

			




	
	
	
		
 
                    <td>${cache.prefix or '-'}</td>

			




	
	
	
		
 
                    <td>${cache.get_prefix() or '-'}</td>

			




	
	
	
		
 
                    <td>${cache.cache_key}</td>

			




	
	
	
		
 
                    <td>${h.bool2icon(cache.cache_active)}</td>

			




	
	
	
		
 
                  </tr>

			




	
	
	
		
 
              %endfor

			




	
	
	
		
 
              </table>

			




	
	
	
		
 
          </div>

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        
    
    
        This site is powered by
            Kallithea 0.7.0,
        which is
        © 2010–2025 by various authors & licensed under GPLv3.