Merge lp:~michael.nelson/rnr-server/731736-other-origins into lp:rnr-server

[Michael Nelson]

[r=zematynnad][bug=731376] Enable reviews of packages in partner and extras.

Overview
========

This branch is fixing bug 731376 by enabling reviews for origins other than 'ubuntu'.

To test: follow the README and then `make test`

This branch will not land until the next one, dealing with the issue identified below, is ready.

Details for the next branch
===========================
The main issue is verifying the origin for a new review when we don't yet have a record of that origin.

For 'ubuntu' and 'canonical' it is simple enough - we can use the LP API to verify that a binary with the given package name is published in the repository for the distroseries and arch. For extras it's also possible to verify (differently) using the API.

But we cannot generalise the origin for public PPAs currently, as the published origin is ambiguous (I created bug 733170). So I've just left that for the moment.

For the commercial PPAs, we cannot verify that the specified origin is correct, as LP doesn't let us query private PPAs for binaries :). So currently (in this branch) submitting a review for 'linux' in the fluendo-dvd origin would work, as would submitting a review for 'vendetta-online' in the fluendo-dvd origin, as would 'fluendo-dvd' in the correct origin, but with 'hoary' as the distroseries etc.

Sooo, we need a solution. The solutions I can think of are:
 1) Pull and cache the staging/production sca available apps to get the data (currently this will also pull the icons, but we could later add a separate url on sca for just the data we need, if necessary)
 2) (Temporary solution): Encode the binary publishings (ie. ppa-name, arch, distroseries) for each of the commercial apps in the settings (and update settings each time a new app is added).
...
So I'll probably go ahead with 1 (Update: checked with achuni and he agrees).

[Danny Tamez (zematynnad)]

Michael - great works as always. Approved but what would you think of adding a test that is the negative test for "test_create_repository_and_software_item"? As it would be good to also test that when lp returns False that the item and repo are not created.

review: Approve

[Michael Nelson (michael.nelson)]

On Mon, Mar 14, 2011 at 6:46 PM, Danny Tamez <email address hidden>wrote:

> Review: Approve
> Michael - great works as always. Approved but what would you think of
> adding a test that is the negative test for
> "test_create_repository_and_software_item"? As it would be good to also
> test that when lp returns False that the item and repo are not created.
>

Yeah - good find... I'll add the test.

Thanks again!
M

[lp:~michael.nelson/rnr-server/731736-other-origins]

154. By Michael Nelson on 2011-03-15

Added test ensuring new repositories are not created when lp_verify returns false.

=== modified file 'django_project/config_dev/config/main.cfg'
--- django_project/config_dev/config/main.cfg	2011-03-11 21:09:10 +0000
+++ django_project/config_dev/config/main.cfg	2011-03-15 09:36:33 +0000
@@ -98,6 +98,14 @@
 cache_review_stats_seconds = 14400
 token_cache_expiry_hours = 4
 reviewsapp_media_root = src/reviewsapp/media
+commercial_origins = lp-ppa-commercial-ppa-uploaders-fluendo-dvd
+                     lp-ppa-commercial-ppa-uploaders-fluendo-plugins
+                     lp-ppa-commercial-ppa-uploaders-fluendo-wmv-plugins
+                     lp-ppa-commercial-ppa-uploaders-brukkon
+                     lp-ppa-commercial-ppa-uploaders-vendetta-online
+                     lp-ppa-commercial-ppa-uploaders-world-of-goo
+                     lp-ppa-commercial-ppa-uploaders-illumination
+
 
 [sso_api]
 sso_api_service_root = https://login.staging.ubuntu.com/api/1.0
 
=== modified file 'django_project/config_dev/schema.py'
--- django_project/config_dev/schema.py	2011-03-10 22:56:54 +0000
+++ django_project/config_dev/schema.py	2011-03-15 09:36:33 +0000
@@ -56,6 +56,7 @@
     rnr.token_cache_expiry_hours = IntConfigOption(default=4)
     rnr.reviewsapp_media_root = StringConfigOption()
     rnr.allow_multiple_reviews_for_testing = BoolConfigOption(default=False)
+    rnr.commercial_origins = LinesConfigOption(item=StringConfigOption())
 
     # Launchpad
     launchpad = ConfigSection()
 
