#!/usr/bin/env python

import os

import sys

try:

    import kallithea

    from kallithea.lib.hooks import handle_git_post_receive as _handler

except ImportError:

    if os.environ.get('RC_DEBUG_GIT_HOOK'):

        import traceback

        print traceback.format_exc()

    kallithea = None

def main():

    if kallithea is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ gets some additional info from rhodecode system

    # like IP or username from basic-auth

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

#!/usr/bin/env python

import os

import sys

try:

    import kallithea

    from kallithea.lib.hooks import handle_git_pre_receive as _handler

except ImportError:

    if os.environ.get('RC_DEBUG_GIT_HOOK'):

        import traceback

        print traceback.format_exc()

    kallithea = None

def main():

    if kallithea is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ gets some additional info from rhodecode system

    # like IP or username from basic-auth

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

    def install_git_hook(self, repo, force_create=False):

        """

        Creates a rhodecode hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = jn(repo.path, 'hooks')

        if not repo.bare:

            loc = jn(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post = pkg_resources.resource_string(

            'kallithea', jn('config', 'post_receive_tmpl.py')

        )

        tmpl_pre = pkg_resources.resource_string(

            'kallithea', jn('config', 'pre_receive_tmpl.py')

        )

        for h_type, tmpl in [('pre', tmpl_pre), ('post', tmpl_post)]:

            _hook_file = jn(loc, '%s-receive' % h_type)

            log.debug('Installing git hook in repo %s' % repo)

            if os.path.exists(_hook_file):

                # let's take a look at this hook, maybe it's rhodecode ?

                log.debug('hook exists, checking if it is from rhodecode')

                with open(_hook_file, 'rb') as f:

                    data = f.read()

                    matches = re.compile(r'(?:%s)\s*=\s*(.*)'

                    if matches:

                        try:

                            ver = matches.groups()[0]

                            log.debug('got %s it is rhodecode' % (ver))

                        except Exception:

                            log.error(traceback.format_exc())

            else:

                # there is no hook in this dir, so we want to create one

                log.debug('writing %s hook file !' % (h_type,))

                try:

                    with open(_hook_file, 'wb') as f:

                        tmpl = tmpl.replace('_TMPL_', kallithea.__version__)

                        f.write(tmpl)

                    os.chmod(_hook_file, 0755)

                except IOError, e:

                    log.error('error writing %s: %s' % (_hook_file, e))

            else:

                log.debug('skipping writing hook file')