Merge ~silverdrake11/ubuntu/+source/landscape-client:ubuntu/mantic-devel into ubuntu/+source/landscape-client:ubuntu/mantic-devel

[Kevin Nasto]

[Kevin Nasto (silverdrake11)]

PPA with this package is here https://launchpad.net/~silverdrake11/+archive/ubuntu/landscape-client

[Lucas Kanashiro (lucaskanashiro)]

Thanks for this MP Kevin!

Initially, I needed to update the d/watch to be able to fetch the upstream tarball:

diff --git a/debian/watch b/debian/watch
index 3592b51..ba7ea91 100644
--- a/debian/watch
+++ b/debian/watch
@@ -1,3 +1,3 @@
 version=4
 opts=filenamemangle=s/.+\/v?(\d\S+)\.tar\.gz/landscape-client-$1\.tar\.gz/ \
- https://github.com/CanonicalLtd/landscape-client/tags .*/?(\d{2}\.\d.\d)\.tar\.gz
+ https://github.com/CanonicalLtd/landscape-client/tags .*/?(\d{2}\.\d{2})\.tar\.gz

I'd recommend to incorporate that change to your package.

I talked to Kevin privately and also asked him to update this line:

https://github.com/canonical/landscape-client/blob/23.08/landscape/__init__.py#L2

to 23.08 (new upstream release).

The only other change related to the package itself that I found is in this commit:

commit a0ecf857a8a883d4c1bb67e5c563de7c6047cc50
Author: Kevin Nasto <email address hidden>
Date: Fri Mar 10 13:25:12 2023 -0600

    Changed gpg file name to be less generic (LP: #2008432) (#137)

This is the change and I believe it is fine to get in:

diff --git a/debian/landscape-client.postrm b/debian/landscape-client.postrm
index 10f79b8..aa34ed2 100644
--- a/debian/landscape-client.postrm
+++ b/debian/landscape-client.postrm
@@ -29,7 +29,7 @@ case "$1" in
     rm -f "${LOG_DIR}/package-reporter.log"*
     rm -f "${LOG_DIR}/package-changer.log"*

- rm -f "${GPG_DIR}/landscape-server"*.asc
+ rm -f "${GPG_DIR}/landscape-server-mirror"*.asc

     rm -rf "${DATA_DIR}/client"
     rm -rf "${DATA_DIR}/.gnupg"

There are 2 lintian errors which are red flags in a first glance:

E: landscape-client source: alien-tag dh_python-is-obsolete [debian/source.lintian-overrides:4]
N:
N: The given override refers to an unknown tag.
N:
N: Please refer to Format of override files (Section 2.4.1) in the Lintian
N: User's Manual for details.
N:
N: Visibility: error
N: Show-Always: yes
N: Check: debian/lintian-overrides/mystery
N:
N:
E: landscape-common: depends-on-obsolete-package Depends: lsb-base
N:
N: The package depends on a package that has been superseded. If the
N: superseded package is part of an ORed group, it should not be the first
N: package in the group.
N:
N: Visibility: error
N: Show-Always: no
N: Check: fields/package-relations
N:
N:

The first one seems to me you added a lintian overrides which will be used just in some ubuntu releases. But it seems this tag does not exist anymore, at least in Mantic's lintian version. I'd remove that TBH.

The second one is about the dependency on lsb-base. I'd consider its removal as well since it is obsolete, but if you are thinking about backporting this to other releases, please check if it is obsolete there as well.

review: Needs Information

[Lucas Kanashiro (lucaskanashiro)]

review: Needs Fixing

[Lucas Kanashiro (lucaskanashiro)]

Thanks for addressing my comments Kevin!

Since you decided to remove the dependency on lsb-base, I think you should remove it from here as well:

https://github.com/canonical/landscape-client/blob/23.08/setup_lib.py#L21

review: Needs Fixing

[Lucas Kanashiro (lucaskanashiro)]

As discussed with Kevin, let's keep lsb-base so he can test it later to make sure it will not impact other supported ubuntu releases.

There are also some improvements that can be made in the package reported by lintian, I will not block this MP because of this, the feature freeze is coming, let's get this uploaded.

review: Approve

[Lucas Kanashiro (lucaskanashiro)]

Package uploaded:

Uploading landscape-client_23.08-0ubuntu1.dsc
Uploading landscape-client_23.08.orig.tar.gz
Uploading landscape-client_23.08-0ubuntu1.debian.tar.xz
Uploading landscape-client_23.08-0ubuntu1_source.buildinfo
Uploading landscape-client_23.08-0ubuntu1_source.changes

diff --git a/.flake8 b/.flake8
 new file mode 100644
index 0000000..c3a3cd2
--- /dev/null
+++ b/.flake8
@@ -0,0 +1,5 @@
+[flake8]
+max-line-length = 79
+max-complexity = 18
+select = B,C,E,F,W,T4,B9
+ignore = E203, W503
diff --git a/.gitignore b/.gitignore
index ca1df98..8ce4558 100644
--- a/.gitignore
+++ b/.gitignore
@@ -25,3 +25,9 @@ tags
 _last_py2_res
 *.pyc
 .cache
+_trial_temp*
+*.snap
+landscape-client_amd64*.txt
+landscape-client_arm64*.txt
+landscape-client_ppc64el*.txt
+landscape-client_s390x*.txt
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
 new file mode 100644
index 0000000..df96450
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,43 @@
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.4.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+    -   id: debug-statements
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.3.0
+    hooks:
+    - id: flake8
+      args:
+        - "--max-line-length=79"
+        - "--select=B,C,E,F,W,T4,B9"
+        - "--ignore=E203,W503"
+-   repo: https://github.com/psf/black
+    rev: 22.12.0
+    hooks:
+    -   id: black
+        args:
+          - --line-length=79
+          - --include='\.pyi?$'
+-   repo: https://github.com/asottile/reorder_python_imports
+    rev: v2.3.0
+    hooks:
+    -   id: reorder-python-imports
+        args: [--py3-plus]
+-   repo: https://github.com/asottile/add-trailing-comma
+    rev: v2.0.1
+    hooks:
+    -   id: add-trailing-comma
+        args: [--py36-plus]
+exclude: >
+  (?x)(
+      \.git
+    | \.csv$
+    | \.__pycache__
+    | \.log$
+  )
diff --git a/LICENSE b/LICENSE
index 5b6e7c6..dcfa4c2 100644
--- a/LICENSE
+++ b/LICENSE
@@ -55,7 +55,7 @@ patent must be licensed for everyone's free use or not licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
 
+
 		    GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
@@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
 
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
 
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -225,7 +225,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
 
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -278,7 +278,7 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
 		     END OF TERMS AND CONDITIONS
-
 
+
 	    How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
diff --git a/Makefile b/Makefile
index fe183ec..09ade0e 100644
--- a/Makefile
+++ b/Makefile
@@ -2,9 +2,15 @@ PYDOCTOR ?= pydoctor
 TXT2MAN ?= txt2man
 PYTHON2 ?= python2
 PYTHON3 ?= python3
+SNAPCRAFT = SNAPCRAFT_BUILD_INFO=1 snapcraft
 TRIAL ?= -m twisted.trial
 TRIAL_ARGS ?=
 
+# PEP8 rules ignored:
+# W503 https://www.flake8rules.com/rules/W503.html
+# E203 Whitespace before ':' (enforced by Black)
+PEP8_IGNORED = W503,E203
+
 .PHONY: help
 help:  ## Print help about available targets
 	@grep -h -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-20s\033[0m %s\n", $$1, $$2}'
@@ -15,11 +21,15 @@ depends: depends3  ## py2 is deprecated
 
 .PHONY: depends2
 depends2:
-	sudo apt-get -y install python-twisted-core python-distutils-extra python-mock python-configobj python-netifaces python-pycurl
+	sudo apt-get -y install python-twisted-core python-distutils-extra python-mock python-configobj python-netifaces python-pycurl python-pip
+	pip install pre-commit
+	pre-commit install
 
 .PHONY: depends3
 depends3:
-	sudo apt-get -y install python3-twisted python3-distutils-extra python3-mock python3-configobj python3-netifaces python3-pycurl
+	sudo apt-get -y install python3-twisted python3-distutils-extra python3-mock python3-configobj python3-netifaces python3-pycurl python3-pip
+	pip3 install pre-commit
+	pre-commit install
 
 all: build
 
@@ -56,13 +66,15 @@ coverage:
 
 .PHONY: lint
 lint:
-	$(PYTHON3) -m flake8 --ignore E24,E121,E123,E125,E126,E221,E226,E266,E704,E265,W504 \
-		`find landscape -name \*.py`
+	$(PYTHON3) -m flake8 --ignore $(PEP8_IGNORED) `find landscape -name \*.py`
 
 .PHONY: pyflakes
 pyflakes:
 	-pyflakes `find landscape -name \*.py`
 
+pre-commit:
+	-pre-commit run -a
+
 clean:
 	-find landscape -name __pycache__ -exec rm -rf {} \;
 	-find landscape -name \*.pyc -exec rm -f {} \;
@@ -115,6 +127,35 @@ tags:
 etags:
 	-etags --languages=python -R .
 
+snap-install:
+	sudo snap install --devmode landscape-client_0.1_amd64.snap
+.PHONY: snap-install
+
+snap-remote-build:
+	snapcraft remote-build
+.PHONY: snap-remote-build
+
+snap-remove:
+	sudo snap remove --purge landscape-client
+.PHONY: snap-remove
+
+snap-shell: snap-install
+	sudo snap run --shell landscape-client.landscape-client
+.PHONY: snap-shell
+
+snap-debug:
+	$(SNAPCRAFT) -v --debug
+.PHONY: snap-debug
+
+snap-clean: snap-remove
+	$(SNAPCRAFT) clean
+	-rm landscape-client_0.1_amd64.snap
+.PHONY: snap-clean
+
+snap:
+	$(SNAPCRAFT)
+.PHONY: snap
+
 include Makefile.packaging
 
 .DEFAULT_GOAL := help
diff --git a/README b/README
index 06be0e1..8751ef3 100644
--- a/README
+++ b/README
@@ -5,7 +5,7 @@
 
 Add our beta PPA to get the latest updates to the landscape-client package
 
-#### Add repo to an Ubuntu series 
+#### Add repo to an Ubuntu series
 ```
 sudo add-apt-repository ppa:landscape/self-hosted-beta
 ```
@@ -50,7 +50,7 @@ monitor_only = true
 
 ## Running
 
-Now you can complete the configuration of your client and register with the 
+Now you can complete the configuration of your client and register with the
 Landscape service. There are two ways to do this:
 
 1. `sudo landscape-config` and answer interactive prompts to finalize your configuration
@@ -86,3 +86,104 @@ Before opening a PR, make sure to run the full testsuite and lint
 make check3
 make lint
 ```
+
+### Building the Landscape Client snap
+
+First, you need to ensure that you have the appropriate tools installed:
+```
+$ sudo snap install snapcraft --classic
+$ lxd init --auto
+```
+
+There are various make targets defined to assist in the lifecycle of
+building and testing the snap.  To simply build the snap with the minimum
+of debug information displayed:
+```
+$ make snap
+```
+
+If you would prefer to see more information displayed showing the progress
+of the build, and would like to get dropped into a debug shell within the
+snap container in the event of an error:
+```
+$ make snap-debug
+```
+
+To install the resulting snap:
+```
+$ make snap-install
+```
+
+To remove a previously installed snap:
+```
+$ make snap-remove
+```
+
+To clean the intermediate files as well as the snap itself from the local
+build environment:
+```
+$ make snap-clean
+```
+
+To enter into a shell environment within the snap container:
+```
+$ make snap-shell
+```
+
+If you wish to upload the snap to the store, you will first need to get
+credentials with the store that allow you to log in locally and publish
+binaries.  This can be done at:
+
+https://snapcraft.io/docs/creating-your-developer-account
+
+After obtaining and confirming your store credentials, you then need to
+log in using the snapcraft tool:
+```
+$ snapcraft login
+```
+
+Since snapcraft version 7.x and higher, the credentials are stored in the
+gnome keyring on your local workstation.  If you are building in an
+environment without a GUI (e.g. in a multipass or lxc container), you
+will need to install the gnome keyring tools:
+```
+$ sudo apt install gnome-keyring
+```
+
+You will then need to initialze the default keyring as follows:
+```
+$ dbus-run-session -- bash
+$ gnome-keyring-daemon --unlock
+```
+The gnome-keyring-daemon will prompt you (without a prompt) to type in
+the initial unlock password (typically the same password for the account
+you are using - if you are using the default multipass or lxc "ubuntu"
+login, use sudo passwd ubuntu to set it to a known value before doing 
+the above step).
+
+Type the login password and hit <ENTER> followed by <CTRL>+D to end
+the input.
+
+At this point, you should be able to log into snapcraft:
+```
+$ snapcraft login
+```
+You will be prompted for your UbuntuOne email address, password and,
+if set up this way, your second factor for authentication.  If you
+are successful, you should be able to query your login credentials
+with:
+```
+$ snapcraft whoami
+```
+A common mistake that first-time users of this process might make
+is that after running the gnome-keyring-daemon command, they will
+exit the dbus session shell.  Do NOT do that.  Do all subsequent
+work in that bash shell that dbus set up for you because it will
+have access to your gnome-keyring.
+
+If you need to leave the environment and get back in, keep in mind
+that you do not have to be logged into the store UNLESS you are
+uploading the snap or otherwise manipulating things in your store
+account.  You will need to repeat the dbus-run-session and
+gnome-keyring-daemon steps BEFORE logging in if you do need to be
+logged into the store.
diff --git a/debian/README.source b/debian/README.source
index d21d7e4..20371fc 100644
--- a/debian/README.source
+++ b/debian/README.source
@@ -12,4 +12,4 @@ appreciated if you also updated the UPSTREAM_VERSION variable in
 landscape/__init__.py to include the entire new client version number. This
 helps us keep track of exact version of clients in use. There's no need to
 update the DEBIAN_REVISION variable, as it gets automatically set at build
-time. 
+time.
diff --git a/debian/changelog b/debian/changelog
index 4ba984f..2479e40 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,25 @@
+landscape-client (23.08-0ubuntu1) mantic; urgency=medium
+
+  * New upstream release 23.08
+    - Restructure landscape-config wizard (LP: #2031673)
+    - Add SnapMonitor, SnapManager, and related machinery (LP: #2031682)
+    - Limit message data directory size (LP: #2004591)
+    - Add zfs and btrfs to stable fs-lists (LP: #1499104)
+    - Test for broken control file (LP: #1813442)
+    - Config man page and help info fixes (LP: #1662222)
+    - Removed unnecesary select to the database (LP: #1994951)
+    - Last apt-key removal (LP: #1990435)
+    - Added a logging level check to provide a better error (LP: #2027521) 
+    - Broker is able to bootstrap the landscape-client folder (LP: #1868730)
+    - Changed gpg file name to be less generic (LP: #2008432)
+    - Improve Dependency data is read from the deb packages (LP: #1813442)
+    - Fix error in swift plugin (LP: #2031674)
+    - Repository profiles do not overwrite all configurations (LP: #2031680)
+    - Remove old plugins (LP: #1989968)
+    - Send ubuntu pro reboot output (LP: #2031684)
+
+ -- Kevin Nasto <[e-mail]>  Thu, 17 Aug 2023 13:41:21 -0500
+
 landscape-client (23.02-0ubuntu1) lunar; urgency=medium
 
   * New upstream release 23.02:
@@ -934,11 +956,11 @@ landscape-client (1.0.21.1-0ubuntu2) intrepid; urgency=low
 
 landscape-client (1.0.21.1-0ubuntu1) intrepid; urgency=low
 
-  * New upstream version: 
+  * New upstream version:
     * Add ok-no-register option to landscape-config script to not fail if
       dbus isn't started or landscape-client isn't running.
     * lower timeout related to package management in landscape.
-  * debian/control: Depend on cron. 
+  * debian/control: Depend on cron.
   * debian/landscape-client.postinst: use ok-no-register option so that the
     postinst script doesn't fail when run from the installer. (LP: #274573).
 
@@ -986,7 +1008,7 @@ landscape-client (1.0.18-0ubuntu4) intrepid; urgency=low
   [ Mathias Gug ]
   * debian/landscape-common.postinst, debian/landscape-common.prerm: don't
     call update-motd init script as it's no longer available in the
-    update-motd package. Call directly /usr/sbin/update-motd instead. 
+    update-motd package. Call directly /usr/sbin/update-motd instead.
     (LP: #271854)
 
  -- Mathias Gug <[e-mail]>  Thu, 18 Sep 2008 16:47:08 -0400
@@ -1006,15 +1028,15 @@ landscape-client (1.0.18-0ubuntu2) intrepid; urgency=low
       command. A landscape account is not required to use this package.
     - landscape-client: has all the binaries required to run the
       landscape-client. Requires a landscape account.
-    - debian/control: 
+    - debian/control:
       + move some dependencies to landscape-client so that
-        landscape-common doesn't install unecessary packages in the 
+        landscape-common doesn't install unecessary packages in the
         default -server install.
       + move python-gobject to a Pre-Depends so that landscape-config can
         register the system during the postinst (LP: #268838).
   * debian/control:
     - depend on python-smartpm instead of smartpm-core.
-  * debian/landscape-client.postrm: delete /etc/landscape/client.conf when 
+  * debian/landscape-client.postrm: delete /etc/landscape/client.conf when
     the package is purged.
   * debian/landscape-client.postinst: remove sysinfo_in_motd debconf question
     as it wasn't used.
@@ -1030,7 +1052,7 @@ landscape-client (1.0.18-0ubuntu2) intrepid; urgency=low
 
 landscape-client (1.0.18-0ubuntu1) intrepid; urgency=low
 
-  * New upstream release 
+  * New upstream release
 
  -- Rick Clark <[e-mail]>  Mon, 08 Sep 2008 16:35:57 -0500
 
@@ -1149,7 +1171,7 @@ landscape-client (1.0.11-hardy1-landscape1) hardy; urgency=low
 
 landscape-client (1.0.10-hardy1-landscape1) hardy; urgency=low
 
-  * Change the utilisation of the csv module to be compatible with 
+  * Change the utilisation of the csv module to be compatible with
     python 2.4 as used in Dapper.
 
  -- Andreas Hasenack <[e-mail]>  Thu, 12 Jun 2008 17:58:05 +0000
@@ -1398,7 +1420,7 @@ landscape-client (0.10.3-1ubuntu1) feisty; urgency=low
     fixed (#114829).
 
  -- Landscape Team <[e-mail]>  Mon, 15 May 2007 16:31:00 -0700
-	
+
 landscape-client (0.10.2-1ubuntu1) feisty; urgency=low
 
   * New upstream release.
@@ -1412,7 +1434,7 @@ landscape-client (0.10.1-1ubuntu1) feisty; urgency=low
   * Minor fix in package management plugin timings.
 
  -- Landscape Team <[e-mail]>  Thu, 10 May 2007 10:00:00 -0700
-	
+
 landscape-client (0.10.0-1ubuntu1) feisty; urgency=low
 
   * New upstream release.
@@ -1422,9 +1444,9 @@ landscape-client (0.10.0-1ubuntu1) feisty; urgency=low
   * The client uses the new operations system.  Support for the now
     unused action info system is gone.
   * A minor bpickle bug was fixed.
-	
+
  -- Jamshed Kakar <[e-mail]>  Mon, 7 May 2007 20:16:00 -0700
-	
+
 landscape-client (0.9.6-1ubuntu1) feisty; urgency=low
 
   * New upstream release.
@@ -1507,7 +1529,7 @@ landscape-client (0.8.1-1) unstable; urgency=low
   * New upstream release.
   * Account registration log message no longer exposes account
     password.
-	
+
  -- Jamshed Kakar <[e-mail]>  Thu, 18 Jan 2007 23:07:00 -0800
 
 landscape-client (0.8.0-1) unstable; urgency=low
@@ -1518,7 +1540,7 @@ landscape-client (0.8.0-1) unstable; urgency=low
   * Client includes an SSL certificate to verify the server with.
   * Package depends on python2.4-pycurl, which is necessary for the
     new SSL support.
-	
+
  -- Jamshed Kakar <[e-mail]>  Thu, 18 Jan 2007 10:48:00 -0800
 
 landscape-client (0.7.0-1) unstable; urgency=low
@@ -1529,7 +1551,7 @@ landscape-client (0.7.0-1) unstable; urgency=low
     added to control log verbosity.
   * Package depends on perl-modules, which is necessary for bare-bones
     server installs.
-	
+
  -- Jamshed Kakar <[e-mail]>  Tue, 2 Jan 2007 12:54:00 -0800
 
 landscape-client (0.6.1-1) unstable; urgency=low
diff --git a/debian/copyright b/debian/copyright
index 479d234..8b528c8 100644
--- a/debian/copyright
+++ b/debian/copyright
@@ -33,4 +33,3 @@ License:
 
 On Debian systems, the complete text of the GNU General
 Public License can be found in `/usr/share/common-licenses/GPL-2'.
-
diff --git a/debian/landscape-client.postrm b/debian/landscape-client.postrm
index 10f79b8..aa34ed2 100644
--- a/debian/landscape-client.postrm
+++ b/debian/landscape-client.postrm
@@ -29,7 +29,7 @@ case "$1" in
     rm -f "${LOG_DIR}/package-reporter.log"*
     rm -f "${LOG_DIR}/package-changer.log"*
 
-    rm -f "${GPG_DIR}/landscape-server"*.asc
+    rm -f "${GPG_DIR}/landscape-server-mirror"*.asc
 
     rm -rf "${DATA_DIR}/client"
     rm -rf "${DATA_DIR}/.gnupg"
diff --git a/debian/source.lintian-overrides b/debian/source.lintian-overrides
 deleted file mode 100644
index 720d1be..0000000
--- a/debian/source.lintian-overrides
+++ /dev/null
@@ -1,4 +0,0 @@
-# we use dh_python or dh_python2 depending on the ubuntu release
-# the package is being built on, this is detected dynamically
-# in the rules file
-landscape-client source: dh_python-is-obsolete
 \ No newline at end of file
diff --git a/debian/watch b/debian/watch
index 3592b51..ba7ea91 100644
--- a/debian/watch
+++ b/debian/watch
@@ -1,3 +1,3 @@
 version=4
 opts=filenamemangle=s/.+\/v?(\d\S+)\.tar\.gz/landscape-client-$1\.tar\.gz/ \
-  https://github.com/CanonicalLtd/landscape-client/tags .*/?(\d{2}\.\d.\d)\.tar\.gz
+  https://github.com/CanonicalLtd/landscape-client/tags .*/?(\d{2}\.\d{2})\.tar\.gz
diff --git a/dev/landscape-client-vm b/dev/landscape-client-vm
index 4d13b6f..a2a1e57 100755
--- a/dev/landscape-client-vm
+++ b/dev/landscape-client-vm
@@ -37,7 +37,7 @@ landscape-devel account on the Landscape staging server (or you can specify
 another account with the --account parameter).
 
 The built VM will be stored under ./build/intrepid along with some other
-files. To launch the VM, cd to ./build/intrepid and issue: 
+files. To launch the VM, cd to ./build/intrepid and issue:
 $ ./run
 Once it's booted you can log into it with:
 $ ./ssh
@@ -136,7 +136,7 @@ cat > script <<EOF
 #!/bin/sh -e
 chown landscape /etc/landscape/client.conf
 chmod 600 /etc/landscape/client.conf
-apt-key add /root/ppa-key
+cp /root/ppa-key /etc/apt/trusted.gpg.d/landscape-server-mirror-root-ppa-key.asc
 echo "RUN=1" > /etc/default/landscape-client
 EOF
 chmod 755 script
diff --git a/dev/upload-to-ppa b/dev/upload-to-ppa
index 2cc01b8..f65b42d 100755
--- a/dev/upload-to-ppa
+++ b/dev/upload-to-ppa
@@ -112,7 +112,7 @@ for release in $releases; do
    else
        message="Built for $codename, no source changes"
    fi
-   cp debian/changelog ../   
+   cp debian/changelog ../
    dch --force-distribution -b -v $version -D $codename -m $message
    dpkg-buildpackage -S $source_opt -k$key
    dput $ppa ../${package}_${version}_source.changes
diff --git a/display_py2_testresults b/display_py2_testresults
index 021681d..e683c1d 100755
--- a/display_py2_testresults
+++ b/display_py2_testresults
@@ -1,5 +1,5 @@
 #!/usr/bin/python
-with open('_last_py2_res', 'r') as py2res:
+with open("_last_py2_res", "r") as py2res:
     lines = py2res.readlines()
 
 lastline = lines[-1]
@@ -7,7 +7,9 @@ lastline = lines[-1]
 time, total, total, err, fail, skip = lastline.split()
 
 if "".join((err, fail, skip)) != "000":
-    print("Python 2: \033[91mFAILED\033[0m (skips={}, failures={}, "
-          "errors={}, total={})".format(skip, fail, err, total))
+    print(
+        "Python 2: \033[91mFAILED\033[0m (skips={}, failures={}, "
+        "errors={}, total={})".format(skip, fail, err, total),
+    )
 else:
-    print("Python 2: \033[92mOK\033[0m (total={})".format(total))
+    print(f"Python 2: \033[92mOK\033[0m (total={total})")
diff --git a/example.conf b/example.conf
index 4b7fd94..16b710e 100644
--- a/example.conf
+++ b/example.conf
@@ -77,7 +77,6 @@ ignore_sigusr1 = False
 #
 #   ActiveProcessInfo - lists active processes
 #   ComputerInfo - various information
-#   HardwareInventory - information provided by the "lshw" command
 #   LoadAverage - load information
 #   MemoryInfo - memory information
 #   MountInfo - information about mount points (space available, used)
@@ -86,9 +85,17 @@ ignore_sigusr1 = False
 #   PackageMonitor - packages installed, available, versions
 #   UserMonitor - users, groups
 #   RebootRequired - whether a reboot is required or not
+#   AptPreferences - system APT preferences configuration
 #   NetworkActivity - network information (TX, RX)
 #   NetworkDevice - a list of connected network devices
 #   UpdateManager - controls when distribution upgrades are prompted
+#   CPUUsage - CPU usage information
+#   SwiftUsage - Swift cluster usage
+#   CephUsage - Ceph usage information
+#   ComputerTags - changes in computer tags
+#   UbuntuProInfo - Ubuntu Pro registration information
+#   LivePatch - Livepath status information
+#   UbuntuProRebootRequired - informs if the system needs to be rebooted
 #
 # The special value "ALL" is an alias for the full list of plugins.
 monitor_plugins = ALL
@@ -130,6 +137,9 @@ apt_update_interval = 21600
 # The number of seconds between package monitor runs.
 package_monitor_interval = 1800
 
+# The number of seconds between snap monitor runs.
+snap_monitor_interval = 1800
+
 # The URL of the http proxy to use, if any.
 # This value is optional.
 #
@@ -182,3 +192,9 @@ script_users = ALL
 # The default is 512kB
 # 2MB is allowed in this example
 #script_output_limit=2048
+
+# Whether files in /etc/apt/sources.list.d are removed when a repository
+# profile is added to this machine.
+#
+# The default is True
+#manage_sources_list_d = True
diff --git a/landscape-client.conf b/landscape-client.conf
index cf96100..af4faaf 100644
--- a/landscape-client.conf
+++ b/landscape-client.conf
@@ -9,4 +9,3 @@ log_dir = /tmp/landscape/
 log_level = debug
 pid_file = /tmp/landscape/landscape-client.pid
 ping_url = http://localhost:8081/ping
-
diff --git a/landscape/__init__.py b/landscape/__init__.py
index 23f8f79..1077067 100644
--- a/landscape/__init__.py
+++ b/landscape/__init__.py
@@ -1,6 +1,6 @@
 DEBIAN_REVISION = ""
-UPSTREAM_VERSION = "23.02"
-VERSION = "%s%s" % (UPSTREAM_VERSION, DEBIAN_REVISION)
+UPSTREAM_VERSION = "23.08"
+VERSION = f"{UPSTREAM_VERSION}{DEBIAN_REVISION}"
 
 # The minimum server API version that all Landscape servers are known to speak
 # and support. It can serve as fallback in case higher versions are not there.
diff --git a/landscape/client/accumulate.py b/landscape/client/accumulate.py
index 2d17c06..ce14c88 100644
--- a/landscape/client/accumulate.py
+++ b/landscape/client/accumulate.py
@@ -72,24 +72,31 @@ representative data at each step boundary.
 """
 
 
-class Accumulator(object):
-
+class Accumulator:
     def __init__(self, persist, step_size):
         self._persist = persist
         self._step_size = step_size
 
     def __call__(self, new_timestamp, new_free_space, key):
         previous_timestamp, accumulated_value = self._persist.get(key, (0, 0))
-        accumulated_value, step_data = \
-            accumulate(previous_timestamp, accumulated_value,
-                       new_timestamp, new_free_space, self._step_size)
+        accumulated_value, step_data = accumulate(
+            previous_timestamp,
+            accumulated_value,
+            new_timestamp,
+            new_free_space,
+            self._step_size,
+        )
         self._persist.set(key, (new_timestamp, accumulated_value))
         return step_data
 
 
-def accumulate(previous_timestamp, accumulated_value,
-               new_timestamp, new_value,
-               step_size):
+def accumulate(
+    previous_timestamp,
+    accumulated_value,
+    new_timestamp,
+    new_value,
+    step_size,
+):
     previous_step = previous_timestamp // step_size
     new_step = new_timestamp // step_size
     step_boundary = new_step * step_size
diff --git a/landscape/client/amp.py b/landscape/client/amp.py
index df4ef92..5b5d448 100644
--- a/landscape/client/amp.py
+++ b/landscape/client/amp.py
@@ -10,14 +10,15 @@ This module implements a few conveniences built around L{landscape.lib.amp} to
 let the various services connect to each other in an easy and idiomatic way,
 and have them respond to standard requests like "ping" or "exit".
 """
-import os
 import logging
+import os
 
-from landscape.lib.amp import (
-    MethodCallClientFactory, MethodCallServerFactory, RemoteObject)
+from landscape.lib.amp import MethodCallClientFactory
+from landscape.lib.amp import MethodCallServerFactory
+from landscape.lib.amp import RemoteObject
 
 
-class ComponentPublisher(object):
+class ComponentPublisher:
     """Publish a Landscape client component using a UNIX socket.
 
     Other Landscape client processes can then connect to the socket and invoke
@@ -72,7 +73,7 @@ def remote(method):
     return method
 
 
-class ComponentConnector(object):
+class ComponentConnector:
     """Utility superclass for creating connections with a Landscape component.
 
     @cvar component: The class of the component to connect to, it is expected
@@ -90,6 +91,7 @@ class ComponentConnector(object):
 
     @see: L{MethodCallClientFactory}.
     """
+
     factory = MethodCallClientFactory
     component = None  # Must be defined by sub-classes
     remote = RemoteObject
@@ -123,14 +125,14 @@ class ComponentConnector(object):
             factory.factor = factor
 
         def fire_reconnect(ignored):
-            self._reactor.fire("%s-reconnect" % self.component.name)
+            self._reactor.fire(f"{self.component.name}-reconnect")
 
         def connected(remote):
             factory.notifyOnConnect(fire_reconnect)
             return remote
 
         def log_error(failure):
-            logging.error("Error while connecting to %s", self.component.name)
+            logging.error(f"Error while connecting to {self.component.name}")
             return failure
 
         socket_path = _get_socket_path(self.component, self._config)
diff --git a/landscape/client/broker/amp.py b/landscape/client/broker/amp.py
index 94a1fa2..2278b08 100644
--- a/landscape/client/broker/amp.py
+++ b/landscape/client/broker/amp.py
@@ -1,16 +1,19 @@
-from twisted.internet.defer import maybeDeferred, execute, succeed
+from twisted.internet.defer import execute
+from twisted.internet.defer import maybeDeferred
+from twisted.internet.defer import succeed
 from twisted.python.compat import iteritems
 
-from landscape.lib.amp import RemoteObject, MethodCallArgument
-from landscape.client.amp import ComponentConnector, get_remote_methods
-from landscape.client.broker.server import BrokerServer
+from landscape.client.amp import ComponentConnector
+from landscape.client.amp import get_remote_methods
 from landscape.client.broker.client import BrokerClient
-from landscape.client.monitor.monitor import Monitor
+from landscape.client.broker.server import BrokerServer
 from landscape.client.manager.manager import Manager
+from landscape.client.monitor.monitor import Monitor
+from landscape.lib.amp import MethodCallArgument
+from landscape.lib.amp import RemoteObject
 
 
 class RemoteBroker(RemoteObject):
-
     def call_if_accepted(self, type, callable, *args):
         """Call C{callable} if C{type} is an accepted message type."""
         deferred_types = self.get_accepted_message_types()
@@ -18,6 +21,7 @@ class RemoteBroker(RemoteObject):
         def got_accepted_types(result):
             if type in result:
                 return callable(*args)
+
         deferred_types.addCallback(got_accepted_types)
         return deferred_types
 
@@ -30,11 +34,10 @@ class RemoteBroker(RemoteObject):
             callable will be fired.
         """
         result = self.listen_events(list(handlers.keys()))
-        return result.addCallback(
-            lambda args: handlers[args[0]](**args[1]))
+        return result.addCallback(lambda args: handlers[args[0]](**args[1]))
 
 
-class FakeRemoteBroker(object):
+class FakeRemoteBroker:
     """Looks like L{RemoteBroker}, but actually talks to local objects."""
 
     def __init__(self, exchanger, message_store, broker_server):
@@ -48,16 +51,19 @@ class FakeRemoteBroker(object):
         that they're encodable with AMP.
         """
         original = getattr(self.broker_server, name, None)
-        if (name in get_remote_methods(self.broker_server) and
-            original is not None and
-            callable(original)
-            ):
+        if (
+            name in get_remote_methods(self.broker_server)
+            and original is not None
+            and callable(original)
+        ):
+
             def method(*args, **kwargs):
                 for arg in args:
                     assert MethodCallArgument.check(arg)
                 for k, v in iteritems(kwargs):
                     assert MethodCallArgument.check(v)
                 return execute(original, *args, **kwargs)
+
             return method
         else:
             raise AttributeError(name)
@@ -76,8 +82,7 @@ class FakeRemoteBroker(object):
             callable will be fired.
         """
         result = self.broker_server.listen_events(handlers.keys())
-        return result.addCallback(
-            lambda args: handlers[args[0]](**args[1]))
+        return result.addCallback(lambda args: handlers[args[0]](**args[1]))
 
     def register(self):
         return succeed(None)
@@ -114,8 +119,8 @@ def get_component_registry():
         RemoteBrokerConnector,
         RemoteClientConnector,
         RemoteMonitorConnector,
-        RemoteManagerConnector
+        RemoteManagerConnector,
     ]
-    return dict(
-        (connector.component.name, connector)
-        for connector in all_connectors)
+    return {
+        connector.component.name: connector for connector in all_connectors
+    }
diff --git a/landscape/client/broker/client.py b/landscape/client/broker/client.py
index 042c18a..edbc2c2 100644
--- a/landscape/client/broker/client.py
+++ b/landscape/client/broker/client.py
@@ -1,19 +1,23 @@
-from logging import info, exception, error, debug
-import sys
 import random
+import sys
+from logging import debug
+from logging import error
+from logging import exception
+from logging import info
 
-from twisted.internet.defer import maybeDeferred, succeed
+from twisted.internet.defer import maybeDeferred
+from twisted.internet.defer import succeed
 
+from landscape.client.amp import remote
 from landscape.lib.format import format_object
 from landscape.lib.twisted_util import gather_results
-from landscape.client.amp import remote
 
 
 class HandlerNotFoundError(Exception):
     """A handler for the given message type was not found."""
 
 
-class BrokerClientPlugin(object):
+class BrokerClientPlugin:
     """A convenience for writing L{BrokerClient} plugins.
 
     This provides a register method which will set up a bunch of
@@ -32,6 +36,7 @@ class BrokerClientPlugin(object):
         sent. See L{landscape.broker.server.BrokerServer.send_message} for
         more details.
     """
+
     run_interval = 5
     run_immediately = False
     scope = None  # Global scope
@@ -58,8 +63,10 @@ class BrokerClientPlugin(object):
             if acceptance:
                 return callable(*args, **kwargs)
 
-        self.client.reactor.call_on(("message-type-acceptance-changed", type),
-                                    acceptance_changed)
+        self.client.reactor.call_on(
+            ("message-type-acceptance-changed", type),
+            acceptance_changed,
+        )
 
     def _resynchronize(self, scopes=None):
         """
@@ -106,18 +113,27 @@ class BrokerClientPlugin(object):
             if self.run_immediately:
                 self._run_with_error_log()
             if self.run_interval is not None:
-                delay = (random.random() * self.run_interval *
-                         self.client.config.stagger_launch)
-                debug("delaying start of %s for %d seconds",
-                      format_object(self), delay)
+                delay = (
+                    random.random()
+                    * self.run_interval
+                    * self.client.config.stagger_launch
+                )
+                debug(
+                    "delaying start of %s for %d seconds",
+                    format_object(self),
+                    delay,
+                )
                 self._loop = self.client.reactor.call_later(
-                    delay, self._start_loop)
+                    delay,
+                    self._start_loop,
+                )
 
     def _start_loop(self):
         """Launch the client loop."""
         self._loop = self.client.reactor.call_every(
             self.run_interval,
-            self._run_with_error_log)
+            self._run_with_error_log,
+        )
 
     def _run_with_error_log(self):
         """Wrap self.run in a Deferred with a logging error handler."""
@@ -134,7 +150,7 @@ class BrokerClientPlugin(object):
         return failure
 
 
-class BrokerClient(object):
+class BrokerClient:
     """Basic plugin registry for clients that have to deal with the broker.
 
     This knows about the needs of a client when dealing with the Landscape
@@ -148,10 +164,11 @@ class BrokerClient(object):
 
     @param reactor: A L{LandscapeReactor}.
     """
+
     name = "client"
 
     def __init__(self, reactor, config):
-        super(BrokerClient, self).__init__()
+        super().__init__()
         self.reactor = reactor
         self.broker = None
         self.config = config
@@ -179,7 +196,7 @@ class BrokerClient(object):
         """
         info("Registering plugin %s.", format_object(plugin))
         self._plugins.append(plugin)
-        if hasattr(plugin, 'plugin_name'):
+        if hasattr(plugin, "plugin_name"):
             self._plugin_names[plugin.plugin_name] = plugin
         plugin.register(self)
 
@@ -210,15 +227,16 @@ class BrokerClient(object):
         @return: The return value of the handler, if found.
         @raises: HandlerNotFoundError if the handler was not found
         """
-        type = message["type"]
-        handler = self._registered_messages.get(type)
+        typ = message["type"]
+        handler = self._registered_messages.get(typ)
         if handler is None:
-            raise HandlerNotFoundError(type)
+            raise HandlerNotFoundError(typ)
         try:
             return handler(message)
         except Exception:
-            exception("Error running message handler for type %r: %r"
-                      % (type, handler))
+            exception(
+                f"Error running message handler for type {typ!r}: {handler!r}",
+            )
 
     @remote
     def message(self, message):
@@ -259,8 +277,9 @@ class BrokerClient(object):
             results = self.reactor.fire((event_type, message_type), acceptance)
         else:
             results = self.reactor.fire(event_type, *args, **kwargs)
-        return gather_results([
-            maybeDeferred(lambda x: x, result) for result in results])
+        return gather_results(
+            [maybeDeferred(lambda x: x, result) for result in results],
+        )
 
     def handle_reconnect(self):
         """Called when the connection with the broker is established again.
@@ -273,8 +292,8 @@ class BrokerClient(object):
           - Re-register ourselves as client, so the broker knows we exist and
             will talk to us firing events and dispatching messages.
         """
-        for type in self._registered_messages:
-            self.broker.register_client_accepted_message_type(type)
+        for typ in self._registered_messages:
+            self.broker.register_client_accepted_message_type(typ)
         self.broker.register_client(self.name)
 
     @remote
diff --git a/landscape/client/broker/config.py b/landscape/client/broker/config.py
index 71e65e1..6b222fb 100644
--- a/landscape/client/broker/config.py
+++ b/landscape/client/broker/config.py
@@ -1,5 +1,4 @@
 """Configuration class for the broker."""
-
 import os
 
 from landscape.client.deployment import Configuration
@@ -12,7 +11,7 @@ class BrokerConfiguration(Configuration):
     """
 
     def __init__(self):
-        super(BrokerConfiguration, self).__init__()
+        super().__init__()
         self._original_http_proxy = os.environ.get("http_proxy")
         self._original_https_proxy = os.environ.get("https_proxy")
 
@@ -33,35 +32,67 @@ class BrokerConfiguration(Configuration):
               - C{http_proxy}
               - C{https_proxy}
         """
-        parser = super(BrokerConfiguration, self).make_parser()
+        parser = super().make_parser()
 
-        parser.add_option("-a", "--account-name", metavar="NAME",
-                          help="The account this computer belongs to.")
-        parser.add_option("-p", "--registration-key", metavar="KEY",
-                          help="The account-wide key used for "
-                               "registering clients.")
-        parser.add_option("-t", "--computer-title", metavar="TITLE",
-                          help="The title of this computer")
-        parser.add_option("--exchange-interval", default=15 * 60, type="int",
-                          metavar="INTERVAL",
-                          help="The number of seconds between server "
-                               "exchanges.")
-        parser.add_option("--urgent-exchange-interval", default=1 * 60,
-                          type="int", metavar="INTERVAL",
-                          help="The number of seconds between urgent server "
-                               "exchanges.")
-        parser.add_option("--ping-interval", default=30, type="int",
-                          metavar="INTERVAL",
-                          help="The number of seconds between pings.")
-        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.")
-        parser.add_option("--access-group", default="",
-                          help="Suggested access group for this computer.")
-        parser.add_option("--tags",
-                          help="Comma separated list of tag names to be sent "
-                               "to the server.")
+        parser.add_option(
+            "-a",
+            "--account-name",
+            metavar="NAME",
+            help="The account this computer belongs to.",
+        )
+        parser.add_option(
+            "-p",
+            "--registration-key",
+            metavar="KEY",
+            help="The account-wide key used for " "registering clients.",
+        )
+        parser.add_option(
+            "-t",
+            "--computer-title",
+            metavar="TITLE",
+            help="The title of this computer",
+        )
+        parser.add_option(
+            "--exchange-interval",
+            default=15 * 60,
+            type="int",
+            metavar="INTERVAL",
+            help="The number of seconds between server " "exchanges.",
+        )
+        parser.add_option(
+            "--urgent-exchange-interval",
+            default=1 * 60,
+            type="int",
+            metavar="INTERVAL",
+            help="The number of seconds between urgent server " "exchanges.",
+        )
+        parser.add_option(
+            "--ping-interval",
+            default=30,
+            type="int",
+            metavar="INTERVAL",
+            help="The number of seconds between pings.",
+        )
+        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.",
+        )
+        parser.add_option(
+            "--access-group",
+            default="",
+            help="Suggested access group for this computer.",
+        )
+        parser.add_option(
+            "--tags",
+            help="Comma separated list of tag names to be sent "
+            "to the server.",
+        )
 
         return parser
 
@@ -78,7 +109,7 @@ class BrokerConfiguration(Configuration):
         C{http_proxy} and C{https_proxy} environment variables based on
         that config data.
         """
-        super(BrokerConfiguration, self).load(args)
+        super().load(args)
         if self.http_proxy:
             os.environ["http_proxy"] = self.http_proxy
         elif self._original_http_proxy:
diff --git a/landscape/client/broker/exchange.py b/landscape/client/broker/exchange.py
index 924cb9a..31f32ff 100644
--- a/landscape/client/broker/exchange.py
+++ b/landscape/client/broker/exchange.py
@@ -342,23 +342,28 @@ Diagram::
   14. Schedule exchange
 
 """
-import time
 import logging
-from landscape.lib.hashlib import md5
+import time
 
-from twisted.internet.defer import Deferred, succeed
-from landscape.lib.compat import _PY3
+from twisted.internet.defer import Deferred
+from twisted.internet.defer import succeed
 
+from landscape import CLIENT_API
+from landscape import DEFAULT_SERVER_API
+from landscape import SERVER_API
 from landscape.lib.backoff import ExponentialBackoff
-from landscape.lib.fetch import HTTPCodeError, PyCurlError
+from landscape.lib.compat import _PY3
+from landscape.lib.fetch import HTTPCodeError
+from landscape.lib.fetch import PyCurlError
 from landscape.lib.format import format_delta
-from landscape.lib.message import got_next_expected, RESYNC
-from landscape.lib.versioning import is_version_higher, sort_versions
-
-from landscape import DEFAULT_SERVER_API, SERVER_API, CLIENT_API
+from landscape.lib.hashlib import md5
+from landscape.lib.message import got_next_expected
+from landscape.lib.message import RESYNC
+from landscape.lib.versioning import is_version_higher
+from landscape.lib.versioning import sort_versions
 
 
-class MessageExchange(object):
+class MessageExchange:
     """Schedule and handle message exchanges with the server.
 
     The L{MessageExchange} is the place where messages are sent to go out
@@ -376,8 +381,16 @@ class MessageExchange(object):
     # The highest server API that we are capable of speaking
     _api = SERVER_API
 
-    def __init__(self, reactor, store, transport, registration_info,
-                 exchange_store, config, max_messages=100):
+    def __init__(
+        self,
+        reactor,
+        store,
+        transport,
+        registration_info,
+        exchange_store,
+        config,
+        max_messages=100,
+    ):
         """
         @param reactor: The L{LandscapeReactor} used to fire events in response
             to messages received by the server.
@@ -421,15 +434,16 @@ class MessageExchange(object):
         A message is considered obsolete if the secure ID changed since it was
         received.
         """
-        if 'operation-id' not in message:
+        if "operation-id" not in message:
             return False
 
-        operation_id = message['operation-id']
+        operation_id = message["operation-id"]
         context = self._exchange_store.get_message_context(operation_id)
         if context is None:
             logging.warning(
-                "No message context for message with operation-id: %s"
-                % operation_id)
+                "No message context for message with "
+                f"operation-id: {operation_id}",
+            )
             return False
 
         # Compare the current secure ID with the one that was in effect when
