Merge lp:~cjwatson/launchpad/bzr-webhooks into lp:launchpad

[Colin Watson]

Add webhook support for Bazaar branches.

Add webhook support for Bazaar branches. It's almost exactly the same shape as for Git repositories, but with the webhook triggering hooked into the TipChange event instead of written directly in the job, and with a slightly different payload structure since there's only one pair of revisions involved.

[William Grant (wgrant)]

review: Approve (code)

[Colin Watson (cjwatson)]

All right, in the name of consistency I cleaned up a bunch of bits of Branch (mainly BzrIdentityMixin) to match the corresponding newer code in GitRepository/GitIdentityMixin, and introduced Branch.shortened_path which lacks the lp: prefix. bzr_branch_path for this branch would now be "~cjwatson/launchpad/bzr-webhooks", or for the target of this merge proposal would be "launchpad". Does this look OK to you?

[William Grant (wgrant)]

review: Approve (code)

[William Grant (wgrant)]

Actually, is there any way to get a branch by its shortened_name? lp.branches.getByUrl exists, but there's no lp.branches.getByPath.

=== modified file 'lib/lp/code/browser/branch.py'
--- lib/lp/code/browser/branch.py	2015-09-23 15:38:13 +0000
+++ lib/lp/code/browser/branch.py	2015-09-29 15:54:57 +0000
@@ -125,6 +125,7 @@
 from lp.services import searchbuilder
 from lp.services.config import config
 from lp.services.database.constants import UTC_NOW
+from lp.services.features import getFeatureFlag
 from lp.services.feeds.browser import (
     BranchFeedLink,
     FeedsMixin,
@@ -152,6 +153,7 @@
 from lp.services.webapp.breadcrumb import NameBreadcrumb
 from lp.services.webapp.escaping import structured
 from lp.services.webapp.interfaces import ICanonicalUrlData
+from lp.services.webhooks.browser import WebhookTargetNavigationMixin
 from lp.snappy.browser.hassnaps import (
     HasSnapsMenuMixin,
     HasSnapsViewMixin,
@@ -183,7 +185,7 @@
         return self.context.target.components[-1]
 
 
-class BranchNavigation(Navigation):
+class BranchNavigation(WebhookTargetNavigationMixin, Navigation):
 
     usedfor = IBranch
 
@@ -240,7 +242,7 @@
     facet = 'branches'
     title = 'Edit branch'
     links = (
-        'edit', 'reviewer', 'edit_whiteboard', 'delete')
+        'edit', 'reviewer', 'edit_whiteboard', 'webhooks', 'delete')
 
     def branch_is_import(self):
         return self.context.branch_type == BranchType.IMPORTED
@@ -267,6 +269,13 @@
         text = 'Set branch reviewer'
         return Link('+reviewer', text, icon='edit')
 
+    @enabled_with_permission('launchpad.Edit')
+    def webhooks(self):
+        text = 'Manage webhooks'
+        return Link(
+            '+webhooks', text, icon='edit',
+            enabled=bool(getFeatureFlag('webhooks.new.enabled')))
+
 
 class BranchContextMenu(ContextMenu, HasRecipesMenuMixin, HasSnapsMenuMixin):
     """Context menu for branches."""
 
=== modified file 'lib/lp/code/configure.zcml'
--- lib/lp/code/configure.zcml	2015-09-11 15:11:34 +0000
+++ lib/lp/code/configure.zcml	2015-09-29 15:54:57 +0000
@@ -418,6 +418,9 @@
       for="lp.codehosting.scanner.events.ITipChanged"
       handler="lp.codehosting.scanner.bzrsync.update_recipes"/>
   <subscriber
+      for="lp.codehosting.scanner.events.ITipChanged"
+      handler="lp.codehosting.scanner.bzrsync.trigger_webhooks"/>
+  <subscriber
       for="lp.codehosting.scanner.events.IRevisionsRemoved"
       handler="lp.codehosting.scanner.email.send_removed_revision_emails"/>
   <subscriber
 
=== modified file 'lib/lp/code/interfaces/branch.py'
--- lib/lp/code/interfaces/branch.py	2015-09-29 00:32:52 +0000
+++ lib/lp/code/interfaces/branch.py	2015-09-29 15:54:57 +0000
@@ -105,6 +105,7 @@
     structured,
     )
 from lp.services.webapp.interfaces import ITableBatchNavigator
+from lp.services.webhooks.interfaces import IWebhookTarget
 
 
 DEFAULT_BRANCH_STATUS_IN_LISTING = (
@@ -711,6 +712,10 @@
         Reference(
             title=_("The associated CodeImport, if any."), schema=Interface))
 