=== modified file 'src/reviewsapp/api/handlers.py'
--- src/reviewsapp/api/handlers.py	2011-03-01 12:24:51 +0000
+++ src/reviewsapp/api/handlers.py	2011-03-15 09:36:33 +0000
@@ -80,7 +80,7 @@
 
 class RetrieveReviewHandler(BaseHandler):
     allowed_methods = ('GET',)
-    
+
     def read(self, request, review_id):
         try:
             review = Review.objects.get(id=review_id)
@@ -95,6 +95,8 @@
         'id',
         'package_name',
         'app_name',
+        'origin',
+        'distroseries',
         'language',
         'date_created',
         'rating',
 
=== modified file 'src/reviewsapp/forms.py'
--- src/reviewsapp/forms.py	2011-03-09 11:45:47 +0000
+++ src/reviewsapp/forms.py	2011-03-15 09:36:33 +0000
@@ -88,8 +88,7 @@
         if not self.is_valid():
             return self.cleaned_data
 
-        self._validate_and_populate_software_item()
-        self._validate_and_populate_repository()
+        self._validate_software_item_and_repository()
 
         if not settings.ALLOW_MULTIPLE_REVIEWS_FOR_TESTING:
             # Ensure a user cannot submit a second review for the same app
@@ -117,52 +116,60 @@
         self.cleaned_data['architecture'] = architecture
         return arch_tag
 