@@ -450,7 +464,7 @@ class MessageExchange(object):
                 max_bytes = self._max_log_text_bytes
                 if len(value) > max_bytes:
                     value = value[:max_bytes]
-                    value += '...MESSAGE TRUNCATED DUE TO SIZE'
+                    value += "...MESSAGE TRUNCATED DUE TO SIZE"
                     message[field] = value
 
     def send(self, message, urgent=False):
@@ -463,14 +477,15 @@ class MessageExchange(object):
         """
         if self._message_is_obsolete(message):
             logging.info(
-                "Response message with operation-id %s was discarded "
-                "because the client's secure ID has changed in the meantime"
-                % message.get('operation-id'))
+                "Response message with operation-id "
+                f"{message.get('operation-id')} was discarded "
+                "because the client's secure ID has changed in the meantime",
+            )
             return None
 
         # These fields sometimes have really long output we need to trim
-        self.truncate_message_field('err', message)
-        self.truncate_message_field('result-text', message)
+        self.truncate_message_field("err", message)
+        self.truncate_message_field("result-text", message)
 
         if "timestamp" not in message:
             message["timestamp"] = int(self._reactor.time())
@@ -535,12 +550,16 @@ class MessageExchange(object):
     def _handle_set_intervals(self, message):
         if "exchange" in message:
             self._config.exchange_interval = message["exchange"]
-            logging.info("Exchange interval set to %d seconds." %
-                         self._config.exchange_interval)
+            logging.info(
+                "Exchange interval set "
+                f"to {self._config.exchange_interval:d} seconds.",
+            )
         if "urgent-exchange" in message:
             self._config.urgent_exchange_interval = message["urgent-exchange"]
-            logging.info("Urgent exchange interval set to %d seconds." %
-                         self._config.urgent_exchange_interval)
+            logging.info(
+                "Urgent exchange interval set "
+                f"to {self._config.urgent_exchange_interval:d} seconds.",
+            )
         self._config.write()
 
     def exchange(self):
@@ -565,19 +584,24 @@ class MessageExchange(object):
 
         start_time = time.time()
         if self._urgent_exchange:
-            logging.info("Starting urgent message exchange with %s."
-                         % self._transport.get_url())
+            logging.info(
+                "Starting urgent message exchange "
+                f"with {self._transport.get_url()}.",
+            )
         else:
-            logging.info("Starting message exchange with %s."
-                         % self._transport.get_url())
+            logging.info(
+                f"Starting message exchange with {self._transport.get_url()}.",
+            )
 
         deferred = Deferred()
 
         def exchange_completed():
             self.schedule_exchange(force=True)
             self._reactor.fire("exchange-done")
-            logging.info("Message exchange completed in %s.",
-                         format_delta(time.time() - start_time))
+            logging.info(
+                "Message exchange completed in %s.",
+                format_delta(time.time() - start_time),
+            )
             deferred.callback(None)
 
         def handle_result(result):
@@ -627,7 +651,7 @@ class MessageExchange(object):
                 # The error returned is an SSL error, most likely the server
                 # is using a self-signed certificate. Let's fire a special
                 # event so that the GUI can display a nice message.
-                logging.error("Message exchange failed: %s" % error.message)
+                logging.error(f"Message exchange failed: {error.message}")
                 ssl_error = True
 
             self._reactor.fire("exchange-failed", ssl_error=ssl_error)
@@ -636,16 +660,19 @@ class MessageExchange(object):
             logging.info("Message exchange failed.")
             exchange_completed()
 
-        self._reactor.call_in_thread(handle_result, handle_failure,
-                                     self._transport.exchange, payload,
-                                     self._registration_info.secure_id,
-                                     self._get_exchange_token(),
-                                     payload.get("server-api"))
+        self._reactor.call_in_thread(
+            handle_result,
+            handle_failure,
+            self._transport.exchange,
+            payload,
+            self._registration_info.secure_id,
+            self._get_exchange_token(),
+            payload.get("server-api"),
+        )
         return deferred
 
     def is_urgent(self):
-        """Return a bool showing whether there is an urgent exchange scheduled.
-        """
+        """Return bool showing whether there is an urgent exchange scheduled"""
         return self._urgent_exchange
 
     def schedule_exchange(self, urgent=False, force=False):
@@ -666,9 +693,12 @@ class MessageExchange(object):
         # The 'not self._exchanging' check below is currently untested.
         # It's a bit tricky to test as it is preventing rehooking 'exchange'
         # while there's a background thread doing the exchange itself.
-        if (not self._exchanging and
-            (force or self._exchange_id is None or
-             urgent and not self._urgent_exchange)):
+        if not self._exchanging and (
+            force
+            or self._exchange_id is None
+            or urgent
+            and not self._urgent_exchange
+        ):
             if urgent:
                 self._urgent_exchange = True
             if self._exchange_id:
@@ -680,18 +710,24 @@ class MessageExchange(object):
                 interval = self._config.exchange_interval
             backoff_delay = self._backoff_counter.get_random_delay()
             if backoff_delay:
-                logging.warning("Server is busy. Backing off client for {} "
-                                "seconds".format(backoff_delay))
+                logging.warning(
+                    "Server is busy. Backing off client for {} "
+                    "seconds".format(backoff_delay),
+                )
                 interval += backoff_delay
 
             if self._notification_id is not None:
                 self._reactor.cancel_call(self._notification_id)
             notification_interval = interval - 10
             self._notification_id = self._reactor.call_later(
-                notification_interval, self._notify_impending_exchange)
+                notification_interval,
+                self._notify_impending_exchange,
+            )
 
             self._exchange_id = self._reactor.call_later(
-                interval, self.exchange)
+                interval,
+                self.exchange,
+            )
 
     def _get_exchange_token(self):
         """Get the token given us by the server at the last exchange.
@@ -743,13 +779,15 @@ class MessageExchange(object):
                 del messages[i:]
         else:
             server_api = store.get_server_api()
-        payload = {"server-api": server_api,
-                   "client-api": CLIENT_API,
-                   "sequence": store.get_sequence(),
-                   "accepted-types": accepted_types_digest,
-                   "messages": messages,
-                   "total-messages": total_messages,
-                   "next-expected-sequence": store.get_server_sequence()}
+        payload = {
+            "server-api": server_api,
+            "client-api": CLIENT_API,
+            "sequence": store.get_sequence(),
+            "accepted-types": accepted_types_digest,
+            "messages": messages,
+            "total-messages": total_messages,
+            "next-expected-sequence": store.get_server_sequence(),
+        }
         accepted_client_types = self.get_client_accepted_message_types()
         accepted_client_types_hash = self._hash_types(accepted_client_types)
         if accepted_client_types_hash != self._client_accepted_types_hash:
@@ -776,7 +814,8 @@ class MessageExchange(object):
         """
         message_store = self._message_store
         self._client_accepted_types_hash = result.get(
-            "client-accepted-types-hash")
+            "client-accepted-types-hash",
+        )
         next_expected = result.get("next-expected-sequence")
         old_sequence = message_store.get_sequence()
         if next_expected is None:
@@ -793,8 +832,10 @@ class MessageExchange(object):
             # let's fire an event to tell all the plugins that they
             # ought to generate new messages so the server gets some
             # up-to-date data.
-            logging.info("Server asked for ancient data: resynchronizing all "
-                         "state with the server.")
+            logging.info(
+                "Server asked for ancient data: resynchronizing all "
+                "state with the server.",
+            )
             self.send({"type": "resynchronize"})
             self._reactor.fire("resynchronize-clients")
 
@@ -808,8 +849,9 @@ class MessageExchange(object):
         if new_uuid and isinstance(new_uuid, bytes):
             new_uuid = new_uuid.decode("ascii")
         if new_uuid != old_uuid:
-            logging.info("Server UUID changed (old=%s, new=%s)."
-                         % (old_uuid, new_uuid))
+            logging.info(
+                f"Server UUID changed (old={old_uuid}, new={new_uuid}).",
+            )
             self._reactor.fire("server-uuid-changed", old_uuid, new_uuid)
             message_store.set_server_uuid(new_uuid)
 
@@ -874,12 +916,14 @@ class MessageExchange(object):
         Any message handlers registered with L{register_message} will
         be called.
         """
-        if 'operation-id' in message:
+        if "operation-id" in message:
             # This is a message that requires a response. Store the secure ID
             # so we can check for obsolete results later.
             self._exchange_store.add_message_context(
-                message['operation-id'], self._registration_info.secure_id,
-                message['type'])
+                message["operation-id"],
+                self._registration_info.secure_id,
+                message["type"],
+            )
 
         self._reactor.fire("message", message)
         # This has plan interference! but whatever.
@@ -903,9 +947,9 @@ def get_accepted_types_diff(old_types, new_types):
     stable_types = old_types & new_types
     removed_types = old_types - new_types
     diff = []
-    diff.extend(["+%s" % type for type in added_types])
-    diff.extend(["%s" % type for type in stable_types])
-    diff.extend(["-%s" % type for type in removed_types])
+    diff.extend([f"+{typ}" for typ in added_types])
+    diff.extend([f"{typ}" for typ in stable_types])
+    diff.extend([f"-{typ}" for typ in removed_types])
     return " ".join(diff)
 
 
diff --git a/landscape/client/broker/exchangestore.py b/landscape/client/broker/exchangestore.py
index aaa9192..4fb855a 100644
--- a/landscape/client/broker/exchangestore.py
+++ b/landscape/client/broker/exchangestore.py
@@ -9,7 +9,7 @@ except ImportError:
 from landscape.lib.store import with_cursor
 
 
-class MessageContext(object):
+class MessageContext:
     """Stores a context for incoming messages that require a response.
 
     The context consists of
@@ -39,10 +39,11 @@ class MessageContext(object):
     def remove(self, cursor):
         cursor.execute(
             "DELETE FROM message_context WHERE operation_id=?",
-            (self.operation_id,))
+            (self.operation_id,),
+        )
 
 
-class ExchangeStore(object):
+class ExchangeStore:
     """Message meta data required by the L{MessageExchange}.
 
     The implementation uses a SQLite database as backend, with a single table
@@ -51,6 +52,7 @@ class ExchangeStore(object):
 
     @param filename: The name of the file that contains the sqlite database.
     """
+
     _db = None
 
     def __init__(self, filename):
@@ -61,13 +63,20 @@ class ExchangeStore(object):
 
     @with_cursor
     def add_message_context(
-            self, cursor, operation_id, secure_id, message_type):
+        self,
+        cursor,
+        operation_id,
+        secure_id,
+        message_type,
+    ):
         """Add a L{MessageContext} with the given data."""
         params = (operation_id, secure_id, message_type, time.time())
         cursor.execute(
             "INSERT INTO message_context "
             "   (operation_id, secure_id, message_type, timestamp) "
-            "   VALUES (?,?,?,?)", params)
+            "   VALUES (?,?,?,?)",
+            params,
+        )
         return MessageContext(self._db, *params)
 
     @with_cursor
@@ -75,7 +84,9 @@ class ExchangeStore(object):
         """The L{MessageContext} for the given C{operation_id} or C{None}."""
         cursor.execute(
             "SELECT operation_id, secure_id, message_type, timestamp "
-            "FROM message_context WHERE operation_id=?", (operation_id,))
+            "FROM message_context WHERE operation_id=?",
+            (operation_id,),
+        )
         row = cursor.fetchone()
         if row:
             return MessageContext(self._db, *row)
@@ -101,10 +112,12 @@ def ensure_exchange_schema(db):
             "CREATE TABLE message_context"
             " (id INTEGER PRIMARY KEY, timestamp TIMESTAMP, "
             "  secure_id TEXT NOT NULL, operation_id INTEGER NOT NULL, "
-            "  message_type text NOT NULL)")
+            "  message_type text NOT NULL)",
+        )
         cursor.execute(
             "CREATE UNIQUE INDEX msgctx_operationid_idx ON "
-            "message_context(operation_id)")
+            "message_context(operation_id)",
+        )
     except (sqlite3.OperationalError, sqlite3.DatabaseError):
         cursor.close()
         db.rollback()
diff --git a/landscape/client/broker/ping.py b/landscape/client/broker/ping.py
index 5c8062e..153be3c 100644
--- a/landscape/client/broker/ping.py
+++ b/landscape/client/broker/ping.py
@@ -48,7 +48,7 @@ from landscape.lib.fetch import fetch
 from landscape.lib.log import log_failure
 
 
-class PingClient(object):
+class PingClient:
     """An HTTP client which knows how to talk to the ping server."""
 
     def __init__(self, reactor, get_page=None):
@@ -74,10 +74,16 @@ class PingClient(object):
 
             def errback(type, value, tb):
                 page_deferred.errback(Failure(value, type, tb))
-            self._reactor.call_in_thread(page_deferred.callback, errback,
-                                         self.get_page, url,
-                                         post=True, data=data,
-                                         headers=headers)
+
+            self._reactor.call_in_thread(
+                page_deferred.callback,
+                errback,
+                self.get_page,
+                url,
+                post=True,
+                data=data,
+                headers=headers,
+            )
             page_deferred.addCallback(self._got_result)
             return page_deferred
         return defer.succeed(False)
@@ -92,7 +98,7 @@ class PingClient(object):
             return True
 
 
-class Pinger(object):
+class Pinger:
     """
     A plugin which pings the Landscape server with HTTP requests to
     see if a full exchange should be initiated.
@@ -107,8 +113,14 @@ class Pinger(object):
         scheduled ping.
     """
 
-    def __init__(self, reactor, identity, exchanger, config,
-                 ping_client_factory=PingClient):
+    def __init__(
+        self,
+        reactor,
+        identity,
+        exchanger,
+        config,
+        ping_client_factory=PingClient,
+    ):
         self._config = config
         self._identity = identity
         self._reactor = reactor
@@ -132,33 +144,42 @@ class Pinger(object):
     def ping(self):
         """Perform a ping; if there are messages, fire an exchange."""
         deferred = self._ping_client.ping(
-            self._config.ping_url, self._identity.insecure_id)
+            self._config.ping_url,
+            self._identity.insecure_id,
+        )
         deferred.addCallback(self._got_result)
         deferred.addErrback(self._got_error)
         deferred.addBoth(lambda _: self._schedule())
 
     def _got_result(self, exchange):
         if exchange:
-            info("Ping indicates message available. "
-                 "Scheduling an urgent exchange.")
+            info(
+                "Ping indicates message available. "
+                "Scheduling an urgent exchange.",
+            )
             self._exchanger.schedule_exchange(urgent=True)
 
     def _got_error(self, failure):
-        log_failure(failure,
-                    "Error contacting ping server at %s" %
-                    (self._ping_client.url,))
+        log_failure(
+            failure,
+            f"Error contacting ping server at {self._ping_client.url}",
+        )
 
     def _schedule(self):
         """Schedule a new ping using the current ping interval."""
-        self._call_id = self._reactor.call_later(self._config.ping_interval,
-                                                 self.ping)
+        self._call_id = self._reactor.call_later(
+            self._config.ping_interval,
+            self.ping,
+        )
 
     def _handle_set_intervals(self, message):
         if message["type"] == "set-intervals" and "ping" in message:
             self._config.ping_interval = message["ping"]
             self._config.write()
-            info("Ping interval set to %d seconds." %
-                 self._config.ping_interval)
+            info(
+                f"Ping interval set to {self._config.ping_interval:d} "
+                "seconds.",
+            )
         if self._call_id is not None:
             self._reactor.cancel_call(self._call_id)
             self._schedule()
@@ -170,8 +191,7 @@ class Pinger(object):
             self._call_id = None
 
 
-class FakePinger(object):
-
+class FakePinger:
     def __init__(self, *args, **kwargs):
         pass
 
diff --git a/landscape/client/broker/registration.py b/landscape/client/broker/registration.py
index 864ce99..c21186e 100644
--- a/landscape/client/broker/registration.py
+++ b/landscape/client/broker/registration.py
@@ -16,10 +16,11 @@ from twisted.internet.defer import Deferred
 from landscape.client.broker.exchange import maybe_bytes
 from landscape.client.monitor.ubuntuproinfo import get_ubuntu_pro_info
 from landscape.lib.juju import get_juju_info
-from landscape.lib.tag import is_valid_tag_list
 from landscape.lib.network import get_fqdn
-from landscape.lib.vm_info import get_vm_info, get_container_info
+from landscape.lib.tag import is_valid_tag_list
 from landscape.lib.versioning import is_version_higher
+from landscape.lib.vm_info import get_container_info
+from landscape.lib.vm_info import get_vm_info
 
 
 class RegistrationError(Exception):
@@ -31,7 +32,6 @@ class RegistrationError(Exception):
 
 
 def persist_property(name):
-
     def get(self):
         value = self._persist.get(name)
         try:
@@ -46,14 +46,13 @@ def persist_property(name):
 
 
 def config_property(name):
-
     def get(self):
         return getattr(self._config, name)
 
     return property(get)
 
 
-class Identity(object):
+class Identity:
     """Maintains details about the identity of this Landscape client.
 
     @ivar secure_id: A server-provided ID for secure message exchange.
@@ -83,7 +82,7 @@ class Identity(object):
         self._persist = persist.root_at("registration")
 
 
-class RegistrationHandler(object):
+class RegistrationHandler:
     """
     An object from which registration can be requested of the server,
     and which will handle forced ID changes from the server.
@@ -91,8 +90,16 @@ class RegistrationHandler(object):
     L{register} should be used to perform initial registration.
     """
 
-    def __init__(self, config, identity, reactor, exchange, pinger,
-                 message_store, fetch_async=None):
+    def __init__(
+        self,
+        config,
+        identity,
+        reactor,
+        exchange,
+        pinger,
+        message_store,
+        fetch_async=None,
+    ):
         self._config = config
         self._identity = identity
         self._reactor = reactor
@@ -104,8 +111,10 @@ class RegistrationHandler(object):
         self._reactor.call_on("exchange-done", self._handle_exchange_done)
         self._exchange.register_message("set-id", self._handle_set_id)
         self._exchange.register_message("unknown-id", self._handle_unknown_id)
-        self._exchange.register_message("registration",
-                                        self._handle_registration)
+        self._exchange.register_message(
+            "registration",
+            self._handle_registration,
+        )
         self._should_register = None
         self._fetch_async = fetch_async
         self._juju_data = None
@@ -116,9 +125,11 @@ class RegistrationHandler(object):
         if id.secure_id:
             return False
 
-        return bool(id.computer_title and
-                    id.account_name and
-                    self._message_store.accepts("register"))
+        return bool(
+            id.computer_title
+            and id.account_name
+            and self._message_store.accepts("register"),
+        )
 
     def register(self):
         """
@@ -186,14 +197,16 @@ class RegistrationHandler(object):
             tags = None
             logging.error("Invalid tags provided for registration.")
 
-        message = {"type": "register",
-                   "hostname": get_fqdn(),
-                   "account_name": account_name,
-                   "computer_title": identity.computer_title,
-                   "registration_password": identity.registration_key,
-                   "tags": tags,
-                   "container-info": get_container_info(),
-                   "vm-info": get_vm_info()}
+        message = {
+            "type": "register",
+            "hostname": get_fqdn(),
+            "account_name": account_name,
+            "computer_title": identity.computer_title,
+            "registration_password": identity.registration_key,
+            "tags": tags,
+            "container-info": get_container_info(),
+            "vm-info": get_vm_info(),
+        }
 
         if self._clone_secure_id:
             # We use the secure id here because the registration is encrypted
@@ -216,19 +229,20 @@ class RegistrationHandler(object):
             message["juju-info"] = {
                 "environment-uuid": self._juju_data["environment-uuid"],
                 "api-addresses": self._juju_data["api-addresses"],
-                "machine-id": self._juju_data["machine-id"]}
+                "machine-id": self._juju_data["machine-id"],
+            }
 
         # The computer is a normal computer, possibly a container.
         with_word = "with" if bool(registration_key) else "without"
-        with_tags = "and tags %s " % tags if tags else ""
-        with_group = "in access group '%s' " % group if group else ""
+        with_tags = f"and tags {tags} " if tags else ""
+        with_group = f"in access group '{group}' " if group else ""
 
         message["ubuntu_pro_info"] = json.dumps(get_ubuntu_pro_info())
 
         logging.info(
-            u"Queueing message to register with account %r %s%s"
-            "%s a password." % (
-                account_name, with_group, with_tags, with_word))
+            f"Queueing message to register with account {account_name!r} "
+            f"{with_group}{with_tags}{with_word} a password.",
+        )
         self._exchange.send(message)
 
     def _handle_set_id(self, message):
@@ -239,15 +253,18 @@ class RegistrationHandler(object):
 
         Fire C{"registration-done"} and C{"resynchronize-clients"}.
         """
-        id = self._identity
-        if id.secure_id:
-            logging.info("Overwriting secure_id with '%s'" % id.secure_id)
+        cid = self._identity
+        if cid.secure_id:
+            logging.info(f"Overwriting secure_id with '{cid.secure_id}'")
 
-        id.secure_id = message.get("id")
-        id.insecure_id = message.get("insecure-id")
-        logging.info("Using new secure-id ending with %s for account %s.",
-                     id.secure_id[-10:], id.account_name)
-        logging.debug("Using new secure-id: %s", id.secure_id)
+        cid.secure_id = message.get("id")
+        cid.insecure_id = message.get("insecure-id")
+        logging.info(
+            "Using new secure-id ending with %s for account %s.",
+            cid.secure_id[-10:],
+            cid.account_name,
+        )
+        logging.debug("Using new secure-id: %s", cid.secure_id)
         self._reactor.fire("registration-done")
         self._reactor.fire("resynchronize-clients")
 
@@ -257,19 +274,21 @@ class RegistrationHandler(object):
             self._reactor.fire("registration-failed", reason=message_info)
 
     def _handle_unknown_id(self, message):
-        id = self._identity
+        cid = self._identity
         clone = message.get("clone-of")
         if clone is None:
-            logging.info("Client has unknown secure-id for account %s."
-                         % id.account_name)
+            logging.info(
+                "Client has unknown secure-id for account "
+                f"{cid.account_name}.",
+            )
         else:  # Save the secure id as the clone, and clear it so it's renewed
-            logging.info("Client is clone of computer %s" % clone)
-            self._clone_secure_id = id.secure_id
-        id.secure_id = None
-        id.insecure_id = None
+            logging.info(f"Client is clone of computer {clone}")
+            self._clone_secure_id = cid.secure_id
+        cid.secure_id = None
+        cid.insecure_id = None
 
 
-class RegistrationResponse(object):
+class RegistrationResponse:
     """A helper for dealing with the response of a single registration request.
 
     @ivar deferred: The L{Deferred} that will be fired as per
diff --git a/landscape/client/broker/server.py b/landscape/client/broker/server.py
index 1f8d708..766c6a0 100644
--- a/landscape/client/broker/server.py
+++ b/landscape/client/broker/server.py
@@ -42,15 +42,14 @@ Diagram::
                                                       : exchange
 
 """
-
 import logging
 
 from twisted.internet.defer import Deferred
-from landscape.lib.compat import _PY3
 
-from landscape.lib.twisted_util import gather_results
 from landscape.client.amp import remote
 from landscape.client.manager.manager import FAILED
+from landscape.lib.compat import _PY3
+from landscape.lib.twisted_util import gather_results
 
 
 def event(method):
@@ -71,7 +70,7 @@ def event(method):
     return broadcast_event
 
 
-class BrokerServer(object):
+class BrokerServer:
     """
     A broker server capable of handling messages from plugins connected using
     the L{BrokerProtocol}.
@@ -82,11 +81,20 @@ class BrokerServer(object):
     @param registration: The {RegistrationHandler}.
     @param message_store: The broker's L{MessageStore}.
     """
+
     name = "broker"
 
-    def __init__(self, config, reactor, exchange, registration,
-                 message_store, pinger):
+    def __init__(
+        self,
+        config,
+        reactor,
+        exchange,
+        registration,
+        message_store,
+        pinger,
+    ):
         from landscape.client.broker.amp import get_component_registry
+
         self.connectors_registry = get_component_registry()
         self._config = config
         self._reactor = reactor
@@ -99,8 +107,10 @@ class BrokerServer(object):
 
         reactor.call_on("message", self.broadcast_message)
         reactor.call_on("impending-exchange", self.impending_exchange)
-        reactor.call_on("message-type-acceptance-changed",
-                        self.message_type_acceptance_changed)
+        reactor.call_on(
+            "message-type-acceptance-changed",
+            self.message_type_acceptance_changed,
+        )
         reactor.call_on("server-uuid-changed", self.server_uuid_changed)
         reactor.call_on("package-data-changed", self.package_data_changed)
         reactor.call_on("resynchronize-clients", self.resynchronize)
@@ -201,7 +211,9 @@ class BrokerServer(object):
             message = {k.decode("ascii"): v for k, v in message.items()}
             message["type"] = message["type"].decode("ascii")
         if isinstance(session_id, bool) and message["type"] in (
-                "operation-result", "change-packages-result"):
+            "operation-result",
+            "change-packages-result",
+        ):
             # XXX This means we're performing a Landscape-driven upgrade and
             # we're being invoked by a package-changer or release-upgrader
             # process that is running code which doesn't know about the
@@ -218,7 +230,8 @@ class BrokerServer(object):
 
         if session_id is None:
             raise RuntimeError(
-                "Session ID must be set before attempting to send a message")
+                "Session ID must be set before attempting to send a message",
+            )
         if self._message_store.is_valid_session_id(session_id):
             return self._exchanger.send(message, urgent=urgent)
 
@@ -320,7 +333,6 @@ class BrokerServer(object):
         calls = []
 
         def get_handler(event_type):
-
             def handler(**kwargs):
                 for call in calls:
                     self._reactor.cancel_call(call)
@@ -367,26 +379,30 @@ class BrokerServer(object):
         indicating as such.
         """
         opid = message.get("operation-id")
-        if (True not in results and
-            opid is not None and
-            message["type"] != "resynchronize"
-            ):
+        if (
+            True not in results
+            and opid is not None
+            and message["type"] != "resynchronize"
+        ):
 
             mtype = message["type"]
-            logging.error("Nobody handled the %s message." % (mtype,))
+            logging.error(f"Nobody handled the {mtype} message.")
 
             result_text = """\
-Landscape client failed to handle this request (%s) because the
+Landscape client failed to handle this request ({}) because the
 plugin which should handle it isn't available.  This could mean that the
 plugin has been intentionally disabled, or that the client isn't running
 properly, or you may be running an older version of the client that doesn't
 support this feature.
-""" % (mtype,)
+""".format(
+                mtype,
+            )
             response = {
                 "type": "operation-result",
                 "status": FAILED,
                 "result-text": result_text,
-                "operation-id": opid}
+                "operation-id": opid,
+            }
             self._exchanger.send(response, urgent=True)
 
     @remote
diff --git a/landscape/client/broker/service.py b/landscape/client/broker/service.py
index 7e36149..9c86267 100644
--- a/landscape/client/broker/service.py
+++ b/landscape/client/broker/service.py
@@ -1,17 +1,19 @@
 """Deployment code for the monitor."""
-
 import os
 
-from landscape.client.service import LandscapeService, run_landscape_service
 from landscape.client.amp import ComponentPublisher
-from landscape.client.broker.registration import RegistrationHandler, Identity
 from landscape.client.broker.config import BrokerConfiguration
-from landscape.client.broker.transport import HTTPTransport
 from landscape.client.broker.exchange import MessageExchange
 from landscape.client.broker.exchangestore import ExchangeStore
 from landscape.client.broker.ping import Pinger
-from landscape.client.broker.store import get_default_message_store
+from landscape.client.broker.registration import Identity
+from landscape.client.broker.registration import RegistrationHandler
 from landscape.client.broker.server import BrokerServer
+from landscape.client.broker.store import get_default_message_store
+from landscape.client.broker.transport import HTTPTransport
+from landscape.client.service import LandscapeService
+from landscape.client.service import run_landscape_service
+from landscape.client.watchdog import bootstrap_list
 
 
 class BrokerService(LandscapeService):
@@ -44,48 +46,82 @@ class BrokerService(LandscapeService):
     service_name = BrokerServer.name
 
     def __init__(self, config):
+        self._config = config
         self.persist_filename = os.path.join(
-            config.data_path, "%s.bpickle" % (self.service_name,))
-        super(BrokerService, self).__init__(config)
+            config.data_path,
+            f"{self.service_name}.bpickle",
+        )
+        super().__init__(config)
 
         self.transport = self.transport_factory(
-            self.reactor, config.url, config.ssl_public_key)
+            self.reactor,
+            config.url,
+            config.ssl_public_key,
+        )
         self.message_store = get_default_message_store(
-            self.persist, config.message_store_path)
+            self.persist,
+            config.message_store_path,
+        )
         self.identity = Identity(self.config, self.persist)
         exchange_store = ExchangeStore(self.config.exchange_store_path)
         self.exchanger = MessageExchange(
-            self.reactor, self.message_store, self.transport, self.identity,
-            exchange_store, config)
+            self.reactor,
+            self.message_store,
+            self.transport,
+            self.identity,
+            exchange_store,
+            config,
+        )
         self.pinger = self.pinger_factory(
-            self.reactor, self.identity, self.exchanger, config)
+            self.reactor,
+            self.identity,
+            self.exchanger,
+            config,
+        )
         self.registration = RegistrationHandler(
-            config, self.identity, self.reactor, self.exchanger, self.pinger,
-            self.message_store)
-        self.broker = BrokerServer(self.config, self.reactor, self.exchanger,
-                                   self.registration, self.message_store,
-                                   self.pinger)
-        self.publisher = ComponentPublisher(self.broker, self.reactor,
-                                            self.config)
-
-    def startService(self):
+            config,
+            self.identity,
+            self.reactor,
+            self.exchanger,
+            self.pinger,
+            self.message_store,
+        )
+        self.broker = BrokerServer(
+            self.config,
+            self.reactor,
+            self.exchanger,
+            self.registration,
+            self.message_store,
+            self.pinger,
+        )
+        self.publisher = ComponentPublisher(
+            self.broker,
+            self.reactor,
+            self.config,
+        )
+
+    def startService(self):  # noqa: N802
         """Start the broker.
 
         Create a L{BrokerServer} listening on C{broker_socket_path} for clients
         connecting with the L{BrokerServerConnector}, and start the
         L{MessageExchange} and L{Pinger} services.
         """
-        super(BrokerService, self).startService()
+        super().startService()
+        bootstrap_list.bootstrap(
+            data_path=self._config.data_path,
+            log_dir=self._config.log_dir,
+        )
         self.publisher.start()
         self.exchanger.start()
         self.pinger.start()
 
-    def stopService(self):
+    def stopService(self):  # noqa: N802
         """Stop the broker."""
         deferred = self.publisher.stop()
         self.exchanger.stop()
         self.pinger.stop()
-        super(BrokerService, self).stopService()
+        super().stopService()
         return deferred
 
 
diff --git a/landscape/client/broker/store.py b/landscape/client/broker/store.py
index ebab5cf..7557d45 100644
--- a/landscape/client/broker/store.py
+++ b/landscape/client/broker/store.py
@@ -91,25 +91,28 @@ See L{MessageStore} for details about how messages are stored on the file
 system and L{landscape.lib.message.got_next_expected} to check how the
 strategy for updating the pending offset and the sequence is implemented.
 """
-
 import itertools
 import logging
 import os
+import shutil
+import traceback
 import uuid
 
 from twisted.python.compat import iteritems
 
 from landscape import DEFAULT_SERVER_API
 from landscape.lib import bpickle
-from landscape.lib.fs import create_binary_file, read_binary_file
-from landscape.lib.versioning import sort_versions, is_version_higher
+from landscape.lib.fs import create_binary_file
+from landscape.lib.fs import read_binary_file
+from landscape.lib.versioning import is_version_higher
+from landscape.lib.versioning import sort_versions
 
 
 HELD = "h"
 BROKEN = "b"
 
 
-class MessageStore(object):
+class MessageStore:
     """A message store which stores its messages in a file system hierarchy.
 
     Beside the "sequence" and the "pending offset" values described in the
@@ -134,9 +137,12 @@ class MessageStore(object):
     # in case the server supports it.
     _api = DEFAULT_SERVER_API
 
-    def __init__(self, persist, directory, directory_size=1000):
+    def __init__(self, persist, directory, directory_size=1000, max_dirs=4,
+                 max_size_mb=400):
         self._directory = directory
         self._directory_size = directory_size
+        self._max_dirs = max_dirs  # Maximum number of directories in store
+        self._max_size_mb = max_size_mb  # Maximum size of message store
         self._schemas = {}
         self._original_persist = persist
         self._persist = persist.root_at("message-store")
@@ -273,7 +279,7 @@ class MessageStore(object):
                 logging.exception(e)
                 self._add_flags(filename, BROKEN)
             else:
-                if u"type" not in message:
+                if "type" not in message:
                     # Special case to decode keys for messages which were
                     # serialized by py27 prior to py3 upgrade, and having
                     # implicit byte message keys. Message may still get
@@ -281,8 +287,9 @@ class MessageStore(object):
                     # broker. (lp: #1718689)
                     message = {
                         (k if isinstance(k, str) else k.decode("ascii")): v
-                        for k, v in message.items()}
-                    message[u"type"] = message[u"type"].decode("ascii")
+                        for k, v in message.items()
+                    }
+                    message["type"] = message["type"].decode("ascii")
 
                 unknown_type = message["type"] not in accepted_types
                 unknown_api = not is_version_higher(server_api, message["api"])
@@ -292,10 +299,53 @@ class MessageStore(object):
                     messages.append(message)
         return messages
 
+    def get_messages_total_size(self):
+        """Get total size of messages directory"""
+        sizes = []
+        for dirname in os.listdir(self._directory):
+            dirpath = os.path.join(self._directory, dirname)
+            dirsize = sum(file.stat().st_size for file in os.scandir(dirpath))
+            sizes.append(dirsize)
+        return sum(sizes)
+
+    def delete_messages_over_limit(self):
+        """
+        Delete messages dirs if there's any over the max, which happens if
+        messages are queued up but not able to be sent
+        """
+
+        cur_dirs = os.listdir(self._directory)
+        cur_dirs.sort(key=int)  # Since you could have 0, .., 9, 10
+        num_dirs = len(cur_dirs)
+
+        num_dirs_to_delete = max(0, num_dirs - self._max_dirs)  # No negatives
+        dirs_to_delete = cur_dirs[:num_dirs_to_delete]  # Chop off beginning
+
+        for dirname in dirs_to_delete:
+            dirpath = os.path.join(self._directory, dirname)
+            try:
+                logging.debug(f"Trimming message store: {dirpath}")
+                shutil.rmtree(dirpath)
+            except Exception:  # We want to continue like normal if any error
+                logging.warning(traceback.format_exc())
+                logging.warning("Unable to delete message directory!")
+                logging.warning(dirpath)
+
+        # Something is wrong if after deleting a bunch of files, we are still
+        # using too much space. Rather then look around for big files, we just
+        # start over.
+        num_bytes = self.get_messages_total_size()
+        num_mb = num_bytes / 1e6
+        if num_mb > self._max_size_mb:
+            logging.warning("Messages too large! Clearing all messages!")
+            self.delete_all_messages()
+
     def delete_old_messages(self):
         """Delete messages which are unlikely to be needed in the future."""
-        for fn in itertools.islice(self._walk_messages(exclude=HELD + BROKEN),
-                                   self.get_pending_offset()):
+        for fn in itertools.islice(
+            self._walk_messages(exclude=HELD + BROKEN),
+            self.get_pending_offset(),
+        ):
             os.unlink(fn)
             containing_dir = os.path.split(fn)[0]
             if not os.listdir(containing_dir):
@@ -326,9 +376,9 @@ class MessageStore(object):
         pending_offset = self.get_pending_offset()
         for filename in self._walk_messages(exclude=BROKEN):
             flags = self._get_flags(filename)
-            if ((HELD in flags or i >= pending_offset) and
-                os.stat(filename).st_ino == message_id
-                ):
+            if (HELD in flags or i >= pending_offset) and os.stat(
+                filename,
+            ).st_ino == message_id:
                 return True
             if BROKEN not in flags and HELD not in flags:
                 i += 1
@@ -347,7 +397,8 @@ class MessageStore(object):
         if not self._persist.has("first-failure-time"):
             self._persist.set("first-failure-time", timestamp)
         continued_failure_time = timestamp - self._persist.get(
-            "first-failure-time")
+            "first-failure-time",
+        )
         if self._persist.get("blackhole-messages"):
             # Already added the resync message
             return
@@ -357,7 +408,8 @@ class MessageStore(object):
             self._persist.set("blackhole-messages", True)
             logging.warning(
                 "Unable to succesfully communicate with Landscape server "
-                "for more than a week. Waiting for resync.")
+                "for more than a week. Waiting for resync.",
+            )
 
     def add(self, message):
         """Queue a message for delivery.
@@ -373,6 +425,8 @@ class MessageStore(object):
             logging.debug("Dropped message, awaiting resync.")
             return
 
+        self.delete_messages_over_limit()
+
         server_api = self.get_server_api()
 
         if "api" not in message:
@@ -432,7 +486,8 @@ class MessageStore(object):
         """Walk the files which are definitely pending."""
         pending_offset = self.get_pending_offset()
         for i, filename in enumerate(
-                self._walk_messages(exclude=HELD + BROKEN)):
+            self._walk_messages(exclude=HELD + BROKEN),
+        ):
             if i >= pending_offset:
                 yield filename
 
@@ -443,12 +498,15 @@ class MessageStore(object):
         for message_dir in message_dirs:
             for filename in self._get_sorted_filenames(message_dir):
                 flags = set(self._get_flags(filename))
-                if (not exclude or not exclude & flags):
+                if not exclude or not exclude & flags:
                     yield self._message_dir(message_dir, filename)
 
     def _get_sorted_filenames(self, dir=""):
-        message_files = [x for x in os.listdir(self._message_dir(dir))
-                         if not x.endswith(".tmp")]
+        message_files = [
+            x
+            for x in os.listdir(self._message_dir(dir))
+            if not x.endswith(".tmp")
+        ]
         message_files.sort(key=lambda x: int(x.split("_")[0]))
         return message_files
 
@@ -549,6 +607,7 @@ def get_default_message_store(*args, **kwargs):
     Get a L{MessageStore} object with all Landscape message schemas added.
     """
     from landscape.message_schemas.server_bound import message_schemas
+
     store = MessageStore(*args, **kwargs)
     for schema in message_schemas:
         store.add_schema(schema)
diff --git a/landscape/client/broker/tests/helpers.py b/landscape/client/broker/tests/helpers.py
index 367a03f..2ce52b0 100644
--- a/landscape/client/broker/tests/helpers.py
+++ b/landscape/client/broker/tests/helpers.py
@@ -7,23 +7,24 @@ connected to remote test L{BrokerClient}.
 """
 import os
 
-from landscape.lib.persist import Persist
-from landscape.lib.testing import FakeReactor
-from landscape.client.watchdog import bootstrap_list
 from landscape.client.amp import ComponentPublisher
-from landscape.client.broker.transport import FakeTransport
+from landscape.client.broker.amp import RemoteBrokerConnector
+from landscape.client.broker.client import BrokerClient
+from landscape.client.broker.config import BrokerConfiguration
 from landscape.client.broker.exchange import MessageExchange
 from landscape.client.broker.exchangestore import ExchangeStore
-from landscape.client.broker.store import get_default_message_store
-from landscape.client.broker.registration import Identity, RegistrationHandler
 from landscape.client.broker.ping import Pinger
-from landscape.client.broker.config import BrokerConfiguration
+from landscape.client.broker.registration import Identity
+from landscape.client.broker.registration import RegistrationHandler
 from landscape.client.broker.server import BrokerServer
-from landscape.client.broker.amp import RemoteBrokerConnector
-from landscape.client.broker.client import BrokerClient
+from landscape.client.broker.store import get_default_message_store
+from landscape.client.broker.transport import FakeTransport
+from landscape.client.watchdog import bootstrap_list
+from landscape.lib.persist import Persist
+from landscape.lib.testing import FakeReactor
 
 
-class BrokerConfigurationHelper(object):
+class BrokerConfigurationHelper:
     """Setup a L{BrokerConfiguration} instance with some test config values.
 
     The following attributes will be set on your test case:
@@ -37,8 +38,10 @@ class BrokerConfigurationHelper(object):
     def set_up(self, test_case):
         data_path = test_case.makeDir()
         log_dir = test_case.makeDir()
-        test_case.config_filename = os.path.join(test_case.makeDir(),
-                                                 "client.conf")
+        test_case.config_filename = os.path.join(
+            test_case.makeDir(),
+            "client.conf",
+        )
 
         with open(test_case.config_filename, "w") as fh:
             fh.write(
@@ -47,8 +50,9 @@ class BrokerConfigurationHelper(object):
                 "computer_title = Some Computer\n"
                 "account_name = some_account\n"
                 "ping_url = http://localhost:91910\n"
-                "data_path = %s\n"
-                "log_dir = %s\n" % (data_path, log_dir))
+                f"data_path = {data_path}\n"
+                f"log_dir = {log_dir}\n",
+            )
 
         bootstrap_list.bootstrap(data_path=data_path, log_dir=log_dir)
 
@@ -87,20 +91,31 @@ class ExchangeHelper(BrokerConfigurationHelper):
     """
 
     def set_up(self, test_case):
-        super(ExchangeHelper, self).set_up(test_case)
+        super().set_up(test_case)
         test_case.persist_filename = test_case.makePersistFile()
         test_case.persist = Persist(filename=test_case.persist_filename)
         test_case.mstore = get_default_message_store(
-            test_case.persist, test_case.config.message_store_path)
+            test_case.persist,
+            test_case.config.message_store_path,
+        )
         test_case.identity = Identity(test_case.config, test_case.persist)
-        test_case.transport = FakeTransport(None, test_case.config.url,
-                                            test_case.config.ssl_public_key)
+        test_case.transport = FakeTransport(
+            None,
+            test_case.config.url,
+            test_case.config.ssl_public_key,
+        )
         test_case.reactor = FakeReactor()
         test_case.exchange_store = ExchangeStore(
-            test_case.config.exchange_store_path)
+            test_case.config.exchange_store_path,
+        )
         test_case.exchanger = MessageExchange(
-            test_case.reactor, test_case.mstore, test_case.transport,
-            test_case.identity, test_case.exchange_store, test_case.config)
+            test_case.reactor,
+            test_case.mstore,
+            test_case.transport,
+            test_case.identity,
+            test_case.exchange_store,
+            test_case.config,
+        )
 
 
 class RegistrationHelper(ExchangeHelper):
@@ -116,16 +131,27 @@ class RegistrationHelper(ExchangeHelper):
     """
 
     def set_up(self, test_case):
-        super(RegistrationHelper, self).set_up(test_case)
-        test_case.pinger = Pinger(test_case.reactor, test_case.identity,
-                                  test_case.exchanger, test_case.config)
+        super().set_up(test_case)
+        test_case.pinger = Pinger(
+            test_case.reactor,
+            test_case.identity,
+            test_case.exchanger,
+            test_case.config,
+        )
         test_case.config.cloud = getattr(test_case, "cloud", False)
         if hasattr(test_case, "juju_contents"):
             test_case.makeFile(
-                test_case.juju_contents, path=test_case.config.juju_filename)
+                test_case.juju_contents,
+                path=test_case.config.juju_filename,
+            )
         test_case.handler = RegistrationHandler(
-            test_case.config, test_case.identity, test_case.reactor,
-            test_case.exchanger, test_case.pinger, test_case.mstore)
+            test_case.config,
+            test_case.identity,
+            test_case.reactor,
+            test_case.exchanger,
+            test_case.pinger,
+            test_case.mstore,
+        )
 
 
 class BrokerServerHelper(RegistrationHelper):