+    shortened_path = Attribute(
+        "The shortest reasonable version of the path to this branch; as "
+        "bzr_identity but without the 'lp:' prefix.")
+
     bzr_identity = exported(
         Text(
             title=_('Bazaar Identity'),
@@ -780,7 +785,7 @@
         :return: A list of suite source packages ordered by pocket.
         """
 
-    def branchLinks():
+    def getBranchLinks():
         """Return a sorted list of ICanHasLinkedBranch objects.
 
         There is one result for each related linked object that the branch is
@@ -792,7 +797,7 @@
         more important links are sorted first.
         """
 
-    def branchIdentities():
+    def getBranchIdentities():
         """A list of aliases for a branch.
 
         Returns a list of tuples of bzr identity and context object.  There is
@@ -805,10 +810,10 @@
 
         For example, a branch linked to the development focus of the 'fooix'
         project is accessible using:
-          lp:fooix - the linked object is the product fooix
-          lp:fooix/trunk - the linked object is the trunk series of fooix
-          lp:~owner/fooix/name - the unique name of the branch where the
-              linked object is the branch itself.
+          fooix - the linked object is the product fooix
+          fooix/trunk - the linked object is the trunk series of fooix
+          ~owner/fooix/name - the unique name of the branch where the linked
+              object is the branch itself.
         """
 
     # subscription-related methods
@@ -1129,7 +1134,7 @@
             vocabulary=ControlFormat))
 
 
-class IBranchEdit(Interface):
+class IBranchEdit(IWebhookTarget):
     """IBranch attributes that require launchpad.Edit permission."""
 
     @call_with(user=REQUEST_USER)
@@ -1313,8 +1318,7 @@
         Return None if no match was found.
         """
 
-    @operation_parameters(
-        url=TextLine(title=_('Branch URL'), required=True))
+    @operation_parameters(url=TextLine(title=_('Branch URL'), required=True))
     @operation_returns_entry(IBranch)
     @export_read_operation()
     @operation_for_version('beta')
@@ -1357,6 +1361,29 @@
             associated branch, the URL will map to `None`.
         """
 
+    @operation_parameters(path=TextLine(title=_('Branch path'), required=True))
+    @operation_returns_entry(IBranch)
+    @export_read_operation()
+    @operation_for_version('devel')
+    def getByPath(path):
+        """Find a branch by its path.
+
+        The path is the same as its lp: URL, but without the leading lp:, so
+        it may be in any of these forms::
+
+            Unique names:
+                ~OWNER/PROJECT/NAME
+                ~OWNER/DISTRO/SERIES/SOURCE/NAME
+                ~OWNER/+junk/NAME
+            Aliases linked to other objects:
+                PROJECT
+                PROJECT/SERIES
+                DISTRO/SOURCE
+                DISTRO/SUITE/SOURCE
+
+        Return None if no match was found.
+        """
+
     @collection_default_content()
     def getBranches(limit=50, eager_load=True):
         """Return a collection of branches.
@@ -1481,26 +1508,29 @@
     """
 
     @property
+    def shortened_path(self):
+        """See `IBranch`."""
+        return self.getBranchIdentities()[0][0]
+
+    @property
     def bzr_identity(self):
         """See `IBranch`."""
-        identity, context = self.branchIdentities()[0]
-        return identity
+        return config.codehosting.bzr_lp_prefix + self.shortened_path
 
     identity = bzr_identity
 
-    def branchIdentities(self):
+    def getBranchIdentities(self):
         """See `IBranch`."""
-        lp_prefix = config.codehosting.bzr_lp_prefix
-        if not self.target.supports_short_identites:
+        if not self.target.supports_short_identities:
             identities = []
         else:
             identities = [
-                (lp_prefix + link.bzr_path, link.context)
-                for link in self.branchLinks()]
-        identities.append((lp_prefix + self.unique_name, self))
+                (link.bzr_path, link.context)
+                for link in self.getBranchLinks()]
+        identities.append((self.unique_name, self))
         return identities
 
-    def branchLinks(self):
+    def getBranchLinks(self):
         """See `IBranch`."""
         links = []
         for suite_sp in self.associatedSuiteSourcePackages():
 
=== modified file 'lib/lp/code/interfaces/branchlookup.py'
--- lib/lp/code/interfaces/branchlookup.py	2013-01-07 02:40:55 +0000
+++ lib/lp/code/interfaces/branchlookup.py	2015-09-29 15:54:57 +0000
@@ -158,6 +158,14 @@
             paths are not handled for shortcut paths.
         """
 
+    def getByPath(path):
+        """Find the branch associated with a path.
+
+        As with `getByLPPath`, but returns None instead of raising any of
+        the documented exceptions, and returns only the `IBranch` on success
+        and not any extra path.
+        """
+
 
 def path_lookups(path):
     if path.startswith(BRANCH_ID_ALIAS_PREFIX + '/'):
 
=== modified file 'lib/lp/code/interfaces/branchtarget.py'
--- lib/lp/code/interfaces/branchtarget.py	2015-04-21 14:32:31 +0000
+++ lib/lp/code/interfaces/branchtarget.py	2015-09-29 15:54:57 +0000
@@ -92,7 +92,7 @@
     supports_merge_proposals = Attribute(
         "Does this target support merge proposals at all?")
 
-    supports_short_identites = Attribute(
+    supports_short_identities = Attribute(
         "Does this target support shortened bazaar identities?")
 
     supports_code_imports = Attribute(
 
=== modified file 'lib/lp/code/interfaces/gitrepository.py'
--- lib/lp/code/interfaces/gitrepository.py	2015-09-21 10:08:08 +0000
+++ lib/lp/code/interfaces/gitrepository.py	2015-09-29 15:54:57 +0000
@@ -688,7 +688,8 @@
     def getByPath(user, path):
         """Find a repository by its path.
 
-        Any of these forms may be used, with or without a leading slash:
+        Any of these forms may be used::
+
             Unique names:
                 ~OWNER/PROJECT/+git/NAME
                 ~OWNER/DISTRO/+source/SOURCE/+git/NAME
 
=== modified file 'lib/lp/code/model/branch.py'
--- lib/lp/code/model/branch.py	2015-09-29 00:32:52 +0000
+++ lib/lp/code/model/branch.py	2015-09-29 15:54:57 +0000
@@ -180,10 +180,12 @@
 from lp.services.webapp import urlappend
 from lp.services.webapp.authorization import check_permission
 from lp.services.webapp.interfaces import ILaunchBag
+from lp.services.webhooks.interfaces import IWebhookSet
+from lp.services.webhooks.model import WebhookTargetMixin
 
 
 @implementer(IBranch, IPrivacy, IInformationType)
-class Branch(SQLBase, BzrIdentityMixin):
+class Branch(SQLBase, WebhookTargetMixin, BzrIdentityMixin):
     """A sequence of ordered revisions in Bazaar."""
     _table = 'Branch'
 
@@ -1336,6 +1338,7 @@
 
         self._deleteBranchSubscriptions()
         self._deleteJobs()
+        getUtility(IWebhookSet).delete(self.webhooks)
 
         # Now destroy the branch.
         branch_id = self.id
@@ -1610,6 +1613,10 @@
         """See `IBranchSet`."""
         return getUtility(IBranchLookup).getByUrls(urls)
 
+    def getByPath(self, path):
+        """See `IBranchSet`."""
+        return getUtility(IBranchLookup).getByPath(path)
+
     def getBranches(self, limit=50, eager_load=True):
         """See `IBranchSet`."""
         anon_branches = getUtility(IAllBranches).visibleByUser(None)
 
=== modified file 'lib/lp/code/model/branchlookup.py'
--- lib/lp/code/model/branchlookup.py	2015-07-10 05:57:13 +0000
+++ lib/lp/code/model/branchlookup.py	2015-09-29 15:54:57 +0000
@@ -248,14 +248,7 @@
         if uri.scheme == 'lp':
             if not self._uriHostAllowed(uri):
                 return None
-            try:
-                return self.getByLPPath(uri.path.lstrip('/'))[0]
-            except (
-                CannotHaveLinkedBranch, InvalidNamespace, InvalidProductName,
-                NoSuchBranch, NoSuchPerson, NoSuchProduct,
-                NoSuchProductSeries, NoSuchDistroSeries,
-                NoSuchSourcePackageName, NoLinkedBranch):
-                return None
+            return self.getByPath(uri.path.lstrip('/'))
 
         return Branch.selectOneBy(url=url)
 
@@ -386,6 +379,16 @@
             suffix = path[len(bzr_path) + 1:]
         return branch, suffix
 
+    def getByPath(self, path):
+        """See `IBranchLookup`."""
+        try:
+            return self.getByLPPath(path)[0]
+        except (
+            CannotHaveLinkedBranch, InvalidNamespace, InvalidProductName,
+            NoSuchBranch, NoSuchPerson, NoSuchProduct, NoSuchProductSeries,
+            NoSuchDistroSeries, NoSuchSourcePackageName, NoLinkedBranch):
+            return None
+
     def _getLinkedBranchAndPath(self, provided):
         """Get the linked branch for 'provided', and the bzr_path.
 
 
=== modified file 'lib/lp/code/model/branchtarget.py'
--- lib/lp/code/model/branchtarget.py	2015-07-08 16:05:11 +0000
+++ lib/lp/code/model/branchtarget.py	2015-09-29 15:54:57 +0000
@@ -113,7 +113,7 @@
         return True
 
     @property
-    def supports_short_identites(self):
+    def supports_short_identities(self):
         """See `IBranchTarget`."""
         return True
 
@@ -229,7 +229,7 @@
         return False
 
     @property
-    def supports_short_identites(self):
+    def supports_short_identities(self):
         """See `IBranchTarget`."""
         return False
 
@@ -314,7 +314,7 @@
         return True
 
     @property
-    def supports_short_identites(self):
+    def supports_short_identities(self):
         """See `IBranchTarget`."""
         return True
 
 
=== modified file 'lib/lp/code/model/tests/test_branch.py'
--- lib/lp/code/model/tests/test_branch.py	2015-08-06 12:03:36 +0000
+++ lib/lp/code/model/tests/test_branch.py	2015-09-29 15:54:57 +0000
@@ -910,202 +910,8 @@
         self.assertFalse(branch.upgrade_pending)
 
 
-class TestBranchLinksAndIdentites(TestCaseWithFactory):
-    """Test IBranch.branchLinks and IBranch.branchIdentities."""
-
-    layer = DatabaseFunctionalLayer
-
-    def test_default_identities(self):
-        # If there are no links, the only branch identity is the unique name.
-        branch = self.factory.makeAnyBranch()
-        self.assertEqual(
-            [('lp://dev/' + branch.unique_name, branch)],
-            branch.branchIdentities())
-
-    def test_linked_to_product(self):
-        # If a branch is linked to the product, it is also by definition
-        # linked to the development focus of the product.
-        fooix = removeSecurityProxy(self.factory.makeProduct(name='fooix'))
-        fooix.development_focus.name = 'devel'
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makeProductBranch(
-            product=fooix, owner=eric, name='trunk')
-        linked_branch = ICanHasLinkedBranch(fooix)
-        linked_branch.setBranch(branch)
-        self.assertEqual(
-            [linked_branch, ICanHasLinkedBranch(fooix.development_focus)],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/fooix', fooix),
-             ('lp://dev/fooix/devel', fooix.development_focus),
-             ('lp://dev/~eric/fooix/trunk', branch)],
-            branch.branchIdentities())
-
-    def test_linked_to_product_series(self):
-        # If a branch is linked to a non-development series of a product and
-        # not linked to the product itself, then only the product series is
-        # returned in the links.
-        fooix = removeSecurityProxy(self.factory.makeProduct(name='fooix'))
-        future = self.factory.makeProductSeries(product=fooix, name='future')
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makeProductBranch(
-            product=fooix, owner=eric, name='trunk')
-        linked_branch = ICanHasLinkedBranch(future)
-        login_person(fooix.owner)
-        linked_branch.setBranch(branch)
-        self.assertEqual(
-            [linked_branch],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/fooix/future', future),
-             ('lp://dev/~eric/fooix/trunk', branch)],
-            branch.branchIdentities())
-
-    def test_linked_to_package(self):
-        # If a branch is linked to a suite source package where the
-        # distroseries is the current series for the distribution, there is a
-        # link for both the distribution source package and the suite source
-        # package.
-        mint = self.factory.makeDistribution(name='mint')
-        dev = self.factory.makeDistroSeries(
-            distribution=mint, version='1.0', name='dev')
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makePackageBranch(
-            distroseries=dev, sourcepackagename='choc', name='tip',
-            owner=eric)
-        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
-        distro_link = ICanHasLinkedBranch(dsp)
-        development_package = dsp.development_version
-        suite_sourcepackage = development_package.getSuiteSourcePackage(
-            PackagePublishingPocket.RELEASE)
-        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
-
-        registrant = suite_sourcepackage.distribution.owner
-        run_with_login(
-            registrant,
-            suite_sp_link.setBranch, branch, registrant)
-
-        self.assertEqual(
-            [distro_link, suite_sp_link],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/mint/choc', dsp),
-             ('lp://dev/mint/dev/choc', suite_sourcepackage),
-             ('lp://dev/~eric/mint/dev/choc/tip', branch)],
-            branch.branchIdentities())
-
-    def test_linked_to_package_not_release_pocket(self):
-        # If a branch is linked to a suite source package where the
-        # distroseries is the current series for the distribution, but the
-        # pocket is not the RELEASE pocket, then there is only the link for
-        # the suite source package.
-        mint = self.factory.makeDistribution(name='mint')
-        dev = self.factory.makeDistroSeries(
-            distribution=mint, version='1.0', name='dev')
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makePackageBranch(
-            distroseries=dev, sourcepackagename='choc', name='tip',
-            owner=eric)
-        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
-        development_package = dsp.development_version
-        suite_sourcepackage = development_package.getSuiteSourcePackage(
-            PackagePublishingPocket.BACKPORTS)
-        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
-
-        registrant = suite_sourcepackage.distribution.owner
-        run_with_login(
-            registrant,
-            suite_sp_link.setBranch, branch, registrant)
-
-        self.assertEqual(
-            [suite_sp_link],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/mint/dev-backports/choc', suite_sourcepackage),
-             ('lp://dev/~eric/mint/dev/choc/tip', branch)],
-            branch.branchIdentities())
-
-    def test_linked_to_package_not_current_series(self):
-        # If the branch is linked to a suite source package where the distro
-        # series is not the current series, only the suite source package is
-        # returned in the links.
-        mint = self.factory.makeDistribution(name='mint')
-        self.factory.makeDistroSeries(
-            distribution=mint, version='1.0', name='dev')
-        supported = self.factory.makeDistroSeries(
-            distribution=mint, version='0.9', name='supported')
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makePackageBranch(
-            distroseries=supported, sourcepackagename='choc', name='tip',
-            owner=eric)
-        suite_sp = self.factory.makeSuiteSourcePackage(
-            distroseries=supported, sourcepackagename='choc',
-            pocket=PackagePublishingPocket.RELEASE)
-        suite_sp_link = ICanHasLinkedBranch(suite_sp)
-
-        registrant = suite_sp.distribution.owner
-        run_with_login(
-            registrant,
-            suite_sp_link.setBranch, branch, registrant)
-
-        self.assertEqual(
-            [suite_sp_link],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/mint/supported/choc', suite_sp),
-             ('lp://dev/~eric/mint/supported/choc/tip', branch)],
-            branch.branchIdentities())
-
-    def test_linked_across_project_to_package(self):
-        # If a product branch is linked to a suite source package, the links
-        # are the same as if it was a source package branch.
-        mint = self.factory.makeDistribution(name='mint')
-        self.factory.makeDistroSeries(
-            distribution=mint, version='1.0', name='dev')
-        eric = self.factory.makePerson(name='eric')
-        fooix = self.factory.makeProduct(name='fooix')
-        branch = self.factory.makeProductBranch(
-            product=fooix, owner=eric, name='trunk')
-        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
-        distro_link = ICanHasLinkedBranch(dsp)
-        development_package = dsp.development_version
-        suite_sourcepackage = development_package.getSuiteSourcePackage(
-            PackagePublishingPocket.RELEASE)
-        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
-
-        registrant = suite_sourcepackage.distribution.owner
-        run_with_login(
-            registrant,
-            suite_sp_link.setBranch, branch, registrant)
-
-        self.assertEqual(
-            [distro_link, suite_sp_link],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/mint/choc', dsp),
-             ('lp://dev/mint/dev/choc', suite_sourcepackage),
-             ('lp://dev/~eric/fooix/trunk', branch)],
-            branch.branchIdentities())
-
-    def test_junk_branch_links(self):
-        # If a junk branch has links, those links are returned in the
-        # branchLinks, but the branchIdentities just has the branch unique
-        # name.
-        eric = self.factory.makePerson(name='eric')
-        branch = self.factory.makePersonalBranch(owner=eric, name='foo')
-        fooix = removeSecurityProxy(self.factory.makeProduct())
-        linked_branch = ICanHasLinkedBranch(fooix)
-        linked_branch.setBranch(branch)
-        self.assertEqual(
-            [linked_branch, ICanHasLinkedBranch(fooix.development_focus)],
-            branch.branchLinks())
-        self.assertEqual(
-            [('lp://dev/~eric/+junk/foo', branch)],
-            branch.branchIdentities())
-
-
-class TestBzrIdentity(TestCaseWithFactory):
-    """Test IBranch.bzr_identity."""
+class TestBzrIdentityMixin(TestCaseWithFactory):
+    """Test the defaults and identities provided by BzrIdentityMixin."""
 
     layer = DatabaseFunctionalLayer
 
