hooks.py
476 lines
| 14.3 KiB
| text/x-python
|
PythonLexer
r913 | # -*- coding: utf-8 -*- | |||
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 | # | |||
r547 | # 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 | # | |||
r547 | # 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/>. | |||
|
r4116 | """ | ||
rhodecode.lib.hooks | ||||
~~~~~~~~~~~~~~~~~~~ | ||||
Hooks runned by rhodecode | ||||
:created_on: Aug 6, 2010 | ||||
:author: marcink | ||||
:copyright: (c) 2013 RhodeCode GmbH. | ||||
:license: GPLv3, see LICENSE for more details. | ||||
""" | ||||
r913 | import os | |||
import sys | ||||
r2904 | import time | |||
r2324 | import binascii | |||
r547 | ||||
r3941 | from rhodecode.lib.vcs.utils.hgcompat import nullrev, revrange | |||
r654 | from rhodecode.lib import helpers as h | |||
from rhodecode.lib.utils import action_logger | ||||
r2404 | from rhodecode.lib.vcs.backends.base import EmptyChangeset | |||
r4074 | from rhodecode.lib.exceptions import HTTPLockedRC, UserCreationError | |||
r3577 | from rhodecode.lib.utils2 import safe_str, _extract_extras | |||
r2818 | from rhodecode.model.db import Repository, User | |||
r1307 | ||||
r2904 | ||||
r2196 | def _get_scm_size(alias, root_path): | |||
if not alias.startswith('.'): | ||||
alias += '.' | ||||
size_scm, size_root = 0, 0 | ||||
r2963 | for path, dirs, files in os.walk(safe_str(root_path)): | |||
r2196 | if path.find(alias) != -1: | |||
for f in files: | ||||
try: | ||||
size_scm += os.path.getsize(os.path.join(path, f)) | ||||
except OSError: | ||||
pass | ||||
else: | ||||
for f in files: | ||||
try: | ||||
size_root += os.path.getsize(os.path.join(path, f)) | ||||
except OSError: | ||||
pass | ||||
size_scm_f = h.format_byte_size(size_scm) | ||||
size_root_f = h.format_byte_size(size_root) | ||||
size_total_f = h.format_byte_size(size_root + size_scm) | ||||
return size_scm_f, size_root_f, size_total_f | ||||
r547 | def repo_size(ui, repo, hooktype=None, **kwargs): | |||
r1722 | """ | |||
Presents size of repository after push | ||||
r1203 | ||||
r913 | :param ui: | |||
:param repo: | ||||
:param hooktype: | ||||
""" | ||||
r547 | ||||
r2196 | size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', repo.root) | |||
r1814 | ||||
last_cs = repo[len(repo) - 1] | ||||
msg = ('Repository size .hg:%s repo:%s total:%s\n' | ||||
'Last revision is now r%s:%s\n') % ( | ||||
size_hg_f, size_root_f, size_total_f, last_cs.rev(), last_cs.hex()[:12] | ||||
) | ||||
sys.stdout.write(msg) | ||||
r675 | ||||
r1307 | ||||
r2726 | def pre_push(ui, repo, **kwargs): | |||
# pre push function, currently used to ban pushing when | ||||
# repository is locked | ||||
r3577 | ex = _extract_extras() | |||
r2726 | ||||
r3577 | usr = User.get_by_username(ex.username) | |||
if ex.locked_by[0] and usr.user_id != int(ex.locked_by[0]): | ||||
locked_by = User.get(ex.locked_by[0]).username | ||||
r3522 | # this exception is interpreted in git/hg middlewares and based | |||
# on that proper return code is server to client | ||||
r3577 | _http_ret = HTTPLockedRC(ex.repository, locked_by) | |||
r3522 | if str(_http_ret.code).startswith('2'): | |||
#2xx Codes don't raise exceptions | ||||
sys.stdout.write(_http_ret.title) | ||||
else: | ||||
raise _http_ret | ||||
r2726 | ||||
def pre_pull(ui, repo, **kwargs): | ||||
# pre push function, currently used to ban pushing when | ||||
# repository is locked | ||||
r3577 | ex = _extract_extras() | |||
if ex.locked_by[0]: | ||||
locked_by = User.get(ex.locked_by[0]).username | ||||
r3522 | # this exception is interpreted in git/hg middlewares and based | |||
# on that proper return code is server to client | ||||
r3577 | _http_ret = HTTPLockedRC(ex.repository, locked_by) | |||
r3522 | if str(_http_ret.code).startswith('2'): | |||
#2xx Codes don't raise exceptions | ||||
sys.stdout.write(_http_ret.title) | ||||
else: | ||||
raise _http_ret | ||||
r2726 | ||||
r654 | def log_pull_action(ui, repo, **kwargs): | |||
r1722 | """ | |||
Logs user last pull action | ||||
r1203 | ||||
r654 | :param ui: | |||
:param repo: | ||||
""" | ||||
r3577 | ex = _extract_extras() | |||
user = User.get_by_username(ex.username) | ||||
r654 | action = 'pull' | |||
r3577 | action_logger(user, action, ex.repository, ex.ip, commit=True) | |||
r2105 | # extension hook call | |||
r2406 | from rhodecode import EXTENSIONS | |||
r2105 | callback = getattr(EXTENSIONS, 'PULL_HOOK', None) | |||
|
r4116 | if callable(callback): | ||
r2105 | kw = {} | |||
r3577 | kw.update(ex) | |||
r2105 | callback(**kw) | |||
r2726 | ||||
|
r3672 | if ex.make_lock is not None and ex.make_lock: | ||
r3577 | Repository.lock(Repository.get_by_repo_name(ex.repository), user.user_id) | |||
r2726 | #msg = 'Made lock on repo `%s`' % repository | |||
#sys.stdout.write(msg) | ||||
r3577 | if ex.locked_by[0]: | |||
locked_by = User.get(ex.locked_by[0]).username | ||||
_http_ret = HTTPLockedRC(ex.repository, locked_by) | ||||
r3522 | if str(_http_ret.code).startswith('2'): | |||
#2xx Codes don't raise exceptions | ||||
sys.stdout.write(_http_ret.title) | ||||
r654 | return 0 | |||
r547 | ||||
r1307 | ||||
r654 | def log_push_action(ui, repo, **kwargs): | |||
r1722 | """ | |||
Maps user last push action to new changeset id, from mercurial | ||||
r1203 | ||||
r604 | :param ui: | |||
r2236 | :param repo: repo object containing the `ui` object | |||
r547 | """ | |||
r675 | ||||
r3577 | ex = _extract_extras() | |||
r2716 | ||||
|
r4116 | action_tmpl = ex.action + ':%s' | ||
revs = [] | ||||
r3577 | if ex.scm == 'hg': | |||
r2203 | node = kwargs['node'] | |||
def get_revs(repo, rev_opt): | ||||
if rev_opt: | ||||
revs = revrange(repo, rev_opt) | ||||
r675 | ||||
r2203 | if len(revs) == 0: | |||
return (nullrev, nullrev) | ||||
|
r4116 | return max(revs), min(revs) | ||
r2203 | else: | |||
|
r4116 | return len(repo) - 1, 0 | ||
r675 | ||||
r2203 | stop, start = get_revs(repo, [node + ':']) | |||
|
r4116 | _h = binascii.hexlify | ||
revs = [_h(repo[r].node()) for r in xrange(start, stop + 1)] | ||||
r3577 | elif ex.scm == 'git': | |||
r2402 | revs = kwargs.get('_git_revs', []) | |||
if '_git_revs' in kwargs: | ||||
kwargs.pop('_git_revs') | ||||
r675 | ||||
|
r4116 | action = action_tmpl % ','.join(revs) | ||
r3577 | action_logger(ex.username, action, ex.repository, ex.ip, commit=True) | |||
r675 | ||||
r2105 | # extension hook call | |||
r2406 | from rhodecode import EXTENSIONS | |||
r2105 | callback = getattr(EXTENSIONS, 'PUSH_HOOK', None) | |||
|
r4116 | if callable(callback): | ||
r2105 | kw = {'pushed_revs': revs} | |||
r3577 | kw.update(ex) | |||
r2105 | callback(**kw) | |||
r2726 | ||||
|
r3672 | if ex.make_lock is not None and not ex.make_lock: | ||
r3577 | Repository.unlock(Repository.get_by_repo_name(ex.repository)) | |||
msg = 'Released lock on repo `%s`\n' % ex.repository | ||||
r2726 | sys.stdout.write(msg) | |||
r3577 | if ex.locked_by[0]: | |||
locked_by = User.get(ex.locked_by[0]).username | ||||
_http_ret = HTTPLockedRC(ex.repository, locked_by) | ||||
r3522 | if str(_http_ret.code).startswith('2'): | |||
#2xx Codes don't raise exceptions | ||||
sys.stdout.write(_http_ret.title) | ||||
r654 | return 0 | |||
r1972 | ||||
def log_create_repository(repository_dict, created_by, **kwargs): | ||||
""" | ||||
Post create repository Hook. This is a dummy function for admins to re-use | ||||
r2109 | if needed. It's taken from rhodecode-extensions module and executed | |||
r2105 | if present | |||
r1972 | ||||
r1982 | :param repository: dict dump of repository object | |||
r1972 | :param created_by: username who created repository | |||
available keys of repository_dict: | ||||
'repo_type', | ||||
'description', | ||||
'private', | ||||
'created_on', | ||||
'enable_downloads', | ||||
'repo_id', | ||||
'user_id', | ||||
'enable_statistics', | ||||
'clone_uri', | ||||
'fork_id', | ||||
'group_id', | ||||
'repo_name' | ||||
""" | ||||
r2406 | from rhodecode import EXTENSIONS | |||
r2105 | callback = getattr(EXTENSIONS, 'CREATE_REPO_HOOK', None) | |||
|
r4116 | if callable(callback): | ||
r2105 | kw = {} | |||
kw.update(repository_dict) | ||||
kw.update({'created_by': created_by}) | ||||
kw.update(kwargs) | ||||
return callback(**kw) | ||||
r1972 | ||||
r1982 | return 0 | |||
r2402 | ||||
r2904 | ||||
r4074 | def check_allowed_create_user(user_dict, created_by, **kwargs): | |||
|
r4116 | # pre create hooks | ||
r4074 | from rhodecode import EXTENSIONS | |||
callback = getattr(EXTENSIONS, 'PRE_CREATE_USER_HOOK', None) | ||||
|
r4116 | if callable(callback): | ||
r4074 | allowed, reason = callback(created_by=created_by, **user_dict) | |||
if not allowed: | ||||
raise UserCreationError(reason) | ||||
|
r4017 | def log_create_user(user_dict, created_by, **kwargs): | ||
|
r4016 | """ | ||
Post create user Hook. This is a dummy function for admins to re-use | ||||
if needed. It's taken from rhodecode-extensions module and executed | ||||
if present | ||||
:param user_dict: dict dump of user object | ||||
available keys for user_dict: | ||||
'username', | ||||
'full_name_or_username', | ||||
'full_contact', | ||||
'user_id', | ||||
'name', | ||||
'firstname', | ||||
'short_contact', | ||||
'admin', | ||||
'lastname', | ||||
'ip_addresses', | ||||
'ldap_dn', | ||||
'email', | ||||
'api_key', | ||||
'last_login', | ||||
'full_name', | ||||
'active', | ||||
'password', | ||||
'emails', | ||||
'inherit_default_permissions' | ||||
""" | ||||
from rhodecode import EXTENSIONS | ||||
callback = getattr(EXTENSIONS, 'CREATE_USER_HOOK', None) | ||||
|
r4116 | if callable(callback): | ||
|
r4017 | return callback(created_by=created_by, **user_dict) | ||
|
r4016 | |||
return 0 | ||||
r2904 | def log_delete_repository(repository_dict, deleted_by, **kwargs): | |||
""" | ||||
Post delete repository Hook. This is a dummy function for admins to re-use | ||||
if needed. It's taken from rhodecode-extensions module and executed | ||||
if present | ||||
:param repository: dict dump of repository object | ||||
:param deleted_by: username who deleted the repository | ||||
available keys of repository_dict: | ||||
'repo_type', | ||||
'description', | ||||
'private', | ||||
'created_on', | ||||
'enable_downloads', | ||||
'repo_id', | ||||
'user_id', | ||||
'enable_statistics', | ||||
'clone_uri', | ||||
'fork_id', | ||||
'group_id', | ||||
'repo_name' | ||||
""" | ||||
from rhodecode import EXTENSIONS | ||||
callback = getattr(EXTENSIONS, 'DELETE_REPO_HOOK', None) | ||||
|
r4116 | if callable(callback): | ||
r2904 | kw = {} | |||
kw.update(repository_dict) | ||||
kw.update({'deleted_by': deleted_by, | ||||
'deleted_on': time.time()}) | ||||
kw.update(kwargs) | ||||
return callback(**kw) | ||||
return 0 | ||||
|
r4017 | def log_delete_user(user_dict, deleted_by, **kwargs): | ||
|
r4016 | """ | ||
Post delete user Hook. This is a dummy function for admins to re-use | ||||
if needed. It's taken from rhodecode-extensions module and executed | ||||
if present | ||||
:param user_dict: dict dump of user object | ||||
available keys for user_dict: | ||||
'username', | ||||
'full_name_or_username', | ||||
'full_contact', | ||||
'user_id', | ||||
'name', | ||||
'firstname', | ||||
'short_contact', | ||||
'admin', | ||||
'lastname', | ||||
'ip_addresses', | ||||
'ldap_dn', | ||||
'email', | ||||
'api_key', | ||||
'last_login', | ||||
'full_name', | ||||
'active', | ||||
'password', | ||||
'emails', | ||||
'inherit_default_permissions' | ||||
""" | ||||
from rhodecode import EXTENSIONS | ||||
callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None) | ||||
|
r4116 | if callable(callback): | ||
|
r4017 | return callback(deleted_by=deleted_by, **user_dict) | ||
|
r4016 | |||
return 0 | ||||
r2726 | handle_git_pre_receive = (lambda repo_path, revs, env: | |||
handle_git_receive(repo_path, revs, env, hook_type='pre')) | ||||
handle_git_post_receive = (lambda repo_path, revs, env: | ||||
handle_git_receive(repo_path, revs, env, hook_type='post')) | ||||
r2402 | ||||
r2726 | ||||
def handle_git_receive(repo_path, revs, env, hook_type='post'): | ||||
r2402 | """ | |||
r2407 | A really hacky method that is runned by git post-receive hook and logs | |||
r2409 | an push action together with pushed revisions. It's executed by subprocess | |||
thus needs all info to be able to create a on the fly pylons enviroment, | ||||
connect to database and run the logging code. Hacky as sh*t but works. | ||||
r2402 | ||||
:param repo_path: | ||||
:param revs: | ||||
:param env: | ||||
""" | ||||
from paste.deploy import appconfig | ||||
from sqlalchemy import engine_from_config | ||||
from rhodecode.config.environment import load_environment | ||||
from rhodecode.model import init_model | ||||
from rhodecode.model.db import RhodeCodeUi | ||||
from rhodecode.lib.utils import make_ui | ||||
r3590 | extras = _extract_extras(env) | |||
r2402 | ||||
r2870 | path, ini_name = os.path.split(extras['config']) | |||
r2402 | conf = appconfig('config:%s' % ini_name, relative_to=path) | |||
|
r4116 | load_environment(conf.global_conf, conf.local_conf, test_env=False, | ||
test_index=False) | ||||
r2402 | ||||
engine = engine_from_config(conf, 'sqlalchemy.db1.') | ||||
init_model(engine) | ||||
baseui = make_ui('db') | ||||
r2617 | # fix if it's not a bare repo | |||
|
r2872 | if repo_path.endswith(os.sep + '.git'): | ||
repo_path = repo_path[:-5] | ||||
r2818 | ||||
r2402 | repo = Repository.get_by_full_path(repo_path) | |||
r2818 | if not repo: | |||
raise OSError('Repository %s not found in database' | ||||
% (safe_str(repo_path))) | ||||
r2402 | _hooks = dict(baseui.configitems('hooks')) or {} | |||
r3278 | if hook_type == 'pre': | |||
repo = repo.scm_instance | ||||
else: | ||||
#post push shouldn't use the cached instance never | ||||
r3549 | repo = repo.scm_instance_no_cache() | |||
r3278 | ||||
r2726 | if hook_type == 'pre': | |||
pre_push(baseui, repo) | ||||
# if push hook is enabled via web interface | ||||
elif hook_type == 'post' and _hooks.get(RhodeCodeUi.HOOK_PUSH): | ||||
r2617 | rev_data = [] | |||
for l in revs: | ||||
old_rev, new_rev, ref = l.split(' ') | ||||
_ref_data = ref.split('/') | ||||
if _ref_data[1] in ['tags', 'heads']: | ||||
rev_data.append({'old_rev': old_rev, | ||||
'new_rev': new_rev, | ||||
'ref': ref, | ||||
'type': _ref_data[1], | ||||
'name': _ref_data[2].strip()}) | ||||
git_revs = [] | ||||
|
r4116 | |||
for push_ref in rev_data: | ||||
r2617 | _type = push_ref['type'] | |||
if _type == 'heads': | ||||
if push_ref['old_rev'] == EmptyChangeset().raw_id: | ||||
|
r4116 | # update the symbolic ref if we push new repo | ||
if repo.is_empty(): | ||||
repo._repo.refs.set_symbolic_ref('HEAD', | ||||
'refs/heads/%s' % push_ref['name']) | ||||
r2617 | cmd = "for-each-ref --format='%(refname)' 'refs/heads/*'" | |||
heads = repo.run_git_command(cmd)[0] | ||||
heads = heads.replace(push_ref['ref'], '') | ||||
heads = ' '.join(map(lambda c: c.strip('\n').strip(), | ||||
heads.splitlines())) | ||||
cmd = (('log %(new_rev)s' % push_ref) + | ||||
' --reverse --pretty=format:"%H" --not ' + heads) | ||||
r2998 | git_revs += repo.run_git_command(cmd)[0].splitlines() | |||
elif push_ref['new_rev'] == EmptyChangeset().raw_id: | ||||
#delete branch case | ||||
git_revs += ['delete_branch=>%s' % push_ref['name']] | ||||
r2617 | else: | |||
cmd = (('log %(old_rev)s..%(new_rev)s' % push_ref) + | ||||
' --reverse --pretty=format:"%H"') | ||||
r2998 | git_revs += repo.run_git_command(cmd)[0].splitlines() | |||
r2617 | elif _type == 'tags': | |||
r2998 | git_revs += ['tag=>%s' % push_ref['name']] | |||
r2402 | ||||
log_push_action(baseui, repo, _git_revs=git_revs) | ||||