Merge ~peppepetra/charm-canonical-livepatch:fix_linting into charm-canonical-livepatch:master

[Giuseppe Petralia]

Fix linting

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Drew Freiberger (afreiberger)]

a couple minor nits inline.

Thanks for this!

review: Needs Fixing

[Paul Goins (vultaire)]

Pretty good, only minor stuff to fix.

review: Needs Fixing

[Paul Goins (vultaire)]

LGTM

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision 7bf3fd86aca5fc26e02cbabffa9f047004a2e79e

diff --git a/Makefile b/Makefile
index e5fd995..fa5236f 100644
--- a/Makefile
+++ b/Makefile
@@ -30,9 +30,9 @@ clean:
 
 submodules:
 	@echo "Cloning submodules"
-	@git submodule update --init --recursive --remote --merge
+	@git submodule update --init --recursive
 
-build: submodules
+build:
 	@echo "Building charm to directory ${CHARM_BUILD_DIR}/${CHARM_NAME}"
 	@-git describe --tags > ./repo-info
 	@CHARM_LAYERS_DIR=${CHARM_LAYERS_DIR} CHARM_INTERFACES_DIR=${CHARM_INTERFACES_DIR} \
@@ -56,7 +56,7 @@ functional: build
 	@echo "Executing functional tests in ${CHARM_BUILD_DIR}"
 	@CHARM_BUILD_DIR=${CHARM_BUILD_DIR} tox -e func
 
-test: proof unittests functional
+test: lint proof unittests functional
 	@echo "Tests completed for charm ${CHARM_NAME}."
 
 # The targets below don't depend on a file
diff --git a/actions/actions.py b/actions/actions.py
index 6c956cd..e3930d1 100755
--- a/actions/actions.py
+++ b/actions/actions.py
@@ -1,76 +1,86 @@
 #!/usr/local/sbin/charm-env python3
+"""Charm actions."""
 
 import os.path
 import sys
 import traceback
-from subprocess import check_output, CalledProcessError
+from subprocess import CalledProcessError, check_output
+
 from charmhelpers.core import hookenv
 
 
 def activate(params):
+    """Execure activate action."""
     config = hookenv.config()
-    livepatch_key = config.get('livepatch_key')
+    livepatch_key = config.get("livepatch_key")
 
     if livepatch_key:
         # disable prior to enabling to work around LP#1628823
-        cmd = ['/snap/bin/canonical-livepatch', 'disable']
+        cmd = ["/snap/bin/canonical-livepatch", "disable"]
         try:
             check_output(cmd, universal_newlines=True)
         except CalledProcessError as e:
-            hookenv.log('Unable to deactivate: {}'.format(str(e)))
+            hookenv.log("Unable to deactivate: {}".format(str(e)))
             # but let's soldier on...
-        cmd = ['/snap/bin/canonical-livepatch', 'enable', '{}'.format(livepatch_key.strip())]
+        cmd = [
+            "/snap/bin/canonical-livepatch",
+            "enable",
+            "{}".format(livepatch_key.strip()),
+        ]
         try:
             check_output(cmd, universal_newlines=True)
         except CalledProcessError as e:
-            hookenv.action_fail('Unable to activate: {}'.format(str(e)))
+            hookenv.action_fail("Unable to activate: {}".format(str(e)))
             return
         else:
-            hookenv.action_set(dict(result='Activated'))
+            hookenv.action_set(dict(result="Activated"))
 
     else:
-        hookenv.action_fail('Unable to activate as no key has been set')
+        hookenv.action_fail("Unable to activate as no key has been set")
 
 
 def deactivate(params):
-    cmd = ['/snap/bin/canonical-livepatch', 'disable']
+    """Execute deactivate action."""
+    cmd = ["/snap/bin/canonical-livepatch", "disable"]
     try:
         check_output(cmd, universal_newlines=True)
     except CalledProcessError as e:
-        hookenv.action_fail('Unable to deactivate: {}'.format(str(e)))
+        hookenv.action_fail("Unable to deactivate: {}".format(str(e)))
         return
-    hookenv.action_set(dict(result='Deactivated'))
+    hookenv.action_set(dict(result="Deactivated"))
 
 
 def refresh(params):
-    cmd = ['/snap/bin/canonical-livepatch', 'refresh']
+    """Execute refresh action."""
+    cmd = ["/snap/bin/canonical-livepatch", "refresh"]
     try:
         check_output(cmd, universal_newlines=True)
     except CalledProcessError as e:
-        hookenv.action_fail('Unable to refresh: {}'.format(str(e)))
+        hookenv.action_fail("Unable to refresh: {}".format(str(e)))
         return
