rhodecode-enterprise-ce Compare - rhodecode-enterprise-ce@ebe0247cd154889e46e1b1638efa15728fc577d0 > rhodecode-enterprise-ce@e31abe6080b9c2d08eb0f9617d5613f7914f9abf

Compare Commits

Target:

Source:

Actions:

Compare Commits Swap

Time	Author	Commit		Description
0 commits hidden, click expand to show them.
No commits in this compare

Collapse all files

rhodecode/lib/vcs/backends/base.py

0 0 -4

             # -*- coding: utf-8 -*-
             # Copyright (C) 2014-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             Base module for all VCS systems
             """
             import collections
             import datetime
             import itertools
             import logging
             import os
             import time
             import warnings
             from zope.cachedescriptors.property import Lazy as LazyProperty
             from rhodecode.lib.utils2 import safe_str, safe_unicode
             from rhodecode.lib.vcs import connection
             from rhodecode.lib.vcs.utils import author_name, author_email
             from rhodecode.lib.vcs.conf import settings
             from rhodecode.lib.vcs.exceptions import (
                 CommitError, EmptyRepositoryError, NodeAlreadyAddedError,
                 NodeAlreadyChangedError, NodeAlreadyExistsError, NodeAlreadyRemovedError,
                 NodeDoesNotExistError, NodeNotChangedError, VCSError,
                 ImproperArchiveTypeError, BranchDoesNotExistError, CommitDoesNotExistError,
                 RepositoryError)
             log = logging.getLogger(__name__)
             FILEMODE_DEFAULT = 0100644
             FILEMODE_EXECUTABLE = 0100755
             Reference = collections.namedtuple('Reference', ('type', 'name', 'commit_id'))
             MergeResponse = collections.namedtuple(
                 'MergeResponse',
                 ('possible', 'executed', 'merge_ref', 'failure_reason'))
             class MergeFailureReason(object):
                 """
                 Enumeration with all the reasons why the server side merge could fail.
                 DO NOT change the number of the reasons, as they may be stored in the
                 database.
                 Changing the name of a reason is acceptable and encouraged to deprecate old
                 reasons.
                 """
                 # Everything went well.
                 NONE = 0
                 # An unexpected exception was raised. Check the logs for more details.
                 UNKNOWN = 1
                 # The merge was not successful, there are conflicts.
                 MERGE_FAILED = 2
                 # The merge succeeded but we could not push it to the target repository.
                 PUSH_FAILED = 3
                 # The specified target is not a head in the target repository.
                 TARGET_IS_NOT_HEAD = 4
                 # The source repository contains more branches than the target. Pushing
                 # the merge will create additional branches in the target.
                 HG_SOURCE_HAS_MORE_BRANCHES = 5
                 # The target reference has multiple heads. That does not allow to correctly
                 # identify the target location. This could only happen for mercurial
                 # branches.
                 HG_TARGET_HAS_MULTIPLE_HEADS = 6
                 # The target repository is locked
                 TARGET_IS_LOCKED = 7
                 # Deprecated, use MISSING_TARGET_REF or MISSING_SOURCE_REF instead.
                 # A involved commit could not be found.
                 _DEPRECATED_MISSING_COMMIT = 8
                 # The target repo reference is missing.
                 MISSING_TARGET_REF = 9
                 # The source repo reference is missing.
                 MISSING_SOURCE_REF = 10
-                # The merge was not successful, there are conflicts related to sub
-                # repositories.
-                SUBREPO_MERGE_FAILED = 11
             class UpdateFailureReason(object):
                 """
                 Enumeration with all the reasons why the pull request update could fail.
                 DO NOT change the number of the reasons, as they may be stored in the
                 database.
                 Changing the name of a reason is acceptable and encouraged to deprecate old
                 reasons.
                 """
                 # Everything went well.
                 NONE = 0
                 # An unexpected exception was raised. Check the logs for more details.
                 UNKNOWN = 1
                 # The pull request is up to date.
                 NO_CHANGE = 2
                 # The pull request has a reference type that is not supported for update.
                 WRONG_REF_TPYE = 3
                 # Update failed because the target reference is missing.
                 MISSING_TARGET_REF = 4
                 # Update failed because the source reference is missing.
                 MISSING_SOURCE_REF = 5
             class BaseRepository(object):
                 """
                 Base Repository for final backends
                 .. attribute:: DEFAULT_BRANCH_NAME
                    name of default branch (i.e. "trunk" for svn, "master" for git etc.
                 .. attribute:: commit_ids
                    list of all available commit ids, in ascending order
                 .. attribute:: path
                    absolute path to the repository
                 .. attribute:: bookmarks
                    Mapping from name to :term:`Commit ID` of the bookmark. Empty in case
                    there are no bookmarks or the backend implementation does not support
                    bookmarks.
                 .. attribute:: tags
                    Mapping from name to :term:`Commit ID` of the tag.
                 """
                 DEFAULT_BRANCH_NAME = None
                 DEFAULT_CONTACT = u"Unknown"
                 DEFAULT_DESCRIPTION = u"unknown"
                 EMPTY_COMMIT_ID = '0' * 40
                 path = None
                 def __init__(self, repo_path, config=None, create=False, **kwargs):
                     """
                     Initializes repository. Raises RepositoryError if repository could
                     not be find at the given ``repo_path`` or directory at ``repo_path``
                     exists and ``create`` is set to True.
                     :param repo_path: local path of the repository
                     :param config: repository configuration
                     :param create=False: if set to True, would try to create repository.
                     :param src_url=None: if set, should be proper url from which repository
                       would be cloned; requires ``create`` parameter to be set to True -
                       raises RepositoryError if src_url is set and create evaluates to
                       False
                     """
                     raise NotImplementedError
                 def __repr__(self):
                     return '<%s at %s>' % (self.__class__.__name__, self.path)
                 def __len__(self):
                     return self.count()
                 def __eq__(self, other):
                     same_instance = isinstance(other, self.__class__)
                     return same_instance and other.path == self.path
                 def __ne__(self, other):
                     return not self.__eq__(other)
                 @LazyProperty
                 def EMPTY_COMMIT(self):
                     return EmptyCommit(self.EMPTY_COMMIT_ID)
                 @LazyProperty
                 def alias(self):
                     for k, v in settings.BACKENDS.items():
                         if v.split('.')[-1] == str(self.__class__.__name__):
                             return k
                 @LazyProperty
                 def name(self):
                     return safe_unicode(os.path.basename(self.path))
                 @LazyProperty
                 def description(self):
                     raise NotImplementedError
                 def refs(self):
                     """
                     returns a `dict` with branches, bookmarks, tags, and closed_branches
                     for this repository
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def branches(self):
                     """
                     A `dict` which maps branch names to commit ids.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def size(self):
                     """
                     Returns combined size in bytes for all repository files
                     """
                     tip = self.get_commit()
                     return tip.size
                 def size_at_commit(self, commit_id):
                     commit = self.get_commit(commit_id)
                     return commit.size
                 def is_empty(self):
                     return not bool(self.commit_ids)
                 @staticmethod
                 def check_url(url, config):
                     """
                     Function will check given url and try to verify if it's a valid
                     link.
                     """
                     raise NotImplementedError
                 @staticmethod
                 def is_valid_repository(path):
                     """
                     Check if given `path` contains a valid repository of this backend
                     """
                     raise NotImplementedError
                 # ==========================================================================
                 # COMMITS
                 # ==========================================================================
                 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
                     """
                     Returns instance of `BaseCommit` class. If `commit_id` and `commit_idx`
                     are both None, most recent commit is returned.
                     :param pre_load: Optional. List of commit attributes to load.
                     :raises ``EmptyRepositoryError``: if there are no commits
                     """
                     raise NotImplementedError
                 def __iter__(self):
                     for commit_id in self.commit_ids:
                         yield self.get_commit(commit_id=commit_id)
                 def get_commits(
                         self, start_id=None, end_id=None, start_date=None, end_date=None,
                         branch_name=None, pre_load=None):
                     """
                     Returns iterator of `BaseCommit` objects from start to end
                     not inclusive. This should behave just like a list, ie. end is not
                     inclusive.
                     :param start_id: None or str, must be a valid commit id
                     :param end_id: None or str, must be a valid commit id
                     :param start_date:
                     :param end_date:
                     :param branch_name:
                     :param pre_load:
                     """
                     raise NotImplementedError
                 def __getitem__(self, key):
                     """
                     Allows index based access to the commit objects of this repository.
                     """
                     pre_load = ["author", "branch", "date", "message", "parents"]
                     if isinstance(key, slice):
                         return self._get_range(key, pre_load)
                     return self.get_commit(commit_idx=key, pre_load=pre_load)
                 def _get_range(self, slice_obj, pre_load):
                     for commit_id in self.commit_ids.__getitem__(slice_obj):
                         yield self.get_commit(commit_id=commit_id, pre_load=pre_load)
                 def count(self):
                     return len(self.commit_ids)
                 def tag(self, name, user, commit_id=None, message=None, date=None, **opts):
                     """
                     Creates and returns a tag for the given ``commit_id``.
                     :param name: name for new tag
                     :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
                     :param commit_id: commit 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
                     """
                     raise NotImplementedError
                 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
                     """
                     raise NotImplementedError
                 def get_diff(
                         self, commit1, commit2, path=None, ignore_whitespace=False,
                         context=3, path1=None):
                     """
                     Returns (git like) *diff*, as plain text. Shows changes introduced by
                     `commit2` since `commit1`.
                     :param commit1: Entry point from which diff is shown. Can be
                       ``self.EMPTY_COMMIT`` - in this case, patch showing all
                       the changes since empty state of the repository until `commit2`
                     :param commit2: Until which commit changes should be shown.
                     :param path: Can be set to a path of a file to create a diff of that
                       file. If `path1` is also set, this value is only associated to
                       `commit2`.
                     :param ignore_whitespace: If set to ``True``, would not show whitespace
                       changes. Defaults to ``False``.
                     :param context: How many lines before/after changed lines should be
                       shown. Defaults to ``3``.
                     :param path1: Can be set to a path to associate with `commit1`. This
                       parameter works only for backends which support diff generation for
                       different paths. Other backends will raise a `ValueError` if `path1`
                       is set and has a different value than `path`.
                     """
                     raise NotImplementedError
                 def strip(self, commit_id, branch=None):
                     """
                     Strip given commit_id from the repository
                     """
                     raise NotImplementedError
                 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
                     """
                     Return a latest common ancestor commit if one exists for this repo
                     `commit_id1` vs `commit_id2` from `repo2`.
                     :param commit_id1: Commit it from this repository to use as a
                        target for the comparison.
                     :param commit_id2: Source commit id to use for comparison.
                     :param repo2: Source repository to use for comparison.
                     """
                     raise NotImplementedError
                 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
                     """
                     Compare this repository's revision `commit_id1` with `commit_id2`.
                     Returns a tuple(commits, ancestor) that would be merged from
                     `commit_id2`. Doing a normal compare (``merge=False``), ``None``
                     will be returned as ancestor.
                     :param commit_id1: Commit it from this repository to use as a
                        target for the comparison.
                     :param commit_id2: Source commit id to use for comparison.
                     :param repo2: Source repository to use for comparison.
                     :param merge: If set to ``True`` will do a merge compare which also
                        returns the common ancestor.
                     :param pre_load: Optional. List of commit attributes to load.
                     """
                     raise NotImplementedError
                 def merge(self, target_ref, source_repo, source_ref, workspace_id,
                           user_name='', user_email='', message='', dry_run=False,
                           use_rebase=False):
                     """
                     Merge the revisions specified in `source_ref` from `source_repo`
                     onto the `target_ref` of this repository.
                     `source_ref` and `target_ref` are named tupls with the following
                     fields `type`, `name` and `commit_id`.
                     Returns a MergeResponse named tuple with the following fields
                     'possible', 'executed', 'source_commit', 'target_commit',
                     'merge_commit'.
                     :param target_ref: `target_ref` points to the commit on top of which
                         the `source_ref` should be merged.
                     :param source_repo: The repository that contains the commits to be
                         merged.
                     :param source_ref: `source_ref` points to the topmost commit from
                         the `source_repo` which should be merged.
                     :param workspace_id: `workspace_id` unique identifier.
                     :param user_name: Merge commit `user_name`.
                     :param user_email: Merge commit `user_email`.
                     :param message: Merge commit `message`.
                     :param dry_run: If `True` the merge will not take place.
                     :param use_rebase: If `True` commits from the source will be rebased
                         on top of the target instead of being merged.
                     """
                     if dry_run:
                         message = message or 'dry_run_merge_message'
                         user_email = user_email or 'dry-run-merge@rhodecode.com'
                         user_name = user_name or 'Dry-Run User'
                     else:
                         if not user_name:
                             raise ValueError('user_name cannot be empty')
                         if not user_email:
                             raise ValueError('user_email cannot be empty')
                         if not message:
                             raise ValueError('message cannot be empty')
                     shadow_repository_path = self._maybe_prepare_merge_workspace(
                         workspace_id, target_ref)
                     try:
                         return self._merge_repo(
                             shadow_repository_path, target_ref, source_repo,
                             source_ref, message, user_name, user_email, dry_run=dry_run,
                             use_rebase=use_rebase)
                     except RepositoryError:
                         log.exception(
                             'Unexpected failure when running merge, dry-run=%s',
                             dry_run)
                         return MergeResponse(
                             False, False, None, MergeFailureReason.UNKNOWN)
                 def _merge_repo(self, shadow_repository_path, target_ref,
                                 source_repo, source_ref, merge_message,
                                 merger_name, merger_email, dry_run=False, use_rebase=False):
                     """Internal implementation of merge."""
                     raise NotImplementedError
                 def _maybe_prepare_merge_workspace(self, workspace_id, target_ref):
                     """
                     Create the merge workspace.
                     :param workspace_id: `workspace_id` unique identifier.
                     """
                     raise NotImplementedError
                 def cleanup_merge_workspace(self, workspace_id):
                     """
                     Remove merge workspace.
                     This function MUST not fail in case there is no workspace associated to
                     the given `workspace_id`.
                     :param workspace_id: `workspace_id` unique identifier.
                     """
                     raise NotImplementedError
                 # ========== #
                 # COMMIT API #
                 # ========== #
                 @LazyProperty
                 def in_memory_commit(self):
                     """
                     Returns :class:`InMemoryCommit` object for this repository.
                     """
                     raise NotImplementedError
                 # ======================== #
                 # UTILITIES FOR SUBCLASSES #
                 # ======================== #
                 def _validate_diff_commits(self, commit1, commit2):
                     """
                     Validates that the given commits are related to this repository.
                     Intended as a utility for sub classes to have a consistent validation
                     of input parameters in methods like :meth:`get_diff`.
                     """
                     self._validate_commit(commit1)
                     self._validate_commit(commit2)
                     if (isinstance(commit1, EmptyCommit) and
                             isinstance(commit2, EmptyCommit)):
                         raise ValueError("Cannot compare two empty commits")
                 def _validate_commit(self, commit):
                     if not isinstance(commit, BaseCommit):
                         raise TypeError(
                             "%s is not of type BaseCommit" % repr(commit))
                     if commit.repository != self and not isinstance(commit, EmptyCommit):
                         raise ValueError(
                             "Commit %s must be a valid commit from this repository %s, "
                             "related to this repository instead %s." %
                             (commit, self, commit.repository))
                 def _validate_commit_id(self, commit_id):
                     if not isinstance(commit_id, basestring):
                         raise TypeError("commit_id must be a string value")
                 def _validate_commit_idx(self, commit_idx):
                     if not isinstance(commit_idx, (int, long)):
                         raise TypeError("commit_idx must be a numeric value")
                 def _validate_branch_name(self, branch_name):
                     if branch_name and branch_name not in self.branches_all:
                         msg = ("Branch %s not found in %s" % (branch_name, self))
                         raise BranchDoesNotExistError(msg)
                 #
                 # Supporting deprecated API parts
                 # TODO: johbo: consider to move this into a mixin
                 #
                 @property
                 def EMPTY_CHANGESET(self):
                     warnings.warn(
                         "Use EMPTY_COMMIT or EMPTY_COMMIT_ID instead", DeprecationWarning)
                     return self.EMPTY_COMMIT_ID
                 @property
                 def revisions(self):
                     warnings.warn("Use commits attribute instead", DeprecationWarning)
                     return self.commit_ids
                 @revisions.setter
                 def revisions(self, value):
                     warnings.warn("Use commits attribute instead", DeprecationWarning)
                     self.commit_ids = value
                 def get_changeset(self, revision=None, pre_load=None):
                     warnings.warn("Use get_commit instead", DeprecationWarning)
                     commit_id = None
                     commit_idx = None
                     if isinstance(revision, basestring):
                         commit_id = revision
                     else:
                         commit_idx = revision
                     return self.get_commit(
                         commit_id=commit_id, commit_idx=commit_idx, pre_load=pre_load)
                 def get_changesets(
                         self, start=None, end=None, start_date=None, end_date=None,
                         branch_name=None, pre_load=None):
                     warnings.warn("Use get_commits instead", DeprecationWarning)
                     start_id = self._revision_to_commit(start)
                     end_id = self._revision_to_commit(end)
                     return self.get_commits(
                         start_id=start_id, end_id=end_id, start_date=start_date,
                         end_date=end_date, branch_name=branch_name, pre_load=pre_load)
                 def _revision_to_commit(self, revision):
                     """
                     Translates a revision to a commit_id
                     Helps to support the old changeset based API which allows to use
                     commit ids and commit indices interchangeable.
                     """
                     if revision is None:
                         return revision
                     if isinstance(revision, basestring):
                         commit_id = revision
                     else:
                         commit_id = self.commit_ids[revision]
                     return commit_id
                 @property
                 def in_memory_changeset(self):
                     warnings.warn("Use in_memory_commit instead", DeprecationWarning)
                     return self.in_memory_commit
             class BaseCommit(object):
                 """
                 Each backend should implement it's commit representation.
                 **Attributes**
                     ``repository``
                         repository object within which commit exists
                     ``id``
                         The commit id, may be ``raw_id`` or i.e. for mercurial's tip
                         just ``tip``.
                     ``raw_id``
                         raw commit representation (i.e. full 40 length sha for git
                         backend)
                     ``short_id``
                         shortened (if apply) version of ``raw_id``; it would be simple
                         shortcut for ``raw_id[:12]`` for git/mercurial backends or same
                         as ``raw_id`` for subversion
                     ``idx``
                         commit index
                     ``files``
                         list of ``FileNode`` (``Node`` with NodeKind.FILE) objects
                     ``dirs``
                         list of ``DirNode`` (``Node`` with NodeKind.DIR) objects
                     ``nodes``
                         combined list of ``Node`` objects
                     ``author``
                         author of the commit, as unicode
                     ``message``
                         message of the commit, as unicode
                     ``parents``
                         list of parent commits
                 """
                 branch = None
                 """
                 Depending on the backend this should be set to the branch name of the
                 commit. Backends not supporting branches on commits should leave this
                 value as ``None``.
                 """
                 _ARCHIVE_PREFIX_TEMPLATE = b'{repo_name}-{short_id}'
                 """
                 This template is used to generate a default prefix for repository archives
                 if no prefix has been specified.
                 """
                 def __str__(self):
                     return '<%s at %s:%s>' % (
                         self.__class__.__name__, self.idx, self.short_id)
                 def __repr__(self):
                     return self.__str__()
                 def __unicode__(self):
                     return u'%s:%s' % (self.idx, self.short_id)
                 def __eq__(self, other):
                     same_instance = isinstance(other, self.__class__)
                     return same_instance and self.raw_id == other.raw_id
                 def __json__(self):
                     parents = []
                     try:
                         for parent in self.parents:
                             parents.append({'raw_id': parent.raw_id})
                     except NotImplementedError:
                         # empty commit doesn't have parents implemented
                         pass
                     return {
                         'short_id': self.short_id,
                         'raw_id': self.raw_id,
                         'revision': self.idx,
                         'message': self.message,
                         'date': self.date,
                         'author': self.author,
                         'parents': parents,
                         'branch': self.branch
                     }
                 @LazyProperty
                 def last(self):
                     """
                     ``True`` if this is last commit in repository, ``False``
                     otherwise; trying to access this attribute while there is no
                     commits would raise `EmptyRepositoryError`
                     """
                     if self.repository is None:
                         raise CommitError("Cannot check if it's most recent commit")
                     return self.raw_id == self.repository.commit_ids[-1]
                 @LazyProperty
                 def parents(self):
                     """
                     Returns list of parent commits.
                     """
                     raise NotImplementedError
                 @property
                 def merge(self):
                     """
                     Returns boolean if commit is a merge.
                     """
                     return len(self.parents) > 1
                 @LazyProperty
                 def children(self):
                     """
                     Returns list of child commits.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def id(self):
                     """
                     Returns string identifying this commit.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def raw_id(self):
                     """
                     Returns raw string identifying this commit.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def short_id(self):
                     """
                     Returns shortened version of ``raw_id`` attribute, as string,
                     identifying this commit, useful for presentation to users.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def idx(self):
                     """
                     Returns integer identifying this commit.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def committer(self):
                     """
                     Returns committer for this commit
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def committer_name(self):
                     """
                     Returns committer name for this commit
                     """
                     return author_name(self.committer)
                 @LazyProperty
                 def committer_email(self):
                     """
                     Returns committer email address for this commit
                     """
                     return author_email(self.committer)
                 @LazyProperty
                 def author(self):
                     """
                     Returns author for this commit
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def author_name(self):
                     """
                     Returns author name for this commit
                     """
                     return author_name(self.author)
                 @LazyProperty
                 def author_email(self):
                     """
                     Returns author email address for this commit
                     """
                     return author_email(self.author)
                 def get_file_mode(self, path):
                     """
                     Returns stat mode of the file at `path`.
                     """
                     raise NotImplementedError
                 def is_link(self, path):
                     """
                     Returns ``True`` if given `path` is a symlink
                     """
                     raise NotImplementedError
                 def get_file_content(self, path):
                     """
                     Returns content of the file at the given `path`.
                     """
                     raise NotImplementedError
                 def get_file_size(self, path):
                     """
                     Returns size of the file at the given `path`.
                     """
                     raise NotImplementedError
                 def get_file_commit(self, path, pre_load=None):
                     """
                     Returns last commit of the file at the given `path`.
                     :param pre_load: Optional. List of commit attributes to load.
                     """
                     return self.get_file_history(path, limit=1, pre_load=pre_load)[0]
                 def get_file_history(self, path, limit=None, pre_load=None):
                     """
                     Returns history of file as reversed list of :class:`BaseCommit`
                     objects for which file at given `path` has been modified.
                     :param limit: Optional. Allows to limit the size of the returned
                        history. This is intended as a hint to the underlying backend, so
                        that it can apply optimizations depending on the limit.
                     :param pre_load: Optional. List of commit attributes to load.
                     """
                     raise NotImplementedError
                 def get_file_annotate(self, path, pre_load=None):
                     """
                     Returns a generator of four element tuples with
                     lineno, sha, commit lazy loader and line
                     :param pre_load: Optional. List of commit attributes to load.
                     """
                     raise NotImplementedError
                 def get_nodes(self, path):
                     """
                     Returns combined ``DirNode`` and ``FileNode`` objects list representing
                     state of commit at the given ``path``.
                     :raises ``CommitError``: if node at the given ``path`` is not
                       instance of ``DirNode``
                     """
                     raise NotImplementedError
                 def get_node(self, path):
                     """
                     Returns ``Node`` object from the given ``path``.
                     :raises ``NodeDoesNotExistError``: if there is no node at the given
                       ``path``
                     """
                     raise NotImplementedError
                 def get_largefile_node(self, path):
                     """
                     Returns the path to largefile from Mercurial storage.
                     """
                     raise NotImplementedError
                 def archive_repo(self, file_path, kind='tgz', subrepos=None,
                                  prefix=None, write_metadata=False, mtime=None):
                     """
                     Creates an archive containing the contents of the repository.
                     :param file_path: path to the file which to create the archive.
                     :param kind: one of following: ``"tbz2"``, ``"tgz"``, ``"zip"``.
                     :param prefix: name of root directory in archive.
                         Default is repository name and commit's short_id joined with dash:
                         ``"{repo_name}-{short_id}"``.
                     :param write_metadata: write a metadata file into archive.
                     :param mtime: custom modification time for archive creation, defaults
                         to time.time() if not given.
                     :raise VCSError: If prefix has a problem.
                     """
                     allowed_kinds = settings.ARCHIVE_SPECS.keys()
                     if kind not in allowed_kinds:
                         raise ImproperArchiveTypeError(
                             'Archive kind (%s) not supported use one of %s' %
                             (kind, allowed_kinds))
                     prefix = self._validate_archive_prefix(prefix)
                     mtime = mtime or time.mktime(self.date.timetuple())
                     file_info = []
                     cur_rev = self.repository.get_commit(commit_id=self.raw_id)
                     for _r, _d, files in cur_rev.walk('/'):
                         for f in files:
                             f_path = os.path.join(prefix, f.path)
                             file_info.append(
                                 (f_path, f.mode, f.is_link(), f.raw_bytes))
                     if write_metadata:
                         metadata = [
                             ('repo_name', self.repository.name),
                             ('rev', self.raw_id),
                             ('create_time', mtime),
                             ('branch', self.branch),
                             ('tags', ','.join(self.tags)),
                         ]
                         meta = ["%s:%s" % (f_name, value) for f_name, value in metadata]
                         file_info.append(('.archival.txt', 0644, False, '\n'.join(meta)))
                     connection.Hg.archive_repo(file_path, mtime, file_info, kind)
                 def _validate_archive_prefix(self, prefix):
                     if prefix is None:
                         prefix = self._ARCHIVE_PREFIX_TEMPLATE.format(
                             repo_name=safe_str(self.repository.name),
                             short_id=self.short_id)
                     elif not isinstance(prefix, str):
                         raise ValueError("prefix not a bytes object: %s" % repr(prefix))
                     elif prefix.startswith('/'):
                         raise VCSError("Prefix cannot start with leading slash")
                     elif prefix.strip() == '':
                         raise VCSError("Prefix cannot be empty")
                     return prefix
                 @LazyProperty
                 def root(self):
                     """
                     Returns ``RootNode`` object for this commit.
                     """
                     return self.get_node('')
                 def next(self, branch=None):
                     """
                     Returns next commit from current, if branch is gives it will return
                     next commit belonging to this branch
                     :param branch: show commits within the given named branch
                     """
                     indexes = xrange(self.idx + 1, self.repository.count())
                     return self._find_next(indexes, branch)
                 def prev(self, branch=None):
                     """
                     Returns previous commit from current, if branch is gives it will
                     return previous commit belonging to this branch
                     :param branch: show commit within the given named branch
                     """
                     indexes = xrange(self.idx - 1, -1, -1)
                     return self._find_next(indexes, branch)
                 def _find_next(self, indexes, branch=None):
                     if branch and self.branch != branch:
                         raise VCSError('Branch option used on commit not belonging '
                                        'to that branch')
                     for next_idx in indexes:
                         commit = self.repository.get_commit(commit_idx=next_idx)
                         if branch and branch != commit.branch:
                             continue
                         return commit
                     raise CommitDoesNotExistError
                 def diff(self, ignore_whitespace=True, context=3):
                     """
                     Returns a `Diff` object representing the change made by this commit.
                     """
                     parent = (
                         self.parents[0] if self.parents else self.repository.EMPTY_COMMIT)
                     diff = self.repository.get_diff(
                         parent, self,
                         ignore_whitespace=ignore_whitespace,
                         context=context)
                     return diff
                 @LazyProperty
                 def added(self):
                     """
                     Returns list of added ``FileNode`` objects.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def changed(self):
                     """
                     Returns list of modified ``FileNode`` objects.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def removed(self):
                     """
                     Returns list of removed ``FileNode`` objects.
                     """
                     raise NotImplementedError
                 @LazyProperty
                 def size(self):
                     """
                     Returns total number of bytes from contents of all filenodes.
                     """
                     return sum((node.size for node in self.get_filenodes_generator()))
                 def walk(self, topurl=''):
                     """
                     Similar to os.walk method. Insted of filesystem it walks through
                     commit starting at given ``topurl``.  Returns generator of tuples
                     (topnode, dirnodes, filenodes).
                     """
                     topnode = self.get_node(topurl)
                     if not topnode.is_dir():
                         return
                     yield (topnode, topnode.dirs, topnode.files)
                     for dirnode in topnode.dirs:
                         for tup in self.walk(dirnode.path):
                             yield tup
                 def get_filenodes_generator(self):
                     """
                     Returns generator that yields *all* file nodes.
                     """
                     for topnode, dirs, files in self.walk():
                         for node in files:
                             yield node
                 #
                 # Utilities for sub classes to support consistent behavior
                 #
                 def no_node_at_path(self, path):
                     return NodeDoesNotExistError(
                         "There is no file nor directory at the given path: "
                         "'%s' at commit %s" % (path, self.short_id))
                 def _fix_path(self, path):
                     """
                     Paths are stored without trailing slash so we need to get rid off it if
                     needed.
                     """
                     return path.rstrip('/')
                 #
                 # Deprecated API based on changesets
                 #
                 @property
                 def revision(self):
                     warnings.warn("Use idx instead", DeprecationWarning)
                     return self.idx
                 @revision.setter
                 def revision(self, value):
                     warnings.warn("Use idx instead", DeprecationWarning)
                     self.idx = value
                 def get_file_changeset(self, path):
                     warnings.warn("Use get_file_commit instead", DeprecationWarning)
                     return self.get_file_commit(path)
             class BaseChangesetClass(type):
                 def __instancecheck__(self, instance):
                     return isinstance(instance, BaseCommit)
             class BaseChangeset(BaseCommit):
                 __metaclass__ = BaseChangesetClass
                 def __new__(cls, *args, **kwargs):
                     warnings.warn(
                         "Use BaseCommit instead of BaseChangeset", DeprecationWarning)
                     return super(BaseChangeset, cls).__new__(cls, *args, **kwargs)
             class BaseInMemoryCommit(object):
                 """
                 Represents differences between repository's state (most recent head) and
                 changes made *in place*.
                 **Attributes**
                     ``repository``
                         repository object for this in-memory-commit
                     ``added``
                         list of ``FileNode`` objects marked as *added*
                     ``changed``
                         list of ``FileNode`` objects marked as *changed*
                     ``removed``
                         list of ``FileNode`` or ``RemovedFileNode`` objects marked to be
                         *removed*
                     ``parents``
                         list of :class:`BaseCommit` instances representing parents of
                         in-memory commit. Should always be 2-element sequence.
                 """
                 def __init__(self, repository):
                     self.repository = repository
                     self.added = []
                     self.changed = []
                     self.removed = []
                     self.parents = []
                 def add(self, *filenodes):
                     """
                     Marks given ``FileNode`` objects as *to be committed*.
                     :raises ``NodeAlreadyExistsError``: if node with same path exists at
                        latest commit
                     :raises ``NodeAlreadyAddedError``: if node with same path is already
                        marked as *added*
                     """
                     # Check if not already marked as *added* first
                     for node in filenodes:
                         if node.path in (n.path for n in self.added):
                             raise NodeAlreadyAddedError(
                                 "Such FileNode %s is already marked for addition"
                                 % node.path)
                     for node in filenodes:
                         self.added.append(node)
                 def change(self, *filenodes):
                     """
                     Marks given ``FileNode`` objects to be *changed* in next commit.
                     :raises ``EmptyRepositoryError``: if there are no commits yet
                     :raises ``NodeAlreadyExistsError``: if node with same path is already
                        marked to be *changed*
                     :raises ``NodeAlreadyRemovedError``: if node with same path is already
                        marked to be *removed*
                     :raises ``NodeDoesNotExistError``: if node doesn't exist in latest
                        commit
                     :raises ``NodeNotChangedError``: if node hasn't really be changed
                     """
                     for node in filenodes:
                         if node.path in (n.path for n in self.removed):
                             raise NodeAlreadyRemovedError(
                                 "Node at %s is already marked as removed" % node.path)
                     try:
                         self.repository.get_commit()
                     except EmptyRepositoryError:
                         raise EmptyRepositoryError(
                             "Nothing to change - try to *add* new nodes rather than "
                             "changing them")
                     for node in filenodes:
                         if node.path in (n.path for n in self.changed):
                             raise NodeAlreadyChangedError(
                                 "Node at '%s' is already marked as changed" % node.path)
                         self.changed.append(node)
                 def remove(self, *filenodes):
                     """
                     Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be
                     *removed* in next commit.
                     :raises ``NodeAlreadyRemovedError``: if node has been already marked to
                        be *removed*
                     :raises ``NodeAlreadyChangedError``: if node has been already marked to
                        be *changed*
                     """
                     for node in filenodes:
                         if node.path in (n.path for n in self.removed):
                             raise NodeAlreadyRemovedError(
                                 "Node is already marked to for removal at %s" % node.path)
                         if node.path in (n.path for n in self.changed):
                             raise NodeAlreadyChangedError(
                                 "Node is already marked to be changed at %s" % node.path)
                         # We only mark node as *removed* - real removal is done by
                         # commit method
                         self.removed.append(node)
                 def reset(self):
                     """
                     Resets this instance to initial state (cleans ``added``, ``changed``
                     and ``removed`` lists).
                     """
                     self.added = []
                     self.changed = []
                     self.removed = []
                     self.parents = []
                 def get_ipaths(self):
                     """
                     Returns generator of paths from nodes marked as added, changed or
                     removed.
                     """
                     for node in itertools.chain(self.added, self.changed, self.removed):
                         yield node.path
                 def get_paths(self):
                     """
                     Returns list of paths from nodes marked as added, changed or removed.
                     """
                     return list(self.get_ipaths())
                 def check_integrity(self, parents=None):
                     """
                     Checks in-memory commit's integrity. Also, sets parents if not
                     already set.
                     :raises CommitError: if any error occurs (i.e.
                       ``NodeDoesNotExistError``).
                     """
                     if not self.parents:
                         parents = parents or []
                         if len(parents) == 0:
                             try:
                                 parents = [self.repository.get_commit(), None]
                             except EmptyRepositoryError:
                                 parents = [None, None]
                         elif len(parents) == 1:
                             parents += [None]
                         self.parents = parents
                     # Local parents, only if not None
                     parents = [p for p in self.parents if p]
                     # Check nodes marked as added
                     for p in parents:
                         for node in self.added:
                             try:
                                 p.get_node(node.path)
                             except NodeDoesNotExistError:
                                 pass
                             else:
                                 raise NodeAlreadyExistsError(
                                     "Node `%s` already exists at %s" % (node.path, p))
                     # Check nodes marked as changed
                     missing = set(self.changed)
                     not_changed = set(self.changed)
                     if self.changed and not parents:
                         raise NodeDoesNotExistError(str(self.changed[0].path))
                     for p in parents:
                         for node in self.changed:
                             try:
                                 old = p.get_node(node.path)
                                 missing.remove(node)
                                 # if content actually changed, remove node from not_changed
                                 if old.content != node.content:
                                     not_changed.remove(node)
                             except NodeDoesNotExistError:
                                 pass
                     if self.changed and missing:
                         raise NodeDoesNotExistError(
                             "Node `%s` marked as modified but missing in parents: %s"
                             % (node.path, parents))
                     if self.changed and not_changed:
                         raise NodeNotChangedError(
                             "Node `%s` wasn't actually changed (parents: %s)"
                             % (not_changed.pop().path, parents))
                     # Check nodes marked as removed
                     if self.removed and not parents:
                         raise NodeDoesNotExistError(
                             "Cannot remove node at %s as there "
                             "were no parents specified" % self.removed[0].path)
                     really_removed = set()
                     for p in parents:
                         for node in self.removed:
                             try:
                                 p.get_node(node.path)
                                 really_removed.add(node)
                             except CommitError:
                                 pass
                     not_removed = set(self.removed) - really_removed
                     if not_removed:
                         # TODO: johbo: This code branch does not seem to be covered
                         raise NodeDoesNotExistError(
                             "Cannot remove node at %s from "
                             "following parents: %s" % (not_removed, parents))
                 def commit(
                         self, message, author, parents=None, branch=None, date=None,
                         **kwargs):
                     """
                     Performs in-memory commit (doesn't check workdir in any way) and
                     returns newly created :class:`BaseCommit`. Updates repository's
                     attribute `commits`.
                     .. note::
                        While overriding this method each backend's should call
                        ``self.check_integrity(parents)`` in the first place.
                     :param message: message of the commit
                     :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"
                     :param parents: single parent or sequence of parents from which commit
                        would be derived
                     :param date: ``datetime.datetime`` instance. Defaults to
                        ``datetime.datetime.now()``.
                     :param branch: branch name, as string. If none given, default backend's
                        branch would be used.
                     :raises ``CommitError``: if any error occurs while committing
                     """
                     raise NotImplementedError
             class BaseInMemoryChangesetClass(type):
                 def __instancecheck__(self, instance):
                     return isinstance(instance, BaseInMemoryCommit)
             class BaseInMemoryChangeset(BaseInMemoryCommit):
                 __metaclass__ = BaseInMemoryChangesetClass
                 def __new__(cls, *args, **kwargs):
                     warnings.warn(
                         "Use BaseCommit instead of BaseInMemoryCommit", DeprecationWarning)
                     return super(BaseInMemoryChangeset, cls).__new__(cls, *args, **kwargs)
             class EmptyCommit(BaseCommit):
                 """
                 An dummy empty commit. It's possible to pass hash when creating
                 an EmptyCommit
                 """
                 def __init__(
                         self, commit_id='0' * 40, repo=None, alias=None, idx=-1,
                         message='', author='', date=None):
                     self._empty_commit_id = commit_id
                     # TODO: johbo: Solve idx parameter, default value does not make
                     # too much sense
                     self.idx = idx
                     self.message = message
                     self.author = author
                     self.date = date or datetime.datetime.fromtimestamp(0)
                     self.repository = repo
                     self.alias = alias
                 @LazyProperty
                 def raw_id(self):
                     """
                     Returns raw string identifying this commit, useful for web
                     representation.
                     """
                     return self._empty_commit_id
                 @LazyProperty
                 def branch(self):
                     if self.alias:
                         from rhodecode.lib.vcs.backends import get_backend
                         return get_backend(self.alias).DEFAULT_BRANCH_NAME
                 @LazyProperty
                 def short_id(self):
                     return self.raw_id[:12]
                 @LazyProperty
                 def id(self):
                     return self.raw_id
                 def get_file_commit(self, path):
                     return self
                 def get_file_content(self, path):
                     return u''
                 def get_file_size(self, path):
                     return 0
             class EmptyChangesetClass(type):
                 def __instancecheck__(self, instance):
                     return isinstance(instance, EmptyCommit)
             class EmptyChangeset(EmptyCommit):
                 __metaclass__ = EmptyChangesetClass
                 def __new__(cls, *args, **kwargs):
                     warnings.warn(
                         "Use EmptyCommit instead of EmptyChangeset", DeprecationWarning)
                     return super(EmptyCommit, cls).__new__(cls, *args, **kwargs)
                 def __init__(self, cs='0' * 40, repo=None, requested_revision=None,
                              alias=None, revision=-1, message='', author='', date=None):
                     if requested_revision is not None:
                         warnings.warn(
                             "Parameter requested_revision not supported anymore",
                             DeprecationWarning)
                     super(EmptyChangeset, self).__init__(
                         commit_id=cs, repo=repo, alias=alias, idx=revision,
                         message=message, author=author, date=date)
                     @property
                     def revision(self):
                         warnings.warn("Use idx instead", DeprecationWarning)
                         return self.idx
                     @revision.setter
                     def revision(self, value):
                         warnings.warn("Use idx instead", DeprecationWarning)
                         self.idx = value
             class CollectionGenerator(object):
                 def __init__(self, repo, commit_ids, collection_size=None, pre_load=None):
                     self.repo = repo
                     self.commit_ids = commit_ids
                     # TODO: (oliver) this isn't currently hooked up
                     self.collection_size = None
                     self.pre_load = pre_load
                 def __len__(self):
                     if self.collection_size is not None:
                         return self.collection_size
                     return self.commit_ids.__len__()
                 def __iter__(self):
                     for commit_id in self.commit_ids:
                         # TODO: johbo: Mercurial passes in commit indices or commit ids
                         yield self._commit_factory(commit_id)
                 def _commit_factory(self, commit_id):
                     """
                     Allows backends to override the way commits are generated.
                     """
                     return self.repo.get_commit(commit_id=commit_id,
                                                 pre_load=self.pre_load)
                 def __getslice__(self, i, j):
                     """
                     Returns an iterator of sliced repository
                     """
                     commit_ids = self.commit_ids[i:j]
                     return self.__class__(
                         self.repo, commit_ids, pre_load=self.pre_load)
                 def __repr__(self):
                     return '<CollectionGenerator[len:%s]>' % (self.__len__())
             class Config(object):
                 """
                 Represents the configuration for a repository.
                 The API is inspired by :class:`ConfigParser.ConfigParser` from the
                 standard library. It implements only the needed subset.
                 """
                 def __init__(self):
                     self._values = {}
                 def copy(self):
                     clone = Config()
                     for section, values in self._values.items():
                         clone._values[section] = values.copy()
                     return clone
                 def __repr__(self):
                     return '<Config(%s sections) at %s>' % (
                         len(self._values), hex(id(self)))
                 def items(self, section):
                     return self._values.get(section, {}).iteritems()
                 def get(self, section, option):
                     return self._values.get(section, {}).get(option)
                 def set(self, section, option, value):
                     section_values = self._values.setdefault(section, {})
                     section_values[option] = value
                 def clear_section(self, section):
                     self._values[section] = {}
                 def serialize(self):
                     """
                     Creates a list of three tuples (section, key, value) representing
                     this config object.
                     """
                     items = []
                     for section in self._values:
                         for option, value in self._values[section].items():
                             items.append(
                                 (safe_str(section), safe_str(option), safe_str(value)))
                     return items
             class Diff(object):
                 """
                 Represents a diff result from a repository backend.
                 Subclasses have to provide a backend specific value for :attr:`_header_re`.
                 """
                 _header_re = None
                 def __init__(self, raw_diff):
                     self.raw = raw_diff
                 def chunks(self):
                     """
                     split the diff in chunks of separate --git a/file b/file chunks
                     to make diffs consistent we must prepend with \n, and make sure
                     we can detect last chunk as this was also has special rule
                     """
                     chunks = ('\n' + self.raw).split('\ndiff --git')[1:]
                     total_chunks = len(chunks)
                     return (DiffChunk(chunk, self, cur_chunk == total_chunks)
                             for cur_chunk, chunk in enumerate(chunks, start=1))
             class DiffChunk(object):
                 def __init__(self, chunk, diff, last_chunk):
                     self._diff = diff
                     # since we split by \ndiff --git that part is lost from original diff
                     # we need to re-apply it at the end, EXCEPT ! if it's last chunk
                     if not last_chunk:
                         chunk += '\n'
                     match = self._diff._header_re.match(chunk)
                     self.header = match.groupdict()
                     self.diff = chunk[match.end():]
                     self.raw = chunk

rhodecode/lib/vcs/backends/hg/repository.py

0 +1 -6

             # -*- coding: utf-8 -*-
             # Copyright (C) 2014-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             HG repository module
             """
             import logging
             import binascii
             import os
             import shutil
             import urllib
             from zope.cachedescriptors.property import Lazy as LazyProperty
             from rhodecode.lib.compat import OrderedDict
             from rhodecode.lib.datelib import (
                 date_to_timestamp_plus_offset, utcdate_fromtimestamp, makedate,
                 date_astimestamp)
             from rhodecode.lib.utils import safe_unicode, safe_str
             from rhodecode.lib.vcs import connection
             from rhodecode.lib.vcs.backends.base import (
                 BaseRepository, CollectionGenerator, Config, MergeResponse,
                 MergeFailureReason, Reference)
             from rhodecode.lib.vcs.backends.hg.commit import MercurialCommit
             from rhodecode.lib.vcs.backends.hg.diff import MercurialDiff
             from rhodecode.lib.vcs.backends.hg.inmemory import MercurialInMemoryCommit
             from rhodecode.lib.vcs.exceptions import (
                 EmptyRepositoryError, RepositoryError, TagAlreadyExistError,
-                TagDoesNotExistError, CommitDoesNotExistError, SubrepoMergeError)
+                TagDoesNotExistError, CommitDoesNotExistError)
             hexlify = binascii.hexlify
             nullid = "\0" * 20
             log = logging.getLogger(__name__)
             class MercurialRepository(BaseRepository):
                 """
                 Mercurial repository backend
                 """
                 DEFAULT_BRANCH_NAME = 'default'
                 def __init__(self, repo_path, config=None, create=False, src_url=None,
                              update_after_clone=False, with_wire=None):
                     """
                     Raises RepositoryError if repository could not be find at the given
                     ``repo_path``.
                     :param repo_path: local path of the repository
                     :param config: config object containing the repo configuration
                     :param create=False: if set to True, would try to create repository if
                        it does not exist rather than raising exception
                     :param src_url=None: would try to clone repository from given location
                     :param update_after_clone=False: sets update of working copy after
                        making a clone
                     """
                     self.path = safe_str(os.path.abspath(repo_path))
                     self.config = config if config else Config()
                     self._remote = connection.Hg(
                         self.path, self.config, with_wire=with_wire)
                     self._init_repo(create, src_url, update_after_clone)
                     # caches
                     self._commit_ids = {}
                 @LazyProperty
                 def commit_ids(self):
                     """
                     Returns list of commit ids, in ascending order.  Being lazy
                     attribute allows external tools to inject shas from cache.
                     """
                     commit_ids = self._get_all_commit_ids()
                     self._rebuild_cache(commit_ids)
                     return commit_ids
                 def _rebuild_cache(self, commit_ids):
                     self._commit_ids = dict((commit_id, index)
                                             for index, commit_id in enumerate(commit_ids))
                 @LazyProperty
                 def branches(self):
                     return self._get_branches()
                 @LazyProperty
                 def branches_closed(self):
                     return self._get_branches(active=False, closed=True)
                 @LazyProperty
                 def branches_all(self):
                     all_branches = {}
                     all_branches.update(self.branches)
                     all_branches.update(self.branches_closed)
                     return all_branches
                 def _get_branches(self, active=True, closed=False):
                     """
                     Gets branches for this repository
                     Returns only not closed active branches by default
                     :param active: return also active branches
                     :param closed: return also closed branches
                     """
                     if self.is_empty():
                         return {}
                     def get_name(ctx):
                         return ctx[0]
                     _branches = [(safe_unicode(n), hexlify(h),) for n, h in
                                  self._remote.branches(active, closed).items()]
                     return OrderedDict(sorted(_branches, key=get_name, reverse=False))
                 @LazyProperty
                 def tags(self):
                     """
                     Gets tags for this repository
                     """
                     return self._get_tags()
                 def _get_tags(self):
                     if self.is_empty():
                         return {}
                     def get_name(ctx):
                         return ctx[0]
                     _tags = [(safe_unicode(n), hexlify(h),) for n, h in
                              self._remote.tags().items()]
                     return OrderedDict(sorted(_tags, key=get_name, reverse=True))
                 def tag(self, name, user, commit_id=None, message=None, date=None,
                         **kwargs):
                     """
                     Creates and returns a tag for the given ``commit_id``.
                     :param name: name for new tag
                     :param user: full username, i.e.: "Joe Doe <joe.doe@example.com>"
                     :param commit_id: commit 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)
                     commit = self.get_commit(commit_id=commit_id)
                     local = kwargs.setdefault('local', False)
                     if message is None:
                         message = "Added tag %s for commit %s" % (name, commit.short_id)
                     date, tz = date_to_timestamp_plus_offset(date)
                     self._remote.tag(
                         name, commit.raw_id, message, local, user, date, tz)
                     self._remote.invalidate_vcs_cache()
                     # Reinitialize tags
                     self.tags = self._get_tags()
                     tag_id = self.tags[name]
                     return self.get_commit(commit_id=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
                     local = False
                     date, tz = date_to_timestamp_plus_offset(date)
                     self._remote.tag(name, nullid, message, local, user, date, tz)
                     self._remote.invalidate_vcs_cache()
                     self.tags = self._get_tags()
                 @LazyProperty
                 def bookmarks(self):
                     """
                     Gets bookmarks for this repository
                     """
                     return self._get_bookmarks()
                 def _get_bookmarks(self):
                     if self.is_empty():
                         return {}
                     def get_name(ctx):
                         return ctx[0]
                     _bookmarks = [
                         (safe_unicode(n), hexlify(h)) for n, h in
                         self._remote.bookmarks().items()]
                     return OrderedDict(sorted(_bookmarks, key=get_name))
                 def _get_all_commit_ids(self):
                     return self._remote.get_all_commit_ids('visible')
                 def get_diff(
                         self, commit1, commit2, path='', ignore_whitespace=False,
                         context=3, path1=None):
                     """
                     Returns (git like) *diff*, as plain text. Shows changes introduced by
                     `commit2` since `commit1`.
                     :param commit1: Entry point from which diff is shown. Can be
                       ``self.EMPTY_COMMIT`` - in this case, patch showing all
                       the changes since empty state of the repository until `commit2`
                     :param commit2: Until which commit changes should be shown.
                     :param ignore_whitespace: If set to ``True``, would not show whitespace
                       changes. Defaults to ``False``.
                     :param context: How many lines before/after changed lines should be
                       shown. Defaults to ``3``.
                     """
                     self._validate_diff_commits(commit1, commit2)
                     if path1 is not None and path1 != path:
                         raise ValueError("Diff of two different paths not supported.")
                     if path:
                         file_filter = [self.path, path]
                     else:
                         file_filter = None
                     diff = self._remote.diff(
                         commit1.raw_id, commit2.raw_id, file_filter=file_filter,
                         opt_git=True, opt_ignorews=ignore_whitespace,
                         context=context)
                     return MercurialDiff(diff)
                 def strip(self, commit_id, branch=None):
                     self._remote.strip(commit_id, update=False, backup="none")
                     self._remote.invalidate_vcs_cache()
                     self.commit_ids = self._get_all_commit_ids()
                     self._rebuild_cache(self.commit_ids)
                 def get_common_ancestor(self, commit_id1, commit_id2, repo2):
                     if commit_id1 == commit_id2:
                         return commit_id1
                     ancestors = self._remote.revs_from_revspec(
                         "ancestor(id(%s), id(%s))", commit_id1, commit_id2,
                         other_path=repo2.path)
                     return repo2[ancestors[0]].raw_id if ancestors else None
                 def compare(self, commit_id1, commit_id2, repo2, merge, pre_load=None):
                     if commit_id1 == commit_id2:
                         commits = []
                     else:
                         if merge:
                             indexes = self._remote.revs_from_revspec(
                                 "ancestors(id(%s)) - ancestors(id(%s)) - id(%s)",
                                 commit_id2, commit_id1, commit_id1, other_path=repo2.path)
                         else:
                             indexes = self._remote.revs_from_revspec(
                                 "id(%s)..id(%s) - id(%s)", commit_id1, commit_id2,
                                 commit_id1, other_path=repo2.path)
                         commits = [repo2.get_commit(commit_idx=idx, pre_load=pre_load)
                                    for idx in indexes]
                     return commits
                 @staticmethod
                 def check_url(url, config):
                     """
                     Function will check given url and try to verify if it's a valid
                     link. Sometimes it may happened that mercurial will issue basic
                     auth request that can cause whole API to hang when used from python
                     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
                     if os.path.isdir(url) or url.startswith('file:'):
                         return True
                     # Request the _remote to verify the url
                     return connection.Hg.check_url(url, config.serialize())
                 @staticmethod
                 def is_valid_repository(path):
                     return os.path.isdir(os.path.join(path, '.hg'))
                 def _init_repo(self, create, src_url=None, update_after_clone=False):
                     """
                     Function will check for mercurial repository in given path. If there
                     is no repository in that path it will raise an exception unless
                     `create` parameter is set to True - in that case repository would
                     be created.
                     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.
                     """
                     if create and os.path.exists(self.path):
                         raise RepositoryError(
                             "Cannot create repository at %s, location already exist"
                             % self.path)
                     if src_url:
                         url = str(self._get_url(src_url))
                         MercurialRepository.check_url(url, self.config)
                         self._remote.clone(url, self.path, update_after_clone)
                         # Don't try to create if we've already cloned repo
                         create = False
                     if create:
                         os.makedirs(self.path, mode=0755)
                     self._remote.localrepository(create)
                 @LazyProperty
                 def in_memory_commit(self):
                     return MercurialInMemoryCommit(self)
                 @LazyProperty
                 def description(self):
                     description = self._remote.get_config_value(
                         'web', 'description', untrusted=True)
                     return safe_unicode(description or self.DEFAULT_DESCRIPTION)
                 @LazyProperty
                 def contact(self):
                     contact = (
                         self._remote.get_config_value("web", "contact") or
                         self._remote.get_config_value("ui", "username"))
                     return safe_unicode(contact or self.DEFAULT_CONTACT)
                 @LazyProperty
                 def last_change(self):
                     """
                     Returns last change made on this repository as
                     `datetime.datetime` object
                     """
                     return utcdate_fromtimestamp(self._get_mtime(), makedate()[1])
                 def _get_mtime(self):
                     try:
                         return date_astimestamp(self.get_commit().date)
                     except RepositoryError:
                         # fallback to filesystem
                         cl_path = os.path.join(self.path, '.hg', "00changelog.i")
                         st_path = os.path.join(self.path, '.hg', "store")
                         if os.path.exists(cl_path):
                             return os.stat(cl_path).st_mtime
                         else:
                             return os.stat(st_path).st_mtime
                 def _sanitize_commit_idx(self, idx):
                     # Note: Mercurial has ``int(-1)`` reserved as not existing id_or_idx
                     # number. A `long` is treated in the correct way though. So we convert
                     # `int` to `long` here to make sure it is handled correctly.
                     if isinstance(idx, int):
                         return long(idx)
                     return idx
                 def _get_url(self, url):
                     """
                     Returns normalized url. If schema is not given, would fall
                     to filesystem
                     (``file:///``) schema.
                     """
                     url = url.encode('utf8')
                     if url != 'default' and '://' not in url:
                         url = "file:" + urllib.pathname2url(url)
                     return url
                 def get_hook_location(self):
                     """
                     returns absolute path to location where hooks are stored
                     """
                     return os.path.join(self.path, '.hg', '.hgrc')
                 def get_commit(self, commit_id=None, commit_idx=None, pre_load=None):
                     """
                     Returns ``MercurialCommit`` object representing repository's
                     commit at the given `commit_id` or `commit_idx`.
                     """
                     if self.is_empty():
                         raise EmptyRepositoryError("There are no commits yet")
                     if commit_id is not None:
                         self._validate_commit_id(commit_id)
                         try:
                             idx = self._commit_ids[commit_id]
                             return MercurialCommit(self, commit_id, idx, pre_load=pre_load)
                         except KeyError:
                             pass
                     elif commit_idx is not None:
                         self._validate_commit_idx(commit_idx)
                         commit_idx = self._sanitize_commit_idx(commit_idx)
                         try:
                             id_ = self.commit_ids[commit_idx]
                             if commit_idx < 0:
                                 commit_idx += len(self.commit_ids)
                             return MercurialCommit(
                                 self, id_, commit_idx, pre_load=pre_load)
                         except IndexError:
                             commit_id = commit_idx
                     else:
                         commit_id = "tip"
                     # TODO Paris: Ugly hack to "serialize" long for msgpack
                     if isinstance(commit_id, long):
                         commit_id = float(commit_id)
                     if isinstance(commit_id, unicode):
                         commit_id = safe_str(commit_id)
                     raw_id, idx = self._remote.lookup(commit_id, both=True)
                     return MercurialCommit(self, raw_id, idx, pre_load=pre_load)
                 def get_commits(
                         self, start_id=None, end_id=None, start_date=None, end_date=None,
                         branch_name=None, pre_load=None):
                     """
                     Returns generator of ``MercurialCommit`` objects from start to end
                     (both are inclusive)
                     :param start_id: None, str(commit_id)
                     :param end_id: None, str(commit_id)
                     :param start_date: if specified, commits with commit date less than
                       ``start_date`` would be filtered out from returned set
                     :param end_date: if specified, commits with commit date greater than
                       ``end_date`` would be filtered out from returned set
                     :param branch_name: if specified, commits not reachable from given
                       branch would be filtered out from returned set
                     :raise BranchDoesNotExistError: If given ``branch_name`` does not
                         exist.
                     :raise CommitDoesNotExistError: If commit for given ``start`` or
                       ``end`` could not be found.
                     """
                     # actually we should check now if it's not an empty repo
                     branch_ancestors = False
                     if self.is_empty():
                         raise EmptyRepositoryError("There are no commits yet")
                     self._validate_branch_name(branch_name)
                     if start_id is not None:
                         self._validate_commit_id(start_id)
                         c_start = self.get_commit(commit_id=start_id)
                         start_pos = self._commit_ids[c_start.raw_id]
                     else:
                         start_pos = None
                     if end_id is not None:
                         self._validate_commit_id(end_id)
                         c_end = self.get_commit(commit_id=end_id)
                         end_pos = max(0, self._commit_ids[c_end.raw_id])
                     else:
                         end_pos = None
                     if None not in [start_id, end_id] and start_pos > end_pos:
                         raise RepositoryError(
                             "Start commit '%s' cannot be after end commit '%s'" %
                             (start_id, end_id))
                     if end_pos is not None:
                         end_pos += 1
                     commit_filter = []
                     if branch_name and not branch_ancestors:
                         commit_filter.append('branch("%s")' % branch_name)
                     elif branch_name and branch_ancestors:
                         commit_filter.append('ancestors(branch("%s"))' % branch_name)
                     if start_date and not end_date:
                         commit_filter.append('date(">%s")' % start_date)
                     if end_date and not start_date:
                         commit_filter.append('date("<%s")' % end_date)
                     if start_date and end_date:
                         commit_filter.append(
                             'date(">%s") and date("<%s")' % (start_date, end_date))
                     # TODO: johbo: Figure out a simpler way for this solution
                     collection_generator = CollectionGenerator
                     if commit_filter:
                         commit_filter = map(safe_str, commit_filter)
                         revisions = self._remote.rev_range(commit_filter)
                         collection_generator = MercurialIndexBasedCollectionGenerator
                     else:
                         revisions = self.commit_ids
                     if start_pos or end_pos:
                         revisions = revisions[start_pos:end_pos]
                     return collection_generator(self, revisions, pre_load=pre_load)
                 def pull(self, url, commit_ids=None):
                     """
                     Tries to pull changes from external location.
                     :param commit_ids: Optional. Can be set to a list of commit ids
                        which shall be pulled from the other repository.
                     """
                     url = self._get_url(url)
                     self._remote.pull(url, commit_ids=commit_ids)
                     self._remote.invalidate_vcs_cache()
                 def _local_clone(self, clone_path):
                     """
                     Create a local clone of the current repo.
                     """
                     self._remote.clone(self.path, clone_path, update_after_clone=True,
                                        hooks=False)
                 def _update(self, revision, clean=False):
                     """
                     Update the working copty to the specified revision.
                     """
                     self._remote.update(revision, clean=clean)
                 def _identify(self):
                     """
                     Return the current state of the working directory.
                     """
                     return self._remote.identify().strip().rstrip('+')
                 def _heads(self, branch=None):
                     """
                     Return the commit ids of the repository heads.
                     """
                     return self._remote.heads(branch=branch).strip().split(' ')
                 def _ancestor(self, revision1, revision2):
                     """
                     Return the common ancestor of the two revisions.
                     """
                     return self._remote.ancestor(
                         revision1, revision2).strip().split(':')[-1]
                 def _local_push(
                         self, revision, repository_path, push_branches=False,
                         enable_hooks=False):
                     """
                     Push the given revision to the specified repository.
                     :param push_branches: allow to create branches in the target repo.
                     """
                     self._remote.push(
                         [revision], repository_path, hooks=enable_hooks,
                         push_branches=push_branches)
                 def _local_merge(self, target_ref, merge_message, user_name, user_email,
                                  source_ref, use_rebase=False):
                     """
                     Merge the given source_revision into the checked out revision.
                     Returns the commit id of the merge and a boolean indicating if the
                     commit needs to be pushed.
                     """
                     self._update(target_ref.commit_id)
                     ancestor = self._ancestor(target_ref.commit_id, source_ref.commit_id)
                     is_the_same_branch = self._is_the_same_branch(target_ref, source_ref)
                     if ancestor == source_ref.commit_id:
                         # Nothing to do, the changes were already integrated
                         return target_ref.commit_id, False
                     elif ancestor == target_ref.commit_id and is_the_same_branch:
                         # In this case we should force a commit message
                         return source_ref.commit_id, True
                     if use_rebase:
                         try:
                             bookmark_name = 'rcbook%s%s' % (source_ref.commit_id,
                                                             target_ref.commit_id)
                             self.bookmark(bookmark_name, revision=source_ref.commit_id)
                             self._remote.rebase(
                                 source=source_ref.commit_id, dest=target_ref.commit_id)
                             self._remote.invalidate_vcs_cache()
                             self._update(bookmark_name)
                             return self._identify(), True
                         except RepositoryError:
                             # The rebase-abort may raise another exception which 'hides'
                             # the original one, therefore we log it here.
                             log.exception('Error while rebasing shadow repo during merge.')
                             # Cleanup any rebase leftovers
                             self._remote.invalidate_vcs_cache()
                             self._remote.rebase(abort=True)
                             self._remote.invalidate_vcs_cache()
                             self._remote.update(clean=True)
                             raise
                     else:
                         try:
                             self._remote.merge(source_ref.commit_id)
                             self._remote.invalidate_vcs_cache()
                             self._remote.commit(
                                 message=safe_str(merge_message),
                                 username=safe_str('%s <%s>' % (user_name, user_email)))
                             self._remote.invalidate_vcs_cache()
                             return self._identify(), True
                         except RepositoryError:
                             # Cleanup any merge leftovers
                             self._remote.update(clean=True)
                             raise
                 def _is_the_same_branch(self, target_ref, source_ref):
                     return (
                         self._get_branch_name(target_ref) ==
                         self._get_branch_name(source_ref))
                 def _get_branch_name(self, ref):
                     if ref.type == 'branch':
                         return ref.name
                     return self._remote.ctx_branch(ref.commit_id)
                 def _get_shadow_repository_path(self, workspace_id):
                     # The name of the shadow repository must start with '.', so it is
                     # skipped by 'rhodecode.lib.utils.get_filesystem_repos'.
                     return os.path.join(
                         os.path.dirname(self.path),
                         '.__shadow_%s_%s' % (os.path.basename(self.path), workspace_id))
                 def _maybe_prepare_merge_workspace(self, workspace_id, unused_target_ref):
                     shadow_repository_path = self._get_shadow_repository_path(workspace_id)
                     if not os.path.exists(shadow_repository_path):
                         self._local_clone(shadow_repository_path)
                         log.debug(
                             'Prepared shadow repository in %s', shadow_repository_path)
                     return shadow_repository_path
                 def cleanup_merge_workspace(self, workspace_id):
                     shadow_repository_path = self._get_shadow_repository_path(workspace_id)
                     shutil.rmtree(shadow_repository_path, ignore_errors=True)
                 def _merge_repo(self, shadow_repository_path, target_ref,
                                 source_repo, source_ref, merge_message,
                                 merger_name, merger_email, dry_run=False,
                                 use_rebase=False):
                     if target_ref.commit_id not in self._heads():
                         return MergeResponse(
                             False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
                     try:
                         if (target_ref.type == 'branch' and
                                 len(self._heads(target_ref.name)) != 1):
                             return MergeResponse(
                                 False, False, None,
                                 MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS)
                     except CommitDoesNotExistError as e:
                         log.exception('Failure when looking up branch heads on hg target')
                         return MergeResponse(
                             False, False, None, MergeFailureReason.MISSING_TARGET_REF)
                     shadow_repo = self._get_shadow_instance(shadow_repository_path)
                     log.debug('Pulling in target reference %s', target_ref)
                     self._validate_pull_reference(target_ref)
                     shadow_repo._local_pull(self.path, target_ref)
                     try:
                         log.debug('Pulling in source reference %s', source_ref)
                         source_repo._validate_pull_reference(source_ref)
                         shadow_repo._local_pull(source_repo.path, source_ref)
                     except CommitDoesNotExistError:
                         log.exception('Failure when doing local pull on hg shadow repo')
                         return MergeResponse(
                             False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
                     merge_ref = None
                     merge_failure_reason = MergeFailureReason.NONE
                     try:
                         merge_commit_id, needs_push = shadow_repo._local_merge(
                             target_ref, merge_message, merger_name, merger_email,
                             source_ref, use_rebase=use_rebase)
                         merge_possible = True
                         # Set a bookmark pointing to the merge commit. This bookmark may be
                         # used to easily identify the last successful merge commit in the
                         # shadow repository.
                         shadow_repo.bookmark('pr-merge', revision=merge_commit_id)
                         merge_ref = Reference('book', 'pr-merge', merge_commit_id)
-                    except SubrepoMergeError:
-                        log.exception(
-                            'Subrepo merge error during local merge on hg shadow repo.')
-                        merge_possible = False
-                        merge_failure_reason = MergeFailureReason.SUBREPO_MERGE_FAILED
                     except RepositoryError:
                         log.exception('Failure when doing local merge on hg shadow repo')
                         merge_possible = False
                         merge_failure_reason = MergeFailureReason.MERGE_FAILED
                     if merge_possible and not dry_run:
                         if needs_push:
                             # In case the target is a bookmark, update it, so after pushing
                             # the bookmarks is also updated in the target.
                             if target_ref.type == 'book':
                                 shadow_repo.bookmark(
                                     target_ref.name, revision=merge_commit_id)
                             try:
                                 shadow_repo_with_hooks = self._get_shadow_instance(
                                     shadow_repository_path,
                                     enable_hooks=True)
                                 # Note: the push_branches option will push any new branch
                                 # defined in the source repository to the target. This may
                                 # be dangerous as branches are permanent in Mercurial.
                                 # This feature was requested in issue #441.
                                 shadow_repo_with_hooks._local_push(
                                     merge_commit_id, self.path, push_branches=True,
                                     enable_hooks=True)
                                 merge_succeeded = True
                             except RepositoryError:
                                 log.exception(
                                     'Failure when doing local push from the shadow '
                                     'repository to the target repository.')
                                 merge_succeeded = False
                                 merge_failure_reason = MergeFailureReason.PUSH_FAILED
                         else:
                             merge_succeeded = True
                     else:
                         merge_succeeded = False
                     return MergeResponse(
                         merge_possible, merge_succeeded, merge_ref, merge_failure_reason)
                 def _get_shadow_instance(
                         self, shadow_repository_path, enable_hooks=False):
                     config = self.config.copy()
                     if not enable_hooks:
                         config.clear_section('hooks')
                     return MercurialRepository(shadow_repository_path, config)
                 def _validate_pull_reference(self, reference):
                     if not (reference.name in self.bookmarks or
                             reference.name in self.branches or
                             self.get_commit(reference.commit_id)):
                         raise CommitDoesNotExistError(
                             'Unknown branch, bookmark or commit id')
                 def _local_pull(self, repository_path, reference):
                     """
                     Fetch a branch, bookmark or commit from a local repository.
                     """
                     repository_path = os.path.abspath(repository_path)
                     if repository_path == self.path:
                         raise ValueError('Cannot pull from the same repository')
                     reference_type_to_option_name = {
                         'book': 'bookmark',
                         'branch': 'branch',
                     }
                     option_name = reference_type_to_option_name.get(
                         reference.type, 'revision')
                     if option_name == 'revision':
                         ref = reference.commit_id
                     else:
                         ref = reference.name
                     options = {option_name: [ref]}
                     self._remote.pull_cmd(repository_path, hooks=False, **options)
                     self._remote.invalidate_vcs_cache()
                 def bookmark(self, bookmark, revision=None):
                     if isinstance(bookmark, unicode):
                         bookmark = safe_str(bookmark)
                     self._remote.bookmark(bookmark, revision=revision)
                     self._remote.invalidate_vcs_cache()
             class MercurialIndexBasedCollectionGenerator(CollectionGenerator):
                 def _commit_factory(self, commit_id):
                     return self.repo.get_commit(
                         commit_idx=commit_id, pre_load=self.pre_load)

rhodecode/lib/vcs/exceptions.py

0 0 -9

             # -*- coding: utf-8 -*-
             # Copyright (C) 2014-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             Custom vcs exceptions module.
             """
             import functools
             import urllib2
             class VCSCommunicationError(Exception):
                 pass
             class PyroVCSCommunicationError(VCSCommunicationError):
                 pass
             class HttpVCSCommunicationError(VCSCommunicationError):
                 pass
             class VCSError(Exception):
                 pass
             class RepositoryError(VCSError):
                 pass
             class RepositoryRequirementError(RepositoryError):
                 pass
             class VCSBackendNotSupportedError(VCSError):
                 """
                 Exception raised when VCSServer does not support requested backend
                 """
             class EmptyRepositoryError(RepositoryError):
                 pass
             class TagAlreadyExistError(RepositoryError):
                 pass
             class TagDoesNotExistError(RepositoryError):
                 pass
             class BranchAlreadyExistError(RepositoryError):
                 pass
             class BranchDoesNotExistError(RepositoryError):
                 pass
             class CommitError(RepositoryError):
                 """
                 Exceptions related to an existing commit
                 """
             class CommitDoesNotExistError(CommitError):
                 pass
             class CommittingError(RepositoryError):
                 """
                 Exceptions happening while creating a new commit
                 """
             class NothingChangedError(CommittingError):
                 pass
             class NodeError(VCSError):
                 pass
             class RemovedFileNodeError(NodeError):
                 pass
             class NodeAlreadyExistsError(CommittingError):
                 pass
             class NodeAlreadyChangedError(CommittingError):
                 pass
             class NodeDoesNotExistError(CommittingError):
                 pass
             class NodeNotChangedError(CommittingError):
                 pass
             class NodeAlreadyAddedError(CommittingError):
                 pass
             class NodeAlreadyRemovedError(CommittingError):
                 pass
-            class SubrepoMergeError(RepositoryError):
-                """
-                This happens if we try to merge a repository which contains subrepos and
-                the subrepos cannot be merged. The subrepos are not merged itself but
-                their references in the root repo are merged.
-                """
             class ImproperArchiveTypeError(VCSError):
                 pass
             class CommandError(VCSError):
                 pass
             class UnhandledException(VCSError):
                 """
                 Signals that something unexpected went wrong.
                 This usually means we have a programming error on the side of the VCSServer
                 and should inspect the logfile of the VCSServer to find more details.
                 """
             _EXCEPTION_MAP = {
                 'abort': RepositoryError,
                 'archive': ImproperArchiveTypeError,
                 'error': RepositoryError,
                 'lookup': CommitDoesNotExistError,
                 'repo_locked': RepositoryError,
                 'requirement': RepositoryRequirementError,
                 'unhandled': UnhandledException,
                 # TODO: johbo: Define our own exception for this and stop abusing
                 # urllib's exception class.
                 'url_error': urllib2.URLError,
-                'subrepo_merge_error': SubrepoMergeError,
             }
             def map_vcs_exceptions(func):
                 """
                 Utility to decorate functions so that plain exceptions are translated.
                 The translation is based on `exc_map` which maps a `str` indicating
                 the error type into an exception class representing this error inside
                 of the vcs layer.
                 """
                 @functools.wraps(func)
                 def wrapper(*args, **kwargs):
                     try:
                         return func(*args, **kwargs)
                     except Exception as e:
                         # The error middleware adds information if it finds
                         # __traceback_info__ in a frame object. This way the remote
                         # traceback information is made available in error reports.
                         remote_tb = getattr(e, '_pyroTraceback', None)
                         if remote_tb:
                             __traceback_info__ = (
                                 'Found Pyro4 remote traceback information:\n\n' +
                                 '\n'.join(remote_tb))
                             # Avoid that remote_tb also appears in the frame
                             del remote_tb
                         # Special vcs errors had an attribute "_vcs_kind" which is used
                         # to translate them to the proper exception class in the vcs
                         # client layer.
                         kind = getattr(e, '_vcs_kind', None)
                         if kind:
                             raise _EXCEPTION_MAP[kind](*e.args)
                         else:
                             raise
                 return wrapper

rhodecode/model/pull_request.py

0 0 -3

             # -*- coding: utf-8 -*-
             # Copyright (C) 2012-2016  RhodeCode GmbH
             #
             # This program is free software: you can redistribute it and/or modify
             # it under the terms of the GNU Affero General Public License, version 3
             # (only), as published by the Free Software Foundation.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU Affero General Public License
             # along with this program.  If not, see <http://www.gnu.org/licenses/>.
             #
             # This program is dual-licensed. If you wish to learn more about the
             # RhodeCode Enterprise Edition, including its added features, Support services,
             # and proprietary license terms, please see https://rhodecode.com/licenses/
             """
             pull request model for RhodeCode
             """
             from collections import namedtuple
             import json
             import logging
             import datetime
             import urllib
             from pylons.i18n.translation import _
             from pylons.i18n.translation import lazy_ugettext
             from sqlalchemy import or_
             from rhodecode.lib import helpers as h, hooks_utils, diffs
             from rhodecode.lib.compat import OrderedDict
             from rhodecode.lib.hooks_daemon import prepare_callback_daemon
             from rhodecode.lib.markup_renderer import (
                 DEFAULT_COMMENTS_RENDERER, RstTemplateRenderer)
             from rhodecode.lib.utils import action_logger
             from rhodecode.lib.utils2 import safe_unicode, safe_str, md5_safe
             from rhodecode.lib.vcs.backends.base import (
                 Reference, MergeResponse, MergeFailureReason, UpdateFailureReason)
             from rhodecode.lib.vcs.conf import settings as vcs_settings
             from rhodecode.lib.vcs.exceptions import (
                 CommitDoesNotExistError, EmptyRepositoryError)
             from rhodecode.model import BaseModel
             from rhodecode.model.changeset_status import ChangesetStatusModel
             from rhodecode.model.comment import ChangesetCommentsModel
             from rhodecode.model.db import (
                 PullRequest, PullRequestReviewers, ChangesetStatus,
                 PullRequestVersion, ChangesetComment)
             from rhodecode.model.meta import Session
             from rhodecode.model.notification import NotificationModel, \
                 EmailNotificationModel
             from rhodecode.model.scm import ScmModel
             from rhodecode.model.settings import VcsSettingsModel
             log = logging.getLogger(__name__)
             # Data structure to hold the response data when updating commits during a pull
             # request update.
             UpdateResponse = namedtuple(
                 'UpdateResponse', 'executed, reason, new, old, changes')
             class PullRequestModel(BaseModel):
                 cls = PullRequest
                 DIFF_CONTEXT = 3
                 MERGE_STATUS_MESSAGES = {
                     MergeFailureReason.NONE: lazy_ugettext(
                         'This pull request can be automatically merged.'),
                     MergeFailureReason.UNKNOWN: lazy_ugettext(
                         'This pull request cannot be merged because of an unhandled'
                         ' exception.'),
                     MergeFailureReason.MERGE_FAILED: lazy_ugettext(
                         'This pull request cannot be merged because of conflicts.'),
                     MergeFailureReason.PUSH_FAILED: lazy_ugettext(
                         'This pull request could not be merged because push to target'
                         ' failed.'),
                     MergeFailureReason.TARGET_IS_NOT_HEAD: lazy_ugettext(
                         'This pull request cannot be merged because the target is not a'
                         ' head.'),
                     MergeFailureReason.HG_SOURCE_HAS_MORE_BRANCHES: lazy_ugettext(
                         'This pull request cannot be merged because the source contains'
                         ' more branches than the target.'),
                     MergeFailureReason.HG_TARGET_HAS_MULTIPLE_HEADS: lazy_ugettext(
                         'This pull request cannot be merged because the target has'
                         ' multiple heads.'),
                     MergeFailureReason.TARGET_IS_LOCKED: lazy_ugettext(
                         'This pull request cannot be merged because the target repository'
                         ' is locked.'),
                     MergeFailureReason._DEPRECATED_MISSING_COMMIT: lazy_ugettext(
                         'This pull request cannot be merged because the target or the '
                         'source reference is missing.'),
                     MergeFailureReason.MISSING_TARGET_REF: lazy_ugettext(
                         'This pull request cannot be merged because the target '
                         'reference is missing.'),
                     MergeFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
                         'This pull request cannot be merged because the source '
                         'reference is missing.'),
-                    MergeFailureReason.SUBREPO_MERGE_FAILED: lazy_ugettext(
-                        'This pull request cannot be merged because of conflicts related '
-                        'to sub repositories.'),
                 }
                 UPDATE_STATUS_MESSAGES = {
                     UpdateFailureReason.NONE: lazy_ugettext(
                         'Pull request update successful.'),
                     UpdateFailureReason.UNKNOWN: lazy_ugettext(
                         'Pull request update failed because of an unknown error.'),
                     UpdateFailureReason.NO_CHANGE: lazy_ugettext(
                         'No update needed because the source reference is already '
                         'up to date.'),
                     UpdateFailureReason.WRONG_REF_TPYE: lazy_ugettext(
                         'Pull request cannot be updated because the reference type is '
                         'not supported for an update.'),
                     UpdateFailureReason.MISSING_TARGET_REF: lazy_ugettext(
                         'This pull request cannot be updated because the target '
                         'reference is missing.'),
                     UpdateFailureReason.MISSING_SOURCE_REF: lazy_ugettext(
                         'This pull request cannot be updated because the source '
                         'reference is missing.'),
                 }
                 def __get_pull_request(self, pull_request):
                     return self._get_instance(PullRequest, pull_request)
                 def _check_perms(self, perms, pull_request, user, api=False):
                     if not api:
                         return h.HasRepoPermissionAny(*perms)(
                             user=user, repo_name=pull_request.target_repo.repo_name)
                     else:
                         return h.HasRepoPermissionAnyApi(*perms)(
                             user=user, repo_name=pull_request.target_repo.repo_name)
                 def check_user_read(self, pull_request, user, api=False):
                     _perms = ('repository.admin', 'repository.write', 'repository.read',)
                     return self._check_perms(_perms, pull_request, user, api)
                 def check_user_merge(self, pull_request, user, api=False):
                     _perms = ('repository.admin', 'repository.write', 'hg.admin',)
                     return self._check_perms(_perms, pull_request, user, api)
                 def check_user_update(self, pull_request, user, api=False):
                     owner = user.user_id == pull_request.user_id
                     return self.check_user_merge(pull_request, user, api) or owner
                 def check_user_delete(self, pull_request, user):
                     owner = user.user_id == pull_request.user_id
                     _perms = ('repository.admin')
                     return self._check_perms(_perms, pull_request, user) or owner
                 def check_user_change_status(self, pull_request, user, api=False):
                     reviewer = user.user_id in [x.user_id for x in
                                                 pull_request.reviewers]
                     return self.check_user_update(pull_request, user, api) or reviewer
                 def get(self, pull_request):
                     return self.__get_pull_request(pull_request)
                 def _prepare_get_all_query(self, repo_name, source=False, statuses=None,
                                            opened_by=None, order_by=None,
                                            order_dir='desc'):
                     repo = None
                     if repo_name:
                         repo = self._get_repo(repo_name)
                     q = PullRequest.query()
                     # source or target
                     if repo and source:
                         q = q.filter(PullRequest.source_repo == repo)
                     elif repo:
                         q = q.filter(PullRequest.target_repo == repo)
                     # closed,opened
                     if statuses:
                         q = q.filter(PullRequest.status.in_(statuses))
                     # opened by filter
                     if opened_by:
                         q = q.filter(PullRequest.user_id.in_(opened_by))
                     if order_by:
                         order_map = {
                             'name_raw': PullRequest.pull_request_id,
                             'title': PullRequest.title,
                             'updated_on_raw': PullRequest.updated_on,
                             'target_repo': PullRequest.target_repo_id
                         }
                         if order_dir == 'asc':
                             q = q.order_by(order_map[order_by].asc())
                         else:
                             q = q.order_by(order_map[order_by].desc())
                     return q
                 def count_all(self, repo_name, source=False, statuses=None,
                               opened_by=None):
                     """
                     Count the number of pull requests for a specific repository.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :returns: int number of pull requests
                     """
                     q = self._prepare_get_all_query(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by)
                     return q.count()
                 def get_all(self, repo_name, source=False, statuses=None, opened_by=None,
                             offset=0, length=None, order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     q = self._prepare_get_all_query(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     if length:
                         pull_requests = q.limit(length).offset(offset).all()
                     else:
                         pull_requests = q.all()
                     return pull_requests
                 def count_awaiting_review(self, repo_name, source=False, statuses=None,
                                           opened_by=None):
                     """
                     Count the number of pull requests for a specific repository that are
                     awaiting review.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :returns: int number of pull requests
                     """
                     pull_requests = self.get_awaiting_review(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by)
                     return len(pull_requests)
                 def get_awaiting_review(self, repo_name, source=False, statuses=None,
                                         opened_by=None, offset=0, length=None,
                                         order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository that are awaiting
                     review.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     pull_requests = self.get_all(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     _filtered_pull_requests = []
                     for pr in pull_requests:
                         status = pr.calculated_review_status()
                         if status in [ChangesetStatus.STATUS_NOT_REVIEWED,
                                       ChangesetStatus.STATUS_UNDER_REVIEW]:
                             _filtered_pull_requests.append(pr)
                     if length:
                         return _filtered_pull_requests[offset:offset+length]
                     else:
                         return _filtered_pull_requests
                 def count_awaiting_my_review(self, repo_name, source=False, statuses=None,
                                              opened_by=None, user_id=None):
                     """
                     Count the number of pull requests for a specific repository that are
                     awaiting review from a specific user.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param user_id: reviewer user of the pull request
                     :returns: int number of pull requests
                     """
                     pull_requests = self.get_awaiting_my_review(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         user_id=user_id)
                     return len(pull_requests)
                 def get_awaiting_my_review(self, repo_name, source=False, statuses=None,
                                            opened_by=None, user_id=None, offset=0,
                                            length=None, order_by=None, order_dir='desc'):
                     """
                     Get all pull requests for a specific repository that are awaiting
                     review from a specific user.
                     :param repo_name: target or source repo
                     :param source: boolean flag to specify if repo_name refers to source
                     :param statuses: list of pull request statuses
                     :param opened_by: author user of the pull request
                     :param user_id: reviewer user of the pull request
                     :param offset: pagination offset
                     :param length: length of returned list
                     :param order_by: order of the returned list
                     :param order_dir: 'asc' or 'desc' ordering direction
                     :returns: list of pull requests
                     """
                     pull_requests = self.get_all(
                         repo_name, source=source, statuses=statuses, opened_by=opened_by,
                         order_by=order_by, order_dir=order_dir)
                     _my = PullRequestModel().get_not_reviewed(user_id)
                     my_participation = []
                     for pr in pull_requests:
                         if pr in _my:
                             my_participation.append(pr)
                     _filtered_pull_requests = my_participation
                     if length:
                         return _filtered_pull_requests[offset:offset+length]
                     else:
                         return _filtered_pull_requests
                 def get_not_reviewed(self, user_id):
                     return [
                         x.pull_request for x in PullRequestReviewers.query().filter(
                             PullRequestReviewers.user_id == user_id).all()
                     ]
                 def _prepare_participating_query(self, user_id=None, statuses=None,
                                                  order_by=None, order_dir='desc'):
                     q = PullRequest.query()
                     if user_id:
                         reviewers_subquery = Session().query(
                             PullRequestReviewers.pull_request_id).filter(
                             PullRequestReviewers.user_id == user_id).subquery()
                         user_filter= or_(
                             PullRequest.user_id == user_id,
                             PullRequest.pull_request_id.in_(reviewers_subquery)
                         )
                         q = PullRequest.query().filter(user_filter)
                     # closed,opened
                     if statuses:
                         q = q.filter(PullRequest.status.in_(statuses))
                     if order_by:
                         order_map = {
                             'name_raw': PullRequest.pull_request_id,
                             'title': PullRequest.title,
                             'updated_on_raw': PullRequest.updated_on,
                             'target_repo': PullRequest.target_repo_id
                         }
                         if order_dir == 'asc':
                             q = q.order_by(order_map[order_by].asc())
                         else:
                             q = q.order_by(order_map[order_by].desc())
                     return q
                 def count_im_participating_in(self, user_id=None, statuses=None):
                     q = self._prepare_participating_query(user_id, statuses=statuses)
                     return q.count()
                 def get_im_participating_in(
                         self, user_id=None, statuses=None, offset=0,
                         length=None, order_by=None, order_dir='desc'):
                     """
                     Get all Pull requests that i'm participating in, or i have opened
                     """
                     q = self._prepare_participating_query(
                         user_id, statuses=statuses, order_by=order_by,
                         order_dir=order_dir)
                     if length:
                         pull_requests = q.limit(length).offset(offset).all()
                     else:
                         pull_requests = q.all()
                     return pull_requests
                 def get_versions(self, pull_request):
                     """
                     returns version of pull request sorted by ID descending
                     """
                     return PullRequestVersion.query()\
                         .filter(PullRequestVersion.pull_request == pull_request)\
                         .order_by(PullRequestVersion.pull_request_version_id.asc())\
                         .all()
                 def create(self, created_by, source_repo, source_ref, target_repo,
                     target_ref, revisions, reviewers, title, description=None):
                     created_by_user = self._get_user(created_by)
                     source_repo = self._get_repo(source_repo)
                     target_repo = self._get_repo(target_repo)
                     pull_request = PullRequest()
                     pull_request.source_repo = source_repo
                     pull_request.source_ref = source_ref
                     pull_request.target_repo = target_repo
                     pull_request.target_ref = target_ref
                     pull_request.revisions = revisions
                     pull_request.title = title
                     pull_request.description = description
                     pull_request.author = created_by_user
                     Session().add(pull_request)
                     Session().flush()
                     reviewer_ids = set()
                     # members / reviewers
                     for reviewer_object in reviewers:
                         if isinstance(reviewer_object, tuple):
                             user_id, reasons = reviewer_object
                         else:
                             user_id, reasons = reviewer_object, []
                         user = self._get_user(user_id)
                         reviewer_ids.add(user.user_id)
                         reviewer = PullRequestReviewers(user, pull_request, reasons)
                         Session().add(reviewer)
                     # Set approval status to "Under Review" for all commits which are
                     # part of this pull request.
                     ChangesetStatusModel().set_status(
                         repo=target_repo,
                         status=ChangesetStatus.STATUS_UNDER_REVIEW,
                         user=created_by_user,
                         pull_request=pull_request
                     )
                     self.notify_reviewers(pull_request, reviewer_ids)
                     self._trigger_pull_request_hook(
                         pull_request, created_by_user, 'create')
                     return pull_request
                 def _trigger_pull_request_hook(self, pull_request, user, action):
                     pull_request = self.__get_pull_request(pull_request)
                     target_scm = pull_request.target_repo.scm_instance()
                     if action == 'create':
                         trigger_hook = hooks_utils.trigger_log_create_pull_request_hook
                     elif action == 'merge':
                         trigger_hook = hooks_utils.trigger_log_merge_pull_request_hook
                     elif action == 'close':
                         trigger_hook = hooks_utils.trigger_log_close_pull_request_hook
                     elif action == 'review_status_change':
                         trigger_hook = hooks_utils.trigger_log_review_pull_request_hook
                     elif action == 'update':
                         trigger_hook = hooks_utils.trigger_log_update_pull_request_hook
                     else:
                         return
                     trigger_hook(
                         username=user.username,
                         repo_name=pull_request.target_repo.repo_name,
                         repo_alias=target_scm.alias,
                         pull_request=pull_request)
                 def _get_commit_ids(self, pull_request):
                     """
                     Return the commit ids of the merged pull request.
                     This method is not dealing correctly yet with the lack of autoupdates
                     nor with the implicit target updates.
                     For example: if a commit in the source repo is already in the target it
                     will be reported anyways.
                     """
                     merge_rev = pull_request.merge_rev
                     if merge_rev is None:
                         raise ValueError('This pull request was not merged yet')
                     commit_ids = list(pull_request.revisions)
                     if merge_rev not in commit_ids:
                         commit_ids.append(merge_rev)
                     return commit_ids
                 def merge(self, pull_request, user, extras):
                     log.debug("Merging pull request %s", pull_request.pull_request_id)
                     merge_state = self._merge_pull_request(pull_request, user, extras)
                     if merge_state.executed:
                         log.debug(
                             "Merge was successful, updating the pull request comments.")
                         self._comment_and_close_pr(pull_request, user, merge_state)
                         self._log_action('user_merged_pull_request', user, pull_request)
                     else:
                         log.warn("Merge failed, not updating the pull request.")
                     return merge_state
                 def _merge_pull_request(self, pull_request, user, extras):
                     target_vcs = pull_request.target_repo.scm_instance()
                     source_vcs = pull_request.source_repo.scm_instance()
                     target_ref = self._refresh_reference(
                         pull_request.target_ref_parts, target_vcs)
                     message = _(
                         'Merge pull request #%(pr_id)s from '
                         '%(source_repo)s %(source_ref_name)s\n\n %(pr_title)s') % {
                             'pr_id': pull_request.pull_request_id,
                             'source_repo': source_vcs.name,
                             'source_ref_name': pull_request.source_ref_parts.name,
                             'pr_title': pull_request.title
                         }
                     workspace_id = self._workspace_id(pull_request)
                     use_rebase = self._use_rebase_for_merging(pull_request)
                     callback_daemon, extras = prepare_callback_daemon(
                         extras, protocol=vcs_settings.HOOKS_PROTOCOL,
                         use_direct_calls=vcs_settings.HOOKS_DIRECT_CALLS)
                     with callback_daemon:
                         # TODO: johbo: Implement a clean way to run a config_override
                         # for a single call.
                         target_vcs.config.set(
                             'rhodecode', 'RC_SCM_DATA', json.dumps(extras))
                         merge_state = target_vcs.merge(
                             target_ref, source_vcs, pull_request.source_ref_parts,
                             workspace_id, user_name=user.username,
                             user_email=user.email, message=message, use_rebase=use_rebase)
                     return merge_state
                 def _comment_and_close_pr(self, pull_request, user, merge_state):
                     pull_request.merge_rev = merge_state.merge_ref.commit_id
                     pull_request.updated_on = datetime.datetime.now()
                     ChangesetCommentsModel().create(
                         text=unicode(_('Pull request merged and closed')),
                         repo=pull_request.target_repo.repo_id,
                         user=user.user_id,
                         pull_request=pull_request.pull_request_id,
                         f_path=None,
                         line_no=None,
                         closing_pr=True
                     )
                     Session().add(pull_request)
                     Session().flush()
                     # TODO: paris: replace invalidation with less radical solution
                     ScmModel().mark_for_invalidation(
                         pull_request.target_repo.repo_name)
                     self._trigger_pull_request_hook(pull_request, user, 'merge')
                 def has_valid_update_type(self, pull_request):
                     source_ref_type = pull_request.source_ref_parts.type
                     return source_ref_type in ['book', 'branch', 'tag']
                 def update_commits(self, pull_request):
                     """
                     Get the updated list of commits for the pull request
                     and return the new pull request version and the list
                     of commits processed by this update action
                     """
                     pull_request = self.__get_pull_request(pull_request)
                     source_ref_type = pull_request.source_ref_parts.type
                     source_ref_name = pull_request.source_ref_parts.name
                     source_ref_id = pull_request.source_ref_parts.commit_id
                     if not self.has_valid_update_type(pull_request):
                         log.debug(
                             "Skipping update of pull request %s due to ref type: %s",
                             pull_request, source_ref_type)
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.WRONG_REF_TPYE,
                             old=pull_request, new=None, changes=None)
                     source_repo = pull_request.source_repo.scm_instance()
                     try:
                         source_commit = source_repo.get_commit(commit_id=source_ref_name)
                     except CommitDoesNotExistError:
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.MISSING_SOURCE_REF,
                             old=pull_request, new=None, changes=None)
                     if source_ref_id == source_commit.raw_id:
                         log.debug("Nothing changed in pull request %s", pull_request)
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.NO_CHANGE,
                             old=pull_request, new=None, changes=None)
                     # Finally there is a need for an update
                     pull_request_version = self._create_version_from_snapshot(pull_request)
                     self._link_comments_to_version(pull_request_version)
                     target_ref_type = pull_request.target_ref_parts.type
                     target_ref_name = pull_request.target_ref_parts.name
                     target_ref_id = pull_request.target_ref_parts.commit_id
                     target_repo = pull_request.target_repo.scm_instance()
                     try:
                         if target_ref_type in ('tag', 'branch', 'book'):
                             target_commit = target_repo.get_commit(target_ref_name)
                         else:
                             target_commit = target_repo.get_commit(target_ref_id)
                     except CommitDoesNotExistError:
                         return UpdateResponse(
                             executed=False,
                             reason=UpdateFailureReason.MISSING_TARGET_REF,
                             old=pull_request, new=None, changes=None)
                     # re-compute commit ids
                     old_commit_ids = set(pull_request.revisions)
                     pre_load = ["author", "branch", "date", "message"]
                     commit_ranges = target_repo.compare(
                         target_commit.raw_id, source_commit.raw_id, source_repo, merge=True,
                         pre_load=pre_load)
                     ancestor = target_repo.get_common_ancestor(
                         target_commit.raw_id, source_commit.raw_id, source_repo)
                     pull_request.source_ref = '%s:%s:%s' % (
                         source_ref_type, source_ref_name, source_commit.raw_id)
                     pull_request.target_ref = '%s:%s:%s' % (
                         target_ref_type, target_ref_name, ancestor)
                     pull_request.revisions = [
                         commit.raw_id for commit in reversed(commit_ranges)]
                     pull_request.updated_on = datetime.datetime.now()
                     Session().add(pull_request)
                     new_commit_ids = set(pull_request.revisions)
                     changes = self._calculate_commit_id_changes(
                         old_commit_ids, new_commit_ids)
                     old_diff_data, new_diff_data = self._generate_update_diffs(
                         pull_request, pull_request_version)
                     ChangesetCommentsModel().outdate_comments(
                         pull_request, old_diff_data=old_diff_data,
                         new_diff_data=new_diff_data)
                     file_changes = self._calculate_file_changes(
                         old_diff_data, new_diff_data)
                     # Add an automatic comment to the pull request
                     update_comment = ChangesetCommentsModel().create(
                         text=self._render_update_message(changes, file_changes),
                         repo=pull_request.target_repo,
                         user=pull_request.author,
                         pull_request=pull_request,
                         send_email=False, renderer=DEFAULT_COMMENTS_RENDERER)
                     # Update status to "Under Review" for added commits
                     for commit_id in changes.added:
                         ChangesetStatusModel().set_status(
                             repo=pull_request.source_repo,
                             status=ChangesetStatus.STATUS_UNDER_REVIEW,
                             comment=update_comment,
                             user=pull_request.author,
                             pull_request=pull_request,
                             revision=commit_id)
                     log.debug(
                         'Updated pull request %s, added_ids: %s, common_ids: %s, '
                         'removed_ids: %s', pull_request.pull_request_id,
                         changes.added, changes.common, changes.removed)
                     log.debug('Updated pull request with the following file changes: %s',
                               file_changes)
                     log.info(
                         "Updated pull request %s from commit %s to commit %s, "
                         "stored new version %s of this pull request.",
                         pull_request.pull_request_id, source_ref_id,
                         pull_request.source_ref_parts.commit_id,
                         pull_request_version.pull_request_version_id)
                     Session().commit()
                     self._trigger_pull_request_hook(pull_request, pull_request.author,
                                                     'update')
                     return UpdateResponse(
                         executed=True, reason=UpdateFailureReason.NONE,
                         old=pull_request, new=pull_request_version, changes=changes)
                 def _create_version_from_snapshot(self, pull_request):
                     version = PullRequestVersion()
                     version.title = pull_request.title
                     version.description = pull_request.description
                     version.status = pull_request.status
                     version.created_on = pull_request.created_on
                     version.updated_on = pull_request.updated_on
                     version.user_id = pull_request.user_id
                     version.source_repo = pull_request.source_repo
                     version.source_ref = pull_request.source_ref
                     version.target_repo = pull_request.target_repo
                     version.target_ref = pull_request.target_ref
                     version._last_merge_source_rev = pull_request._last_merge_source_rev
                     version._last_merge_target_rev = pull_request._last_merge_target_rev
                     version._last_merge_status = pull_request._last_merge_status
                     version.shadow_merge_ref = pull_request.shadow_merge_ref
                     version.merge_rev = pull_request.merge_rev
                     version.revisions = pull_request.revisions
                     version.pull_request = pull_request
                     Session().add(version)
                     Session().flush()
                     return version
                 def _generate_update_diffs(self, pull_request, pull_request_version):
                     diff_context = (
                         self.DIFF_CONTEXT +
                         ChangesetCommentsModel.needed_extra_diff_context())
                     old_diff = self._get_diff_from_pr_or_version(
                         pull_request_version, context=diff_context)
                     new_diff = self._get_diff_from_pr_or_version(
                         pull_request, context=diff_context)
                     old_diff_data = diffs.DiffProcessor(old_diff)
                     old_diff_data.prepare()
                     new_diff_data = diffs.DiffProcessor(new_diff)
                     new_diff_data.prepare()
                     return old_diff_data, new_diff_data
                 def _link_comments_to_version(self, pull_request_version):
                     """
                     Link all unlinked comments of this pull request to the given version.
                     :param pull_request_version: The `PullRequestVersion` to which
                         the comments shall be linked.
                     """
                     pull_request = pull_request_version.pull_request
                     comments = ChangesetComment.query().filter(
                         # TODO: johbo: Should we query for the repo at all here?
                         # Pending decision on how comments of PRs are to be related
                         # to either the source repo, the target repo or no repo at all.
                         ChangesetComment.repo_id == pull_request.target_repo.repo_id,
                         ChangesetComment.pull_request == pull_request,
                         ChangesetComment.pull_request_version == None)
                     # TODO: johbo: Find out why this breaks if it is done in a bulk
                     # operation.
                     for comment in comments:
                         comment.pull_request_version_id = (
                             pull_request_version.pull_request_version_id)
                         Session().add(comment)
                 def _calculate_commit_id_changes(self, old_ids, new_ids):
                     added = new_ids.difference(old_ids)
                     common = old_ids.intersection(new_ids)
                     removed = old_ids.difference(new_ids)
                     return ChangeTuple(added, common, removed)
                 def _calculate_file_changes(self, old_diff_data, new_diff_data):
                     old_files = OrderedDict()
                     for diff_data in old_diff_data.parsed_diff:
                         old_files[diff_data['filename']] = md5_safe(diff_data['raw_diff'])
                     added_files = []
                     modified_files = []
                     removed_files = []
                     for diff_data in new_diff_data.parsed_diff:
                         new_filename = diff_data['filename']
                         new_hash = md5_safe(diff_data['raw_diff'])
                         old_hash = old_files.get(new_filename)
                         if not old_hash:
                             # file is not present in old diff, means it's added
                             added_files.append(new_filename)
                         else:
                             if new_hash != old_hash:
                                 modified_files.append(new_filename)
                             # now remove a file from old, since we have seen it already
                             del old_files[new_filename]
                     # removed files is when there are present in old, but not in NEW,
                     # since we remove old files that are present in new diff, left-overs
                     # if any should be the removed files
                     removed_files.extend(old_files.keys())
                     return FileChangeTuple(added_files, modified_files, removed_files)
                 def _render_update_message(self, changes, file_changes):
                     """
                     render the message using DEFAULT_COMMENTS_RENDERER (RST renderer),
                     so it's always looking the same disregarding on which default
                     renderer system is using.
                     :param changes: changes named tuple
                     :param file_changes: file changes named tuple
                     """
                     new_status = ChangesetStatus.get_status_lbl(
                         ChangesetStatus.STATUS_UNDER_REVIEW)
                     changed_files = (
                         file_changes.added + file_changes.modified + file_changes.removed)
                     params = {
                         'under_review_label': new_status,
                         'added_commits': changes.added,
                         'removed_commits': changes.removed,
                         'changed_files': changed_files,
                         'added_files': file_changes.added,
                         'modified_files': file_changes.modified,
                         'removed_files': file_changes.removed,
                     }
                     renderer = RstTemplateRenderer()
                     return renderer.render('pull_request_update.mako', **params)
                 def edit(self, pull_request, title, description):
                     pull_request = self.__get_pull_request(pull_request)
                     if pull_request.is_closed():
                         raise ValueError('This pull request is closed')
                     if title:
                         pull_request.title = title
                     pull_request.description = description
                     pull_request.updated_on = datetime.datetime.now()
                     Session().add(pull_request)
                 def update_reviewers(self, pull_request, reviewer_data):
                     """
                     Update the reviewers in the pull request
                     :param pull_request: the pr to update
                     :param reviewer_data: list of tuples [(user, ['reason1', 'reason2'])]
                     """
                     reviewers_reasons = {}
                     for user_id, reasons in reviewer_data:
                         if isinstance(user_id, (int, basestring)):
                             user_id = self._get_user(user_id).user_id
                         reviewers_reasons[user_id] = reasons
                     reviewers_ids = set(reviewers_reasons.keys())
                     pull_request = self.__get_pull_request(pull_request)
                     current_reviewers = PullRequestReviewers.query()\
                         .filter(PullRequestReviewers.pull_request ==
                                 pull_request).all()
                     current_reviewers_ids = set([x.user.user_id for x in current_reviewers])
                     ids_to_add = reviewers_ids.difference(current_reviewers_ids)
                     ids_to_remove = current_reviewers_ids.difference(reviewers_ids)
                     log.debug("Adding %s reviewers", ids_to_add)
                     log.debug("Removing %s reviewers", ids_to_remove)
                     changed = False
                     for uid in ids_to_add:
                         changed = True
                         _usr = self._get_user(uid)
                         reasons = reviewers_reasons[uid]
                         reviewer = PullRequestReviewers(_usr, pull_request, reasons)
                         Session().add(reviewer)
                     self.notify_reviewers(pull_request, ids_to_add)
                     for uid in ids_to_remove:
                         changed = True
                         reviewer = PullRequestReviewers.query()\
                             .filter(PullRequestReviewers.user_id == uid,
                                     PullRequestReviewers.pull_request == pull_request)\
                             .scalar()
                         if reviewer:
                             Session().delete(reviewer)
                     if changed:
                         pull_request.updated_on = datetime.datetime.now()
                         Session().add(pull_request)
                     return ids_to_add, ids_to_remove
                 def get_url(self, pull_request):
                     return h.url('pullrequest_show',
                                  repo_name=safe_str(pull_request.target_repo.repo_name),
                                  pull_request_id=pull_request.pull_request_id,
                                  qualified=True)
                 def get_shadow_clone_url(self, pull_request):
                     """
                     Returns qualified url pointing to the shadow repository. If this pull
                     request is closed there is no shadow repository and ``None`` will be
                     returned.
                     """
                     if pull_request.is_closed():
                         return None
                     else:
                         pr_url = urllib.unquote(self.get_url(pull_request))
                         return safe_unicode('{pr_url}/repository'.format(pr_url=pr_url))
                 def notify_reviewers(self, pull_request, reviewers_ids):
                     # notification to reviewers
                     if not reviewers_ids:
                         return
                     pull_request_obj = pull_request
                     # get the current participants of this pull request
                     recipients = reviewers_ids
                     notification_type = EmailNotificationModel.TYPE_PULL_REQUEST
                     pr_source_repo = pull_request_obj.source_repo
                     pr_target_repo = pull_request_obj.target_repo
                     pr_url = h.url(
                         'pullrequest_show',
                         repo_name=pr_target_repo.repo_name,
                         pull_request_id=pull_request_obj.pull_request_id,
                         qualified=True,)
                     # set some variables for email notification
                     pr_target_repo_url = h.url(
                         'summary_home',
                         repo_name=pr_target_repo.repo_name,
                         qualified=True)
                     pr_source_repo_url = h.url(
                         'summary_home',
                         repo_name=pr_source_repo.repo_name,
                         qualified=True)
                     # pull request specifics
                     pull_request_commits = [
                         (x.raw_id, x.message)
                         for x in map(pr_source_repo.get_commit, pull_request.revisions)]
                     kwargs = {
                         'user': pull_request.author,
                         'pull_request': pull_request_obj,
                         'pull_request_commits': pull_request_commits,
                         'pull_request_target_repo': pr_target_repo,
                         'pull_request_target_repo_url': pr_target_repo_url,
                         'pull_request_source_repo': pr_source_repo,
                         'pull_request_source_repo_url': pr_source_repo_url,
                         'pull_request_url': pr_url,
                     }
                     # pre-generate the subject for notification itself
                     (subject,
                      _h, _e,  # we don't care about those
                      body_plaintext) = EmailNotificationModel().render_email(
                         notification_type, **kwargs)
                     # create notification objects, and emails
                     NotificationModel().create(
                         created_by=pull_request.author,
                         notification_subject=subject,
                         notification_body=body_plaintext,
                         notification_type=notification_type,
                         recipients=recipients,
                         email_kwargs=kwargs,
                     )
                 def delete(self, pull_request):
                     pull_request = self.__get_pull_request(pull_request)
                     self._cleanup_merge_workspace(pull_request)
                     Session().delete(pull_request)
                 def close_pull_request(self, pull_request, user):
                     pull_request = self.__get_pull_request(pull_request)
                     self._cleanup_merge_workspace(pull_request)
                     pull_request.status = PullRequest.STATUS_CLOSED
                     pull_request.updated_on = datetime.datetime.now()
                     Session().add(pull_request)
                     self._trigger_pull_request_hook(
                         pull_request, pull_request.author, 'close')
                     self._log_action('user_closed_pull_request', user, pull_request)
                 def close_pull_request_with_comment(self, pull_request, user, repo,
                                                     message=None):
                     status = ChangesetStatus.STATUS_REJECTED
                     if not message:
                         message = (
                             _('Status change %(transition_icon)s %(status)s') % {
                                 'transition_icon': '>',
                                 'status': ChangesetStatus.get_status_lbl(status)})
                     internal_message = _('Closing with') + ' ' + message
                     comm = ChangesetCommentsModel().create(
                         text=internal_message,
                         repo=repo.repo_id,
                         user=user.user_id,
                         pull_request=pull_request.pull_request_id,
                         f_path=None,
                         line_no=None,
                         status_change=ChangesetStatus.get_status_lbl(status),
                         status_change_type=status,
                         closing_pr=True
                     )
                     ChangesetStatusModel().set_status(
                         repo.repo_id,
                         status,
                         user.user_id,
                         comm,
                         pull_request=pull_request.pull_request_id
                     )
                     Session().flush()
                     PullRequestModel().close_pull_request(
                         pull_request.pull_request_id, user)
                 def merge_status(self, pull_request):
                     if not self._is_merge_enabled(pull_request):
                         return False, _('Server-side pull request merging is disabled.')
                     if pull_request.is_closed():
                         return False, _('This pull request is closed.')
                     merge_possible, msg = self._check_repo_requirements(
                         target=pull_request.target_repo, source=pull_request.source_repo)
                     if not merge_possible:
                         return merge_possible, msg
                     try:
                         resp = self._try_merge(pull_request)
                         log.debug("Merge response: %s", resp)
                         status = resp.possible, self.merge_status_message(
                             resp.failure_reason)
                     except NotImplementedError:
                         status = False, _('Pull request merging is not supported.')
                     return status
                 def _check_repo_requirements(self, target, source):
                     """
                     Check if `target` and `source` have compatible requirements.
                     Currently this is just checking for largefiles.
                     """
                     target_has_largefiles = self._has_largefiles(target)
                     source_has_largefiles = self._has_largefiles(source)
                     merge_possible = True
                     message = u''
                     if target_has_largefiles != source_has_largefiles:
                         merge_possible = False
                         if source_has_largefiles:
                             message = _(
                                 'Target repository large files support is disabled.')
                         else:
                             message = _(
                                 'Source repository large files support is disabled.')
                     return merge_possible, message
                 def _has_largefiles(self, repo):
                     largefiles_ui = VcsSettingsModel(repo=repo).get_ui_settings(
                         'extensions', 'largefiles')
                     return largefiles_ui and largefiles_ui[0].active
                 def _try_merge(self, pull_request):
                     """
                     Try to merge the pull request and return the merge status.
                     """
                     log.debug(
                         "Trying out if the pull request %s can be merged.",
                         pull_request.pull_request_id)
                     target_vcs = pull_request.target_repo.scm_instance()
                     # Refresh the target reference.
                     try:
                         target_ref = self._refresh_reference(
                             pull_request.target_ref_parts, target_vcs)
                     except CommitDoesNotExistError:
                         merge_state = MergeResponse(
                             False, False, None, MergeFailureReason.MISSING_TARGET_REF)
                         return merge_state
                     target_locked = pull_request.target_repo.locked
                     if target_locked and target_locked[0]:
                         log.debug("The target repository is locked.")
                         merge_state = MergeResponse(
                             False, False, None, MergeFailureReason.TARGET_IS_LOCKED)
                     elif self._needs_merge_state_refresh(pull_request, target_ref):
                         log.debug("Refreshing the merge status of the repository.")
                         merge_state = self._refresh_merge_state(
                             pull_request, target_vcs, target_ref)
                     else:
                         possible = pull_request.\
                             _last_merge_status == MergeFailureReason.NONE
                         merge_state = MergeResponse(
                             possible, False, None, pull_request._last_merge_status)
                     return merge_state
                 def _refresh_reference(self, reference, vcs_repository):
                     if reference.type in ('branch', 'book'):
                         name_or_id = reference.name
                     else:
                         name_or_id = reference.commit_id
                     refreshed_commit = vcs_repository.get_commit(name_or_id)
                     refreshed_reference = Reference(
                         reference.type, reference.name, refreshed_commit.raw_id)
                     return refreshed_reference
                 def _needs_merge_state_refresh(self, pull_request, target_reference):
                     return not(
                         pull_request.revisions and
                         pull_request.revisions[0] == pull_request._last_merge_source_rev and
                         target_reference.commit_id == pull_request._last_merge_target_rev)
                 def _refresh_merge_state(self, pull_request, target_vcs, target_reference):
                     workspace_id = self._workspace_id(pull_request)
                     source_vcs = pull_request.source_repo.scm_instance()
                     use_rebase = self._use_rebase_for_merging(pull_request)
                     merge_state = target_vcs.merge(
                         target_reference, source_vcs, pull_request.source_ref_parts,
                         workspace_id, dry_run=True, use_rebase=use_rebase)
                     # Do not store the response if there was an unknown error.
                     if merge_state.failure_reason != MergeFailureReason.UNKNOWN:
                         pull_request._last_merge_source_rev = \
                             pull_request.source_ref_parts.commit_id
                         pull_request._last_merge_target_rev = target_reference.commit_id
                         pull_request._last_merge_status = merge_state.failure_reason
                         pull_request.shadow_merge_ref = merge_state.merge_ref
                         Session().add(pull_request)
                         Session().commit()
                     return merge_state
                 def _workspace_id(self, pull_request):
                     workspace_id = 'pr-%s' % pull_request.pull_request_id
                     return workspace_id
                 def merge_status_message(self, status_code):
                     """
                     Return a human friendly error message for the given merge status code.
                     """
                     return self.MERGE_STATUS_MESSAGES[status_code]
                 def generate_repo_data(self, repo, commit_id=None, branch=None,
                                        bookmark=None):
                     all_refs, selected_ref = \
                         self._get_repo_pullrequest_sources(
                             repo.scm_instance(), commit_id=commit_id,
                             branch=branch, bookmark=bookmark)
                     refs_select2 = []
                     for element in all_refs:
                         children = [{'id': x[0], 'text': x[1]} for x in element[0]]
                         refs_select2.append({'text': element[1], 'children': children})
                     return {
                         'user': {
                             'user_id': repo.user.user_id,
                             'username': repo.user.username,
                             'firstname': repo.user.firstname,
                             'lastname': repo.user.lastname,
                             'gravatar_link': h.gravatar_url(repo.user.email, 14),
                         },
                         'description': h.chop_at_smart(repo.description, '\n'),
                         'refs': {
                             'all_refs': all_refs,
                             'selected_ref': selected_ref,
                             'select2_refs': refs_select2
                         }
                     }
                 def generate_pullrequest_title(self, source, source_ref, target):
                     return u'{source}#{at_ref} to {target}'.format(
                         source=source,
                         at_ref=source_ref,
                         target=target,
                     )
                 def _cleanup_merge_workspace(self, pull_request):
                     # Merging related cleanup
                     target_scm = pull_request.target_repo.scm_instance()
                     workspace_id = 'pr-%s' % pull_request.pull_request_id
                     try:
                         target_scm.cleanup_merge_workspace(workspace_id)
                     except NotImplementedError:
                         pass
                 def _get_repo_pullrequest_sources(
                         self, repo, commit_id=None, branch=None, bookmark=None):
                     """
                     Return a structure with repo's interesting commits, suitable for
                     the selectors in pullrequest controller
                     :param commit_id: a commit that must be in the list somehow
                         and selected by default
                     :param branch: a branch that must be in the list and selected
                         by default - even if closed
                     :param bookmark: a bookmark that must be in the list and selected
                     """
                     commit_id = safe_str(commit_id) if commit_id else None
                     branch = safe_str(branch) if branch else None
                     bookmark = safe_str(bookmark) if bookmark else None
                     selected = None
                     # order matters: first source that has commit_id in it will be selected
                     sources = []
                     sources.append(('book', repo.bookmarks.items(), _('Bookmarks'), bookmark))
                     sources.append(('branch', repo.branches.items(), _('Branches'), branch))
                     if commit_id:
                         ref_commit = (h.short_id(commit_id), commit_id)
                         sources.append(('rev', [ref_commit], _('Commit IDs'), commit_id))
                     sources.append(
                         ('branch', repo.branches_closed.items(), _('Closed Branches'), branch),
                     )
                     groups = []
                     for group_key, ref_list, group_name, match in sources:
                         group_refs = []
                         for ref_name, ref_id in ref_list:
                             ref_key = '%s:%s:%s' % (group_key, ref_name, ref_id)
                             group_refs.append((ref_key, ref_name))
                             if not selected:
                                 if set([commit_id, match]) & set([ref_id, ref_name]):
                                     selected = ref_key
                         if group_refs:
                             groups.append((group_refs, group_name))
                     if not selected:
                         ref = commit_id or branch or bookmark
                         if ref:
                             raise CommitDoesNotExistError(
                                 'No commit refs could be found matching: %s' % ref)
                         elif repo.DEFAULT_BRANCH_NAME in repo.branches:
                             selected = 'branch:%s:%s' % (
                                 repo.DEFAULT_BRANCH_NAME,
                                 repo.branches[repo.DEFAULT_BRANCH_NAME]
                             )
                         elif repo.commit_ids:
                             rev = repo.commit_ids[0]
                             selected = 'rev:%s:%s' % (rev, rev)
                         else:
                             raise EmptyRepositoryError()
                     return groups, selected
                 def get_diff(self, pull_request, context=DIFF_CONTEXT):
                     pull_request = self.__get_pull_request(pull_request)
                     return self._get_diff_from_pr_or_version(pull_request, context=context)
                 def _get_diff_from_pr_or_version(self, pr_or_version, context):
                     source_repo = pr_or_version.source_repo
                     # we swap org/other ref since we run a simple diff on one repo
                     target_ref_id = pr_or_version.target_ref_parts.commit_id
                     source_ref_id = pr_or_version.source_ref_parts.commit_id
                     target_commit = source_repo.get_commit(
                         commit_id=safe_str(target_ref_id))
                     source_commit = source_repo.get_commit(commit_id=safe_str(source_ref_id))
                     vcs_repo = source_repo.scm_instance()
                     # TODO: johbo: In the context of an update, we cannot reach
                     # the old commit anymore with our normal mechanisms. It needs
                     # some sort of special support in the vcs layer to avoid this
                     # workaround.
                     if (source_commit.raw_id == vcs_repo.EMPTY_COMMIT_ID and
                             vcs_repo.alias == 'git'):
                         source_commit.raw_id = safe_str(source_ref_id)
                     log.debug('calculating diff between '
                               'source_ref:%s and target_ref:%s for repo `%s`',
                               target_ref_id, source_ref_id,
                               safe_unicode(vcs_repo.path))
                     vcs_diff = vcs_repo.get_diff(
                         commit1=target_commit, commit2=source_commit, context=context)
                     return vcs_diff
                 def _is_merge_enabled(self, pull_request):
                     settings_model = VcsSettingsModel(repo=pull_request.target_repo)
                     settings = settings_model.get_general_settings()
                     return settings.get('rhodecode_pr_merge_enabled', False)
                 def _use_rebase_for_merging(self, pull_request):
                     settings_model = VcsSettingsModel(repo=pull_request.target_repo)
                     settings = settings_model.get_general_settings()
                     return settings.get('rhodecode_hg_use_rebase_for_merging', False)
                 def _log_action(self, action, user, pull_request):
                     action_logger(
                         user,
                         '{action}:{pr_id}'.format(
                             action=action, pr_id=pull_request.pull_request_id),
                         pull_request.target_repo)
             ChangeTuple = namedtuple('ChangeTuple',
                                      ['added', 'common', 'removed'])
             FileChangeTuple = namedtuple('FileChangeTuple',
                                          ['added', 'modified', 'removed'])

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages