Changeset - 07c24b9ad3eb
Parent rev.
Child rev.
[Not reviewed]
default
0 1 0
Mads Kiilerich - 7 years ago 2018-08-08 02:23:11
mads@kiilerich.com
hooks: minor changes to clean up, improve docs and naming
1 file changed with 29 insertions and 35 deletions:
kallithea/lib/hooks.py
29
35
0 comments (0 inline, 0 general)
kallithea/lib/hooks.py
➞
Show inline comments
 
@@ -23,13 +23,12 @@ Original author and date, and relevant c
 
:author: marcink
 
:copyright: (c) 2013 RhodeCode GmbH, and others.
 
:license: GPLv3, see LICENSE.md for more details.
 
"""
 

			




	
	
	
		
 
import os

			




	
	
	
		
 
import sys

			




	
	
	
		
 
import time

			




	
	
	
		
 
import binascii

			




	
	
	
		
 

			




	
	
	
		
 
from kallithea.lib.vcs.utils.hgcompat import nullrev, revrange

			




	
	
	
		
 
from kallithea.lib import helpers as h

			




	
	
	
		
 
from kallithea.lib.utils import action_logger

			




	
	
		
 
@@ -37,13 +36,12 @@ from kallithea.lib.vcs.backends.base imp

			




	
	
	
		
 
from kallithea.lib.exceptions import HTTPLockedRC, UserCreationError

			




	
	
	
		
 
from kallithea.lib.utils2 import safe_str, safe_unicode, _extract_extras

			




	
	
	
		
 
from kallithea.model.db import Repository, User

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def _get_scm_size(alias, root_path):

			




	
	
	
		
 

			




	
	
	
		
 
    if not alias.startswith('.'):

			




	
	
	
		
 
        alias += '.'

			




	
	
	
		
 

			




	
	
	
		
 
    size_scm, size_root = 0, 0

			




	
	
	
		
 
    for path, dirs, files in os.walk(safe_str(root_path)):

			




	
	
	
		
 
        if path.find(alias) != -1:

			




	
	
		
 
@@ -64,34 +62,29 @@ def _get_scm_size(alias, root_path):

			




	
	
	
		
 
    size_total_f = h.format_byte_size(size_root + size_scm)

			




	
	
	
		
 

			




	
	
	
		
 
    return size_scm_f, size_root_f, size_total_f

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def repo_size(ui, repo, hooktype=None, **kwargs):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Presents size of repository after push

			




	
	
	
		
 

			




	
	
	
		
 
    :param ui:

			




	
	
	
		
 
    :param repo:

			




	
	
	
		
 
    :param hooktype:

			




	
	
	
		
 
    """

			




	
	
	
		
 

			




	
	
	
		
 
    """Presents size of repository after push"""

			




	
	
	
		
 
    size_hg_f, size_root_f, size_total_f = _get_scm_size('.hg', repo.root)

			




	
	
	
		
 

			




	
	
	
		
 
    last_cs = repo[len(repo) - 1]

			




	
	
	
		
 

			




	
	
	
		
 
    msg = ('Repository size .hg: %s Checkout: %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]

			




	
	
	
		
 
    )

			




	
	
	
		
 
    ui.status(msg)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def push_lock_handling(ui, repo, **kwargs):

			




	
	
	
		
 
    # pre push function, currently used to ban pushing when

			




	
	
	
		
 
    # repository is locked

			




	
	
	
		
 
    """Pre push function, currently used to ban pushing when repository is locked.

			




	
	
	
		
 

			




	
	
	
		
 
    Called as Mercurial hook prechangegroup.push_lock_handling or from the Git pre-receive hook calling handle_git_pre_receive.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    ex = _extract_extras()

			




	
	
	
		
 

			




	
	
	
		
 
    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

			




	
	
	
		
 
        # this exception is interpreted in git/hg middlewares and based

			




	
	
		
 
@@ -102,12 +95,13 @@ def push_lock_handling(ui, repo, **kwarg

			




	
	
	
		
 
            ui.status(safe_str(_http_ret.title))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            raise _http_ret

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def pull_lock_handling(ui, repo, **kwargs):

			




	
	
	
		
 
    """Called as Mercurial hook preoutgoing.pull_lock_handling or from Kallithea before invoking Git"""

			




	
	
	
		
 
    # pre pull function ...

			




	
	
	
		
 
    ex = _extract_extras()

			




	
	
	
		
 
    if ex.locked_by[0]:

			




	
	
	
		
 
        locked_by = User.get(ex.locked_by[0]).username

			




	
	
	
		
 
        # this exception is interpreted in git/hg middlewares and based

			




	
	
	
		
 
        # on that proper return code is server to client

			




	
	
		
 
@@ -117,17 +111,15 @@ def pull_lock_handling(ui, repo, **kwarg

			




	
	
	
		
 
            ui.status(safe_str(_http_ret.title))

			




	
	
	
		
 
        else:

			




	
	
	
		
 
            raise _http_ret

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def log_pull_action(ui, repo, **kwargs):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Logs user last pull action

			




	
	
	
		
 
    """Logs user last pull action, and also handle locking

			




	
	
	
		
 

			




	
	
	
		
 
    :param ui:

			




	
	
	
		
 
    :param repo:

			




	
	
	
		
 
    Called as Mercurial hook outgoing.pull_logger or from Kallithea before invoking Git.

			




	
	
	
		
 
    """

			




	
	
	
		
 
    ex = _extract_extras()

			




	
	
	
		
 

			




	
	
	
		
 
    user = User.get_by_username(ex.username)

			




	
	
	
		
 
    action = 'pull'

			




	
	
	
		
 
    action_logger(user, action, ex.repository, ex.ip, commit=True)

			




	
	
		
 
@@ -153,15 +145,15 @@ def log_pull_action(ui, repo, **kwargs):

			




	
	
	
		
 
    return 0

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def log_push_action(ui, repo, **kwargs):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    Register that changes have been pushed.

			




	
	
	
		
 
    Mercurial invokes this directly as a hook, git uses handle_git_receive.

			




	
	
	
		
 

			




	
	
	
		
 
    Called as Mercurial hook changegroup.push_logger or from the Git post-receive hook calling handle_git_post_receive ... or from scm _handle_push

			




	
	
	
		
 
    """

			




	
	
	
		
 

			




	
	
	
		
 
    ex = _extract_extras()

			




	
	
	
		
 

			




	
	
	
		
 
    action_tmpl = ex.action + ':%s'

			




	
	
	
		
 
    revs = []

			




	
	
	
		
 
    if ex.scm == 'hg':

			




	
	
	
		
 
        node = kwargs['node']

			




	
	
		
 
