kallithea.CELERY_ON = str2bool(config.get('use_celery'))

    kallithea.CELERY_EAGER = str2bool(config.get('celery.always.eager'))

    kallithea.CONFIG = config

    load_rcextensions(root_path=config['here'])

    config['base_path'] = repos_path

    set_app_settings(config)

    instance_id = kallithea.CONFIG.get('instance_id', '*')

    if instance_id == '*':

        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())

            # no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            ancestors = [hgrepo[ancestor].hex() for ancestor in

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

                ancestors = [hgrepo[ancestor].hex() for ancestor in

                                     other_rev, org_rev, org_rev)

                                   org_rev, other_rev, other_rev)

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                from dulwich.client import SubprocessGitClient

            # a revset not restricting to merge() would be better

            # (especially because it would get the branch point)

            # ... but is currently too expensive

            # including branches of children could be nice too

            peerbranches = set()

            for i in repo._repo.revs(

                branch_rev, branch_rev

            ):

                for abranch in repo.get_changeset(i).branches:

                    if abranch not in peerbranches:

                        n = 'branch:%s:%s' % (abranch, repo.get_changeset(abranch).raw_id)

                        peers.append((n, abranch))

    Returns git style diff between given ``filenode_old`` and ``filenode_new``.

    """

    # make sure we pass in default context

    context = context or 3

    submodules = [o for o in [filenode_new, filenode_old] if isinstance(o, SubModuleNode)]

    if submodules:

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    """

    try:

        return scm_instance.get_diff(rev1, rev2, path=path,

                                     ignore_whitespace=ignore_whitespace, context=context)

    except MemoryError:

        h.flash('MemoryError: Diff is too big', category='error')

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

RENAMED_FILENODE = 4