-    hookenv.action_set(dict(result='Refreshed'))
+    hookenv.action_set(dict(result="Refreshed"))
 
 
 def main(argv):
+    """Select the appropriate action."""
     action = os.path.basename(argv[0])
     params = hookenv.action_get()
     try:
-        if action == 'activate':
+        if action == "activate":
             activate(params)
-        elif action == 'deactivate':
+        elif action == "deactivate":
             deactivate(params)
-        elif action == 'refresh':
+        elif action == "refresh":
             refresh(params)
         else:
-            hookenv.action_fail('Action {} not implemented'.format(action))
+            hookenv.action_fail("Action {} not implemented".format(action))
     except Exception:
-        hookenv.action_fail('Unhandled exception')
+        hookenv.action_fail("Unhandled exception")
         tb = traceback.format_exc()
         hookenv.action_set(dict(traceback=tb))
-        hookenv.log('Unhandled exception in action {}'.format(action))
+        hookenv.log("Unhandled exception in action {}".format(action))
         print(tb)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main(sys.argv)
diff --git a/files/check_canonical-livepatch.py b/files/check_canonical-livepatch.py
index cafd472..f7ce127 100755
--- a/files/check_canonical-livepatch.py
+++ b/files/check_canonical-livepatch.py
@@ -1,75 +1,78 @@
 #!/usr/bin/env python3
+"""Check canonical-livepatch and alert."""
 
 # Copyright (C) 2016 Canonical Ltd.
 
 import os
+from subprocess import call, check_output
+
 import nagios_plugin3
-from subprocess import check_output, call
+
 from yaml import safe_load
 
-supported_archs = ['x86_64']
+supported_archs = ["x86_64"]
 
 
 def check_snap_installed():
-    """Confirm the snap is installed, raise an error if not"""
-    cmd = ['snap', 'list', 'canonical-livepatch']
+    """Confirm the snap is installed, raise an error if not."""
+    cmd = ["snap", "list", "canonical-livepatch"]
     try:
-        check_output(cmd).decode('UTF-8')
+        check_output(cmd).decode("UTF-8")
     except Exception:
-        raise nagios_plugin3.CriticalError('canonical-livepatch snap is not installed')
+        raise nagios_plugin3.CriticalError("canonical-livepatch snap is not installed")
 
 
 def load_status():
-    """Load the cached status from disk, return it as a string"""
-    livepatch_output_path = '/var/lib/nagios/canonical-livepatch-status.txt'
+    """Load the cached status from disk, return it as a string."""
+    livepatch_output_path = "/var/lib/nagios/canonical-livepatch-status.txt"
 
-    with open(livepatch_output_path, 'r') as canonical_livepatch_log:
+    with open(livepatch_output_path, "r") as canonical_livepatch_log:
         livepatch_status = canonical_livepatch_log.read()
 
     return livepatch_status.strip()
 
 
 def check_serious_errors():
-    """In serious error cases, the output will not be YAML"""
+    """Check serious error cases, the output will not be YAML."""
     livepatch_status = load_status()
 
     # if it's empty, something's definitely wrong
-    if livepatch_status == '':
-        raise nagios_plugin3.CriticalError('No output from canonical-livepatch status')
+    if livepatch_status == "":
+        raise nagios_plugin3.CriticalError("No output from canonical-livepatch status")
 
     # in some cases, it's obviously not valid YAML
     try:
         livepatch_yaml = safe_load(livepatch_status)
     except Exception:
-        raise nagios_plugin3.CriticalError(livepatch_status.replace('\n', ' '))
+        raise nagios_plugin3.CriticalError(livepatch_status.replace("\n", " "))
 
     # in other cases, it's less obvious until we try to parse
     try:
-        livepatch_yaml['status']
+        livepatch_yaml["status"]
     except TypeError:
-        raise nagios_plugin3.CriticalError(livepatch_status.replace('\n', ' '))
+        raise nagios_plugin3.CriticalError(livepatch_status.replace("\n", " "))
 
 
 def active_kernel_version():
-    """Return the active kernel version, from livepatch's perspective"""
+    """Return the active kernel version, from livepatch's perspective."""
     livepatch_status = load_status()
     status_yaml = safe_load(livepatch_status)
-    for kernel in status_yaml.get('status'):
-        if kernel.get('running') is True:
-            return kernel.get('kernel')
+    for kernel in status_yaml.get("status"):
+        if kernel.get("running") is True:
+            return kernel.get("kernel")
 
 
 def check_status():
-    """Check the cached status, raise an error if we find any issues"""
+    """Check the cached status, raise an error if we find any issues."""
     livepatch_status = load_status()
     errors = []
 
     status_yaml = safe_load(livepatch_status)
 