-    def _validate_and_populate_software_item(self):
-        """Add the software item to the cleaned data, creating if necessary.
+    def _validate_software_item_and_repository(self):
+        """Add the software item and repository to the cleaned data.
+
+        If they do not exist in the db, we check the validity and
+        create them if they are valid.
         """
         package_name = self.cleaned_data['package_name']
         app_name = self.cleaned_data['app_name']
+        origin = self.cleaned_data['origin']
         distroseries = self.cleaned_data['distroseries']
         arch_tag=self.cleaned_data['arch_tag']
-        review_count = Review.objects.filter(
-            softwareitem__package_name=package_name,
-            softwareitem__app_name=app_name,
-            repository__distroseries=distroseries,
-            architecture__tag=arch_tag).count()
-        if review_count == 0:
-            # This is the first review for this software_item and distroseries
-            if not WebServices().lp_verify_packagename_in_distro(
-                package_name, distroseries, arch_tag=arch_tag):
+
+        require_lp_check = False
+        repository = None
+        # First we grab the repository - if it exists.
+        try:
+            repository = Repository.objects.get(
+                origin=origin, distroseries=distroseries)
+        except Repository.DoesNotExist:
+            require_lp_check = True
+
+        if repository is not None:
+            # Check whether there are any existing reviews for this
+            # software in the repository with the given arch.
+            review_count = Review.objects.filter(
+                softwareitem__package_name=package_name,
+                softwareitem__app_name=app_name,
+                repository=repository,
+                architecture__tag=arch_tag).count()
+            if review_count == 0:
+                # This is the first review for this software_item in the
+                # repository with the given arch.
+                require_lp_check = True
+
+        if require_lp_check:
+            valid_in_lp = WebServices().lp_verify_packagename_in_repository(
+                package_name, origin, distroseries, arch_tag=arch_tag)
+
+            if not valid_in_lp:
                 raise forms.ValidationError(
-                    ': package {0} not in {1} for {2}'.format(
-                    package_name, distroseries, arch_tag))
+                    ': package {0} not in {1} {2} for {2}'.format(
+                        package_name, origin, distroseries, arch_tag))
+
+        # Now we know the given data corresponds to a published binary
+        # on launchpad, so we can populate the cleaned data, creating
+        # the repository and software_item records if necessary.
+        repository = repository or Repository.objects.create(
+            origin=origin, distroseries=distroseries)
+        self.cleaned_data['repository'] = repository
+
         software_item, created = SoftwareItem.objects.get_or_create(
             package_name=package_name, app_name=app_name)
-
         self.cleaned_data['software_item'] = software_item
 
-    def _validate_and_populate_repository(self):
-        """Add the repository to the cleaned data, creating if necessary."""
-        # Find the origin/distroseries for the software item.
-        origin = self.cleaned_data['origin']
-        distroseries = self.cleaned_data['distroseries']
-        try:
-            repository = Repository.objects.get(
-                origin=origin,
-                distroseries=distroseries)
-        except Repository.DoesNotExist:
-            # The software repository does not yet exist, probably because
-            # this is the first review for this origin/distroseries.  That's
-            # okay, create a record for it in our database.
-            #
-            # XXX 2010-03-03 bug=688043 Verify with Launchpad first.
-            repository = Repository(
-                origin=origin,
-                distroseries=distroseries)
-            repository.save()
-
-        self.cleaned_data['repository'] = repository
-
 
 class ReviewModerationFilterForm(forms.Form):
     """Filtering options for review moderation list."""
 
=== modified file 'src/reviewsapp/models/reviews.py'
--- src/reviewsapp/models/reviews.py	2011-03-09 08:27:34 +0000
+++ src/reviewsapp/models/reviews.py	2011-03-15 09:36:33 +0000
@@ -270,6 +270,12 @@
     def app_name(self):
         return self.softwareitem.app_name
 
+    def origin(self):
+        return self.repository.origin
+
+    def distroseries(self):
+        return self.repository.distroseries
+
     def package_app_name(self):
         app_name = self.app_name()
         if app_name:
 
=== modified file 'src/reviewsapp/tests/test_handlers.py'
--- src/reviewsapp/tests/test_handlers.py	2011-03-09 11:49:10 +0000
+++ src/reviewsapp/tests/test_handlers.py	2011-03-15 09:36:33 +0000
@@ -51,6 +51,7 @@
     SubmitUsefulnessHandler,
 )
 from reviewsapp.models import (
+    Repository,
     Review,
     ReviewModerationFlag,
     SoftwareItem,
@@ -475,7 +476,7 @@
         }
         super(SubmitReviewHandlerTestCase, self).setUp()
 
-    def _post_new_review(self, data, user=None):
+    def _post_new_review(self, data, user=None, lp_verify_result=True):
         # Post a review as an authenticated user.
         url = reverse('rnr-api-reviews')
 
@@ -485,11 +486,11 @@
 
         is_authed_fn = 'reviewsapp.auth.SSOOAuthAuthentication.is_authenticated'
         lp_verify_fn = ('reviewsapp.utilities.WebServices.'
-                        'lp_verify_packagename_in_distro')
+                        'lp_verify_packagename_in_repository')
         with patch(is_authed_fn) as mock_is_authenticated:
             mock_is_authenticated.return_value = True
             with patch(lp_verify_fn) as mock_lp_verify_method:
-                mock_lp_verify_method.return_value = True
+                mock_lp_verify_method.return_value = lp_verify_result
                 response = self.client.post(
                     url, data=data, content_type='application/json')
         return response
@@ -520,6 +521,44 @@
         response_dict = simplejson.loads(response.content)
         self.assertEqual('inkscape', response_dict['package_name'])
 
+    def test_creates_repository_and_software_item(self):
+        # Submitting a review for a software item or repository of which
+        # we don't yet have a record will create those records (after
+        # validating that the corresponding binary exists on Launchpad).
+        required_data = self.required_data
+        required_data['distroseries'] = 'doesntexist'
+        self.assertEqual(0, Repository.objects.filter(
+            origin='ubuntu', distroseries='doesntexist').count())
+        self.assertEqual(0, SoftwareItem.objects.filter(
+            package_name='inkscape').count())
+
+        response = self._post_new_review(simplejson.dumps(self.required_data))
+
+        self.assertEqual(1, Repository.objects.filter(
+            origin='ubuntu', distroseries='doesntexist').count())
+        self.assertEqual(1, SoftwareItem.objects.filter(
+            package_name='inkscape').count())
+
+    def test_bad_repository(self):
+        # If lp_verify returns false a bad request status is returned,
+        # and no new repositories are created.
+        required_data = self.required_data
+        required_data['distroseries'] = 'doesntexist'
+        self.assertEqual(0, Repository.objects.filter(
+            origin='ubuntu', distroseries='doesntexist').count())
+        self.assertEqual(0, SoftwareItem.objects.filter(
+            package_name='inkscape').count())
+
+        response = self._post_new_review(
+            simplejson.dumps(self.required_data), lp_verify_result=False)
+
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code)
+        self.assertEqual(0, Repository.objects.filter(
+            origin='ubuntu', distroseries='doesntexist').count())
+        self.assertEqual(0, SoftwareItem.objects.filter(
+            package_name='inkscape').count())
+
+
     def test_max_length_summary(self):
         # Posting with a summary > 80 chars results in a bad request.
         data = self.required_data
 
=== modified file 'src/reviewsapp/tests/test_rnrclient.py'
--- src/reviewsapp/tests/test_rnrclient.py	2011-03-09 08:27:34 +0000
+++ src/reviewsapp/tests/test_rnrclient.py	2011-03-15 09:36:33 +0000
@@ -154,6 +154,8 @@
                          reviews[0].reviewer_username)
         self.assertEqual(review.reviewer_displayname(),
                          reviews[0].reviewer_displayname)
+        self.assertEqual(review.origin(), reviews[0].origin)
+        self.assertEqual(review.distroseries(), reviews[0].distroseries)
 
     def test_get_reviews_for_app(self):
         software_item = self.factory.makeSoftwareItem(app_name='something')
@@ -202,9 +204,11 @@
         review = self.factory.makeReview()
 
         api = RatingsAndReviewsAPI()
-        review_request = api.get_review(review_id=review.id)
+        review_detail = api.get_review(review_id=review.id)
 
-        self.assertEqual(review_request.id, review.id)
+        self.assertEqual(review_detail.id, review.id)
+        self.assertEqual(review_detail.origin, review.origin())
+        self.assertEqual(review_detail.distroseries, review.distroseries())
         invalidate_paginated_reviews_for(review)
 
 
@@ -222,7 +226,8 @@
         auth = OAuthAuthorizer(token.token, token.token_secret, consumer.key,
             consumer.secret)
         lp_verify_packagename_method = (
-            'reviewsapp.utilities.WebServices.lp_verify_packagename_in_distro')
+            'reviewsapp.utilities.WebServices.'
+            'lp_verify_packagename_in_repository')
 
         if mock_verify_package is None:
             mock_verify_package = Mock()
 
=== modified file 'src/reviewsapp/tests/test_utilities.py'
--- src/reviewsapp/tests/test_utilities.py	2011-03-10 22:56:54 +0000
+++ src/reviewsapp/tests/test_utilities.py	2011-03-15 09:36:33 +0000
@@ -100,58 +100,135 @@
 class LaunchpadTestCase(TestCaseWithFactory):
     def setUp(self):
         super(LaunchpadTestCase, self).setUp()
-        self._request = HttpRequest()
-        self._request.user = self.factory.makeUser()
-        self.binary = Mock()
-        self.mock_lp = Mock()
-        archive = self.mock_lp.load.return_value
-        archive.getPublishedBinaries.return_value = [self.binary]
-        self.client.login(username=self._request.user.username, password='test')
         # Force web_services to recreate the the Launchpad service root
         WebServices._launchpad_service = None
 
-    @patch('reviewsapp.utilities.Launchpad')
-    def test_valid_package(self, mock_launchpad):
-        # A valid package in a distroseries can be found.
-        mock_launchpad.login_anonymously.return_value = self.mock_lp
-        self.binary.binary_package_name = 'apt'
-        ws = WebServices()
-
-        self.assertTrue(ws.lp_verify_packagename_in_distro("apt", "lucid",
-                                                           'i386'))
-
-    @patch('reviewsapp.utilities.Launchpad')
-    def test_invalid_distro(self, mock_launchpad):
-        # Invalid distroseries (assuming we never call a release 'xxx') cannot
-        # be found.
-        mock_launchpad.login_anonymously.return_value = self.mock_lp
+    def _make_mock_launchpad(self, binary_name='mypkg'):
+        mock_ubuntu = Mock()
+        mock_ubuntu.self_link = 'http://lpapi/ubuntu'
+
+        mock_launchpad = Mock()
+        mock_launchpad.distributions =  dict(ubuntu=mock_ubuntu)
+        app_review_board = Mock()
+        mock_launchpad.people = {'app-review-board': app_review_board}
+
+        mock_archive = Mock()
+        mock_ubuntu.getArchive.return_value = mock_archive
+        app_review_board.getPPAByName.return_value = mock_archive
+
+        mock_binary = Mock()
+        mock_binary.binary_package_name = binary_name
+        mock_archive.getPublishedBinaries.return_value = [mock_binary]
+        return (mock_launchpad, mock_ubuntu, mock_archive)
+
+    def _verify_package(self, mock_lp_api, package_name,
+        distro, series, arch_tag):
+        with patch('reviewsapp.utilities.Launchpad') as mock_launchpad:
+            mock_launchpad.login_anonymously.return_value = mock_lp_api
+            return WebServices().lp_verify_packagename_in_repository(
+                package_name, distro, series, arch_tag)
+
+    def test_package_in_ubuntu(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+
+        result = self._verify_package(lp_api, 'mypkg', 'ubuntu', 'lucid',
+            'i386')
+
+        ubuntu.getArchive.assert_called_with(name='primary')
+        archive.getPublishedBinaries.assert_called_with(
+            binary_name='mypkg',
+            distro_arch_series='http://lpapi/ubuntu/lucid/i386',
+            status='Published', exact_match=True)
+        self.assertTrue(result)
+
+    def test_package_not_in_ubuntu(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad(
+            binary_name='other_pkg')
+
+        result = self._verify_package(lp_api, 'mypkg', 'ubuntu', 'lucid',
+            'i386')
+
+        ubuntu.getArchive.assert_called_with(name='primary')
+        archive.getPublishedBinaries.assert_called_with(
+            binary_name='mypkg',
+            distro_arch_series='http://lpapi/ubuntu/lucid/i386',
+            status='Published', exact_match=True)
+        self.assertFalse(result)
+
+    def test_package_in_partner(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+
+        result = self._verify_package(lp_api, 'mypkg', 'canonical', 'lucid',
+            'i386')
+
+        ubuntu.getArchive.assert_called_with(name='partner')
+        archive.getPublishedBinaries.assert_called_with(
+            binary_name='mypkg',
+            distro_arch_series='http://lpapi/ubuntu/lucid/i386',
+            status='Published', exact_match=True)
+        self.assertTrue(result)
+
+    def test_package_in_extras(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+
+        result = self._verify_package(lp_api, 'mypkg',
+            'lp-ppa-app-review-board', 'lucid', 'i386')
+
+        app_review_board = lp_api.people['app-review-board']
+        app_review_board.getPPAByName.assert_called_with(name='ppa')
+        archive.getPublishedBinaries.assert_called_with(
+            binary_name='mypkg',
+            distro_arch_series='http://lpapi/ubuntu/lucid/i386',
+            status='Published', exact_match=True)
+        self.assertTrue(result)
+
+    def test_commercial_package(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+
+        with patch_settings(COMMERCIAL_ORIGINS=['lp-ppa-commercial-one']):
+            result = self._verify_package(lp_api, 'anything',
+                'lp-ppa-commercial-one', 'anything', 'anything')
+
+        # XXX The result should not always be true... we need a way to
+        # know the content of commercial ppas.
+        self.assertTrue(result)
+
+    def test_unknown_origin(self):
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+
+        result = self._verify_package(lp_api, 'mypkg',
+            'lp-ppa-unknown', 'lucid', 'i386')
+
+        # Currently we only support primary, partner, extras and the
+        # specified commercial origins.
+        self.assertEqual(0, archive.getPublishedBinaries.call_count)
+        self.assertFalse(result)
+
+    def test_invalid_series_or_arch(self):
+        # An invalid series or arch raises a 400 Bad Request.
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
         response = Mock()
-        response.status = 404
-        mock_launchpad.load.side_effect = HTTPError(response, 'content')
-        ws = WebServices()
-
-        self.assertFalse(ws.lp_verify_packagename_in_distro("apt", "xxx",
-                                                            'i386'))
-
-    @patch('reviewsapp.utilities.Launchpad')
-    def test_invalid_package(self, mock_launchpad):
-        # Invalid package (assuming no one creates such a package) in a valid
-        # distroseries cannot be found.
-        mock_launchpad.login_anonymously.return_value = self.mock_lp
-        ws = WebServices()
-
-        self.assertFalse(ws.lp_verify_packagename_in_distro(
-            "***xxx***", "lucid", 'i386'))
+        response.status = 400
+        archive.getPublishedBinaries.side_effect = HTTPError(
+            response, 'content')
+
+        result = self._verify_package(lp_api, 'mypkg', 'ubuntu', 'lucid',
+            'i386')
+
+        self.assertFalse(result)
 
     @patch('reviewsapp.utilities.Launchpad')
     def test_doesnt_sign_in_each_time(self, mock_launchpad):
-        mock_launchpad.login_anonymously.return_value = self.mock_lp
+        lp_api, ubuntu, archive = self._make_mock_launchpad()
+        mock_launchpad.login_anonymously.return_value = lp_api
         ws = WebServices()
-        ws.lp_verify_packagename_in_distro("foobar", "lucid", 'i386')
+        ws.lp_verify_packagename_in_repository("foobar", 'ubuntu',
+                                               "lucid", 'i386')
         self.assertTrue(mock_launchpad.login_anonymously.called)
         mock_launchpad.login_anonymously.reset_mock()
 
-        ws.lp_verify_packagename_in_distro("foobar", "lucid", 'i386')
+        ws.lp_verify_packagename_in_repository("foobar", 'ubuntu',
+                                               "lucid", 'i386')
 
         self.assertFalse(mock_launchpad.login_anonymously.called)
 
@@ -163,8 +240,8 @@
             del os.environ['HOME']
         ws = WebServices()
         # SyntaxError is raised when we fail to parse our dummy wadl
-        self.assertRaises(SyntaxError, ws.lp_verify_packagename_in_distro,
-            "foobar", "lucid", 'i386')
+        self.assertRaises(SyntaxError, ws.lp_verify_packagename_in_repository,
+            "foobar", "ubuntu", "lucid", 'i386')
 
 
 class InvalidatePaginatedReviewsTestCase(TestCaseWithFactory):
 
=== modified file 'src/reviewsapp/utilities.py'
--- src/reviewsapp/utilities.py	2011-03-10 11:02:01 +0000
+++ src/reviewsapp/utilities.py	2011-03-15 09:36:33 +0000
@@ -157,33 +157,62 @@
             result.update(api.accounts.me())
         return result
 
-    def lp_verify_packagename_in_distro(self, pkgname, distroseries,
-                                        arch_tag):
+    def lp_verify_packagename_in_repository(self, pkgname, origin, distroseries,
+                                            arch_tag):
         """Verify that a given package exists in a distroseries.
 
         :param pkgname: The name of the package to check.
