scm.py
407 lines
| 13.5 KiB
| text/x-python
|
PythonLexer
r757 | # -*- coding: utf-8 -*- | |||
""" | ||||
r811 | rhodecode.model.scm | |||
~~~~~~~~~~~~~~~~~~~ | ||||
r757 | ||||
r811 | Scm model for RhodeCode | |||
r757 | :created_on: Apr 9, 2010 | |||
:author: marcink | ||||
r1203 | :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com> | |||
r757 | :license: GPLv3, see COPYING for more details. | |||
""" | ||||
r1206 | # 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, either version 3 of the License, or | ||||
# (at your option) any later version. | ||||
r1203 | # | |||
r691 | # 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. | ||||
r1203 | # | |||
r691 | # You should have received a copy of the GNU General Public License | |||
r1206 | # along with this program. If not, see <http://www.gnu.org/licenses/>. | |||
r757 | import os | |||
import time | ||||
import traceback | ||||
import logging | ||||
r1022 | from sqlalchemy.exc import DatabaseError | |||
r757 | from vcs import get_backend | |||
r1437 | from vcs.exceptions import RepositoryError | |||
r757 | from vcs.utils.lazy import LazyProperty | |||
r1311 | from vcs.nodes import FileNode | |||
r757 | ||||
r710 | from rhodecode import BACKENDS | |||
r691 | from rhodecode.lib import helpers as h | |||
r1401 | from rhodecode.lib import safe_str | |||
r691 | from rhodecode.lib.auth import HasRepoPermissionAny | |||
r1038 | from rhodecode.lib.utils import get_repos as get_filesystem_repos, make_ui, \ | |||
r1483 | action_logger, EmptyChangeset | |||
r752 | from rhodecode.model import BaseModel | |||
r758 | from rhodecode.model.user import UserModel | |||
from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \ | ||||
r784 | UserFollowing, UserLog | |||
r757 | ||||
r691 | log = logging.getLogger(__name__) | |||
r757 | ||||
r735 | class UserTemp(object): | |||
def __init__(self, user_id): | ||||
self.user_id = user_id | ||||
r901 | ||||
def __repr__(self): | ||||
return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id) | ||||
r1213 | ||||
r735 | class RepoTemp(object): | |||
def __init__(self, repo_id): | ||||
self.repo_id = repo_id | ||||
r747 | ||||
r901 | def __repr__(self): | |||
return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id) | ||||
r1366 | class CachedRepoList(object): | |||
r1428 | def __init__(self, db_repo_list, repos_path, order_by=None): | |||
r1366 | self.db_repo_list = db_repo_list | |||
self.repos_path = repos_path | ||||
self.order_by = order_by | ||||
self.reversed = (order_by or '').startswith('-') | ||||
def __len__(self): | ||||
return len(self.db_repo_list) | ||||
def __repr__(self): | ||||
return '<%s (%s)>' % (self.__class__.__name__, self.__len__()) | ||||
def __iter__(self): | ||||
r1428 | for dbr in self.db_repo_list: | |||
r1366 | ||||
r1428 | scmr = dbr.scm_instance_cached | |||
r1366 | ||||
r1437 | # check permission at this level | |||
if not HasRepoPermissionAny('repository.read', 'repository.write', | ||||
r1366 | 'repository.admin')(dbr.repo_name, | |||
'get repo check'): | ||||
continue | ||||
r1380 | if scmr is None: | |||
r1373 | log.error('%s this repository is present in database but it ' | |||
'cannot be created as an scm instance', | ||||
dbr.repo_name) | ||||
continue | ||||
r1366 | ||||
last_change = scmr.last_change | ||||
tip = h.get_changeset_safe(scmr, 'tip') | ||||
tmp_d = {} | ||||
tmp_d['name'] = dbr.repo_name | ||||
tmp_d['name_sort'] = tmp_d['name'].lower() | ||||
tmp_d['description'] = dbr.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'] = dbr.user.full_contact | ||||
tmp_d['contact_sort'] = tmp_d['contact'] | ||||
tmp_d['owner_sort'] = tmp_d['contact'] | ||||
tmp_d['repo_archives'] = list(scmr._get_archives()) | ||||
tmp_d['last_msg'] = tip.message | ||||
r1459 | tmp_d['author'] = tip.author | |||
r1366 | tmp_d['dbrepo'] = dbr.get_dict() | |||
tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork \ | ||||
else {} | ||||
yield tmp_d | ||||
r1213 | ||||
r752 | class ScmModel(BaseModel): | |||
r811 | """Generic Scm Model | |||
r691 | """ | |||
@LazyProperty | ||||
def repos_path(self): | ||||
r811 | """Get's the repositories root path from database | |||
r691 | """ | |||
r811 | ||||
r691 | q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one() | |||
return q.ui_value | ||||
r1038 | def repo_scan(self, repos_path=None): | |||
r1203 | """Listing of repositories in given path. This path should not be a | |||
r691 | repository itself. Return a dictionary of repository objects | |||
r1203 | ||||
r691 | :param repos_path: path to directory containing repositories | |||
""" | ||||
r811 | ||||
r691 | log.info('scanning for repositories in %s', repos_path) | |||
r1038 | if repos_path is None: | |||
repos_path = self.repos_path | ||||
baseui = make_ui('db') | ||||
r691 | repos_list = {} | |||
r877 | for name, path in get_filesystem_repos(repos_path, recursive=True): | |||
r691 | try: | |||
r1213 | if name in repos_list: | |||
r691 | raise RepositoryError('Duplicate repository name %s ' | |||
'found in %s' % (name, path)) | ||||
else: | ||||
klass = get_backend(path[0]) | ||||
r710 | if path[0] == 'hg' and path[0] in BACKENDS.keys(): | |||
r1401 | ||||
# for mercurial we need to have an str path | ||||
repos_list[name] = klass(safe_str(path[1]), | ||||
baseui=baseui) | ||||
r691 | ||||
r710 | if path[0] == 'git' and path[0] in BACKENDS.keys(): | |||
r691 | repos_list[name] = klass(path[1]) | |||
except OSError: | ||||
continue | ||||
return repos_list | ||||
r1366 | def get_repos(self, all_repos=None, sort_key=None): | |||
r1343 | """ | |||
Get all repos from db and for each repo create it's | ||||
r1213 | backend instance and fill that backed with information from database | |||
r1203 | ||||
r1343 | :param all_repos: list of repository names as strings | |||
give specific repositories list, good for filtering | ||||
r691 | """ | |||
r767 | if all_repos is None: | |||
r1366 | all_repos = self.sa.query(Repository)\ | |||
r1343 | .filter(Repository.group_id == None)\ | |||
r1193 | .order_by(Repository.repo_name).all() | |||
r691 | ||||
r1428 | repo_iter = CachedRepoList(all_repos, repos_path=self.repos_path, | |||
r1366 | order_by=sort_key) | |||
r691 | ||||
r1366 | return repo_iter | |||
r691 | ||||
r692 | def mark_for_invalidation(self, repo_name): | |||
r1203 | """Puts cache invalidation task into db for | |||
r692 | further global cache invalidation | |||
r1203 | ||||
r692 | :param repo_name: this repo that should invalidation take place | |||
""" | ||||
r811 | ||||
r692 | log.debug('marking %s for invalidation', repo_name) | |||
cache = self.sa.query(CacheInvalidation)\ | ||||
.filter(CacheInvalidation.cache_key == repo_name).scalar() | ||||
if cache: | ||||
r1428 | # mark this cache as inactive | |||
r692 | cache.cache_active = False | |||
else: | ||||
log.debug('cache key not found in invalidation db -> creating one') | ||||
cache = CacheInvalidation(repo_name) | ||||
try: | ||||
self.sa.add(cache) | ||||
self.sa.commit() | ||||
r758 | except (DatabaseError,): | |||
r692 | log.error(traceback.format_exc()) | |||
self.sa.rollback() | ||||
r734 | def toggle_following_repo(self, follow_repo_id, user_id): | |||
r692 | ||||
r734 | f = self.sa.query(UserFollowing)\ | |||
.filter(UserFollowing.follows_repo_id == follow_repo_id)\ | ||||
.filter(UserFollowing.user_id == user_id).scalar() | ||||
if f is not None: | ||||
r747 | ||||
r734 | try: | |||
self.sa.delete(f) | ||||
self.sa.commit() | ||||
r735 | action_logger(UserTemp(user_id), | |||
'stopped_following_repo', | ||||
r747 | RepoTemp(follow_repo_id)) | |||
r734 | return | |||
except: | ||||
log.error(traceback.format_exc()) | ||||
self.sa.rollback() | ||||
raise | ||||
try: | ||||
f = UserFollowing() | ||||
f.user_id = user_id | ||||
f.follows_repo_id = follow_repo_id | ||||
self.sa.add(f) | ||||
self.sa.commit() | ||||
r735 | action_logger(UserTemp(user_id), | |||
'started_following_repo', | ||||
r747 | RepoTemp(follow_repo_id)) | |||
r734 | except: | |||
log.error(traceback.format_exc()) | ||||
self.sa.rollback() | ||||
raise | ||||
r1213 | def toggle_following_user(self, follow_user_id, user_id): | |||
r734 | f = self.sa.query(UserFollowing)\ | |||
.filter(UserFollowing.follows_user_id == follow_user_id)\ | ||||
.filter(UserFollowing.user_id == user_id).scalar() | ||||
if f is not None: | ||||
try: | ||||
self.sa.delete(f) | ||||
self.sa.commit() | ||||
return | ||||
except: | ||||
log.error(traceback.format_exc()) | ||||
self.sa.rollback() | ||||
raise | ||||
try: | ||||
f = UserFollowing() | ||||
f.user_id = user_id | ||||
f.follows_user_id = follow_user_id | ||||
self.sa.add(f) | ||||
self.sa.commit() | ||||
except: | ||||
log.error(traceback.format_exc()) | ||||
self.sa.rollback() | ||||
raise | ||||
r999 | def is_following_repo(self, repo_name, user_id, cache=False): | |||
r734 | r = self.sa.query(Repository)\ | |||
.filter(Repository.repo_name == repo_name).scalar() | ||||
f = self.sa.query(UserFollowing)\ | ||||
.filter(UserFollowing.follows_repository == r)\ | ||||
.filter(UserFollowing.user_id == user_id).scalar() | ||||
return f is not None | ||||
r999 | def is_following_user(self, username, user_id, cache=False): | |||
r758 | u = UserModel(self.sa).get_by_username(username) | |||
r734 | ||||
f = self.sa.query(UserFollowing)\ | ||||
.filter(UserFollowing.follows_user == u)\ | ||||
.filter(UserFollowing.user_id == user_id).scalar() | ||||
return f is not None | ||||
r692 | ||||
r747 | def get_followers(self, repo_id): | |||
r1282 | if not isinstance(repo_id, int): | |||
repo_id = getattr(Repository.by_repo_name(repo_id), 'repo_id') | ||||
return self.sa.query(UserFollowing)\ | ||||
.filter(UserFollowing.follows_repo_id == repo_id).count() | ||||
r747 | ||||
def get_forks(self, repo_id): | ||||
r1282 | if not isinstance(repo_id, int): | |||
repo_id = getattr(Repository.by_repo_name(repo_id), 'repo_id') | ||||
return self.sa.query(Repository)\ | ||||
r747 | .filter(Repository.fork_id == repo_id).count() | |||
r692 | ||||
r1114 | def pull_changes(self, repo_name, username): | |||
r1370 | dbrepo = Repository.by_repo_name(repo_name) | |||
repo = dbrepo.scm_instance | ||||
r1114 | try: | |||
r1213 | extras = {'ip': '', | |||
'username': username, | ||||
'action': 'push_remote', | ||||
'repository': repo_name} | ||||
r1114 | ||||
r1203 | #inject ui extra param to log this action via push logger | |||
r1114 | for k, v in extras.items(): | |||
repo._repo.ui.setconfig('rhodecode_extras', k, v) | ||||
repo.pull(dbrepo.clone_uri) | ||||
self.mark_for_invalidation(repo_name) | ||||
except: | ||||
log.error(traceback.format_exc()) | ||||
raise | ||||
r1311 | ||||
r1312 | def commit_change(self, repo, repo_name, cs, user, author, message, content, | |||
r1311 | f_path): | |||
if repo.alias == 'hg': | ||||
from vcs.backends.hg import MercurialInMemoryChangeset as IMC | ||||
elif repo.alias == 'git': | ||||
from vcs.backends.git import GitInMemoryChangeset as IMC | ||||
# decoding here will force that we have proper encoded values | ||||
# in any other case this will throw exceptions and deny commit | ||||
r1401 | content = safe_str(content) | |||
message = safe_str(message) | ||||
path = safe_str(f_path) | ||||
author = safe_str(author) | ||||
r1311 | m = IMC(repo) | |||
m.change(FileNode(path, content)) | ||||
r1312 | tip = m.commit(message=message, | |||
r1311 | author=author, | |||
parents=[cs], branch=cs.branch) | ||||
r1312 | new_cs = tip.short_id | |||
action = 'push_local:%s' % new_cs | ||||
action_logger(user, action, repo_name) | ||||
r1311 | self.mark_for_invalidation(repo_name) | |||
r1483 | def create_node(self, repo, repo_name, cs, user, author, message, content, | |||
f_path): | ||||
if repo.alias == 'hg': | ||||
from vcs.backends.hg import MercurialInMemoryChangeset as IMC | ||||
elif repo.alias == 'git': | ||||
from vcs.backends.git import GitInMemoryChangeset as IMC | ||||
# decoding here will force that we have proper encoded values | ||||
# in any other case this will throw exceptions and deny commit | ||||
r1485 | ||||
if isinstance(content,(basestring,)): | ||||
content = safe_str(content) | ||||
elif isinstance(content,file): | ||||
content = content.read() | ||||
r1483 | message = safe_str(message) | |||
path = safe_str(f_path) | ||||
author = safe_str(author) | ||||
m = IMC(repo) | ||||
if isinstance(cs, EmptyChangeset): | ||||
# Emptychangeset means we we're editing empty repository | ||||
parents = None | ||||
else: | ||||
parents = [cs] | ||||
m.add(FileNode(path, content=content)) | ||||
tip = m.commit(message=message, | ||||
author=author, | ||||
parents=parents, branch=cs.branch) | ||||
new_cs = tip.short_id | ||||
action = 'push_local:%s' % new_cs | ||||
action_logger(user, action, repo_name) | ||||
self.mark_for_invalidation(repo_name) | ||||
r1311 | ||||
r784 | def get_unread_journal(self): | |||
return self.sa.query(UserLog).count() | ||||
r692 | def _should_invalidate(self, repo_name): | |||
r811 | """Looks up database for invalidation signals for this repo_name | |||
r1203 | ||||
r692 | :param repo_name: | |||
""" | ||||
ret = self.sa.query(CacheInvalidation)\ | ||||
.filter(CacheInvalidation.cache_key == repo_name)\ | ||||
.filter(CacheInvalidation.cache_active == False)\ | ||||
.scalar() | ||||
return ret | ||||
r1483 | ||||