@@ -1115,16 +921,17 @@
         Actually, it'll be lp://dev/<identity_path>.
         """
         self.assertEqual(
-            'lp://dev/%s' % identity_path, branch.bzr_identity,
-            "bzr identity")
+            identity_path, branch.shortened_path, "shortened path")
+        self.assertEqual(
+            'lp://dev/%s' % identity_path, branch.bzr_identity, "bzr identity")
 
-    def test_default_identity(self):
+    def test_bzr_identity_default(self):
         # By default, the bzr identity is an lp URL with the branch's unique
         # name.
         branch = self.factory.makeAnyBranch()
         self.assertBzrIdentity(branch, branch.unique_name)
 
-    def test_linked_to_product(self):
+    def test_bzr_identity_linked_to_product(self):
         # If a branch is the development focus branch for a product, then it's
         # bzr identity is lp:product.
         branch = self.factory.makeProductBranch()
@@ -1133,7 +940,7 @@
         linked_branch.setBranch(branch)
         self.assertBzrIdentity(branch, linked_branch.bzr_path)
 
-    def test_linked_to_product_series(self):
+    def test_bzr_identity_linked_to_product_series(self):
         # If a branch is the development focus branch for a product series,
         # then it's bzr identity is lp:product/series.
         branch = self.factory.makeProductBranch()
@@ -1144,7 +951,7 @@
         linked_branch.setBranch(branch)
         self.assertBzrIdentity(branch, linked_branch.bzr_path)
 
-    def test_private_linked_to_product(self):
+    def test_bzr_identity_private_linked_to_product(self):
         # Private branches also have a short lp:url.
         branch = self.factory.makeProductBranch(
             information_type=InformationType.USERDATA)
@@ -1153,7 +960,7 @@
             ICanHasLinkedBranch(product).setBranch(branch)
             self.assertBzrIdentity(branch, product.name)
 
-    def test_linked_to_series_and_dev_focus(self):
+    def test_bzr_identity_linked_to_series_and_dev_focus(self):
         # If a branch is the development focus branch for a product and the
         # branch for a series, the bzr identity will be the storter of the two
         # URLs.
@@ -1167,7 +974,7 @@
         series_link.setBranch(branch)
         self.assertBzrIdentity(branch, product_link.bzr_path)
 
-    def test_junk_branch_always_unique_name(self):
+    def test_bzr_identity_junk_branch_always_unique_name(self):
         # For junk branches, the bzr identity is always based on the unique
         # name of the branch, even if it's linked to a product, product series
         # or whatever.
@@ -1176,7 +983,7 @@
         ICanHasLinkedBranch(product).setBranch(branch)
         self.assertBzrIdentity(branch, branch.unique_name)
 
-    def test_linked_to_package(self):
+    def test_bzr_identity_linked_to_package(self):
         # If a branch is linked to a pocket of a package, then the
         # bzr identity is the path to that package.
         branch = self.factory.makePackageBranch()
@@ -1191,7 +998,7 @@
         login(ANONYMOUS)
         self.assertBzrIdentity(branch, linked_branch.bzr_path)
 
-    def test_linked_to_dev_package(self):
+    def test_bzr_identity_linked_to_dev_package(self):
         # If a branch is linked to the development focus version of a package
         # then the bzr identity is distro/package.
         sourcepackage = self.factory.makeSourcePackage()
@@ -1205,6 +1012,192 @@
             linked_branch.setBranch, branch, registrant)
         self.assertBzrIdentity(branch, linked_branch.bzr_path)
 
+    def test_identities_no_links(self):
+        # If there are no links, the only branch identity is the unique name.
+        branch = self.factory.makeAnyBranch()
+        self.assertEqual(
+            [(branch.unique_name, branch)], branch.getBranchIdentities())
+
+    def test_linked_to_product(self):
+        # If a branch is linked to the product, it is also by definition
+        # linked to the development focus of the product.
+        fooix = removeSecurityProxy(self.factory.makeProduct(name='fooix'))
+        fooix.development_focus.name = 'devel'
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makeProductBranch(
+            product=fooix, owner=eric, name='trunk')
+        linked_branch = ICanHasLinkedBranch(fooix)
+        linked_branch.setBranch(branch)
+        self.assertEqual(
+            [linked_branch, ICanHasLinkedBranch(fooix.development_focus)],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('fooix', fooix),
+             ('fooix/devel', fooix.development_focus),
+             ('~eric/fooix/trunk', branch)],
+            branch.getBranchIdentities())
+
+    def test_linked_to_product_series(self):
+        # If a branch is linked to a non-development series of a product and
+        # not linked to the product itself, then only the product series is
+        # returned in the links.
+        fooix = removeSecurityProxy(self.factory.makeProduct(name='fooix'))
+        future = self.factory.makeProductSeries(product=fooix, name='future')
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makeProductBranch(
+            product=fooix, owner=eric, name='trunk')
+        linked_branch = ICanHasLinkedBranch(future)
+        login_person(fooix.owner)
+        linked_branch.setBranch(branch)
+        self.assertEqual(
+            [linked_branch],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('fooix/future', future),
+             ('~eric/fooix/trunk', branch)],
+            branch.getBranchIdentities())
+
+    def test_linked_to_package(self):
+        # If a branch is linked to a suite source package where the
+        # distroseries is the current series for the distribution, there is a
+        # link for both the distribution source package and the suite source
+        # package.
+        mint = self.factory.makeDistribution(name='mint')
+        dev = self.factory.makeDistroSeries(
+            distribution=mint, version='1.0', name='dev')
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makePackageBranch(
+            distroseries=dev, sourcepackagename='choc', name='tip',
+            owner=eric)
+        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
+        distro_link = ICanHasLinkedBranch(dsp)
+        development_package = dsp.development_version
+        suite_sourcepackage = development_package.getSuiteSourcePackage(
+            PackagePublishingPocket.RELEASE)
+        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
+
+        registrant = suite_sourcepackage.distribution.owner
+        run_with_login(
+            registrant,
+            suite_sp_link.setBranch, branch, registrant)
+
+        self.assertEqual(
+            [distro_link, suite_sp_link],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('mint/choc', dsp),
+             ('mint/dev/choc', suite_sourcepackage),
+             ('~eric/mint/dev/choc/tip', branch)],
+            branch.getBranchIdentities())
+
+    def test_linked_to_package_not_release_pocket(self):
+        # If a branch is linked to a suite source package where the
+        # distroseries is the current series for the distribution, but the
+        # pocket is not the RELEASE pocket, then there is only the link for
+        # the suite source package.
+        mint = self.factory.makeDistribution(name='mint')
+        dev = self.factory.makeDistroSeries(
+            distribution=mint, version='1.0', name='dev')
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makePackageBranch(
+            distroseries=dev, sourcepackagename='choc', name='tip',
+            owner=eric)
+        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
+        development_package = dsp.development_version
+        suite_sourcepackage = development_package.getSuiteSourcePackage(
+            PackagePublishingPocket.BACKPORTS)
+        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
+
+        registrant = suite_sourcepackage.distribution.owner
+        run_with_login(
+            registrant,
+            suite_sp_link.setBranch, branch, registrant)
+
+        self.assertEqual(
+            [suite_sp_link],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('mint/dev-backports/choc', suite_sourcepackage),
+             ('~eric/mint/dev/choc/tip', branch)],
+            branch.getBranchIdentities())
+
+    def test_linked_to_package_not_current_series(self):
+        # If the branch is linked to a suite source package where the distro
+        # series is not the current series, only the suite source package is
+        # returned in the links.
+        mint = self.factory.makeDistribution(name='mint')
+        self.factory.makeDistroSeries(
+            distribution=mint, version='1.0', name='dev')
+        supported = self.factory.makeDistroSeries(
+            distribution=mint, version='0.9', name='supported')
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makePackageBranch(
+            distroseries=supported, sourcepackagename='choc', name='tip',
+            owner=eric)
+        suite_sp = self.factory.makeSuiteSourcePackage(
+            distroseries=supported, sourcepackagename='choc',
+            pocket=PackagePublishingPocket.RELEASE)
+        suite_sp_link = ICanHasLinkedBranch(suite_sp)
+
+        registrant = suite_sp.distribution.owner
+        run_with_login(
+            registrant,
+            suite_sp_link.setBranch, branch, registrant)
+
+        self.assertEqual(
+            [suite_sp_link],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('mint/supported/choc', suite_sp),
+             ('~eric/mint/supported/choc/tip', branch)],
+            branch.getBranchIdentities())
+
+    def test_linked_across_project_to_package(self):
+        # If a product branch is linked to a suite source package, the links
+        # are the same as if it was a source package branch.
+        mint = self.factory.makeDistribution(name='mint')
+        self.factory.makeDistroSeries(
+            distribution=mint, version='1.0', name='dev')
+        eric = self.factory.makePerson(name='eric')
+        fooix = self.factory.makeProduct(name='fooix')
+        branch = self.factory.makeProductBranch(
+            product=fooix, owner=eric, name='trunk')
+        dsp = self.factory.makeDistributionSourcePackage('choc', mint)
+        distro_link = ICanHasLinkedBranch(dsp)
+        development_package = dsp.development_version
+        suite_sourcepackage = development_package.getSuiteSourcePackage(
+            PackagePublishingPocket.RELEASE)
+        suite_sp_link = ICanHasLinkedBranch(suite_sourcepackage)
+
+        registrant = suite_sourcepackage.distribution.owner
+        run_with_login(
+            registrant,
+            suite_sp_link.setBranch, branch, registrant)
+
+        self.assertEqual(
+            [distro_link, suite_sp_link],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('mint/choc', dsp),
+             ('mint/dev/choc', suite_sourcepackage),
+             ('~eric/fooix/trunk', branch)],
+            branch.getBranchIdentities())
+
+    def test_junk_branch_links(self):
+        # If a junk branch has links, those links are returned by
+        # getBranchLinks, but getBranchIdentities just returns the branch
+        # unique name.
+        eric = self.factory.makePerson(name='eric')
+        branch = self.factory.makePersonalBranch(owner=eric, name='foo')
+        fooix = removeSecurityProxy(self.factory.makeProduct())
+        linked_branch = ICanHasLinkedBranch(fooix)
+        linked_branch.setBranch(branch)
+        self.assertEqual(
+            [linked_branch, ICanHasLinkedBranch(fooix.development_focus)],
+            branch.getBranchLinks())
+        self.assertEqual(
+            [('~eric/+junk/foo', branch)], branch.getBranchIdentities())
+
 
 class TestBranchDeletion(TestCaseWithFactory):
     """Test the different cases that makes a branch deletable or not."""
@@ -1442,6 +1435,13 @@
         )
         self.branch.destroySelf(break_references=True)
 
+    def test_related_webhooks_deleted(self):
+        webhook = self.factory.makeWebhook(target=self.branch)
+        webhook.ping()
+        self.branch.destroySelf()
+        transaction.commit()
+        self.assertRaises(LostObjectError, getattr, webhook, 'target')
+
 
 class TestBranchDeletionConsequences(TestCase):
     """Test determination and application of branch deletion consequences."""
 
=== modified file 'lib/lp/code/model/tests/test_branchlookup.py'
--- lib/lp/code/model/tests/test_branchlookup.py	2012-11-12 13:38:27 +0000
+++ lib/lp/code/model/tests/test_branchlookup.py	2015-09-29 15:54:57 +0000
@@ -153,7 +153,7 @@
         self.assertEqual((branch, '/foo'), result)
 
 
-class TestGetByPath(TestCaseWithFactory):
+class TestGetByLPPath(TestCaseWithFactory):
     """Test `IBranchLookup.getByLPPath`."""
 
     layer = DatabaseFunctionalLayer
@@ -171,54 +171,51 @@
             self.factory.getUniqueString()
             for i in range(arbitrary_num_segments)])
 
+    def assertMissingPath(self, exctype, path):
+        self.assertRaises(exctype, self.getByPath, path)
+
+    def assertPath(self, expected_branch, expected_suffix, path):
+        branch, suffix = self.getByPath(path)
+        self.assertEqual(expected_branch, branch)
+        self.assertEqual(expected_suffix, suffix)
+
     def test_finds_exact_personal_branch(self):
         branch = self.factory.makePersonalBranch()
-        found_branch, suffix = self.getByPath(branch.unique_name)
-        self.assertEqual(branch, found_branch)
-        self.assertEqual('', suffix)
+        self.assertPath(branch, '', branch.unique_name)
 
     def test_finds_suffixed_personal_branch(self):
         branch = self.factory.makePersonalBranch()
         suffix = self.makeRelativePath()
-        found_branch, found_suffix = self.getByPath(
-            branch.unique_name + '/' + suffix)
-        self.assertEqual(branch, found_branch)
-        self.assertEqual(suffix, found_suffix)
+        self.assertPath(branch, suffix, branch.unique_name + '/' + suffix)
 
     def test_missing_personal_branch(self):
         owner = self.factory.makePerson()
         namespace = get_branch_namespace(owner)
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
-        self.assertRaises(NoSuchBranch, self.getByPath, branch_name)
+        self.assertMissingPath(NoSuchBranch, branch_name)
 
     def test_missing_suffixed_personal_branch(self):
         owner = self.factory.makePerson()
         namespace = get_branch_namespace(owner)
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
         suffix = self.makeRelativePath()
-        self.assertRaises(
-            NoSuchBranch, self.getByPath, branch_name + '/' + suffix)
+        self.assertMissingPath(NoSuchBranch, branch_name + '/' + suffix)
 
     def test_finds_exact_product_branch(self):
         branch = self.factory.makeProductBranch()
-        found_branch, suffix = self.getByPath(branch.unique_name)
-        self.assertEqual(branch, found_branch)
-        self.assertEqual('', suffix)
+        self.assertPath(branch, '', branch.unique_name)
 
     def test_finds_suffixed_product_branch(self):
         branch = self.factory.makeProductBranch()
         suffix = self.makeRelativePath()
-        found_branch, found_suffix = self.getByPath(
-            branch.unique_name + '/' + suffix)
-        self.assertEqual(branch, found_branch)
-        self.assertEqual(suffix, found_suffix)
+        self.assertPath(branch, suffix, branch.unique_name + '/' + suffix)
 
     def test_missing_product_branch(self):
         owner = self.factory.makePerson()
         product = self.factory.makeProduct()
         namespace = get_branch_namespace(owner, product=product)
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
-        self.assertRaises(NoSuchBranch, self.getByPath, branch_name)
+        self.assertMissingPath(NoSuchBranch, branch_name)
 
     def test_missing_suffixed_product_branch(self):
         owner = self.factory.makePerson()
@@ -226,14 +223,11 @@
         namespace = get_branch_namespace(owner, product=product)
         suffix = self.makeRelativePath()
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
-        self.assertRaises(
-            NoSuchBranch, self.getByPath, branch_name + '/' + suffix)
+        self.assertMissingPath(NoSuchBranch, branch_name + '/' + suffix)
 
     def test_finds_exact_package_branch(self):
         branch = self.factory.makePackageBranch()
-        found_branch, suffix = self.getByPath(branch.unique_name)
-        self.assertEqual(branch, found_branch)
-        self.assertEqual('', suffix)
+        self.assertPath(branch, '', branch.unique_name)
 
     def test_missing_package_branch(self):
         owner = self.factory.makePerson()
@@ -243,7 +237,7 @@
             owner, distroseries=distroseries,
             sourcepackagename=sourcepackagename)
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
-        self.assertRaises(NoSuchBranch, self.getByPath, branch_name)
+        self.assertMissingPath(NoSuchBranch, branch_name)
 
     def test_missing_suffixed_package_branch(self):
         owner = self.factory.makePerson()
@@ -254,19 +248,30 @@
             sourcepackagename=sourcepackagename)
         suffix = self.makeRelativePath()
         branch_name = namespace.getBranchName(self.factory.getUniqueString())
-        self.assertRaises(
-            NoSuchBranch, self.getByPath, branch_name + '/' + suffix)
+        self.assertMissingPath(NoSuchBranch, branch_name + '/' + suffix)
 
     def test_too_short(self):
         person = self.factory.makePerson()
-        self.assertRaises(
-            InvalidNamespace, self.getByPath, '~%s' % person.name)
+        self.assertMissingPath(InvalidNamespace, '~%s' % person.name)
 
     def test_no_such_product(self):
         person = self.factory.makePerson()
         branch_name = '~%s/%s/%s' % (
             person.name, self.factory.getUniqueString(), 'branch-name')
-        self.assertRaises(NoSuchProduct, self.getByPath, branch_name)
+        self.assertMissingPath(NoSuchProduct, branch_name)
+
+
+class TestGetByPath(TestGetByLPPath):
+    """Test `IBranchLookup.getByPath`."""
+
+    def getByPath(self, path):
+        return self.branch_lookup.getByPath(path)
+
+    def assertMissingPath(self, exctype, path):
+        self.assertIsNone(self.getByPath(path))
+
+    def assertPath(self, expected_branch, expected_suffix, path):
+        self.assertEqual(expected_branch, self.getByPath(path))
 
 
 class TestGetByUrl(TestCaseWithFactory):
 
=== modified file 'lib/lp/code/model/tests/test_branchset.py'
--- lib/lp/code/model/tests/test_branchset.py	2012-09-18 18:36:09 +0000
+++ lib/lp/code/model/tests/test_branchset.py	2015-09-29 15:54:57 +0000
@@ -10,7 +10,9 @@
 
 from lp.app.enums import InformationType
 from lp.code.interfaces.branch import IBranchSet
+from lp.code.interfaces.linkedbranch import ICanHasLinkedBranch
 from lp.code.model.branch import BranchSet
+from lp.services.propertycache import clear_property_cache
 from lp.testing import (
     login_person,
     logout,
@@ -46,6 +48,16 @@
         branches = BranchSet().getByUrls([url])
         self.assertEqual({url: None}, branches)
 
+    def test_getByPath(self):
+        branch = self.factory.makeProductBranch()
+        self.assertEqual(branch, BranchSet().getByPath(branch.shortened_path))
+        product = removeSecurityProxy(branch.product)
+        ICanHasLinkedBranch(product).setBranch(branch)
+        clear_property_cache(branch)
+        self.assertEqual(product.name, branch.shortened_path)
+        self.assertEqual(branch, BranchSet().getByPath(branch.shortened_path))
+        self.assertIsNone(BranchSet().getByPath('nonexistent'))
+
     def test_api_branches_query_count(self):
         webservice = LaunchpadWebServiceCaller()
         collector = QueryCollector()
 
=== modified file 'lib/lp/code/model/tests/test_branchtarget.py'
--- lib/lp/code/model/tests/test_branchtarget.py	2014-11-28 22:07:05 +0000
+++ lib/lp/code/model/tests/test_branchtarget.py	2015-09-29 15:54:57 +0000
@@ -141,9 +141,9 @@
         # Package branches do support merge proposals.
         self.assertTrue(self.target.supports_merge_proposals)
 
-    def test_supports_short_identites(self):
-        # Package branches do support short bzr identites.
-        self.assertTrue(self.target.supports_short_identites)
+    def test_supports_short_identities(self):
+        # Package branches do support short bzr identities.
+        self.assertTrue(self.target.supports_short_identities)
 
     def test_displayname(self):
         # The display name of a source package target is the display name of
@@ -280,9 +280,9 @@
         # Personal branches do not support merge proposals.
         self.assertFalse(self.target.supports_merge_proposals)
 
-    def test_supports_short_identites(self):
-        # Personal branches do not support short bzr identites.
-        self.assertFalse(self.target.supports_short_identites)
+    def test_supports_short_identities(self):
+        # Personal branches do not support short bzr identities.
+        self.assertFalse(self.target.supports_short_identities)
 
     def test_displayname(self):
         # The display name of a person branch target is ~$USER/+junk.
@@ -405,9 +405,9 @@
         # Product branches do support merge proposals.
         self.assertTrue(self.target.supports_merge_proposals)
 
-    def test_supports_short_identites(self):
-        # Product branches do support short bzr identites.
-        self.assertTrue(self.target.supports_short_identites)
+    def test_supports_short_identities(self):
+        # Product branches do support short bzr identities.
+        self.assertTrue(self.target.supports_short_identities)
 
     def test_displayname(self):
         # The display name of a product branch target is the display name of
 
=== modified file 'lib/lp/codehosting/scanner/bzrsync.py'
--- lib/lp/codehosting/scanner/bzrsync.py	2015-02-25 12:48:27 +0000
+++ lib/lp/codehosting/scanner/bzrsync.py	2015-09-29 15:54:57 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 #
-# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Import version control metadata from a Bazaar branch into the database."""
@@ -34,7 +34,9 @@
 from lp.code.model.revision import Revision
 from lp.codehosting.scanner import events
 from lp.services.config import config