@@ -362,16 +354,18 @@ def log_delete_user(user_dict, deleted_b

			




	
	
	
		
 
        return callback(deleted_by=deleted_by, **user_dict)

			




	
	
	
		
 

			




	
	
	
		
 
    return 0

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def handle_git_pre_receive(repo_path, git_stdin_lines, env):

			




	
	
	
		
 
    """Called from Git pre-receive hook"""

			




	
	
	
		
 
    return handle_git_receive(repo_path, git_stdin_lines, env, hook_type='pre')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def handle_git_post_receive(repo_path, git_stdin_lines, env):

			




	
	
	
		
 
    """Called from Git post-receive hook"""

			




	
	
	
		
 
    return handle_git_receive(repo_path, git_stdin_lines, env, hook_type='post')

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
def handle_git_receive(repo_path, git_stdin_lines, env, hook_type):

			




	
	
	
		
 
    """

			




	
	
	
		
 
    A really hacky method that is run by git post-receive hook and logs

			




	
	
		
 
@@ -386,44 +380,45 @@ def handle_git_receive(repo_path, git_st

			




	
	
	
		
 
    from paste.deploy import appconfig

			




	
	
	
		
 
    from sqlalchemy import engine_from_config

			




	
	
	
		
 
    from kallithea.config.environment import load_environment

			




	
	
	
		
 
    from kallithea.model.base import init_model

			




	
	
	
		
 
    from kallithea.model.db import Ui

			




	
	
	
		
 
    from kallithea.lib.utils import make_ui, setup_cache_regions

			




	
	
	
		
 

			




	
	
	
		
 
    extras = _extract_extras(env)

			




	
	
	
		
 

			




	
	
	
		
 
    repo_path = safe_unicode(repo_path)

			




	
	
	
		
 
    path, ini_name = os.path.split(extras['config'])

			




	
	
	
		
 
    conf = appconfig('config:%s' % ini_name, relative_to=path)

			




	
	
	
		
 
    conf = load_environment(conf.global_conf, conf.local_conf)

			




	
	
	
		
 

			




	
	
	
		
 
    setup_cache_regions(conf)

			




	
	
	
		
 

			




	
	
	
		
 
    engine = engine_from_config(conf, 'sqlalchemy.')

			




	
	
	
		
 
    init_model(engine)

			




	
	
	
		
 

			




	
	
	
		
 
    baseui = make_ui('db')

			




	
	
	
		
 
    repo_path = safe_unicode(repo_path)

			




	
	
	
		
 
    # fix if it's not a bare repo

			




	
	
	
		
 
    if repo_path.endswith(os.sep + '.git'):

			




	
	
	
		
 
        repo_path = repo_path[:-5]

			




	
	
	
		
 

			




	
	
	
		
 
    repo = Repository.get_by_full_path(repo_path)

			




	
	
	
		
 
    if not repo:

			




	
	
	
		
 
        raise OSError('Repository %s not found in database'

			




	
	
	
		
 
                      % (safe_str(repo_path)))

			




	
	
	
		
 

			




	
	
	
		
 
    baseui = make_ui('db')

			




	
	
	
		
 

			




	
	
	
		
 
    if hook_type == 'pre':

			




	
	
	
		
 
        scm_repo = repo.scm_instance

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        # post push should never use the cached instance

			




	
	
	
		
 
        scm_repo = repo.scm_instance_no_cache()

			




	
	
	
		
 

			




	
	
	
		
 
    _hooks = dict(baseui.configitems('hooks')) or {}

			




	
	
	
		
 

			




	
	
	
		
 
    if hook_type == 'pre':

			




	
	
	
		
 
        repo = repo.scm_instance

			




	
	
	
		
 
    else:

			




	
	
	
		
 
        # post push shouldn't use the cached instance never

			




	
	
	
		
 
        repo = repo.scm_instance_no_cache()

			




	
	
	
		
 

			




	
	
	
		
 
    if hook_type == 'pre':

			




	
	
	
		
 
        push_lock_handling(baseui, repo)

			




	
	
	
		
 
        push_lock_handling(baseui, scm_repo)

			




	
	
	
		
 

			




	
	
	
		
 
    # if push hook is enabled via web interface

			




	
	
	
		
 
    elif hook_type == 'post' and _hooks.get(Ui.HOOK_PUSH_LOG):

			




	
	
	
		
 
        rev_data = []

			




	
	
	
		
 
        for l in git_stdin_lines:

			




	
	
	
		
 
            old_rev, new_rev, ref = l.strip().split(' ')

			




	
	
		
 
@@ -433,37 +428,36 @@ def handle_git_receive(repo_path, git_st

			




	
	
	
		
 
                                 'new_rev': new_rev,

			




	
	
	
		
 
                                 'ref': ref,

			




	
	
	
		
 
                                 'type': _ref_data[1],

			




	
	
	
		
 
                                 'name': '/'.join(_ref_data[2:])})

			




	
	
	
		
 

			




	
	
	
		
 
        git_revs = []

			




	
	
	
		
 

			




	
	
	
		
 
        for push_ref in rev_data:

			




	
	
	
		
 
            _type = push_ref['type']

			




	
	
	
		
 
            if _type == 'heads':

			




	
	
	
		
 
                if push_ref['old_rev'] == EmptyChangeset().raw_id:

			




	
	
	
		
 
                    # update the symbolic ref if we push new repo

			




	
	
	
		
 
                    if repo.is_empty():

			




	
	
	
		
 
                        repo._repo.refs.set_symbolic_ref('HEAD',

			




	
	
	
		
 
                    if scm_repo.is_empty():

			




	
	
	
		
 
                        scm_repo._repo.refs.set_symbolic_ref('HEAD',

			




	
	
	
		
 
                                            'refs/heads/%s' % push_ref['name'])

			




	
	
	
		
 

			




	
	
	
		
 
                    cmd = ['for-each-ref', '--format=%(refname)', 'refs/heads/*']

			




	
	
	
		
 
                    heads = repo.run_git_command(cmd)[0]

			




	
	
	
		
 
                    heads = scm_repo.run_git_command(cmd)[0]

			




	
	
	
		
 
                    cmd = ['log', push_ref['new_rev'],

			




	
	
	
		
 
                           '--reverse', '--pretty=format:%H', '--not']

			




	
	
	
		
 
                    heads = heads.replace(push_ref['ref'], '')

			




	
	
	
		
 
                    for l in heads.splitlines():

			




	
	
	
		
 
                        cmd.append(l.strip())

			




	
	
	
		
 
                    git_revs += repo.run_git_command(cmd)[0].splitlines()

			




	
	
	
		
 
                    git_revs += scm_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']]

			




	
	
	
		
 
                else:

			




	
	
	
		
 
                    cmd = ['log', '%(old_rev)s..%(new_rev)s' % push_ref,

			




	
	
	
		
 
                           '--reverse', '--pretty=format:%H']

			




	
	
	
		
 
                    git_revs += repo.run_git_command(cmd)[0].splitlines()

			




	
	
	
		
 
                    git_revs += scm_repo.run_git_command(cmd)[0].splitlines()

			




	
	
	
		
 

			




	
	
	
		
 
            elif _type == 'tags':

			




	
	
	
		
 
                git_revs += ['tag=>%s' % push_ref['name']]

			




	
	
	
		
 

			




	
	
	
		
 
        log_push_action(baseui, repo, _git_revs=git_revs)

			




	
	
	
		
 
        log_push_action(baseui, scm_repo, _git_revs=git_revs)

			




        

    



    


    



    



      

      





    
    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.