+        :param origin: The repository origin identifier.
         :param distroseries: The name of distribution series.
         :param arch_tag: The machine architecture (i386, amd64...)
         :return: Whether the package was found or not.
         :rtype: bool
         """
-        # FIXME: is there a better way to get the root_uri from LP?
-        ubuntu_uri = str(self.launchpad_service._root_uri) + "ubuntu/"
+        ubuntu = self.launchpad_service.distributions['ubuntu']
+        if origin == 'ubuntu':
+            archive = ubuntu.getArchive(name='primary')
+        elif origin == 'canonical':
+            archive = ubuntu.getArchive(name='partner')
+        elif origin =='lp-ppa-app-review-board':
+            app_review_board = self.launchpad_service.people[
+                'app-review-board']
+            archive = app_review_board.getPPAByName(name='ppa')
+        elif origin in settings.COMMERCIAL_ORIGINS:
+            # XXX 2011-03-11 michaeln bug=733170 PPA origins are
+            # currently ambiguous.
+            # We should check this in a way that doesn't require
+            # settings, either pulling the data from SCA, or request
+            # that LP updates IArchive to allow public access to
+            # getPublishedBinaries() for commercial PPAs (but not
+            # private-only).
+            # XXX - chat with achuni about options - dict in settings?
+            # Perhaps for now just a non-configglue setting with a
+            # complex dict:
+            # 'lp-ppa-commercial-ppa-uploaders-fluendo-dvd': {
+            #      'package_name': 'fluendo-dvd',
+            #       'releases': {
+            #           'natty': ['i386', 'amd64'],
+            #           ...
+            # And then we can make this available on SCA as json/api.
+            return True
+        else:
+            return False
+
+        # We now have the archive, check for the distroseries and the
+        # package.
+        distro_arch_series = ubuntu.self_link + '/{0}/{1}'.format(
+            distroseries, arch_tag)
         try:
-            release = self.launchpad_service.load(ubuntu_uri + distroseries)
-            distro_arch = self.launchpad_service.load(
-                ubuntu_uri + '{0}/{1}'.format(distroseries, arch_tag))
+            binaries = archive.getPublishedBinaries(
+                binary_name=pkgname, distro_arch_series=distro_arch_series,
+                status='Published', exact_match=True)
         except HTTPError as error:
-            if error.response.status == 404:
-                # Either the release or distro_arch does not exist.
-                # Obviously, this does not verify!  Any other status is
-                # unexpected.
+            if error.response.status == 400:
+                # A bad request is raised if the distro arch series we
+                # indicate does not exist.  Obviously, this does not
+                # verify!  Any other status is unexpected.
                 return False
             raise
-        archive = self.launchpad_service.load(ubuntu_uri + '+archive/primary')
-        binaries = archive.getPublishedBinaries(
-            binary_name=pkgname, distro_arch_series=distro_arch,
-            exact_match=True)
         for binary in binaries:
             if binary.binary_package_name == pkgname:
                 return True