@@ -139,10 +165,15 @@ class BrokerServerHelper(RegistrationHelper):
     """
 
     def set_up(self, test_case):
-        super(BrokerServerHelper, self).set_up(test_case)
-        test_case.broker = BrokerServer(test_case.config, test_case.reactor,
-                                        test_case.exchanger, test_case.handler,
-                                        test_case.mstore, test_case.pinger)
+        super().set_up(test_case)
+        test_case.broker = BrokerServer(
+            test_case.config,
+            test_case.reactor,
+            test_case.exchanger,
+            test_case.handler,
+            test_case.mstore,
+            test_case.pinger,
+        )
 
 
 class RemoteBrokerHelper(BrokerServerHelper):
@@ -168,13 +199,17 @@ class RemoteBrokerHelper(BrokerServerHelper):
     """
 
     def set_up(self, test_case):
-        super(RemoteBrokerHelper, self).set_up(test_case)
-
-        self._publisher = ComponentPublisher(test_case.broker,
-                                             test_case.reactor,
-                                             test_case.config)
-        self._connector = RemoteBrokerConnector(test_case.reactor,
-                                                test_case.config)
+        super().set_up(test_case)
+
+        self._publisher = ComponentPublisher(
+            test_case.broker,
+            test_case.reactor,
+            test_case.config,
+        )
+        self._connector = RemoteBrokerConnector(
+            test_case.reactor,
+            test_case.config,
+        )
 
         self._publisher.start()
         deferred = self._connector.connect()
@@ -183,7 +218,7 @@ class RemoteBrokerHelper(BrokerServerHelper):
     def tear_down(self, test_case):
         self._connector.disconnect()
         self._publisher.stop()
-        super(RemoteBrokerHelper, self).tear_down(test_case)
+        super().tear_down(test_case)
 
 
 class BrokerClientHelper(RemoteBrokerHelper):
@@ -204,7 +239,7 @@ class BrokerClientHelper(RemoteBrokerHelper):
     """
 
     def set_up(self, test_case):
-        super(BrokerClientHelper, self).set_up(test_case)
+        super().set_up(test_case)
         # The client needs its own reactor to avoid infinite loops
         # when the broker broadcasts and event
         test_case.client_reactor = FakeReactor()
@@ -227,10 +262,12 @@ class RemoteClientHelper(BrokerClientHelper):
     """
 
     def set_up(self, test_case):
-        super(RemoteClientHelper, self).set_up(test_case)
-        self._client_publisher = ComponentPublisher(test_case.client,
-                                                    test_case.reactor,
-                                                    test_case.config)
+        super().set_up(test_case)
+        self._client_publisher = ComponentPublisher(
+            test_case.client,
+            test_case.reactor,
+            test_case.config,
+        )
         self._client_publisher.start()
         test_case.remote.register_client("client")
         test_case.remote_client = test_case.broker.get_client("client")
@@ -239,4 +276,4 @@ class RemoteClientHelper(BrokerClientHelper):
     def tear_down(self, test_case):
         self._client_connector.disconnect()
         self._client_publisher.stop()
-        super(RemoteClientHelper, self).tear_down(test_case)
+        super().tear_down(test_case)
diff --git a/landscape/client/broker/tests/test_amp.py b/landscape/client/broker/tests/test_amp.py
index a017dc1..bc992b4 100644
--- a/landscape/client/broker/tests/test_amp.py
+++ b/landscape/client/broker/tests/test_amp.py
@@ -1,10 +1,10 @@
-import mock
+from unittest import mock
 
+from landscape.client.broker.tests.helpers import RemoteBrokerHelper
+from landscape.client.broker.tests.helpers import RemoteClientHelper
+from landscape.client.tests.helpers import DEFAULT_ACCEPTED_TYPES
+from landscape.client.tests.helpers import LandscapeTest
 from landscape.lib.amp import MethodCallError
-from landscape.client.tests.helpers import (
-        LandscapeTest, DEFAULT_ACCEPTED_TYPES)
-from landscape.client.broker.tests.helpers import (
-    RemoteBrokerHelper, RemoteClientHelper)
 
 
 class RemoteBrokerTest(LandscapeTest):
@@ -41,13 +41,13 @@ class RemoteBrokerTest(LandscapeTest):
 
         session_id = self.successResultOf(self.remote.get_session_id())
         message_id = self.successResultOf(
-            self.remote.send_message(message, session_id))
+            self.remote.send_message(message, session_id),
+        )
 
         self.assertTrue(isinstance(message_id, int))
         self.assertTrue(self.mstore.is_pending(message_id))
         self.assertFalse(self.exchanger.is_urgent())
-        self.assertMessages(self.mstore.get_pending_messages(),
-                            [message])
+        self.assertMessages(self.mstore.get_pending_messages(), [message])
 
     def test_send_message_with_urgent(self):
         """
@@ -56,8 +56,9 @@ class RemoteBrokerTest(LandscapeTest):
         message = {"type": "test"}
         self.mstore.set_accepted_types(["test"])
         session_id = self.successResultOf(self.remote.get_session_id())
-        message_id = self.successResultOf(self.remote.send_message(
-            message, session_id, urgent=True))
+        message_id = self.successResultOf(
+            self.remote.send_message(message, session_id, urgent=True),
+        )
         self.assertTrue(isinstance(message_id, int))
         self.assertTrue(self.exchanger.is_urgent())
 
@@ -95,8 +96,9 @@ class RemoteBrokerTest(LandscapeTest):
         a L{Deferred}.
         """
         # This should make the registration succeed
-        self.transport.responses.append([{"type": "set-id", "id": "abc",
-                                          "insecure-id": "def"}])
+        self.transport.responses.append(
+            [{"type": "set-id", "id": "abc", "insecure-id": "def"}],
+        )
         result = self.remote.register()
         return self.assertSuccess(result, None)
 
@@ -130,7 +132,8 @@ class RemoteBrokerTest(LandscapeTest):
             self.assertEqual(response, None)
             self.assertEqual(
                 self.exchanger.get_client_accepted_message_types(),
-                sorted(["type"] + DEFAULT_ACCEPTED_TYPES))
+                sorted(["type"] + DEFAULT_ACCEPTED_TYPES),
+            )
 
         result = self.remote.register_client_accepted_message_type("type")
         return result.addCallback(assert_response)
@@ -159,8 +162,11 @@ class RemoteBrokerTest(LandscapeTest):
         The L{RemoteBroker.call_if_accepted} method doesn't do anything if the
         given message type is not accepted.
         """
-        function = (lambda: 1 / 0)
-        result = self.remote.call_if_accepted("test", function)
+
+        def division_by_zero():
+            raise ZeroDivisionError()
+
+        result = self.remote.call_if_accepted("test", division_by_zero)
         return self.assertSuccess(result, None)
 
     def test_listen_events(self):
@@ -181,8 +187,9 @@ class RemoteBrokerTest(LandscapeTest):
         """
         callback1 = mock.Mock()
         callback2 = mock.Mock(return_value=123)
-        deferred = self.remote.call_on_event({"event1": callback1,
-                                              "event2": callback2})
+        deferred = self.remote.call_on_event(
+            {"event1": callback1, "event2": callback2},
+        )
         self.reactor.call_later(0.05, self.reactor.fire, "event2")
         self.reactor.advance(0.05)
         self.remote._factory.fake_connection.flush()
@@ -228,8 +235,10 @@ class RemoteClientTest(LandscapeTest):
         a L{Deferred}.
         """
         handler = mock.Mock()
-        with mock.patch.object(self.client.broker,
-                               "register_client_accepted_message_type") as m:
+        with mock.patch.object(
+            self.client.broker,
+            "register_client_accepted_message_type",
+        ) as m:
             # We need to register a test message handler to let the dispatch
             # message method call succeed
             self.client.register_message("test", handler)
diff --git a/landscape/client/broker/tests/test_client.py b/landscape/client/broker/tests/test_client.py
index 3295b02..219cc0c 100644
--- a/landscape/client/broker/tests/test_client.py
+++ b/landscape/client/broker/tests/test_client.py
@@ -1,14 +1,14 @@
-import mock
+from unittest import mock
 
 from twisted.internet import reactor
 from twisted.internet.defer import Deferred
 
-from landscape.lib.twisted_util import gather_results
-from landscape.client.tests.helpers import (
-        LandscapeTest, DEFAULT_ACCEPTED_TYPES)
+from landscape.client.broker.client import BrokerClientPlugin
+from landscape.client.broker.client import HandlerNotFoundError
 from landscape.client.broker.tests.helpers import BrokerClientHelper
-from landscape.client.broker.client import (
-        BrokerClientPlugin, HandlerNotFoundError)
+from landscape.client.tests.helpers import DEFAULT_ACCEPTED_TYPES
+from landscape.client.tests.helpers import LandscapeTest
+from landscape.lib.twisted_util import gather_results
 
 
 class BrokerClientTest(LandscapeTest):
@@ -45,7 +45,8 @@ class BrokerClientTest(LandscapeTest):
         getting a session id.
         """
         test_session_id = self.successResultOf(
-            self.client.broker.get_session_id(scope="test"))
+            self.client.broker.get_session_id(scope="test"),
+        )
         plugin = BrokerClientPlugin()
         plugin.scope = "test"
         self.client.add(plugin)
@@ -130,8 +131,10 @@ class BrokerClientTest(LandscapeTest):
         If a plugin has a run method, the reactor will call it every
         run_interval, but will stop and log if it raises unhandled exceptions.
         """
+
         class RunFailure(Exception):
             pass
+
         # log helper should not complain on the error we're testing
         self.log_helper.ignore_errors("BrokerClientPlugin.*")
         plugin = BrokerClientPlugin()
@@ -146,7 +149,8 @@ class BrokerClientTest(LandscapeTest):
         # message entry that would be present on a live client.
         self.assertIn(
             "ERROR: BrokerClientPlugin raised an uncaught exception",
-            self.logfile.getvalue())
+            self.logfile.getvalue(),
+        )
 
     def test_run_interval_blocked_during_resynch(self):
         """
@@ -220,7 +224,8 @@ class BrokerClientTest(LandscapeTest):
         def got_result(result):
             self.assertEqual(
                 self.exchanger.get_client_accepted_message_types(),
-                sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES))
+                sorted(["bar", "foo"] + DEFAULT_ACCEPTED_TYPES),
+            )
 
         return gather_results([result1, result2]).addCallback(got_result)
 
@@ -251,8 +256,10 @@ class BrokerClientTest(LandscapeTest):
 
         def dispatch_message(result):
             self.assertIs(self.client.dispatch_message(message), None)
-            self.assertTrue("Error running message handler for type 'foo'" in
-                            self.logfile.getvalue())
+            self.assertTrue(
+                "Error running message handler for type 'foo'"
+                in self.logfile.getvalue(),
+            )
             handle_message.assert_called_once_with(message)
 
         result = self.client.register_message("foo", handle_message)
@@ -263,8 +270,11 @@ class BrokerClientTest(LandscapeTest):
         L{BrokerClient.dispatch_message} raises an error if no handler was
         found for the given message.
         """
-        error = self.assertRaises(HandlerNotFoundError,
-                                  self.client.dispatch_message, {"type": "x"})
+        error = self.assertRaises(
+            HandlerNotFoundError,
+            self.client.dispatch_message,
+            {"type": "x"},
+        )
         self.assertEqual(str(error), "x")
 
     def test_message(self):
@@ -326,8 +336,9 @@ class BrokerClientTest(LandscapeTest):
         self.client.add(plugin1)
         self.client.add(plugin2)
         self.client.exchange()
-        self.assertTrue("Error during plugin exchange" in
-                        self.logfile.getvalue())
+        self.assertTrue(
+            "Error during plugin exchange" in self.logfile.getvalue(),
+        )
         self.assertTrue("ZeroDivisionError" in self.logfile.getvalue())
         plugin1.exchange.assert_called_once_with()
         plugin2.exchange.assert_called_once_with()
@@ -342,8 +353,10 @@ class BrokerClientTest(LandscapeTest):
         plugin.exchange = mock.Mock()
         self.client.add(plugin)
         self.client_reactor.fire("impending-exchange")
-        self.assertTrue("Got notification of impending exchange. "
-                        "Notifying all plugins." in self.logfile.getvalue())
+        self.assertTrue(
+            "Got notification of impending exchange. "
+            "Notifying all plugins." in self.logfile.getvalue(),
+        )
         plugin.exchange.assert_called_once_with()
 
     def test_fire_event(self):
@@ -415,7 +428,9 @@ class BrokerClientTest(LandscapeTest):
             calls = [mock.call("bar"), mock.call("foo")]
 
             broker.register_client_accepted_message_type.assert_has_calls(
-                calls, any_order=True)
+                calls,
+                any_order=True,
+            )
             broker.register_client.assert_called_once_with("client")
 
         return gather_results([result1, result2]).addCallback(got_result)
diff --git a/landscape/client/broker/tests/test_config.py b/landscape/client/broker/tests/test_config.py
index 0b60fc4..b5236ae 100644
--- a/landscape/client/broker/tests/test_config.py
+++ b/landscape/client/broker/tests/test_config.py
@@ -1,8 +1,8 @@
 import os
 
 from landscape.client.broker.config import BrokerConfiguration
-from landscape.lib.testing import EnvironSaverHelper
 from landscape.client.tests.helpers import LandscapeTest
+from landscape.lib.testing import EnvironSaverHelper
 
 
 class ConfigurationTests(LandscapeTest):
@@ -20,9 +20,16 @@ class ConfigurationTests(LandscapeTest):
             del os.environ["https_proxy"]
 
         configuration = BrokerConfiguration()
-        configuration.load(["--http-proxy", "foo",
-                            "--https-proxy", "bar",
-                            "--url", "whatever"])
+        configuration.load(
+            [
+                "--http-proxy",
+                "foo",
+                "--https-proxy",
+                "bar",
+                "--url",
+                "whatever",
+            ],
+        )
         self.assertEqual(os.environ["http_proxy"], "foo")
         self.assertEqual(os.environ["https_proxy"], "bar")
 
@@ -53,9 +60,9 @@ class ConfigurationTests(LandscapeTest):
         os.environ["https_proxy"] = "originals"
 
         configuration = BrokerConfiguration()
-        configuration.load(["--http-proxy", "x",
-                            "--https-proxy", "y",
-                            "--url", "whatever"])
+        configuration.load(
+            ["--http-proxy", "x", "--https-proxy", "y", "--url", "whatever"],
+        )
         self.assertEqual(os.environ["http_proxy"], "x")
         self.assertEqual(os.environ["https_proxy"], "y")
 
@@ -74,10 +81,12 @@ class ConfigurationTests(LandscapeTest):
         The 'urgent_exchange_interval, 'exchange_interval' and 'ping_interval'
         values specified in the configuration file are converted to integers.
         """
-        filename = self.makeFile("[client]\n"
-                                 "urgent_exchange_interval = 12\n"
-                                 "exchange_interval = 34\n"
-                                 "ping_interval = 6\n")
+        filename = self.makeFile(
+            "[client]\n"
+            "urgent_exchange_interval = 12\n"
+            "exchange_interval = 34\n"
+            "ping_interval = 6\n",
+        )
 
         configuration = BrokerConfiguration()
         configuration.load(["--config", filename, "--url", "whatever"])
@@ -91,8 +100,9 @@ class ConfigurationTests(LandscapeTest):
         The 'tags' value specified in the configuration file is not converted
         to a list (it must be a string). See bug #1228301.
         """
-        filename = self.makeFile("[client]\n"
-                                 "tags = check,linode,profile-test")
+        filename = self.makeFile(
+            "[client]\ntags = check,linode,profile-test",
+        )
 
         configuration = BrokerConfiguration()
         configuration.load(["--config", filename, "--url", "whatever"])
@@ -104,8 +114,7 @@ class ConfigurationTests(LandscapeTest):
         The 'access_group' value specified in the configuration file is
         passed through.
         """
-        filename = self.makeFile("[client]\n"
-                                 "access_group = webserver")
+        filename = self.makeFile("[client]\naccess_group = webserver")
 
         configuration = BrokerConfiguration()
         configuration.load(["--config", filename, "--url", "whatever"])
@@ -122,5 +131,7 @@ class ConfigurationTests(LandscapeTest):
         configuration = BrokerConfiguration()
         configuration.load(["--config", filename])
 
-        self.assertEqual(configuration.url,
-                         "https://landscape.canonical.com/message-system")
+        self.assertEqual(
+            configuration.url,
+            "https://landscape.canonical.com/message-system",
+        )
diff --git a/landscape/client/broker/tests/test_exchange.py b/landscape/client/broker/tests/test_exchange.py
index 3736bd4..bc7fb5f 100644
--- a/landscape/client/broker/tests/test_exchange.py
+++ b/landscape/client/broker/tests/test_exchange.py
@@ -1,22 +1,23 @@
-import mock
+from unittest import mock
 
 from landscape import CLIENT_API
-from landscape.lib.persist import Persist
-from landscape.lib.fetch import HTTPCodeError, PyCurlError
-from landscape.lib.hashlib import md5
-from landscape.lib.schema import Int
-from landscape.message_schemas.message import Message
 from landscape.client.broker.config import BrokerConfiguration
-from landscape.client.broker.exchange import (
-        get_accepted_types_diff, MessageExchange)
-from landscape.client.broker.transport import FakeTransport
-from landscape.client.broker.store import MessageStore
+from landscape.client.broker.exchange import get_accepted_types_diff
+from landscape.client.broker.exchange import MessageExchange
 from landscape.client.broker.ping import Pinger
 from landscape.client.broker.registration import RegistrationHandler
-from landscape.client.tests.helpers import (
-        LandscapeTest, DEFAULT_ACCEPTED_TYPES)
-from landscape.client.broker.tests.helpers import ExchangeHelper
 from landscape.client.broker.server import BrokerServer
+from landscape.client.broker.store import MessageStore
+from landscape.client.broker.tests.helpers import ExchangeHelper
+from landscape.client.broker.transport import FakeTransport
+from landscape.client.tests.helpers import DEFAULT_ACCEPTED_TYPES
+from landscape.client.tests.helpers import LandscapeTest
+from landscape.lib.fetch import HTTPCodeError
+from landscape.lib.fetch import PyCurlError
+from landscape.lib.hashlib import md5
+from landscape.lib.persist import Persist
+from landscape.lib.schema import Int
+from landscape.message_schemas.message import Message
 
 
 class MessageExchangeTest(LandscapeTest):
@@ -24,11 +25,11 @@ class MessageExchangeTest(LandscapeTest):
     helpers = [ExchangeHelper]
 
     def setUp(self):
-        super(MessageExchangeTest, self).setUp()
+        super().setUp()
         self.mstore.add_schema(Message("empty", {}))
         self.mstore.add_schema(Message("data", {"data": Int()}))
         self.mstore.add_schema(Message("holdme", {}))
-        self.identity.secure_id = 'needs-to-be-set-for-tests-to-pass'
+        self.identity.secure_id = "needs-to-be-set-for-tests-to-pass"
 
     def wait_for_exchange(self, urgent=False, factor=1, delta=0):
         if urgent:
@@ -52,9 +53,14 @@ class MessageExchangeTest(LandscapeTest):
         session IDs are expired, so any new messages being sent with those IDs
         will be discarded.
         """
-        broker = BrokerServer(self.config, self.reactor,
-                              self.exchanger, None,
-                              self.mstore, None)
+        broker = BrokerServer(
+            self.config,
+            self.reactor,
+            self.exchanger,
+            None,
+            self.mstore,
+            None,
+        )
 
         disk_session_id = self.mstore.get_session_id(scope="disk")
         package_session_id = self.mstore.get_session_id(scope="package")
@@ -72,9 +78,14 @@ class MessageExchangeTest(LandscapeTest):
         When a resynchronisation event occurs with a scope existing session IDs
         for that scope are expired, all other session IDs are unaffected.
         """
-        broker = BrokerServer(self.config, self.reactor,
-                              self.exchanger, None,
-                              self.mstore, None)
+        broker = BrokerServer(
+            self.config,
+            self.reactor,
+            self.exchanger,
+            None,
+            self.mstore,
+            None,
+        )
 
         disk_session_id = self.mstore.get_session_id(scope="disk")
         package_session_id = self.mstore.get_session_id(scope="package")
@@ -105,9 +116,10 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual(len(self.transport.payloads), 1)
         messages = self.transport.payloads[0]["messages"]
-        self.assertEqual(messages, [{"type": "empty",
-                                     "timestamp": 0,
-                                     "api": b"3.2"}])
+        self.assertEqual(
+            messages,
+            [{"type": "empty", "timestamp": 0, "api": b"3.2"}],
+        )
 
     def test_send_urgent(self):
         """
@@ -118,8 +130,10 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.send({"type": "empty"}, urgent=True)
         self.wait_for_exchange(urgent=True)
         self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [{"type": "empty"}])
+        self.assertMessages(
+            self.transport.payloads[0]["messages"],
+            [{"type": "empty"}],
+        )
 
     def test_send_urgent_wont_reschedule(self):
         """
@@ -132,8 +146,10 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.send({"type": "empty"}, urgent=True)
         self.wait_for_exchange(urgent=True, factor=0.5)
         self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [{"type": "empty"}, {"type": "empty"}])
+        self.assertMessages(
+            self.transport.payloads[0]["messages"],
+            [{"type": "empty"}, {"type": "empty"}],
+        )
 
     def test_send_returns_message_id(self):
         """
@@ -151,14 +167,15 @@ class MessageExchangeTest(LandscapeTest):
         """
         self.mstore.set_accepted_types(["package-reporter-result"])
         self.exchanger._max_log_text_bytes = 5
-        self.exchanger.send({"type": "package-reporter-result", "err": "E"*10,
-                             "code": 0})
+        self.exchanger.send(
+            {"type": "package-reporter-result", "err": "E" * 10, "code": 0},
+        )
         self.exchanger.exchange()
         self.assertEqual(len(self.transport.payloads), 1)
         messages = self.transport.payloads[0]["messages"]
-        self.assertIn('TRUNCATED', messages[0]['err'])
-        self.assertIn('EEEEE', messages[0]['err'])
-        self.assertNotIn('EEEEEE', messages[0]['err'])
+        self.assertIn("TRUNCATED", messages[0]["err"])
+        self.assertIn("EEEEE", messages[0]["err"])
+        self.assertNotIn("EEEEEE", messages[0]["err"])
 
     def test_send_big_message_trimmed_result(self):
         """
@@ -166,14 +183,21 @@ class MessageExchangeTest(LandscapeTest):
         """
         self.mstore.set_accepted_types(["operation-result"])
         self.exchanger._max_log_text_bytes = 5
-        self.exchanger.send({"type": "operation-result", "result-text": "E"*10,
-                             "code": 0, "status": 0, "operation-id": 0})
+        self.exchanger.send(
+            {
+                "type": "operation-result",
+                "result-text": "E" * 10,
+                "code": 0,
+                "status": 0,
+                "operation-id": 0,
+            },
+        )
         self.exchanger.exchange()
         self.assertEqual(len(self.transport.payloads), 1)
         messages = self.transport.payloads[0]["messages"]
-        self.assertIn('TRUNCATED', messages[0]['result-text'])
-        self.assertIn('EEEEE', messages[0]['result-text'])
-        self.assertNotIn('EEEEEE', messages[0]['result-text'])
+        self.assertIn("TRUNCATED", messages[0]["result-text"])
+        self.assertIn("EEEEE", messages[0]["result-text"])
+        self.assertNotIn("EEEEEE", messages[0]["result-text"])
 
     def test_send_small_message_not_trimmed(self):
         """
@@ -181,13 +205,14 @@ class MessageExchangeTest(LandscapeTest):
         """
         self.mstore.set_accepted_types(["package-reporter-result"])
         self.exchanger._max_log_text_bytes = 4
-        self.exchanger.send({"type": "package-reporter-result", "err": "E"*4,
-                             "code": 0})
+        self.exchanger.send(
+            {"type": "package-reporter-result", "err": "E" * 4, "code": 0},
+        )
         self.exchanger.exchange()
         self.assertEqual(len(self.transport.payloads), 1)
         messages = self.transport.payloads[0]["messages"]
-        self.assertNotIn('TRUNCATED', messages[0]['err'])
-        self.assertIn('EEEE', messages[0]['err'])
+        self.assertNotIn("TRUNCATED", messages[0]["err"])
+        self.assertIn("EEEE", messages[0]["err"])
 
     def test_wb_include_accepted_types(self):
         """
@@ -204,7 +229,8 @@ class MessageExchangeTest(LandscapeTest):
         types.
         """
         self.exchanger.handle_message(
-            {"type": "accepted-types", "types": ["foo"]})
+            {"type": "accepted-types", "types": ["foo"]},
+        )
         self.assertEqual(self.mstore.get_accepted_types(), ["foo"])
 
     def test_message_type_acceptance_changed_event(self):
@@ -212,13 +238,18 @@ class MessageExchangeTest(LandscapeTest):
 
         def callback(type, accepted):
             stash.append((type, accepted))
+
         self.reactor.call_on("message-type-acceptance-changed", callback)
         self.exchanger.handle_message(
-            {"type": "accepted-types", "types": ["a", "b"]})
+            {"type": "accepted-types", "types": ["a", "b"]},
+        )
         self.exchanger.handle_message(
-            {"type": "accepted-types", "types": ["b", "c"]})
-        self.assertCountEqual(stash, [("a", True), ("b", True),
-                                      ("a", False), ("c", True)])
+            {"type": "accepted-types", "types": ["b", "c"]},
+        )
+        self.assertCountEqual(
+            stash,
+            [("a", True), ("b", True), ("a", False), ("c", True)],
+        )
 
     def test_wb_accepted_types_roundtrip(self):
         """
@@ -226,11 +257,11 @@ class MessageExchangeTest(LandscapeTest):
         should affect its future payloads.
         """
         self.exchanger.handle_message(
-            {"type": "accepted-types", "types": ["ack", "bar"]})
+            {"type": "accepted-types", "types": ["ack", "bar"]},
+        )
         payload = self.exchanger._make_payload()
         self.assertIn("accepted-types", payload)
-        self.assertEqual(payload["accepted-types"],
-                         md5(b"ack;bar").digest())
+        self.assertEqual(payload["accepted-types"], md5(b"ack;bar").digest())
 
     def test_accepted_types_causes_urgent_if_held_messages_exist(self):
         """
@@ -240,11 +271,14 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.send({"type": "holdme"})
         self.assertEqual(self.mstore.get_pending_messages(), [])
         self.exchanger.handle_message(
-            {"type": "accepted-types", "types": ["holdme"]})
+            {"type": "accepted-types", "types": ["holdme"]},
+        )
         self.wait_for_exchange(urgent=True)
         self.assertEqual(len(self.transport.payloads), 1)
-        self.assertMessages(self.transport.payloads[0]["messages"],
-                            [{"type": "holdme"}])
+        self.assertMessages(
+            self.transport.payloads[0]["messages"],
+            [{"type": "holdme"}],
+        )
 
     def test_accepted_types_no_urgent_without_held(self):
         """
@@ -253,8 +287,10 @@ class MessageExchangeTest(LandscapeTest):
         """
         self.exchanger.send({"type": "holdme"})
         self.assertEqual(self.transport.payloads, [])
-        self.reactor.fire("message",
-                          {"type": "accepted-types", "types": ["irrelevant"]})
+        self.reactor.fire(
+            "message",
+            {"type": "accepted-types", "types": ["irrelevant"]},
+        )
         self.assertEqual(len(self.transport.payloads), 0)
 
     def test_sequence_is_committed_immediately(self):
@@ -294,8 +330,7 @@ class MessageExchangeTest(LandscapeTest):
         def handler(message):
             Persist(filename=self.persist_filename)
             store = MessageStore(self.persist, self.config.message_store_path)
-            self.assertEqual(store.get_server_sequence(),
-                             self.message_counter)
+            self.assertEqual(store.get_server_sequence(), self.message_counter)
             self.message_counter += 1
             handled.append(True)
 
@@ -324,8 +359,10 @@ class MessageExchangeTest(LandscapeTest):
         self.wait_for_exchange(urgent=True)
 
         self.assertEqual(len(self.transport.payloads), 2)
-        self.assertMessages(self.transport.payloads[1]["messages"],
-                            [{"type": "empty"}])
+        self.assertMessages(
+            self.transport.payloads[1]["messages"],
+            [{"type": "empty"}],
+        )
 
     def test_server_expects_older_messages(self):
         """
@@ -361,22 +398,29 @@ class MessageExchangeTest(LandscapeTest):
         self.assertEqual(exchanged, [True])
 
         payload = self.transport.payloads[-1]
-        self.assertMessages(payload["messages"],
-                            [{"type": "data", "data": 1},
-                             {"type": "data", "data": 2},
-                             {"type": "data", "data": 3}])
+        self.assertMessages(
+            payload["messages"],
+            [
+                {"type": "data", "data": 1},
+                {"type": "data", "data": 2},
+                {"type": "data", "data": 3},
+            ],
+        )
         self.assertEqual(payload["sequence"], 1)
         self.assertEqual(payload["next-expected-sequence"], 0)
 
-    @mock.patch("landscape.client.broker.store.MessageStore"
-                ".delete_old_messages")
-    def test_pending_offset_when_next_expected_too_high(self,
-                                                        mock_rm_all_messages):
-        '''
+    @mock.patch(
+        "landscape.client.broker.store.MessageStore.delete_old_messages",
+    )
+    def test_pending_offset_when_next_expected_too_high(
+        self,
+        mock_rm_all_messages,
+    ):
+        """
         When next expected sequence received from server is too high, then the
         pending offset should reset to zero. This will cause the client to
         resend the pending messages.
-        '''
+        """
 
         self.mstore.set_accepted_types(["data"])
         self.mstore.add({"type": "data", "data": 0})
@@ -399,12 +443,12 @@ class MessageExchangeTest(LandscapeTest):
         self.assertTrue(mock_rm_all_messages.called)
 
     def test_payloads_when_next_expected_too_high(self):
-        '''
+        """
         When next expected sequence received from server is too high, then the
         current messages should get sent again since we don't have confirmation
         that the server received it. Also previous messages should not get
         repeated.
-        '''
+        """
 
         self.mstore.set_accepted_types(["data"])
 
@@ -426,17 +470,16 @@ class MessageExchangeTest(LandscapeTest):
         self.assertTrue(last_messages)
 
         # Confirm earlier messages are not resent
-        self.assertNotIn(message0["data"],
-                         [m["data"] for m in last_messages])
+        self.assertNotIn(message0["data"], [m["data"] for m in last_messages])
 
         # Confirm contents of payload
         self.assertEqual([message1, message2], last_messages)
 
     def test_resync_when_next_expected_too_high(self):
-        '''
+        """
         When next expected sequence received from the server is too high, then
         a resynchronize should happen
-        '''
+        """
 
         self.mstore.set_accepted_types(["empty", "resynchronize"])
         self.mstore.add({"type": "empty"})
@@ -447,17 +490,24 @@ class MessageExchangeTest(LandscapeTest):
         self.reactor.call_on("resynchronize-clients", lambda scope=None: None)
 
         self.exchanger.exchange()
-        self.assertMessage(self.mstore.get_pending_messages()[-1],
-                           {"type": "resynchronize"})
+        self.assertMessage(
+            self.mstore.get_pending_messages()[-1],
+            {"type": "resynchronize"},
+        )
 
     def test_start_with_urgent_exchange(self):
         """
         Immediately after registration, an urgent exchange should be scheduled.
         """
         transport = FakeTransport()
-        exchanger = MessageExchange(self.reactor, self.mstore, transport,
-                                    self.identity, self.exchange_store,
-                                    self.config)
+        exchanger = MessageExchange(
+            self.reactor,
+            self.mstore,
+            transport,
+            self.identity,
+            self.exchange_store,
+            self.config,
+        )
         exchanger.start()
         self.wait_for_exchange(urgent=True)
         self.assertEqual(len(transport.payloads), 1)
@@ -499,13 +549,17 @@ class MessageExchangeTest(LandscapeTest):
         self.mstore.record_success = mock_record_success
 
         exchanger = MessageExchange(
-            self.reactor, self.mstore, self.transport,
-            self.identity, self.exchange_store, self.config)
+            self.reactor,
+            self.mstore,
+            self.transport,
+            self.identity,
+            self.exchange_store,
+            self.config,
+        )
         exchanger.exchange()
 
         mock_record_success.assert_called_with(mock.ANY)
-        self.assertTrue(
-            type(mock_record_success.call_args[0][0]) is int)
+        self.assertTrue(type(mock_record_success.call_args[0][0]) is int)
 
     def test_ancient_causes_resynchronize(self):
         """
@@ -530,15 +584,20 @@ class MessageExchangeTest(LandscapeTest):
             # should come AFTER the "resynchronize" message that is generated
             # by the exchange code itself.
             self.mstore.add({"type": "data", "data": 999})
+
         self.reactor.call_on("resynchronize-clients", resynchronize)
 
         # This exchange call will notice the server is asking for an old
         # message and fire the event:
         self.exchanger.exchange()
-        self.assertMessages(self.mstore.get_pending_messages(),
-                            [{"type": "empty"},
-                             {"type": "resynchronize"},
-                             {"type": "data", "data": 999}])
+        self.assertMessages(
+            self.mstore.get_pending_messages(),
+            [
+                {"type": "empty"},
+                {"type": "resynchronize"},
+                {"type": "data", "data": 999},
+            ],
+        )
 
     def test_resynchronize_msg_causes_resynchronize_response_then_event(self):
         """
@@ -551,15 +610,20 @@ class MessageExchangeTest(LandscapeTest):
 
         def resynchronized(scopes=None):
             self.mstore.add({"type": "empty"})
+
         self.reactor.call_on("resynchronize-clients", resynchronized)
 
-        self.transport.responses.append([{"type": "resynchronize",
-                                          "operation-id": 123}])
+        self.transport.responses.append(
+            [{"type": "resynchronize", "operation-id": 123}],
+        )
         self.exchanger.exchange()
-        self.assertMessages(self.mstore.get_pending_messages(),
-                            [{"type": "resynchronize",
-                              "operation-id": 123},
-                             {"type": "empty"}])
+        self.assertMessages(
+            self.mstore.get_pending_messages(),
+            [
+                {"type": "resynchronize", "operation-id": 123},
+                {"type": "empty"},
+            ],
+        )
 
     def test_scopes_are_copied_from_incoming_resynchronize_messages(self):
         """
@@ -574,9 +638,15 @@ class MessageExchangeTest(LandscapeTest):
 
         self.reactor.call_on("resynchronize-clients", resynchronized)
 
-        self.transport.responses.append([{"type": "resynchronize",
-                                          "operation-id": 123,
-                                          "scopes": ["disk", "users"]}])
+        self.transport.responses.append(
+            [
+                {
+                    "type": "resynchronize",
+                    "operation-id": 123,
+                    "scopes": ["disk", "users"],
+                },
+            ],
+        )
         self.exchanger.exchange()
         self.assertEqual(["disk", "users"], fired_scopes)
 
@@ -622,8 +692,10 @@ class MessageExchangeTest(LandscapeTest):
 
     def test_old_sequence_id_does_not_cause_resynchronize(self):
         resynchronized = []
-        self.reactor.call_on("resynchronize",
-                             lambda: resynchronized.append(True))
+        self.reactor.call_on(
+            "resynchronize",
+            lambda: resynchronized.append(True),
+        )
 
         self.mstore.set_accepted_types(["empty"])
         self.mstore.add({"type": "empty"})
@@ -663,9 +735,10 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
 
         payload = self.transport.payloads[-1]
-        self.assertMessages(payload["messages"],
-                            [{"type": "a", "api": b"1.0"},
-                             {"type": "b", "api": b"1.0"}])
+        self.assertMessages(
+            payload["messages"],
+            [{"type": "a", "api": b"1.0"}, {"type": "b", "api": b"1.0"}],
+        )
         self.assertEqual(payload.get("client-api"), CLIENT_API)
         self.assertEqual(payload.get("server-api"), b"1.0")
         self.assertEqual(self.transport.message_api, b"1.0")
@@ -673,9 +746,10 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
 
         payload = self.transport.payloads[-1]
-        self.assertMessages(payload["messages"],
-                            [{"type": "c", "api": b"1.1"},
-                             {"type": "d", "api": b"1.1"}])
+        self.assertMessages(
+            payload["messages"],
+            [{"type": "c", "api": b"1.1"}, {"type": "d", "api": b"1.1"}],
+        )
         self.assertEqual(payload.get("client-api"), CLIENT_API)
         self.assertEqual(payload.get("server-api"), b"1.1")
         self.assertEqual(self.transport.message_api, b"1.1")
@@ -732,9 +806,15 @@ class MessageExchangeTest(LandscapeTest):
         the total-messages is equivalent to the total number of messages
         pending.
         """
-        exchanger = MessageExchange(self.reactor, self.mstore, self.transport,
-                                    self.identity, self.exchange_store,
-                                    self.config, max_messages=1)
+        exchanger = MessageExchange(
+            self.reactor,
+            self.mstore,
+            self.transport,
+            self.identity,
+            self.exchange_store,
+            self.config,
+            max_messages=1,
+        )
         self.mstore.set_accepted_types(["empty"])
         self.mstore.add({"type": "empty"})
         self.mstore.add({"type": "empty"})
@@ -763,9 +843,14 @@ class MessageExchangeTest(LandscapeTest):
         # fixture has an urgent exchange interval of 10 seconds, which makes
         # testing this awkward.
         self.config.urgent_exchange_interval = 20
-        exchanger = MessageExchange(self.reactor, self.mstore, self.transport,
-                                    self.identity, self.exchange_store,
-                                    self.config)
+        exchanger = MessageExchange(
+            self.reactor,
+            self.mstore,
+            self.transport,
+            self.identity,
+            self.exchange_store,
+            self.config,
+        )
         exchanger.schedule_exchange(urgent=True)
         events = []
         self.reactor.call_on("impending-exchange", lambda: events.append(True))
@@ -783,9 +868,14 @@ class MessageExchangeTest(LandscapeTest):
         """
         self.config.exchange_interval = 60 * 60
         self.config.urgent_exchange_interval = 20
-        exchanger = MessageExchange(self.reactor, self.mstore, self.transport,
-                                    self.identity, self.exchange_store,
-                                    self.config)
+        exchanger = MessageExchange(
+            self.reactor,
+            self.mstore,
+            self.transport,
+            self.identity,
+            self.exchange_store,
+            self.config,
+        )
         events = []
         self.reactor.call_on("impending-exchange", lambda: events.append(True))
         # This call will:
@@ -806,11 +896,12 @@ class MessageExchangeTest(LandscapeTest):
         # schedule a regular exchange.
         # Let's make sure that that *original* impending-exchange event has
         # been cancelled:
-        TIME_UNTIL_EXCHANGE = 60 * 60
-        TIME_UNTIL_NOTIFY = 10
-        TIME_ADVANCED = 20  # time that we've already advanced
-        self.reactor.advance(TIME_UNTIL_EXCHANGE -
-                             (TIME_UNTIL_NOTIFY + TIME_ADVANCED))
+        time_until_exchange = 60 * 60
+        time_until_notify = 10
+        time_advanced = 20
+        self.reactor.advance(
+            time_until_exchange - (time_until_notify + time_advanced),
+        )
         self.assertEqual(events, [True])
         # Ok, so no new events means that the original call was
         # cancelled. great.
@@ -877,8 +968,13 @@ class MessageExchangeTest(LandscapeTest):
         the L{MessageExchange} are changed, the configuration values as well,
         and the configuration is written to disk to be persisted.
         """
-        server_message = [{"type": "set-intervals",
-                           "urgent-exchange": 1234, "exchange": 5678}]
+        server_message = [
+            {
+                "type": "set-intervals",
+                "urgent-exchange": 1234,
+                "exchange": 5678,
+            },
+        ]
         self.transport.responses.append(server_message)
 
         self.exchanger.exchange()
@@ -993,6 +1089,7 @@ class MessageExchangeTest(LandscapeTest):
 
         def server_uuid_changed(old_uuid, new_uuid):
             called.append((old_uuid, new_uuid))
+
         self.reactor.call_on("server-uuid-changed", server_uuid_changed)
 
         # Set it for the first time, and it should emit the event
@@ -1028,6 +1125,7 @@ class MessageExchangeTest(LandscapeTest):
 
         def server_uuid_changed(old_uuid, new_uuid):
             called.append((old_uuid, new_uuid))
+
         self.reactor.call_on("server-uuid-changed", server_uuid_changed)
 
         self.mstore.set_server_uuid("the-uuid")
@@ -1039,8 +1137,10 @@ class MessageExchangeTest(LandscapeTest):
         self.transport.extra["server-uuid"] = "the-uuid"
         self.exchanger.exchange()
 
-        self.assertIn("INFO: Server UUID changed (old=None, new=the-uuid).",
-                      self.logfile.getvalue())
+        self.assertIn(
+            "INFO: Server UUID changed (old=None, new=the-uuid).",
+            self.logfile.getvalue(),
+        )
 
         # An exchange with the same UUID shouldn't be logged.
         self.logfile.truncate(0)
@@ -1063,9 +1163,11 @@ class MessageExchangeTest(LandscapeTest):
         [message] = messages
         self.assertIsNot(
             None,
-            self.exchange_store.get_message_context(message['operation-id']))
+            self.exchange_store.get_message_context(message["operation-id"]),
+        )
         message_context = self.exchange_store.get_message_context(
-            message['operation-id'])
+            message["operation-id"],
+        )
         self.assertEqual(message_context.operation_id, 123456)
         self.assertEqual(message_context.message_type, "type-R")
 
@@ -1099,12 +1201,13 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
 
         # Change the secure ID so that the response message gets discarded.
-        self.identity.secure_id = 'brand-new'
+        self.identity.secure_id = "brand-new"
         ids_before = self.exchange_store.all_operation_ids()
 
         self.mstore.set_accepted_types(["resynchronize"])
         message_id = self.exchanger.send(
-            {"type": "resynchronize", "operation-id": 234567})
+            {"type": "resynchronize", "operation-id": 234567},
+        )
         self.exchanger.exchange()
         self.assertEqual(2, len(self.transport.payloads))
         messages = self.transport.payloads[1]["messages"]
@@ -1112,13 +1215,14 @@ class MessageExchangeTest(LandscapeTest):
         self.assertIs(None, message_id)
         expected_log_entry = (
             "Response message with operation-id 234567 was discarded because "
-            "the client's secure ID has changed in the meantime")
+            "the client's secure ID has changed in the meantime"
+        )
         self.assertIn(expected_log_entry, self.logfile.getvalue())
 
         # The MessageContext was removed after utilisation.
         ids_after = self.exchange_store.all_operation_ids()
         self.assertEqual(len(ids_after), len(ids_before) - 1)
