Merge ~ahasenack/ubuntu/+source/landscape-client:trusty-landscape-client-1721383 into ~usd-import-team/ubuntu/+source/landscape-client:ubuntu/trusty-devel

[Andreas Hasenack]

9a2c9d1... by Andreas Hasenack on 2017-11-23

changelog

[ChristianEhrhardt (paelzer)]

From a packaging perspective this LGTM, as with the other one the actual code review will be by Simon/Eric.
Note: I've seen that you added SRU Templates, but as a heads up empty "Regression potential" sections are usually teasers for the SRU Team to think into it really deep and then Nack you for some potential regression (teaches maintainers to think about regressions themselves). If possible, give it a thought and outline the potential issues :-)

review: Approve

[Simon Poirier (simpoir)]

+1 LGTM

review: Approve

diff --git a/debian/changelog b/debian/changelog
index a03f5db..2ae1ca0 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,13 @@
+landscape-client (14.12-0ubuntu6.14.04.1) trusty; urgency=medium
+
+  [ Simon Poirier ]
+  * Add proxy handling to package reporter. (LP: #1531150)
+  * Fix regression in configuration hook under install-cd chroot (LP: #1699789)
+  * Report autoremovable packages (LP: #1208393)
+  * No not re-register client by default (LP: #1618483)
+
+ -- Andreas Hasenack <[e-mail]>  Fri, 10 Nov 2017 16:21:54 -0200
+
 landscape-client (14.12-0ubuntu6.14.04) trusty; urgency=medium
 
   * Minor updates (LP: #1636477):
diff --git a/debian/patches/autoremovable-report-1208393.diff b/debian/patches/autoremovable-report-1208393.diff
new file mode 100644
index 0000000..eab7407
--- /dev/null
+++ b/debian/patches/autoremovable-report-1208393.diff
@@ -0,0 +1,317 @@
+Description: Package autoremove reporting
+ - Add autoremove state to store schema
+ - autoremove package report
+Author: Simon Poirier <[e-mail]>
+Origin: upstream, https://github.com/CanonicalLtd/landscape-client/commit/4807ca51a92814acaa51156d7172a274309f2934
+Bug-Ubuntu: https://launchpad.net/bugs/1208393
+Last-Update: 2017-11-10
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/landscape/package/facade.py
++++ b/landscape/package/facade.py
+@@ -422,6 +422,10 @@
+             return False
+         return version > version.package.installed
+ 
++    def is_package_autoremovable(self, version):
++        """Was the package auto-installed, but isn't required anymore?"""
++        return version.package.is_auto_removable
++
+     def _is_main_architecture(self, package):
+         """Is the package for the facade's main architecture?"""
+         # package.name includes the architecture, if it's for a foreign
+--- a/landscape/package/reporter.py
++++ b/landscape/package/reporter.py
+@@ -341,6 +341,7 @@
+         self._store.clear_installed()
+         self._store.clear_locked()
+         self._store.clear_hash_id_requests()
++        self._store.clear_autoremovable()
+ 
+         return succeed(None)
+ 
+@@ -542,11 +543,13 @@
+         old_available = set(self._store.get_available())
+         old_upgrades = set(self._store.get_available_upgrades())
+         old_locked = set(self._store.get_locked())
++        old_autoremovable = set(self._store.get_autoremovable())
+ 
+         current_installed = set()
+         current_available = set()
+         current_upgrades = set()
+         current_locked = set()
++        current_autoremovable = set()
+         lsb = parse_lsb_release(LSB_RELEASE_FILENAME)
+         backports_archive = "{}-backports".format(lsb["code-name"])
+ 
+@@ -574,6 +577,8 @@
+                     current_installed.add(id)
+                     if self._facade.is_package_available(package):
+                         current_available.add(id)
++                    if self._facade.is_package_autoremovable(package):
++                        current_autoremovable.add(id)
+                 else:
+                     current_available.add(id)
+ 
+@@ -591,11 +596,13 @@
+         new_available = current_available - old_available
+         new_upgrades = current_upgrades - old_upgrades
+         new_locked = current_locked - old_locked
++        new_autoremovable = current_autoremovable - old_autoremovable
+ 
+         not_installed = old_installed - current_installed
+         not_available = old_available - current_available
+         not_upgrades = old_upgrades - current_upgrades
+         not_locked = old_locked - current_locked
++        not_autoremovable = old_autoremovable - current_autoremovable
+ 
+         message = {}
+         if new_installed:
+@@ -611,6 +618,13 @@
+             message["locked"] = \
+                 list(sequence_to_ranges(sorted(new_locked)))
+ 
++        if new_autoremovable:
++            message["autoremovable"] = list(
++                sequence_to_ranges(sorted(new_autoremovable)))
++        if not_autoremovable:
++            message["not-autoremovable"] = list(
++                sequence_to_ranges(sorted(not_autoremovable)))
++
+         if not_installed:
+             message["not-installed"] = \
+                 list(sequence_to_ranges(sorted(not_installed)))
+@@ -632,12 +646,15 @@
+ 
+         logging.info("Queuing message with changes in known packages: "
+                      "%d installed, %d available, %d available upgrades, "
+-                     "%d locked, %d not installed, %d not available, "
+-                     "%d not available upgrades, %d not locked."
++                     "%d locked, %d autoremovable, %d not installed, "
++                     "%d not available, %d not available upgrades, "
++                     "%d not locked, %d not autoremovable. "
+                      % (len(new_installed), len(new_available),
+                         len(new_upgrades), len(new_locked),
++                        len(new_autoremovable),
+                         len(not_installed), len(not_available),
+-                        len(not_upgrades), len(not_locked)))
++                        len(not_upgrades), len(not_locked),
++                        len(not_autoremovable)))
+ 
+         def update_currently_known(result):
+             if new_installed:
+@@ -648,6 +665,8 @@
+                 self._store.add_available(new_available)
+             if new_locked:
+                 self._store.add_locked(new_locked)
++            if new_autoremovable:
++                self._store.add_autoremovable(new_autoremovable)
+             if not_available:
+                 self._store.remove_available(not_available)
+             if new_upgrades:
+@@ -656,6 +675,8 @@
+                 self._store.remove_available_upgrades(not_upgrades)
+             if not_locked:
+                 self._store.remove_locked(not_locked)
++            if not_autoremovable:
++                self._store.remove_autoremovable(not_autoremovable)
+             # Something has changed wrt the former run, let's update the
+             # timestamp and return True.
+             stamp_file = self._config.detect_package_changes_stamp
+--- a/landscape/package/store.py
++++ b/landscape/package/store.py
+@@ -208,6 +208,25 @@
+         return [row[0] for row in cursor.fetchall()]
+ 
+     @with_cursor
++    def add_autoremovable(self, cursor, ids):
++        for id in ids:
++            cursor.execute("REPLACE INTO autoremovable VALUES (?)", (id,))
++
++    @with_cursor
++    def remove_autoremovable(self, cursor, ids):
++        id_list = ",".join(str(int(id)) for id in ids)
++        cursor.execute("DELETE FROM autoremovable WHERE id IN (%s)" % id_list)
++
++    @with_cursor
++    def clear_autoremovable(self, cursor):
++        cursor.execute("DELETE FROM autoremovable")
++
++    @with_cursor
++    def get_autoremovable(self, cursor):
++        cursor.execute("SELECT id FROM autoremovable")
++        return [row[0] for row in cursor.fetchall()]
++
++    @with_cursor
+     def add_installed(self, cursor, ids):
+         for id in ids:
+             cursor.execute("REPLACE INTO installed VALUES (?)", (id,))
+@@ -424,6 +443,8 @@
+     #       try block.
+     cursor = db.cursor()
+     try:
++        cursor.execute("CREATE TABLE autoremovable"
++                       " (id INTEGER PRIMARY KEY)")
+         cursor.execute("CREATE TABLE locked"
+                        " (id INTEGER PRIMARY KEY)")
+         cursor.execute("CREATE TABLE available"
+--- a/landscape/package/tests/test_facade.py
++++ b/landscape/package/tests/test_facade.py
+@@ -817,6 +817,30 @@
+         self.assertEqual("version2-release2", version2.version)
+         self.assertFalse(self.facade.is_package_installed(version2))
+ 
++    def test_is_package_autoremovable(self):
++        """
++        Check that auto packages without dependencies on them are correctly
++        detected as being autoremovable.
++        """
++        self._add_system_package("dep")
++        self._add_system_package("newdep")
++        self._add_system_package("foo", control_fields={"Depends": "newdep"})
++        self.facade.reload_channels()
++        dep, = sorted(self.facade.get_packages_by_name("dep"))
++        dep.package.mark_auto(True)
++        # dep should not be explicitely installed
++        dep.package.mark_install(False)
++        newdep, = sorted(self.facade.get_packages_by_name("newdep"))
++        newdep, = sorted(self.facade.get_packages_by_name("newdep"))
++        newdep.package.mark_auto(True)
++        self.assertTrue(dep.package.is_installed)
++        self.assertTrue(dep.package.is_auto_installed)
++        self.assertTrue(newdep.package.is_installed)
++        self.assertTrue(dep.package.is_auto_installed)
++
++        self.assertTrue(self.facade.is_package_autoremovable(dep))
++        self.assertFalse(self.facade.is_package_autoremovable(newdep))
++
+     def test_is_package_available_in_channel_not_installed(self):
+         """
+         A package is considered available if the package is in a
+--- a/landscape/package/tests/test_reporter.py
++++ b/landscape/package/tests/test_reporter.py
+@@ -84,6 +84,15 @@
+         """Make it so that package "name1" is considered installed."""
+         self._install_deb_file(os.path.join(self.repository_dir, PKGNAME1))
+ 
++    def set_pkg1_autoremovable(self):
++        """Make it so package "name1" is considered auto removable."""
++        self.set_pkg1_installed()
++        self.facade.reload_channels()
++        name1 = sorted(self.facade.get_packages_by_name("name1"))[0]
++        # Since no other package depends on this, all that's needed
++        # to have it autoremovable is to mark it as installed+auto.
++        name1.package.mark_auto(True)
++
+     def _make_fake_apt_update(self, out="output", err="error", code=0):
+         """Create a fake apt-update executable"""
+         self.reporter.apt_update_filename = self.makeFile(
+@@ -971,6 +980,53 @@
+         result = self.reporter.detect_packages_changes()
+         return result.addCallback(got_result)
+ 
++    def test_detect_packages_changes_with_autoremovable(self):
++        message_store = self.broker_service.message_store
++        message_store.set_accepted_types(["packages"])
++
++        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
++        self.store.add_available([1, 2, 3])
++        self.store.add_installed([1])
++        self.set_pkg1_autoremovable()
++
++        result = self.successResultOf(self.reporter.detect_packages_changes())
++        self.assertTrue(result)
++
++        expected = [{"type": "packages", "autoremovable": [1]}]
++        self.assertMessages(message_store.get_pending_messages(), expected)
++        self.assertEqual([1], self.store.get_autoremovable())
++
++    def test_detect_packages_changes_with_not_autoremovable(self):
++        message_store = self.broker_service.message_store
++        message_store.set_accepted_types(["packages"])
++
++        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
++        self.store.add_available([1, 2, 3])
++        # We don't care about checking other state changes in this test.
++        # In reality the package would also be installed, available, etc.
++        self.store.add_autoremovable([1, 2])
++
++        result = self.successResultOf(self.reporter.detect_packages_changes())
++        self.assertTrue(result)
++
++        expected = [{"type": "packages", "not-autoremovable": [1, 2]}]
++        self.assertMessages(message_store.get_pending_messages(), expected)
++        self.assertEqual([], self.store.get_autoremovable())
++
++    def test_detect_packages_changes_with_known_autoremovable(self):
++        message_store = self.broker_service.message_store
++        message_store.set_accepted_types(["packages"])
++
++        self.store.set_hash_ids({HASH1: 1, HASH2: 2, HASH3: 3})
++        self.store.add_available([1, 2, 3])
++        self.store.add_installed([1])
++        self.store.add_autoremovable([1])
++        self.set_pkg1_autoremovable()
++
++        result = self.successResultOf(self.reporter.detect_packages_changes())
++        self.assertFalse(result)
++        self.assertEqual([1], self.store.get_autoremovable())
++
+     def test_detect_packages_changes_with_backports(self):
+         """
+         Package versions coming from backports aren't considered to be
+--- a/landscape/package/tests/test_store.py
++++ b/landscape/package/tests/test_store.py
+@@ -284,6 +284,23 @@
+         self.store1.clear_available_upgrades()
+         self.assertEqual(self.store2.get_available_upgrades(), [])
+ 
++    def test_add_and_get_autoremovable(self):
++        self.store1.add_autoremovable([1, 2])
++        value = self.store1.get_autoremovable()
++        self.assertEqual([1, 2], value)
++
++    def test_clear_autoremovable(self):
++        self.store1.add_autoremovable([1, 2])
++        self.store1.clear_autoremovable()
++        value = self.store1.get_autoremovable()
++        self.assertEqual([], value)
++
++    def test_remove_autoremovable(self):
++        self.store1.add_autoremovable([1, 2, 3, 4])
++        self.store1.remove_autoremovable([2, 4, 5])
++        value = self.store1.get_autoremovable()
++        self.assertEqual([1, 3], value)
++
+     def test_add_and_get_installed_packages(self):
+         self.store1.add_installed([1, 2])
+         self.assertEqual(self.store2.get_installed(), [1, 2])
+@@ -350,6 +367,9 @@
+         cursor.execute("pragma table_info(locked)")
+         result = cursor.fetchall()
+         self.assertTrue(len(result) > 0)
++        cursor.execute("pragma table_info(autoremovable)")
++        result = cursor.fetchall()
++        self.assertTrue(len(result) > 0)
+ 
+     def test_add_and_get_locked(self):
+         """
+--- a/landscape/message_schemas.py
++++ b/landscape/message_schemas.py
+@@ -350,13 +350,15 @@
+      "available": package_ids_or_ranges,
+      "available-upgrades": package_ids_or_ranges,
+      "locked": package_ids_or_ranges,
++     "autoremovable": package_ids_or_ranges,
++     "not-autoremovable": package_ids_or_ranges,
+      "not-installed": package_ids_or_ranges,
+      "not-available": package_ids_or_ranges,
+      "not-available-upgrades": package_ids_or_ranges,
+      "not-locked": package_ids_or_ranges},
+     optional=["installed", "available", "available-upgrades", "locked",
+               "not-available", "not-installed", "not-available-upgrades",
+-              "not-locked"])
++              "not-locked", "autoremovable", "not-autoremovable"])
+ 
+ package_locks = List(Tuple(Unicode(), Unicode(), Unicode()))
+ PACKAGE_LOCKS = Message(
diff --git a/debian/patches/config-no-reregister-1618483.diff b/debian/patches/config-no-reregister-1618483.diff
new file mode 100644
index 0000000..0a564d6
--- /dev/null
+++ b/debian/patches/config-no-reregister-1618483.diff
@@ -0,0 +1,184 @@
+Description: Default to not register again if already registered
+ When running the landscape-config script, change the default answer to the
+ registration question to "No" if this client is already registered.
+Author: Alberto Donato <[e-mail]>
+Origin: upstream, http://bazaar.launchpad.net/~landscape/landscape-client/trunk/revision/939
+Bug: https://launchpad.net/bugs/1618483
+Last-Update: 2017-11-10
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/landscape/configuration.py
++++ b/landscape/configuration.py
+@@ -22,8 +22,10 @@
+ from landscape.lib.twisted_util import gather_results
+ from landscape.lib.fetch import fetch, FetchError
+ from landscape.lib.bootstrap import BootstrapList, BootstrapDirectory
++from landscape.lib.persist import Persist
+ from landscape.reactor import LandscapeReactor
+-from landscape.broker.registration import InvalidCredentialsError
++from landscape.broker.registration import Identity, InvalidCredentialsError
++from landscape.broker.service import BrokerService
+ from landscape.broker.config import BrokerConfiguration
+ from landscape.broker.amp import RemoteBrokerConnector
+ 
+@@ -731,6 +733,15 @@
+         return 2  # An error happened
+ 
+ 
++def is_registered(config):
++    """Return whether the client is already registered."""
++    persist_filename = os.path.join(
++        config.data_path, "{}.bpickle".format(BrokerService.service_name))
++    persist = Persist(filename=persist_filename)
++    identity = Identity(config, persist)
++    return bool(identity.secure_id)
++
++
+ def main(args, print=print):
+     """Interact with the user and the server to set up client configuration."""
+ 
+@@ -769,9 +780,13 @@
+         report_registration_outcome(result, print=print)
+         sys.exit(determine_exit_code(result))
+     else:
+-        answer = raw_input("\nRequest a new registration for "
+-                           "this computer now? (Y/n): ")
+-        if not answer.upper().startswith("N"):
++        script = LandscapeSetupScript(config)
++        default_answer = not is_registered(config)
++        answer = script.prompt_yes_no(
++            "\nRequest a new registration for this computer now?",
++            default=default_answer)
++
++        if answer:
+             result = register(config, reactor)
+             report_registration_outcome(result, print=print)
+             sys.exit(determine_exit_code(result))
+--- a/landscape/tests/test_configuration.py
++++ b/landscape/tests/test_configuration.py
+@@ -7,10 +7,12 @@
+ import sys
+ import unittest
+ 
++import mock
+ from twisted.internet.defer import succeed, fail, Deferred
+ 
+ from landscape.broker.registration import InvalidCredentialsError
+-from landscape.broker.tests.helpers import RemoteBrokerHelper
++from landscape.broker.tests.helpers import (
++    RemoteBrokerHelper, BrokerConfigurationHelper)
+ from landscape.configuration import (
+     print_text, LandscapeSetupScript, LandscapeSetupConfiguration,
+     register, setup, main, setup_init_script_and_start_client,
+@@ -18,15 +20,17 @@
+     ImportOptionError, store_public_key_data,
+     bootstrap_tree, got_connection, success, failure, exchange_failure,
+     handle_registration_errors, done, got_error, report_registration_outcome,
+-    determine_exit_code)
++    determine_exit_code, is_registered)
+ from landscape.lib.amp import MethodCallError
+ from landscape.lib.fetch import HTTPCodeError, PyCurlError
++from landscape.lib.persist import Persist
+ from landscape.sysvconfig import SysVConfig, ProcessError
+ from landscape.tests.helpers import FakeBrokerServiceHelper
+ from landscape.tests.helpers import LandscapeTest, EnvironSaverHelper
+ from landscape.tests.mocker import ANY, MATCH, CONTAINS, expect
+ 
+ 
++
+ class LandscapeConfigurationTest(LandscapeTest):
+ 
+     def get_config(self, args, data_path=None):
+@@ -1167,9 +1171,9 @@
+         setup_mock = self.mocker.replace(setup)
+         setup_mock(ANY)
+ 
+-        raw_input_mock = self.mocker.replace(raw_input)
++        raw_input_mock = self.mocker.replace(raw_input, passthrough=False)
+         raw_input_mock("\nRequest a new registration for "
+-                       "this computer now? (Y/n): ")
++                       "this computer now? [Y/n]")
+         self.mocker.result("n")
+ 
+         # This must not be called.
+@@ -1215,7 +1219,7 @@
+ 
+         raw_input_mock = self.mocker.replace(raw_input)
+         raw_input_mock("\nRequest a new registration for "
+-                       "this computer now? (Y/n): ")
++                       "this computer now? [Y/n]")
+         self.mocker.result("y")
+ 
+         # The register() function will be called.
+@@ -1246,7 +1250,7 @@
+ 
+         raw_input_mock = self.mocker.replace(raw_input)
+         raw_input_mock("\nRequest a new registration for "
+-                       "this computer now? (Y/n): ")
++                       "this computer now? [Y/n]")
+         self.mocker.result("y")
+ 
+         # The register() function will be called.
+@@ -1337,13 +1341,15 @@
+             printed)
+ 
+     def make_working_config(self):
++        data_path = self.makeFile()
+         return self.makeFile("[client]\n"
+                              "computer_title = Old Title\n"
+                              "account_name = Old Name\n"
+                              "registration_key = Old Password\n"
+                              "http_proxy = http://old.proxy\n"
+                              "https_proxy = https://old.proxy\n"
+-                             "url = http://url\n")
++                             "data_path = {}\n"
++                             "url = http://url\n".format(data_path))
+ 
+     def test_register(self):
+         sysvconfig_mock = self.mocker.patch(SysVConfig)
+@@ -1357,7 +1363,7 @@
+ 
+         raw_input_mock = self.mocker.replace(raw_input)
+         raw_input_mock("\nRequest a new registration for "
+-                       "this computer now? (Y/n): ")
++                       "this computer now? [Y/n]")
+         self.mocker.result("")
+ 
+         raw_input_mock("\nThe Landscape client must be started "
+@@ -1424,7 +1430,7 @@
+         setup_mock(ANY)
+         raw_input_mock = self.mocker.replace(raw_input)
+         raw_input_mock("\nRequest a new registration for "
+-                       "this computer now? (Y/n): ")
++                       "this computer now? [Y/n]")
+         self.mocker.result("")
+ 
+         register_mock = self.mocker.replace(register, passthrough=False)
+@@ -2322,3 +2328,27 @@
+         for code in failure_codes:
+             result = determine_exit_code(code)
+             self.assertEqual(2, result)
++
++
++class IsRegisteredTest(LandscapeTest):
++
++    helpers = [BrokerConfigurationHelper]
++
++    def setUp(self):
++        super(IsRegisteredTest, self).setUp()
++        persist_file = os.path.join(self.config.data_path, "broker.bpickle")
++        self.persist = Persist(filename=persist_file)
++
++    def test_is_registered_false(self):
++        """
++        If the client hasn't previouly registered, is_registered returns False.
++        """
++        self.assertFalse(is_registered(self.config))
++
++    def test_is_registered_true(self):
++        """
++        If the client has previouly registered, is_registered returns True.
++        """
++        self.persist.set("registration.secure-id", "super-secure")
++        self.persist.save()
++        self.assertTrue(is_registered(self.config))
diff --git a/debian/patches/iso-configuration-1699789.diff b/debian/patches/iso-configuration-1699789.diff
new file mode 100644
index 0000000..1adcd6d
--- /dev/null
+++ b/debian/patches/iso-configuration-1699789.diff
@@ -0,0 +1,87 @@
+Description: Stop reactor in landscape-config on broker error
+ Handle SystemExit exception, as those don't propagate past the reactor, in
+ order to avoid getting stuck when installed in chroot.
+Author: Simon Poirier <[e-mail]>
+Origin: upstream, https://github.com/CanonicalLtd/landscape-client/commit/e0b1b0ca43c13bc65374df13d192405abb3014e6
+Bug-Ubuntu: https://launchpad.net/bugs/1699789
+Last-Update: 2017-11-10
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/landscape/configuration.py
++++ b/landscape/configuration.py
+@@ -639,10 +639,12 @@
+     return results
+ 
+ 
+-def got_error(failure, print=print):
+-    """...from broker."""
++def got_error(failure, reactor, add_result, print=print):
++    """Handle errors contacting broker."""
+     print(failure.getTraceback(), file=sys.stderr)
+-    raise SystemExit
++    # Can't just raise SystemExit; it would be ignored by the reactor.
++    add_result(SystemExit())
++    reactor.stop()
+ 
+ 
+ def register(config, reactor=None, connector_factory=RemoteBrokerConnector,
+@@ -671,6 +673,7 @@
+     """
+     if reactor is None:
+         reactor = LandscapeReactor()
++
+     if results is None:
+         results = []
+     add_result = results.append
+@@ -679,13 +682,17 @@
+     connection = connector.connect(max_retries=max_retries, quiet=True)
+     connection.addCallback(
+         partial(got_connection, add_result, connector, reactor))
+-    connection.addErrback(got_error)
++    connection.addErrback(
++        partial(got_error, reactor=reactor, add_result=add_result))
+     reactor.run()
+ 
+     assert len(results) == 1, "We expect exactly one result."
+     # Results will be things like "success" or "ssl-error".
+     result = results[0]
+ 
++    if isinstance(result, SystemExit):
++        raise result
++
+     # If there was an error and the caller requested that errors be reported
+     # to the on_error callable, then do so.
+     if result != "success" and on_error is not None:
+--- a/landscape/tests/test_configuration.py
++++ b/landscape/tests/test_configuration.py
+@@ -172,14 +172,19 @@
+             def getTraceback(self):
+                 return "traceback"
+ 
++        results = []
+         printed = []
+ 
+         def faux_print(text, file):
+             printed.append((text, file))
+ 
+-        with self.assertRaises(SystemExit):
+-            got_error(FauxFailure(), print=faux_print)
++        mock_reactor = mock.Mock()
+ 
++        got_error(FauxFailure(), reactor=mock_reactor,
++                  add_result=results.append, print=faux_print)
++        mock_reactor.stop.assert_called_once_with()
++
++        self.assertIsInstance(results[0], SystemExit)
+         self.assertEqual([('traceback', sys.stderr)], printed)
+ 
+ 
+@@ -2081,7 +2086,7 @@
+         self.assertTrue(1, len(connector.connection.errbacks))
+         self.assertEqual(
+             'got_error',
+-            connector.connection.errbacks[0].__name__)
++            connector.connection.errbacks[0].func.__name__)
+         # We ask for retries because networks aren't reliable.
+         self.assertEqual(99, connector.max_retries)
+ 
diff --git a/debian/patches/package-reporter-proxy-1531150.diff b/debian/patches/package-reporter-proxy-1531150.diff
new file mode 100644
index 0000000..b154609
--- /dev/null
+++ b/debian/patches/package-reporter-proxy-1531150.diff
@@ -0,0 +1,271 @@
+Description: Add proxy handling to package reporter
+Author: Simon Poirier <[e-mail]>
+Origin: upstream, http://bazaar.launchpad.net/~landscape/landscape-client/trunk/revision/919
+Bug: https://launchpad.net/bugs/1531150
+Last-Update: 2017-11-10
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/apt-update/apt-update.c
++++ b/apt-update/apt-update.c
+@@ -19,7 +19,7 @@
+ int main(int argc, char *argv[], char *envp[])
+ {
+   char *apt_argv[] = {"/usr/bin/apt-get", "-q", "update", NULL};
+-  char *apt_envp[] = {"PATH=/bin:/usr/bin", NULL, NULL};
++  char *apt_envp[] = {"PATH=/bin:/usr/bin", NULL, NULL, NULL, NULL};
+ 
+   // Set the HOME environment variable
+   struct passwd *pwd = getpwuid(geteuid());
+@@ -33,6 +33,24 @@
+     exit(1);
+   }
+ 
++  // Pass proxy environment variables
++  int proxy_arg = 2;
++  char *http_proxy = getenv("http_proxy");
++  if (http_proxy) {
++      if (asprintf(&apt_envp[proxy_arg], "http_proxy=%s", http_proxy) == -1) {
++        perror("error: Unable to set http_proxy environment variable");
++        exit(1);
++      }
++      proxy_arg++;
++  }
++  char *https_proxy = getenv("https_proxy");
++  if (https_proxy) {
++      if (asprintf(&apt_envp[proxy_arg], "https_proxy=%s", https_proxy) == -1) {
++        perror("error: Unable to set https_proxy environment variable");
++        exit(1);
++      }
++  }
++
+   // Drop any supplementary group
+   if (setgroups(0, NULL) == -1) {
+     perror("error: Unable to set supplementary groups IDs");
+--- a/landscape/lib/fetch.py
++++ b/landscape/lib/fetch.py
+@@ -45,7 +45,7 @@
+ 
+ def fetch(url, post=False, data="", headers={}, cainfo=None, curl=None,
+           connect_timeout=30, total_timeout=600, insecure=False, follow=True,
+-          user_agent=None):
++          user_agent=None, proxy=None):
+     """Retrieve a URL and return the content.
+ 
+     @param url: The url to be fetched.
+@@ -61,6 +61,7 @@
+         during autodiscovery)
+     @param follow: If True, follow HTTP redirects (default True).
+     @param user_agent: The user-agent to set in the request.
++    @param proxy: The proxy url to use for the request.
+     """
+     import pycurl
+     output = StringIO(data)
+@@ -94,6 +95,9 @@
+     if user_agent is not None:
+         curl.setopt(pycurl.USERAGENT, user_agent)
+ 
++    if proxy is not None:
++        curl.setopt(pycurl.PROXY, proxy)
++
+     curl.setopt(pycurl.MAXREDIRS, 5)
+     curl.setopt(pycurl.CONNECTTIMEOUT, connect_timeout)
+     curl.setopt(pycurl.LOW_SPEED_LIMIT, 1)
+--- a/landscape/lib/tests/test_fetch.py
++++ b/landscape/lib/tests/test_fetch.py
+@@ -286,6 +286,14 @@
+         self.assertEqual(result, "result")
+         self.assertEqual("user-agent", curl.options[pycurl.USERAGENT])
+ 
++    def test_pycurl_proxy(self):
++        """If provided, the proxy is set in the request."""
++        curl = CurlStub("result")
++        proxy = "http://my.little.proxy"
++        result = fetch("http://example.com", curl=curl, proxy=proxy)
++        self.assertEqual("result", result)
++        self.assertEqual(proxy, curl.options[pycurl.PROXY])
++
+     def test_create_curl(self):
+         curls = []
+ 
+--- a/landscape/package/reporter.py
++++ b/landscape/package/reporter.py
+@@ -38,6 +38,10 @@
+         parser.add_option("--force-apt-update", default=False,
+                           action="store_true",
+                           help="Force running apt-update.")
++        parser.add_option("--http-proxy", metavar="URL",
++                          help="The URL of the HTTP proxy, if one is needed.")
++        parser.add_option("--https-proxy", metavar="URL",
++                          help="The URL of the HTTPS proxy, if one is needed.")
+         return parser
+ 
+ 
+@@ -133,8 +137,14 @@
+                 logging.warning("Couldn't download hash=>id database: %s" %
+                                 str(exception))
+ 
++            if url.startswith("https"):
++                proxy = self._config.get("https_proxy")
++            else:
++                proxy = self._config.get("http_proxy")
++
+             result = fetch_async(url,
+-                                 cainfo=self._config.get("ssl_public_key"))
++                                 cainfo=self._config.get("ssl_public_key"),
++                                 proxy=proxy)
+             result.addCallback(fetch_ok)
+             result.addErrback(fetch_error)
+ 
+@@ -262,7 +272,12 @@
+         Run apt-update using the passed in deferred, which allows for callers
+         to inspect the result code.
+         """
+-        result = spawn_process(self.apt_update_filename)
++        env = {}
++        if self._config.http_proxy:
++            env["http_proxy"] = self._config.http_proxy
++        if self._config.https_proxy:
++            env["https_proxy"] = self._config.https_proxy
++        result = spawn_process(self.apt_update_filename, env=env)
+ 
+         def callback((out, err, code), deferred):
+             return deferred.callback((out, err, code))
+--- a/landscape/package/tests/test_reporter.py
++++ b/landscape/package/tests/test_reporter.py
+@@ -3,11 +3,11 @@
+ import time
+ import apt_pkg
+ import shutil
++import mock
+ 
+ from twisted.internet.defer import Deferred, succeed, inlineCallbacks
+ from twisted.internet import reactor
+ 
+-
+ from landscape.lib.fs import create_file, touch_file
+ from landscape.lib.fetch import fetch_async, FetchError
+ from landscape.lib.lsb_release import parse_lsb_release, LSB_RELEASE_FILENAME
+@@ -286,7 +286,7 @@
+         hash_id_db_url = self.config.package_hash_id_url + "uuid_codename_arch"
+         fetch_async_mock = self.mocker.replace("landscape.lib."
+                                                "fetch.fetch_async")
+-        fetch_async_mock(hash_id_db_url, cainfo=None)
++        fetch_async_mock(hash_id_db_url, cainfo=None, patch=None)
+         fetch_async_result = Deferred()
+         fetch_async_result.callback("hash-ids")
+         self.mocker.result(fetch_async_result)
+@@ -311,6 +311,33 @@
+ 
+         return result
+ 
++    @mock.patch("landscape.package.reporter.fetch_async",
++                return_value=succeed("hash-ids"))
++    @mock.patch("logging.info", return_value=None)
++    def test_fetch_hash_id_db_with_proxy(self, logging_mock, mock_fetch_async):
++        """fetching hash-id-db uses proxy settings"""
++        # Assume package_hash_id_url is set
++        self.config.data_path = self.makeDir()
++        self.config.package_hash_id_url = "https://fake.url/path/"
++        os.makedirs(os.path.join(self.config.data_path, "package", "hash-id"))
++
++        # Fake uuid, codename and arch
++        message_store = self.broker_service.message_store
++        message_store.set_server_uuid("uuid")
++        self.reporter.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
++        self.facade.set_arch("arch")
++
++        # Let's say fetch_async is successful
++        hash_id_db_url = self.config.package_hash_id_url + "uuid_codename_arch"
++
++        # set proxy settings
++        self.config.https_proxy = "http://helloproxy:8000"
++
++        result = self.reporter.fetch_hash_id_db()
++        mock_fetch_async.assert_called_once_with(
++            hash_id_db_url, cainfo=None, proxy="http://helloproxy:8000")
++         return result
++
+     def test_fetch_hash_id_db_does_not_download_twice(self):
+ 
+         # Let's say that the hash=>id database is already there
+@@ -330,7 +357,7 @@
+         # Intercept any call to fetch_async
+         fetch_async_mock = self.mocker.replace("landscape.lib."
+                                                "fetch.fetch_async")
+-        fetch_async_mock(ANY)
++        fetch_async_mock(ANY, proxy=None)
+ 
+         # Go!
+         self.mocker.replay()
+@@ -430,7 +457,7 @@
+                          "uuid_codename_arch"
+         fetch_async_mock = self.mocker.replace("landscape.lib."
+                                                "fetch.fetch_async")
+-        fetch_async_mock(hash_id_db_url, cainfo=None)
++        fetch_async_mock(hash_id_db_url, cainfo=None, proxy=None)
+         fetch_async_result = Deferred()
+         fetch_async_result.callback("hash-ids")
+         self.mocker.result(fetch_async_result)
+@@ -462,7 +489,7 @@
+         hash_id_db_url = self.config.package_hash_id_url + "uuid_codename_arch"
+         fetch_async_mock = self.mocker.replace("landscape.lib."
+                                                "fetch.fetch_async")
+-        fetch_async_mock(hash_id_db_url, cainfo=None)
++        fetch_async_mock(hash_id_db_url, cainfo=None, proxy=None)
+         fetch_async_result = Deferred()
+         fetch_async_result.errback(FetchError("fetch error"))
+         self.mocker.result(fetch_async_result)
+@@ -538,7 +565,7 @@
+                          "uuid_codename_arch"
+         fetch_async_mock = self.mocker.replace("landscape.lib."
+                                                "fetch.fetch_async")
+-        fetch_async_mock(hash_id_db_url, cainfo=self.config.ssl_public_key)
++        fetch_async_mock(hash_id_db_url, cainfo=self.config.ssl_public_key, proxy=None)
+         fetch_async_result = Deferred()
+         fetch_async_result.callback("hash-ids")
+         self.mocker.result(fetch_async_result)
+@@ -1621,6 +1648,44 @@
+         reactor.callWhenRunning(do_test)
+         return deferred
+ 
++    @mock.patch("landscape.package.reporter.spawn_process",
++                return_value=succeed(("", "", 0)))
++    def test_run_apt_update_honors_http_proxy(self, mock_spawn_process):
++        """
++        The PackageReporter.run_apt_update method honors the http_proxy
++        config when calling the apt-update wrapper.
++        """
++        self.config.http_proxy = "http://proxy_server:8080"
++        self.reporter.sources_list_filename = "/I/Dont/Exist"
++
++        update_result = self.reporter.run_apt_update()
++        # run_apt_update uses reactor.call_later so advance a bit
++        self.reactor.advance(0)
++        self.successResultOf(update_result)
++
++        mock_spawn_process.assert_called_once_with(
++            self.reporter.apt_update_filename,
++            env={"http_proxy": "http://proxy_server:8080"})
++
++    @mock.patch("landscape.package.reporter.spawn_process",
++                return_value=succeed(("", "", 0)))
++    def test_run_apt_update_honors_https_proxy(self, mock_spawn_process):
++        """
++        The PackageReporter.run_apt_update method honors the https_proxy
++        config when calling the apt-update wrapper.
++        """
++        self.config.https_proxy = "http://proxy_server:8443"
++        self.reporter.sources_list_filename = "/I/Dont/Exist"
++
++        update_result = self.reporter.run_apt_update()
++        # run_apt_update uses reactor.call_later, so advance a bit
++        self.reactor.advance(0)
++        self.successResultOf(update_result)
++
++        mock_spawn_process.assert_called_once_with(
++            self.reporter.apt_update_filename,
++            env={"https_proxy": "http://proxy_server:8443"})
++
+     def test_run_apt_update_error_on_cache_file(self):
+         """
+         L{PackageReporter.run_apt_update} succeeds if the command fails because
diff --git a/debian/patches/series b/debian/patches/series
index 687f449..aaf6d9f 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -10,3 +10,7 @@ bug-1508110-revno-824.diff
 bug-1532887-revno-825.diff
 bug-1508110-revno-826.diff
 bug-1508110-revno-829.diff
+package-reporter-proxy-1531150.diff
+iso-configuration-1699789.diff
+autoremovable-report-1208393.diff
+config-no-reregister-1618483.diff