class DiffProcessor(object):

    """

    Give it a unified or git diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    def __init__(self, diff, vcs='hg', diff_limit=None, inline_diff=True):

        """

        :param diff:   a text in diff format

        :param vcs: type of version control hg or git

        :param diff_limit: define the size of diff that is considered "big"

            return ' <i></i>'

        assert False

    return _escape_re.sub(substitute, safe_unicode(string))

    ^diff[ ]--git[ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

    (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

       ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

    (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

       ^rename[ ]from[ ](?P<rename_from>.+)\n

       ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

    (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

    (?:^---[ ](a/(?P<a_file>.+?)|/dev/null)\t?(?:\n|$))?

    (?:^\+\+\+[ ](b/(?P<b_file>.+?)|/dev/null)\t?(?:\n|$))?

""", re.VERBOSE | re.MULTILINE)

    ^diff[ ]--git[ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

    (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

       ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

    (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?

    (?:^rename[ ]from[ ](?P<rename_from>.+)\n

       ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

    if match is None:

        raise Exception('diff not recognized as valid %s diff' % vcs)

    meta_info = match.groupdict()

    rest = diff_chunk[match.end():]

    if rest and _header_next_check.match(rest):

        raise Exception('cannot parse %s diff header: %r followed by %r' % (vcs, diff_chunk[:match.end()], rest[:1000]))

    return meta_info, diff_lines

_chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

_newline_marker = re.compile(r'^\\ No newline at end of file')

    The pushed changesets is given by the revset 'node:node_last'.

    Note: This hook is not only logging, but also the side effect invalidating

    cahes! The function should perhaps be renamed.

    """

    _h = binascii.hexlify

    process_pushed_raw_ids(revs)

    return 0

def process_pushed_raw_ids(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():

                # build exclude list without the ref

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

                stdout = scm_repo.run_git_command(cmd)

                ref = push_ref['ref']

                heads = [head for head in stdout.splitlines() if head != ref]

    try:

        decoded = base64.b64decode(keyvalue)

    except TypeError:

        raise SshKeyParseError(_("Incorrect SSH key - failed to decode base64 part %r") % keyvalue)

    return keytype, decoded, comment

SSH_OPTIONS = 'no-pty,no-port-forwarding,no-X11-forwarding,no-agent-forwarding'

    baseui._ucfg = config.config()

    baseui._tcfg = config.config()

    sa = meta.Session()

    for ui_ in sa.query(Ui).all():

        if ui_.ui_active:

            log.debug('config from db: [%s] %s=%r', ui_.ui_section,

                      ui_.ui_key, ui_val)

            baseui.setconfig(safe_str(ui_.ui_section), safe_str(ui_.ui_key),

                             ui_val)

    # force set push_ssl requirement to False, Kallithea handles that

    # prevent interactive questions for ssh password / passphrase

    # push / pull hooks

    if repo_path is not None:

        hgrc_path = os.path.join(repo_path, '.hg', 'hgrc')

        if os.path.isfile(hgrc_path):

            log.debug('reading hgrc from %s', hgrc_path)

            cfg = config.config()

                return cs

    def diff(self, ignore_whitespace=True, context=3):

        # Only used to feed diffstat

        rev1 = self.parents[0] if self.parents else self.repository.EMPTY_CHANGESET

        rev2 = self

                                    ignore_whitespace=ignore_whitespace,

                                    context=context))

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

            if path != '':

                obj_path = '/'.join((path, name))

            else:

                obj_path = name

            if objects.S_ISGITLINK(stat):

                root_tree = self.repository._repo[self._tree_id]

                url = cf.get(('submodule', obj_path), 'url')

                dirnodes.append(SubModuleNode(obj_path, url=url, changeset=id,

                                              alias=als))

                continue

            obj = self.repository._repo.get_object(id)

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

            _GL = lambda m: m and objects.S_ISGITLINK(m)

            if _GL(self._stat_modes.get(path)):

                tree = self.repository._repo[self._tree_id]

                url = cf.get(('submodule', path), 'url')

                node = SubModuleNode(path, url=url, changeset=id_,

                                     alias=self.repository.alias)

            else:

                obj = self.repository._repo.get_object(id_)

        if branch is None:

            branch = GitRepository.DEFAULT_BRANCH_NAME

        repo = self.repository._repo

        object_store = repo.object_store

        # Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or \

            objects.Tree()

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

                object_store.add_object(tree)

            object_store.add_object(blob)

            for tree in new_trees:

                object_store.add_object(tree)

        for node in self.removed:

            tree = commit_tree

            trees = [tree]

            # Traverse deep into the forest...

            for path in paths:

                try:

                    obj = self.repository._repo[tree[path][1]]

        author_tz = kwargs.pop('author_timezone', tz)

        commit.commit_timezone = tz

        commit.author_timezone = author_tz

        object_store.add_object(commit)

        repo.refs[ref] = commit.id

        self.repository.revisions.append(commit.id)

        # invalidate parsed refs after commit

        self.repository._parsed_refs = self.repository._get_parsed_refs()

        tip = self.repository.get_changeset()

        self.reset()

        return tip

                   (cmd, type(err).__name__, err)

            ).strip()

            log.error(msg)

            raise RepositoryError(msg)

        try:

        finally:

            p.close()

        # TODO: introduce option to make commands fail if they have any stderr output?

        if stderr:

            log.debug('stderr from %s:\n%s', cmd, stderr)

        else:

        if '+' in url[:url.find('://')]:

            url = url[url.find('+') + 1:]

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        if not test_uri.endswith('info/refs'):

            test_uri = test_uri.rstrip('/') + '/info/refs'

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            handlers.extend((httpbasicauthhandler(passmgr),

            return []

        return so.splitlines()

    def _get_all_revisions2(self):

        # alternate implementation using dulwich

        includes = [x[1][0] for x in self._parsed_refs.iteritems()

        return [c.commit.id for c in self._repo.get_walker(include=includes)]

    def _get_revision(self, revision):

        """

        Given any revision identifier, returns a 40 char string with revision hash.

        """

                except IndexError:

                    msg = "Revision %r does not exist for %s" % (revision, self)

                    raise ChangesetDoesNotExistError(msg)

            # get by branch/tag name

            _ref_revision = self._parsed_refs.get(revision)

                return _ref_revision[0]

            if revision in self.revisions:

                return revision

            # maybe it's a tag ? we don't have them in self.revisions

                return os.stat(in_path).st_mtime

            else:

                return os.stat(he_path).st_mtime

    @LazyProperty

    def description(self):

    @LazyProperty

    def contact(self):

        undefined_contact = u'Unknown'

        return undefined_contact

    @property

    def branches(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        _branches = [(x[0], x[1][0])

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

    def closed_branches(self):

        return {}

    def _get_tags(self):

        if not self.revisions:

            return {}

        sortkey = lambda ctx: ctx[0]

        _tags = [(x[0], x[1][0])

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        Creates and returns a tag for the given ``revision``.

        """

        if name in self.tags:

            raise TagAlreadyExistError("Tag %s already exists" % name)

        changeset = self.get_changeset(revision)

        message = message or "Added tag %s for commit %s" % (name,

            changeset.raw_id)

        self._parsed_refs = self._get_parsed_refs()

        self.tags = self._get_tags()

        return changeset

    def remove_tag(self, name, user, message=None, date=None):

        return self._get_parsed_refs()

    def _get_parsed_refs(self):

        # cache the property

        _repo = self._repo

        refs = _repo.get_refs()

        _refs = {}

        for ref, sha in refs.iteritems():

            for k, type_ in keys:

                if ref.startswith(k):

                    _key = ref[len(k):]

                        obj = _repo.get_object(sha)

                        if isinstance(obj, Tag):

                            sha = _repo.get_object(sha).object[1]

                    _refs[_key] = [sha, type_]

                    break

        return _refs

    def _heads(self, reverse=False):

        refs = self._repo.get_refs()

        heads = {}

        for key, val in refs.items():

                if key.startswith(ref_key):

                    n = key[len(ref_key):]

                        heads[n] = val

        return heads if reverse else dict((y, x) for x, y in heads.iteritems())

    def get_changeset(self, revision=None):

        """

            cmd += ['--', path]

        stdout, stderr = self._run_git_command(cmd, cwd=self.path)

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            if len(parts) > 1:

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

from kallithea.lib.vcs.exceptions import BranchDoesNotExistError, RepositoryError

class GitWorkdir(BaseWorkdir):

    def get_branch(self):

        try:

            content = open(headpath).read()

            match = re.match(r'^ref: refs/heads/(?P<branch>.+)\n$', content)

            if match:

                return match.groupdict()['branch']

            else:

                raise RepositoryError("Couldn't compute workdir's branch")

        except IOError:

            # Try naive way...

            raise RepositoryError("Couldn't compute workdir's branch")

    def get_changeset(self):

        return self.repository.get_changeset(wk_dir_id)

    def checkout_branch(self, branch=None):

        if branch is None:

            branch = self.repository.DEFAULT_BRANCH_NAME

        if branch not in self.repository.branches:

            if not branch or branch == cs.branch:

                return cs

    def diff(self):

        # Only used to feed diffstat

    def _fix_path(self, path):

        """

        Paths are stored without trailing slash so we need to get rid off it if

        needed. Also mercurial keeps filenodes as str so we need to decode

        from unicode to str

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

        """

        fctx = self._get_filectx(path)

            return 0o100755

        else:

            return 0o100644

    def get_file_content(self, path):

        """

            raise RepositoryError('Given message and author needs to be '

                                  'an <unicode> instance got %r & %r instead'

                                  % (type(message), type(author)))

        if branch is None:

            branch = MercurialRepository.DEFAULT_BRANCH_NAME

        def filectxfn(_repo, memctx, path):

            """

            Marks given path as added/changed/removed in a given _repo. This is

            for internal mercurial commit function.

            """

        if date and isinstance(date, datetime.datetime):

            date = date.strftime('%a, %d %b %Y %H:%M:%S')

        commit_ctx = memctx(repo=self.repository._repo,

            parents=parents,

            files=self.get_paths(),

            filectxfn=filectxfn,

            user=author,

            date=date,

            extra=kwargs)

            ((safe_unicode(n), hex(h)) for n, h in self._repo._bookmarks.items()),

            reverse=True,

            key=lambda x: x[0],  # sort by name

        ))

    def _get_all_revisions(self):

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

                  context=3):

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

        self.get_changeset(rev2)

        if path:

            file_filter = match_exact(path)

        else:

            file_filter = None

                          opts=diffopts(git=True,

                                        showfunc=True,

                                        ignorews=ignore_whitespace,

                                        context=context)))

    @classmethod

        or other external calls.

        On failures it'll raise urllib2.HTTPError, exception is also thrown

        when the return code is non 200

        """

        # check first if it's not an local url

            return True

            # in case of invalid uri or authentication issues, sshpeer will

            # throw an exception.

            return True

        url_prefix = None

        handlers = []

        url_obj = hg_url(url)

        test_uri, authinfo = url_obj.authinfo()

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        if not url_prefix: # skip svn+http://... (and git+... too)

            # now check if it's a proper hg repo

            try:

            except Exception as e:

                raise urllib2.URLError(

                    "url [%s] does not look like an hg repo org_exc: %s"

                    % (cleaned_uri, e))

        return True

    @LazyProperty

    def in_memory_changeset(self):

        return MercurialInMemoryChangeset(self)

    @LazyProperty

    def description(self):

    @LazyProperty

    def contact(self):

        return safe_unicode(get_contact(self._repo.ui.config)

    @LazyProperty

    def last_change(self):

        """

        Returns last change made on this repository as datetime object

        """

        :param revision: str or int or None

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, None]:

        elif isinstance(revision, unicode):

            revision = safe_bytes(revision)

        try:

            if isinstance(revision, int):

                return self._repo[revision].hex()

            # TODO: just report 'not found'?

            revision = ref_name

        return self._get_revision(revision)

    def _get_archives(self, archive_name='tip'):

                                         untrusted=True)

                                                           untrusted=True):

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        # filter branches

        filter_ = []

        if branch_name:

        if start_date:

        if end_date:

        if filter_ or max_revisions:

            if filter_:

            else:

            if max_revisions:

            revisions = scmutil.revrange(self._repo, [revspec])

        else:

            revisions = self.revisions

        # this is very much a hack to turn this into a list; a better solution

        # would be to get rid of this function entirely and use revsets

        self.repo_name = repo_name

    def _serve(self):

        # Note: we want a repo with config based on .hg/hgrc and can thus not use self.db_repo.scm_instance._repo.ui

        baseui = make_ui(repo_path=self.db_repo.repo_full_path)

        if not self.allow_push: