events: change target to source repo for pull request events

to make sure commits can be found - fixes  #4135, also made
_get_commits work on multiple repos

rhodecode/events/pullrequest.py

@@ -1,126 +1,131 b''
 # Copyright (C) 2016-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/
 
 
 from rhodecode.translation import lazy_ugettext
-from rhodecode.events.repo import RepoEvent
+from rhodecode.events.repo import (
+    RepoEvent, _commits_as_dict, _issues_as_dict)
 
 
 class PullRequestEvent(RepoEvent):
     """
     Base class for pull request events.
 
     :param pullrequest: a :class:`PullRequest` instance
     """
 
     def __init__(self, pullrequest):
         super(PullRequestEvent, self).__init__(pullrequest.target_repo)
         self.pullrequest = pullrequest
 
     def as_dict(self):
         from rhodecode.model.pull_request import PullRequestModel
         data = super(PullRequestEvent, self).as_dict()
 
-        commits = self._commits_as_dict(self.pullrequest.revisions)
-        issues = self._issues_as_dict(commits)
+        commits = _commits_as_dict(
+            commit_ids=self.pullrequest.revisions,
+            repos=[self.pullrequest.source_repo]
+        )
+        issues = _issues_as_dict(commits)
 
         data.update({
             'pullrequest': {
                 'title': self.pullrequest.title,
                 'issues': issues,
                 'pull_request_id': self.pullrequest.pull_request_id,
                 'url': PullRequestModel().get_url(self.pullrequest),
                 'status': self.pullrequest.calculated_review_status(),
+                'commits': commits,
             }
         })
         return data
 
 
 class PullRequestCreateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is created.
     """
     name = 'pullrequest-create'
     display_name = lazy_ugettext('pullrequest created')
 
 
 class PullRequestCloseEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is closed.
     """
     name = 'pullrequest-close'
     display_name = lazy_ugettext('pullrequest closed')
 
 
 class PullRequestUpdateEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request's commits have been updated.
     """
     name = 'pullrequest-update'
     display_name = lazy_ugettext('pullrequest commits updated')
 
 
 class PullRequestReviewEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request review has changed.
     """
     name = 'pullrequest-review'
     display_name = lazy_ugettext('pullrequest review changed')
 
 
 class PullRequestMergeEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request is merged.
     """
     name = 'pullrequest-merge'
     display_name = lazy_ugettext('pullrequest merged')
 
 
 class PullRequestCommentEvent(PullRequestEvent):
     """
     An instance of this class is emitted as an :term:`event` after a pull
     request comment is created.
     """
     name = 'pullrequest-comment'
     display_name = lazy_ugettext('pullrequest commented')
 
     def __init__(self, pullrequest, comment):
         super(PullRequestCommentEvent, self).__init__(pullrequest)
         self.comment = comment
 
     def as_dict(self):
         from rhodecode.model.comment import ChangesetCommentsModel
         data = super(PullRequestCommentEvent, self).as_dict()
 
         status = None
         if self.comment.status_change:
             status = self.comment.status_change[0].status
 
         data.update({
             'comment': {
                 'status': status,
                 'text': self.comment.text,
                 'url': ChangesetCommentsModel().get_url(self.comment)
             }
         })
         return data

rhodecode/events/repo.py

@@ -1,220 +1,252 b''
 # Copyright (C) 2016-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/
 
 import logging
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.model.db import User, Repository, Session
 from rhodecode.events.base import RhodecodeEvent
+from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
+def _commits_as_dict(commit_ids, repos):
+    """
+    Helper function to serialize commit_ids
+
+    :param commit_ids: commits to get
+    :param repos: list of repos to check
+    """
+    from rhodecode.lib.utils2 import extract_mentioned_users
+    from rhodecode.model.db import Repository
+    from rhodecode.lib import helpers as h
+    from rhodecode.lib.helpers import process_patterns
+    from rhodecode.lib.helpers import urlify_commit_message
+
+    if not repos:
+        raise Exception('no repo defined')
+
+    if not isinstance(repos, (tuple, list)):
+        repos = [repos]
+
+    if not commit_ids:
+        return []
+
+    needed_commits = set(commit_ids)
+
+    commits = []
+    reviewers = []
+    for repo in repos:
+        if not needed_commits:
+            return commits # return early if we have the commits we need
+
+        vcs_repo = repo.scm_instance(cache=False)
+        try:
+            for commit_id in list(needed_commits):
+                try:
+                    cs = vcs_repo.get_changeset(commit_id)
+                except CommitDoesNotExistError:
+                    continue # maybe its in next repo
+
+                cs_data = cs.__json__()
+                cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
+                cs_data['reviewers'] = reviewers
+                cs_data['url'] = h.url('changeset_home',
+                    repo_name=repo.repo_name,
+                    revision=cs_data['raw_id'],
+                    qualified=True
+                )
+                urlified_message, issues_data = process_patterns(
+                    cs_data['message'], repo.repo_name)
+                cs_data['issues'] = issues_data
+                cs_data['message_html'] = urlify_commit_message(cs_data['message'],
+                    repo.repo_name)
+                commits.append(cs_data)
+
+                needed_commits.discard(commit_id)
+
+        except Exception as e:
+            log.exception(e)
+            # we don't send any commits when crash happens, only full list matters
+            # we short circuit then.
+            return []
+
+    missing_commits = set(commit_ids) - set(c['raw_id'] for c in commits)
+    if missing_commits:
+        log.error('missing commits: %s' % ', '.join(missing_commits))
+
+    return commits
+
+
+def _issues_as_dict(commits):
+    """ Helper function to serialize issues from commits """
+    issues = {}
+    for commit in commits:
+        for issue in commit['issues']:
+            issues[issue['id']] = issue
+    return issues
 
 class RepoEvent(RhodecodeEvent):
     """
     Base class for events acting on a repository.
 
     :param repo: a :class:`Repository` instance
     """
 
     def __init__(self, repo):
         super(RepoEvent, self).__init__()
         self.repo = repo
 
     def as_dict(self):
         from rhodecode.model.repo import RepoModel
         data = super(RepoEvent, self).as_dict()
         data.update({
             'repo': {
                 'repo_id': self.repo.repo_id,
                 'repo_name': self.repo.repo_name,
                 'repo_type': self.repo.repo_type,
                 'url': RepoModel().get_url(self.repo)
             }
         })
         return data
 
-    def _commits_as_dict(self, commit_ids):
-        """ Helper function to serialize commit_ids """
-
-        from rhodecode.lib.utils2 import extract_mentioned_users
-        from rhodecode.model.db import Repository
-        from rhodecode.lib import helpers as h
-        from rhodecode.lib.helpers import process_patterns
-        from rhodecode.lib.helpers import urlify_commit_message
-        if not commit_ids:
-            return []
-        commits = []
-        reviewers = []
-        vcs_repo = self.repo.scm_instance(cache=False)
-        try:
-            for commit_id in commit_ids:
-                cs = vcs_repo.get_changeset(commit_id)
-                cs_data = cs.__json__()
-                cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
-                cs_data['reviewers'] = reviewers
-                cs_data['url'] = h.url('changeset_home',
-                    repo_name=self.repo.repo_name,
-                    revision=cs_data['raw_id'],
-                    qualified=True
-                )
-                urlified_message, issues_data = process_patterns(
-                    cs_data['message'], self.repo.repo_name)
-                cs_data['issues'] = issues_data
-                cs_data['message_html'] = urlify_commit_message(cs_data['message'],
-                    self.repo.repo_name)
-                commits.append(cs_data)
-        except Exception as e:
-            log.exception(e)
-            # we don't send any commits when crash happens, only full list matters
-            # we short circuit then.
-            return []
-        return commits
-
-    def _issues_as_dict(self, commits):
-        """ Helper function to serialize issues from commits """
-        issues = {}
-        for commit in commits:
-            for issue in commit['issues']:
-                issues[issue['id']] = issue
-        return issues
-
 
 class RepoPreCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` before a repo is
     created.
     """
     name = 'repo-pre-create'
     display_name = lazy_ugettext('repository pre create')
 
 
 class RepoCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-create'
     display_name = lazy_ugettext('repository created')
 
 
 class RepoPreDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-pre-delete'
     display_name = lazy_ugettext('repository pre delete')
 
 
 class RepoDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-delete'
     display_name = lazy_ugettext('repository deleted')
 
 
 class RepoVCSEvent(RepoEvent):
     """
     Base class for events triggered by the VCS
     """
     def __init__(self, repo_name, extras):
         self.repo = Repository.get_by_repo_name(repo_name)
         if not self.repo:
             raise Exception('repo by this name %s does not exist' % repo_name)
         self.extras = extras
         super(RepoVCSEvent, self).__init__(self.repo)
 
     @property
     def actor(self):
         if self.extras.get('username'):
             return User.get_by_username(self.extras['username'])
 
     @property
     def actor_ip(self):
         if self.extras.get('ip'):
             return self.extras['ip']
 
 
 class RepoPrePullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pulled from a repo.
     """
     name = 'repo-pre-pull'
     display_name = lazy_ugettext('repository pre pull')
 
 
 class RepoPullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pulled from a repo.
     """
     name = 'repo-pull'
     display_name = lazy_ugettext('repository pull')
 
 
 class RepoPrePushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pushed to a repo.
     """
     name = 'repo-pre-push'
     display_name = lazy_ugettext('repository pre push')
 
 
 class RepoPushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pushed to a repo.
 
     :param extras: (optional) dict of data from proxied VCS actions
     """
     name = 'repo-push'
     display_name = lazy_ugettext('repository push')
 
     def __init__(self, repo_name, pushed_commit_ids, extras):
         super(RepoPushEvent, self).__init__(repo_name, extras)
         self.pushed_commit_ids = pushed_commit_ids
 
     def as_dict(self):
         data = super(RepoPushEvent, self).as_dict()
         branch_url = repo_url = data['repo']['url']
 
-        commits = self._commits_as_dict(self.pushed_commit_ids)
-        issues = self._issues_as_dict(commits)
+        commits = _commits_as_dict(
+            commit_ids=self.pushed_commit_ids, repos=[self.repo])
+        issues = _issues_as_dict(commits)
 
         branches = set(
             commit['branch'] for commit in commits if commit['branch'])
         branches = [
             {
                 'name': branch,
                 'url': '{}/changelog?branch={}'.format(
                     data['repo']['url'], branch)
             }
             for branch in branches
         ]
 
         data['push'] = {
             'commits': commits,
             'issues': issues,
             'branches': branches,
         }
         return data