+from lp.services.features import getFeatureFlag
 from lp.services.utils import iter_list_chunks
+from lp.services.webhooks.interfaces import IWebhookSet
 from lp.translations.interfaces.translationtemplatesbuild import (
     ITranslationTemplatesBuildSource,
     )
@@ -323,3 +325,13 @@
 
 def update_recipes(tip_changed):
     tip_changed.db_branch.markRecipesStale()
+
+
+def trigger_webhooks(tip_changed):
+    old_revid = tip_changed.old_tip_revision_id
+    new_revid = tip_changed.new_tip_revision_id
+    if getFeatureFlag("code.bzr.webhooks.enabled") and old_revid != new_revid:
+        payload = tip_changed.composeWebhookPayload(
+            tip_changed.db_branch, old_revid, new_revid)
+        getUtility(IWebhookSet).trigger(
+            tip_changed.db_branch, "bzr:push:0.1", payload)
 
=== modified file 'lib/lp/codehosting/scanner/events.py'
--- lib/lp/codehosting/scanner/events.py	2015-07-08 16:05:11 +0000
+++ lib/lp/codehosting/scanner/events.py	2015-09-29 15:54:57 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Events generated by the scanner."""
@@ -82,6 +82,14 @@
         """The new tip revision id from this scan."""
         return self.bzr_branch.last_revision()
 
+    @staticmethod
+    def composeWebhookPayload(branch, old_revid, new_revid):
+        return {
+            "bzr_branch_path": branch.shortened_path,
+            "old": {"revision_id": old_revid},
+            "new": {"revision_id": new_revid},
+            }
+
 
 class IRevisionsRemoved(IObjectEvent):
     """Revisions have been removed from the branch."""
 
=== modified file 'lib/lp/codehosting/scanner/tests/test_bzrsync.py'
--- lib/lp/codehosting/scanner/tests/test_bzrsync.py	2013-07-04 07:58:00 +0000
+++ lib/lp/codehosting/scanner/tests/test_bzrsync.py	2015-09-29 15:54:57 +0000
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 #
-# Copyright 2009-2012 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 import datetime
@@ -17,6 +17,11 @@
 from fixtures import TempDir
 import pytz
 from storm.locals import Store
+from testtools.matchers import (
+    Equals,
+    MatchesDict,
+    MatchesStructure,
+    )
 from twisted.python.util import mergeFunctionMetadata
 from zope.component import getUtility
 from zope.security.proxy import removeSecurityProxy
@@ -44,6 +49,7 @@
 from lp.codehosting.scanner.bzrsync import BzrSync
 from lp.services.config import config
 from lp.services.database.interfaces import IStore
+from lp.services.features.testing import FeatureFixture
 from lp.services.osutils import override_environ
 from lp.testing import TestCaseWithFactory
 from lp.testing.dbuser import (
@@ -743,6 +749,32 @@
         self.assertEqual(False, recipe.is_stale)
 
 
+class TestTriggerWebhooks(BzrSyncTestCase):
+    """Test triggering of webhooks."""
+
+    def test_triggers_webhooks(self):
+        # On tip change, any relevant webhooks are triggered.
+        self.useFixture(FeatureFixture({"code.bzr.webhooks.enabled": "on"}))
+        self.syncAndCount()
+        old_revid = self.db_branch.last_scanned_id
+        with dbuser(config.launchpad.dbuser):
+            hook = self.factory.makeWebhook(
+                target=self.db_branch, event_types=["bzr:push:0.1"])
+        self.commitRevision()
+        new_revid = self.bzr_branch.last_revision()
+        self.makeBzrSync(self.db_branch).syncBranchAndClose()
+        delivery = hook.deliveries.one()
+        self.assertThat(
+            delivery,
+            MatchesStructure(
+                event_type=Equals("bzr:push:0.1"),
+                payload=MatchesDict({
+                    "bzr_branch_path": Equals(self.db_branch.shortened_path),
+                    "old": Equals({"revision_id": old_revid}),
+                    "new": Equals({"revision_id": new_revid}),
+                    })))
+
+
 class TestRevisionProperty(BzrSyncTestCase):
     """Tests for storting revision properties."""
 
 
=== modified file 'lib/lp/registry/browser/productseries.py'
--- lib/lp/registry/browser/productseries.py	2015-07-15 03:58:56 +0000
+++ lib/lp/registry/browser/productseries.py	2015-09-29 15:54:57 +0000
@@ -417,7 +417,8 @@
     @property
     def long_bzr_identity(self):
         """The bzr identity of the branch including the unique_name."""
-        return self.context.branch.branchIdentities()[-1][0]
+        lp_prefix = config.codehosting.bzr_lp_prefix
+        return lp_prefix + self.context.branch.getBranchIdentities()[-1][0]
 
     @property
     def is_obsolete(self):
 
=== modified file 'lib/lp/services/webhooks/client.py'
--- lib/lp/services/webhooks/client.py	2015-09-01 06:03:55 +0000
+++ lib/lp/services/webhooks/client.py	2015-09-29 15:54:57 +0000
@@ -1,7 +1,7 @@
 # Copyright 2015 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-"""Communication with the Git hosting service."""
+"""Communication with webhook delivery endpoints."""
 
 __metaclass__ = type
 __all__ = [
 
=== modified file 'lib/lp/services/webhooks/interfaces.py'
--- lib/lp/services/webhooks/interfaces.py	2015-09-09 06:11:43 +0000
+++ lib/lp/services/webhooks/interfaces.py	2015-09-29 15:54:57 +0000
@@ -71,13 +71,14 @@
 
 
 WEBHOOK_EVENT_TYPES = {
+    "bzr:push:0.1": "Bazaar push",
     "git:push:0.1": "Git push",
     }
 
 
 @error_status(httplib.UNAUTHORIZED)
 class WebhookFeatureDisabled(Exception):
-    """Only certain users can create new Git repositories."""
+    """Only certain users can create new webhooks."""
 
     def __init__(self):
         Exception.__init__(
 
=== modified file 'lib/lp/services/webhooks/model.py'
--- lib/lp/services/webhooks/model.py	2015-09-09 06:11:43 +0000
+++ lib/lp/services/webhooks/model.py	2015-09-29 15:54:57 +0000
@@ -93,6 +93,9 @@
     git_repository_id = Int(name='git_repository')
     git_repository = Reference(git_repository_id, 'GitRepository.id')
 
+    branch_id = Int(name='branch')
+    branch = Reference(branch_id, 'Branch.id')
+
     registrant_id = Int(name='registrant', allow_none=False)
     registrant = Reference(registrant_id, 'Person.id')
     date_created = DateTime(tzinfo=utc, allow_none=False)
@@ -108,6 +111,8 @@
     def target(self):
         if self.git_repository is not None:
             return self.git_repository
+        elif self.branch is not None:
+            return self.branch
         else:
             raise AssertionError("No target.")
 
@@ -159,10 +164,13 @@
 
     def new(self, target, registrant, delivery_url, event_types, active,
             secret):
+        from lp.code.interfaces.branch import IBranch
         from lp.code.interfaces.gitrepository import IGitRepository
         hook = Webhook()
         if IGitRepository.providedBy(target):
             hook.git_repository = target
+        elif IBranch.providedBy(target):
+            hook.branch = target
         else:
             raise AssertionError("Unsupported target: %r" % (target,))
         hook.registrant = registrant
@@ -184,9 +192,12 @@
         return IStore(Webhook).get(Webhook, id)
 
     def findByTarget(self, target):
+        from lp.code.interfaces.branch import IBranch
         from lp.code.interfaces.gitrepository import IGitRepository
         if IGitRepository.providedBy(target):
             target_filter = Webhook.git_repository == target
+        elif IBranch.providedBy(target):
+            target_filter = Webhook.branch == target
         else:
             raise AssertionError("Unsupported target: %r" % (target,))
         return IStore(Webhook).find(Webhook, target_filter).order_by(
 
=== modified file 'lib/lp/services/webhooks/templates/webhooktarget-webhooks.pt'
--- lib/lp/services/webhooks/templates/webhooktarget-webhooks.pt	2015-08-06 00:46:39 +0000
+++ lib/lp/services/webhooks/templates/webhooktarget-webhooks.pt	2015-09-29 15:54:57 +0000
@@ -18,8 +18,8 @@
       <div>
         <div class="beta" style="display: inline">
           <img class="beta" alt="[BETA]" src="/@@/beta" /></div>
-        The only currently supported events are Git pushes. We'll be
-        rolling out webhooks for more soon.
+        The only currently supported events are Git and Bazaar pushes. We'll
+        be rolling out webhooks for more soon.
       </div>
       <ul class="horizontal">
         <li>
 
=== modified file 'lib/lp/services/webhooks/tests/test_browser.py'
--- lib/lp/services/webhooks/tests/test_browser.py	2015-08-10 05:56:25 +0000
+++ lib/lp/services/webhooks/tests/test_browser.py	2015-09-29 15:54:57 +0000
@@ -27,6 +27,7 @@
 from lp.testing.matchers import HasQueryCount
 from lp.testing.views import create_view
 
+
 breadcrumbs_tag = soupmatchers.Tag(
     'breadcrumbs', 'ol', attrs={'class': 'breadcrumbs'})
 webhooks_page_crumb_tag = soupmatchers.Tag(
@@ -47,12 +48,28 @@
     'batch nav links', 'td', attrs={'class': 'batch-navigation-links'})
 
 
+class GitRepositoryTestHelpers:
+
+    event_type = "git:push:0.1"
+
+    def makeTarget(self):
+        return self.factory.makeGitRepository()
+
+
+class BranchTestHelpers:
+
+    event_type = "bzr:push:0.1"
+
+    def makeTarget(self):
+        return self.factory.makeBranch()
+
+
 class WebhookTargetViewTestHelpers:
 
     def setUp(self):
         super(WebhookTargetViewTestHelpers, self).setUp()
         self.useFixture(FeatureFixture({'webhooks.new.enabled': 'true'}))
-        self.target = self.factory.makeGitRepository()
+        self.target = self.makeTarget()
         self.owner = self.target.owner
         login_person(self.owner)
 
@@ -65,7 +82,7 @@
         return view
 
 
-class TestWebhooksView(WebhookTargetViewTestHelpers, TestCaseWithFactory):
+class TestWebhooksViewBase(WebhookTargetViewTestHelpers):
 
     layer = DatabaseFunctionalLayer
 
@@ -125,7 +142,19 @@
         self.assertThat(recorder2, HasQueryCount(Equals(recorder1.count)))
 
 
-class TestWebhookAddView(WebhookTargetViewTestHelpers, TestCaseWithFactory):
+class TestWebhooksViewGitRepository(
+    TestWebhooksViewBase, GitRepositoryTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhooksViewBranch(
+    TestWebhooksViewBase, BranchTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhookAddViewBase(WebhookTargetViewTestHelpers):
 
     layer = DatabaseFunctionalLayer
 
@@ -150,7 +179,7 @@
             form={
                 "field.delivery_url": "http://example.com/test",
                 "field.active": "on", "field.event_types-empty-marker": "1",
-                "field.event_types": "git:push:0.1",
+                "field.event_types": self.event_type,
                 "field.actions.new": "Add webhook"})
         self.assertEqual([], view.errors)
         hook = self.target.webhooks.one()
@@ -161,7 +190,7 @@
                 registrant=self.owner,
                 delivery_url="http://example.com/test",
                 active=True,
-                event_types=["git:push:0.1"]))
+                event_types=[self.event_type]))
 
     def test_rejects_bad_scheme(self):
         transaction.commit()
@@ -176,12 +205,24 @@
         self.assertIs(None, self.target.webhooks.one())
 
 
+class TestWebhookAddViewGitRepository(
+    TestWebhookAddViewBase, GitRepositoryTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhookAddViewBranch(
+    TestWebhookAddViewBase, BranchTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
 class WebhookViewTestHelpers:
 
     def setUp(self):
         super(WebhookViewTestHelpers, self).setUp()
         self.useFixture(FeatureFixture({'webhooks.new.enabled': 'true'}))
-        self.target = self.factory.makeGitRepository()
+        self.target = self.makeTarget()
         self.owner = self.target.owner
         self.webhook = self.factory.makeWebhook(
             target=self.target, delivery_url=u'http://example.com/original')
@@ -196,7 +237,7 @@
         return view
 
 
-class TestWebhookView(WebhookViewTestHelpers, TestCaseWithFactory):
+class TestWebhookViewBase(WebhookViewTestHelpers):
 
     layer = DatabaseFunctionalLayer
 
@@ -249,7 +290,19 @@
                 event_types=[]))
 
 
-class TestWebhookDeleteView(WebhookViewTestHelpers, TestCaseWithFactory):
+class TestWebhookViewGitRepository(
+    TestWebhookViewBase, GitRepositoryTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhookViewBranch(
+    TestWebhookViewBase, BranchTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhookDeleteViewBase(WebhookViewTestHelpers):
 
     layer = DatabaseFunctionalLayer
 
@@ -281,3 +334,15 @@
             form={"field.actions.delete": "Delete webhook"})
         self.assertEqual([], view.errors)
         self.assertIs(None, self.target.webhooks.one())
+
+
+class TestWebhookDeleteViewGitRepository(
+    TestWebhookDeleteViewBase, GitRepositoryTestHelpers, TestCaseWithFactory):
+
+    pass
+
+
+class TestWebhookDeleteViewBranch(
+    TestWebhookDeleteViewBase, BranchTestHelpers, TestCaseWithFactory):
+
+    pass
 
=== modified file 'lib/lp/services/webhooks/tests/test_model.py'
--- lib/lp/services/webhooks/tests/test_model.py	2015-08-10 07:36:52 +0000
+++ lib/lp/services/webhooks/tests/test_model.py	2015-09-29 15:54:57 +0000
@@ -115,17 +115,17 @@
             expected_set_permissions, checker.set_permissions, 'set')
 
 
-class TestWebhookSet(TestCaseWithFactory):
+class TestWebhookSetBase:
 
     layer = DatabaseFunctionalLayer
 
     def test_new(self):
-        target = self.factory.makeGitRepository()
+        target = self.makeTarget()
         login_person(target.owner)
         person = self.factory.makePerson()
         hook = getUtility(IWebhookSet).new(
-            target, person, u'http://path/to/something', ['git:push'], True,
-            u'sekrit')
+            target, person, u'http://path/to/something', [self.event_type],
+            True, u'sekrit')
         Store.of(hook).flush()
         self.assertEqual(target, hook.target)
         self.assertEqual(person, hook.registrant)
@@ -134,7 +134,7 @@
         self.assertEqual(u'http://path/to/something', hook.delivery_url)
         self.assertEqual(True, hook.active)
         self.assertEqual(u'sekrit', hook.secret)
-        self.assertEqual(['git:push'], hook.event_types)
+        self.assertEqual([self.event_type], hook.event_types)
 
     def test_getByID(self):
         hook1 = self.factory.makeWebhook()
@@ -148,8 +148,8 @@
                 None, getUtility(IWebhookSet).getByID(1234))
 
     def test_findByTarget(self):
-        target1 = self.factory.makeGitRepository()
-        target2 = self.factory.makeGitRepository()
+        target1 = self.makeTarget()
+        target2 = self.makeTarget()
         for target, name in ((target1, 'one'), (target2, 'two')):
             for i in range(3):
                 self.factory.makeWebhook(
@@ -168,7 +168,7 @@
                 getUtility(IWebhookSet).findByTarget(target2)])
 
     def test_delete(self):
-        target = self.factory.makeGitRepository()
+        target = self.makeTarget()
         login_person(target.owner)
         hooks = []
         for i in range(3):
@@ -195,21 +195,21 @@
 
     def test_trigger(self):
         owner = self.factory.makePerson()
-        target1 = self.factory.makeGitRepository(owner=owner)
-        target2 = self.factory.makeGitRepository(owner=owner)
+        target1 = self.makeTarget(owner=owner)
+        target2 = self.makeTarget(owner=owner)
         hook1a = self.factory.makeWebhook(
             target=target1, event_types=[])
         hook1b = self.factory.makeWebhook(
-            target=target1, event_types=['git:push:0.1'])
+            target=target1, event_types=[self.event_type])
         hook2a = self.factory.makeWebhook(
-            target=target2, event_types=['git:push:0.1'])
+            target=target2, event_types=[self.event_type])
         hook2b = self.factory.makeWebhook(
-            target=target2, event_types=['git:push:0.1'], active=False)
+            target=target2, event_types=[self.event_type], active=False)
 
         # Only webhooks subscribed to the relevant target and event type
         # are triggered.
         getUtility(IWebhookSet).trigger(
-            target1, 'git:push:0.1', {'some': 'payload'})
+            target1, self.event_type, {'some': 'payload'})
         with admin_logged_in():
             self.assertThat(list(hook1a.deliveries), HasLength(0))
             self.assertThat(list(hook1b.deliveries), HasLength(1))
@@ -220,7 +220,7 @@
 
         # Disabled webhooks aren't triggered.
         getUtility(IWebhookSet).trigger(
-            target2, 'git:push:0.1', {'other': 'payload'})
+            target2, self.event_type, {'other': 'payload'})
         with admin_logged_in():
             self.assertThat(list(hook1a.deliveries), HasLength(0))
             self.assertThat(list(hook1b.deliveries), HasLength(1))
@@ -228,3 +228,19 @@
             self.assertThat(list(hook2b.deliveries), HasLength(0))
             delivery = hook2a.deliveries.one()
             self.assertEqual(delivery.payload, {'other': 'payload'})
+
+
+class TestWebhookSetGitRepository(TestWebhookSetBase, TestCaseWithFactory):
+
+    event_type = 'git:push:0.1'
+
+    def makeTarget(self, owner=None):
+        return self.factory.makeGitRepository(owner=owner)
+
+
+class TestWebhookSetBranch(TestWebhookSetBase, TestCaseWithFactory):
+
+    event_type = 'bzr:push:0.1'
+
+    def makeTarget(self, owner=None):
+        return self.factory.makeBranch(owner=owner)
 
=== modified file 'lib/lp/services/webhooks/tests/test_webservice.py'
--- lib/lp/services/webhooks/tests/test_webservice.py	2015-09-09 06:11:43 +0000
+++ lib/lp/services/webhooks/tests/test_webservice.py	2015-09-29 15:54:57 +0000
@@ -260,12 +260,12 @@
         self.assertIs(None, representation['date_first_sent'])
 
 
-class TestWebhookTarget(TestCaseWithFactory):
+class TestWebhookTargetBase:
     layer = DatabaseFunctionalLayer
 
     def setUp(self):
-        super(TestWebhookTarget, self).setUp()
-        self.target = self.factory.makeGitRepository()
+        super(TestWebhookTargetBase, self).setUp()
+        self.target = self.makeTarget()
         self.owner = self.target.owner
         self.target_url = api_url(self.target)
         self.webservice = webservice_for_person(
@@ -309,13 +309,13 @@
         response = self.webservice.named_post(
             self.target_url, 'newWebhook',
             delivery_url='http://example.com/ep',
-            event_types=['git:push:0.1'], api_version='devel')
+            event_types=[self.event_type], api_version='devel')
         self.assertEqual(201, response.status)
 
         representation = self.webservice.get(
             self.target_url + '/webhooks', api_version='devel').jsonBody()
         self.assertContentEqual(
-            [('http://example.com/ep', ['git:push:0.1'], True)],
+            [('http://example.com/ep', [self.event_type], True)],
             [(entry['delivery_url'], entry['event_types'], entry['active'])
              for entry in representation['entries']])
 
@@ -323,8 +323,9 @@
         self.useFixture(FeatureFixture({'webhooks.new.enabled': 'true'}))
         response = self.webservice.named_post(
             self.target_url, 'newWebhook',
-            delivery_url='http://example.com/ep', event_types=['git:push:0.1'],
-            secret='sekrit', api_version='devel')
+            delivery_url='http://example.com/ep',
+            event_types=[self.event_type], secret='sekrit',
+            api_version='devel')
         self.assertEqual(201, response.status)
 
         # The secret is set, but cannot be read back through the API.
@@ -339,16 +340,33 @@
         webservice = LaunchpadWebServiceCaller()
         response = webservice.named_post(
             self.target_url, 'newWebhook',
-            delivery_url='http://example.com/ep', event_types=['git:push:0.1'],
-            api_version='devel')
+            delivery_url='http://example.com/ep',
+            event_types=[self.event_type], api_version='devel')
         self.assertEqual(401, response.status)
         self.assertIn('launchpad.Edit', response.body)
 
     def test_newWebhook_feature_flag_guard(self):
         response = self.webservice.named_post(
             self.target_url, 'newWebhook',
-            delivery_url='http://example.com/ep', event_types=['git:push:0.1'],
-            api_version='devel')
+            delivery_url='http://example.com/ep',
+            event_types=[self.event_type], api_version='devel')
         self.assertEqual(401, response.status)
         self.assertEqual(
             'This webhook feature is not available yet.', response.body)
+
+
+class TestWebhookTargetGitRepository(
+    TestWebhookTargetBase, TestCaseWithFactory):
+
+    event_type = 'git:push:0.1'
+
+    def makeTarget(self):
+        return self.factory.makeGitRepository()
+
+
+class TestWebhookTargetBranch(TestWebhookTargetBase, TestCaseWithFactory):
+
+    event_type = 'bzr:push:0.1'
+
+    def makeTarget(self):
+        return self.factory.makeBranch()