from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.controllers.changeset import _context_url, _ignorews_url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

    def _before(self, *args, **kwargs):

        super(CompareController, self)._before(*args, **kwargs)

        # The base repository has already been retrieved.

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestors = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                hgrepo = mercurial.unionrepo.makeunionrepository(other_repo.baseui,

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            # no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

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

                         hgrepo.revs(b"id(%s) & ::id(%s)", ascii_bytes(other_rev), ascii_bytes(org_rev))]

            if ancestors:

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

            else:

                    c.update_msg = _('This pull request has been closed and can not be updated.')

                else: # look for descendants of PR head on source branch in org repo

                    avail_revs = org_scm_instance._repo.revs('%s:: & branch(%s)',

                                                             revs[0], c.cs_branch_name)

                    if len(avail_revs) > 1: # more than just revs[0]

                        # also show changesets that not are descendants but would be merged in

                        targethead = other_scm_instance.get_changeset(c.a_branch_name).raw_id

                        if org_scm_instance.path != other_scm_instance.path:

                            # Note: org_scm_instance.path must come first so all

                            # valid revision numbers are 100% org_scm compatible

                            # - both for avail_revs and for revset results

                            hgrepo = mercurial.unionrepo.makeunionrepository(org_scm_instance.baseui,

                        else:

                            hgrepo = org_scm_instance._repo

                        show = set(hgrepo.revs('::%ld & !::parents(%s) & !::%s',

                                               avail_revs, revs[0], targethead))

                        if show:

                            c.update_msg = _('The following additional changes are available on %s:') % c.cs_branch_name

                        else:

                            c.update_msg = _('No additional changesets found for iterating on this pull request.')

                    else:

                        show = set()

                        avail_revs = set() # drop revs[0]

                        c.update_msg = _('No additional changesets found for iterating on this pull request.')

def check_password(password, hashed):

    """

    Checks matching password with it's hashed value, runs different

    implementation based on platform it runs on

    :param password: password

    :param hashed: password in hashed form

    """

    if is_windows:

    elif is_unix:

        import bcrypt

        try:

            return bcrypt.checkpw(safe_bytes(password), ascii_bytes(hashed))

        except ValueError as e:

            # bcrypt will throw ValueError 'Invalid hashed_password salt' on all password errors

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

        raise Exception('Unknown or unsupported platform %s'

                        % __platform__)

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import os

import time

import mercurial.scmutil

from kallithea.lib import helpers as h

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import action_logger, make_ui, setup_cache_regions

from kallithea.lib.vcs.backends.base import EmptyChangeset

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:

            for f in files:

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

    """Show size of Mercurial repository, to be called 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(), ascii_str(last_cs.hex())[:12]

    )

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

    """Logs user last pull action

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

    Does *not* use the action from the hook environment but is always 'pull'.

    """

    ex = get_hook_environment()

    user = User.get_by_username(ex.username)

                             '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(

                        b'HEAD',

                # 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]

                # now list the git revs while excluding from the list

                cmd = ['log', push_ref['new_rev'], '--reverse', '--pretty=format:%H']

                cmd.append('--not')

                cmd.extend(heads) # empty list is ok

                stdout = scm_repo.run_git_command(cmd)

                git_revs += stdout.splitlines()

        elif _type == 'tags':

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

    process_pushed_raw_ids(git_revs)

    return 0

# Almost exactly like Mercurial contrib/hg-ssh:

def rejectpush(ui, **kwargs):

    """Mercurial hook to be installed as pretxnopen and prepushkey for read-only repos"""

    ex = get_hook_environment()

    return 1

"""

import logging

import os

import urllib

import mercurial.hgweb

from kallithea.lib.base import BaseVCSController, get_path_info

from kallithea.lib.utils import make_ui

log = logging.getLogger(__name__)

def get_header_hgarg(environ):

    """Decode the special Mercurial encoding of big requests over multiple headers.

    >>> get_header_hgarg({})

    ''

    >>> get_header_hgarg({'HTTP_X_HGARG_0': ' ', 'HTTP_X_HGARG_1': 'a','HTTP_X_HGARG_2': '','HTTP_X_HGARG_3': 'b+c %20'})

    'ab+c %20'

    """

                        action = cmd_mapping.get(cmd, 'push')

                    break # only process one cmd

        return parsed_request

    def _make_app(self, parsed_request):

        """

        Make an hgweb wsgi application.

        """

        str_repo_name = safe_str(parsed_request.repo_name)

        repo_path = os.path.join(safe_str(self.basepath), str_repo_name)

        baseui = make_ui(repo_path=repo_path)

        def wrapper_app(environ, start_response):

            environ['REPO_NAME'] = str_repo_name # used by mercurial.hgweb.hgweb

            return hgweb_app(environ, start_response)

        return wrapper_app

    # prevent interactive questions for ssh password / passphrase

    ssh = baseui.config(b'ui', b'ssh', default=b'ssh')

    baseui.setconfig(b'ui', b'ssh', b'%s -oBatchMode=yes -oIdentitiesOnly=yes' % ssh)

    # push / pull hooks

    baseui.setconfig(b'hooks', b'changegroup.kallithea_log_push_action', b'python:kallithea.lib.hooks.log_push_action')

    baseui.setconfig(b'hooks', b'outgoing.kallithea_log_pull_action', b'python:kallithea.lib.hooks.log_pull_action')

    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 = mercurial.config.config()

            for section in ui_sections:

                for k, v in cfg.items(section):

                    log.debug('config from file: [%s] %s=%s', section, k, v)

                    baseui.setconfig(ascii_bytes(section), ascii_bytes(k), safe_bytes(v))

        else:

            log.debug('hgrc file is not present at %s, skipping...', hgrc_path)

    return baseui

def set_app_settings(config):

    """

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                zip(ancestors, ancestors[1:])]

            ):

                parent[path] = stat.S_IFDIR, tree.id

                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]]

                    if isinstance(obj, objects.Tree):

                        trees.append(obj)

                        tree = obj

                except KeyError:

                    break

            # Cut down the blob and all rotten trees on the way back...

        author_time = kwargs.pop('author_time', date)

        commit.commit_time = int(date)

        commit.author_time = int(author_time)

        tz = time.timezone

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

        commit.commit_timezone = tz

        commit.author_timezone = author_tz

        object_store.add_object(commit)

        # Update vcs repository object & recreate dulwich repo

        repo.refs[ref] = commit.id

        self.repository.revisions.append(ascii_str(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

    def _get_missing_trees(self, path, root_tree):

        """

        Creates missing ``Tree`` objects for the given path.

import mercurial.url  # import httpbasicauthhandler, httpdigestauthhandler

import mercurial.util  # import url as hg_url

from dulwich.config import ConfigFile

from dulwich.objects import Tag

from dulwich.repo import NotGitRepository, Repo

from kallithea.lib.vcs import subprocessio

from kallithea.lib.vcs.backends.base import BaseRepository, CollectionGenerator

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import (

    BranchDoesNotExistError, ChangesetDoesNotExistError, EmptyRepositoryError, RepositoryError, TagAlreadyExistError, TagDoesNotExistError)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import abspath, get_user_home

from .changeset import GitChangeset

from .inmemory import GitInMemoryChangeset

from .workdir import GitWorkdir

SHA_PATTERN = re.compile(r'^([0-9a-fA-F]{12}|[0-9a-fA-F]{40})$')

log = logging.getLogger(__name__)

        """

        # check first if it's not an local url

        if os.path.isdir(url) or url.startswith('file:'):

            return True

        if url.startswith('git://'):

            return True

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

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

        handlers = []

        test_uri, authinfo = url_obj.authinfo()

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

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

        url_obj.passwd = b'*****'

        cleaned_uri = str(url_obj)

        if authinfo:

            # create a password manager

            passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()

            passmgr.add_password(*authinfo)

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

                raise ChangesetDoesNotExistError(msg)

        if isinstance(revision, (str, unicode)):

            if revision.isdigit() and (len(revision) < 12 or len(revision) == revision.count('0')):

                try:

                    return self.revisions[int(revision)]

                except IndexError:

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

                    raise ChangesetDoesNotExistError(msg)

            # get by branch/tag name

            if _ref_revision:  # and _ref_revision[1] in [b'H', b'RH', b'T']:

                return ascii_str(_ref_revision[0])

            if revision in self.revisions:

                return revision

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

            if revision in self.tags.values():

                return revision

            if SHA_PATTERN.match(revision):

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

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param revision: changeset id for which new tag would be created

        :param message: message of the tag's commit

        :param date: date of tag's commit

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        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):

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param message: message of the tag's removal commit

import os

import posixpath

import mercurial.archival

import mercurial.node

import mercurial.obsutil

from kallithea.lib.vcs.backends.base import BaseChangeset

from kallithea.lib.vcs.conf import settings

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

from kallithea.lib.vcs.nodes import (

    AddedFileNodesGenerator, ChangedFileNodesGenerator, DirNode, FileNode, NodeKind, RemovedFileNodesGenerator, RootNode, SubModuleNode)

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.utils.paths import get_dirs_for_path

class MercurialChangeset(BaseChangeset):

    """

    Represents state of the repository at a revision.

    """

    def __init__(self, repository, revision):

        self.repository = repository

        assert isinstance(revision, basestring), repr(revision)

            return NodeKind.FILE

        elif path in self._dir_paths:

            return NodeKind.DIR

        else:

            raise ChangesetError("Node does not exist at the given path '%s'"

                % (path))

    def _get_filectx(self, path):

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

            raise ChangesetError("File does not exist for revision %s at "

                " '%s'" % (self.raw_id, path))

    def _extract_submodules(self):

        """

        returns a dictionary with submodule information from substate file

        of hg repository

        """

        return self._ctx.substate

    def get_file_mode(self, path):

        """

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

        """

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        if prefix is None:

            prefix = '%s-%s' % (self.repository.name, self.short_id)

        elif prefix.startswith('/'):

            raise VCSError("Prefix cannot start with leading slash")

        elif prefix.strip() == '':

            raise VCSError("Prefix cannot be empty")

        mercurial.archival.archive(self.repository._repo, stream, ascii_bytes(self.raw_id),

    def get_nodes(self, path):

        """

        Returns combined ``DirNode`` and ``FileNode`` objects list representing

        state of changeset at the given ``path``. If node at the given ``path``

        is not instance of ``DirNode``, ChangesetError would be raised.

        """

        if self._get_kind(path) != NodeKind.DIR:

            raise ChangesetError("Directory does not exist for revision %s at "

                " '%s'" % (self.revision, path))

        path = self._fix_path(path)

        :raises ``CommitError``: if any error occurs while committing

        """

        self.check_integrity(parents)

        from .repository import MercurialRepository

        if not isinstance(message, unicode) or not isinstance(author, unicode):

            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, bytes_path):

            """

            Callback from Mercurial, returning ctx to commit for the given

            path.

            """

            path = bytes_path  # will be different for py3

            # check if this path is removed

            if path in (node.path for node in self.removed):

                return None

                        isexec=node.is_executable,

                        copysource=False)

            raise RepositoryError("Given path haven't been marked as added, "

                                  "changed or removed (%s)" % path)

        parents = [None, None]

        for i, parent in enumerate(self.parents):

            if parent is not None:

                parents[i] = parent._ctx.node()

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

        commit_ctx = mercurial.context.memctx(

            repo=self.repository._repo,

            parents=parents,

            text=b'',

            filectxfn=filectxfn,

            date=date,

            extra=kwargs)

        # injecting given _repo params

        commit_ctx._text = safe_bytes(message)

        commit_ctx._user = safe_bytes(author)

        commit_ctx._date = date

        # TODO: Catch exceptions!

        n = self.repository._repo.commitctx(commit_ctx)

        # Returns mercurial node

        self._commit_ctx = commit_ctx  # For reference

        :raises TagAlreadyExistError: if tag with same name already exists

        """

        if name in self.tags:

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

        changeset = self.get_changeset(revision)

        local = kwargs.setdefault('local', False)

        if message is None:

            message = "Added tag %s for changeset %s" % (name,

                changeset.short_id)

        if date is None:

        try:

        except mercurial.error.Abort as e:

            raise RepositoryError(e.message)

        # Reinitialize tags

        self.tags = self._get_tags()

        tag_id = self.tags[name]

        return self.get_changeset(revision=tag_id)

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

        """

        Removes tag with the given ``name``.

        :param name: name of the tag to be removed

        :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"

        :param message: message of the tag's removal commit

        :param date: date of tag's removal commit

        :raises TagDoesNotExistError: if tag with given name does not exists

        """

        if name not in self.tags:

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        if message is None:

            message = "Removed tag %s" % name

        if date is None:

        local = False

        try:

            self.tags = self._get_tags()

        except mercurial.error.Abort as e:

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        Gets bookmarks for this repository

        """

        return self._get_bookmarks()

    def _get_bookmarks(self):

        that case repository would be created and returned.

        If ``src_url`` is given, would try to clone repository from the

        location at given clone_point. Additionally it'll make update to

        working copy accordingly to ``update_after_clone`` flag

        """

        try:

            if src_url:

                url = safe_bytes(self._get_url(src_url))

                opts = {}

                if not update_after_clone:

                    opts.update({'noupdate': True})

                MercurialRepository._check_url(url, self.baseui)

                # Don't try to create if we've already cloned repo

                create = False

        except (mercurial.error.Abort, mercurial.error.RepoError) as err:

            if create:

                msg = "Cannot create repository at %s. Original error was %s" \

                    % (self.name, err)

            else:

                msg = "Not valid repository at %s. Original error was %s" \

                    % (self.name, err)

            raise RepositoryError(msg)

    @LazyProperty

    def in_memory_changeset(self):

        return MercurialInMemoryChangeset(self)

                                  "after end revision '%s'" % (start, end))

        if branch_name and branch_name not in self.allbranches:

            msg = "Branch %r not found in %s" % (branch_name, self.name)

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        # filter branches

        filter_ = []

        if branch_name:

            filter_.append(b'branch("%s")' % safe_bytes(branch_name))

        if start_date:

        if end_date:

        if filter_ or max_revisions:

            if filter_:

                revspec = b' and '.join(filter_)

            else:

                revspec = b'all()'

            if max_revisions:

                revspec = b'limit(%s, %d)' % (revspec, max_revisions)

            revisions = mercurial.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

        revs = list(revisions)[start_pos:end_pos]

        if reverse:

            revs.reverse()

        return CollectionGenerator(self, revs)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        try:

            mercurial.exchange.pull(self._repo, other, heads=None, force=None)

        except mercurial.error.Abort as err:

            # Propagate error but with vcs's type

            raise RepositoryError(str(err))

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return MercurialWorkdir(self)

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        config = self._repo.ui

        if config_file:

            config = mercurial.ui.ui()

            for path in config_file:

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        username = self.get_config_value('ui', 'username', config_file=config_file)

        if username:

            return author_name(username)

        return None

    user = relationship('User')

    @property

    def public_key(self):

        return self._public_key

    @public_key.setter

    def public_key(self, full_key):

        # the full public key is too long to be suitable as database key - instead,

        # use fingerprints similar to 'ssh-keygen -E sha256 -lf ~/.ssh/id_rsa.pub'

        self._public_key = full_key

        self.fingerprint = base64.b64encode(hashlib.sha256(base64.b64decode(enc_key)).digest()).replace(b'\n', b'').rstrip(b'=').decode()

import sys

import traceback

import pkg_resources

from tg.i18n import ugettext as _

import kallithea

from kallithea import BACKENDS

from kallithea.lib.auth import HasPermissionAny, HasRepoGroupPermissionLevel, HasRepoPermissionLevel, HasUserGroupPermissionLevel

from kallithea.lib.exceptions import IMCCommitError, NonRelativePathError

from kallithea.lib.hooks import process_pushed_raw_ids

from kallithea.lib.utils import action_logger, get_filesystem_repos, make_ui

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.model.db import PullRequest, RepoGroup, Repository, Session, Ui, User, UserFollowing, UserLog

log = logging.getLogger(__name__)

class UserTemp(object):

        Creates a kallithea hook inside a git repository

        :param repo: Instance of VCS repo

        :param force_create: Create even if same name hook exists

        """

        loc = os.path.join(repo.path, 'hooks')

        if not repo.bare:

            loc = os.path.join(repo.path, '.git', 'hooks')

        if not os.path.isdir(loc):

            os.makedirs(loc)

        tmpl_post += pkg_resources.resource_string(

            'kallithea', os.path.join('config', 'post_receive_tmpl.py')

        )