# -*- coding: utf-8 -*- # Copyright (C) 2012-2018 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 . # # 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 """ import json import logging import datetime import urllib import collections from pyramid.threadlocal import get_current_request from rhodecode import events from rhodecode.translation import lazy_ugettext#, _ from rhodecode.lib import helpers as h, hooks_utils, diffs from rhodecode.lib import audit_logger 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.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 CommentsModel from rhodecode.model.db import ( or_, PullRequest, PullRequestReviewers, ChangesetStatus, PullRequestVersion, ChangesetComment, Repository, RepoReviewRule) 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 = collections.namedtuple('UpdateResponse', [ 'executed', 'reason', 'new', 'old', 'changes', 'source_changed', 'target_changed']) 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 merge 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 and target have not changed.'), UpdateFailureReason.WRONG_REF_TYPE: lazy_ugettext( 'Pull request cannot be updated because the reference type is ' 'not supported for an update. Only Branch, Tag or Bookmark is allowed.'), 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, PullRequestVersion), 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 check_user_comment(self, pull_request, user): owner = user.user_id == pull_request.user_id return self.check_user_read(pull_request, user) or owner 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 get_pr_version(self, pull_request_id, version=None): at_version = None if version and version == 'latest': pull_request_ver = PullRequest.get(pull_request_id) pull_request_obj = pull_request_ver _org_pull_request_obj = pull_request_obj at_version = 'latest' elif version: pull_request_ver = PullRequestVersion.get_or_404(version) pull_request_obj = pull_request_ver _org_pull_request_obj = pull_request_ver.pull_request at_version = pull_request_ver.pull_request_version_id else: _org_pull_request_obj = pull_request_obj = PullRequest.get_or_404( pull_request_id) pull_request_display_obj = PullRequest.get_pr_display_object( pull_request_obj, _org_pull_request_obj) return _org_pull_request_obj, pull_request_obj, \ pull_request_display_obj, at_version def create(self, created_by, source_repo, source_ref, target_repo, target_ref, revisions, reviewers, title, description=None, reviewer_data=None, translator=None): translator = translator or get_current_request().translate 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 pull_request.reviewer_data = reviewer_data Session().add(pull_request) Session().flush() reviewer_ids = set() # members / reviewers for reviewer_object in reviewers: user_id, reasons, mandatory, rules = reviewer_object user = self._get_user(user_id) # skip duplicates if user.user_id in reviewer_ids: continue reviewer_ids.add(user.user_id) reviewer = PullRequestReviewers() reviewer.user = user reviewer.pull_request = pull_request reviewer.reasons = reasons reviewer.mandatory = mandatory # NOTE(marcink): pick only first rule for now rule_id = rules[0] if rules else None rule = RepoReviewRule.get(rule_id) if rule_id else None if rule: review_group = rule.user_group_vote_rule() if review_group: # NOTE(marcink): # again, can be that user is member of more, # but we pick the first same, as default reviewers algo review_group = review_group[0] rule_data = { 'rule_name': rule.review_rule_name, 'rule_user_group_entry_id': review_group.repo_review_rule_users_group_id, 'rule_user_group_name': review_group.users_group.users_group_name, 'rule_user_group_members': [x.user.username for x in review_group.users_group.members], } # e.g {'vote_rule': -1, 'mandatory': True} rule_data.update(review_group.rule_data()) reviewer.rule_data = rule_data Session().add(reviewer) Session().flush() # 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 ) # we commit early at this point. This has to do with a fact # that before queries do some row-locking. And because of that # we need to commit and finish transation before below validate call # that for large repos could be long resulting in long row locks Session().commit() # prepare workspace, and run initial merge simulation MergeCheck.validate( pull_request, user=created_by_user, translator=translator) self.notify_reviewers(pull_request, reviewer_ids) self._trigger_pull_request_hook( pull_request, created_by_user, 'create') creation_data = pull_request.get_api_data(with_merge_state=False) self._log_audit_action( 'repo.pull_request.create', {'data': creation_data}, created_by_user, pull_request) 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_audit_action( 'repo.pull_request.merge', {'merge_state': merge_state.__dict__}, 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, merge_msg=None): 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_msg or ( '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) close_branch = self._close_branch_before_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, close_branch=close_branch) return merge_state def _comment_and_close_pr(self, pull_request, user, merge_state, close_msg=None): pull_request.merge_rev = merge_state.merge_ref.commit_id pull_request.updated_on = datetime.datetime.now() close_msg = close_msg or 'Pull request merged and closed' CommentsModel().create( text=safe_unicode(close_msg), 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 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 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_TYPE, old=pull_request, new=None, changes=None, source_changed=False, target_changed=False) # source repo 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, source_changed=False, target_changed=False) source_changed = source_ref_id != source_commit.raw_id # target repo target_repo = pull_request.target_repo.scm_instance() try: target_commit = target_repo.get_commit(commit_id=target_ref_name) except CommitDoesNotExistError: return UpdateResponse( executed=False, reason=UpdateFailureReason.MISSING_TARGET_REF, old=pull_request, new=None, changes=None, source_changed=False, target_changed=False) target_changed = target_ref_id != target_commit.raw_id if not (source_changed or target_changed): 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, source_changed=target_changed, target_changed=source_changed) change_in_found = 'target repo' if target_changed else 'source repo' log.debug('Updating pull request because of change in %s detected', change_in_found) # Finally there is a need for an update, in case of source change # we create a new version, else just an update if source_changed: pull_request_version = self._create_version_from_snapshot(pull_request) self._link_comments_to_version(pull_request_version) else: try: ver = pull_request.versions[-1] except IndexError: ver = None pull_request.pull_request_version_id = \ ver.pull_request_version_id if ver else None pull_request_version = pull_request 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, source_changed=source_changed, target_changed=target_changed) # re-compute commit ids old_commit_ids = 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 = pull_request.revisions old_diff_data, new_diff_data = self._generate_update_diffs( pull_request, pull_request_version) # calculate commit and file changes changes = self._calculate_commit_id_changes( old_commit_ids, new_commit_ids) file_changes = self._calculate_file_changes( old_diff_data, new_diff_data) # set comments as outdated if DIFFS changed CommentsModel().outdate_comments( pull_request, old_diff_data=old_diff_data, new_diff_data=new_diff_data) commit_changes = (changes.added or changes.removed) file_node_changes = ( file_changes.added or file_changes.modified or file_changes.removed) pr_has_changes = commit_changes or file_node_changes # Add an automatic comment to the pull request, in case # anything has changed if pr_has_changes: update_comment = CommentsModel().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, source_changed=source_changed, target_changed=target_changed) 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 = datetime.datetime.now() 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.reviewer_data = pull_request.reviewer_data 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 + CommentsModel.needed_extra_diff_context()) source_repo = pull_request_version.source_repo source_ref_id = pull_request_version.source_ref_parts.commit_id target_ref_id = pull_request_version.target_ref_parts.commit_id old_diff = self._get_diff_from_pr_or_version( source_repo, source_ref_id, target_ref_id, context=diff_context) source_repo = pull_request.source_repo source_ref_id = pull_request.source_ref_parts.commit_id target_ref_id = pull_request.target_ref_parts.commit_id new_diff = self._get_diff_from_pr_or_version( source_repo, source_ref_id, target_ref_id, 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)\ .order_by(ChangesetComment.comment_id.asc()) # 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 = [x for x in new_ids if x not in old_ids] common = [x for x in new_ids if x in old_ids] removed = [x for x in old_ids if x not in new_ids] total = new_ids return ChangeTuple(added, common, removed, total) 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, user): pull_request = self.__get_pull_request(pull_request) old_data = pull_request.get_api_data(with_merge_state=False) 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) self._log_audit_action( 'repo.pull_request.edit', {'old_data': old_data}, user, pull_request) def update_reviewers(self, pull_request, reviewer_data, user): """ Update the reviewers in the pull request :param pull_request: the pr to update :param reviewer_data: list of tuples [(user, ['reason1', 'reason2'], mandatory_flag, [rules])] """ pull_request = self.__get_pull_request(pull_request) if pull_request.is_closed(): raise ValueError('This pull request is closed') reviewers = {} for user_id, reasons, mandatory, rules in reviewer_data: if isinstance(user_id, (int, basestring)): user_id = self._get_user(user_id).user_id reviewers[user_id] = { 'reasons': reasons, 'mandatory': mandatory} reviewers_ids = set(reviewers.keys()) 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) reviewer = PullRequestReviewers() reviewer.user = _usr reviewer.pull_request = pull_request reviewer.reasons = reviewers[uid]['reasons'] # NOTE(marcink): mandatory shouldn't be changed now # reviewer.mandatory = reviewers[uid]['reasons'] Session().add(reviewer) self._log_audit_action( 'repo.pull_request.reviewer.add', {'data': reviewer.get_dict()}, user, pull_request) for uid in ids_to_remove: changed = True reviewers = PullRequestReviewers.query()\ .filter(PullRequestReviewers.user_id == uid, PullRequestReviewers.pull_request == pull_request)\ .all() # use .all() in case we accidentally added the same person twice # this CAN happen due to the lack of DB checks for obj in reviewers: old_data = obj.get_dict() Session().delete(obj) self._log_audit_action( 'repo.pull_request.reviewer.delete', {'old_data': old_data}, user, pull_request) if changed: pull_request.updated_on = datetime.datetime.now() Session().add(pull_request) self.notify_reviewers(pull_request, ids_to_add) return ids_to_add, ids_to_remove def get_url(self, pull_request, request=None, permalink=False): if not request: request = get_current_request() if permalink: return request.route_url( 'pull_requests_global', pull_request_id=pull_request.pull_request_id,) else: return request.route_url('pullrequest_show', repo_name=safe_str(pull_request.target_repo.repo_name), pull_request_id=pull_request.pull_request_id,) def get_shadow_clone_url(self, pull_request, request=None): """ 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, request=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.route_url('pullrequest_show', repo_name=pr_target_repo.repo_name, pull_request_id=pull_request_obj.pull_request_id,) # set some variables for email notification pr_target_repo_url = h.route_url( 'repo_summary', repo_name=pr_target_repo.repo_name) pr_source_repo_url = h.route_url( 'repo_summary', repo_name=pr_source_repo.repo_name) # 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, user): pull_request = self.__get_pull_request(pull_request) old_data = pull_request.get_api_data(with_merge_state=False) self._cleanup_merge_workspace(pull_request) self._log_audit_action( 'repo.pull_request.delete', {'old_data': old_data}, user, 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') pr_data = pull_request.get_api_data(with_merge_state=False) self._log_audit_action( 'repo.pull_request.close', {'data': pr_data}, user, pull_request) def close_pull_request_with_comment( self, pull_request, user, repo, message=None): pull_request_review_status = pull_request.calculated_review_status() if pull_request_review_status == ChangesetStatus.STATUS_APPROVED: # approved only if we have voting consent status = ChangesetStatus.STATUS_APPROVED else: status = ChangesetStatus.STATUS_REJECTED status_lbl = ChangesetStatus.get_status_lbl(status) default_message = ( 'Closing with status change {transition_icon} {status}.' ).format(transition_icon='>', status=status_lbl) text = message or default_message # create a comment, and link it to new status comment = CommentsModel().create( text=text, repo=repo.repo_id, user=user.user_id, pull_request=pull_request.pull_request_id, status_change=status_lbl, status_change_type=status, closing_pr=True ) # calculate old status before we change it old_calculated_status = pull_request.calculated_review_status() ChangesetStatusModel().set_status( repo.repo_id, status, user.user_id, comment=comment, pull_request=pull_request.pull_request_id ) Session().flush() events.trigger(events.PullRequestCommentEvent(pull_request, comment)) # we now calculate the status of pull request again, and based on that # calculation trigger status change. This might happen in cases # that non-reviewer admin closes a pr, which means his vote doesn't # change the status, while if he's a reviewer this might change it. calculated_status = pull_request.calculated_review_status() if old_calculated_status != calculated_status: self._trigger_pull_request_hook( pull_request, user, 'review_status_change') # finally close the PR PullRequestModel().close_pull_request( pull_request.pull_request_id, user) return comment, status def merge_status(self, pull_request, translator=None, force_shadow_repo_refresh=False): _ = translator or get_current_request().translate 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, translator=_) if not merge_possible: return merge_possible, msg try: resp = self._try_merge( pull_request, force_shadow_repo_refresh=force_shadow_repo_refresh) 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, translator): """ Check if `target` and `source` have compatible requirements. Currently this is just checking for largefiles. """ _ = translator 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, force_shadow_repo_refresh=False): """ Try to merge the pull request and return the merge status. """ log.debug( "Trying out if the pull request %s can be merged. Force_refresh=%s", pull_request.pull_request_id, force_shadow_repo_refresh) 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 force_shadow_repo_refresh or 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) close_branch = self._close_branch_before_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, close_branch=close_branch) # 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, translator=None): from rhodecode.model.repo import RepoModel all_refs, selected_ref = \ self._get_repo_pullrequest_sources( repo.scm_instance(), commit_id=commit_id, branch=branch, bookmark=bookmark, translator=translator) 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.first_name, 'lastname': repo.user.last_name, 'gravatar_link': h.gravatar_url(repo.user.email, 14), }, 'name': repo.repo_name, 'link': RepoModel().get_url(repo), 'description': h.chop_at_smart(repo.description_safe, '\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, translator=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 """ _ = translator or get_current_request().translate 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: # make the user select in this case selected = None else: raise EmptyRepositoryError() return groups, selected def get_diff(self, source_repo, source_ref_id, target_ref_id, context=DIFF_CONTEXT): return self._get_diff_from_pr_or_version( source_repo, source_ref_id, target_ref_id, context=context) def _get_diff_from_pr_or_version( self, source_repo, source_ref_id, target_ref_id, context): 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)) if isinstance(source_repo, Repository): vcs_repo = source_repo.scm_instance() else: vcs_repo = source_repo # 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): return self._get_general_setting( pull_request, 'rhodecode_pr_merge_enabled') def _use_rebase_for_merging(self, pull_request): repo_type = pull_request.target_repo.repo_type if repo_type == 'hg': return self._get_general_setting( pull_request, 'rhodecode_hg_use_rebase_for_merging') elif repo_type == 'git': return self._get_general_setting( pull_request, 'rhodecode_git_use_rebase_for_merging') return False def _close_branch_before_merging(self, pull_request): repo_type = pull_request.target_repo.repo_type if repo_type == 'hg': return self._get_general_setting( pull_request, 'rhodecode_hg_close_branch_before_merging') elif repo_type == 'git': return self._get_general_setting( pull_request, 'rhodecode_git_close_branch_before_merging') return False def _get_general_setting(self, pull_request, settings_key, default=False): settings_model = VcsSettingsModel(repo=pull_request.target_repo) settings = settings_model.get_general_settings() return settings.get(settings_key, default) def _log_audit_action(self, action, action_data, user, pull_request): audit_logger.store( action=action, action_data=action_data, user=user, repo=pull_request.target_repo) def get_reviewer_functions(self): """ Fetches functions for validation and fetching default reviewers. If available we use the EE package, else we fallback to CE package functions """ try: from rc_reviewers.utils import get_default_reviewers_data from rc_reviewers.utils import validate_default_reviewers except ImportError: from rhodecode.apps.repository.utils import \ get_default_reviewers_data from rhodecode.apps.repository.utils import \ validate_default_reviewers return get_default_reviewers_data, validate_default_reviewers class MergeCheck(object): """ Perform Merge Checks and returns a check object which stores information about merge errors, and merge conditions """ TODO_CHECK = 'todo' PERM_CHECK = 'perm' REVIEW_CHECK = 'review' MERGE_CHECK = 'merge' def __init__(self): self.review_status = None self.merge_possible = None self.merge_msg = '' self.failed = None self.errors = [] self.error_details = OrderedDict() def push_error(self, error_type, message, error_key, details): self.failed = True self.errors.append([error_type, message]) self.error_details[error_key] = dict( details=details, error_type=error_type, message=message ) @classmethod def validate(cls, pull_request, user, translator, fail_early=False, force_shadow_repo_refresh=False): _ = translator merge_check = cls() # permissions to merge user_allowed_to_merge = PullRequestModel().check_user_merge( pull_request, user) if not user_allowed_to_merge: log.debug("MergeCheck: cannot merge, approval is pending.") msg = _('User `{}` not allowed to perform merge.').format(user.username) merge_check.push_error('error', msg, cls.PERM_CHECK, user.username) if fail_early: return merge_check # review status, must be always present review_status = pull_request.calculated_review_status() merge_check.review_status = review_status status_approved = review_status == ChangesetStatus.STATUS_APPROVED if not status_approved: log.debug("MergeCheck: cannot merge, approval is pending.") msg = _('Pull request reviewer approval is pending.') merge_check.push_error( 'warning', msg, cls.REVIEW_CHECK, review_status) if fail_early: return merge_check # left over TODOs todos = CommentsModel().get_unresolved_todos(pull_request) if todos: log.debug("MergeCheck: cannot merge, {} " "unresolved todos left.".format(len(todos))) if len(todos) == 1: msg = _('Cannot merge, {} TODO still not resolved.').format( len(todos)) else: msg = _('Cannot merge, {} TODOs still not resolved.').format( len(todos)) merge_check.push_error('warning', msg, cls.TODO_CHECK, todos) if fail_early: return merge_check # merge possible, here is the filesystem simulation + shadow repo merge_status, msg = PullRequestModel().merge_status( pull_request, translator=translator, force_shadow_repo_refresh=force_shadow_repo_refresh) merge_check.merge_possible = merge_status merge_check.merge_msg = msg if not merge_status: log.debug( "MergeCheck: cannot merge, pull request merge not possible.") merge_check.push_error('warning', msg, cls.MERGE_CHECK, None) if fail_early: return merge_check log.debug('MergeCheck: is failed: %s', merge_check.failed) return merge_check @classmethod def get_merge_conditions(cls, pull_request, translator): _ = translator merge_details = {} model = PullRequestModel() use_rebase = model._use_rebase_for_merging(pull_request) if use_rebase: merge_details['merge_strategy'] = dict( details={}, message=_('Merge strategy: rebase') ) else: merge_details['merge_strategy'] = dict( details={}, message=_('Merge strategy: explicit merge commit') ) close_branch = model._close_branch_before_merging(pull_request) if close_branch: repo_type = pull_request.target_repo.repo_type if repo_type == 'hg': close_msg = _('Source branch will be closed after merge.') elif repo_type == 'git': close_msg = _('Source branch will be deleted after merge.') merge_details['close_branch'] = dict( details={}, message=close_msg ) return merge_details ChangeTuple = collections.namedtuple( 'ChangeTuple', ['added', 'common', 'removed', 'total']) FileChangeTuple = collections.namedtuple( 'FileChangeTuple', ['added', 'modified', 'removed'])