Merge lp:~bjornt/landscape-client/lxd-update-fail into lp:~landscape/landscape-client/trunk

[Björn Tillenius]

Don't report packages that are coming from backports.

The reason for this is that backports are enabled by default from
xenial, but landscape doesn't handle that well, since we don't support
pinning properly.

If we report packages from backports, it means that Landscape will
upgrade to those version if you use an upgrade profile or select all
upgrades to their latest versions.

Don't report packages that are coming from backports.

The reason for this is that backports are enabled by default from
xenial, but landscape doesn't handle that well, since we don't support
pinning properly.

If we report packages from backports, it means that Landscape will
upgrade to those version if you use an upgrade profile or select all
upgrades to their latest versions.

Testing instructions:

   Use this branch for a xenial machine that has lxd installed
   Register it with Landscape
   Ensure that Landscape doesn't off to upgrade lxd to 2.8

[🤖 Landscape Builder (landscape-builder)]

review: Abstain (executing tests)

[🤖 Landscape Builder (landscape-builder)]

Command: TRIAL_ARGS=-j4 make check
Result: Success
Revno: 961
Branch: lp:~bjornt/landscape-client/lxd-update-fail
Jenkins: https://ci.lscape.net/job/latch-test-xenial/3638/

review: Approve (test results)

[Adam Collard (adam-collard)]

LGTM, +1. Thanks for the work on this!

review: Approve

[Alberto Donato (ack)]

Nice fix, +1

review: Approve

=== modified file 'landscape/package/reporter.py'
--- landscape/package/reporter.py	2017-03-17 09:26:45 +0000
+++ landscape/package/reporter.py	2017-03-17 15:43:18 +0000
@@ -18,6 +18,7 @@
 from landscape.lib.twisted_util import gather_results, spawn_process
 from landscape.lib.fetch import fetch_async
 from landscape.lib.fs import touch_file
+from landscape.lib.lsb_release import parse_lsb_release, LSB_RELEASE_FILENAME
 
 from landscape.compat import convert_buffer_to_string
 from landscape.package.taskhandler import (
@@ -551,8 +552,26 @@
         current_available = set()
         current_upgrades = set()
         current_locked = set()
+        lsb = parse_lsb_release(LSB_RELEASE_FILENAME)
+        backports_archive = "{}-backports".format(lsb["code-name"])
 
         for package in self._facade.get_packages():
+            # Don't include package versions from the official backports
+            # archive. The backports archive is enabled by default since
+            # xenial with a pinning policy of 100. Ideally we would
+            # support pinning, but we don't yet. In the mean time, we
+            # ignore backports, so that packages don't get automatically
+            # upgraded to the backports version.
+            backport_origins = [
+                origin for origin in package.origins
+                if origin.archive == backports_archive]
+            if backport_origins and (
+                    len(backport_origins) == len(package.origins)):
+                # Ignore the version if it's only in the official
+                # backports archive. If it's somewhere else as well,
+                # e.g. a PPA, we assume it was added manually and the
+                # user wants to get updates from it.
+                continue
             hash = self._facade.get_package_hash(package)
             id = self._store.get_hash_id(hash)
             if id is not None:

=== modified file 'landscape/package/tests/test_reporter.py'
--- landscape/package/tests/test_reporter.py	2017-03-17 09:26:45 +0000
+++ landscape/package/tests/test_reporter.py	2017-03-17 15:43:18 +0000
@@ -3,6 +3,7 @@
 import time
 import apt_pkg
 import mock
+import shutil
 
 from twisted.internet.defer import Deferred, succeed, fail, inlineCallbacks
 from twisted.internet import reactor
@@ -11,6 +12,7 @@
 from landscape.lib import bpickle
 from landscape.lib.fs import create_text_file, touch_file
 from landscape.lib.fetch import FetchError
+from landscape.lib.lsb_release import parse_lsb_release, LSB_RELEASE_FILENAME
 from landscape.package.store import (
     PackageStore, UnknownHashIDRequest, FakePackageStore)
 from landscape.package.reporter import (
@@ -925,6 +927,92 @@
         result = self.reporter.detect_packages_changes()
         return result.addCallback(got_result)
 
+    def test_detect_packages_changes_with_backports(self):
+        """
+        Package versions coming from backports aren't considered to be
+        available.
+
+        This is because we don't support pinning, and the backports
+        archive is enabled by default since xenial.
+        """
+        message_store = self.broker_service.message_store
+        message_store.set_accepted_types(["packages"])
+
+        lsb = parse_lsb_release(LSB_RELEASE_FILENAME)
+        release_path = os.path.join(self.repository_dir, "Release")
+        with open(release_path, "w") as release:
+            release.write("Suite: {}-backports".format(lsb["code-name"]))
+
+        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
+
+        def got_result(result):
+            self.assertMessages(message_store.get_pending_messages(), [])
+
+            self.assertEqual(sorted(self.store.get_available()), [])
+
+        result = self.reporter.detect_packages_changes()
+        return result.addCallback(got_result)
+
+    def test_detect_packages_changes_with_backports_others(self):
+        """
+        Packages coming from backport archives that aren't named like
+        the official backports archive are considered to be available.
+        """
+        message_store = self.broker_service.message_store
+        message_store.set_accepted_types(["packages"])
+
+        release_path = os.path.join(self.repository_dir, "Release")
+        with open(release_path, "w") as release:
+            release.write("Suite: my-personal-backports")
+
+        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
+
+        def got_result(result):
+            self.assertMessages(message_store.get_pending_messages(),
+                                [{"type": "packages", "available": [(1, 3)]}])
+
+            self.assertEqual(sorted(self.store.get_available()), [1, 2, 3])
+
+        result = self.reporter.detect_packages_changes()
+        return result.addCallback(got_result)
+
+    def test_detect_packages_changes_with_backports_both(self):
+        """
+        If a package is both in the official backports archive and in
+        some other archive (e.g. a PPA), the package is considered to be
+        available.
+
+        The reason for this is that if you have enabled a PPA, you most
+        likely want to get updates from it.
+        """
+        message_store = self.broker_service.message_store
+        message_store.set_accepted_types(["packages"])
+
+        temp_dir = self.makeDir()
+        other_backport_dir = os.path.join(temp_dir, "my-personal-backports")
+        shutil.copytree(self.repository_dir, other_backport_dir)
+        os.remove(os.path.join(other_backport_dir, "Packages"))
+        self.facade.add_channel_deb_dir(other_backport_dir)
+
+        lsb = parse_lsb_release(LSB_RELEASE_FILENAME)
+        official_release_path = os.path.join(self.repository_dir, "Release")
+        with open(official_release_path, "w") as release:
+            release.write("Suite: {}-backports".format(lsb["code-name"]))
+        unofficial_release_path = os.path.join(other_backport_dir, "Release")
+        with open(unofficial_release_path, "w") as release:
+            release.write("Suite: my-personal-backports")
+
+        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
+
+        def got_result(result):
+            self.assertMessages(message_store.get_pending_messages(),
+                                [{"type": "packages", "available": [(1, 3)]}])
+
+            self.assertEqual(sorted(self.store.get_available()), [1, 2, 3])
+
+        result = self.reporter.detect_packages_changes()
+        return result.addCallback(got_result)
+
     @inlineCallbacks
     def test_detect_packages_after_tasks(self):
         """