-        self.assertNotIn('234567', ids_after)
+        self.assertNotIn("234567", ids_after)
 
     def test_error_exchanging_causes_failed_exchange(self):
         """
@@ -1135,13 +1239,14 @@ class MessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual([None], events)
 
-    def test_SSL_error_exchanging_causes_failed_exchange(self):
+    def test_SSL_error_exchanging_causes_failed_exchange(self):  # noqa: N802
         """
         If an SSL error occurs when exchanging, the 'exchange-failed'
         event should be fired with the optional "ssl_error" flag set to True.
         """
-        self.log_helper.ignore_errors("Message exchange failed: Failed to "
-                                      "communicate.")
+        self.log_helper.ignore_errors(
+            "Message exchange failed: Failed to communicate.",
+        )
         events = []
 
         def failed_exchange(ssl_error):
@@ -1149,8 +1254,9 @@ class MessageExchangeTest(LandscapeTest):
                 events.append(None)
 
         self.reactor.call_on("exchange-failed", failed_exchange)
-        self.transport.responses.append(PyCurlError(60,
-                                                    "Failed to communicate."))
+        self.transport.responses.append(
+            PyCurlError(60, "Failed to communicate."),
+        )
         self.exchanger.exchange()
         self.assertEqual([None], events)
 
@@ -1167,8 +1273,9 @@ class MessageExchangeTest(LandscapeTest):
                 events.append(None)
 
         self.reactor.call_on("exchange-failed", failed_exchange)
-        self.transport.responses.append(PyCurlError(10,  # Not 60
-                                                    "Failed to communicate."))
+        self.transport.responses.append(
+            PyCurlError(10, "Failed to communicate."),  # Not 60
+        )
         self.exchanger.exchange()
         self.assertEqual([None], events)
 
@@ -1278,14 +1385,23 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
     helpers = [ExchangeHelper]
 
     def setUp(self):
-        super(AcceptedTypesMessageExchangeTest, self).setUp()
-        self.pinger = Pinger(self.reactor, self.identity, self.exchanger,
-                             self.config)
+        super().setUp()
+        self.pinger = Pinger(
+            self.reactor,
+            self.identity,
+            self.exchanger,
+            self.config,
+        )
         # The __init__ method of RegistrationHandler registers a few default
         # message types that we want to catch as well
         self.handler = RegistrationHandler(
-            self.config, self.identity, self.reactor, self.exchanger,
-            self.pinger, self.mstore)
+            self.config,
+            self.identity,
+            self.reactor,
+            self.exchanger,
+            self.pinger,
+            self.mstore,
+        )
 
     def test_register_accepted_message_type(self):
         self.exchanger.register_client_accepted_message_type("type-B")
@@ -1293,9 +1409,10 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
         self.exchanger.register_client_accepted_message_type("type-C")
         self.exchanger.register_client_accepted_message_type("type-A")
         types = self.exchanger.get_client_accepted_message_types()
-        self.assertEqual(types,
-                         sorted(["type-A", "type-B", "type-C"] +
-                                DEFAULT_ACCEPTED_TYPES))
+        self.assertEqual(
+            types,
+            sorted(["type-A", "type-B", "type-C"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_exchange_sends_message_type_when_no_hash(self):
         self.exchanger.register_client_accepted_message_type("type-A")
@@ -1303,15 +1420,17 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual(
             self.transport.payloads[0]["client-accepted-types"],
-            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
+            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_exchange_does_not_send_message_types_when_hash_matches(self):
         self.exchanger.register_client_accepted_message_type("type-A")
         self.exchanger.register_client_accepted_message_type("type-B")
         types = sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES)
         accepted_types_digest = md5(";".join(types).encode("ascii")).digest()
-        self.transport.extra["client-accepted-types-hash"] = \
-            accepted_types_digest
+        self.transport.extra[
+            "client-accepted-types-hash"
+        ] = accepted_types_digest
         self.exchanger.exchange()
         self.exchanger.exchange()
         self.assertNotIn("client-accepted-types", self.transport.payloads[1])
@@ -1327,7 +1446,8 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual(
             self.transport.payloads[1]["client-accepted-types"],
-            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
+            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_exchange_sends_new_accepted_types_hash(self):
         """
@@ -1342,7 +1462,8 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual(
             self.transport.payloads[1]["client-accepted-types"],
-            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES))
+            sorted(["type-A", "type-B"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_exchange_sends_new_types_when_server_screws_up(self):
         """
@@ -1359,7 +1480,8 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
         self.exchanger.exchange()
         self.assertEqual(
             self.transport.payloads[2]["client-accepted-types"],
-            sorted(["type-A"] + DEFAULT_ACCEPTED_TYPES))
+            sorted(["type-A"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_register_message_adds_accepted_type(self):
         """
@@ -1373,7 +1495,6 @@ class AcceptedTypesMessageExchangeTest(LandscapeTest):
 
 
 class GetAcceptedTypesDiffTest(LandscapeTest):
-
     def test_diff_empty(self):
         self.assertEqual(get_accepted_types_diff([], []), "")
 
@@ -1387,6 +1508,7 @@ class GetAcceptedTypesDiffTest(LandscapeTest):
         self.assertEqual(get_accepted_types_diff(["ooga"], ["ooga"]), "ooga")
 
     def test_diff_complex(self):
-        self.assertEqual(get_accepted_types_diff(["foo", "bar"],
-                                                 ["foo", "ooga"]),
-                         "+ooga foo -bar")
+        self.assertEqual(
+            get_accepted_types_diff(["foo", "bar"], ["foo", "ooga"]),
+            "+ooga foo -bar",
+        )
diff --git a/landscape/client/broker/tests/test_exchangestore.py b/landscape/client/broker/tests/test_exchangestore.py
index 45354db..76a7d9f 100644
--- a/landscape/client/broker/tests/test_exchangestore.py
+++ b/landscape/client/broker/tests/test_exchangestore.py
@@ -14,7 +14,7 @@ class ExchangeStoreTest(LandscapeTest):
     """Unit tests for the C{ExchangeStore}."""
 
     def setUp(self):
-        super(ExchangeStoreTest, self).setUp()
+        super().setUp()
 
         self.filename = self.makeFile()
         self.store1 = ExchangeStore(self.filename)
@@ -23,19 +23,21 @@ class ExchangeStoreTest(LandscapeTest):
     def test_add_message_context(self):
         """Adding a message context works correctly."""
         now = time.time()
-        self.store1.add_message_context(123, 'abc', 'change-packages')
+        self.store1.add_message_context(123, "abc", "change-packages")
 
         db = sqlite3.connect(self.store2._filename)
         cursor = db.cursor()
         cursor.execute(
             "SELECT operation_id, secure_id, message_type, timestamp "
-            "FROM message_context WHERE operation_id=?", (123,))
+            "FROM message_context WHERE operation_id=?",
+            (123,),
+        )
         results = cursor.fetchall()
         self.assertEqual(1, len(results))
         [row] = results
         self.assertEqual(123, row[0])
-        self.assertEqual('abc', row[1])
-        self.assertEqual('change-packages', row[2])
+        self.assertEqual("abc", row[1])
+        self.assertEqual("change-packages", row[2])
         self.assertTrue(row[3] > now)
 
     def test_add_message_context_with_duplicate_operation_id(self):
@@ -43,18 +45,22 @@ class ExchangeStoreTest(LandscapeTest):
         self.store1.add_message_context(123, "abc", "change-packages")
         self.assertRaises(
             (sqlite3.IntegrityError, sqlite3.OperationalError),
-            self.store1.add_message_context, 123, "def", "change-packages")
+            self.store1.add_message_context,
+            123,
+            "def",
+            "change-packages",
+        )
 
     def test_get_message_context(self):
         """
         Accessing a C{MessageContext} with an existing C{operation-id} works.
         """
         now = time.time()
-        self.store1.add_message_context(234, 'bcd', 'change-packages')
+        self.store1.add_message_context(234, "bcd", "change-packages")
         context = self.store2.get_message_context(234)
         self.assertEqual(234, context.operation_id)
-        self.assertEqual('bcd', context.secure_id)
-        self.assertEqual('change-packages', context.message_type)
+        self.assertEqual("bcd", context.secure_id)
+        self.assertEqual("change-packages", context.message_type)
         self.assertTrue(context.timestamp > now)
 
     def test_get_message_context_with_nonexistent_operation_id(self):
@@ -65,7 +71,10 @@ class ExchangeStoreTest(LandscapeTest):
     def test_message_context_remove(self):
         """C{MessageContext}s are deleted correctly."""
         context = self.store1.add_message_context(
-            345, 'opq', 'change-packages')
+            345,
+            "opq",
+            "change-packages",
+        )
         context.remove()
         self.assertIs(None, self.store1.get_message_context(345))
 
@@ -78,7 +87,7 @@ class ExchangeStoreTest(LandscapeTest):
 
     def test_all_operation_ids(self):
         """C{all_operation_ids} works correctly."""
-        self.store1.add_message_context(456, 'cde', 'change-packages')
+        self.store1.add_message_context(456, "cde", "change-packages")
         self.assertEqual([456], self.store2.all_operation_ids())
-        self.store2.add_message_context(567, 'def', 'change-packages')
+        self.store2.add_message_context(567, "def", "change-packages")
         self.assertEqual([456, 567], self.store1.all_operation_ids())
diff --git a/landscape/client/broker/tests/test_ping.py b/landscape/client/broker/tests/test_ping.py
index b095b5a..843b984 100644
--- a/landscape/client/broker/tests/test_ping.py
+++ b/landscape/client/broker/tests/test_ping.py
@@ -1,15 +1,15 @@
-from landscape.client.tests.helpers import LandscapeTest
-
 from twisted.internet.defer import fail
 
+from landscape.client.broker.ping import PingClient
+from landscape.client.broker.ping import Pinger
+from landscape.client.broker.tests.helpers import ExchangeHelper
+from landscape.client.tests.helpers import LandscapeTest
 from landscape.lib import bpickle
 from landscape.lib.fetch import fetch
 from landscape.lib.testing import FakeReactor
-from landscape.client.broker.ping import PingClient, Pinger
-from landscape.client.broker.tests.helpers import ExchangeHelper
 
 
-class FakePageGetter(object):
+class FakePageGetter:
     """An fake web client."""
 
     def __init__(self, response):
@@ -39,9 +39,8 @@ class FakePageGetter(object):
 
 
 class PingClientTest(LandscapeTest):
-
     def setUp(self):
-        super(PingClientTest, self).setUp()
+        super().setUp()
         self.reactor = FakeReactor()
 
     def test_default_get_page(self):
@@ -64,8 +63,15 @@ class PingClientTest(LandscapeTest):
         pinger.ping(url, insecure_id)
         self.assertEqual(
             client.fetches,
-            [(url, True, {"Content-Type": "application/x-www-form-urlencoded"},
-              "insecure_id=10")])
+            [
+                (
+                    url,
+                    True,
+                    {"Content-Type": "application/x-www-form-urlencoded"},
+                    "insecure_id=10",
+                ),
+            ],
+        )
 
     def test_ping_no_insecure_id(self):
         """
@@ -100,6 +106,7 @@ class PingClientTest(LandscapeTest):
 
         def errback(failure):
             failures.append(failure)
+
         d.addErrback(errback)
         self.assertEqual(len(failures), 1)
         self.assertEqual(failures[0].getErrorMessage(), "That's a failure!")
@@ -116,7 +123,7 @@ class PingerTest(LandscapeTest):
     install_exchanger = False
 
     def setUp(self):
-        super(PingerTest, self).setUp()
+        super().setUp()
         self.page_getter = FakePageGetter(None)
 
         def factory(reactor):
@@ -125,21 +132,25 @@ class PingerTest(LandscapeTest):
         self.config.ping_url = "http://localhost:8081/whatever"
         self.config.ping_interval = 10
 
-        self.pinger = Pinger(self.reactor,
-                             self.identity,
-                             self.exchanger,
-                             self.config,
-                             ping_client_factory=factory)
+        self.pinger = Pinger(
+            self.reactor,
+            self.identity,
+            self.exchanger,
+            self.config,
+            ping_client_factory=factory,
+        )
 
     def test_default_ping_client(self):
         """
         The C{ping_client_factory} argument to L{Pinger} should be optional,
         and default to L{PingClient}.
         """
-        pinger = Pinger(self.reactor,
-                        self.identity,
-                        self.exchanger,
-                        self.config)
+        pinger = Pinger(
+            self.reactor,
+            self.identity,
+            self.exchanger,
+            self.config,
+        )
         self.assertEqual(pinger.ping_client_factory, PingClient)
 
     def test_occasional_ping(self):
@@ -195,7 +206,7 @@ class PingerTest(LandscapeTest):
         self.log_helper.ignore_errors(ZeroDivisionError)
         self.identity.insecure_id = 42
 
-        class BadPingClient(object):
+        class BadPingClient:
             def __init__(self, *args, **kwargs):
                 pass
 
@@ -204,11 +215,13 @@ class PingerTest(LandscapeTest):
                 return fail(ZeroDivisionError("Couldn't fetch page"))
 
         self.config.ping_url = "http://foo.com/"
-        pinger = Pinger(self.reactor,
-                        self.identity,
-                        self.exchanger,
-                        self.config,
-                        ping_client_factory=BadPingClient)
+        pinger = Pinger(
+            self.reactor,
+            self.identity,
+            self.exchanger,
+            self.config,
+            ping_client_factory=BadPingClient,
+        )
         pinger.start()
 
         self.reactor.advance(30)
@@ -238,8 +251,10 @@ class PingerTest(LandscapeTest):
         self.assertEqual(len(self.page_getter.fetches), 1)
 
     def test_get_url(self):
-        self.assertEqual(self.pinger.get_url(),
-                         "http://localhost:8081/whatever")
+        self.assertEqual(
+            self.pinger.get_url(),
+            "http://localhost:8081/whatever",
+        )
 
     def test_config_url(self):
         """
diff --git a/landscape/client/broker/tests/test_registration.py b/landscape/client/broker/tests/test_registration.py
index 8ca0cb4..fe1d256 100644
--- a/landscape/client/broker/tests/test_registration.py
+++ b/landscape/client/broker/tests/test_registration.py
@@ -1,14 +1,14 @@
 import json
 import logging
 import socket
-import mock
+from unittest import mock
 
-from landscape.lib.compat import _PY3
-
-from landscape.client.broker.registration import RegistrationError, Identity
+from landscape.client.broker.registration import Identity
+from landscape.client.broker.registration import RegistrationError
+from landscape.client.broker.tests.helpers import BrokerConfigurationHelper
+from landscape.client.broker.tests.helpers import RegistrationHelper
 from landscape.client.tests.helpers import LandscapeTest
-from landscape.client.broker.tests.helpers import (
-    BrokerConfigurationHelper, RegistrationHelper)
+from landscape.lib.compat import _PY3
 from landscape.lib.persist import Persist
 
 
@@ -17,33 +17,43 @@ class IdentityTest(LandscapeTest):
     helpers = [BrokerConfigurationHelper]
 
     def setUp(self):
-        super(IdentityTest, self).setUp()
+        super().setUp()
         self.persist = Persist(filename=self.makePersistFile())
         self.identity = Identity(self.config, self.persist)
 
     def check_persist_property(self, attr, persist_name):
         value = "VALUE"
-        self.assertEqual(getattr(self.identity, attr), None,
-                         "%r attribute should default to None, not %r" %
-                         (attr, getattr(self.identity, attr)))
+        self.assertEqual(
+            getattr(self.identity, attr),
+            None,
+            f"{attr!r} attribute should default to None, "
+            f"not {getattr(self.identity, attr)!r}",
+        )
         setattr(self.identity, attr, value)
-        self.assertEqual(getattr(self.identity, attr), value,
-                         "%r attribute should be %r, not %r" %
-                         (attr, value, getattr(self.identity, attr)))
         self.assertEqual(
-            self.persist.get(persist_name), value,
-            "%r not set to %r in persist" % (persist_name, value))
+            getattr(self.identity, attr),
+            value,
+            f"{attr!r} attribute should be {value!r}, "
+            f"not {getattr(self.identity, attr)!r}",
+        )
+        self.assertEqual(
+            self.persist.get(persist_name),
+            value,
+            f"{persist_name!r} not set to {value!r} in persist",
+        )
 
     def check_config_property(self, attr):
         value = "VALUE"
         setattr(self.config, attr, value)
-        self.assertEqual(getattr(self.identity, attr), value,
-                         "%r attribute should be %r, not %r" %
-                         (attr, value, getattr(self.identity, attr)))
+        self.assertEqual(
+            getattr(self.identity, attr),
+            value,
+            f"{attr!r} attribute should be {value!r}, "
+            f"not {getattr(self.identity, attr)!r}",
+        )
 
     def test_secure_id(self):
-        self.check_persist_property("secure_id",
-                                    "registration.secure-id")
+        self.check_persist_property("secure_id", "registration.secure-id")
 
     def test_secure_id_as_unicode(self):
         """secure-id is expected to be retrieved as unicode."""
@@ -51,8 +61,7 @@ class IdentityTest(LandscapeTest):
         self.assertEqual(self.identity.secure_id, "spam")
 
     def test_insecure_id(self):
-        self.check_persist_property("insecure_id",
-                                    "registration.insecure-id")
+        self.check_persist_property("insecure_id", "registration.insecure-id")
 
     def test_computer_title(self):
         self.check_config_property("computer_title")
@@ -75,7 +84,7 @@ class RegistrationHandlerTestBase(LandscapeTest):
     helpers = [RegistrationHelper]
 
     def setUp(self):
-        super(RegistrationHandlerTestBase, self).setUp()
+        super().setUp()
         logging.getLogger().setLevel(logging.INFO)
         self.hostname = "ooga.local"
         self.addCleanup(setattr, socket, "getfqdn", socket.getfqdn)
@@ -83,14 +92,14 @@ class RegistrationHandlerTestBase(LandscapeTest):
 
 
 class RegistrationHandlerTest(RegistrationHandlerTestBase):
-
     def test_server_initiated_id_changing(self):
         """
         The server must be able to ask a client to change its secure
         and insecure ids even if no requests were sent.
         """
         self.exchanger.handle_message(
-            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"})
+            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"},
+        )
         self.assertEqual(self.identity.secure_id, "abc")
         self.assertEqual(self.identity.insecure_id, "def")
 
@@ -101,7 +110,8 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         """
         reactor_fire_mock = self.reactor.fire = mock.Mock()
         self.exchanger.handle_message(
-            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"})
+            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"},
+        )
         reactor_fire_mock.assert_any_call("registration-done")
 
     def test_unknown_id(self):
@@ -120,9 +130,12 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.config.computer_title = "Wu"
         self.mstore.set_accepted_types(["register"])
         self.exchanger.handle_message(
-            {"type": b"unknown-id", "clone-of": "Wu"})
-        self.assertIn("Client is clone of computer Wu",
-                      self.logfile.getvalue())
+            {"type": b"unknown-id", "clone-of": "Wu"},
+        )
+        self.assertIn(
+            "Client is clone of computer Wu",
+            self.logfile.getvalue(),
+        )
 
     def test_clone_secure_id_saved(self):
         """
@@ -134,7 +147,8 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.config.computer_title = "Wu"
         self.mstore.set_accepted_types(["register"])
         self.exchanger.handle_message(
-            {"type": b"unknown-id", "clone-of": "Wu"})
+            {"type": b"unknown-id", "clone-of": "Wu"},
+        )
         self.assertEqual(self.handler._clone_secure_id, secure_id)
         self.assertIsNone(self.identity.secure_id)
 
@@ -148,7 +162,8 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.mstore.set_accepted_types(["register"])
         self.mstore.set_server_api(b"3.3")  # Note this is only for later api
         self.exchanger.handle_message(
-            {"type": b"unknown-id", "clone-of": "Wu"})
+            {"type": b"unknown-id", "clone-of": "Wu"},
+        )
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         self.assertEqual(messages[0]["clone_secure_id"], secure_id)
@@ -192,9 +207,11 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         messages = self.mstore.get_pending_messages()
         self.assertEqual(1, len(messages))
         self.assertEqual("register", messages[0]["type"])
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "INFO: Queueing message to register with account "
-                         "'account_name' without a password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "INFO: Queueing message to register with account "
+            "'account_name' without a password.",
+        )
 
     @mock.patch("landscape.client.broker.registration.get_vm_info")
     def test_queue_message_on_exchange_with_vm_info(self, get_vm_info_mock):
@@ -210,14 +227,18 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         self.assertEqual(b"vmware", messages[0]["vm-info"])
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "INFO: Queueing message to register with account "
-                         "'account_name' without a password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "INFO: Queueing message to register with account "
+            "'account_name' without a password.",
+        )
         get_vm_info_mock.assert_called_once_with()
 
     @mock.patch("landscape.client.broker.registration.get_container_info")
     def test_queue_message_on_exchange_with_lxc_container(
-            self, get_container_info_mock):
+        self,
+        get_container_info_mock,
+    ):
         """
         If the client is running in an LXC container, the information is
         included in the registration message.
@@ -241,9 +262,11 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         messages = self.mstore.get_pending_messages()
         password = messages[0]["registration_password"]
         self.assertEqual("SEKRET", password)
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "INFO: Queueing message to register with account "
-                         "'account_name' with a password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "INFO: Queueing message to register with account "
+            "'account_name' with a password.",
+        )
 
     def test_queue_message_on_exchange_with_tags(self):
         """
@@ -254,14 +277,16 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.config.computer_title = "Computer Title"
         self.config.account_name = "account_name"
         self.config.registration_key = "SEKRET"
-        self.config.tags = u"computer,tag"
+        self.config.tags = "computer,tag"
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         self.assertEqual("computer,tag", messages[0]["tags"])
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "INFO: Queueing message to register with account "
-                         "'account_name' and tags computer,tag with a "
-                         "password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "INFO: Queueing message to register with account "
+            "'account_name' and tags computer,tag with a "
+            "password.",
+        )
 
     def test_queue_message_on_exchange_with_invalid_tags(self):
         """
@@ -273,14 +298,16 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.config.computer_title = "Computer Title"
         self.config.account_name = "account_name"
         self.config.registration_key = "SEKRET"
-        self.config.tags = u"<script>alert()</script>"
+        self.config.tags = "<script>alert()</script>"
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         self.assertIs(None, messages[0]["tags"])
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "ERROR: Invalid tags provided for registration.\n    "
-                         "INFO: Queueing message to register with account "
-                         "'account_name' with a password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "ERROR: Invalid tags provided for registration.\n    "
+            "INFO: Queueing message to register with account "
+            "'account_name' with a password.",
+        )
 
     def test_queue_message_on_exchange_with_unicode_tags(self):
         """
@@ -291,10 +318,10 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.config.computer_title = "Computer Title"
         self.config.account_name = "account_name"
         self.config.registration_key = "SEKRET"
-        self.config.tags = u"prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o"
+        self.config.tags = "prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o"
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
-        expected = u"prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o"
+        expected = "prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o"
         self.assertEqual(expected, messages[0]["tags"])
 
         logs = self.logfile.getvalue().strip()
@@ -306,10 +333,12 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         # here, to circumvent that problem.
         if _PY3:
             logs = logs.encode("utf-8")
-        self.assertEqual(logs,
-                         b"INFO: Queueing message to register with account "
-                         b"'account_name' and tags prova\xc4\xb5o "
-                         b"with a password.")
+        self.assertEqual(
+            logs,
+            b"INFO: Queueing message to register with account "
+            b"'account_name' and tags prova\xc4\xb5o "
+            b"with a password.",
+        )
 
     def test_queue_message_on_exchange_with_access_group(self):
         """
@@ -318,15 +347,17 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         """
         self.mstore.set_accepted_types(["register"])
         self.config.account_name = "account_name"
-        self.config.access_group = u"dinosaurs"
-        self.config.tags = u"server,london"
+        self.config.access_group = "dinosaurs"
+        self.config.tags = "server,london"
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         self.assertEqual("dinosaurs", messages[0]["access_group"])
-        self.assertEqual(self.logfile.getvalue().strip(),
-                         "INFO: Queueing message to register with account "
-                         "'account_name' in access group 'dinosaurs' and "
-                         "tags server,london without a password.")
+        self.assertEqual(
+            self.logfile.getvalue().strip(),
+            "INFO: Queueing message to register with account "
+            "'account_name' in access group 'dinosaurs' and "
+            "tags server,london without a password.",
+        )
 
     def test_queue_message_on_exchange_with_empty_access_group(self):
         """
@@ -334,7 +365,7 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         an "access_group" key.
         """
         self.mstore.set_accepted_types(["register"])
