@@ -46,193 +46,193 @@ from rhodecode.lib.utils import get_repo
action_logger
from rhodecode.model import BaseModel
from rhodecode.model.user import UserModel
from rhodecode.model.repo import RepoModel
from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \
UserFollowing, UserLog
from rhodecode.model.caching_query import FromCache
log = logging.getLogger(__name__)
class UserTemp(object):
def __init__(self, user_id):
self.user_id = user_id
def __repr__(self):
return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)
class RepoTemp(object):
def __init__(self, repo_id):
self.repo_id = repo_id
return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)
class ScmModel(BaseModel):
"""Generic Scm Model
"""
@LazyProperty
def repos_path(self):
"""Get's the repositories root path from database
q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()
return q.ui_value
def repo_scan(self, repos_path=None):
"""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 containing repositories
log.info('scanning for repositories in %s', repos_path)
if repos_path is None:
repos_path = self.repos_path
baseui = make_ui('db')
repos_list = {}
for name, path in get_filesystem_repos(repos_path, recursive=True):
try:
if name in repos_list:
raise RepositoryError('Duplicate repository name %s '
'found in %s' % (name, path))
else:
klass = get_backend(path[0])
if path[0] == 'hg' and path[0] in BACKENDS.keys():
repos_list[name] = klass(path[1], baseui=baseui)
if path[0] == 'git' and path[0] in BACKENDS.keys():
repos_list[name] = klass(path[1])
except OSError:
continue
return repos_list
def get_repos(self, all_repos=None):
"""Get all repos from db and for each repo create it's
backend instance and fill that backed with information from database
:param all_repos: give specific repositories list, good for filtering
this have to be a list of just the repository names
if all_repos is None:
repos = self.sa.query(Repository)\
.order_by(Repository.repo_name).all()
all_repos = [r.repo_name for r in repos]
#get the repositories that should be invalidated
invalidation_list = [str(x.cache_key) for x in \
self.sa.query(CacheInvalidation.cache_key)\
.filter(CacheInvalidation.cache_active == False)\
.all()]
for r_name in all_repos:
r_dbr = self.get(r_name, invalidation_list)
if r_dbr is not None:
repo, dbrepo = r_dbr
if repo is None and dbrepo is None:
if repo is None or dbrepo is None:
log.error('Repository %s looks somehow corrupted', r_name)
last_change = repo.last_change
tip = h.get_changeset_safe(repo, 'tip')
tmp_d = {}
tmp_d['name'] = dbrepo.repo_name
tmp_d['name_sort'] = tmp_d['name'].lower()
tmp_d['description'] = dbrepo.description
tmp_d['description_sort'] = tmp_d['description']
tmp_d['last_change'] = last_change
tmp_d['last_change_sort'] = time.mktime(last_change \
.timetuple())
tmp_d['tip'] = tip.raw_id
tmp_d['tip_sort'] = tip.revision
tmp_d['rev'] = tip.revision
tmp_d['contact'] = dbrepo.user.full_contact
tmp_d['contact_sort'] = tmp_d['contact']
tmp_d['owner_sort'] = tmp_d['contact']
tmp_d['repo_archives'] = list(repo._get_archives())
tmp_d['last_msg'] = tip.message
tmp_d['repo'] = repo
tmp_d['dbrepo'] = dbrepo.get_dict()
tmp_d['dbrepo_fork'] = dbrepo.fork.get_dict() if dbrepo.fork \
else {}
yield tmp_d
def get(self, repo_name, invalidation_list=None, retval='all'):
"""Returns a tuple of Repository,DbRepository,
Get's repository from given name, creates BackendInstance and
propagates it's data from database with all additional information
:param repo_name:
:param invalidation_list: if a invalidation list is given the get
method should not manually check if this repository needs
invalidation and just invalidate the repositories in list
:param retval: string specifing what to return one of 'repo','dbrepo',
'all'if repo or dbrepo is given it'll just lazy load chosen type
and return None as the second
if not HasRepoPermissionAny('repository.read', 'repository.write',
'repository.admin')(repo_name, 'get repo check'):
return
#======================================================================
# CACHE FUNCTION
@cache_region('long_term')
def _get_repo(repo_name):
repo_path = os.path.join(self.repos_path, repo_name)
alias = get_scm(repo_path)[0]
log.debug('Creating instance of %s repository', alias)
backend = get_backend(alias)
except VCSError:
log.error(traceback.format_exc())
log.error('Perhaps this repository is in db and not in '
'filesystem run rescan repositories with '
'"destroy old data " option from admin panel')
if alias == 'hg':
repo = backend(repo_path, create=False, baseui=make_ui('db'))
#skip hidden web repository
if repo._get_hidden():
repo = backend(repo_path, create=False)
return repo
pre_invalidate = True
dbinvalidate = False
if invalidation_list is not None:
pre_invalidate = repo_name in invalidation_list
if pre_invalidate:
#this returns object to invalidate
invalidate = self._should_invalidate(repo_name)
if invalidate:
log.info('invalidating cache for repository %s', repo_name)
region_invalidate(_get_repo, None, repo_name)
self._mark_invalidated(invalidate)
dbinvalidate = True
r, dbr = None, None
if retval == 'repo' or 'all':
r = _get_repo(repo_name)
if retval == 'dbrepo' or 'all':
dbr = RepoModel().get_full(repo_name, cache=True,
invalidate=dbinvalidate)
return r, dbr
Status change: