kallithea Changeset - c55338638085

Changeset - c55338638085

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

Mads Kiilerich - 7 years ago 2018-08-14 23:43:35
mads@kiilerich.com

hooks: empower the Git entry points and avoid the big handle_git_receive dispatch

Use the new _hook_environment and enjoy the small and clean hooks.

Just moving code - no change.

1 file changed with 11 insertions and 29 deletions:

kallithea/lib/hooks.py

0 comments (0 inline, 0 general)

kallithea/lib/hooks.py

➞

Show inline comments

@@ @@ -312,163 +312,145 @@ def log_delete_repository(repository_dic @@
     if callable(callback):
         kw = {}
         kw.update(repository_dict)
         kw.update({'deleted_by': deleted_by,
                    'deleted_on': time.time()})
         kw.update(kwargs)
         return callback(**kw)
     return 0
 def log_delete_user(user_dict, deleted_by, **kwargs):
     """
     Post delete user Hook.
     :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 kallithea import EXTENSIONS
     callback = getattr(EXTENSIONS, 'DELETE_USER_HOOK', None)
     if callable(callback):
         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 _hook_environment(repo_path, env):
     """
     Create a light-weight environment for stand-alone scripts and return an UI and the
     db repository.
     Git hooks are executed as subprocess of Git while Kallithea is waiting, and
     they thus need enough info to be able to create an app environment and
     connect to the database.
     """
     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
     extras = _extract_extras(env)
     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)
     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')
     return baseui, repo
 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
     a push action together with pushed revisions. It's executed by subprocess
     thus needs all info to be able to create an on the fly app environment,
     connect to database and run the logging code. Hacky as sh*t but works.
     :param repo_path:
     :param revs:
     :param env:
     """
 def handle_git_pre_receive(repo_path, git_stdin_lines, env):
     """Called from Git pre-receive hook"""
     baseui, repo = _hook_environment(repo_path, env)
     scm_repo = repo.scm_instance
     push_lock_handling(baseui, scm_repo)
 def handle_git_post_receive(repo_path, git_stdin_lines, env):
     """Called from Git post-receive hook"""
     baseui, repo = _hook_environment(repo_path, env)
     if hook_type == 'pre':
         scm_repo = repo.scm_instance
     else:
         # post push should never use the cached instance
     # the post push hook should never use the cached instance
         scm_repo = repo.scm_instance_no_cache()
     _hooks = dict(baseui.configitems('hooks')) or {}
     if hook_type == 'pre':
         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):
+    if _hooks.get(Ui.HOOK_PUSH_LOG):
         rev_data = []
         for l in git_stdin_lines:
             old_rev, new_rev, ref = l.strip().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': '/'.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 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 = 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 += 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 += scm_repo.run_git_command(cmd)[0].splitlines()
             elif _type == 'tags':
                 git_revs += ['tag=>%s' % push_ref['name']]
         log_push_action(baseui, scm_repo, _git_revs=git_revs)

0 comments (0 inline, 0 general)