-        self.config.access_group = u""
+        self.config.access_group = ""
         self.reactor.fire("pre-exchange")
         messages = self.mstore.get_pending_messages()
         # Make sure the key does not appear in the outgoing message.
@@ -368,8 +399,7 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         self.assertEqual(messages[0]["type"], "register")
 
     def test_no_message_when_should_register_is_false(self):
-        """If we already have a secure id, do not queue a register message.
-        """
+        """If we already have a secure id, do not queue a register message."""
         self.mstore.set_accepted_types(["register"])
         self.config.computer_title = "Computer Title"
         self.config.account_name = "account_name"
@@ -395,9 +425,12 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         """
         reactor_fire_mock = self.reactor.fire = mock.Mock()
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"unknown-account"})
+            {"type": b"registration", "info": b"unknown-account"},
+        )
         reactor_fire_mock.assert_called_with(
-            "registration-failed", reason="unknown-account")
+            "registration-failed",
+            reason="unknown-account",
+        )
 
     def test_registration_failed_event_max_pending_computers(self):
         """
@@ -407,9 +440,12 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         """
         reactor_fire_mock = self.reactor.fire = mock.Mock()
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"max-pending-computers"})
+            {"type": b"registration", "info": b"max-pending-computers"},
+        )
         reactor_fire_mock.assert_called_with(
-            "registration-failed", reason="max-pending-computers")
+            "registration-failed",
+            reason="max-pending-computers",
+        )
 
     def test_registration_failed_event_not_fired_when_uncertain(self):
         """
@@ -418,7 +454,8 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         """
         reactor_fire_mock = self.reactor.fire = mock.Mock()
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"blah-blah"})
+            {"type": b"registration", "info": b"blah-blah"},
+        )
         for name, args, kwargs in reactor_fire_mock.mock_calls:
             self.assertNotEquals("registration-failed", args[0])
 
@@ -449,13 +486,15 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
 
         # This should somehow callback the deferred.
         self.exchanger.handle_message(
-            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"})
+            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"},
+        )
 
         self.assertEqual(calls, [1])
 
         # Doing it again to ensure that the deferred isn't called twice.
         self.exchanger.handle_message(
-            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"})
+            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"},
+        )
 
         self.assertEqual(calls, [1])
 
@@ -477,7 +516,8 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
 
         # This should somehow callback the deferred.
         self.exchanger.handle_message(
-            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"})
+            {"type": b"set-id", "id": b"abc", "insecure-id": b"def"},
+        )
 
         self.assertEqual(results, [None])
 
@@ -502,13 +542,15 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
 
         # This should somehow callback the deferred.
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"unknown-account"})
+            {"type": b"registration", "info": b"unknown-account"},
+        )
 
         self.assertEqual(calls, [True])
 
         # Doing it again to ensure that the deferred isn't called twice.
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"unknown-account"})
+            {"type": b"registration", "info": b"unknown-account"},
+        )
 
         self.assertEqual(calls, [True])
 
@@ -534,13 +576,15 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
         d.addErrback(add_call)
 
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"max-pending-computers"})
+            {"type": b"registration", "info": b"max-pending-computers"},
+        )
 
         self.assertEqual(calls, [True])
 
         # Doing it again to ensure that the deferred isn't called twice.
         self.exchanger.handle_message(
-            {"type": b"registration", "info": b"max-pending-computers"})
+            {"type": b"registration", "info": b"max-pending-computers"},
+        )
 
         self.assertEqual(calls, [True])
 
@@ -575,9 +619,13 @@ class RegistrationHandlerTest(RegistrationHandlerTestBase):
 
 class JujuRegistrationHandlerTest(RegistrationHandlerTestBase):
 
-    juju_contents = json.dumps({"environment-uuid": "DEAD-BEEF",
-                                "machine-id": "1",
-                                "api-addresses": "10.0.3.1:17070"})
+    juju_contents = json.dumps(
+        {
+            "environment-uuid": "DEAD-BEEF",
+            "machine-id": "1",
+            "api-addresses": "10.0.3.1:17070",
+        },
+    )
 
     def test_juju_info_added_when_present(self):
         """
@@ -593,10 +641,13 @@ class JujuRegistrationHandlerTest(RegistrationHandlerTestBase):
 
         messages = self.mstore.get_pending_messages()
         self.assertEqual(
-            {"environment-uuid": "DEAD-BEEF",
-             "machine-id": "1",
-             "api-addresses": ["10.0.3.1:17070"]},
-            messages[0]["juju-info"])
+            {
+                "environment-uuid": "DEAD-BEEF",
+                "machine-id": "1",
+                "api-addresses": ["10.0.3.1:17070"],
+            },
+            messages[0]["juju-info"],
+        )
 
     def test_juju_info_skipped_with_old_server(self):
         """
diff --git a/landscape/client/broker/tests/test_server.py b/landscape/client/broker/tests/test_server.py
index 99fa65a..13461eb 100644
--- a/landscape/client/broker/tests/test_server.py
+++ b/landscape/client/broker/tests/test_server.py
@@ -1,23 +1,23 @@
 import random
+from unittest.mock import Mock
 
 from configobj import ConfigObj
-from mock import Mock
-from twisted.internet.defer import succeed, fail
+from twisted.internet.defer import fail
+from twisted.internet.defer import succeed
 
-from landscape.client.manager.manager import FAILED
-from landscape.client.tests.helpers import (
-        LandscapeTest, DEFAULT_ACCEPTED_TYPES)
-from landscape.client.broker.tests.helpers import (
-    BrokerServerHelper, RemoteClientHelper)
+from landscape.client.broker.tests.helpers import BrokerServerHelper
+from landscape.client.broker.tests.helpers import RemoteClientHelper
 from landscape.client.broker.tests.test_ping import FakePageGetter
+from landscape.client.manager.manager import FAILED
+from landscape.client.tests.helpers import DEFAULT_ACCEPTED_TYPES
+from landscape.client.tests.helpers import LandscapeTest
 
 
-class FakeClient(object):
+class FakeClient:
     pass
 
 
-class FakeCreator(object):
-
+class FakeCreator:
     def __init__(self, reactor, config):
         pass
 
@@ -105,7 +105,11 @@ class BrokerServerTest(LandscapeTest):
         message = {"type": "test"}
         self.mstore.set_accepted_types(["test"])
         self.assertRaises(
-            RuntimeError, self.broker.send_message, message, None)
+            RuntimeError,
+            self.broker.send_message,
+            message,
+            None,
+        )
 
     def test_send_message_with_old_release_upgrader(self):
         """
@@ -123,8 +127,11 @@ class BrokerServerTest(LandscapeTest):
         If we receive a message from an old package-changer process that
         doesn't know about session IDs, we just let the message in.
         """
-        message = {"type": "change-packages-result", "operation-id": 99,
-                   "result-code": 123}
+        message = {
+            "type": "change-packages-result",
+            "operation-id": 99,
+            "result-code": 123,
+        }
         self.mstore.set_accepted_types(["change-packages-result"])
         self.broker.send_message(message, True)
         self.assertMessages(self.mstore.get_pending_messages(), [message])
@@ -138,14 +145,17 @@ class BrokerServerTest(LandscapeTest):
         legacy_message = {
             b"type": b"change-packages-result",
             b"operation-id": 99,
-            b"result-code": 123}
+            b"result-code": 123,
+        }
         self.mstore.set_accepted_types(["change-packages-result"])
         self.broker.send_message(legacy_message, True)
-        expected = [{
-            "type": "change-packages-result",
-            "operation-id": 99,
-            "result-code": 123
-        }]
+        expected = [
+            {
+                "type": "change-packages-result",
+                "operation-id": 99,
+                "result-code": 123,
+            },
+        ]
         self.assertMessages(self.mstore.get_pending_messages(), expected)
         self.assertTrue(self.exchanger.is_urgent())
 
@@ -176,9 +186,11 @@ class BrokerServerTest(LandscapeTest):
             self.assertEqual(len(self.broker.get_clients()), 1)
             self.assertEqual(len(self.broker.get_connectors()), 1)
             self.assertTrue(
-                isinstance(self.broker.get_client("test"), FakeClient))
+                isinstance(self.broker.get_client("test"), FakeClient),
+            )
             self.assertTrue(
-                isinstance(self.broker.get_connector("test"), FakeCreator))
+                isinstance(self.broker.get_connector("test"), FakeCreator),
+            )
 
         self.broker.connectors_registry = {"test": FakeCreator}
         result = self.broker.register_client("test")
@@ -190,8 +202,10 @@ class BrokerServerTest(LandscapeTest):
         of each registered client, and returns a deferred resulting in C{None}
         if all C{exit} calls were successful.
         """
-        self.broker.connectors_registry = {"foo": FakeCreator,
-                                           "bar": FakeCreator}
+        self.broker.connectors_registry = {
+            "foo": FakeCreator,
+            "bar": FakeCreator,
+        }
         self.broker.register_client("foo")
         self.broker.register_client("bar")
         for client in self.broker.get_clients():
@@ -203,8 +217,10 @@ class BrokerServerTest(LandscapeTest):
         The L{BrokerServer.stop_clients} method calls the C{exit} method of
         each registered client, and raises an exception if any calls fail.
         """
-        self.broker.connectors_registry = {"foo": FakeCreator,
-                                           "bar": FakeCreator}
+        self.broker.connectors_registry = {
+            "foo": FakeCreator,
+            "bar": FakeCreator,
+        }
         self.broker.register_client("foo")
         self.broker.register_client("bar")
         [client1, client2] = self.broker.get_clients()
@@ -221,8 +237,12 @@ class BrokerServerTest(LandscapeTest):
         config_obj["client"]["computer_title"] = "New Title"
         config_obj.write()
         result = self.broker.reload_configuration()
-        result.addCallback(lambda x: self.assertEqual(
-            self.config.computer_title, "New Title"))
+        result.addCallback(
+            lambda x: self.assertEqual(
+                self.config.computer_title,
+                "New Title",
+            ),
+        )
         return result
 
     def test_reload_configuration_stops_clients(self):
@@ -230,8 +250,10 @@ class BrokerServerTest(LandscapeTest):
         The L{BrokerServer.reload_configuration} method forces the config
         file associated with the broker server to be reloaded.
         """
-        self.broker.connectors_registry = {"foo": FakeCreator,
-                                           "bar": FakeCreator}
+        self.broker.connectors_registry = {
+            "foo": FakeCreator,
+            "bar": FakeCreator,
+        }
         self.broker.register_client("foo")
         self.broker.register_client("bar")
         for client in self.broker.get_clients():
@@ -245,8 +267,9 @@ class BrokerServerTest(LandscapeTest):
         """
         registered = self.broker.register()
         # This should callback the deferred.
-        self.exchanger.handle_message({"type": "set-id", "id": "abc",
-                                       "insecure-id": "def"})
+        self.exchanger.handle_message(
+            {"type": "set-id", "id": "abc", "insecure-id": "def"},
+        )
         return self.assertSuccess(registered)
 
     def test_get_accepted_types_empty(self):
@@ -263,8 +286,10 @@ class BrokerServerTest(LandscapeTest):
         message types accepted by the Landscape server.
         """
         self.mstore.set_accepted_types(["foo", "bar"])
-        self.assertEqual(sorted(self.broker.get_accepted_message_types()),
-                         ["bar", "foo"])
+        self.assertEqual(
+            sorted(self.broker.get_accepted_message_types()),
+            ["bar", "foo"],
+        )
 
     def test_get_server_uuid_with_unset_uuid(self):
         """
@@ -288,8 +313,10 @@ class BrokerServerTest(LandscapeTest):
         """
         self.broker.register_client_accepted_message_type("type1")
         self.broker.register_client_accepted_message_type("type2")
-        self.assertEqual(self.exchanger.get_client_accepted_message_types(),
-                         sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES))
+        self.assertEqual(
+            self.exchanger.get_client_accepted_message_types(),
+            sorted(["type1", "type2"] + DEFAULT_ACCEPTED_TYPES),
+        )
 
     def test_fire_event(self):
         """
@@ -304,8 +331,10 @@ class BrokerServerTest(LandscapeTest):
         """
         The L{BrokerServer.exit} method stops all registered clients.
         """
-        self.broker.connectors_registry = {"foo": FakeCreator,
-                                           "bar": FakeCreator}
+        self.broker.connectors_registry = {
+            "foo": FakeCreator,
+            "bar": FakeCreator,
+        }
         self.broker.register_client("foo")
         self.broker.register_client("bar")
         for client in self.broker.get_clients():
@@ -430,8 +459,10 @@ class EventTest(LandscapeTest):
         """
         callback = Mock(return_value="foo")
         self.client_reactor.call_on("resynchronize", callback)
-        return self.assertSuccess(self.broker.resynchronize(["foo"]),
-                                  [["foo"]])
+        return self.assertSuccess(
+            self.broker.resynchronize(["foo"]),
+            [["foo"]],
+        )
 
     def test_impending_exchange(self):
         """
@@ -448,7 +479,9 @@ class EventTest(LandscapeTest):
             plugin.exchange.assert_called_once_with()
 
         deferred = self.assertSuccess(
-            self.broker.impending_exchange(), [[None]])
+            self.broker.impending_exchange(),
+            [[None]],
+        )
         deferred.addCallback(assert_called)
         return deferred
 
@@ -464,12 +497,15 @@ class EventTest(LandscapeTest):
             self.remote.register_client = Mock()
 
             def assert_called_made(ignored):
-                self.remote.register_client_accepted_message_type\
-                    .assert_called_once_with("type")
+                self.remote.register_client_accepted_message_type.assert_called_once_with(  # noqa: E501
+                    "type",
+                )
                 self.remote.register_client.assert_called_once_with("client")
 
             deferred = self.assertSuccess(
-                self.broker.broker_reconnect(), [[None]])
+                self.broker.broker_reconnect(),
+                [[None]],
+            )
             return deferred.addCallback(assert_called_made)
 
         registered = self.client.register_message("type", lambda x: None)
@@ -488,7 +524,9 @@ class EventTest(LandscapeTest):
 
         self.client_reactor.call_on("server-uuid-changed", callback)
         deferred = self.assertSuccess(
-            self.broker.server_uuid_changed(None, "abc"), [[return_value]])
+            self.broker.server_uuid_changed(None, "abc"),
+            [[return_value]],
+        )
         return deferred.addCallback(assert_called)
 
     def test_message_type_acceptance_changed(self):
@@ -499,7 +537,9 @@ class EventTest(LandscapeTest):
         return_value = random.randint(1, 100)
         callback = Mock(return_value=return_value)
         self.client_reactor.call_on(
-            ("message-type-acceptance-changed", "type"), callback)
+            ("message-type-acceptance-changed", "type"),
+            callback,
+        )
         result = self.broker.message_type_acceptance_changed("type", True)
         return self.assertSuccess(result, [[return_value]])
 
@@ -512,7 +552,9 @@ class EventTest(LandscapeTest):
         callback = Mock(return_value=return_value)
         self.client_reactor.call_on("package-data-changed", callback)
         return self.assertSuccess(
-            self.broker.package_data_changed(), [[return_value]])
+            self.broker.package_data_changed(),
+            [[return_value]],
+        )
 
 
 class HandlersTest(LandscapeTest):
@@ -520,7 +562,7 @@ class HandlersTest(LandscapeTest):
     helpers = [BrokerServerHelper]
 
     def setUp(self):
-        super(HandlersTest, self).setUp()
+        super().setUp()
         self.broker.connectors_registry = {"test": FakeCreator}
         self.broker.register_client("test")
         self.client = self.broker.get_client("test")
@@ -549,18 +591,25 @@ class HandlersTest(LandscapeTest):
         result = self.reactor.fire("message", message)
         result = [i for i in result if i is not None][0]
 
-        class StartsWith(object):
-
+        class StartsWith:
             def __eq__(self, other):
                 return other.startswith(
-                    "Landscape client failed to handle this request (foobar)")
+                    "Landscape client failed to handle this request (foobar)",
+                )
 
         def broadcasted(ignored):
             self.client.message.assert_called_once_with(message)
             self.assertMessages(
                 self.mstore.get_pending_messages(),
-                [{"type": "operation-result", "status": FAILED,
-                  "result-text": StartsWith(), "operation-id": 4}])
+                [
+                    {
+                        "type": "operation-result",
+                        "status": FAILED,
+                        "result-text": StartsWith(),
+                        "operation-id": 4,
+                    },
+                ],
+            )
 
         result.addCallback(broadcasted)
         return result
@@ -582,7 +631,10 @@ class HandlersTest(LandscapeTest):
         self.client.fire_event = Mock(return_value=succeed(None))
         self.reactor.fire("message-type-acceptance-changed", "test", True)
         self.client.fire_event.assert_called_once_with(
-            "message-type-acceptance-changed", "test", True)
+            "message-type-acceptance-changed",
+            "test",
+            True,
+        )
 
     def test_server_uuid_changed(self):
         """
@@ -592,7 +644,10 @@ class HandlersTest(LandscapeTest):
         self.client.fire_event = Mock(return_value=succeed(None))
         self.reactor.fire("server-uuid-changed", None, 123)
         self.client.fire_event.assert_called_once_with(
-            "server-uuid-changed", None, 123)
+            "server-uuid-changed",
+            None,
+            123,
+        )
 
     def test_package_data_changed(self):
         """
diff --git a/landscape/client/broker/tests/test_service.py b/landscape/client/broker/tests/test_service.py
index 580f64e..e99f9ac 100644
--- a/landscape/client/broker/tests/test_service.py
+++ b/landscape/client/broker/tests/test_service.py
@@ -1,12 +1,11 @@
 import os
+from unittest.mock import Mock
 
-from mock import Mock
-
-from landscape.client.tests.helpers import LandscapeTest
-from landscape.client.broker.tests.helpers import BrokerConfigurationHelper
+from landscape.client.broker.amp import RemoteBrokerConnector
 from landscape.client.broker.service import BrokerService
+from landscape.client.broker.tests.helpers import BrokerConfigurationHelper
 from landscape.client.broker.transport import HTTPTransport
-from landscape.client.broker.amp import RemoteBrokerConnector
+from landscape.client.tests.helpers import LandscapeTest
 from landscape.lib.testing import FakeReactor
 
 
@@ -15,7 +14,7 @@ class BrokerServiceTest(LandscapeTest):
     helpers = [BrokerConfigurationHelper]
 
     def setUp(self):
-        super(BrokerServiceTest, self).setUp()
+        super().setUp()
 
         class FakeBrokerService(BrokerService):
             reactor_factory = FakeReactor
@@ -28,7 +27,8 @@ class BrokerServiceTest(LandscapeTest):
         """
         self.assertEqual(
             self.service.persist.filename,
-            os.path.join(self.config.data_path, "broker.bpickle"))
+            os.path.join(self.config.data_path, "broker.bpickle"),
+        )
 
     def test_transport(self):
         """
diff --git a/landscape/client/broker/tests/test_store.py b/landscape/client/broker/tests/test_store.py
index 208c75c..b61edf3 100644
--- a/landscape/client/broker/tests/test_store.py
+++ b/landscape/client/broker/tests/test_store.py
@@ -1,22 +1,22 @@
 import os
-import mock
-
+from unittest import mock
 
 from twisted.python.compat import intToBytes
 
+from landscape.client.broker.store import MessageStore
+from landscape.client.tests.helpers import LandscapeTest
 from landscape.lib.bpickle import dumps
 from landscape.lib.persist import Persist
-from landscape.lib.schema import InvalidError, Int, Bytes, Unicode
+from landscape.lib.schema import Bytes
+from landscape.lib.schema import Int
+from landscape.lib.schema import InvalidError
+from landscape.lib.schema import Unicode
 from landscape.message_schemas.message import Message
-from landscape.client.broker.store import MessageStore
-
-from landscape.client.tests.helpers import LandscapeTest
 
 
 class MessageStoreTest(LandscapeTest):
-
     def setUp(self):
-        super(MessageStoreTest, self).setUp()
+        super().setUp()
         self.temp_dir = self.makeDir()
         self.persist_filename = self.makeFile()
         self.store = self.create_store()
@@ -137,13 +137,87 @@ class MessageStoreTest(LandscapeTest):
         self.assertEqual(self.store.get_pending_offset(), 0)
         self.assertEqual(self.store.get_pending_messages(), [])
 
+    def test_messages_over_limit(self):
+        """
+        Create six messages, two per directory. Since there is a limit of
+        one directory then only the last 2 messages should be in the queue
+        """
+
+        self.store._directory_size = 2
+        self.store._max_dirs = 1
+        for num in range(6):  # 0,1  2,3  4,5
+            message = {"type": "data", "data": f"{num}".encode()}
+            self.store.add(message)
+        messages = self.store.get_pending_messages(200)
+        self.assertMessages(
+            messages,
+            [{"type": "data", "data": b"4"}, {"type": "data", "data": b"5"}],
+        )
+
+    def test_messages_under_limit(self):
+        """
+        Create six messages, all of which should be in the queue, since 3
+        directories are active
+        """
+
+        self.store._directory_size = 2
+        self.store._max_dirs = 3
+        messages_sent = []
+        for num in range(6):  # 0,1  2,3  4,5
+            message = {"type": "data", "data": f"{num}".encode()}
+            messages_sent.append(message)
+            self.store.add(message)
+        messages = self.store.get_pending_messages(200)
+        self.assertMessages(messages, messages_sent)
+
+    def test_messages_over_mb(self):
+        """
+        Create three messages with the second one being very large. The
+        max size should get triggered, so all should be cleared except for the
+        last one.
+        """
+
+        self.store._directory_size = 2
+        self.store._max_size_mb = 0.01
+        self.store.add({"type": "data", "data": b"a"})
+        self.store.add({"type": "data", "data": b"b" * 15000})
+        self.store.add({"type": "data", "data": b"c"})
+        messages = self.store.get_pending_messages(200)
+        self.assertMessages(
+            messages,
+            [{"type": "data", "data": b"c"}],
+        )
+
+    @mock.patch("shutil.rmtree")
+    def test_exception_on_message_limit(self, rmtree_mock):
+        """
+        If an exception occurs while deleting it shouldn't affect the next
+        message sent
+        """
+        rmtree_mock.side_effect = IOError("Error!")