Merge ~aluria/charm-prometheus-blackbox-exporter:rewrite into ~aluria/charm-prometheus-blackbox-exporter:refactor-peer-discovery

[Alvaro Uria]

[Peter Sabaini (peter-sabaini)]

Added mostly minor comments, questions and nits.

The only thing of of substance I'm wondering about is the use of unit ports (.get_unit_open_ports()) -- aiui those would be used as reference points (probe targets)? If that is the case I'm wondering if these wouldn't be too dynamic. E.g. how are they going to be updated if services change or are removed?

Also wonder about the scope of the bb exporter here. Should the bb exporter measure network health or service health? If a service goes down the listening port would go down as well, triggering an alert even though the network might be healthy.

review: Needs Fixing

[Alvaro Uria (aluria)]

Thank you for the review. A new MP can be found at [1]. I'll go ahead and mark this MP as rejected.

1. https://code.launchpad.net/~aluria/charm-prometheus-blackbox-exporter-peer/+git/charm-prometheus-blackbox-exporter-peer/+merge/374648

Unmerged commits

371fd4b... by Alvaro Uria on 2019-10-19

Rewrite charm using template-python-pytest

 * Cloned template-python-pytest
 * Moved the reactive script helpers to lib_bb_peer_exporter (generic)
 and lib_network (network related helpers)
 * Created minimum unit (for the libs) and functional tests
 * wheelhouse.txt installs psutil as well as netifaces and pyroute2.
 * Linting now runs flake8-docstrings, flake8-import-order and other
 extra checks. All scripts have been updated following parser
 recommendations.
 * Better use of the peer-discovery interface. Available (and transient)
 states when units join or leave a peer relation are used to trigger
 config changes.

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..32e2995
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,22 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Log files
+*.log
+
+.tox/
+.coverage
+
+# vi
+.*.swp
+
+# pycharm
+.idea/
+
+# version data
+repo-info
+
+# reports
+report/*
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..eb95ca8
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,56 @@
+PROJECTPATH = $(dir $(realpath $(firstword $(MAKEFILE_LIST))))
+DIRNAME = $(notdir $(PROJECTPATH:%/=%))
+
+ifndef CHARM_BUILD_DIR
+    CHARM_BUILD_DIR := /tmp/$(DIRNAME)-builds
+    $(warning Warning CHARM_BUILD_DIR was not set, defaulting to $(CHARM_BUILD_DIR))
+endif
+
+help:
+	@echo "This project supports the following targets"
+	@echo ""
+	@echo " make help - show this text"
+	@echo " make lint - run flake8"
+	@echo " make test - run the unittests and lint"
+	@echo " make unittest - run the tests defined in the unittest subdirectory"
+	@echo " make functional - run the tests defined in the functional subdirectory"
+	@echo " make release - build the charm"
+	@echo " make clean - remove unneeded files"
+	@echo ""
+
+lint:
+	@echo "Running flake8"
+	@tox -e lint
+
+test: lint unittest functional
+
+unittest:
+	@tox -e unit
+
+functional: build
+	@PYTEST_KEEP_MODEL=$(PYTEST_KEEP_MODEL) \
+	    PYTEST_CLOUD_NAME=$(PYTEST_CLOUD_NAME) \
+	    PYTEST_CLOUD_REGION=$(PYTEST_CLOUD_REGION) \
+	    CHARM_BUILD_DIR=$(CHARM_BUILD_DIR) \
+	    tox -e functional
+
+build:
+	@echo "Building charm to base directory $(CHARM_BUILD_DIR)"
+	@CHARM_LAYERS_DIR=./layers \
+		CHARM_INTERFACES_DIR=./interfaces \
+		TERM=linux \
+		CHARM_BUILD_DIR=$(CHARM_BUILD_DIR) \
+		charm build . --force
+
+release: clean build
+	@echo "Charm is built at $(CHARM_BUILD_DIR)"
+
+clean:
+	@echo "Cleaning files"
+	@if [ -d $(CHARM_BUILD_DIR) ] ; then rm -r $(CHARM_BUILD_DIR) ; fi
+	@if [ -d .tox ] ; then rm -r .tox ; fi
+	@if [ -d .pytest_cache ] ; then rm -r .pytest_cache ; fi
+	@find . -iname __pycache__ -exec rm -r {} +
+
+# The targets below don't depend on a file
+.PHONY: lint test unittest functional build release clean help
diff --git a/icon.svg b/icon.svg
new file mode 100644
index 0000000..ffa6296
--- /dev/null
+++ b/icon.svg
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="100px" height="100px" viewBox="0 0 100 100" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <!-- Generator: Sketch 45.2 (43514) - http://www.bohemiancoding.com/sketch -->
+    <title>prometheus</title>
+    <desc>Created with Sketch.</desc>
+    <defs></defs>
+    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="prometheus" fill-rule="nonzero" fill="#B8B8B8">
+            <path d="M50.0004412,3.12178676e-15 C22.3871247,3.12178676e-15 0,22.3848726 0,49.9995588 C0,77.6133626 22.3871247,100 50.0004412,100 C77.6137577,100 100,77.6133626 100,49.9995588 C100,22.3848726 77.6128753,-1.77635684e-15 50.0004412,3.12178676e-15 Z M49.8864141,88.223871 C42.8334797,88.223871 37.1152482,83.6412396 37.1152482,77.9899953 L62.6575799,77.9899953 C62.6575799,83.6404692 56.9393484,88.223871 49.8864141,88.223871 Z M70.9802642,74.6007896 L28.7901876,74.6007896 L28.7901876,67.159792 L70.9810563,67.159792 L70.9810563,74.6007896 L70.9802642,74.6007896 Z M70.8289715,63.3298895 L28.9105881,63.3298895 C28.771177,63.1734883 28.6285974,63.0193985 28.493939,62.860686 C24.1753633,57.7603128 23.1582959,55.0976406 22.1705366,52.3841188 C22.1539023,52.2947467 27.4071661,53.4280774 31.1324525,54.2432125 C31.1324525,54.2432125 33.0493552,54.6746641 35.8518351,55.1716037 C33.1610425,52.1036753 31.5633596,48.2036619 31.5633596,44.2173581 C31.5633596,35.4658266 38.4642091,27.8183486 35.974612,21.6370353 C38.397672,21.8288772 40.9894511,26.6110549 41.164507,34.0882636 C43.740444,30.6258652 44.8185037,24.3027893 44.8185037,20.4258893 C44.8185037,16.4118494 47.5378123,11.7490913 50.257913,11.5896084 C47.8332688,15.4765242 50.886055,18.8087166 53.5998189,27.0748652 C54.6176783,30.1797752 54.4877725,35.4049611 55.2735442,38.7186628 C55.5341479,31.8362408 56.7508266,21.794207 61.2397056,18.3271859 C59.2594343,22.6933211 61.5327858,28.1565758 63.0876948,30.7830368 C65.5963025,35.020507 67.1171509,38.2309685 67.1171509,44.302878 C67.1171509,48.3739312 65.5717472,52.2069155 62.964918,55.2031922 C65.9289881,54.6623369 67.9757966,54.1746426 67.9757966,54.1746426 L77.6014994,52.3479077 C77.6022915,52.3471373 76.2034279,57.9421388 70.8289715,63.3298895 Z" id="path3023"></path>
+        </g>
+    </g>
+</svg>
\ No newline at end of file
diff --git a/interfaces/.empty b/interfaces/.empty
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/interfaces/.empty
@@ -0,0 +1 @@
+#
diff --git a/layer.yaml b/layer.yaml
index 6036e6d..929f452 100644
--- a/layer.yaml
+++ b/layer.yaml
@@ -1,11 +1,15 @@
+# exclude the interfaces and layers folders we use for submodules
+exclude:
+  - interfaces
+  - layers
+# include required layers here
 includes:
   - 'layer:basic'
-  - "interface:juju-info"
+  - 'layer:status'
   - 'interface:http'
+  - 'interface:juju-info'
   - 'interface:peer-discovery'
-repo: 'https://git.launchpad.net/prometheus-blackbox-exporter-charm'
-ignore:
-  - '.*.swp'
+repo: 'https://git.launchpad.net/prometheus-blackbox-peer-exporter-charm'
 options:
   basic:
     use_venv: true
diff --git a/layers/.empty b/layers/.empty
new file mode 100644
index 0000000..792d600
--- /dev/null
+++ b/layers/.empty
@@ -0,0 +1 @@
+#
diff --git a/lib/lib_bb_peer_exporter.py b/lib/lib_bb_peer_exporter.py
new file mode 100644
index 0000000..6de8dc2
--- /dev/null
+++ b/lib/lib_bb_peer_exporter.py
@@ -0,0 +1,158 @@
+"""General helpers."""
+import os
+import subprocess
+
+from charmhelpers import fetch
+from charmhelpers.core import hookenv, host, unitdata
+from charmhelpers.core.templating import render
+
+from charms.reactive.helpers import any_file_changed, data_changed
+
+import lib_network
+
+import yaml
+
+
+APT_PKG_NAME = 'prometheus-blackbox-exporter'
+SVC_NAME = 'prometheus-blackbox-exporter'
+SVC_PATH = os.path.join('/usr/bin', SVC_NAME)
+PORT_DEF = 9115
+BLACKBOX_EXPORTER_YML_TMPL = 'blackbox.yaml.j2'
+CONF_FILE_PATH = '/etc/prometheus/blackbox.yml'
+
+
+class BBPeerExporterError(Exception):
+    """Handle exceptions encountered in BBPeerExporterHelper."""
+
+    pass
+
+
+class BBPeerExporterHelper():
+    """General helpers."""
+
+    def __init__(self):
+        """Load config.yaml."""
+        self.charm_config = hookenv.config()
+
+    @property
+    def config_changed(self):
+        """Verify and update checksum if config has changed."""
+        return data_changed('blackbox-peer-exporter.config', self.charm_config)
+
+    def peer_relation_data_changed(self, keymap):
+        """Verify and update checksum if peer relation data has changed."""
+        return data_changed('blackbox-peer.relation_data', keymap)
+
+    def bbexporter_relation_data_changed(self, keymap):
+        """Verify and update checksum if provides relation data has changed."""
+        return data_changed('blackbox-exporter.relation_data', keymap)
+
+    @property
+    def is_blackbox_exporter_relation_enabled(self):
+        """Verify if the blackbox-export relation exists."""
+        kv = unitdata.kv()
+        return kv.get('blackbox_exporter', False)
+
+    @property
+    def enable_blackbox_exporter_relation(self):
+        """Enable the blackbox-export flag for one time functions."""
+        kv = unitdata.kv()
+        kv.set('blackbox_exporter', True)
+
+    @property
+    def disable_blackbox_exporter_relation(self):
+        """Disable the blackbox-export flag for one time functions."""
+        kv = unitdata.kv()
+        kv.set('blackbox_exporter', False)
+
+    @property
+    def modules(self):
+        """Return the modules config parameter."""
+        return self.charm_config['modules']
+
+    @property
+    def scrape_interval(self):
+        """Return the scrape-interval config parameter."""
+        return self.charm_config['scrape-interval']
+
+    @property
+    def port_def(self):
+        """Return the port exposed by blackbox-exporter."""
+        return PORT_DEF
+
+    @property
+    def templates_changed(self):
+        """Verify if any stored template has changed."""
+        return any_file_changed(['templates/{}'.format(tmpl)
+                                 for tmpl in [BLACKBOX_EXPORTER_YML_TMPL]])
+
+    def install_packages(self):
+        """Install the APT package and sets Linux capabilities."""
+        fetch.install(APT_PKG_NAME, fatal=True)
+        cmd = ["setcap", "cap_net_raw+ep", SVC_PATH]
+        try:
+            subprocess.check_output(cmd)
+        except subprocess.CalledProcessError as error:
+            hookenv.log('unable to set linux capabilities: {}'.format(str(error)),
+                        hookenv.ERROR)
+            raise BBPeerExporterError('Unable to set linux capabilities')
+
+    def render_modules(self):
+        """Generate /etc/prometheus/blackbox.yml from the template."""
+        try:
+            modules = yaml.safe_load(self.modules)
+            if 'modules' in modules:
+                modules = modules['modules']
+        except (yaml.parser.ParserError, yaml.scanner.ScannerError) as error:
+            hookenv.log('error retrieving modules yaml config: {}'.format(str(error)),
+                        hookenv.ERROR)
+            # render "null" value
+            modules = None
+
+        context = {'modules': yaml.safe_dump(modules, default_flow_style=False)}
+        render(source=BLACKBOX_EXPORTER_YML_TMPL, target=CONF_FILE_PATH, context=context)
+        hookenv.open_port(PORT_DEF)
+
+    def restart_bbexporter(self):
+        """Restart the exporter daemon."""
+        if not host.service_running(SVC_NAME):
+            hookenv.log('Starting {}...'.format(SVC_NAME))
+            host.service_start(SVC_NAME)
+        else:
+            hookenv.log('Restarting {}, config file changed...'.format(SVC_NAME))
+            host.service_restart(SVC_NAME)
+
+    def get_icmp_and_tcp_targets(self, unit_networks, unit_ports, principal_unit):
+        """Return a dict with structured unit-networks and unit-ports for Prometheus."""
+        peers_net_info = {key: [] for key in ('networks', 'icmp_targets', 'tcp_targets')}
+        unit_networks = [] if unit_networks is None else lib_network.safe_loads(unit_networks)
+        unit_ports = [] if unit_ports is None else lib_network.safe_loads(unit_ports)
+        if not unit_networks:
+            return peers_net_info
+
+        local_networks = set(net['net'] for net in lib_network.get_unit_ipv4_networks())
+        for unit_network in unit_networks:
+            # We can't probe a network we can't reach directly
+            if unit_network['net'] not in local_networks:
+                continue
+
+            probe_dst_ip = unit_network['ip']
+            peers_net_info['networks'].append(unit_network['net'])
+            peers_net_info['icmp_targets'].append({
+                'network': unit_network['net'],
+                'interface': unit_network['iface'],
+                'ip-address': probe_dst_ip,
+                'principal-unit': principal_unit,
+                'module': 'icmp',
+                'source-ip': lib_network.get_source_ip_ipv4(probe_dst_ip),
+                })
+
+            for port in unit_ports:
+                peers_net_info['tcp_targets'].append({
+                    'ip-address': probe_dst_ip,
+                    'port': port,
+                    'principal-unit': principal_unit,
+                    'module': 'tcp_connect',
+                    })
+
+        return peers_net_info
diff --git a/lib/lib_network.py b/lib/lib_network.py
new file mode 100644
index 0000000..1d13452
--- /dev/null
+++ b/lib/lib_network.py
@@ -0,0 +1,94 @@
+"""Network helpers."""
+import ast
+import ipaddress
+import re
+import socket
+
+import netifaces
+
+import psutil
+
+import pyroute2
+
+IFACE_BLACKLIST_PATTERN = '^(lo|virbr|docker|lxdbr|vhost|tun|tap)'
+
+
+def _is_valid_ipv4_addr(address):
+    """Filter out non-IPv4 addresses."""
+    try:
+        ip = ipaddress.IPv4Address(address.get('addr'))
+        invalid = any((ip.is_multicast, ip.is_reserved, ip.is_link_local, ip.is_loopback))
+        return not invalid
+    except (ipaddress.AddressValueError, ValueError):
+        return False
+
+
+def _get_local_ifaces():
+    """Ignore interfaces used by Docker, KVM, Contrail, etc."""
+    iface_blacklist_re = re.compile(IFACE_BLACKLIST_PATTERN)
+    ifaces_whitelist = (iface for iface in netifaces.interfaces()
+                        if not iface_blacklist_re.search(iface))
+    return ifaces_whitelist
+
+
+def _get_ipv4_addresses(iface):
+    """Return all IPv4 IPs from a given interface.
+
+    Note that the interface name will exist as this function is called after
+    the list of interfaces has been retrieved.
+    """
+    ipv4_addresses = netifaces.ifaddresses(iface).get(netifaces.AF_INET, [])
+    filtered_ipv4_addrs = (ipv4_addr for ipv4_addr in ipv4_addresses
+                           if _is_valid_ipv4_addr(ipv4_addr))
+    return filtered_ipv4_addrs
+
+
+def get_source_ip_ipv4(destination):
+    """Return the src ip of a connection towards "destination".
+
+    This function is similar to running "ip route get <ipv4_addr>"
+
+    Disclaimer: source ip configuration for the blackbox exporter is done in
+    the module definition. To avoid having to create a module for every local
+    address we are simply letting the exporter use whatever source IP the
+    kernel deems appropriate. Be aware that this function is doing a route
+    lookup, and it is not - strictly speaking - returning the source IP of the
+    packet the blackbox exporter will generate. The two addresses should always
+    be the same, but YMMV.
+    """
+    with pyroute2.IPRoute() as ipr:
+        routes = ipr.route('get', dst=destination)
+        return routes[0].get_attr('RTA_PREFSRC')
+
+
+def get_unit_ipv4_networks():
+    """Return a list of IPv4 network blocks available on the host."""
+    networks = []
+    for iface in _get_local_ifaces():
+        for ip_addr in _get_ipv4_addresses(iface):
+            network = "{}/{}".format(ip_addr['addr'], ip_addr['netmask'])
+            ip_ipv4 = ipaddress.IPv4Interface(network)
+            networks.append(
+                {"iface": iface,
+                 "ip": str(ip_ipv4.ip),
+                 "net": str(ip_ipv4.network)}
+            )
+    return networks
+
+
+def get_unit_open_ports():
+    """Return TCP connections listening on ANY_ADDRESS."""
+    ports = [str(conn.laddr.port) for conn in psutil.net_connections()
+             if conn.status == "LISTEN" and
+             conn.type == socket.SOCK_STREAM and
+             conn.family.value in (netifaces.AF_INET, netifaces.AF_INET6) and
+             conn.laddr.ip in ("0.0.0.0", "::")]
+
+    return list(set(ports))
+
+
+def safe_loads(data_str):
+    """Evaluate a string and convert it into a Python object."""
+    if not isinstance(data_str, str) or not data_str:
+        return []
+    return ast.literal_eval(data_str)
diff --git a/metadata.yaml b/metadata.yaml
index 89d3c6e..6e0be63 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -1,10 +1,13 @@
-name: prometheus-blackbox-exporter
-display-name: Prometheus Blackbox Exporter
-summary: Blackbox exporter for Prometheus
-maintainer: Jacek Nykis <[e-mail]>
+name: prometheus-blackbox-peer-exporter
+display-name: Prometheus Blackbox Peer Exporter
+summary: Blackbox peer exporter for Prometheus
+maintainer: Llama (LMA) Charmers <[e-mail]>
 description: |
-       The blackbox exporter allows blackbox probing of
-       endpoints over HTTP, HTTPS, DNS, TCP and ICMP.
+       The blackbox peer exporter allows blackbox probing of
+       endpoints over HTTP, HTTPS, DNS, TCP and ICMP. This
+       charm allows all units to probe their peers, whereas
+       the prometheus-blackbox-exporter charm deploys a single
+       unit that can probe external endpoints.
 tags:
   - monitoring
 series:
diff --git a/reactive/prometheus-blackbox-exporter.py b/reactive/prometheus-blackbox-exporter.py
index 7d4e877..a057bba 100644
--- a/reactive/prometheus-blackbox-exporter.py
+++ b/reactive/prometheus-blackbox-exporter.py
@@ -1,250 +1,169 @@
-import ast
-import re
-import subprocess
-import yaml
-import sys
-
-from charmhelpers.core import host, hookenv
-from charmhelpers.core.templating import render
-from charms.reactive import (
-    when, when_not, set_state, remove_state
-)
-from ipaddress import (
-    IPv4Interface, IPv4Address
-)
-from pyroute2 import IPRoute
-from netifaces import interfaces, ifaddresses, AF_INET
-from charms.reactive.helpers import any_file_changed, data_changed
-from charms.reactive import hook
+"""Reactive script describing the prometheus-blackbox-peer-exporter behavior."""
 
-from charmhelpers.fetch import apt_install
+from charmhelpers.core import hookenv
 
-hooks = hookenv.Hooks()
+from charms.layer import status
+from charms.reactive import (
+    clear_flag, is_flag_set, set_flag, when, when_any, when_not
+)
 
-APT_PKG_NAME = 'prometheus-blackbox-exporter'
-SVC_NAME = 'prometheus-blackbox-exporter'
-EXECUTABLE = '/usr/bin/prometheus-blackbox-exporter'
-PORT_DEF = 9115
-BLACKBOX_EXPORTER_YML_TMPL = 'blackbox.yaml.j2'
-CONF_FILE_PATH = '/etc/prometheus/blackbox.yml'
-IFACE_BLACKLIST_PATTERN = re.compile('^(lo|virbr|docker|lxdbr|vhost|tun|tap)')
+from lib_bb_peer_exporter import BBPeerExporterError, BBPeerExporterHelper
 
+import lib_network
 
-def templates_changed(tmpl_list):
-    return any_file_changed(['templates/{}'.format(x) for x in tmpl_list])
+helper = BBPeerExporterHelper()
 
 
-@when_not('blackbox-exporter.installed')
+@when_not('prometheus-blackbox-peer-exporter.installed')
 def install_packages():
-    hookenv.status_set('maintenance', 'Installing software')
-    config = hookenv.config()
-    apt_install(APT_PKG_NAME, fatal=True)
-    cmd = ["sudo", "setcap", "cap_net_raw+ep", EXECUTABLE]
-    subprocess.check_output(cmd)
-    set_state('blackbox-exporter.installed')
-    set_state('blackbox-exporter.do-check-reconfig')
-
-
-def get_modules():
-    config = hookenv.config()
+    """Install APT package or get blocked until user action."""
+    status.maintenance('Installing software')
     try:
-        modules = yaml.safe_load(config.get('modules'))
-    except:
-        return None
-
-    if 'modules' in modules:
-        return yaml.safe_dump(modules['modules'], default_flow_style=False)
-    else:
-        return yaml.safe_dump(modules, default_flow_style=False)
+        helper.install_packages()
+        set_flag('prometheus-blackbox-peer-exporter.installed')
+        set_flag('prometheus-blackbox-peer-exporter.do-check-reconfig')
+    except BBPeerExporterError as error:
+        status.blocked(error)
 
 
-@when('blackbox-exporter.installed')
-@when('blackbox-exporter.do-reconfig-yaml')
+@when('prometheus-blackbox-peer-exporter.installed')
+@when('prometheus-blackbox-peer-exporter.do-reconfig-yaml')
 def write_blackbox_exporter_config_yaml():
-    modules = get_modules()
-    render(source=BLACKBOX_EXPORTER_YML_TMPL,
-           target=CONF_FILE_PATH,
-           context={'modules': modules}
-           )
-    hookenv.open_port(PORT_DEF)
-    set_state('blackbox-exporter.do-restart')
-    remove_state('blackbox-exporter.do-reconfig-yaml')
+    """Generate /etc/prometheus/blackbox.yml."""
+    helper.render_modules()
+    set_flag('prometheus-blackbox-peer-exporter.do-restart')
+    clear_flag('prometheus-blackbox-peer-exporter.do-reconfig-yaml')
 
 
-@when('blackbox-exporter.started')
+@when('prometheus-blackbox-peer-exporter.started')
 def check_config():
-    set_state('blackbox-exporter.do-check-reconfig')
+    """Trigger a config check."""
+    set_flag('prometheus-blackbox-peer-exporter.do-check-reconfig')
 
 
-@when('blackbox-exporter.do-check-reconfig')
+@when('prometheus-blackbox-peer-exporter.do-check-reconfig')
 def check_reconfig_blackbox_exporter():
-    config = hookenv.config()
-
-    if data_changed('blackbox-exporter.config', config):
-        set_state('blackbox-exporter.do-reconfig-yaml')
-
-    if templates_changed([BLACKBOX_EXPORTER_YML_TMPL]):
-        set_state('blackbox-exporter.do-reconfig-yaml')
+    """Trigger a blackbox.yml config regeneration on changes."""
+    if helper.config_changed or helper.templates_changed:
+        set_flag('prometheus-blackbox-peer-exporter.do-reconfig-yaml')
 
-    remove_state('blackbox-exporter.do-check-reconfig')
+    clear_flag('prometheus-blackbox-peer-exporter.do-check-reconfig')
 
 
-@when('blackbox-exporter.do-restart')
+@when('prometheus-blackbox-peer-exporter.do-restart')
 def restart_blackbox_exporter():
-    if not host.service_running(SVC_NAME):
-        hookenv.log('Starting {}...'.format(SVC_NAME))
-        host.service_start(SVC_NAME)
-    else:
-        hookenv.log('Restarting {}, config file changed...'.format(SVC_NAME))
-        host.service_restart(SVC_NAME)
-    hookenv.status_set('active', 'Ready')
-    set_state('blackbox-exporter.started')
-    remove_state('blackbox-exporter.do-restart')
+    """Restart the blackbox-exporter daemon."""
+    helper.restart_bbexporter()
+    status.active('Ready')
+    set_flag('prometheus-blackbox-peer-exporter.started')
+    clear_flag('prometheus-blackbox-peer-exporter.do-restart')
+
 
 # Relations
-@hook('blackbox-peer-relation-{joined,departed}')
-def configure_blackbox_exporter_relation(peers):
-    hookenv.log('Running blackbox exporter relation.')
-    hookenv.status_set('maintenance', 'Configuring blackbox peer relations.')
-    config = hookenv.config()
+@when_any('blackbox-peer.joined',
+          'blackbox-peer.departed')
+def blackbox_peer_changed():
+    """Shares unit data with its peers in the blackbox-peer relation.
+
+    If a single unit exists, data will NOT be shared (the main goal of this
+    service is to probe against its peers). When a unit is removed, all its
+    peers may need to rebuild their probes (one less).
+    """
+    hookenv.log('Running blackbox peer relations.')
+    status.maintenance('Configuring blackbox peer relations.')
+    rids = hookenv.relation_ids("blackbox-peer")
+    if not rids or len(rids) != 1:
+        hookenv.log('[*] More than one blackbox-peer relation', hookenv.ERROR)
+        return
+
+    rid, unit = rids[0], hookenv.local_unit()
+    relation_settings = hookenv.relation_get(rid=rid, unit=unit)
+    relation_settings.update({
+        'principal-unit': hookenv.principal_unit(),
+        'private-address': hookenv.unit_get('private-address'),
+        'unit-networks': lib_network.get_unit_ipv4_networks(),
+        'unit-ports': lib_network.get_unit_open_ports(),
+    })
+    if helper.peer_relation_data_changed(relation_settings):
+        hookenv.relation_set(relation_id=rid, relation_settings=relation_settings)
 
-    icmp_targets = []
-    tcp_targets = []
-    networks = []
-    for rid in hookenv.relation_ids('blackbox-peer'):
-        for unit in hookenv.related_units(rid):
-            unit_ports = hookenv.relation_get('unit-ports', rid=rid, unit=unit)
-            principal_unit = hookenv.relation_get('principal-unit', rid=rid, unit=unit)
-            unit_networks = hookenv.relation_get('unit-networks', rid=rid, unit=unit)
-            if unit_networks is not None:
-                unit_networks = ast.literal_eval(unit_networks)
-                for unit_network in unit_networks:
-                    # Chcek if same network exists on this unit
-                    if unit_network['net'] in [net['net'] for net in get_unit_networks()]:
-                        networks.append(unit_network['net'])
-                        probe_dst_ip = unit_network['ip']
-                        icmp_targets.append({
-                            'network': unit_network['net'],
-                            'interface': unit_network['iface'],
-                            'ip-address': probe_dst_ip,
-                            'principal-unit': principal_unit,
-                            'module': 'icmp',
-                            'source-ip': _get_source_ip(probe_dst_ip)
-                            })
-
-            if unit_ports is not None:
-                unit_ports = ast.literal_eval(unit_ports)
-                for port in unit_ports:
-                    tcp_targets.append({
-                        'ip-address': unit_network['ip'],
-                        'port': port,
-                        'principal-unit': principal_unit,
-                        'module': 'tcp_connect',
-                        })
-
-    relation_settings = {}
-    relation_settings['icmp_targets'] = icmp_targets
-    relation_settings['tcp_targets'] = tcp_targets
-    relation_settings['networks'] = networks
-    relation_settings['ip_address'] = hookenv.unit_get('private-address')
-    relation_settings['port'] = PORT_DEF
-    relation_settings['job_name'] = hookenv.principal_unit()
-    relation_settings['scrape_interval'] = config.get('scrape-interval')
+    # Share with Prometheus - all peer units' network data with present unit
+    if is_flag_set('blackbox-exporter.available'):
+        configure_blackbox_exporter_relation()
 
+    status.active('Ready')
 
-    for rel_id in hookenv.relation_ids('blackbox-exporter'):
-        relation_settings['ip_address'] = \
-            hookenv.ingress_address(rid=rel_id, unit=hookenv.local_unit())
-        hookenv.relation_set(relation_id=rel_id, relation_settings=relation_settings)
-
-    hookenv.status_set('active', 'Ready')
 
-
-def _get_source_ip(destination):
-    """
-    Get the source ip of a connection towards destination without having to run
-    ip r g via subprocess
-
-    Disclaimer: source ip configuration for the blackbox exporter is done in
-    the module definition. To avoid having to create a module for every local
-    address we are simply letting the exporter use whatever source IP the
-    kernel deems appropriate. Be aware that this function is doing a route
-    lookup, and it is not - strictly speaking - returning the source IP of the
-    packet the blackbox exporter will generate. The two addresses should always
-    be the same, but YMMV.
-    """
-    with IPRoute() as ipr:
-        routes = ipr.route('get', dst=destination)
-        return routes[0].get_attr('RTA_PREFSRC')
+@when('blackbox-peer.connected')
+@when('blackbox-exporter.available')
+def blackbox_peer_and_exporter_any_hook():
+    """First time the prometheus2:blackbox-exporter relation is seen."""
+    if not helper.is_blackbox_exporter_relation_enabled:
+        helper.enable_blackbox_exporter_relation
+        configure_blackbox_exporter_relation()
 
 
-def _is_valid_ip(address):
-    """
-    Filter out "uninteresting" addresses
-    """
-    ip = IPv4Address(address.get('addr'))
-    return not (ip.is_multicast or
-                ip.is_reserved or
-                ip.is_link_local or
-                ip.is_loopback)
+@when('blackbox-peer.connected')
+@when_not('blackbox-exporter.available')
+def blackbox_peer_and_no_exporter_any_hook():
+    """When the prometheus2:blackbox-exporter relation is gone."""
+    if helper.is_blackbox_exporter_relation_enabled:
+        helper.disable_blackbox_exporter_relation
 
 
-def _is_valid_iface(iface):
-    """
-    Ignore interfaces used by Docker, KVM, Contrail, etc
-    """
-    if IFACE_BLACKLIST_PATTERN.search(iface):
-        return False
-    else:
-        return True
+def configure_blackbox_exporter_relation():
+    """Retrieve data from peers and share the bundle of probes with Prometheus."""
+    hookenv.log('Running blackbox exporter relation.')
 
+    # Reads peer relations
+    rids = hookenv.relation_ids("blackbox-peer")
+    if not rids or len(rids) != 1:
+        hookenv.log('[*] More than one blackbox-peer relation', hookenv.ERROR)
+        return
 
-def get_unit_networks():
+    status.maintenance('Configuring blackbox peer relations.')
     networks = []
-    for iface in filter(_is_valid_iface, interfaces()):
-        ip_addresses = ifaddresses(iface)
-        for ip_address in filter(_is_valid_ip, ip_addresses.get(AF_INET, [])):
-            ip_v4 = IPv4Interface(
-                "{}/{}".format(ip_address['addr'], ip_address['netmask'])
-            )
-            networks.append(
-                {"iface": iface,
-                 "ip": str(ip_v4.ip),
-                 "net": str(ip_v4.network)}
-            )
-    return networks
-
-def get_principal_unit_open_ports():
-    cmd = "lsof -P -iTCP -sTCP:LISTEN".split()
-    result = subprocess.check_output(cmd)
-    result = result.decode(sys.stdout.encoding)
-
-    ports = []
-    for r in result.split('\n'):
-        for p in r.split():
-            if '*:' in p:
-                ports.append(p.split(':')[1])
-    ports = [p for p in set(ports)]
-
-    return ports
-
-@hook('blackbox-peer-relation-{joined,departed}')
-def blackbox_peer_departed(peers):
-    hookenv.log('Blackbox peer unit joined/departed.')
-    set_state('blackbox-exporter.redo-peer-relation')
-
-@when('blackbox-exporter.redo-peer-relation')
-def setup_blackbox_peer_relation(peers):
-    # Set blackbox-peer relations
-    hookenv.log('Running blackbox peer relations.')
-    hookenv.status_set('maintenance', 'Configuring blackbox peer relations.')
-    for rid in hookenv.relation_ids('blackbox-peer'):
-        relation_settings = hookenv.relation_get(rid=rid, unit=hookenv.local_unit())
-        relation_settings['principal-unit'] = hookenv.principal_unit()
-        relation_settings['private-address'] = hookenv.unit_get('private-address')
-        relation_settings['unit-networks'] = get_unit_networks()
-        relation_settings['unit-ports'] = get_principal_unit_open_ports()
-        hookenv.relation_set(relation_id=rid, relation_settings=relation_settings)
+    icmp_targets = []
+    tcp_targets = []
+    rid = rids[0]
+    for peer_unit in hookenv.related_units(rid):
+        # principal-unit: ubuntu/1
+        principal_unit = hookenv.relation_get('principal-unit', rid=rid, unit=peer_unit)
+        # unit-networks: '[{''iface'': ''eth0'', ''ip'': ''10.66.111.152'', ''net'': ''10.66.111.0/24''}]'
+        unit_networks = hookenv.relation_get('unit-networks', rid=rid, unit=peer_unit)
+        # unit-ports: '[''22'', ''9115'']'
+        unit_ports = hookenv.relation_get('unit-ports', rid=rid, unit=peer_unit)
+
+        peer_net_info = helper.get_icmp_and_tcp_targets(
+            unit_networks, unit_ports, principal_unit)
+
+        if peer_net_info['networks']:
+            networks.extend(peer_net_info['networks'])
+
+        if peer_net_info['icmp_targets']:
+            icmp_targets.extend(peer_net_info['icmp_targets'])
+
+        if peer_net_info['tcp_targets']:
+            tcp_targets.extend(peer_net_info['tcp_targets'])
+
+    relation_settings = {
+        'networks': networks,
+        'icmp_targets': icmp_targets,
+        'tcp_targets': tcp_targets,
+        'ip_address': hookenv.unit_get('private-address'),
+        'port': helper.port_def,
+        'job_name': hookenv.principal_unit(),
+        'scrape_interval': helper.scrape_interval,
+    }
+
+    if not helper.bbexporter_relation_data_changed(relation_settings):
+        status.active('Ready')
+        return
+
+    # Shares information with the "prometheus" application
+    for rel_id in hookenv.relation_ids('blackbox-exporter'):
+        relation_settings['ip_address'] = \
+            hookenv.ingress_address(rid=rel_id, unit=hookenv.local_unit())
+        hookenv.relation_set(relation_id=rel_id, relation_settings=relation_settings)
 
-    hookenv.status_set('active', 'Ready')
-    remove_state('blackbox-exporter.redo-peer-relation')
+    status.active('Ready')
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..8462291
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+# Include python requirements here
diff --git a/tests/functional/bundle.yaml.j2 b/tests/functional/bundle.yaml.j2
new file mode 100644
index 0000000..e52b841
--- /dev/null
+++ b/tests/functional/bundle.yaml.j2
@@ -0,0 +1,13 @@
+applications:
+  {{ ubuntu_appname }}:
+    series: {{ series }}
+    charm: cs:ubuntu
+    num_units: 2
+
+  {{ bb_appname }}:
+    series: {{ series }}
+    charm: {{ charm_path }}
+
+relations:
+  - - {{ ubuntu_appname }}
+    - {{ bb_appname }}
diff --git a/tests/functional/conftest.py b/tests/functional/conftest.py
new file mode 100644
index 0000000..9679d97
--- /dev/null
+++ b/tests/functional/conftest.py
@@ -0,0 +1,68 @@
+"""
+Reusable pytest fixtures for functional testing.
+
+Environment variables
+---------------------
+
+PYTEST_CLOUD_REGION, PYTEST_CLOUD_NAME: cloud name and region to use for juju model creation
+
+PYTEST_KEEP_MODEL: if set, the testing model won't be torn down at the end of the testing session
+"""
+
+import asyncio
+import os
+import subprocess
+import uuid
+
+from juju.controller import Controller
+
+from juju_tools import JujuTools
+
+import pytest
+
+
[e-mail](scope='module')
+def event_loop():
+    """Override the default pytest event loop to allow for fixtures using a broader scope."""
+    loop = asyncio.get_event_loop_policy().new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.set_debug(True)
+    yield loop
+    loop.close()
+    asyncio.set_event_loop(None)
+
+
[e-mail](scope='module')
+async def controller():
+    """Connect to the current controller."""
+    _controller = Controller()
+    await _controller.connect_current()
+    yield _controller
+    await _controller.disconnect()
+
+
[e-mail](scope='module')
+async def model(controller):
+    """Create a temporary model to run the tests."""
+    model_name = "functest-{}".format(str(uuid.uuid4())[-12:])
+    _model = await controller.add_model(model_name,
+                                        cloud_name=os.getenv('PYTEST_CLOUD_NAME'),
+                                        region=os.getenv('PYTEST_CLOUD_REGION'),
+                                        )
+    # https://github.com/juju/python-libjuju/issues/267
+    subprocess.check_call(['juju', 'models'])
+    while model_name not in await controller.list_models():
+        await asyncio.sleep(1)
+    yield _model
+    await _model.disconnect()
+    if not os.getenv('PYTEST_KEEP_MODEL'):
+        await controller.destroy_model(model_name)
+        while model_name in await controller.list_models():
+            await asyncio.sleep(1)
+
+
[e-mail](scope='module')
+async def jujutools(controller, model):
+    """Load helpers to run commands on the units."""
+    tools = JujuTools(controller, model)
+    return tools
diff --git a/tests/functional/juju_tools.py b/tests/functional/juju_tools.py
new file mode 100644
index 0000000..850c296
--- /dev/null
+++ b/tests/functional/juju_tools.py
@@ -0,0 +1,71 @@
+"""Juju helpers to run commands on the units."""
+import base64
+import pickle
+
+import juju
+
+
+class JujuTools:
+    """Load helpers to run commands on units."""
+
+    def __init__(self, controller, model):
+        """Load initialized controller and model."""
+        self.controller = controller
+        self.model = model
+
+    async def run_command(self, cmd, target):
+        """
+        Run a command on a unit.
+
+        :param cmd: Command to be run
+        :param unit: Unit object or unit name string
+        """
+        unit = (
+            target
+            if isinstance(target, juju.unit.Unit)
+            else await self.get_unit(target)
+        )
+        action = await unit.run(cmd)
+        return action.results
+
+    async def remote_object(self, imports, remote_cmd, target):
+        """
+        Run command on target machine and returns a python object of the result.
+
+        :param imports: Imports needed for the command to run
+        :param remote_cmd: The python command to execute
+        :param target: Unit object or unit name string
+        """
+        python3 = "python3 -c '{}'"
+        python_cmd = ('import pickle;'
+                      'import base64;'
+                      '{}'
+                      'print(base64.b64encode(pickle.dumps({})), end="")'
+                      .format(imports, remote_cmd))
+        cmd = python3.format(python_cmd)
+        results = await self.run_command(cmd, target)
+        return pickle.loads(base64.b64decode(bytes(results['Stdout'][2:-1], 'utf8')))
+
+    async def file_stat(self, path, target):
+        """
+        Run stat on a file.
+
+        :param path: File path
+        :param target: Unit object or unit name string
+        """
+        imports = 'import os;'
+        python_cmd = ('os.stat("{}")'
+                      .format(path))
+        print("Calling remote cmd: " + python_cmd)
+        return await self.remote_object(imports, python_cmd, target)
+
+    async def file_contents(self, path, target):
+        """
+        Return the contents of a file.
+
+        :param path: File path
+        :param target: Unit object or unit name string
+        """
+        cmd = 'cat {}'.format(path)
+        result = await self.run_command(cmd, target)
+        return result['Stdout']
diff --git a/tests/functional/requirements.txt b/tests/functional/requirements.txt
new file mode 100644
index 0000000..3d8a11b
--- /dev/null
+++ b/tests/functional/requirements.txt
@@ -0,0 +1,7 @@
+flake8
+jinja2
+juju
+mock
+pytest
+pytest-asyncio
+requests
diff --git a/tests/functional/test_deploy.py b/tests/functional/test_deploy.py
new file mode 100644
index 0000000..173ab29
--- /dev/null
+++ b/tests/functional/test_deploy.py
@@ -0,0 +1,150 @@
+"""Tests around Juju deployed charms."""
+import asyncio
+import os
+import stat
+import subprocess
+
+import jinja2
+
+import pytest
+
+# Treat all tests as coroutines
+pytestmark = pytest.mark.asyncio
+
+CHARM_BUILD_DIR = os.getenv('CHARM_BUILD_DIR', '.').rstrip('/')
+
+# series = ['bionic',
+#           pytest.param('eoan', marks=pytest.mark.xfail(reason='canary')),
+#           ]
+series = ['bionic']
+sources = [('local', os.path.join(CHARM_BUILD_DIR, 'prometheus-blackbox-peer-exporter')),
+           # ('jujucharms', 'cs:...'),
+           ]
+
+
+def render(templates_dir, template_name, context):
+    """Render a configuration file from a template."""
+    templates = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir))
+    template = templates.get_template(template_name)
+    return template.render(context)
+
+# Uncomment for re-using the current model, useful for debugging functional tests
+# @pytest.fixture(scope='module')
+# async def model():
+#     from juju.model import Model
+#     model = Model()
+#     await model.connect_current()
+#     yield model
+#     await model.disconnect()
+
+
+# Custom fixtures
[e-mail](params=series)
+def series(request):
+    """Return series scope."""
+    return request.param
+
+
[e-mail](params=sources, ids=[s[0] for s in sources])
+def source(request):
+    """Return location of deployed charm (local disk or charm store)."""
+    return request.param
+
+
[e-mail]
+async def app(model, series, source):
+    """Return Juju application object for the deployed series."""
+    app_name = 'prometheus-blackbox-peer-exporter-{}-{}'.format(series, source[0])
+    return await model._wait_for_new('application', app_name)
+
+
+async def test_bbpeerexporter_deploy(model, series, source, request):
+    """Start a deploy for each series.
+
+    subprocess is used because libjuju fails with JAAS
+    https://github.com/juju/python-libjuju/issues/221
+    """
+    dir_path = os.path.dirname(os.path.realpath(__file__))
+    bundle_path = os.path.join(CHARM_BUILD_DIR, 'bundle.yaml')
+
+    ubuntu_appname = "ubuntu-{}-{}".format(series, source[0])
+    bb_appname = 'prometheus-blackbox-peer-exporter-{}-{}'.format(series, source[0])
+
+    context = {
+        "ubuntu_appname": ubuntu_appname,
+        "bb_appname": bb_appname,
+        "series": series,
+        "charm_path": os.path.join(CHARM_BUILD_DIR, "prometheus-blackbox-peer-exporter")
+    }
+    rendered = render(dir_path, "bundle.yaml.j2", context)
+    with open(bundle_path, "w") as fd:
+        fd.write(rendered)
+
+    if not os.path.exists(bundle_path):
+        assert False
+
+    cmd = ["juju", "deploy", "-m", model.info.name, bundle_path]
+    if request.node.get_closest_marker('xfail'):
+        # If series is 'xfail' force install to allow testing against versions not in
+        # metadata.yaml
+        cmd.append('--force')
+    subprocess.check_call(cmd)
+    while True:
+        try:
+            model.applications[bb_appname]
+            break
+        except KeyError:
+            await asyncio.sleep(5)
+    assert True
+
+
+# async def test_charm_upgrade(model, app):
+#     """Test juju upgrade-charm, from one source to another."""
+#     if app.name.endswith('local'):
+#         pytest.skip("No need to upgrade the local deploy")
+#     unit = app.units[0]
+#     await model.block_until(lambda: unit.agent_status == 'idle',
+#                             timeout=60)
+#     subprocess.check_call(['juju',
+#                            'upgrade-charm',
+#                            '--switch={}'.format(sources[0][1]),
+#                            '-m', model.info.name,
+#                            app.name,
+#                            ])
+#     await model.block_until(lambda: unit.agent_status == 'executing')
+
+
+# Tests
+async def test_bbpeerexporter_status(model, app):
+    """Verify status for all deployed series of the charm."""
+    await model.block_until(lambda: app.status == 'active',
+                            timeout=900)
+    unit = app.units[0]
+    await model.block_until(lambda: unit.agent_status == 'idle',
+                            timeout=900)
+
+
+# async def test_example_action(app):
+#     unit = app.units[0]
+#     action = await unit.run_action('example-action')
+#     action = await action.wait()
+#     assert action.status == 'completed'
+
+
+async def test_run_command(app, jujutools):
+    """Test simple juju-run command."""
+    unit = app.units[0]
+    cmd = 'hostname -i'
+    results = await jujutools.run_command(cmd, unit)
+    assert results['Code'] == '0'
+    assert unit.public_address in results['Stdout']
+
+
+async def test_file_stat(app, jujutools):
+    """Verify a file exists in the deployed unit."""
+    unit = app.units[0]
+    path = '/var/lib/juju/agents/unit-{}/charm/metadata.yaml'.format(unit.entity_id.replace('/', '-'))
+    fstat = await jujutools.file_stat(path, unit)
+    assert stat.filemode(fstat.st_mode) == '-rw-r--r--'
+    assert fstat.st_uid == 0
+    assert fstat.st_gid == 0
diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py
new file mode 100644
index 0000000..5410860
--- /dev/null
+++ b/tests/unit/conftest.py
@@ -0,0 +1,69 @@
+"""Reusable pytest fixtures for functional testing."""
+import unittest.mock as mock
+
+import pytest
+
+
+# If layer options are used, add this to prometheusblackboxpeerexporter
+# and import layer in lib_bb_peer_exporter
[e-mail]
+def mock_layers(monkeypatch):
+    """Mock imported modules and calls."""
+    import sys
+    sys.modules['charms.layer'] = mock.Mock()
+    sys.modules['charms.reactive.helpers'] = mock.Mock()
+    sys.modules['reactive'] = mock.Mock()
+    # sys.modules['lib_network'] = mock.Mock()
+    # Mock any functions in layers that need to be mocked here
+
+    def options(layer):
+        # mock options for layers here
+        # if layer == 'status':
+        #     return None
+        return None
+
+    # monkeypatch.setattr('lib_bb_peer_exporter.lib_network', options)
+
+
[e-mail]
+def mock_hookenv_config(monkeypatch):
+    """Mock hookenv.config()."""
+    import yaml
+
+    def mock_config():
+        cfg = {}
+        yml = yaml.load(open('./config.yaml'))
+
+        # Load all defaults
+        for key, value in yml['options'].items():
+            cfg[key] = value['default']
+
+        # Manually add cfg from other layers
+        return cfg
+        # cfg['my-other-layer'] = 'mock'
+
+    monkeypatch.setattr('lib_bb_peer_exporter.hookenv.config', mock_config)
+
+
[e-mail]
+def mock_remote_unit(monkeypatch):
+    """Mock a remote unit name."""
+    monkeypatch.setattr('lib_bb_peer_exporter.hookenv.remote_unit', lambda: 'unit-mock/0')
+
+
[e-mail]
+def mock_charm_dir(monkeypatch):
+    """Mock CHARM_DIR Juju environment variable."""
+    monkeypatch.setattr('lib_bb_peer_exporter.hookenv.charm_dir', lambda: '/mock/charm/dir')
+
+
[e-mail]
+def bbpeerexporter(tmpdir, mock_layers, mock_hookenv_config, mock_charm_dir, monkeypatch):
+    """Test the basic structure of the helper class."""
+    from lib_bb_peer_exporter import BBPeerExporterHelper
+    helper = BBPeerExporterHelper()
+
+    # Any other functions that load helper will get this version
+    monkeypatch.setattr('lib_bb_peer_exporter.BBPeerExporterHelper', lambda: helper)
+
+    return helper
diff --git a/tests/unit/requirements.txt b/tests/unit/requirements.txt
new file mode 100644
index 0000000..31b5d37
--- /dev/null
+++ b/tests/unit/requirements.txt
@@ -0,0 +1,7 @@
+charmhelpers
+charms.reactive
+netifaces
+psutil
+pyroute2
+pytest
+pytest-cov
diff --git a/tests/unit/test_lib_bb_peer_exporter.py b/tests/unit/test_lib_bb_peer_exporter.py
new file mode 100644
index 0000000..9c0ab0f
--- /dev/null
+++ b/tests/unit/test_lib_bb_peer_exporter.py
@@ -0,0 +1,46 @@
+"""Tests around lib_bb_peer_exporter module."""
+
+
+class TestLib():
+    """Test suite for lib_bb_peer_exporter module."""
+
+    def test_bbpeerexporter(self, bbpeerexporter):
+        """See if the helper fixture works to load charm configs."""
+        assert isinstance(bbpeerexporter.charm_config, dict)
+        assert bbpeerexporter.modules
+        assert bbpeerexporter.scrape_interval == "60s"
+        assert bbpeerexporter.port_def == 9115
+
+    def test_get_icmp_and_tcp_targets(self, bbpeerexporter, monkeypatch):
+        """Correct output over given input."""
+        principal_unit = "ubuntu/1"
+        unit_networks = "[{'iface': 'eth0', 'ip': '10.66.111.152', 'net': '10.66.111.0/24'}]"
+        unit_ports = "['22', '9115']"
+        monkeypatch.setattr(
+            'lib_network.get_source_ip_ipv4',
+            lambda x: '10.66.111.1')
+        monkeypatch.setattr(
+            'lib_network.get_unit_ipv4_networks',
+            lambda: [{'net': '192.168.0.0/23'}, {'net': '10.66.111.0/24'}])
+
+        expected = {
+            "networks": ['10.66.111.0/24'],
+            "icmp_targets": [{
+                'network': '10.66.111.0/24',
+                'interface': 'eth0',
+                'ip-address': '10.66.111.152',
+                'principal-unit': principal_unit,
+                'module': 'icmp',
+                'source-ip': '10.66.111.1',
+            }],
+            "tcp_targets": [{'ip-address': '10.66.111.152', 'port': '22',
+                             'principal-unit': principal_unit, 'module': 'tcp_connect',
+                             },
+                            {
+                              'ip-address': '10.66.111.152', 'port': '9115',
+                              'principal-unit': principal_unit, 'module': 'tcp_connect',
+                            }],
+            }
+
+        actual = bbpeerexporter.get_icmp_and_tcp_targets(unit_networks, unit_ports, principal_unit)
+        assert actual == expected
diff --git a/tox.ini b/tox.ini
new file mode 100644
index 0000000..bd1f448
--- /dev/null
+++ b/tox.ini
@@ -0,0 +1,50 @@
+[tox]
+skipsdist=True
+envlist = unit, functional
+skip_missing_interpreters = True
+
+[testenv]
+basepython = python3
+setenv =
+  PYTHONPATH = .
+
+[testenv:unit]
+commands = pytest -v --ignore {toxinidir}/tests/functional \
+	   --cov=lib \
+	   --cov=reactive \
+	   --cov=actions \
+	   --cov-report=term \
+	   --cov-report=annotate:report/annotated \
+	   --cov-report=html:report/html
+deps = -r{toxinidir}/tests/unit/requirements.txt
+       -r{toxinidir}/requirements.txt
+setenv = PYTHONPATH={toxinidir}/lib
+
+[testenv:functional]
+passenv =
+  HOME
+  CHARM_BUILD_DIR
+  PATH
+  PYTEST_KEEP_MODEL
+  PYTEST_CLOUD_NAME
+  PYTEST_CLOUD_REGION
+commands = pytest -v --ignore {toxinidir}/tests/unit
+deps = -r{toxinidir}/tests/functional/requirements.txt
+       -r{toxinidir}/requirements.txt
+
+[testenv:lint]
+commands = flake8
+deps =
+    flake8
+    flake8-docstrings
+    flake8-import-order
+    pep8-naming
+    flake8-colors
+
+[flake8]
+exclude =
+    .git,
+    __pycache__,
+    .tox,
+max-line-length = 120
+max-complexity = 10
diff --git a/wheelhouse.txt b/wheelhouse.txt
index ea2fb5e..f06761b 100644
--- a/wheelhouse.txt
+++ b/wheelhouse.txt
@@ -1,2 +1,3 @@
 netifaces
+psutil
 pyroute2