-    for kernel in status_yaml.get('status'):
-        if kernel.get('running') is True:
-            check_state = kernel.get('livepatch').get('checkState')
-            patch_state = kernel.get('livepatch').get('patchState')
+    for kernel in status_yaml.get("status"):
+        if kernel.get("running") is True:
+            check_state = kernel.get("livepatch").get("checkState")
+            patch_state = kernel.get("livepatch").get("patchState")
 
     check_state_error = check_check_state(check_state)
     patch_state_error = check_patch_state(patch_state)
@@ -80,66 +83,67 @@ def check_status():
         errors.append(patch_state_error)
 
     if errors:
-        raise nagios_plugin3.CriticalError(' '.join(errors))
+        raise nagios_plugin3.CriticalError(" ".join(errors))
 
 
 def check_check_state(check_state):
-    """Check for issues with checkState, including unexpected output"""
-    if check_state in ['checked', 'needs-check']:
+    """Check for issues with checkState, including unexpected output."""
+    if check_state in ["checked", "needs-check"]:
         pass
-    elif check_state == 'check-failed':
-        return 'Livepatch failed to check the remote service for patches.'
+    elif check_state == "check-failed":
+        return "Livepatch failed to check the remote service for patches."
     else:
-        return 'Unknown check state: {}'.format(check_state)
+        return "Unknown check state: {}".format(check_state)
 
 
 def check_patch_state(patch_state):
-    """Check for issues with patchState, including unexpected output"""
-    if patch_state in ['applied', 'applying', 'nothing-to-apply']:
+    """Check for issues with patchState, including unexpected output."""
+    if patch_state in ["applied", "applying", "nothing-to-apply"]:
         pass
-    elif patch_state == 'unapplied':
-        return 'Livepatch has not applied the downloaded patches.'
-    elif patch_state == 'applied-with-bug':
-        return 'Livepatch has detected a kernel bug while applying patches.'
-    elif patch_state == 'apply-failed':
-        return 'Livepatch failed to apply patches.'
-    elif patch_state == 'kernel-upgrade-required':
-        return 'A kernel upgrade (and reboot) is required.'
+    elif patch_state == "unapplied":
+        return "Livepatch has not applied the downloaded patches."
+    elif patch_state == "applied-with-bug":
+        return "Livepatch has detected a kernel bug while applying patches."
+    elif patch_state == "apply-failed":
+        return "Livepatch failed to apply patches."
+    elif patch_state == "kernel-upgrade-required":
+        return "A kernel upgrade (and reboot) is required."
     else:
-        return 'Unknown patch state: {}'.format(patch_state)
+        return "Unknown patch state: {}".format(patch_state)
 
 
 def lsb_release():
-    """Return /etc/lsb-release in a dict"""
+    """Return /etc/lsb-release in a dict."""
     d = {}
-    with open('/etc/lsb-release', 'r') as lsb:
-        for l in lsb:
-            k, v = l.split('=')
+    with open("/etc/lsb-release", "r") as lsb:
+        for line in lsb:
+            k, v = line.split("=")
             d[k.strip()] = v.strip()
     return d
 
 
 def init_is_systemd():
     """Return True if the host system uses systemd, False otherwise."""
-    if lsb_release()['DISTRIB_CODENAME'] == 'trusty':
+    if lsb_release()["DISTRIB_CODENAME"] == "trusty":
         return False
-    return os.path.isdir('/run/systemd/system')
+    return os.path.isdir("/run/systemd/system")
 
 
 def is_container():
