Merge lp:~cjwatson/launchpad/git-permissions-notifications into lp:launchpad

[Colin Watson]

Send email notifications for GitRule and GitGrant changes.

We'll have to be careful to send the right ObjectModifiedEvents in the webservice API and the web UI (slightly fiddly as you have to send them both for any rules/grants and for the repository), but that should be manageable in later branches.

[William Grant (wgrant)]

My only concern is that this will probably send rule changes to all subscribers, not just those who can see the rules normally (the owner).

review: Approve (code)

=== modified file 'database/schema/security.cfg'
--- database/schema/security.cfg	2018-10-15 14:44:25 +0000
+++ database/schema/security.cfg	2018-10-16 10:11:25 +0000
@@ -2053,6 +2053,7 @@
 public.branchmergeproposaljob           = SELECT, INSERT
 public.branchrevision                   = SELECT
 public.branchsubscription               = SELECT
+public.codeimport                       = SELECT
 public.codereviewinlinecomment          = SELECT, INSERT
 public.codereviewmessage                = SELECT, INSERT
 public.codereviewvote                   = SELECT, INSERT

=== modified file 'lib/lp/code/adapters/gitrepository.py'
--- lib/lp/code/adapters/gitrepository.py	2015-07-08 16:05:11 +0000
+++ lib/lp/code/adapters/gitrepository.py	2018-10-16 10:11:25 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Components related to Git repositories."""
@@ -27,12 +27,14 @@
 
     interface = IGitRepository
 
-    def __init__(self, repository, user, name=None, git_identity=None):
+    def __init__(self, repository, user, name=None, git_identity=None,
+                 activities=None):
         self.repository = repository
         self.user = user
 
         self.name = name
         self.git_identity = git_identity
+        self.activities = activities
 
     @classmethod
     def construct(klass, old_repository, new_repository, user):
@@ -43,10 +45,13 @@
         """
         delta = ObjectDelta(old_repository, new_repository)
         delta.recordNewAndOld(klass.delta_values)
-        if delta.changes:
+        activities = list(new_repository.getActivity(
+            changed_after=old_repository.date_last_modified))
+        if delta.changes or activities:
             changes = delta.changes
             changes["repository"] = new_repository
             changes["user"] = user
+            changes["activities"] = activities
 
             return GitRepositoryDelta(**changes)
         else:

=== modified file 'lib/lp/code/interfaces/gitactivity.py'
--- lib/lp/code/interfaces/gitactivity.py	2018-10-03 00:53:23 +0000
+++ lib/lp/code/interfaces/gitactivity.py	2018-10-16 10:11:25 +0000
@@ -12,7 +12,10 @@
     ]
 
 from lazr.restful.fields import Reference
-from zope.interface import Interface
+from zope.interface import (
+    Attribute,
+    Interface,
+    )
 from zope.schema import (
     Choice,
     Datetime,
@@ -55,6 +58,9 @@
         vocabulary="ValidPersonOrTeam",
         description=_("The person or team that this change was applied to."))
 
+    changee_description = Attribute(
+        "A human-readable description of the changee.")
+
     what_changed = Choice(
         title=_("What changed"), required=True, readonly=True,
         vocabulary=GitActivityType,

=== modified file 'lib/lp/code/interfaces/gitrepository.py'
--- lib/lp/code/interfaces/gitrepository.py	2018-10-15 14:44:25 +0000
+++ lib/lp/code/interfaces/gitrepository.py	2018-10-16 10:11:25 +0000
@@ -622,9 +622,11 @@
         :return: The diff as a binary string.
         """
 
-    def getActivity():
+    def getActivity(changed_after=None):
         """Get activity log entries for this repository.
 
+        :param changed_after: If supplied, only return entries for changes
+            made after this date.
         :return: A `ResultSet` of `IGitActivity`.
         """
 

=== modified file 'lib/lp/code/mail/branch.py'
--- lib/lp/code/mail/branch.py	2015-09-01 17:10:46 +0000
+++ lib/lp/code/mail/branch.py	2018-10-16 10:11:25 +0000
@@ -1,12 +1,16 @@
-# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Email notifications related to branches."""
 
 __metaclass__ = type
 
-from zope.component import getUtility
+from zope.component import (
+    getAdapter,
+    getUtility,
+    )
 
+from lp.app.interfaces.security import IAuthorization
 from lp.code.adapters.branch import BranchDelta
 from lp.code.adapters.gitrepository import GitRepositoryDelta
 from lp.code.enums import (
@@ -20,6 +24,7 @@
 from lp.code.interfaces.gitref import IGitRef
 from lp.registry.interfaces.person import IPerson
 from lp.registry.interfaces.product import IProduct
+from lp.registry.interfaces.role import IPersonRoles
 from lp.services.config import config
 from lp.services.mail import basemailer
 from lp.services.mail.basemailer import BaseMailer
@@ -163,13 +168,14 @@
     app = 'code'
 
     def __init__(self, subject, template_name, recipients, from_address,
-                 delta=None, contents=None, diff=None, message_id=None,
-                 revno=None, revision_id=None, notification_type=None,
-                 **kwargs):
+                 delta=None, delta_for_editors=None, contents=None, diff=None,
+                 message_id=None, revno=None, revision_id=None,
+                 notification_type=None, **kwargs):
         super(BranchMailer, self).__init__(
             subject, template_name, recipients, from_address,
             message_id=message_id, notification_type=notification_type)
         self.delta_text = delta
+        self.delta_for_editors_text = delta_for_editors
         self.contents = contents
         self.diff = diff
         if diff is None:
@@ -181,12 +187,16 @@
         self.extra_template_params = kwargs
 
     @classmethod
-    def forBranchModified(cls, branch, user, delta):
+    def forBranchModified(cls, branch, user, delta, delta_for_editors=None):
         """Construct a BranchMailer for mail about a branch modification.
 
         :param branch: The branch that was modified.
         :param user: The user making the change.
-        :param delta: an IBranchDelta representing the modification.
+        :param delta: an IBranchDelta representing the modification as
+            visible to people who cannot edit the branch.
+        :param delta_for_editors: an IBranchDelta representing the
+            notification as visible to people who can edit the branch.  If
+            None, `delta` is used for people who can edit the branch too.
         :return: a BranchMailer.
         """
         recipients = branch.getNotificationRecipients()
@@ -218,6 +228,7 @@
         return cls(
             '[Branch %(unique_name)s]', 'branch-modified.txt',
             actual_recipients, from_address, delta=delta,
+            delta_for_editors=delta_for_editors,
             notification_type='branch-updated')
 
     @classmethod
@@ -288,8 +299,14 @@
         params['diff'] = self.contents or ''
         if not self._includeDiff(email):
             params['diff'] += self._explainNotPresentDiff(email)
-        params['delta'] = (
-            self.delta_text if self.delta_text is not None else '')
+        if self.delta_for_editors_text is not None:
+            authz = getAdapter(branch, IAuthorization, 'launchpad.Edit')
+            if authz.checkAuthenticated(IPersonRoles(recipient)):
+                params['delta'] = self.delta_for_editors_text
+            else:
+                params['delta'] = self.delta_text or ''
+        else:
+            params['delta'] = self.delta_text or ''
         params.update(self.extra_template_params)
         return params
 

=== modified file 'lib/lp/code/model/gitactivity.py'
--- lib/lp/code/model/gitactivity.py	2018-09-11 16:39:57 +0000
+++ lib/lp/code/model/gitactivity.py	2018-10-16 10:11:25 +0000
@@ -72,6 +72,17 @@
         self.old_value = old_value
         self.new_value = new_value
 
+    @property
+    def changee_description(self):
+        if self.changee is not None:
+            return "~" + self.changee.name
+        elif self.new_value is not None and "changee_type" in self.new_value:
+            return self.new_value["changee_type"].lower()
+        elif self.old_value is not None and "changee_type" in self.old_value:
+            return self.old_value["changee_type"].lower()
+        else:
+            return None
+
 
 def _make_rule_value(rule, position=None):
     return {

=== modified file 'lib/lp/code/model/gitjob.py'
--- lib/lp/code/model/gitjob.py	2015-10-01 14:45:57 +0000
+++ lib/lp/code/model/gitjob.py	2018-10-16 10:11:25 +0000
@@ -1,9 +1,10 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __metaclass__ = type
 
 __all__ = [
+    'describe_repository_delta',
     'GitJob',
     'GitJobType',
     'GitRefScanJob',
@@ -32,6 +33,7 @@
 from zope.security.proxy import removeSecurityProxy
 
 from lp.app.errors import NotFoundError
+from lp.code.enums import GitActivityType
 from lp.code.interfaces.githosting import IGitHostingClient
 from lp.code.interfaces.gitjob import (
     IGitJob,
@@ -57,6 +59,7 @@
     )
 from lp.services.database.stormbase import StormBase
 from lp.services.features import getFeatureFlag
+from lp.services.helpers import english_list
 from lp.services.job.model.job import (
     EnumeratedSubclass,
     Job,
@@ -298,6 +301,57 @@
         getUtility(IGitHostingClient).delete(self.repository_path, logger=log)
 
 
+activity_descriptions = {
+    GitActivityType.RULE_ADDED: "Added protected ref: {new[ref_pattern]}",
+    GitActivityType.RULE_CHANGED: (
+        "Changed protected ref: {old[ref_pattern]} => {new[ref_pattern]}"),
+    GitActivityType.RULE_REMOVED: "Removed protected ref: {old[ref_pattern]}",
+    GitActivityType.RULE_MOVED: (
+        "Moved rule for protected ref {new[ref_pattern]}: "
+        "position {old[position]} => {new[position]}"),
+    GitActivityType.GRANT_ADDED: (
+        "Added access for {changee} to {new[ref_pattern]}: {new_grants}"),
+    GitActivityType.GRANT_CHANGED: (
+        "Changed access for {changee} to {new[ref_pattern]}: "
+        "{old_grants} => {new_grants}"),
+    GitActivityType.GRANT_REMOVED: (
+        "Removed access for {changee} to {old[ref_pattern]}: {old_grants}"),
+    }
+
+
+def describe_grants(activity_value):
+    output = []
+    if activity_value is not None:
+        if activity_value.get("can_create"):
+            output.append("create")
+        if activity_value.get("can_push"):
+            output.append("push")
+        if activity_value.get("can_force_push"):
+            output.append("force-push")
+    return english_list(output)
+
+
+def describe_repository_delta(repository_delta):
+    output = text_delta(
+        repository_delta, repository_delta.delta_values,
+        repository_delta.new_values, repository_delta.interface).split("\n")
+    if output and not output[-1]:  # text_delta returned empty string
+        output.pop()
+    # Parts of the delta are only visible to people who can edit the
+    # repository.
+    output_for_editors = list(output)
+    indent = " " * 4
+    for activity in repository_delta.activities:
+        if activity.what_changed in activity_descriptions:
+            description = activity_descriptions[activity.what_changed].format(
+                old=activity.old_value, new=activity.new_value,
+                changee=activity.changee_description,
+                old_grants=describe_grants(activity.old_value),
+                new_grants=describe_grants(activity.new_value))
+            output_for_editors.append(indent + description)
+    return "\n".join(output), "\n".join(output_for_editors)
+
+
 @implementer(IGitRepositoryModifiedMailJob)
 @provider(IGitRepositoryModifiedMailJobSource)
 class GitRepositoryModifiedMailJob(GitJobDerived):
@@ -310,11 +364,11 @@
     @classmethod
     def create(cls, repository, user, repository_delta):
         """See `IGitRepositoryModifiedMailJobSource`."""
+        delta, delta_for_editors = describe_repository_delta(repository_delta)
         metadata = {
             "user": user.id,
-            "repository_delta": text_delta(
-                repository_delta, repository_delta.delta_values,
-                repository_delta.new_values, repository_delta.interface),
+            "repository_delta": delta,
+            "repository_delta_for_editors": delta_for_editors,
             }
         git_job = GitJob(repository, cls.class_job_type, metadata)
         job = cls(git_job)
@@ -329,10 +383,15 @@
     def repository_delta(self):
         return self.metadata["repository_delta"]
 
+    @property
+    def repository_delta_for_editors(self):
+        return self.metadata["repository_delta_for_editors"]
+
     def getMailer(self):
         """Return a `BranchMailer` for this job."""
         return BranchMailer.forBranchModified(
-            self.repository, self.user, self.repository_delta)
+            self.repository, self.user, self.repository_delta,
+            delta_for_editors=self.repository_delta_for_editors)
 
     def run(self):
         """See `IGitRepositoryModifiedMailJob`."""

=== modified file 'lib/lp/code/model/gitrepository.py'
--- lib/lp/code/model/gitrepository.py	2018-10-15 14:44:25 +0000
+++ lib/lp/code/model/gitrepository.py	2018-10-16 10:11:25 +0000
@@ -240,7 +240,7 @@
     """
     if event.edited_fields:
         repository.date_last_modified = UTC_NOW
-        send_git_repository_modified_notifications(repository, event)
+    send_git_repository_modified_notifications(repository, event)
 
 
 @implementer(IGitRepository, IHasOwner, IPrivacy, IInformationType)
@@ -1208,9 +1208,11 @@
         return self.grants.find(
             GitRuleGrant.grantee_type == GitGranteeType.REPOSITORY_OWNER)
 
-    def getActivity(self):
+    def getActivity(self, changed_after=None):
         """See `IGitRepository`."""
         clauses = [GitActivity.repository_id == self.id]
+        if changed_after is not None:
+            clauses.append(GitActivity.date_changed > changed_after)
         return Store.of(self).find(GitActivity, *clauses).order_by(
             Desc(GitActivity.date_changed), Desc(GitActivity.id))
 

=== modified file 'lib/lp/code/model/tests/test_gitjob.py'
--- lib/lp/code/model/tests/test_gitjob.py	2018-09-27 13:50:06 +0000
+++ lib/lp/code/model/tests/test_gitjob.py	2018-10-16 10:11:25 +0000
@@ -13,6 +13,8 @@
     )
 import hashlib
 
+from lazr.lifecycle.event import ObjectModifiedEvent
+from lazr.lifecycle.snapshot import Snapshot
 import pytz
 from testtools.matchers import (
     ContainsDict,
@@ -21,9 +23,16 @@
     MatchesSetwise,
     MatchesStructure,
     )
+import transaction
+from zope.event import notify
+from zope.interface import providedBy
 from zope.security.proxy import removeSecurityProxy
 
-from lp.code.enums import GitObjectType
+from lp.code.adapters.gitrepository import GitRepositoryDelta
+from lp.code.enums import (
+    GitGranteeType,
+    GitObjectType,
+    )
 from lp.code.interfaces.branchmergeproposal import (
     BRANCH_MERGE_PROPOSAL_WEBHOOKS_FEATURE_FLAG,
     )
@@ -33,6 +42,7 @@
     IReclaimGitRepositorySpaceJob,
     )
 from lp.code.model.gitjob import (
+    describe_repository_delta,
     GitJob,
     GitJobDerived,
     GitJobType,
@@ -47,6 +57,7 @@
 from lp.services.utils import seconds_since_epoch
 from lp.services.webapp import canonical_url
 from lp.testing import (
+    person_logged_in,
     TestCaseWithFactory,
     time_counter,
     )
@@ -338,5 +349,132 @@
         self.assertEqual([(path,)], hosting_fixture.delete.extract_args())
 
 
+class TestDescribeRepositoryDelta(TestCaseWithFactory):
+    """Tests for `describe_repository_delta`."""
+
+    layer = ZopelessDatabaseLayer
+
+    def assertDeltaDescriptionEqual(self, expected, expected_for_editors,
+                                    snapshot, repository):
+        repository_delta = GitRepositoryDelta.construct(
+            snapshot, repository, repository.owner)
+        delta, delta_for_editors = describe_repository_delta(repository_delta)
+        self.assertEqual(
+            "\n".join("    %s" % line for line in expected), delta)
+        self.assertEqual(
+            "\n".join("    %s" % line for line in expected_for_editors),
+            delta_for_editors)
+
+    def test_change_basic_properties(self):
+        repository = self.factory.makeGitRepository(name="foo")
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            repository.setName("bar", repository.owner)
+        expected = [
+            "Name: foo => bar",
+            "Git identity: lp:~{person}/{project}/+git/foo => "
+            "lp:~{person}/{project}/+git/bar".format(
+                person=repository.owner.name, project=repository.target.name),
+            ]
+        self.assertDeltaDescriptionEqual(
+            expected, expected, snapshot, repository)
+
+    def test_add_rule(self):
+        repository = self.factory.makeGitRepository()
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            repository.addRule("refs/heads/*", repository.owner)
+        self.assertDeltaDescriptionEqual(
+            [], ["Added protected ref: refs/heads/*"], snapshot, repository)
+
+    def test_change_rule(self):
+        repository = self.factory.makeGitRepository()
+        rule = self.factory.makeGitRule(
+            repository=repository, ref_pattern="refs/heads/foo")
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        rule_snapshot = Snapshot(rule, providing=providedBy(rule))
+        with person_logged_in(repository.owner):
+            rule.ref_pattern = "refs/heads/bar"
+            notify(ObjectModifiedEvent(rule, rule_snapshot, ["ref_pattern"]))
+        self.assertDeltaDescriptionEqual(
+            [], ["Changed protected ref: refs/heads/foo => refs/heads/bar"],
+            snapshot, repository)
+
+    def test_remove_rule(self):
+        repository = self.factory.makeGitRepository()
+        rule = self.factory.makeGitRule(
+            repository=repository, ref_pattern="refs/heads/*")
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            rule.destroySelf(repository.owner)
+        self.assertDeltaDescriptionEqual(
+            [], ["Removed protected ref: refs/heads/*"], snapshot, repository)
+
+    def test_move_rule(self):
+        repository = self.factory.makeGitRepository()
+        rule = self.factory.makeGitRule(
+            repository=repository, ref_pattern="refs/heads/*")
+        self.factory.makeGitRule(
+            repository=repository, ref_pattern="refs/heads/stable/*")
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            repository.moveRule(rule, 1, repository.owner)
+        self.assertDeltaDescriptionEqual(
+            [], ["Moved rule for protected ref refs/heads/*: position 0 => 1"],
+            snapshot, repository)
+
+    def test_add_grant(self):
+        repository = self.factory.makeGitRepository()
+        rule = self.factory.makeGitRule(
+            repository=repository, ref_pattern="refs/heads/*")
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            rule.addGrant(
+                GitGranteeType.REPOSITORY_OWNER, repository.owner,
+                can_create=True, can_push=True, can_force_push=True)
+        self.assertDeltaDescriptionEqual(
+            [],
+            ["Added access for repository owner to refs/heads/*: "
+             "create, push, and force-push"],
+            snapshot, repository)
+
+    def test_change_grant(self):
+        repository = self.factory.makeGitRepository()
+        grant = self.factory.makeGitRuleGrant(
+            repository=repository, ref_pattern="refs/heads/*",
+            can_create=True)
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        grant_snapshot = Snapshot(grant, providing=providedBy(grant))
+        with person_logged_in(repository.owner):
+            grant.can_push = True
+            notify(ObjectModifiedEvent(grant, grant_snapshot, ["can_push"]))
+        self.assertDeltaDescriptionEqual(
+            [],
+            ["Changed access for ~{grantee} to refs/heads/*: "
+             "create => create and push".format(grantee=grant.grantee.name)],
+            snapshot, repository)
+
+    def test_remove_grant(self):
+        repository = self.factory.makeGitRepository()
+        grant = self.factory.makeGitRuleGrant(
+            repository=repository, ref_pattern="refs/heads/*",
+            grantee=GitGranteeType.REPOSITORY_OWNER, can_push=True)
+        transaction.commit()
+        snapshot = Snapshot(repository, providing=providedBy(repository))
+        with person_logged_in(repository.owner):
+            grant.destroySelf(repository.owner)
+        self.assertDeltaDescriptionEqual(
+            [],
+            ["Removed access for repository owner to refs/heads/*: push"],
+            snapshot, repository)
+
+
 # XXX cjwatson 2015-03-12: We should test that the jobs work via Celery too,
 # but that isn't feasible until we have a proper turnip fixture.

=== modified file 'lib/lp/code/model/tests/test_gitrepository.py'
--- lib/lp/code/model/tests/test_gitrepository.py	2018-10-15 14:44:25 +0000
+++ lib/lp/code/model/tests/test_gitrepository.py	2018-10-16 10:11:25 +0000
@@ -981,6 +981,12 @@
         # Attribute modifications send mail to subscribers.
         self.assertEqual(0, len(stub.test_emails))
         repository = self.factory.makeGitRepository(name="foo")
+        subscriber = self.factory.makePerson()
+        owner_address = (
+            removeSecurityProxy(repository.owner.preferredemail).email)
+        subscriber_address = (
+            removeSecurityProxy(subscriber.preferredemail).email)
+        transaction.commit()
         repository_before_modification = Snapshot(
             repository, providing=providedBy(repository))
         with person_logged_in(repository.owner):
@@ -990,22 +996,45 @@
                 BranchSubscriptionDiffSize.NODIFF,
                 CodeReviewNotificationLevel.NOEMAIL,
                 repository.owner)
+            repository.subscribe(
+                subscriber,
+                BranchSubscriptionNotificationLevel.ATTRIBUTEONLY,
+                BranchSubscriptionDiffSize.NODIFF,
+                CodeReviewNotificationLevel.NOEMAIL,
+                repository.owner)
             repository.setName("bar", repository.owner)
+            repository.addRule("refs/heads/stable/*", repository.owner)
             notify(ObjectModifiedEvent(
                 repository, repository_before_modification, ["name"],
                 user=repository.owner))
         with dbuser(config.IGitRepositoryModifiedMailJobSource.dbuser):
             JobRunner.fromReady(
                 getUtility(IGitRepositoryModifiedMailJobSource)).runAll()
-        self.assertEqual(1, len(stub.test_emails))
-        message = email.message_from_string(stub.test_emails[0][2])
-        body = message.get_payload(decode=True)
-        self.assertIn("Name: foo => bar\n", body)
-        self.assertIn(
-            "Git identity: lp:~{person}/{project}/+git/foo => "
-            "lp:~{person}/{project}/+git/bar\n".format(
-                person=repository.owner.name, project=repository.target.name),
-            body)
+        bodies_by_recipient = {}
+        for from_addr, to_addrs, message in stub.test_emails:
+            body = email.message_from_string(message).get_payload(decode=True)
+            for to_addr in to_addrs:
+                bodies_by_recipient[to_addr] = body
+        # Both the owner and the unprivileged subscriber receive email.
+        self.assertContentEqual(
+            [owner_address, subscriber_address], bodies_by_recipient.keys())
+        # The owner receives a message including details of permission
+        # changes.
+        self.assertEqual(
+            "    Name: foo => bar\n"
+            "    Git identity: lp:~{person}/{project}/+git/foo => "
+            "lp:~{person}/{project}/+git/bar\n"
+            "    Added protected ref: refs/heads/stable/*".format(
+                person=repository.owner.name, project=repository.target.name),
+            bodies_by_recipient[owner_address].split("\n\n--\n")[0])
+        # The unprivileged subscriber receives a message omitting details of
+        # permission changes.
+        self.assertEqual(
+            "    Name: foo => bar\n"
+            "    Git identity: lp:~{person}/{project}/+git/foo => "
+            "lp:~{person}/{project}/+git/bar".format(
+                person=repository.owner.name, project=repository.target.name),
+            bodies_by_recipient[subscriber_address].split("\n\n--\n")[0])
 
     # XXX cjwatson 2015-02-04: This will need to be expanded once Launchpad
     # actually notices any interesting kind of repository modifications.