-    """Determine whether unit is running in a container
+    """Determine whether unit is running in a container.
 
     @return: boolean indicating if unit is in a container
     """
     if init_is_systemd():
         # Detect using systemd-detect-virt
-        return call(['systemd-detect-virt', '--container', '--quiet']) == 0
+        return call(["systemd-detect-virt", "--container", "--quiet"]) == 0
     else:
         # Detect using upstart container file marker
-        return os.path.exists('/run/container_type')
+        return os.path.exists("/run/container_type")
 
 
 def main():
+    """Run all the checks."""
     arch = os.uname()[4]
     if arch not in supported_archs:
         raise nagios_plugin3.CriticalError(
diff --git a/reactive/canonical_livepatch.py b/reactive/canonical_livepatch.py
index 25f1f3c..b3a0dcd 100644
--- a/reactive/canonical_livepatch.py
+++ b/reactive/canonical_livepatch.py
@@ -1,264 +1,303 @@
-from charms.layer import snap
-from charms.reactive import when, when_not, set_flag, clear_flag, hook
-from charms.reactive.flags import register_trigger
-from charmhelpers.core.host import write_file, is_container
-from charmhelpers.core import hookenv
-from charmhelpers.contrib.charmsupport import nrpe
+"""Charm hooks."""
+
 from distutils.version import LooseVersion
 from os import environ, mkdir, path, uname
-from subprocess import check_call, check_output, CalledProcessError
+from subprocess import CalledProcessError, check_call, check_output
 from time import sleep
+
+from charmhelpers.contrib.charmsupport import nrpe
+from charmhelpers.core import hookenv
+from charmhelpers.core.host import is_container, write_file
+
+from charms.layer import snap
+from charms.reactive import clear_flag, hook, set_flag, when, when_not
+from charms.reactive.flags import register_trigger
+
 from yaml import safe_load
 
 
 def file_to_units(local_path, unit_path):
-    """ copy a file from the charm onto our unit(s) """
-    if local_path[-3:] == '.py':
+    """Copy a file from the charm onto our unit(s)."""
+    if local_path[-3:] == ".py":
         perms = 0o755
     else:
         perms = 0o644
 
-    fh = open(local_path, 'r')
+    fh = open(local_path, "r")
     write_file(
-        path=unit_path,
-        content=fh.read().encode(),
-        owner='root',
-        perms=perms,
+        path=unit_path, content=fh.read().encode(), owner="root", perms=perms,
     )
 
 
 def wait_for_path(file_path, timeout=30):
-    hookenv.log('Waiting for up to {}s for {}'.format(timeout, file_path))
+    """Wait until path exists or timeout."""
+    hookenv.log("Waiting for up to {}s for {}".format(timeout, file_path))
     seconds_waited = 0
     interval = 1
     while not (path.exists(file_path)):
-        hookenv.log('{} does not exist - waiting {}s'.format(file_path, interval))
+        hookenv.log("{} does not exist - waiting {}s".format(file_path, interval))
         sleep(interval)
         seconds_waited += interval
         if seconds_waited >= timeout:
-            hookenv.log('Giving up waiting for {}'.format(file_path), hookenv.ERROR)
+            hookenv.log("Giving up waiting for {}".format(file_path), hookenv.ERROR)
             return
     return
 
 
 def wait_for_livepatch():
-    wait_for_path('/var/snap/canonical-livepatch/current/livepatchd-priv.sock')
+    """Wait until canonical-livepatch socket is created."""
+    wait_for_path("/var/snap/canonical-livepatch/current/livepatchd-priv.sock")
 
 
 def unit_update(status=None, message=None):
+    """Update status message."""
     if status and message:
         hookenv.status_set(status, message)
     else:
         patch_details = get_patch_details()
-        hookenv.status_set('active', 'Running kernel {}, patchState: {}'.format(*patch_details))
+        hookenv.status_set(
+            "active", "Running kernel {}, patchState: {}".format(*patch_details)
+        )
 
 
 def get_livepatch_status():
-    cmd = ['/snap/bin/canonical-livepatch', 'status', '--format', 'yaml']
-    livepatch_status = ''
+    """Get livepatch status."""
+    cmd = ["/snap/bin/canonical-livepatch", "status", "--format", "yaml"]
+    livepatch_status = ""
     try:
         livepatch_status = check_output(cmd, universal_newlines=True)
     except FileNotFoundError:
         # If the snap's not installed yet, don't crash out
         pass
     except CalledProcessError:
-        # If the service hasn't been enabled yet, we'll get a process error - this is fine
+        # If the service hasn't been enabled yet,
+        # we'll get a process error - this is fine
         pass
     return livepatch_status
 
 
 def write_status_to_disk():
+    """Write livepatch status to disk."""
     # In a race with nrpe, create /var/lib/nagios if nrpe didn't do it yet
-    if not path.exists('/var/lib/nagios'):
-        mkdir('/var/lib/nagios')
+    if not path.exists("/var/lib/nagios"):
+        mkdir("/var/lib/nagios")
 
     current_status = get_livepatch_status()
     perms = 0o644
     write_file(
-        path='/var/lib/nagios/canonical-livepatch-status.txt',
+        path="/var/lib/nagios/canonical-livepatch-status.txt",
         content=current_status,
-        owner='root',
+        owner="root",
         perms=perms,
     )
 
 
 def get_patch_details():
-    kernel = 'unknown'
-    patch_state = 'unknown'
+    """Get patch details.
+
+    :return: a tuple containing kernel version and patch state.
+    """
+    kernel = "unknown"
+    patch_state = "unknown"
     raw_status = get_livepatch_status()
 
     # status will usually pass YAML (but not always!)
     try:
         status = safe_load(raw_status)
     except Exception:
-        hookenv.log('Unable to parse status yaml', hookenv.ERROR)
+        hookenv.log("Unable to parse status yaml", hookenv.ERROR)
         return kernel, raw_status
 
     # even if we got YAML, be paranoid
     try:
-        for k in status['status']:
-            if k['running'] is True:
-                kernel = k['kernel']
-                patch_state = k['livepatch']['patchState']
+        for k in status["status"]:
+            if k["running"] is True:
+                kernel = k["kernel"]
+                patch_state = k["livepatch"]["patchState"]
     except Exception:
-        hookenv.log('Unable to find patching details in status yaml', hookenv.ERROR)
+        hookenv.log("Unable to find patching details in status yaml", hookenv.ERROR)
         return kernel, patch_state
 
     return kernel, patch_state
 
 
 def configure_proxies(proxy=None):
-    for proto in ('http-proxy', 'https-proxy'):
+    """Configure proxies."""
+    for proto in ("http-proxy", "https-proxy"):
         if proxy is None:
-            proxy = ''
-        cmd = ['/snap/bin/canonical-livepatch', 'config', '{}={}'.format(proto, proxy)]
-        hookenv.log('Configuring {} as {}'.format(proto, proxy))
+            proxy = ""
+        cmd = ["/snap/bin/canonical-livepatch", "config", "{}={}".format(proto, proxy)]
+        hookenv.log("Configuring {} as {}".format(proto, proxy))
         try:
             check_call(cmd, universal_newlines=True)
         except CalledProcessError:
-            hookenv.log('Failed to set proxy', hookenv.ERROR)
+            hookenv.log("Failed to set proxy", hookenv.ERROR)
 
 
 def activate_livepatch():
-    unit_update('maintenance', 'Updating API key')
+    """Activate livepatch."""
+    unit_update("maintenance", "Updating API key")
     config = hookenv.config()
 
-    livepatch_key = config.get('livepatch_key')
+    livepatch_key = config.get("livepatch_key")
     if livepatch_key:
         # disable prior to enabling to work around LP#1628823
-        cmd = ['/snap/bin/canonical-livepatch', 'disable']
-        hookenv.log('Disabling canonical-livepatch ahead of key change to work around LP#1628823')
+        cmd = ["/snap/bin/canonical-livepatch", "disable"]
+        hookenv.log(
+            "Disabling canonical-livepatch ahead "
+            "of key change to work around LP#1628823"
+        )
         try:
             check_output(cmd, universal_newlines=True)
         except CalledProcessError as e:
-            hookenv.log('Unable to deactivate: {}'.format(str(e)), hookenv.ERROR)
-
-        cmd = ['/snap/bin/canonical-livepatch', 'enable', '{}'.format(livepatch_key.strip())]
-        hookenv.log('Activating canonical-livepatch with your key')
+            hookenv.log("Unable to deactivate: {}".format(str(e)), hookenv.ERROR)
+
+        cmd = [
+            "/snap/bin/canonical-livepatch",
+            "enable",
+            "{}".format(livepatch_key.strip()),
+        ]
+        hookenv.log("Activating canonical-livepatch with your key")
         try:
             check_output(cmd, universal_newlines=True)
         except CalledProcessError as e:
-            hookenv.log('Unable to activate: {}'.format(str(e)), hookenv.ERROR)
-            clear_flag('canonical-livepatch.active')
-            unit_update('blocked', 'Activation failed')
+            hookenv.log("Unable to activate: {}".format(str(e)), hookenv.ERROR)
+            clear_flag("canonical-livepatch.active")
+            unit_update("blocked", "Activation failed")
         else:
-            set_flag('canonical-livepatch.active')
+            set_flag("canonical-livepatch.active")
             unit_update()
     else:
-        hookenv.log('Unable to activate canonical-livepatch as no key has been set', hookenv.ERROR)
-        cmd = ['/snap/bin/canonical-livepatch', 'disable']
+        hookenv.log(
+            "Unable to activate canonical-livepatch as no key has been set",
+            hookenv.ERROR,
+        )
+        cmd = ["/snap/bin/canonical-livepatch", "disable"]
         try:
             check_output(cmd, universal_newlines=True)
         except CalledProcessError as e:
-            hookenv.log('Unable to deactivate: {}'.format(str(e)), hookenv.ERROR)
-        clear_flag('canonical-livepatch.active')
-        unit_update('blocked', 'Service disabled, please set livepatch_key to activate')
+            hookenv.log("Unable to deactivate: {}".format(str(e)), hookenv.ERROR)
+        clear_flag("canonical-livepatch.active")
+        unit_update("blocked", "Service disabled, please set livepatch_key to activate")
 
 
-register_trigger(when='config.changed.livepatch_proxy', clear_flag='livepatch-proxy.configured')
+register_trigger(
+    when="config.changed.livepatch_proxy", clear_flag="livepatch-proxy.configured"
+)
 
 
-@when_not('canonical-livepatch.supported')
+@when_not("canonical-livepatch.supported")
 def livepatch_supported():
+    """Check if livepatch is supported and set flag."""
     arch = uname()[4]
-    supported_archs = ['x86_64', ]
+    supported_archs = ["x86_64"]
+
     if arch not in supported_archs:
-        hookenv.log('Livepatch does not currently support {} architecture'.format(arch))
-        unit_update('blocked', 'Architecture {} is not supported by livepatch'.format(arch))
+        hookenv.log("Livepatch does not currently support {} architecture".format(arch))
+        unit_update(
+            "blocked", "Architecture {} is not supported by livepatch".format(arch)
+        )
     elif is_container() and not hookenv.config()["enable_container"]:
-        hookenv.log('OS container detected, livepatch is not needed')
-        unit_update('blocked', 'Livepatch is not needed in OS containers')
+        hookenv.log("OS container detected, livepatch is not needed")
+        unit_update("blocked", "Livepatch is not needed in OS containers")
     else:
-        set_flag('canonical-livepatch.supported')
+        set_flag("canonical-livepatch.supported")
 
 
-@when('canonical-livepatch.supported')
-@when_not('snap.installed.canonical-livepatch')
+@when("canonical-livepatch.supported")
+@when_not("snap.installed.canonical-livepatch")
 def install_livepatch():
+    """Install livepatch."""
     config = hookenv.config()
-    snap_channel = config.get('snap_channel')
-    snap.install('canonical-livepatch', **{'channel': snap_channel, })
+    snap_channel = config.get("snap_channel")
+    snap.install("canonical-livepatch", **{"channel": snap_channel})
 
 
-@when('snap.installed.canonical-livepatch')
-@when_not('livepatch-proxy.configured')
+@when("snap.installed.canonical-livepatch")
+@when_not("livepatch-proxy.configured")
 def proxy_settings():
+    """Get proxy settings and configure it."""
     # Configure proxies early, if required - LP#1761661
 
     preferred_proxy = None  # default to None
 
     for key, value in environ.items():
         # use environment's https_proxy or http_proxy if either are set
-        if key == 'https_proxy':
+        if key == "https_proxy":
             preferred_proxy = value
-        elif key == 'http_proxy':
+        elif key == "http_proxy":
             preferred_proxy = value
 
     # but if we have a charm configured proxy, prefer that
     config = hookenv.config()
-    charm_config_proxy = config.get('livepatch_proxy')
+    charm_config_proxy = config.get("livepatch_proxy")
     if charm_config_proxy:
         preferred_proxy = charm_config_proxy
 
     # whatever we prefer (or None), configure it!
     configure_proxies(preferred_proxy)
 
-    set_flag('livepatch-proxy.configured')
+    set_flag("livepatch-proxy.configured")
 
 
-@when('snap.installed.canonical-livepatch')
-@when('livepatch-proxy.configured')
-@when_not('canonical-livepatch.connected')
+@when("snap.installed.canonical-livepatch")
+@when("livepatch-proxy.configured")
+@when_not("canonical-livepatch.connected")
 def canonical_livepatch_connect():
+    """Check if livepatch socket is created and update unit."""
     # So if we've just installed snapd on a trusty system, we will not be on
     # the HWE kernel yet and unfortunately need to reboot first!
     current = LooseVersion(uname()[2])
-    required = LooseVersion('4.4')
-    uptrack_path = '/usr/sbin/uptrack-upgrade'
+    required = LooseVersion("4.4")
+    uptrack_path = "/usr/sbin/uptrack-upgrade"
     if path.exists(uptrack_path):
-        hookenv.log('Ksplice/Uptrack detected, please remove it and reboot')
-        unit_update('blocked', 'Remove ksplice and then reboot')
+        hookenv.log("Ksplice/Uptrack detected, please remove it and reboot")
+        unit_update("blocked", "Remove ksplice and then reboot")
     elif current < required:
-        hookenv.log('Reboot required, kernel {} is too old'.format(current))
-        unit_update('blocked', 'A reboot is required')
+        hookenv.log("Reboot required, kernel {} is too old".format(current))
+        unit_update("blocked", "A reboot is required")
     else:
-        unit_update('maintenance', 'Connecting to the livepatch service')
+        unit_update("maintenance", "Connecting to the livepatch service")
         # Make sure the service is ready for us
         wait_for_livepatch()
-        set_flag('canonical-livepatch.connected')
-        unit_update('blocked', 'Service disabled, please set livepatch_key to activate')
+        set_flag("canonical-livepatch.connected")
+        unit_update("blocked", "Service disabled, please set livepatch_key to activate")
 
 
-@when('canonical-livepatch.connected')
-@when_not('config.changed.livepatch_key', 'canonical-livepatch.active')
+@when("canonical-livepatch.connected")
+@when_not("config.changed.livepatch_key", "canonical-livepatch.active")
 def init_key():
+    """Activate livepatch."""
     # If deployed under Trusty before rebooting into the HWE kernel
     # the config-changed hook won't fire post-reboot as the state
     # isn't tracked, but we didn't initialise yet! So, handle it here
     activate_livepatch()
 
 
-@when('canonical-livepatch.connected', 'config.changed.livepatch_key')
+@when("canonical-livepatch.connected", "config.changed.livepatch_key")
 def update_key():
+    """Activate livepatch and write status to disk."""
     # handle regular config-changed hooks for the livepatch key
     activate_livepatch()
     write_status_to_disk()
 
 
-@when('snap.installed.canonical-livepatch', 'config.changed.snap_channel')
+@when("snap.installed.canonical-livepatch", "config.changed.snap_channel")
 def change_channel():
+    """Update snap channel."""
     config = hookenv.config()
-    snap_channel = config.get('snap_channel')
+    snap_channel = config.get("snap_channel")
     # refresh to the given channel
-    snap.refresh('canonical-livepatch', **{'channel': snap_channel, })
+    snap.refresh("canonical-livepatch", **{"channel": snap_channel})
 
 
 # Set up Nagios checks when the nrpe-external-master subordinate is related
-@when('nrpe-external-master.available')
-@when_not('canonical-livepatch.nagios-setup.complete')
-@when('canonical-livepatch.supported')
+@when("nrpe-external-master.available")
+@when_not("canonical-livepatch.nagios-setup.complete")
+@when("canonical-livepatch.supported")
 def configure_nagios(nagios):
-    if hookenv.hook_name() == 'update-status':
+    """Configure nagios checks."""
+    if hookenv.hook_name() == "update-status":
         return
 
     # Ask charmhelpers.contrib.charmsupport's nrpe to work out our hostname
@@ -267,44 +306,43 @@ def configure_nagios(nagios):
 
     # install nagios support files
     file_to_units(
-        'files/check_canonical-livepatch.cron',
-        '/etc/cron.d/check_canonical-livepatch',
+        "files/check_canonical-livepatch.cron", "/etc/cron.d/check_canonical-livepatch",
     )
     file_to_units(
-        'files/check_canonical-livepatch.py',
-        '/usr/lib/nagios/plugins/check_canonical-livepatch.py',
+        "files/check_canonical-livepatch.py",
+        "/usr/lib/nagios/plugins/check_canonical-livepatch.py",
     )
 
     # write current status to disk to satisfy the nagios check
     write_status_to_disk()
 
     # remove check from previous release with poorly formed name
-    nrpe_setup.remove_check(
-        shortname='check_canonical-livepatch'
-    )
+    nrpe_setup.remove_check(shortname="check_canonical-livepatch")
 
     # use charmhelpers to create the check
     nrpe_setup.add_check(
-        'canonical-livepatch',
-        'Verify canonical-livepatch is working',
-        '/usr/lib/nagios/plugins/check_canonical-livepatch.py'
+        "canonical-livepatch",
+        "Verify canonical-livepatch is working",
+        "/usr/lib/nagios/plugins/check_canonical-livepatch.py",
     )
 
     nrpe_setup.write()
 
     # Remove obsolete state from older charm, if present
-    clear_flag('canonical-livepatch.nagios-configured')
+    clear_flag("canonical-livepatch.nagios-configured")
     # Set our preferred state
-    set_flag('canonical-livepatch.nagios-setup.complete')
+    set_flag("canonical-livepatch.nagios-setup.complete")
 
 
-@when('snap.installed.canonical-livepatch', 'canonical-livepatch.active')
+@when("snap.installed.canonical-livepatch", "canonical-livepatch.active")
 def update_kernel_version():
+    """Update kernel version."""
     unit_update()
 
 
 # This is triggered on any config-changed, and after an upgrade-charm - you
 # don't get the latter with @when('config.changed')
-@hook('config-changed')
+@hook("config-changed")
 def set_nrpe_flag():
-    clear_flag('canonical-livepatch.nagios-setup.complete')
+    """Run config changed."""
+    clear_flag("canonical-livepatch.nagios-setup.complete")
diff --git a/tests/functional/tests/test_canonical_livepatch.py b/tests/functional/tests/test_canonical_livepatch.py
index 684cb2a..e87e876 100644
--- a/tests/functional/tests/test_canonical_livepatch.py
+++ b/tests/functional/tests/test_canonical_livepatch.py
@@ -1,22 +1,24 @@
+"""Zaza functional tests."""
+import logging
 import unittest
+
 import yaml
+
 import zaza.model as model
-import logging
 
 
 class TestBase(unittest.TestCase):
-    """Base Class for charm functional tests"""
+    """Base Class for charm functional tests."""
+
     @classmethod
     def setUpClass(cls):
-        """ Run setup for tests. """
+        """Run setup for tests."""
         cls.model_name = model.get_juju_model()
         cls.application_name = "canonical-livepatch"
         cls.lead_unit_name = model.get_lead_unit_name(
             cls.application_name, model_name=cls.model_name
         )
-        cls.units = model.get_units(
-            cls.application_name, model_name=cls.model_name
-        )
+        cls.units = model.get_units(cls.application_name, model_name=cls.model_name)
 
         cls.lead_unit = cls.units[0]
 
@@ -24,9 +26,13 @@ class TestBase(unittest.TestCase):
 
 
 class TestCanonicalLivepatch(TestBase):
+    """Class for charm functional tests."""
+
     def test_01_install(self):
-        if self.lead_unit.workload_status_message == ("Livepatch "
-                                                      "is not needed in OS containers"):
+        """Verify that the snap is installed."""
+        if self.lead_unit.workload_status_message == (
+            "Livepatch is not needed in OS containers"
+        ):
             model.set_application_config(
                 self.application_name, {"enable_container": "true"}
             )
@@ -37,6 +43,7 @@ class TestCanonicalLivepatch(TestBase):
         self.assertEqual(code, "0")
 
     def test_02_status(self):
+        """Verify canonical-livepatch status."""
         # run a status check - we expect this to return 1 due to no access key
         cmd = "sudo canonical-livepatch status"
         result = model.run_on_unit(self.lead_unit_name, cmd)
@@ -44,10 +51,11 @@ class TestCanonicalLivepatch(TestBase):
         self.assertEqual(code, "1")
 
     def test_03_nagios_init(self):
+        """Verify nagios plugins are rendered."""
         for path in [
-            '/etc/cron.d/check_canonical-livepatch',
-            '/usr/lib/nagios/plugins/check_canonical-livepatch.py',
-            '/var/lib/nagios/canonical-livepatch-status.txt'
+            "/etc/cron.d/check_canonical-livepatch",
+            "/usr/lib/nagios/plugins/check_canonical-livepatch.py",
+            "/var/lib/nagios/canonical-livepatch-status.txt",
         ]:
             logging.info("Checking that file '{}' exists".format(path))
             cmd = "stat {}".format(path)
@@ -56,20 +64,24 @@ class TestCanonicalLivepatch(TestBase):
             self.assertEqual(code, "0")
 
     def test_04_nagios_context_update(self):
+        """Update nagios context and verify."""
         test_context_name = "new_context"
         model.set_application_config(
             self.application_name, {"nagios_context": test_context_name}
         )
         model.block_until_all_units_idle()
 
-        cmd = "grep {} /var/lib/nagios/export/" \
-              "service__*_check_canonical-livepatch.cfg".format(test_context_name)
+        cmd = (
+            "grep {} /var/lib/nagios/export/"
+            "service__*_check_canonical-livepatch.cfg".format(test_context_name)
+        )
 
         result = model.run_on_unit(self.lead_unit_name, cmd)
         code = result.get("Code")
         self.assertEqual(code, "0")
 
     def test_05_channel_update(self):
+        """Update snap channel and verify."""
         # verify the current channel
         cmd = "snap info canonical-livepatch"
         result = model.run_on_unit(self.lead_unit_name, cmd)
@@ -83,9 +95,7 @@ class TestCanonicalLivepatch(TestBase):
         self.assertIn("stable", channel)
 
         # change channel to 'beta'
-        model.set_application_config(
-            self.application_name, {"snap_channel": "beta"}
-        )
+        model.set_application_config(self.application_name, {"snap_channel": "beta"})
         model.block_until_all_units_idle()
 
         # verify the current channel
@@ -101,14 +111,17 @@ class TestCanonicalLivepatch(TestBase):
         self.assertIn("beta", channel)
 
     def test_06_nagios_servicegroup_update(self):
+        """Update nagios service group and verify."""
         test_servicegroup_name = "new_servicegroup"
         model.set_application_config(
             self.application_name, {"nagios_servicegroups": test_servicegroup_name}
         )
         model.block_until_all_units_idle()
 
-        cmd = "grep {} /var/lib/nagios/export/" \
-              "service__*_check_canonical-livepatch.cfg".format(test_servicegroup_name)
+        cmd = (
+            "grep {} /var/lib/nagios/export/"
+            "service__*_check_canonical-livepatch.cfg".format(test_servicegroup_name)
+        )
 
         result = model.run_on_unit(self.lead_unit_name, cmd)
         code = result.get("Code")