Merge ~sylvain-pineau/plainbox:xmas_diet into plainbox:master

[Sylvain Pineau]

Cleanup of obsolete code (whitelists, local jobs, py3.2)

[Maciej Kisielewski (kissiel)]

Great branch. Also literally :)

Few observations:

Saving storage now uses the py33 method that uses python API for 'saving-at-location'. This is necessary for corner cases when saving. This is the only thing that makes checkbox not run on OSX at the moment.

Lazy modules were not actually used properly, as many of the modules are imported at checkbox start-up, so their laziness was not actually employed.

Overall, awesome stuff covered in awesomesauce. Great christmas present!
Huge +1!

review: Approve

[Devices Certification Bot (ce-certification-qa)]

The merge was fine but running tests failed.

[trusty] starting container
[trusty] (timing) 0.00user 0.00system 0:00.14elapsed 5%CPU (0avgtext+0avgdata 4960maxresident)k
[trusty] (timing) 432inputs+72outputs (1major+1436minor)pagefaults 0swaps
[trusty] provisioning container
[trusty] (timing) 38.72user 12.08system 2:06.54elapsed 40%CPU (0avgtext+0avgdata 68076maxresident)k
[trusty] (timing) 591960inputs+1882064outputs (581major+1356518minor)pagefaults 0swaps
[trusty-testing] Starting tests...
Found a test script: ./requirements/001-container-tests-plainbox-egg-info
[trusty-testing] 001-container-tests-plainbox-egg-info: PASS
[trusty-testing] (timing) 0.29user 0.03system 0:00.34elapsed 94%CPU (0avgtext+0avgdata 22680maxresident)k
[trusty-testing] (timing) 760inputs+96outputs (17major+9248minor)pagefaults 0swaps
Found a test script: ./requirements/container-tests-plainbox
[trusty-testing] container-tests-plainbox: PASS
[trusty-testing] (timing) 37.84user 2.28system 0:45.87elapsed 87%CPU (0avgtext+0avgdata 68532maxresident)k
[trusty-testing] (timing) 18768inputs+82760outputs (71major+931471minor)pagefaults 0swaps
Found a test script: ./requirements/container-tests-plainbox-documentation
[trusty-testing] container-tests-plainbox-documentation: FAIL
[trusty-testing] stdout: https://paste.ubuntu.com/26345630/
[trusty-testing] stderr: https://paste.ubuntu.com/26345631/
[trusty-testing] (timing) Command exited with non-zero status 1
[trusty-testing] (timing) 1.40user 0.07system 0:01.55elapsed 94%CPU (0avgtext+0avgdata 52832maxresident)k
[trusty-testing] (timing) 11544inputs+1720outputs (17major+20042minor)pagefaults 0swaps
Found a test script: ./requirements/container-tests-plainbox-integration
[trusty-testing] container-tests-plainbox-integration: PASS
[trusty-testing] (timing) 0.91user 0.06system 0:01.02elapsed 95%CPU (0avgtext+0avgdata 39536maxresident)k
[trusty-testing] (timing) 56inputs+112outputs (0major+30120minor)pagefaults 0swaps
Found a test script: ./requirements/container-tests-providers-internal
[trusty-testing] container-tests-providers-internal: PASS
[trusty-testing] (timing) 1.12user 0.05system 0:01.20elapsed 98%CPU (0avgtext+0avgdata 30060maxresident)k
[trusty-testing] (timing) 264inputs+8outputs (1major+19705minor)pagefaults 0swaps
[trusty-testing] Fixing file permissions in source directory
[trusty-testing] Destroying container
Name: trusty-testing
State: STOPPED
[xenial] starting container
[xenial] (timing) 0.00user 0.00system 0:00.13elapsed 5%CPU (0avgtext+0avgdata 4984maxresident)k
[xenial] (timing) 496inputs+72outputs (1major+1427minor)pagefaults 0swaps
[xenial] provisioning container
[xenial] (timing) 42.40user 7.98system 1:44.10elapsed 48%CPU (0avgtext+0avgdata 81308maxresident)k
[xenial] (timing) 725800inputs+2195984outputs (594major+1640039minor)pagefaults 0swaps
[xenial-testing] Starting tests...
Found a test script: ./requirements/001-container-tests-plainbox-egg-info
[xenial-testing] 001-container-tests-plainbox-egg-info: PASS
[xenial-testing] (timing) 0.34user 0.04system 0:00.40elapsed 94%CPU (0avgtext+0avgdata 23860ma...

review: Needs Fixing

diff --git a/MANIFEST.in b/MANIFEST.in
index e51f963..1eb7c3b 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -35,7 +35,6 @@ include plainbox/impl/providers/stubbox/po/*.pot
 include plainbox/impl/providers/stubbox/po/POTFILES.in
 include plainbox/impl/providers/stubbox/units/jobs/*.pxu
 include plainbox/impl/providers/stubbox/units/testplans/*.pxu
-include plainbox/impl/providers/stubbox/whitelists/*.whitelist
 
 include plainbox/vendor/argparse/py*-argparse.py
 
diff --git a/daily-package-testing/README b/daily-package-testing/README
deleted file mode 100644
index 27d3e8e..0000000
--- a/daily-package-testing/README
+++ /dev/null
@@ -1,18 +0,0 @@
-About
-=====
-
-This Vagrantfile can be used to see how packaged version of plainbox from the
-ppa looks like.
-
-The package is built with this recipe:
-https://code.launchpad.net/~checkbox-dev/+recipe/plainbox-daily
-
-Usage instructions
-==================
-
-$TARGET is either precise or quantal
-
-$ vagrant up $TARGET
-$ vagrant ssh $TARGET
-$ plainbox --help
-$ exit
diff --git a/daily-package-testing/Vagrantfile b/daily-package-testing/Vagrantfile
deleted file mode 100644
index 28213a8..0000000
--- a/daily-package-testing/Vagrantfile
+++ /dev/null
@@ -1,48 +0,0 @@
-# -*- mode: ruby -*-
-# vi: set ft=ruby sw=2 ts=2 :
-
-Vagrant::Config.run do |config|
-
-  config.ssh.timeout = 60
-
-  # Define a Ubuntu Server image (cloud) for the 12.04 release (precise)
-  config.vm.define :precise do |precise_config|
-    precise_config.vm.box = "precise-cloud-i386"
-    precise_config.vm.box_url = "http://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-i386-vagrant-disk1.box"
-  end
-
-  # Define a Ubuntu Server image (cloud) for the 12.10 release (quantal)
-  config.vm.define :quantal do |quantal_config|
-    quantal_config.vm.box = "quantal-cloud-i386"
-    quantal_config.vm.box_url = "http://cloud-images.ubuntu.com/vagrant/quantal/current/quantal-server-cloudimg-i386-vagrant-disk1.box"
-  end
-
-  # Define a Ubuntu Server image (cloud) for the 13.04 release (raring)
-  config.vm.define :raring do |raring_config|
-    raring_config.vm.box = "raring-cloud-i386"
-    raring_config.vm.box_url = "http://cloud-images.ubuntu.com/vagrant/raring/current/raring-server-cloudimg-i386-vagrant-disk1.box"
-  end
-
-  # For debugging and later future GUI testing
-  if ENV.key? "VAGRANT_GUI"
-    config.vm.boot_mode = :gui
-  end
-
-  # Setup an apt cache if one is available
-  if ENV.key? "VAGRANT_APT_CACHE"
-    config.vm.provision :shell, :inline => "echo 'Acquire::http { Proxy \"#{ENV['VAGRANT_APT_CACHE']}\"; };' > /etc/apt/apt.conf"
-  end
-
-  # Update to have the latest packages, this is needed because the image comes
-  # with an old (and no longer working) apt cache and links to many packages no
-  # longer work.
-  config.vm.provision :shell, :inline => "apt-get update && DEBIAN_FRONTEND=noninteractive apt-get dist-upgrade --yes"
-  # Install package that provides add-apt-repository 
-  config.vm.provision :shell, :inline => "apt-get install --yes python-software-properties"
-  # Add the checkbox-dev/ppa ppa with daily builds 
-  config.vm.provision :shell, :inline => "add-apt-repository ppa:checkbox-dev/ppa"
-  # Update apt cache again
-  config.vm.provision :shell, :inline => "apt-get update"
-  # Install plainbox
-  config.vm.provision :shell, :inline => "apt-get install --yes plainbox"
-end
diff --git a/daily-package-testing/test-in-vagrant.sh b/daily-package-testing/test-in-vagrant.sh
deleted file mode 100755
index c21b00f..0000000
--- a/daily-package-testing/test-in-vagrant.sh
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/bin/sh
-# Runs simple smoke tests on the current package in the daily ppa.
-
-mkdir -p vagrant-logs
-
-test -z $(which vagrant) && echo "You need to install vagrant first" && exit
-
-outcome=0
-# XXX: this list needs to be in sync with plainbox/daily-pkg-testing/Vagrantfile
-target_list="precise quantal raring"
-for target in $target_list; do
-    # Bring up target if needed
-    if ! vagrant status $target | grep -q running; then
-        echo "[$target] Bringing VM 'up'"
-        if ! vagrant up $target >vagrant-logs/$target.startup.log 2>vagrant-logs/$target.startup.err; then
-            outcome=1
-            echo "[$target] Unable to 'up' VM!"
-            echo "[$target] stdout: $(pastebinit vagrant-logs/$target.startup.log)"
-            echo "[$target] stderr: $(pastebinit vagrant-logs/$target.startup.err)"
-            echo "[$target] NOTE: unable to execute tests, marked as failed"
-            continue
-        fi
-    fi
-    # Display something before the first test output
-    echo "[$target] Starting tests..."
-    # Test that plainbox --help works correctly
-    if vagrant ssh $target -c 'plainbox --help' >vagrant-logs/$target.help.log 2>vagrant-logs/$target.help.err; then
-        echo "[$target] packaged PlainBox plainbox --help: pass"
-    else
-        outcome=1
-        echo "[$target] packaged PlainBox plainbox --help: fail"
-        echo "[$target] stdout: $(pastebinit vagrant-logs/$target.help.log)"
-        echo "[$target] stderr: $(pastebinit vagrant-logs/$target.help.err)"
-    fi
-    case $VAGRANT_DONE_ACTION in
-        suspend)
-            # Suspend the target to conserve resources
-            echo "[$target] Suspending VM"
-            if ! vagrant suspend $target >vagrant-logs/$target.suspend.log 2>vagrant-logs/$target.suspend.err; then
-                echo "[$target] Unable to suspend VM!"
-                echo "[$target] stdout: $(pastebinit vagrant-logs/$target.suspend.log)"
-                echo "[$target] stderr: $(pastebinit vagrant-logs/$target.suspend.err)"
-                echo "[$target] You may need to manually 'vagrant destroy $target' to fix this"
-            fi
-            ;;
-        destroy)
-            # Destroy the target to work around virtualbox hostsf bug
-            echo "[$target] Destroying VM"
-            if ! vagrant destroy --force $target >vagrant-logs/$target.destroy.log 2>vagrant-logs/$target.destroy.err; then
-                echo "[$target] Unable to destroy VM!"
-                echo "[$target] stdout: $(pastebinit vagrant-logs/$target.suspend.log)"
-                echo "[$target] stderr: $(pastebinit vagrant-logs/$target.suspend.err)"
-                echo "[$target] You may need to manually 'vagrant destroy $target' to fix this"
-            fi
-            ;;
-    esac
-done
-# Propagate failure code outside
-exit $outcome
diff --git a/docs/author/index.rst b/docs/author/index.rst
index 8e213ae..b22bb46 100644
--- a/docs/author/index.rst
+++ b/docs/author/index.rst
@@ -8,10 +8,8 @@ core.
 
 .. toctree::
    intro.rst
-   tutorial.rst
    qml-job-tutorial.rst
    providers.rst
-   whitelists.rst
    rfc822.rst
    faq.rst
 
diff --git a/docs/author/intro.rst b/docs/author/intro.rst
index 2bbabb7..2dae15d 100644
--- a/docs/author/intro.rst
+++ b/docs/author/intro.rst
@@ -49,7 +49,7 @@ Terminology
 In developing or using Plainbox, you'll run into several unfamiliar terms.
 Check the :doc:`../glossary` to learn what they mean. In fact, you should
 probably check it now. Pay particular attention to the terms *Checkbox*,
-*Plainbox*, *job*, *provider*, and *whitelist*.
+*Plainbox*, *job* and *provider*.
 
 Getting Started
 ---------------
@@ -73,7 +73,7 @@ tests. First up is a welcome screen:
        select tests.
 
 When you press the Enter key, ``checkbox-cli`` lets you select which
-whitelist to use:
+test plan to use:
 
 .. image:: cc2.png
  :height: 343
@@ -81,7 +81,7 @@ whitelist to use:
  :scale: 100
  :alt: checkbox-cli enables you to select which test suite to run.
 
-With a whitelist selected, you can choose the individual tests to run:
+With a test plan selected, you can choose the individual tests to run:
 
 .. image:: cc3.png
  :height: 600
@@ -117,7 +117,7 @@ A provider is described in a configuration file (stored in
 ``/usr/share/plainbox-providers-1``). This file describes where to find all
 the files from the provider. This file is usually managed automatically
 (more on this later). A provider can ship jobs, binaries, data and
-whitelists.
+test plans.
 
 A **job** or **test** is the smallest unit or description that Plainbox
 knows about. It describes a single test (historically they're called
@@ -140,10 +140,6 @@ types include (but are not limited to):
  * ``shell`` -- An automated test that requires no user interaction; the
    test is passed or failed on the basis of the return value of the script
    or command.
- * ``local`` -- This type of job is similar to a ``shell`` test, but it
-   supports creating multiple tests from a single definition (say, to test
-   all the Ethernet ports on a computer). Jobs using the ``local`` plugin
-   are run when Plainbox is initialized.
  * ``user-interact`` -- A test that asks the user to perform some action
    *before* the test is performed. The test then passes or fails
    automatically based on the output of the test. An example is
@@ -162,170 +158,9 @@ types include (but are not limited to):
    which probes the system to determine the maximum supported resolution
    and then asks the user to confirm that the resolution is correct.
 
-A fairly complex example definition is::
-
- plugin: local
- _summary: Automated test to walk multiple network cards and test each one in sequence.
- id: ethernet/multi_nic
- requires:
-  device.category == 'NETWORK'
- _description: Automated test to walk multiple network cards and test each one in sequence.
- command:
-  cat <<'EOF' | run_templates -s 'udev_resource | filter_templates -w "category=NETWORK" | awk "/path: / { print \$2 }" | xargs -n 1 sh -c "for i in \``ls /sys\$0/net 2>/dev/null\``; do echo \$0 \$i; done"'
-  plugin: shell
-  id: ethernet/multi_nic_$2
-  requires:
-   package.name == 'ethtool'
-   package.name == 'nmap'
-   device.path == "$1"
-  user: root
-  environ: TEST_TARGET_FTP TEST_TARGET_IPERF TEST_USER TEST_PASS
-  command: network test -i $2 -t iperf --fail-threshold 80
-  estimated_duration: 330.0
-  description:
-   Testing for NIC $2
-  EOF
-
-Key points to note include:
-
- * If a field name begins with an underscore, its value can be localized.
- * The values of fields can appear on the same line as their field names,
-   as in ``plugin: local``; or they can appear on a subsequent line, which
-   is indented, as in the preceding example's ``requires: device.category
-   == 'NETWORK'``.
- * The ``requires`` field can be used to specify dependencies; if the
-   specified condition is not met, the test does not run.
- * The ``command`` field specifies the command that's used to run the test.
-   This can be a standard Linux command (or even a set of commands) or a
-   Checkbox test script. In this example's ``local`` test definition, the
-   first ``command`` line generates a list of network devices that is fed
-   to an embedded test, which is defined beginning with the second
-   ``plugin`` line immediately following the first ``command`` line.
- * In this example, the line that reads ``EOF`` ends the
-   ``ethernet/ethtool_multi_nic_$2`` test's command; it's matched to the
-   ``EOF`` that's part of ``cat << 'EOF'`` near the start of that command.
-
 Each provider has a ``bin`` directory and all binaries there are available
 in the path.
 
-Whitelists
-``````````
-
-In the job files we have a "universe" of known jobs. We don't normally want
-to run them all; rather we want to select a subset depending on what we're
-testing, and maybe give the user a way to fine-tune that selection. Also,
-we need a way to determine the order in which they will run, beyond what
-dependencies may provide. This is where the whitelist comes in; think of it
-as a mask or selection filter from the universe of jobs. Whitelists support
-regular expressions, and Plainbox will attempt to run tests in the order
-shown in the whitelist. Again, providers ship whitelists in a specific
-directory, and you can use ``plainbox`` to run a specific whitelist with
-the ``-w`` option.
-
-You can also use ``plainbox`` to run a test with the ``-i`` syntax. This is
-good for quickly running a job and ensuring it works well.
-
-Let's look at ``checkbox-cli`` for a moment. This is a "launcher"; it
-specifies a set of configuration options for a specific testing purpose.
-This enables us to create mini-clients for each testing purpose, without
-changing the core utility (``checkbox-launcher``). For instance, let's look
-at the launcher for ``canonical-certification-server``, which appears in
-``./providers/plainbox-provider-certification-server/launcher/canonical-certification-server``
-in the Checkbox source tree::
-
- #!/usr/bin/env checkbox-launcher
- [welcome]
- text = Welcome to System Certification!
-     This application will gather information from your system. Then you will be
-     asked manual tests to confirm that the system is working properly. Finally,
-     you will be asked for the Secure ID of the computer to submit the
-     information to the certification.canonical.com database.
-     To learn how to create or locate the Secure ID, please see here:
-     https://certification.canonical.com/
-
- [suite]
- # Whitelist(s) displayed in the suite selection screen
- whitelist_filter = ^((network|storage|usb|virtualization)-only)|(server-(full|functional)-14.04)$
- # Whitelist(s) pre-selected in the suite selection screen, default whitelist(s)
- whitelist_selection = ^server-full-14.04$
-
- [transport]
- submit_to = certification
-
- [config]
- config_filename = canonical-certification.conf
-
-A launcher such as this sets up an environment that includes introductory
-text to be shown to users, a filter to determine what whitelists to present
-as options, information on where to (optionally) submit results, and a
-configuration filename. This allows each provider to ship a launcher or
-binary with which to launch its relevant tests.
-
-Developing Tests
-````````````````
-
-One way to deliver tests via Plainbox is to start your own provider. To
-learn how to do that, see the :ref:`tutorial`.
-
-In other cases you want to add tests to the main Checkbox repository (which
-is also what we recommend to keep tests centralized, unless they're so
-purpose-specific that this makes no sense).
-
-This is a bit easier because the provider in question already exists. So
-let's get started by branching a copy of ``lp:checkbox``. In brief, you
-should change to your software development directory and type ``bzr branch
-lp:checkbox my-branch`` to create a copy of the ``checkbox`` Launchpad
-project in the ``my-branch`` subdirectory. You can then edit the files in
-that subdirectory, upload the results to your own Launchpad account, and
-request a merge.
-
-To begin, consider the files and subdirectories in the main Checkbox
-development directory (``my-branch`` if you used the preceding ``bzr``
-command without change):
-
- * ``checkbox-gui`` -- Checkbox GUI components, used in desktop/laptop
-   testing
- * ``checkbox-ng`` -- The Plainbox-based version of Checkbox
- * ``checkbox-support`` -- Support code for many providers
- * ``checkbox-touch`` -- A Checkbox frontend optimized for touch/tablet
-   devices
- * ``mk-venv`` -- A symbolic link to a script used to set up an environment
-   for testing Checkbox
- * ``plainbox`` -- A Python3 library and development tools at the heart of
-   Plainbox
- * ``plainbox-client`` -- Unfinished Python3 interface for Checkbox
- * ``providers`` -- Provider definitions, including test scripts
- * ``README.md`` -- A file describing the contents of the subdirectory in
-   greater detail
- * ``setup.py`` -- A setup script
- * ``support`` -- Support code that's not released
- * ``tarmac-verify`` -- A support script
- * ``test-in-lxc.sh`` -- A support script for testing in an LXC
- * ``test-in-vagrant.sh`` -- A support script for testing with Vagrant
- * ``test-with-coverage`` -- A link to a support script for testing with
-   coverage
- * ``Vagrantfile`` -- A Vagrant configuration file
-
-Let's say I want to write a test to ensure that the ubuntu user exists in
-``/etc/passwd``. You need to remove any existing Checkbox provider
-packages, lest they interfere with your new or modified tests. The
-``setup.py`` script will set up a Plainbox development environment for you.
-
-We can write a simple job here, then add a requirement, perhaps a
-dependency, then a script in the directory. Note that scripts can be
-anything that's executable, we usually prefer either shell or Python but
-anything goes.
-
-Plainbox will supply two environment variables, ``PLAINBOX_PROVIDER_DATA``
-and ``SHARE``, we usually try to use them in the job description only, not
-in the scripts, to keep the scripts Plainbox-agnostic if possible.
-
-Once the test is running correctly, we can create a whitelist with a few
-tests and name it.
-
-Once we get everything running correctly we can prepare and propose a merge
-request using ``bzr`` as usual.
-
 Other Questions
 ---------------
 
diff --git a/docs/author/provider-files.rst b/docs/author/provider-files.rst
index 7a33346..34f21d4 100644
--- a/docs/author/provider-files.rst
+++ b/docs/author/provider-files.rst
@@ -53,11 +53,6 @@ jobs_dir
     Absolute pathname to a directory with :term:`job definitions <job>`
     as individual ``.txt`` files using the :doc:`job file format <jobs>`.
 
-whitelists_dir
-    Absolute pathname to a directory with :term:`whitelists <whitelist>`
-    as individual ``.whitelist`` files using the
-    :doc:`whitelist format <whitelists>`.
-
 bin_dir
     Absolute pathname to a directory with additional executables required by
     any of the job definitions.
@@ -80,7 +75,6 @@ location
         Variable          Default Value
     ================  =====================
     jobs_dir          $location/jobs
-    whitelists_dir    $location/whitelists
     bin_dir           $location/bin
     data_dir          $location/data
     locale_dir        $location/locale
diff --git a/docs/author/provider-namespaces.rst b/docs/author/provider-namespaces.rst
index 4459e50..e25036b 100644
--- a/docs/author/provider-namespaces.rst
+++ b/docs/author/provider-namespaces.rst
@@ -120,7 +120,7 @@ The part of the provide name before the colon is used as the name-space. The
 colon is *not* a part of the name-space.
 
 The implicit name-space is used to construct non-partial job definition names
-as well as to implicitly prefix each pattern inside :term:`whitelists <whitelist>`. 
+as well as to implicitly prefix each pattern inside test plans. 
 
 Using Explicit Name-Spaces
 --------------------------
@@ -133,15 +133,15 @@ Explicit name-spaces need to be used in two situations:
    This is required as any partial ID may silently change the job it resolves
    to and we didn't want to introduce that ambiguity.
 
-2. When including a job from another name-space inside a whitelist, e.g.::
+2. When including a job from another name-space inside a test plan, e.g.::
 
-        ~/com.example.some:provider$ cat whitelists/cross.whitelist
+        ~/com.example.some:provider$ cat units/test-plan.pxu
         job-a
         job-b
         com\.example\.other::job-a
         ~com.example.some:provider$
 
-   Here the whitelist names three jobs:
+   Here the test plan names three jobs:
 
    * com.example.some::job-a
    * com.example.some::job-b
diff --git a/docs/author/provider-template.rst b/docs/author/provider-template.rst
index 91a1db3..ae5bb76 100644
--- a/docs/author/provider-template.rst
+++ b/docs/author/provider-template.rst
@@ -23,17 +23,14 @@ The following files and directories are generated::
     ├── data
     │   ├── example.dat
     │   └── README.md
-    ├── jobs
-    │   ├── examples-intermediate.txt
-    │   ├── examples-normal.txt
-    │   └── examples-trivial.txt
     ├── manage.py
     ├── po
     │   └── POTFILES.in
     ├── README.md
-    └── whitelists
-        ├── normal.whitelist
-        └── trivial.whitelist
+    └── units
+        ├── examples-intermediate.txt
+        ├── examples-normal.txt
+        └── examples-trivial.txt
 
 Generated Content
 =================
@@ -59,10 +56,8 @@ README.md
     Plainbox parlance, is the smallest piece of executable test code. Each
     job has a name and a number of other attributes.
 
-    Jobs can be arranged in lists, test plans if you will that are known
-    as "whitelists". Those are defined in the ``whitelists/`` directory,
-    this time one per file. You can create as many whitelists as you need,
-    referring to arbitrary subsets of your jobs.
+    Jobs can be arranged in lists, test plans if you will. You can create as
+    many test plans as you need, referring to arbitrary subsets of your jobs.
 
     Then there are the ``bin/`` and ``data/`` directories. Those are
     entirely for custom content you may need. You can put arbitrary
@@ -340,7 +335,7 @@ jobs/examples-intermediate.txt
     estimated_duration: 30
 
 
-po/PORFILES.in
+po/POTFILES.in
 --------------
 
 ::
@@ -350,20 +345,3 @@ po/PORFILES.in
     [type: gettext/rfc822deb] jobs/examples-normal.txt
     [type: gettext/rfc822deb] jobs/examples-intermediate.txt
     manage.py
-
-whitelists/trivial.whitelist
-----------------------------
-
-::
-
-    # select two trivial jobs by directly selecting their names
-    examples/trivial/always-pass
-    examples/trivial/always-fail
-
-whitelists/normal.whitelist
----------------------------
-
-::
-
-    # use regular expression to select all normal jobs
-    examples/normal/.*
diff --git a/docs/author/providers.rst b/docs/author/providers.rst
index 6640750..cc1bb6c 100644
--- a/docs/author/providers.rst
+++ b/docs/author/providers.rst
@@ -5,7 +5,7 @@ Providers
 Providers are a new feature introduced in Plainbox 0.5. They allow third party
 developers to produce and maintain private and public test collections.
 
-All :term:`jobs <job>` and :term:`whitelists <whitelist>` are now loaded from a provider. This
+All :term:`jobs <job>` and test plans are now loaded from a provider. This
 also affects the :term:`Checkbox` project that now produces a custom user
 interface and a number of providers for various purposes.
 
diff --git a/docs/author/tutorial.rst b/docs/author/tutorial.rst
deleted file mode 100644
index 892cb19..0000000
--- a/docs/author/tutorial.rst
+++ /dev/null
@@ -1,177 +0,0 @@
-.. _tutorial:
-
-========
-Tutorial
-========
-
-To best illustrate how providers work, we will walk through creating one
-step-by-step. At the end of this tutorial you will have a provider which adds
-a new :term:`whitelist`, several new jobs and the scripts and test data 
-supporting those jobs. Before starting this tutorial you will need to have a 
-running version of :term:`Plainbox` installed. You can either install it from 
-the  repositories of Debian or its derivatives by running ``apt-get install 
-plainbox``, or if you prefer to work with the source, see :doc:`Getting 
-started with development <../dev/intro>`. There is also a Launchpad PPA with
-the very latest development build for Ubuntu, which is `ppa:checkbox-dev/ppa`.
-
-#. To get started we create an initial template for our provider by running
-   ``plainbox startprovider com.example:myprovider``.
-
-#. This will create a directory called ``com.example:myprovider``.
-   Change to this directory and you will see that it contains::
-
-    /bin
-    /data
-    /integration-tests
-    /jobs
-    manage.py
-    README.md
-    /whitelists
-
-   The ``manage.py`` script is a helper script for developing the provider.
-   It provides a set of commands which assist in validating the correctness
-   of the provider and making it ready for distribution.
-
-#. Let’s create some jobs first by changing to the jobs directory. It currently
-   contains a file called category.txt which serves as an example of how
-   jobs should look. Let’s delete it and instead create a file called
-   ``myjobs.txt``. This can contain the following simple jobs::
-
-    plugin: shell
-    name: myjobs/shell_command
-    command: true
-    _description:
-     An example job that uses a command provided by the shell.
-
-    plugin: shell
-    name: myjobs/provider_command
-    command: mycommand
-    _description:
-      An example job that uses a test command provided by this provider.
-  
-   At this point we can check that everything looks okay by running the command
-   ``./manage.py info`` which displays some information about the provider. The
-   output should be something like::
-
-    [Provider MetaData]
-	name: com.example:myprovider
-	version: 1.0
-    [Job Definitions]
-	'myjobs/builtin_command', from jobs/myjobs.txt:1-5
-	'myjobs/provider_command', from jobs/myjobs.txt:7-11
-    [White Lists]    
-        'category', from whitelists/category.whitelist:1-1
-
-   This shows all three jobs from the job file we added - great!
-
-#. Next we need to change directory to ``bin`` to add the command used by the
-   job ``myjobs/this_provider_command``. We create a file there called 
-   ``mycommand`` which contains the following text::
-
-    #!/bin/sh
-    test `cat $CHECKBOX_SHARE/data/testfile` = 'expected'
-
-   This needs to be executable to be used in the job command so we need to run
-   ``chmod a+x mycommand`` to make it executable.
-
-   You'll notice the command uses a file in ``$CHECKBOX_SHARE/data`` - we'll
-   add this file to our provider next. 
-
-#. Because the command we’re using uses a file that we expect to be located in
-   ``$CHECKBOX_SHARE/data``, we need to add this file to our provider so that 
-   after the provider is installed this file is available in that location. 
-   First we need to change to the directory called ``data``, then as indicated 
-   by the contents of the script we wrote in the previous step, we need to 
-   create a file there called ``testfile`` with the contents::
-
-    expected
-
-   As simple as that!
-
-#. Lastly we need to add a :term:`whitelist` that utilizes the jobs we created
-   earlier. We need to change to the directory called ``whitelists``. As with
-   the ``jobs`` directory  there is already an example file there called 
-   ``category.whitelist``. We can delete that and add a file called 
-   ``mywhitelist.whitelist``. The contents should be::
-
-    myjobs/shell_command
-    myjobs/provider_command
-
-   The ``miscellanea/submission_resources`` and ``graphics/glxgears`` jobs
-   are from the default provider that is part of Plainbox.
-
-   We can check that everything is correct with the whitelist by running the 
-   ``./manage.py info`` command again. The output should be like::
-
-    [Provider MetaData]
-	name: com.example:myprovider
-	version: 1.0
-    [Job Definitions]
-	'myjobs/builtin_command', from jobs/myjobs.txt:1-5
-	'myjobs/provider_command', from jobs/myjobs.txt:7-11
-    [White Lists]
-	'mywhitelist', from whitelists/mywhitelist.whitelist:1-2 
-  
-   Our new :term:`whitelist` is listed there.
-
-#. Now we have a provider we need to test it to make sure everything is
-   correct. The first thing to do is to install the provider so that it
-   it visible to Plainbox. Run ``./manage.py develop`` then run 
-   ``plainbox dev list provider``. Your provider should be in the list
-   that is displayed.
-
-#. We should also make sure the whole provider works end-to-end by running
-   the :term:`whitelist` which it provides. Run the following command - 
-   ``plainbox run -w whitelists/mywhitelist.whitelist``.
-
-#. Assuming everything works okay, we can now package the provider for 
-   distribution. This involves creating a basic ``debian`` directory
-   containing all of the files needed for packaging your provider. Create
-   a directory called ``debian`` at the base of your provider, and then
-   create the following files within it.
-
-   ``compat``::
-
-    9
-
-   ``control``::
-
-    Source: plainbox-myprovider
-    Section: utils
-    Priority: optional
-    Maintainer: Brendan Donegan <[e-mail]>
-    Standards-Version: 3.9.3
-    X-Python3-Version: >= 3.2
-    Build-Depends: debhelper (>= 9.2),
-                   lsb-release,
-                   python3 (>= 3.2),
-                   python3-plainbox
-
-    Package: plainbox-myprovider
-    Architecture: all
-    Depends: plainbox-provider-checkbox
-    Description: My whitelist provider
-     A provider for Plainbox.
-
-   ``rules``::
-
-    #!/usr/bin/make -f
-    %:
-        dh "$@"
-
-    override_dh_auto_build:
-        $(CURDIR)/manage.py install
-
-   Note that the ``rules`` file must be executable. Make it so with 
-   ``chmod a+x rules``. Also, be careful with the indentation in the
-   file - all indents must be actual TAB characters, not four spaces
-   for example.
-
-   ``source/format``::
-
-    3.0 (native)
-
-   Finally we should create a ``changelog`` file. The easiest way to do this
-   is to run the command ``dch --create 'Initial release.'``. You'll need to
-   edit the field ``PACKAGE`` to the name of your provider and the field
-   ``VERSION`` to something like ``0.1``.
diff --git a/docs/author/whitelists.rst b/docs/author/whitelists.rst
deleted file mode 100644
index 7b5f162..0000000
--- a/docs/author/whitelists.rst
+++ /dev/null
@@ -1,120 +0,0 @@
-========================
-Checkbox Whitelist Files
-========================
-
-When creating a test suite for a particular purpose, it will be necessary to
-specify which tests to run and which order they should run in. For this purpose
-Checkbox provides the concept of Whitelists.
-
-Whitelist Format
-================
-
-A whitelist is a text file containing a line-seperated sequence of patterns, 
-each representing one or more 'jobs'. These patterns are in the Python regular 
-expression syntax. Comments may be included in the file by starting the line 
-with '#'.
-
-Minimal Whitelist File
-======================
-
-In order to be useful a whitelist file needs to include a particular subset of
-jobs which provide Checkbox with all of the information it needs to run tests 
-properly. These include jobs which attach hardware information and resource 
-jobs which provide other jobs with information of the environment they a
-re running in (available hardware, available packages etc). To make this easy 
-to do a single job exists whose purpose is to execute all of these other jobs::
-
-    miscellanea/submission-resources
-
-This should be included as the first job in any whitelist.
-
-Job Categories
-==============
-
-In order to allow Checkbox to display jobs by category in the UI it is 
-necessary to include a particular local job which itself generates jobs which 
-belong to that category. This job will normally look like ``__<category>__`` 
-where <category> is the name of the job file which contains the job. This is 
-indicated again by the prefix of the job (before the ``/`` in the job name). 
-As a quick example, the job ``graphics/glxgears`` is contained in 
-``graphics.txt``. Therefore we should include the ``__graphics__`` job so that 
-the ``graphics/glxgears`` job shows correctly under the category. The 
-``__graphics__`` job itself looks like::
-
-    name: __graphics__
-    plugin: local
-    _description: Graphics tests
-    command:
-      shopt -s extglob
-      cat $CHECKBOX_SHARE/jobs/graphics.txt?(.in)
-
-Checkbox will interpret this job as a request to display any job in 
-``graphics.txt`` (or its untranslated version ``graphics.txt.in``) under the 
-heading shown in the description of this job (in this case 'Graphics tests').
-
-Tutorial
-========
-
-To compound what we discussed before, below is a brief tutorial which walks 
-through assembling a basic whitelist file.
-
-1. First we need to create a file, let's name it tutorial.whitelist. 
-Whitelists don't have to end with the .whitelist suffix but this is the 
-convention used to help identify them.
-2. We start by adding the one job that is required for all whitelists, as 
-explained above in the section 'Minimal Whitelist File', so our whitelist file 
-looks like::
-
-    miscellanea/submission-resources
-
-3. Next we should choose some jobs that we want to run. This all depends on 
-your specific use-case of course, but I've selected a few jobs that will help 
-clearly illustrate more of the concepts involved in whitelists. These jobs will 
-give us a whitelist file that looks like::
-
-    miscellanea/submission-resources
-    cpu/clocktest
-    ethernet/multi_nic
-    ethernet/multi_nic_eth0
-    graphics/glxgears
-
- If we run this whitelist now then all of these jobs will be executed and a 
- valid test submission will be created, but we can still improve it in a couple 
- of ways.
-
-4. The first way is by adding the necessary jobs to allow the Checkbox UI to 
-group the jobs into specific categories. To do this we need to add a job with 
-a name like ``__<category>__`` for each category. We have three categories in 
-our whitelist file - cpu, ethernet and graphics. The category of the job is 
-the prefix of the job name prior to the ``/``. So now our whitelist file looks 
-like::
-
-    miscellanea/submission-resources
-    __cpu__
-    __ethernet__
-    __graphics__
-    cpu/clocktest
-    ethernet/multi_nic
-    ethernet/multi_nic_eth0
-    graphics/glxgears
-
-  Now the Checkbox UI will group the jobs into these categories.
-
-5. Although it's not immediately apparent there is another problem with this 
-whitelist. The ``ethernet/multi_nic`` tests are only able to include one job 
-for the ethernet port 'eth0'. It would be better if we included all of the 
-jobs generated by 'ethernet/multi_nic', no matter how many ethernet ports are 
-present on the system under test. The best way to do this is to write the 
-pattern so that it matches all of the possible job names. We can take advantage 
-of the Python regular expression syntax and use the ``\d`` special character 
-to match any decimal number. After doing this the whitelist file will look 
-like this::
-
-    miscellanea/submission-resources
-    __cpu__
-    __ethernet__
-    __graphics__
-    cpu/clocktest
-    ethernet/multi_nic
-    ethernet/multi_nic_eth\d
-    graphics/glxgears
diff --git a/docs/dev/old.rst b/docs/dev/old.rst
index 151f21c..7921f68 100644
--- a/docs/dev/old.rst
+++ b/docs/dev/old.rst
@@ -144,8 +144,6 @@ dependencies) being added to the repository.
 Implementation issues
 ---------------------
 
-There are two issues that are known at this time:
-
 * There is too much checkbox-specific knowledge which really belongs
   elsewhere. We are working to remove that so that non-checkbox jobs
   can be introduced later. There is a branch in progress that entirely
@@ -155,15 +153,6 @@ There are two issues that are known at this time:
   that was previously internal (most notably a way to add new jobs and
   resources).
 
-* The way jobs are currently selected is unfortunate because of local jobs
-  that can add new jobs to the system. This causes considerable complexity
-  at the application level where the application must check if each
-  executed job is a 'local' job and re-compute the desired_job_list. This
-  should be replaced by a matcher function that can be passed to
-  SessionState once so that desired_job_list is re-evaluated internally
-  whenever job_list changes.
-
-
 :class:`~plainbox.impl.job.JobDefinition`
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -211,49 +200,6 @@ plugin == "manual"
 This value is used for fully manual jobs. It has no special handling in the core
 apart from requiring a human-provided outcome (pass/fail classification) 
 
-.. _local:
-
-plugin == "local"
-#################
-
-This value is used for special job generator jobs. The output of such jobs is
-interpreted as additional jobs and is identical in effect to loading such jobs
-from a job definition file. 
-
-There are two practical uses for such jobs:
-
-* Some local jobs are used to generate a number of jobs for each object.
-  This is needed where the tested machine may have a number of such objects
-  and each requires unique testing. A good example is a computer where all
-  network tests are explicitly "instantiated" for each network card
-  present.
- 
-  This is a valid use case but is rather unfortunate for architecture of
-  Plainbox and there is a desire to replace it with equally-expressive
-  pattern jobs. The advantage is that unlike local jobs (which cannot be
-  "discovered" without enduring any potential side effects that may be
-  caused by the job script command) pattern jobs would allow the core to
-  determine the names of jobs that can be generated and, for example,
-  automatically determine that a pattern job needs to be executed as a
-  dependency of a phantom (yet undetermined) job with a given name.
-
-  The solution with "pattern" jobs may be executed in future phases of
-  Plainbox development. Currently there is no support for that at all.
-
-  Currently Plainbox cannot determine job dependencies across local jobs.
-  That is, unless a local job is explicitly requested (in the desired job
-  list) Plainbox will not be able to run a job that is generated by a local
-  job at all and will treat it as if that job never existed.
-
-* Some local jobs are used to create a form of informal "category".
-  Typically all such jobs have a leading and trailing double underscore,
-  for example '__audio__'. This is currently being used by Checkbox for
-  building a hierarchical tree of tests that the user may select.
-
-  Since this has the same flaws as described above (for pattern jobs) it
-  will likely be replaced by an explicit category field that can be
-  specified each job.
-
 plugin == "resource"
 ####################
 
diff --git a/docs/dev/trusted-launcher.rst b/docs/dev/trusted-launcher.rst
index d74735e..a0cc565 100644
--- a/docs/dev/trusted-launcher.rst
+++ b/docs/dev/trusted-launcher.rst
@@ -145,7 +145,7 @@ Usage
 .. code-block:: text
 
     plainbox-trusted-launcher-1 [-h] (--hash HASH | --warmup)
-                              [--via LOCAL-JOB-HASH]
+                              [--via GENERATOR-JOB-HASH]
                               [NAME=VALUE [NAME=VALUE ...]]
 
     positional arguments:
@@ -156,7 +156,7 @@ Usage
       --hash HASH           job hash to match
       --warmup              Return immediately, only useful when used with
                             pkexec(1)
-      --via LOCAL-JOB-HASH  Local job hash to use to match the generated job
+      --via GENERATOR-JOB-HASH  Generator job hash to use to match the generated job
 
 .. note::
 
@@ -185,15 +185,11 @@ thanks to the installed policy file the authentication will be kept.
 Special case of jobs using the Checkbox local plugin
 ----------------------------------------------------
 
-For jobs generated from :ref:`local <local>` jobs (e.g.
+For jobs generated from resources jobs (e.g.
 disk/read_performance.*) the trusted launcher is started with ``--via`` meaning
-that we have to first eval a local job to find a hash match. Once a match is
+that we have to first eval a generator job to find a hash match. Once a match is
 found, the job command is executed.
 
 .. code-block:: bash
 
-    $ pkexec plainbox-trusted-launcher-1 --hash JOB-HASH --via LOCAL-JOB-HASH
-
-.. note::
-
-    it will obviously fail if any local job can ever generate another local job.
+    $ pkexec plainbox-trusted-launcher-1 --hash JOB-HASH --via GENERATOR-JOB-HASH
diff --git a/docs/glossary.rst b/docs/glossary.rst
index 6174025..212d9a2 100644
--- a/docs/glossary.rst
+++ b/docs/glossary.rst
@@ -46,12 +46,11 @@ Glossary
            necessary for end-user work. ``plainbox`` is usually installed
            explicitly if needed.
 
-    whitelist
+    test plan
 
-        Whitelists are text files used by Checkbox to select jobs for
-        execution.  They can include simple regular expressions to match and
-        pick many similar jobs at once. For more information see
-        :doc:`Checkbox Whitelist Files <author/whitelists>`
+        Test plans are text files used by Checkbox to select jobs for
+        execution. They can include simple regular expressions to match and
+        pick many similar jobs at once.
 
     job
 
@@ -63,7 +62,7 @@ Glossary
 
     provider
 
-        A container for jobs, whitelists, private executables and data.
+        A container for jobs, test plans, private executables and data.
         Providers are the foundation of Plainbox as they *provide* all of the
         content. Providers can be created and managed by any entity, separately
         from the Checkbox project.
diff --git a/docs/manpages/plainbox-dev-analyze.rst b/docs/manpages/plainbox-dev-analyze.rst
index e5fe5dc..23fc999 100644
--- a/docs/manpages/plainbox-dev-analyze.rst
+++ b/docs/manpages/plainbox-dev-analyze.rst
@@ -15,13 +15,6 @@ plainbox-dev-analyze (1)
     and the command prints nothing at all) to inspect certain aspects of the
     hypothetical session
 
-    The only exception to the rule above is the ``--run-local`` option. With that
-    option all local jobs and their dependencies *are* started. This is
-    technically required to correctly emulate the behavior of ``plainbox run``
-    that does so unconditionally. Still, local jobs can cause harm so don't run
-    untrusted code this way (the author of this man page recalls one local job
-    that ran ``sudo reboot`` to measure bootchart data)
-
     Report Types
     ============
 
@@ -74,11 +67,11 @@ plainbox-dev-analyze (1)
     always includes additional jobs (such as resource jobs and other
     dependencies)
 
-    The run list is of great importance. Most of the time the test operator will
-    see tests in precisely this order. The only exception is that some test
-    applications choose to pre-run local jobs. Still, if your job ordering is
-    wrong in any way, inspecting the run list is the best way to debug the
-    problem.
+    The run list is of great importance. Most of the time the test operator
+    will see tests in precisely this order. The only exception is that some
+    test applications choose to pre-run generator jobs (resources). Still, if
+    your job ordering is wrong in any way, inspecting the run list is the best
+    way to debug the problem.
 
 See Also
 ========
diff --git a/docs/manpages/plainbox-exporter-units.rst b/docs/manpages/plainbox-exporter-units.rst
index 7017071..df7172c 100644
--- a/docs/manpages/plainbox-exporter-units.rst
+++ b/docs/manpages/plainbox-exporter-units.rst
@@ -120,36 +120,4 @@ The provider shipping such unit can be as follow::
         └── exporters.pxu
 
 Note that exporters.pxu is not strictly needed to store the exporter units, but
-keeping them in a dedidated file is a good practice.
-
-How to use exporter units?
---------------------------
-
-In order to call an exporter unit from provider foo, you just need to add the
-unit id to the cli or the gui launcher in the exporter section:
-
-Example of a gui launcher:
-
-    #!/usr/bin/checkbox-gui
-
-    [welcome]
-    title = "Foo"
-    text = "bar"
-
-    [exporter]
-    HTML = "com.foo.bar::my_html"
-
-Example of a cli launcher:
-
-    #!/usr/bin/env checkbox-launcher
-    [welcome]
-    text = Foo
-
-    [suite]
-    whitelist_filter = ^.*$
-    whitelist_selection = ^default$
-
-    [exporter]
-    com.foo.bar::my_html
-    com.foo.bar::my_json
-    com.foo.baz::my_html
+keeping them in a dedicated file is a good practice.
diff --git a/docs/manpages/plainbox-file-units.rst b/docs/manpages/plainbox-file-units.rst
index 2a61277..3c5ddbd 100644
--- a/docs/manpages/plainbox-file-units.rst
+++ b/docs/manpages/plainbox-file-units.rst
@@ -36,9 +36,6 @@ There are two fields that are used by the file unit:
     'unit-source':
         The file is a source of unit definitions. Currently this is the only
         actually implemented value.
-
-    'legacy-whitelist':
-        This file is a legacy whitelist.
     
     'script':
         This file is an architecture independent executable.
@@ -60,4 +57,4 @@ There are two fields that are used by the file unit:
         This file contains copyright and licensing information.
 
     'docs':
-        This file contains documentation.
\ No newline at end of file
+        This file contains documentation.
diff --git a/docs/manpages/plainbox-job-units.rst b/docs/manpages/plainbox-job-units.rst
index be0c17f..08e8fd1 100644
--- a/docs/manpages/plainbox-job-units.rst
+++ b/docs/manpages/plainbox-job-units.rst
@@ -56,9 +56,6 @@ Following fields may be used by the job unit:
         test's outcome. This is essentially a manual job with a command.
      :attachment: jobs whose command output will be attached to the
          test report or submission.
-     :local: a job whose command output needs to be in Checkbox job
-         format. Jobs output by a local job will be added to the set of
-         available jobs to be run.
      :resource: A job whose command output results in a set of rfc822
           records, containing key/value pairs, and that can be used in other
           jobs' ``requires`` expressions.
diff --git a/docs/manpages/plainbox-run.rst b/docs/manpages/plainbox-run.rst
index eaf5098..3363aa8 100644
--- a/docs/manpages/plainbox-run.rst
+++ b/docs/manpages/plainbox-run.rst
@@ -74,44 +74,6 @@ plainbox-run (1)
 
         plainbox run -i '.*::foo' -i '.*::bar'
 
-    Selecting jobs with whitelists
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    The second mechanism is the ``--whitelist WHITELIST`` command-line option.
-    WhiteLists (or test plans, which is somewhat easier to relate to).
-    Whitelists are simple text files composed of a list of regular expressions,
-    identical to those that may be passed with the ``-i`` option.
-
-    Unlike the ``-i`` option though, there are two kinds of whitelists.
-    Standalone whitelists are not associated with any Plainbox Provider.  Such
-    whitelists can be distributed entirely separately from any other component
-    and thus have no association with any namespace.
-
-    Therefore, be fully qualified, each pattern must include both the namespace
-    and the partial identifier components. For example, this is a valid, fully
-    quallified whitelist::
-
-        com.canonical.plainbox::stub/.*
-
-    It will unambiguously select some of the jobs from the special, internal
-    StubBox provider that is built into Plainbox. It can be saved under any
-    filename and stored in any directory and it will always select the same set
-    of jobs.
-
-    In contrast, whitelists that are associated with a particular provider, by
-    being stored in the per-provider ``whitelists/`` directory, carry an
-    implicit namespace. Such whitelists are typically written without
-    mentioning the namespace component.
-
-    For example, the same "stub/.*" pattern can be abbreviated to::
-
-        stub/.*
-
-    Typically this syntax is used in all whitelists specific to a particular
-    provider unless the provider maintainer explicitly wants to include a job
-    from another namespace (for example, one of the well-known Checkbox job
-    definitions).
-
     GENERATED JOBS
     ==============
 
@@ -125,28 +87,7 @@ plainbox-run (1)
     storage devices) and then duplicate each of the store specific tests so
     that all devices are tested separately.
 
-    At this time jobs can be generated only from jobs using the plugin type
-    `local`. Jobs of this kind are expected to print fully conforming job
-    definitions on stdout. Generated jobs cause a few complexities and one
-    limitation that is currently enforced is that generated jobs cannot
-    generate additional jobs if any of the affected jobs need to run as another
-    user.
-
-    Another limitation is that jobs cannot override existing definitions.
-
-    Creating Parent-Child Association
-    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-    A relatively niche and legacy feature of generated jobs is to print a
-    verbatim copy of existing job definitions from a ``local`` job definition
-    named afer a generic testing theme or category. For example the Checkbox
-    job definition ``__wireless__`` prints, with the help of ``cat`` (1), all
-    of the job definitions defined in the file ``wireless.txt``.
-
-    This behavior is special-cased not to cause redefinition errors. Instead,
-    existing definitions gain the ``via`` attribute that links them to the
-    generator job. This feature is used by derivative application such as
-    Checkbox. Plainbox is not using it at this time.
+    One limitation is that jobs cannot override existing definitions.
 
     RESUMING
     ========
@@ -302,35 +243,24 @@ plainbox-run (1)
         Exported data will include comments added by the test operator to each
         job result that has them.
 
-    with-job-via:
-        Exported data will include the ``via`` attribute alongside each job
-        result. The via attribute contains the checksum of the job definition
-        that generated a particular job definition. This is useful for tracking
-        jobs generated by jobs with the plugin type `local`.
-
     with-job-hash:
         Exported data will include the ``hash`` attribute alongside each job
         result. The hash attribute is the checksum of the job definition's
-        data. It can be useful alongside with `with-job-via`.
+        data.
 
     machine-json:
         The generated JSON document will be minimal (devoid of any optional
         whitespace). This option is best to be used if the result is not
         intended to be read by humans as it saves some space.
 
-    rfc822
+    text
     ------
 
     All of the options have the same meaning as for the `json` exporter:
     `with-io-log`, `squash-io-log`, `flatten-io-log`, `with-run-list`,
     `with-job-list`, `with-resource-map`, `with-job-defs`, `with-attachments`,
-    `with-comments`, `with-job-via`, `with-job-hash`.  The only exception is
-    the `machine-json` option which doesn't exist for this exporter.
-
-    text
-    ----
-
-    Same as with rfc822.
+    `with-comments`, `with-job-hash`.  The only exception is the `machine-json`
+    option which doesn't exist for this exporter.
 
     xlsx
     ----
diff --git a/docs/manpages/plainbox-test-plan-units.rst b/docs/manpages/plainbox-test-plan-units.rst
index 7d77e6f..6857100 100644
--- a/docs/manpages/plainbox-test-plan-units.rst
+++ b/docs/manpages/plainbox-test-plan-units.rst
@@ -99,11 +99,10 @@ copy such constructs when working on a new test plan from scratch
        common and most test plans used by Checkbox actually look like that.
 
      - You can use regular expressions to select many tests at the same time.
-       This is the only way to select generated jobs (created either by
-       template units or by job definitions using the legacy 'local' plugin
-       type). Please remember that the dot character has a special meaning
-       so unless you actually want to match *any character* escape the dot
-       with the backslash character (\\).
+       This is the only way to select generated jobs (created by template
+       units). Please remember that the dot character has a special meaning so
+       unless you actually want to match *any character* escape the dot with
+       the backslash character (\\).
 
     Regardless of if you use patterns or literal job identifiers you can use
     their fully qualified name (the one that includes the namespace they reside
@@ -149,7 +148,7 @@ copy such constructs when working on a new test plan from scratch
 
     Note that each entry in the bootstrap_include section must be a valid job
     identifier and cannot be a regular expression pattern.
-    Also note that only local and resource jobs are allowed in this section.
+    Also note that only resource jobs are allowed in this section.
 
 ``exclude``:
     A multi-line list of job identifiers or patterns matching such identifiers
diff --git a/docs/manpages/plainbox-trusted-launcher-1.rst b/docs/manpages/plainbox-trusted-launcher-1.rst
index ba889e0..77cdfeb 100644
--- a/docs/manpages/plainbox-trusted-launcher-1.rst
+++ b/docs/manpages/plainbox-trusted-launcher-1.rst
@@ -77,13 +77,8 @@ The following environment variables *DO NOT* affect ``plainbox-trusted-launcher-
 Bugs
 ====
 
-Currently it is impossible to use ``plainbox-trusted-launcher-1`` with a
-``local`` job needs to run as root, that generates another ``local`` job that
-needs to run as root, to generate any additional jobs that also need to run as
-root. In other words, only one-level job generation is supported.
-
 The launcher is somewhat inefficient, in that it has to re-run all of the
-dependencies of the ``local`` job over and over. Ideally those would be cached,
+dependencies of the generator job over and over. Ideally those would be cached,
 per-session, but that would significantly increase the complexity of the code
 running as root.
 
diff --git a/docs/usage.rst b/docs/usage.rst
index e2037b9..e2f2f0a 100644
--- a/docs/usage.rst
+++ b/docs/usage.rst
@@ -47,17 +47,6 @@ To list all known jobs run:
 
     plainbox dev special --list-jobs
 
-Running a white list
-^^^^^^^^^^^^^^^^^^^^
-
-To run a :term:`whitelist` pass the ``--whitelist`` or ``-w`` option.
-
-For example, to run the default white list run:
-
-.. code-block:: bash
-
-    $ plainbox run -w /path/to/some/file.whitelist
-
 Saving test results
 ^^^^^^^^^^^^^^^^^^^
 
@@ -72,7 +61,7 @@ To generate a JSON file with all of the internally available data (for storage,
 processing or other automation) you will need to pass three additional
 arguments to ``plainbox run``:
 
-#. ``--output-format=com.canonical.plainbox::json``
+#. ``--output-format=com.canonical.com.canonical.plainbox::json``
 #. ``--output-options=OPTION1,OPTION2`` where *OPTIONx* are option names.
 #. ``--output-file=NAME`` where *NAME* is a file name.
 
@@ -81,7 +70,7 @@ exporter options can be specified, separated with commas.
 
 .. code-block:: bash
 
-    $ plainbox run --whitelist=/path/to/some/file.whitelist --output-format=com.canonical.plainbox::json --output-file=results.json
+    $ plainbox run -i com.canonical.certification::foo --output-format=com.canonical.plainbox::json --output-file=results.json
 
 Other Exporters
 ---------------
diff --git a/plainbox/__init__.py b/plainbox/__init__.py
index 2a7c4e9..336f833 100644
--- a/plainbox/__init__.py
+++ b/plainbox/__init__.py
@@ -1,6 +1,6 @@
 # This file is part of Checkbox.
 #
-# Copyright 2012-2014 Canonical Ltd.
+# Copyright 2012-2018 Canonical Ltd.
 # Written by:
 #   Zygmunt Krynicki <[e-mail]>
 #
@@ -19,17 +19,11 @@
 :mod:`plainbox` -- main package
 ===============================
 
-Simple checkbox redesign, without the complex message passing
+Simple checkbox (2008 version) redesign, without the complex message passing
 
-All public API is in :mod:`plainbox.public`.
 All abstract base classes are in :mod:`plainbox.abc`.
 """
 
-import sys
-
-if sys.version_info[0:2] < (3, 2):
-    raise ImportError("plainbox requires python 3.2")  # pragma: no cover
-
 # PEP440 compliant version declaration.
 #
 # This is used by @public decorator to enforce our public API guarantees.
diff --git a/plainbox/__main__.py b/plainbox/__main__.py
deleted file mode 100644
index 41fa1ed..0000000
--- a/plainbox/__main__.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`plainbox.__main__` -- execute plainbox
-============================================
-
-This module allows plainbox to be executed with:
-
-    python3 -m plainbox
-"""
-
-from plainbox.public import main
-
-
-if __name__ == '__main__':
-    main()
diff --git a/plainbox/_lazymod.py b/plainbox/_lazymod.py
deleted file mode 100644
index 0d697bb..0000000
--- a/plainbox/_lazymod.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2015 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-""" Implementation of a lazy module.  """
-
-import inspect
-import sys
-import types
-
-
-class LazyModule(types.ModuleType):
-
-    """
-    A module subclass that imports things lazily on demand.
-
-    There are some special provisions to make dir() and __all__ work better so
-    that pydoc is more informative.
-
-    :ivar _lazy:
-        A mapping of 'name' to 'callable'. The callable is called only once and
-        defines the lazily loaded version of 'name'.
-    :ivar _all:
-        A set of all the "public" objects. This is exposed as the module's
-        __all__ property. It automatically collects all the objects reported
-        via :meth:`lazily()` and :meth:`immediate()`.
-    :ivar _old:
-        Reference to the old (original) module. This is kept around for python
-        2.x compatibility. It also seems to help with implementing __dir__()
-    """
-
-    def __init__(self, name, doc, old):
-        """ Initialize a new lazy module. """
-        super(LazyModule, self).__init__(name, doc)
-        self._lazy = {}
-        self._all = set()
-        self._old = old
-
-    def __dir__(self):
-        """ Lazy-aware version of dir().  """
-        if sys.version_info[0] == 3:
-            data = super(LazyModule, self).__dir__()
-        else:
-            data = self.__dict__.keys()
-        data = set(data) | self._all
-        return sorted(data)
-
-    def __getattr__(self, name):
-        """ Lazy-aware version of getattr().  """
-        try:
-            callable, args = self._lazy[name]
-        except KeyError:
-            raise AttributeError(name)
-        value = callable(*args)
-        del self._lazy[name]
-        setattr(self, name, value)
-        return value
-
-    @classmethod
-    def shadow_normal_module(cls, mod_name=None):
-        """
-        Shadow a module with an instance of LazyModule.
-
-        :param mod_name:
-            Name of the module to shadow. By default this is the module that is
-            making the call into this method. This is not hard-coded as that
-            module might be called '__main__' if it is executed via 'python -m'
-        :returns:
-            A fresh instance of :class:`LazyModule`.
-        """
-        if mod_name is None:
-            frame = inspect.currentframe()
-            try:
-                mod_name = frame.f_back.f_locals['__name__']
-            finally:
-                del frame
-        orig_mod = sys.modules[mod_name]
-        lazy_mod = cls(orig_mod.__name__, orig_mod.__doc__, orig_mod)
-        for attr in dir(orig_mod):
-            setattr(lazy_mod, attr, getattr(orig_mod, attr))
-        sys.modules[mod_name] = lazy_mod
-        return lazy_mod
-
-    def lazily(self, name, callable, args):
-        """ Load something lazily.  """
-        self._lazy[name] = callable, args
-        self._all.add(name)
-
-    def immediate(self, name, value):
-        """ Load something immediately.  """
-        setattr(self, name, value)
-        self._all.add(name)
-
-    @property
-    def __all__(self):
-        """
-        A lazy-aware version of __all__.
-
-        In addition to exposing all of the original module's __all__ it also
-        contains all the (perhaps not yet loaded) objects defined via
-        :meth:`lazily()`
-        """
-        return sorted(self._all)
-
-    @__all__.setter
-    def __all__(self, value):
-        """
-        Setter for __all__ that just updates the internal set :ivar:`_all`.
-
-        This is used by :meth:`shadow_normal_module()` which copies (assigns)
-        all of the original module's attributes, which also assigns __all__.
-        """
-        self._all.update(value)
-
-
-def far(import_path):
-    """ Helper for lazy imports for :meth:`LazyModule.lazily()`. """
-    module_name, func_name = import_path.split(":", 1)
-    module = __import__(module_name, fromlist=[''])
-    try:
-        return getattr(module, func_name)
-    except AttributeError:
-        raise NotImplementedError(
-            "%s.%s does not exist" % (module_name, func_name))
diff --git a/plainbox/abc.py b/plainbox/abc.py
index 3315d9d..f879732 100644
--- a/plainbox/abc.py
+++ b/plainbox/abc.py
@@ -298,11 +298,11 @@ class IJobQualifier(metaclass=ABCMeta):
     can simply check if a qualifier designates a particular job (if it selects
     it and marks for subsequent execution). This API works fine for certain
     tasks but it was found that it is insufficient to implement so-called
-    whitelist ordering, where the order of jobs in a whitelist is preserved
-    when selecting that whitelist for execution. This spawned the second,
+    test plan ordering, where the order of jobs in a test plan is preserved
+    when selecting that test plan for execution. This spawned the second,
     lower-level API, that gives portable visibility into composite qualifiers
-    (such as a whitelist) and distinct select, deselect vote so that full range
-    of current expressiveness can be preserved.
+    and distinct select, deselect vote so that full range of current
+    expressiveness can be preserved.
 
     :attr VOTE_EXCLUDE:
         (0) vote indicating that a job should *not* be included for
@@ -642,12 +642,6 @@ class IProviderBackend1(metaclass=ABCMeta):
         """
 
     @abstractproperty
-    def whitelists_dir(self):
-        """
-        Return an absolute path of the whitelist directory
-        """
-
-    @abstractproperty
     def data_dir(self):
         """
         absolute path of the data directory
@@ -758,18 +752,6 @@ class IProvider1(IProviderBackend1):
         """
 
     @abstractproperty
-    def whitelist_list(self):
-        """
-        List of loaded whitelists.
-
-        .. warning::
-            :class:`WhiteList` is currently deprecated. You should never need
-            to access them in any new code.  They are entirely replaced by
-            :class:`TestPlan`. This property is provided for completeness and
-            it will be **removed** once whitelists classes are no longer used.
-        """
-
-    @abstractproperty
     def problem_list(self):
         """
         list of problems encountered by the loading process
diff --git a/plainbox/impl/applogic.py b/plainbox/impl/applogic.py
index 6f56ed4..1d90dfd 100644
--- a/plainbox/impl/applogic.py
+++ b/plainbox/impl/applogic.py
@@ -48,21 +48,6 @@ def get_matching_job_list(job_list, qualifier):
     return select_jobs(job_list, [qualifier])
 
 
-def get_whitelist_by_name(provider_list, desired_whitelist):
-    """
-    Get the first whitelist matching desired_whitelist from the loaded
-    providers
-    """
-    for provider in provider_list:
-        for whitelist in provider.whitelist_list:
-            if whitelist.name == desired_whitelist:
-                return whitelist
-    else:
-        raise LookupError(
-            _("None of the providers had a whitelist "
-              "named '{}'").format(desired_whitelist))
-
-
 def run_job_if_possible(session, runner, config, job, update=True, ui=None):
     """
     Coupling point for session, runner, config and job
@@ -103,11 +88,6 @@ class PlainBoxConfig(config.Config):
     environment = config.Section(
         help_text=_("Environment variables for scripts and jobs"))
 
-    extcmd = config.Variable(
-        section='FEATURE-FLAGS', kind=str, default="legacy",
-        validator_list=[config.ChoiceValidator(["legacy", "glibc"])],
-        help_text=_("Which implementation of extcmd to use"))
-
     class Meta:
 
         # TODO: properly depend on xdg and use real code that also handles
diff --git a/plainbox/impl/buildsystems.py b/plainbox/impl/buildsystems.py
index 2e8d7ec..8eabeb6 100644
--- a/plainbox/impl/buildsystems.py
+++ b/plainbox/impl/buildsystems.py
@@ -29,13 +29,6 @@ from plainbox.abc import IBuildSystem
 from plainbox.impl.secure.plugins import PkgResourcesPlugInCollection
 
 
-# python3.2 doesn't have shlex.quote
-# so let's use the bundled copy here
-if not hasattr(shlex, 'quote'):
-    from ._shlex import quote
-    shlex.quote = quote
-
-
 class MakefileBuildSystem(IBuildSystem):
     """
     A build system for projects using classic makefiles
diff --git a/plainbox/impl/commands/__init__.py b/plainbox/impl/commands/__init__.py
index aa0c4de..5a26853 100644
--- a/plainbox/impl/commands/__init__.py
+++ b/plainbox/impl/commands/__init__.py
@@ -28,7 +28,7 @@ import logging
 
 from plainbox.impl.clitools import CommandBase
 from plainbox.impl.clitools import ToolBase
-from plainbox.public import get_providers
+from plainbox.impl.providers import get_providers
 
 
 logger = logging.getLogger("plainbox.commands")
diff --git a/plainbox/impl/commands/cmd_analyze.py b/plainbox/impl/commands/cmd_analyze.py
index 81c1f32..d9c040e 100644
--- a/plainbox/impl/commands/cmd_analyze.py
+++ b/plainbox/impl/commands/cmd_analyze.py
@@ -53,17 +53,6 @@ class AnalyzeCommand(PlainBoxCommand, CheckBoxCommandMixIn):
         parser = subparsers.add_parser(
             "analyze", help=_("analyze how selected jobs would be executed"),
             prog="plainbox dev analyze")
-        group = parser.add_mutually_exclusive_group()
-        group.add_argument(
-            '-l', '--run-local',
-            action='store_true', dest='run_local',
-            help=_('run all selected local jobs, required to see true data'))
-        group.add_argument(
-            '-L', '--skip-local',
-            action='store_false', dest='run_local',
-            # TRANSLATORS: please keep the word 'local' untranslated.
-            # It designates special type of jobs, not their location.
-            help=_('do not run local jobs'))
         group = parser.add_argument_group("reports")
         group.add_argument(
             '-s', '--print-stats', action='store_true',
diff --git a/plainbox/impl/commands/cmd_checkbox.py b/plainbox/impl/commands/cmd_checkbox.py
index 02fa6ca..5bc9e3c 100644
--- a/plainbox/impl/commands/cmd_checkbox.py
+++ b/plainbox/impl/commands/cmd_checkbox.py
@@ -62,12 +62,3 @@ class CheckBoxCommandMixIn:
             metavar=_("PATTERN"), default=[], dest='exclude_pattern_list',
             # TRANSLATORS: this is in imperative form
             help=_("exclude jobs matching the given regular expression"))
-        # TODO: Find a way to handle the encoding of the file
-        group.add_argument(
-            '-w', '--whitelist',
-            action="append",
-            metavar=_("WHITELIST"),
-            default=[],
-            type=FileType("rt"),
-            # TRANSLATORS: this is in imperative form
-            help=_("load whitelist containing run patterns"))
diff --git a/plainbox/impl/commands/inv_analyze.py b/plainbox/impl/commands/inv_analyze.py
index 71d99fe..194d9ef 100644
--- a/plainbox/impl/commands/inv_analyze.py
+++ b/plainbox/impl/commands/inv_analyze.py
@@ -56,12 +56,6 @@ class AnalyzeInvocation(CheckBoxInvocationMixIn):
             self.desired_job_list)
 
     def run(self):
-        if self.ns.run_local:
-            if self.ns.print_desired_job_list:
-                self._print_desired_job_list()
-            if self.ns.print_run_list:
-                self._print_run_list()
-            self._run_local_jobs()
         if self.ns.print_stats:
             self._print_general_stats()
         if self.ns.print_dependency_report:
@@ -89,46 +83,6 @@ class AnalyzeInvocation(CheckBoxInvocationMixIn):
         for job in self.session.run_list:
             print("{}".format(job.id))
 
-    def _run_local_jobs(self):
-        print(_("[Running Local Jobs]").center(80, '='))
-        manager = SessionManager.create_with_state(self.session)
-        try:
-            manager.state.metadata.title = "plainbox dev analyze session"
-            manager.state.metadata.flags = [SessionMetaData.FLAG_INCOMPLETE]
-            manager.checkpoint()
-            runner = JobRunner(
-                manager.storage.location, self.provider_list,
-                os.path.join(manager.storage.location, 'io-logs'),
-                command_io_delegate=self)
-            again = True
-            while again:
-                for job in self.session.run_list:
-                    if job.plugin == 'local':
-                        job_state = self.session.job_state_map[job.id]
-                        if job_state.result.outcome is None:
-                            self._run_local_job(manager, runner, job, job_state)
-                            break
-                else:
-                    again = False
-            manager.state.metadata.flags = []
-            manager.checkpoint()
-        finally:
-            manager.destroy()
-
-    def _run_local_job(self, manager, runner, job, job_state):
-        print("{job}".format(job=job.id))
-        manager.state.metadata.running_job_name = job.id
-        manager.checkpoint()
-        result = runner.run_job(job, job_state, self.config)
-        self.session.update_job_result(job, result)
-        new_desired_job_list = self._get_matching_job_list(
-            self.ns, self.session.job_list)
-        new_problem_list = self.session.update_desired_job_list(
-            new_desired_job_list)
-        if new_problem_list:
-            print(_("Problem list"), new_problem_list)
-            self.problem_list.extend(new_problem_list)
-
     def _print_general_stats(self):
         print(_("[General Statistics]").center(80, '='))
         print(_("Known jobs: {}").format(len(self.session.job_list)))
diff --git a/plainbox/impl/commands/inv_checkbox.py b/plainbox/impl/commands/inv_checkbox.py
index 5136c55..1321985 100644
--- a/plainbox/impl/commands/inv_checkbox.py
+++ b/plainbox/impl/commands/inv_checkbox.py
@@ -33,7 +33,6 @@ from plainbox.impl.secure.origin import CommandLineTextSource
 from plainbox.impl.secure.origin import Origin
 from plainbox.impl.secure.qualifiers import RegExpJobQualifier
 from plainbox.impl.secure.qualifiers import select_jobs
-from plainbox.impl.secure.qualifiers import WhiteList
 from plainbox.impl.secure.rfc822 import FileTextSource
 
 logger = getLogger("plainbox.commands.checkbox")
@@ -66,51 +65,6 @@ class CheckBoxInvocationMixIn:
         return list(
             itertools.chain(*[p.job_list for p in self.provider_list]))
 
-    def get_whitelist_from_file(self, filename, stream=None):
-        """
-        Load a whitelist from a file, with special behavior.
-
-        :param filename:
-            name of the file to load
-        :param stream:
-            (optional) pre-opened stream pointing at the whitelist
-        :returns:
-            The loaded whitelist or None if loading fails for any reason
-
-        This function implements special loading behavior for whitelists that
-        makes them inherit the implicit namespace of the provider they may be a
-        part of. Before loading the whitelist directly from the file, all known
-        providers are interrogated to see if any of them has a whitelist that
-        was loaded from the same file (as indicated by os.path.realpath())
-
-        The stream argument can be provided if the caller already has an open
-        file object, which is typically the case when working with argparse.
-        """
-        # Look up a whitelist with the same name in any of the providers
-        wanted_realpath = os.path.realpath(filename)
-        for provider in self.provider_list:
-            for whitelist in provider.whitelist_list:
-                if (whitelist.origin is not None
-                        and whitelist.origin.source is not None
-                        and isinstance(whitelist.origin.source,
-                                       FileTextSource)
-                        and os.path.realpath(
-                            whitelist.origin.source.filename) ==
-                        wanted_realpath):
-                    logger.debug(
-                        _("Using whitelist %r obtained from provider %r"),
-                        whitelist.name, provider)
-                    return whitelist
-        # Or load it directly
-        try:
-            if stream is not None:
-                return WhiteList.from_string(stream.read(), filename=filename)
-            else:
-                return WhiteList.from_file(filename)
-        except Exception as exc:
-            logger.warning(
-                _("Unable to load whitelist %r: %s"), filename, exc)
-
     def _get_matching_job_list(self, ns, job_list):
         logger.debug("_get_matching_job_list(%r, %r)", ns, job_list)
         qualifier_list = []
@@ -126,12 +80,6 @@ class CheckBoxInvocationMixIn:
                         break
             else:
                 logger.debug(_("There is no test plan: %s"), ns.test_plan)
-        # Add whitelists
-        for whitelist_file in ns.whitelist:
-            qualifier = self.get_whitelist_from_file(
-                whitelist_file.name, whitelist_file)
-            if qualifier is not None:
-                qualifier_list.append(qualifier)
         # Add all the --include jobs
         for pattern in ns.include_pattern_list:
             origin = Origin(CommandLineTextSource('-i', pattern), None, None)
diff --git a/plainbox/impl/commands/inv_run.py b/plainbox/impl/commands/inv_run.py
index 1f0d5f8..c61c764 100644
--- a/plainbox/impl/commands/inv_run.py
+++ b/plainbox/impl/commands/inv_run.py
@@ -403,16 +403,11 @@ class RunInvocation(CheckBoxInvocationMixIn):
             self.metadata.flags.add(SessionMetaData.FLAG_INCOMPLETE)
             self.manager.checkpoint()
             # Select all the jobs that we are likely to run. This is the
-            # initial selection as we haven't started any jobs yet. Local jobs
-            # will cause that to happen again.
+            # initial selection as we haven't started any jobs yet.
             self.do_initial_job_selection()
         # Print out our estimates
         self.print_estimated_duration()
-        # Maybe ask the secure launcher to prompt for the password now. This is
-        # imperfect as we are going to run local jobs and we cannot see if they
-        # might need root or not. This cannot be fixed before template jobs are
-        # added and local jobs deprecated and removed (at least not being a
-        # part of the session we want to execute).
+        # Maybe ask the secure launcher to prompt for the password now.
         self.maybe_warm_up_authentication()
         # Iterate through the run list and run jobs if possible. This function
         # also implements backtrack to run new jobs that were added (and
@@ -731,7 +726,7 @@ class RunInvocation(CheckBoxInvocationMixIn):
             estimated_time = 0
             # gather jobs that we want to run and skip the jobs that already
             # have result, this is only needed when we run over the list of
-            # jobs again, after discovering new jobs via the local job output
+            # jobs again
             for job in self.state.run_list:
                 job_state = self.state.job_state_map[job.id]
                 if job_state.result.outcome is None:
@@ -758,7 +753,7 @@ class RunInvocation(CheckBoxInvocationMixIn):
 
     def get_ui_for_job(self, job):
         if self.ns.dont_suppress_output is False and (job.plugin in (
-                'local', 'resource', 'attachment') or
+                'resource', 'attachment') or
                 'suppress-output' in job.get_flag_set()):
             return NormalUI(self.C.c, show_cmd_output=False)
         else:
diff --git a/plainbox/impl/commands/inv_special.py b/plainbox/impl/commands/inv_special.py
index f93d0a7..bc82fa7 100644
--- a/plainbox/impl/commands/inv_special.py
+++ b/plainbox/impl/commands/inv_special.py
@@ -95,9 +95,6 @@ class SpecialInvocation(CheckBoxInvocationMixIn):
                 print('\t"{}" [shape=ellipse,color=blue];'.format(job.id))
             elif job.plugin == "attachment":
                 print('\t"{}" [color=green];'.format(job.id))
-            elif job.plugin == "local":
-                print('\t"{}" [shape=invtriangle,color=red];'.format(
-                    job.id))
             elif job.plugin == "shell":
                 print('\t"{}" [];'.format(job.id))
             elif job.plugin in ("manual", "user-verify", "user-interact"):
diff --git a/plainbox/impl/commands/test_run.py b/plainbox/impl/commands/test_run.py
index 19d7c9c..fe6f2a0 100644
--- a/plainbox/impl/commands/test_run.py
+++ b/plainbox/impl/commands/test_run.py
@@ -34,7 +34,6 @@ from inspect import cleandoc
 from unittest import TestCase
 
 from plainbox.impl.box import main
-from plainbox.impl.exporter.rfc822 import RFC822SessionStateExporter
 from plainbox.impl.exporter.text import TextSessionStateExporter
 from plainbox.testing_utils.io import TestIO
 from plainbox.vendor.mock import patch, Mock
@@ -63,7 +62,7 @@ class TestRun(TestCase):
         usage: plainbox run [-h] [--non-interactive] [-n] [--dont-suppress-output]
                             [-f FORMAT] [-p OPTIONS] [-o FILE] [-t TRANSPORT]
                             [--transport-where WHERE] [--transport-options OPTIONS]
-                            [-T TEST-PLAN-ID] [-i PATTERN] [-x PATTERN] [-w WHITELIST]
+                            [-T TEST-PLAN-ID] [-i PATTERN] [-x PATTERN]
 
         optional arguments:
           -h, --help            show this help message and exit
@@ -100,8 +99,6 @@ class TestRun(TestCase):
                                 include jobs matching the given regular expression
           -x PATTERN, --exclude-pattern PATTERN
                                 exclude jobs matching the given regular expression
-          -w WHITELIST, --whitelist WHITELIST
-                                load whitelist containing run patterns
         """
         self.assertEqual(io.combined, cleandoc(expected) + "\n")
 
@@ -133,7 +130,6 @@ class TestRun(TestCase):
         Available output formats:
         com.canonical.plainbox::html - Generate a standalone HTML
         com.canonical.plainbox::json - Generate JSON output
-        com.canonical.plainbox::rfc822 - Generate RCF822 output
         com.canonical.plainbox::text - Generate plain text output
         com.canonical.plainbox::tar - Generate a tar.xz archive
         com.canonical.plainbox::xlsx - Generate an Excel 2007+ XLSX document
@@ -150,10 +146,9 @@ class TestRun(TestCase):
         Each format may support a different set of options
         com.canonical.plainbox::html: 
         com.canonical.plainbox::json: 
-        com.canonical.plainbox::rfc822: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments, with-job-via, with-job-hash, with-category-map, with-certification-status
-        com.canonical.plainbox::text: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments, with-job-via, with-job-hash, with-category-map, with-certification-status
+        com.canonical.plainbox::text: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments, with-job-hash, with-category-map, with-certification-status
         com.canonical.plainbox::tar: 
-        com.canonical.plainbox::xlsx: with-sys-info, with-summary, with-job-description, with-text-attachments, with-unit-categories
+        com.canonical.plainbox::xlsx: with-sys-info, with-summary, with-job-description, with-text-attachments
         com.canonical.plainbox::global: 
         """
         self.assertIn(cleandoc(expected) + "\n", io.combined)
diff --git a/plainbox/impl/ctrl.py b/plainbox/impl/ctrl.py
index 1551c0e..056ee47 100644
--- a/plainbox/impl/ctrl.py
+++ b/plainbox/impl/ctrl.py
@@ -21,7 +21,7 @@
 :mod:`plainbox.impl.ctrl` -- Controller Classes
 ===============================================
 
-Session controller classes implement the glue between models (jobs, whitelists,
+Session controller classes implement the glue between models (jobs, test plans,
 session state) and the rest of the application. They encapsulate knowledge that
 used to be special-cased and sprinkled around various parts of both plainbox
 and particular plainbox-using applications.
@@ -102,9 +102,6 @@ class CheckBoxSessionStateController(ISessionStateController):
           true. This is expressed via the 'requires' attribute. A job will
           become inhibited if any of the requirement programs evaluates to
           value other than True.
-        * A job may have the attribute 'plugin' equal to "local" which will
-          cause the controller to interpret the stdout of the command as a set
-          of job definitions.
         * A job may have the attribute 'plugin' equal to "resource" which will
           cause the controller to interpret the stdout of the command as a set
           of resource definitions.
@@ -243,8 +240,8 @@ class CheckBoxSessionStateController(ISessionStateController):
         Results also change the ready map (jobs that can run) because of
         dependency relations.
 
-        Some results have deeper meaning, those are results for local and
-        resource jobs. They are discussed in detail below:
+        Some results have deeper meaning, those are results for resource jobs.
+        They are discussed in detail below:
 
         Resource jobs produce resource records which are used as data to run
         requirement expressions against. Each time a result for a resource job
@@ -252,11 +249,6 @@ class CheckBoxSessionStateController(ISessionStateController):
         records. A new entry is created in the resource map (entirely replacing
         any old entries), with a list of the resources that were parsed from
         the IO log.
-
-        Local jobs produce more jobs. Like with resource jobs, their IO log is
-        parsed and interpreted as additional jobs. Unlike in resource jobs
-        local jobs don't replace anything. They cannot replace an existing job
-        with the same id.
         """
         # Store the result in job_state_map
         session_state.job_state_map[job.id].result = result
@@ -265,8 +257,6 @@ class CheckBoxSessionStateController(ISessionStateController):
         # Treat some jobs specially and interpret their output
         if job.plugin == "resource":
             self._process_resource_result(session_state, job, result)
-        elif job.plugin == "local":
-            self._process_local_result(session_state, job, result)
 
     def _process_resource_result(self, session_state, job, result):
         """
@@ -333,108 +323,6 @@ class CheckBoxSessionStateController(ISessionStateController):
                                 new_unit.id]
                             job_state.via_job = job
 
-    def _process_local_result(self, session_state, job, result):
-        """
-        Analyze a result of a CheckBox "local" job and generate
-        additional job definitions
-        """
-        # First parse all records and create a list of new jobs (confusing
-        # name, not a new list of jobs)
-        new_job_list = []
-        for record in gen_rfc822_records_from_io_log(job, result):
-            # Skip non-job units as the code below is wired to work with jobs
-            # Fixes: https://bugs.launchpad.net/plainbox/+bug/1443228
-            if record.data.get('unit', 'job') != 'job':
-                continue
-            new_job = job.create_child_job_from_record(record)
-            check_result = new_job.check()
-            # Only ignore jobs for which check() returns an error
-            if [c for c in check_result if c.severity == Severity.error]:
-                logger.error(_("Ignoring invalid generated job %s"),
-                             new_job.id)
-            else:
-                new_job_list.append(new_job)
-        # Then for each new job, add it to the job_list, unless it collides
-        # with another job with the same id.
-        for new_job in new_job_list:
-            try:
-                added_unit = session_state.add_unit(new_job, recompute=False)
-            except DependencyDuplicateError as exc:
-                # XXX: there should be a channel where such errors could be
-                # reported back to the UI layer. Perhaps update_job_result()
-                # could simply return a list of problems in a similar manner
-                # how update_desired_job_list() does.
-                logger.warning(
-                    # TRANSLATORS: keep the word "local" untranslated. It is a
-                    # special type of job that needs to be distinguished.
-                    _("Local job %s produced job %s that collides with"
-                      " an existing job %s (from %s), the new job was"
-                      " discarded"),
-                    job.id, exc.duplicate_job.id, exc.job.id, exc.job.origin)
-            else:
-                # Set the via_job attribute of the newly added job to point to
-                # the generator job. This way it can be traced back to the old
-                # __category__-style local jobs or to their corresponding
-                # generator job in general.
-                #
-                # NOTE: this is the only place where we assign via_job so as
-                # long as that holds true, we can detect and break via cycles.
-                #
-                # Via cycles occur whenever a job can reach itself again
-                # through via associations. Note that the chain may be longer
-                # than one link (A->A) and can include other jobs in the list
-                # (A->B->C->A)
-                #
-                # To detect a cycle we must iterate back the via chain (and we
-                # must do it here because we have access to job_state_map that
-                # allows this iteration to happen) and break the cycle if we
-                # see the job being added.
-                job_state_map = session_state.job_state_map
-                job_state_map[added_unit.id].via_job = job
-                via_cycle = get_via_cycle(job_state_map, added_unit)
-                if via_cycle:
-                    logger.warning(_("Automatically breaking via-cycle: %s"),
-                                   ' -> '.join(str(cycle_job)
-                                               for cycle_job in via_cycle))
-                    job_state_map[added_unit.id].via_job = None
-
-
-def get_via_cycle(job_state_map, job):
-    """
-    Find a possible cycle including via_job.
-
-    :param job_state_map:
-        A dictionary mapping job.id to a JobState object.
-    :param via_job:
-        Any job, start of a hypothetical via job cycle.
-    :raises KeyError:
-        If any of the encountered jobs are not present in job_state_map.
-    :return:
-        A list of jobs that represent the cycle or an empty tuple if no cycle
-        is present. The list has the property that item[0] is item[-1]
-
-    A via cycle occurs if *job* is reachable through the *via_job* by
-    recursively following via_job connection until via_job becomes None.
-    """
-    cycle = []
-    seen = set()
-    while job is not None:
-        cycle.append(job)
-        seen.add(job)
-        next_job = job_state_map[job.id].via_job
-        if next_job in seen:
-            break
-        job = next_job
-    else:
-        return ()
-    # Discard all the jobs leading to the cycle.
-    # cycle = cycle[cycle.index(next_job):]
-    # This is just to hold the promise of the return value so
-    # that processing is easier for the caller.
-    cycle.append(next_job)
-    # assert cycle[0] is cycle[-1]
-    return cycle
-
 
 def gen_rfc822_records_from_io_log(job, result):
     """
diff --git a/plainbox/impl/depmgr.py b/plainbox/impl/depmgr.py
index aa7fb50..f91bc2f 100644
--- a/plainbox/impl/depmgr.py
+++ b/plainbox/impl/depmgr.py
@@ -31,9 +31,9 @@ Job Dependency Solver.
 from abc import ABCMeta
 from abc import abstractproperty
 from logging import getLogger
+import enum
 
 from plainbox.i18n import gettext as _
-from plainbox.vendor import enum
 
 
 logger = getLogger("plainbox.depmgr")
diff --git a/plainbox/impl/exporter/__init__.py b/plainbox/impl/exporter/__init__.py
index 703beca..4c86c5d 100644
--- a/plainbox/impl/exporter/__init__.py
+++ b/plainbox/impl/exporter/__init__.py
@@ -79,7 +79,6 @@ class SessionStateExporterBase(ISessionStateExporter):
     OPTION_WITH_JOB_DEFS = 'with-job-defs'
     OPTION_WITH_ATTACHMENTS = 'with-attachments'
     OPTION_WITH_COMMENTS = 'with-comments'
-    OPTION_WITH_JOB_VIA = 'with-job-via'
     OPTION_WITH_JOB_HASH = 'with-job-hash'
     OPTION_WITH_CATEGORY_MAP = 'with-category-map'
     OPTION_WITH_CERTIFICATION_STATUS = 'with-certification-status'
@@ -94,7 +93,6 @@ class SessionStateExporterBase(ISessionStateExporter):
         OPTION_WITH_JOB_DEFS,
         OPTION_WITH_ATTACHMENTS,
         OPTION_WITH_COMMENTS,
-        OPTION_WITH_JOB_VIA,
         OPTION_WITH_JOB_HASH,
         OPTION_WITH_CATEGORY_MAP,
         OPTION_WITH_CERTIFICATION_STATUS,
@@ -261,13 +259,6 @@ class SessionStateExporterBase(ISessionStateExporter):
                 data['result_map'][job_id]['comments'] = \
                     job_state.result.comments
 
-            # Add Parent hash if requested
-            if self.OPTION_WITH_JOB_VIA in self._option_list:
-                data['result_map'][job_id]['via'] = (
-                    job_state.via_job.checksum
-                    if job_state.via_job is not None else None
-                )
-
             # Add Job hash if requested
             if self.OPTION_WITH_JOB_HASH in self._option_list:
                 data['result_map'][job_id]['hash'] = job_state.job.checksum
diff --git a/plainbox/impl/exporter/rfc822.py b/plainbox/impl/exporter/rfc822.py
deleted file mode 100644
index 8f3a185..0000000
--- a/plainbox/impl/exporter/rfc822.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`plainbox.impl.exporter.rfc822` -- RFC822 exporter
-=======================================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-
-from collections import OrderedDict
-from io import StringIO
-
-from plainbox.impl.exporter import SessionStateExporterBase
-from plainbox.impl.secure.rfc822 import RFC822Record
-
-
-class RFC822SessionStateExporter(SessionStateExporterBase):
-    """
-    Session state exporter creating rfc822 documents
-    """
-
-    def dump(self, data, stream):
-        entry = OrderedDict()
-        string_stream = StringIO()
-        for job_name, job_data in sorted(data['result_map'].items()):
-            entry['name'] = job_name
-            entry.update(job_data)
-            RFC822Record(entry).dump(string_stream)
-        stream.write(string_stream.getvalue().encode('UTF-8'))
diff --git a/plainbox/impl/exporter/tar.py b/plainbox/impl/exporter/tar.py
index 6fe8acb..6723e93 100644
--- a/plainbox/impl/exporter/tar.py
+++ b/plainbox/impl/exporter/tar.py
@@ -33,8 +33,8 @@ import time
 from plainbox.impl.exporter import SessionStateExporterBase
 from plainbox.impl.exporter.jinja2 import Jinja2SessionStateExporter
 from plainbox.impl.exporter.xlsx import XLSXSessionStateExporter
+from plainbox.impl.providers import get_providers
 from plainbox.impl.unit.exporter import ExporterUnitSupport
-from plainbox.public import get_providers
 
 
 class TARSessionStateExporter(SessionStateExporterBase):
@@ -78,7 +78,6 @@ class TARSessionStateExporter(SessionStateExporterBase):
             XLSXSessionStateExporter.OPTION_WITH_SUMMARY,
             XLSXSessionStateExporter.OPTION_WITH_DESCRIPTION,
             XLSXSessionStateExporter.OPTION_WITH_TEXT_ATTACHMENTS,
-            XLSXSessionStateExporter.OPTION_WITH_UNIT_CATEGORIES
         ]
         xlsx_exporter = XLSXSessionStateExporter(options_list)
         xlsx_exporter.dump_from_session_manager(manager, xlsx_stream)
diff --git a/plainbox/impl/exporter/test_html.py b/plainbox/impl/exporter/test_html.py
index 9827a00..e763571 100644
--- a/plainbox/impl/exporter/test_html.py
+++ b/plainbox/impl/exporter/test_html.py
@@ -31,12 +31,12 @@ import io
 from plainbox.abc import IJobResult
 from plainbox.testing_utils import resource_string
 from plainbox.impl.exporter.jinja2 import Jinja2SessionStateExporter
+from plainbox.impl.providers import get_providers
 from plainbox.impl.resource import Resource
 from plainbox.impl.result import MemoryJobResult
 from plainbox.impl.session import SessionManager
 from plainbox.impl.unit.exporter import ExporterUnitSupport
 from plainbox.impl.unit.job import JobDefinition
-from plainbox.public import get_providers
 
 
 class HTMLExporterTests(TestCase):
diff --git a/plainbox/impl/exporter/test_init.py b/plainbox/impl/exporter/test_init.py
index e590ae4..8980390 100644
--- a/plainbox/impl/exporter/test_init.py
+++ b/plainbox/impl/exporter/test_init.py
@@ -219,7 +219,6 @@ class SessionStateExporterBaseTests(TestCase):
                                      'uncategorised')),
                     ('outcome', 'pass'),
                     ('comments', None),
-                    ('via', None),
                     ('hash', '2def0c995e1b6d934c5a91286ba164'
                              '18845da26d057bc992a2b5dfeae2e2fe91'),
                     ('plugin', 'shell'),
@@ -234,7 +233,6 @@ class SessionStateExporterBaseTests(TestCase):
                                      'uncategorised')),
                     ('outcome', 'pass'),
                     ('comments', 'foo'),
-                    ('via', None),
                     ('hash', 'ed19ba54624864a7c622ff7d1e8ed5'
                              '96b1a0fddc4b78c8fb780fe41e55250e6f'),
                     ('plugin', 'resource'),
diff --git a/plainbox/impl/exporter/test_rfc822.py b/plainbox/impl/exporter/test_rfc822.py
deleted file mode 100644
index b858b61..0000000
--- a/plainbox/impl/exporter/test_rfc822.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#   Daniel Manrique  <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-plainbox.impl.exporter.test_rfc822
-==================================
-
-Test definitions for plainbox.impl.exporter.rfc822 module
-"""
-
-from io import BytesIO
-from unittest import TestCase
-
-from plainbox.impl.exporter.rfc822 import RFC822SessionStateExporter
-
-
-class RFC822SessionStateExporterTests(TestCase):
-
-    def test_dump(self):
-        exporter = RFC822SessionStateExporter()
-        # exporter expects this data format
-        data = {'result_map': {'job_name': {'outcome': 'fail'}}}
-        stream = BytesIO()
-        exporter.dump(data, stream)
-        expected_bytes = (
-            "name: job_name\n"
-            "outcome: fail\n"
-            "\n"
-        ).encode('UTF-8')
-        self.assertEqual(stream.getvalue(), expected_bytes)
diff --git a/plainbox/impl/exporter/xlsx.py b/plainbox/impl/exporter/xlsx.py
index 7de2e8a..e51b193 100644
--- a/plainbox/impl/exporter/xlsx.py
+++ b/plainbox/impl/exporter/xlsx.py
@@ -63,14 +63,12 @@ class XLSXSessionStateExporter(SessionStateExporterBase):
     OPTION_WITH_SUMMARY = 'with-summary'
     OPTION_WITH_DESCRIPTION = 'with-job-description'
     OPTION_WITH_TEXT_ATTACHMENTS = 'with-text-attachments'
-    OPTION_WITH_UNIT_CATEGORIES = 'with-unit-categories'
 
     SUPPORTED_OPTION_LIST = (
         OPTION_WITH_SYSTEM_INFO,
         OPTION_WITH_SUMMARY,
         OPTION_WITH_DESCRIPTION,
         OPTION_WITH_TEXT_ATTACHMENTS,
-        OPTION_WITH_UNIT_CATEGORIES,
     )
 
     def __init__(self, option_list=None, exporter_unit=None):
@@ -96,8 +94,6 @@ class XLSXSessionStateExporter(SessionStateExporterBase):
             SessionStateExporterBase.OPTION_FLATTEN_IO_LOG,
             SessionStateExporterBase.OPTION_WITH_COMMENTS,
             SessionStateExporterBase.OPTION_WITH_JOB_DEFS,
-            SessionStateExporterBase.OPTION_WITH_JOB_VIA,
-            SessionStateExporterBase.OPTION_WITH_JOB_HASH,
             SessionStateExporterBase.OPTION_WITH_RESOURCE_MAP,
             SessionStateExporterBase.OPTION_WITH_ATTACHMENTS,
             SessionStateExporterBase.OPTION_WITH_CATEGORY_MAP,
@@ -443,30 +439,6 @@ class XLSXSessionStateExporter(SessionStateExporterBase):
             'x_offset': 0, 'y_offset': 10, 'x_scale': 0.50, 'y_scale': 0.50
         })
 
-    def _set_category_status(self, result_map, via, child):
-        for parent in [j for j in result_map if result_map[j]['hash'] == via]:
-            if 'category_status' not in result_map[parent]:
-                result_map[parent]['category_status'] = None
-            child_status = result_map[child]['outcome']
-            if 'category_status' in result_map[child]:
-                child_status = result_map[child]['category_status']
-            # Ignore categories without any child
-            elif result_map[child]['plugin'] == 'local':
-                continue
-            if child_status == IJobResult.OUTCOME_FAIL:
-                result_map[parent]['category_status'] = IJobResult.OUTCOME_FAIL
-            elif (
-                child_status == IJobResult.OUTCOME_PASS and
-                result_map[parent]['category_status'] !=
-                    IJobResult.OUTCOME_FAIL
-            ):
-                result_map[parent]['category_status'] = IJobResult.OUTCOME_PASS
-            elif (
-                result_map[parent]['category_status'] not in
-                (IJobResult.OUTCOME_PASS, IJobResult.OUTCOME_FAIL)
-            ):
-                result_map[parent]['category_status'] = IJobResult.OUTCOME_SKIP
-
     def _tree(self, result_map, category_map):
         res = {}
         tmp_result_map = {}
@@ -500,21 +472,6 @@ class XLSXSessionStateExporter(SessionStateExporterBase):
         result_map.update(tmp_result_map)
         return res, 2
 
-    def _legacy_tree(self, result_map, via=None, level=0, max_level=0):
-        res = {}
-        for job_name in [j for j in result_map if result_map[j]['via'] == via]:
-            level += 1
-            # Find the maximum depth of the test tree
-            if level > max_level:
-                max_level = level
-            res[job_name], max_level = self._legacy_tree(
-                result_map, result_map[job_name]['hash'], level, max_level)
-            # Generate parent categories status
-            if via is not None:
-                self._set_category_status(result_map, via, job_name)
-            level -= 1
-        return res, max_level
-
     def _write_job(self, tree, result_map, max_level, level=0):
         for job, children in OrderedDict(
                 sorted(
@@ -635,11 +592,8 @@ class XLSXSessionStateExporter(SessionStateExporterBase):
                             {'hidden': True})
 
     def write_results(self, data):
-        if self.OPTION_WITH_UNIT_CATEGORIES in self._option_list:
-            tree, max_level = self._tree(
-                data['result_map'], data['category_map'])
-        else:
-            tree, max_level = self._legacy_tree(data['result_map'])
+        tree, max_level = self._tree(
+            data['result_map'], data['category_map'])
         self.worksheet3.write(3, 1, _('Tests Performed'), self.format03)
         self.worksheet3.freeze_panes(6, 0)
         self.worksheet3.set_tab_color('#DC4C00')  # Orange
diff --git a/plainbox/impl/highlevel.py b/plainbox/impl/highlevel.py
index 4c36ae8..eeed23e 100644
--- a/plainbox/impl/highlevel.py
+++ b/plainbox/impl/highlevel.py
@@ -123,9 +123,6 @@ class PlainBoxObject:
         return self._attrs
 
 
-# NOTE: This should merge with the service object below but I didn't want
-# to do it right away as that would have to alter Service.__init__() and
-# I want to get Explorer API right first.
 class Explorer:
     """
     Class simplifying discovery of various PlainBox objects.
@@ -164,7 +161,6 @@ class Explorer:
             the explorer itself
                 - all providers
                     - all jobs
-                    - all whitelists
                     - all executables
                 - all repositories
                     - all storages
@@ -173,7 +169,7 @@ class Explorer:
             self,
             name='service object',
             group="service")
-        # Milk each provider for jobs and whitelists
+        # Milk each provider for jobs and test plans
         for provider in self.provider_list:
             provider_obj = PlainBoxObject(
                 provider,
@@ -189,7 +185,6 @@ class Explorer:
                     ('tr_description', provider.tr_description()),
                     ('jobs_dir', provider.jobs_dir),
                     ('units_dir', provider.units_dir),
-                    ('whitelists_dir', provider.whitelists_dir),
                     ('data_dir', provider.data_dir),
                     ('locale_dir', provider.locale_dir),
                     ('gettext_domain', provider.gettext_domain),
diff --git a/plainbox/impl/launcher.py b/plainbox/impl/launcher.py
index c535aef..897d80c 100644
--- a/plainbox/impl/launcher.py
+++ b/plainbox/impl/launcher.py
@@ -65,93 +65,7 @@ class LauncherDefinition(PlainBoxConfig):
         :returns: LauncherDefinition instance
         :raises KeyError: for unknown launcher_version values
         """
-        return {
-            '1': LauncherDefinition1,
-            config.Unset: LauncherDefinitionLegacy
-        }[self.launcher_version]()
-
-
-class LauncherDefinitionLegacy(LauncherDefinition):
-    """
-    Launcher definition class for 'unversioned' launchers.
-
-    This definition is used for launchers that do not specify
-    'launcher_version' in their [launcher] section.
-    """
-
-    api_flags = config.Variable(
-        section='launcher',
-        kind=list,
-        default=[],
-        help_text=_('List of feature-flags the application requires'))
-
-    api_version = config.Variable(
-        section='launcher',
-        default='0.99',
-        help_text=_('Version of API the launcher uses'))
-
-    title = config.Variable(
-        section="welcome",
-        help_text=_("Application Title"))
-
-    text = config.Variable(
-        section="welcome",
-        help_text=_("Welcome Message"))
-
-    dont_suppress_output = config.Variable(
-        section="ui", kind=bool, default=False,
-        help_text=_("Don't suppress the output of certain job plugin types."))
-
-    whitelist_filter = config.Variable(
-        section="suite",
-        # TODO: valid regexp text validator
-        help_text=_("Pattern that whitelists need to match to be displayed"))
-
-    whitelist_selection = config.Variable(
-        section="suite",
-        # TODO: valid regexp text validator
-        help_text=_("Pattern that whitelists need to match to be selected"))
-
-    skip_whitelist_selection = config.Variable(
-        section="suite",
-        kind=bool,
-        default=False,
-        help_text=_("If enabled then suite selection screen is not displayed"))
-
-    skip_test_selection = config.Variable(
-        section="suite",
-        kind=bool,
-        default=False,
-        help_text=_("If enabled then test selection screen is not displayed"))
-
-    input_type = config.Variable(
-        section="submission",
-        # TODO: probably a choice validator
-        help_text=_("Type of the input field?"))
-
-    ok_btn_text = config.Variable(
-        section="submission",
-        help_text=_("Label on the 'send' button"))
-
-    submit_to = config.Variable(
-        section="transport",
-        validator_list=[config.ChoiceValidator(get_all_transports().keys())],
-        help_text=_("Where to submit the test results to"))
-
-    # TODO: Add a validator to ensure it looks like a valid URL
-    submit_url = config.Variable(
-        section="transport",
-        help_text=_("HTTP endpoint to submit data to, using the"
-                    " transport specified with submit_to."))
-
-    secure_id = config.Variable(
-        section="submission",
-        validator_list=[config.PatternValidator(SECURE_ID_PATTERN)],
-        help_text=_("Secure ID to identify the system this"
-                    " submission belongs to."))
-
-    exporter = config.Section(
-        help_text=_("Section with only exported unit ids as keys (no values)"))
+        return {'1': LauncherDefinition1}[self.launcher_version]()
 
 
 class LauncherDefinition1(LauncherDefinition):
diff --git a/plainbox/impl/providers/__init__.py b/plainbox/impl/providers/__init__.py
index a6a510b..8a6b121 100644
--- a/plainbox/impl/providers/__init__.py
+++ b/plainbox/impl/providers/__init__.py
@@ -22,18 +22,10 @@ APIs for working with providers.
 :mod:`plainbox.impl.providers` -- providers package
 ===================================================
 
-Providers are a mechanism by which PlainBox can enumerate jobs and whitelists.
+Providers are a mechanism by which PlainBox can enumerate jobs and test plans.
 Currently there are only v1 (as in version one) providers that basically have
 to behave as CheckBox itself (mini CheckBox forks for example)
 
-There is ongoing work and discussion on V2 providers that would have a
-lower-level interface and would be able to define new job types, new whitelist
-types and generally all the next-gen semantics.
-
-PlainBox does not come with any real provider by default. PlainBox sometimes
-creates special dummy providers that have particular data in them for testing.
-
-
 V1 providers
 ------------
 
@@ -43,9 +35,6 @@ this is also described by :class:`IProvider1`::
     * there is a directory with '.txt' or '.txt.in' files with RFC822-encoded
       job definitions. The definitions need a particular set of keys to work.
 
-    * there is a directory with '.whitelist' files that contain a list (one per
-      line) of job definitions to execute.
-
     * there is a directory with additional executables (added to PATH)
 
     * there is a directory with an additional python3 libraries (added to
diff --git a/plainbox/impl/providers/exporters/data/checkbox.html b/plainbox/impl/providers/exporters/data/checkbox.html
index 8b6e5c6..9bc8eba 100644
--- a/plainbox/impl/providers/exporters/data/checkbox.html
+++ b/plainbox/impl/providers/exporters/data/checkbox.html
@@ -225,7 +225,7 @@
                     </tr>
                 </thead>
                 <tbody>
-                {%- for job_id, job_state in job_state_map|dictsort if job_state.result.outcome != None and job_state.job.plugin not in ("resource", "local", "attachment") %}
+                {%- for job_id, job_state in job_state_map|dictsort if job_state.result.outcome != None and job_state.job.plugin not in ("resource", "attachment") %}
                     <tr>
                         <td>{{ job_state.job.tr_summary() }}</td>
                         <td style='font-weight: bold; color: {{ job_state.result.outcome_meta().color_hex }}'>{{ job_state.result.outcome_meta().tr_label }}</td>
diff --git a/plainbox/impl/providers/exporters/data/checkbox.json b/plainbox/impl/providers/exporters/data/checkbox.json
index 00ed7e1..cd49b05 100644
--- a/plainbox/impl/providers/exporters/data/checkbox.json
+++ b/plainbox/impl/providers/exporters/data/checkbox.json
@@ -36,7 +36,7 @@
     },
 {%- endif %}
     "results": [
-    {%- for job_id, job_state in job_state_map|dictsort if job_state.result.outcome != None and job_state.job.plugin not in ("resource", "local", "attachment") %}
+    {%- for job_id, job_state in job_state_map|dictsort if job_state.result.outcome != None and job_state.job.plugin not in ("resource", "attachment") %}
         {
             "id": "{{ job_id|strip_ns }}",
             "name": "{{ job_state.job.tr_summary() }}",
diff --git a/plainbox/impl/providers/exporters/units/exporter.pxu b/plainbox/impl/providers/exporters/units/exporter.pxu
index 0d7ec67..65f96eb 100644
--- a/plainbox/impl/providers/exporters/units/exporter.pxu
+++ b/plainbox/impl/providers/exporters/units/exporter.pxu
@@ -13,12 +13,6 @@ file_extension: json
 data: {"template": "checkbox.json"}
 
 unit: exporter
-id: rfc822
-_summary: Generate RCF822 output
-entry_point: rfc822
-file_extension: rfc822
-
-unit: exporter
 id: text
 _summary: Generate plain text output
 entry_point: text
@@ -36,7 +30,7 @@ _summary: Generate an Excel 2007+ XLSX document
 entry_point: xlsx
 file_extension: xlsx
 options:
- with-sys-info, with-summary, with-job-description, with-text-attachments, with-unit-categories
+ with-sys-info, with-summary, with-job-description, with-text-attachments
 
 unit: exporter
 id: global
diff --git a/plainbox/impl/providers/stubbox/units/jobs/local.pxu b/plainbox/impl/providers/stubbox/units/jobs/local.pxu
deleted file mode 100644
index 0f41e6c..0000000
--- a/plainbox/impl/providers/stubbox/units/jobs/local.pxu
+++ /dev/null
@@ -1,9 +0,0 @@
-id: stub/local/true
-_summary: A job generated by another job
-# TRANSLATORS: don't translate 'local' below.
-_description:
- Check success result from shell test case (generated from a local job)
-plugin: shell
-flags: preserve-locale
-command: true
-estimated_duration: 0.1
diff --git a/plainbox/impl/providers/stubbox/units/jobs/multilevel.pxu b/plainbox/impl/providers/stubbox/units/jobs/multilevel.pxu
deleted file mode 100644
index f01a716..0000000
--- a/plainbox/impl/providers/stubbox/units/jobs/multilevel.pxu
+++ /dev/null
@@ -1,25 +0,0 @@
-id: stub/multilevel
-_summary: A generated generator job that generates two more jobs
-_description: Multilevel tests
-plugin: local
-flags: preserve-locale
-command:
- cat <<'EOF'
- id: stub/multilevel_1
- _summary: Generated multi-level job 1
- _description: This is just a sample multilevel test. Test 1.
- plugin: shell
- command: echo 1
- estimated_duration: 0.1
- EOF
- echo ""
- cat <<'EOF'
- id: stub/multilevel_2
- _summary: Generated multi-level job 2
- _description: This is just a sample multilevel test. Test 2.
- plugin: shell
- command: echo 2
- estimated_duration: 0.1
- EOF
- echo ""
-estimated_duration: 0.1
diff --git a/plainbox/impl/providers/stubbox/units/jobs/representative.pxu b/plainbox/impl/providers/stubbox/units/jobs/representative.pxu
index f7d7f60..8bab00d 100644
--- a/plainbox/impl/providers/stubbox/units/jobs/representative.pxu
+++ b/plainbox/impl/providers/stubbox/units/jobs/representative.pxu
@@ -29,15 +29,6 @@ command:
 estimated_duration: 0.1
 category_id: plugin-representative
 
-id: representative/plugin/local
-_summary: Job with plugin=local
-_description: Job with plugin=local
-plugin: local
-flags: preserve-locale
-command: :
-estimated_duration: 0.1
-category_id: plugin-representative
-
 id: representative/plugin/attachment
 _summary: Job with plugin=attachment
 _description: Job with plugin=attachment
diff --git a/plainbox/impl/providers/stubbox/units/jobs/stub.pxu b/plainbox/impl/providers/stubbox/units/jobs/stub.pxu
index 7bdfc8d..55c1d62 100644
--- a/plainbox/impl/providers/stubbox/units/jobs/stub.pxu
+++ b/plainbox/impl/providers/stubbox/units/jobs/stub.pxu
@@ -328,30 +328,6 @@ command: false
 estimated_duration: 25
 category_id: split-field-representative
 
-id: __local__
-_summary: A job generating one more job
-_description:
-    This job generates the stub/local/true job
-plugin: local
-flags: preserve-locale
-command:
-  shopt -s extglob
-  cat $PLAINBOX_PROVIDER_UNITS/jobs/local.pxu
-estimated_duration: 0.1
-category_id: plugin-representative
-
-id: __multilevel__
-_summary: A job generating more generator jobs
-_description:
-    This job generates stub/multilevel which in turn can
-    generate stub/multilevel_1 and stub/multilevel_2
-plugin: local
-flags: preserve-locale
-command:
-  shopt -s extglob
-  cat $PLAINBOX_PROVIDER_UNITS/jobs/multilevel.pxu
-estimated_duration: 0.1
-
 id: stub/root
 _summary: A job that runs as root
 _description:
diff --git a/plainbox/impl/providers/stubbox/whitelists/stub.whitelist b/plainbox/impl/providers/stubbox/whitelists/stub.whitelist
deleted file mode 100644
index 3c06fd3..0000000
--- a/plainbox/impl/providers/stubbox/whitelists/stub.whitelist
+++ /dev/null
@@ -1,23 +0,0 @@
-# Shell job that always works
-stub/true
-# Shell job that always fails
-stub/false
-# User-* Job collection
-stub/user-verify
-stub/user-interact
-stub/user-interact-verify
-# A manual job
-stub/manual
-# A shell job with a dependency that always works
-stub/dependency/good
-# A shell job with a dependency that always fails
-stub/dependency/bad
-# A shell job that requires a resource which is available
-stub/requirement/good
-# A shell job that requires a resource which is not available
-stub/requirement/bad
-__local__
-stub/local/true
-stub/multilevel
-stub/multilevel.*
-stub/root
diff --git a/plainbox/impl/providers/stubbox/whitelists/stub1.whitelist b/plainbox/impl/providers/stubbox/whitelists/stub1.whitelist
deleted file mode 100644
index d33c8a4..0000000
--- a/plainbox/impl/providers/stubbox/whitelists/stub1.whitelist
+++ /dev/null
@@ -1,7 +0,0 @@
-stub/true
-stub/dependency/bad
-# stub_package
-stub/requirement/good
-stub/requirement/bad
-stub/multilevel
-stub/multilevel.*
diff --git a/plainbox/impl/providers/stubbox/whitelists/stub2.whitelist b/plainbox/impl/providers/stubbox/whitelists/stub2.whitelist
deleted file mode 100644
index 7785d21..0000000
--- a/plainbox/impl/providers/stubbox/whitelists/stub2.whitelist
+++ /dev/null
@@ -1,7 +0,0 @@
-stub/false
-stub/dependency/good
-stub/dependency/bad
-# stub_package
-stub/manual
-__local__
-stub/local/true
diff --git a/plainbox/impl/result.py b/plainbox/impl/result.py
index ec325e6..e31b069 100644
--- a/plainbox/impl/result.py
+++ b/plainbox/impl/result.py
@@ -461,30 +461,6 @@ class MemoryJobResult(_JobResultBase):
                     " or special the IOLogRecord tuple")
 
 
-class GzipFile(gzip.GzipFile):
-
-    """
-    Subclass of GzipFile that works around missing read1() on python3.2.
-
-    See: http://bugs.python.org/issue10791
-    """
-
-    def _read_gzip_header(self):
-        """
-        Ignore the non-compressed garbage at the end of the file
-
-        See: https://bugs.python.org/issue24301
-        """
-
-        try:
-            return super()._read_gzip_header()
-        except OSError:
-            return False
-
-    def read1(self, n):
-        return self.read(n)
-
-
 class DiskJobResult(_JobResultBase):
 
     """
@@ -505,7 +481,7 @@ class DiskJobResult(_JobResultBase):
     def get_io_log(self):
         record_path = self.io_log_filename
         if record_path:
-            with GzipFile(record_path, mode='rb') as gzip_stream, \
+            with gzip.GzipFile(record_path, mode='rb') as gzip_stream, \
                     io.TextIOWrapper(gzip_stream, encoding='UTF-8') as stream:
                 for record in IOLogRecordReader(stream):
                     yield record
diff --git a/plainbox/impl/runner.py b/plainbox/impl/runner.py
index 8c22892..e5a6e28 100644
--- a/plainbox/impl/runner.py
+++ b/plainbox/impl/runner.py
@@ -275,7 +275,7 @@ class JobRunner(IJobRunner):
     """
 
     # List of plugins that are still executed
-    _DRY_RUN_PLUGINS = ('local', 'resource', 'attachment')
+    _DRY_RUN_PLUGINS = ('resource', 'attachment')
 
     def __init__(self, session_dir, provider_list, jobs_io_log_dir,
                  command_io_delegate=None, dry_run=False,
@@ -520,32 +520,6 @@ class JobRunner(IJobRunner):
                 job, job_state, config).get_result()
         return result
 
-    def run_local_job(self, job, job_state, config):
-        """
-        Method called to run a job with plugin field equal to 'local'.
-
-        The 'local' job implements the following scenario:
-
-        * Maybe display the description to the user
-        * The API states that :meth:`JobRunner.run_job()` should only be
-          called at this time.
-        * Run the command and wait for it to finish
-        * Decide on the outcome based on the return code
-        * The method ends here
-
-        .. note::
-            Local jobs are similar to resource jobs, in that the output matters
-            more than the return code. Unlike resource jobs and attachment
-            jobs, the output is expected to be a job definition in the
-            canonical RFC822 format. Local jobs are discouraged (due to some
-            complexities they introduce) but only supported way of generating
-            additional jobs at runtime.
-        """
-        if job.plugin != "local":
-            # TRANSLATORS: please keep 'plugin' untranslated
-            raise ValueError(_("bad job plugin value"))
-        return self._just_run_command(job, job_state, config).get_result()
-
     def run_manual_job(self, job, job_state, config):
         """
         Method called to run a job with plugin field equal to 'manual'.
@@ -741,7 +715,7 @@ class JobRunner(IJobRunner):
         delegate, io_log_gen = self._prepare_io_handling(job, config)
         # Create a subprocess.Popen() like object that uses the delegate
         # system to observe all IO as it occurs in real time.
-        delegate_cls = self._get_delegate_cls(config)
+        delegate_cls = extcmd.ExternalCommandWithDelegate
         extcmd_popen = delegate_cls(delegate)
         # Stream all IOLogRecord entries to disk
         record_path = self.get_record_path_for_job(job)
@@ -892,7 +866,7 @@ class JobRunner(IJobRunner):
         delegate, io_log_gen = self._prepare_io_handling(job, config)
         # Create a subprocess.Popen() like object that uses the delegate
         # system to observe all IO as it occurs in real time.
-        delegate_cls = self._get_delegate_cls(config)
+        delegate_cls = extcmd.ExternalCommandWithDelegate
         flags = 0
         # Use chunked IO for jobs that explicitly request this
         if 'use-chunked-io' in job.get_flag_set():
@@ -996,14 +970,3 @@ class JobRunner(IJobRunner):
             logger.warning(
                 _("Please store desired files in $PLAINBOX_SESSION_SHARE and"
                   " use regular temporary files for everything else"))
-
-    def _get_delegate_cls(self, config):
-        if (sys.version_info[0:2] >= (3, 4) and sys.platform == 'linux'
-                and config.extcmd == "glibc"):
-            logger.debug("Using glibc-based command runner")
-            from plainbox.vendor.extcmd.glibc import (
-                GlibcExternalCommandWithDelegate)
-            return GlibcExternalCommandWithDelegate
-        else:
-            logger.debug("Using classic thread-based command runner")
-            return extcmd.ExternalCommandWithDelegate
diff --git a/plainbox/impl/secure/launcher1.py b/plainbox/impl/secure/launcher1.py
index eaa1a8e..9515cc1 100644
--- a/plainbox/impl/secure/launcher1.py
+++ b/plainbox/impl/secure/launcher1.py
@@ -121,11 +121,7 @@ class TrustedLauncher:
             logging.error(
                 _("Syntax error in record generated from %s: %s"), job, exc)
         else:
-            if job.plugin == 'local':
-                for record in record_list:
-                    job = JobDefinition.from_rfc822_record(record)
-                    job_list.append(job)
-            elif job.plugin == 'resource':
+            if job.plugin == 'resource':
                 resource_list = []
                 for record in record_list:
                     resource = Resource(record.data)
@@ -209,9 +205,9 @@ def get_parser_for_sphinx():
     group.add_argument(
         '-g', '--generator',
         metavar=_('CHECKSUM'),
-        # TRANSLATORS: don't translate 'local' in the sentence below. It
-        # denotes a special type of job, not its location.
-        help=_('also run a job with this checksum (assuming it is a local'
+        # TRANSLATORS: don't translate 'resource' in the sentence below. It
+        # denotes a special type of job.
+        help=_('also run a job with this checksum (assuming it is a resource'
                ' job)'))
     group.add_argument(
         '-G', '--generator-environment',
@@ -266,7 +262,7 @@ def main(argv=None):
     all_providers.load()
     for plugin in all_providers.get_all_plugins():
         launcher.add_job_list(plugin.plugin_object.job_list)
-    # Run the local job and feed the result back to the launcher
+    # Run the generator job and feed the result back to the launcher
     if ns.generator:
         try:
             generated_job_list = launcher.run_generator_job(
diff --git a/plainbox/impl/secure/providers/__init__.py b/plainbox/impl/secure/providers/__init__.py
index 8808022..066d2ee 100644
--- a/plainbox/impl/secure/providers/__init__.py
+++ b/plainbox/impl/secure/providers/__init__.py
@@ -21,18 +21,10 @@
 :mod:`plainbox.impl.secure.providers` -- providers package
 ==========================================================
 
-Providers are a mechanism by which PlainBox can enumerate jobs and whitelists.
+Providers are a mechanism by which PlainBox can enumerate jobs and test plans.
 Currently there are only v1 (as in version one) providers that basically have
 to behave as CheckBox itself (mini CheckBox forks for example)
 
-There is ongoing work and discussion on V2 providers that would have a
-lower-level interface and would be able to define new job types, new whitelist
-types and generally all the next-gen semantics.
-
-PlainBox does not come with any real provider by default. PlainBox sometimes
-creates special dummy providers that have particular data in them for testing.
-
-
 V1 providers
 ------------
 
@@ -42,9 +34,6 @@ this is also described by :class:`plainbox.abc.IProvider1`::
     * there is a directory with '.txt' or '.txt.in' files with RFC822-encoded
       job definitions. The definitions need a particular set of keys to work.
 
-    * there is a directory with '.whitelist' files that contain a list (one per
-      line) of job definitions to execute.
-
     * there is a directory with additional executables (added to PATH)
 
     * there is a directory with an additional python3 libraries (added to
diff --git a/plainbox/impl/secure/providers/test_v1.py b/plainbox/impl/secure/providers/test_v1.py
index d54a3c2..b0eb001 100644
--- a/plainbox/impl/secure/providers/test_v1.py
+++ b/plainbox/impl/secure/providers/test_v1.py
@@ -37,8 +37,6 @@ from plainbox.impl.secure.providers.v1 import Provider1Definition
 from plainbox.impl.secure.providers.v1 import Provider1PlugIn
 from plainbox.impl.secure.providers.v1 import UnitPlugIn
 from plainbox.impl.secure.providers.v1 import VersionValidator
-from plainbox.impl.secure.providers.v1 import WhiteListPlugIn
-from plainbox.impl.secure.qualifiers import WhiteList
 from plainbox.impl.secure.rfc822 import FileTextSource
 from plainbox.impl.secure.rfc822 import Origin
 from plainbox.impl.unit.file import FileUnit
@@ -156,7 +154,6 @@ class Provider1DefinitionTests(TestCase):
                 "gettext_domain = domain\n"
                 "units_dir = /some/directory/units\n"
                 "jobs_dir = /some/directory/jobs\n"
-                "whitelists_dir = /some/directory/whitelists\n"
                 "data_dir = /some/directory/data\n"
                 "bin_dir = /some/directory/bin\n"
                 "locale_dir = /some/directory/locale\n"
@@ -168,7 +165,6 @@ class Provider1DefinitionTests(TestCase):
         self.assertEqual(def_.location, Unset)
         self.assertEqual(def_.units_dir, "/some/directory/units")
         self.assertEqual(def_.jobs_dir, "/some/directory/jobs")
-        self.assertEqual(def_.whitelists_dir, "/some/directory/whitelists")
         self.assertEqual(def_.data_dir, "/some/directory/data")
         self.assertEqual(def_.bin_dir, "/some/directory/bin")
         self.assertEqual(def_.locale_dir, "/some/directory/locale")
@@ -211,7 +207,6 @@ class Provider1DefinitionTests(TestCase):
         self.assertEqual(def_.location, "/some/directory")
         self.assertEqual(def_.units_dir, Unset)
         self.assertEqual(def_.jobs_dir, Unset)
-        self.assertEqual(def_.whitelists_dir, Unset)
         self.assertEqual(def_.data_dir, Unset)
         self.assertEqual(def_.bin_dir, Unset)
         self.assertEqual(def_.locale_dir, Unset)
@@ -369,11 +364,11 @@ class Provider1DefinitionTests(TestCase):
 
     def test_init_validation__foo_dir_unset(self):
         """
-        verify that Provider1Definition allows 'jobs_dir', 'whitelists_dir',
-        'data_dir', 'bin_dir' and 'locale_dir'  fields to be unset
+        verify that Provider1Definition allows 'jobs_dir', 'data_dir',
+        'bin_dir' and 'locale_dir'  fields to be unset
         """
-        for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
-                     'bin_dir', 'locale_dir'):
+        for attr in ('units_dir', 'jobs_dir', 'data_dir', 'bin_dir',
+                     'locale_dir'):
             def_ = Provider1Definition()
             setattr(def_, attr, Unset)
             self.assertEqual(getattr(def_, attr), Unset)
@@ -381,11 +376,10 @@ class Provider1DefinitionTests(TestCase):
     def test_init_validation__foo_dir_is_empty(self):
         """
         verify that Provider1Definition ensures that 'jobs_dir',
-        'whitelists_dir', 'data_dir', 'bin_dir' and 'locale_dir' fields are not
-        empty
+        'data_dir', 'bin_dir' and 'locale_dir' fields are not empty
         """
-        for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
-                     'bin_dir', 'locale_dir'):
+        for attr in ('units_dir', 'jobs_dir', 'data_dir', 'bin_dir',
+                     'locale_dir'):
             def_ = Provider1Definition()
             with self.assertRaises(ValidationError) as boom:
                 setattr(def_, attr, '')
@@ -394,11 +388,11 @@ class Provider1DefinitionTests(TestCase):
     def test_init_validation__foo_dir_relative(self):
         """
         verify that Provider1Definition ensures that 'jobs_dir',
-        'whitelists_dir', 'data_dir', 'bin_dir' and 'locale_dir' fields are not
-        a relative pathname
+        'data_dir', 'bin_dir' and 'locale_dir' fields are not a relative
+        pathname
         """
-        for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
-                     'bin_dir', 'locale_dir'):
+        for attr in ('units_dir', 'jobs_dir', 'data_dir', 'bin_dir',
+                     'locale_dir'):
             def_ = Provider1Definition()
             with self.assertRaises(ValidationError) as boom:
                 setattr(def_, attr, 'some/place')
@@ -407,11 +401,11 @@ class Provider1DefinitionTests(TestCase):
     def test_init_validation__foo_dir_doesnt_exist(self):
         """
         verify that Provider1Definition ensures that 'jobs_dir',
-        'whitelists_dir', 'data_dir', 'bin_dir' and 'locale_dir' fields are not
-        pointing to a non-existing directory
+        'data_dir', 'bin_dir' and 'locale_dir' fields are not pointing to a
+        non-existing directory
         """
-        for attr in ('units_dir', 'jobs_dir', 'whitelists_dir', 'data_dir',
-                     'bin_dir', 'locale_dir'):
+        for attr in ('units_dir', 'jobs_dir', 'data_dir', 'bin_dir',
+                     'locale_dir'):
             def_ = Provider1Definition()
             with self.assertRaises(ValidationError) as boom:
                 with mock.patch('os.path.isdir') as mock_isdir:
@@ -437,7 +431,6 @@ class Provider1PlugInTests(TestCase):
     DEF_TEXT_w_dirs = DEF_TEXT + (
         "units_dir = /some/directory/units\n"
         "jobs_dir = /some/directory/jobs\n"
-        "whitelists_dir = /some/directory/whitelists\n"
         "data_dir = /some/directory/data\n"
         "bin_dir = /some/directory/bin\n"
         "locale_dir = /some/directory/locale\n"
@@ -488,7 +481,6 @@ class Provider1PlugInTests(TestCase):
         provider = self.plugin.plugin_object
         self.assertEqual(provider.units_dir, None)
         self.assertEqual(provider.jobs_dir, None)
-        self.assertEqual(provider.whitelists_dir, None)
         self.assertEqual(provider.data_dir, None)
         self.assertEqual(provider.bin_dir, None)
         self.assertEqual(provider.build_bin_dir, None)
@@ -505,7 +497,6 @@ class Provider1PlugInTests(TestCase):
         provider = self.plugin_w_location.plugin_object
         self.assertEqual(provider.units_dir, "/some/directory/units")
         self.assertEqual(provider.jobs_dir, "/some/directory/jobs")
-        self.assertEqual(provider.whitelists_dir, "/some/directory/whitelists")
         self.assertEqual(provider.data_dir, "/some/directory/data")
         self.assertEqual(provider.bin_dir, "/some/directory/bin")
         self.assertEqual(provider.build_bin_dir, "/some/directory/build/bin")
@@ -523,7 +514,6 @@ class Provider1PlugInTests(TestCase):
         provider = self.plugin_w_location_w_no_dirs.plugin_object
         self.assertEqual(provider.units_dir, None)
         self.assertEqual(provider.jobs_dir, None)
-        self.assertEqual(provider.whitelists_dir, None)
         self.assertEqual(provider.data_dir, None)
         self.assertEqual(provider.bin_dir, None)
         self.assertEqual(provider.build_bin_dir, "/some/directory/build/bin")
@@ -539,7 +529,6 @@ class Provider1PlugInTests(TestCase):
         provider = self.plugin_w_dirs.plugin_object
         self.assertEqual(provider.units_dir, "/some/directory/units")
         self.assertEqual(provider.jobs_dir, "/some/directory/jobs")
-        self.assertEqual(provider.whitelists_dir, "/some/directory/whitelists")
         self.assertEqual(provider.data_dir, "/some/directory/data")
         self.assertEqual(provider.bin_dir, "/some/directory/bin")
         self.assertEqual(provider.build_bin_dir, None)
@@ -548,62 +537,6 @@ class Provider1PlugInTests(TestCase):
         self.assertEqual(provider.base_dir, None)
 
 
-class WhiteListPlugInTests(TestCase):
-    """
-    Tests for WhiteListPlugIn
-    """
-
-    LOAD_TIME = 42
-
-    def setUp(self):
-        self.plugin = WhiteListPlugIn(
-            "/path/to/some.whitelist", "foo\nbar\n", self.LOAD_TIME)
-
-    def test_plugin_name(self):
-        """
-        verify that the WhiteListPlugIn.plugin_name property returns
-        WhiteList.name
-        """
-        self.assertEqual(self.plugin.plugin_name, "some")
-
-    def test_plugin_object(self):
-        """
-        verify that the WhiteListPlugIn.plugin_object property returns a
-        WhiteList
-        """
-        self.assertIsInstance(self.plugin.plugin_object, WhiteList)
-
-    def test_plugin_load_time(self):
-        self.assertEqual(self.plugin.plugin_load_time, self.LOAD_TIME)
-
-    def test_whitelist_data(self):
-        """
-        verify the contents of the loaded whitelist object
-        """
-        self.assertEqual(
-            self.plugin.plugin_object.qualifier_list[0].pattern_text, "^foo$")
-        self.assertEqual(
-            self.plugin.plugin_object.qualifier_list[1].pattern_text, "^bar$")
-        self.assertEqual(self.plugin.plugin_object.name, 'some')
-        self.assertEqual(
-            self.plugin.plugin_object.origin,
-            Origin(FileTextSource('/path/to/some.whitelist'), 1, 2))
-
-    def test_init_failing(self):
-        """
-        verify how WhiteList() initializer works if something is wrong
-        """
-        # The pattern is purposefully invalid
-        with self.assertRaises(PlugInError) as boom:
-            WhiteListPlugIn("/path/to/some.whitelist", "*", self.LOAD_TIME)
-        # NOTE: we should have syntax error for whitelists that keeps track or
-        # line we're at to help developers figure out where errors such as this
-        # are coming from.
-        self.assertEqual(
-            str(boom.exception),
-            ("Cannot load '/path/to/some.whitelist': nothing to repeat"))
-
-
 class UnitPlugInTests(TestCase):
     """
     Tests for UnitPlugIn
@@ -686,7 +619,6 @@ class Provider1Tests(TestCase):
     GETTEXT_DOMAIN = "domain"
     UNITS_DIR = "units-dir"
     JOBS_DIR = "jobs-dir"
-    WHITELISTS_DIR = "whitelists-dir"
     DATA_DIR = "data-dir"
     BIN_DIR = "bin-dir"
     LOCALE_DIR = "locale-dir"
@@ -698,8 +630,7 @@ class Provider1Tests(TestCase):
         self.provider = Provider1(
             self.NAME, self.NAMESPACE, self.VERSION, self.DESCRIPTION,
             self.SECURE, self.GETTEXT_DOMAIN, self.UNITS_DIR, self.JOBS_DIR,
-            self.WHITELISTS_DIR, self.DATA_DIR, self.BIN_DIR, self.LOCALE_DIR,
-            self.BASE_DIR,
+            self.DATA_DIR, self.BIN_DIR, self.LOCALE_DIR, self.BASE_DIR,
             # We are using dummy job definitions so let's not shout about those
             # being invalid in each test
             validate=False)
@@ -762,12 +693,6 @@ class Provider1Tests(TestCase):
         """
         self.assertEqual(self.provider.jobs_dir, self.JOBS_DIR)
 
-    def test_whitelists_dir(self):
-        """
-        Verify that Provider1.whitelists_dir attribute is set correctly
-        """
-        self.assertEqual(self.provider.whitelists_dir, self.WHITELISTS_DIR)
-
     def test_data_dir(self):
         """
         Verify that Provider1.data_dir attribute is set correctly
@@ -901,8 +826,7 @@ class Provider1Tests(TestCase):
         Provider1(
             self.NAME, self.NAMESPACE, self.VERSION, self.DESCRIPTION,
             self.SECURE, self.GETTEXT_DOMAIN, self.UNITS_DIR, self.JOBS_DIR,
-            self.WHITELISTS_DIR, self.DATA_DIR, self.BIN_DIR, self.LOCALE_DIR,
-            self.BASE_DIR)
+            self.DATA_DIR, self.BIN_DIR, self.LOCALE_DIR, self.BASE_DIR)
         mock_gettext.bindtextdomain.assert_called_once_with(
             self.GETTEXT_DOMAIN, self.LOCALE_DIR)
 
@@ -915,6 +839,6 @@ class Provider1Tests(TestCase):
         Provider1(
             self.NAME, self.NAMESPACE, self.VERSION, self.DESCRIPTION,
             self.SECURE, self.GETTEXT_DOMAIN, self.UNITS_DIR, self.JOBS_DIR,
-            self.WHITELISTS_DIR, self.DATA_DIR, self.BIN_DIR, locale_dir=None,
+            self.DATA_DIR, self.BIN_DIR, locale_dir=None,
             base_dir=self.BASE_DIR)
         self.assertEqual(mock_gettext.bindtextdomain.call_args_list, [])
diff --git a/plainbox/impl/secure/providers/v1.py b/plainbox/impl/secure/providers/v1.py
index f1a6e58..18d3213 100644
--- a/plainbox/impl/secure/providers/v1.py
+++ b/plainbox/impl/secure/providers/v1.py
@@ -44,7 +44,6 @@ from plainbox.impl.secure.plugins import LazyFsPlugInCollection
 from plainbox.impl.secure.plugins import PlugIn
 from plainbox.impl.secure.plugins import PlugInError
 from plainbox.impl.secure.plugins import now
-from plainbox.impl.secure.qualifiers import WhiteList
 from plainbox.impl.secure.rfc822 import FileTextSource
 from plainbox.impl.secure.rfc822 import RFC822SyntaxError
 from plainbox.impl.secure.rfc822 import load_rfc822_records
@@ -63,17 +62,14 @@ class ProviderContentPlugIn(PlugIn):
     """
     PlugIn class for loading provider content.
 
-    Provider content comes in two shapes and sizes:
+    Provider content:
         - units (of any kind)
-        - whitelists
 
     The actual logic on how to load everything is encapsulated in
     :meth:`wrap()` though its return value is not so useful.
 
     :attr unit_list:
         The list of loaded units
-    :attr whitelist_list:
-        The list of loaded whitelists
     """
 
     def __init__(self, filename, text, load_time, provider, *,
@@ -94,12 +90,9 @@ class ProviderContentPlugIn(PlugIn):
         wrap_time = now() - start_time
         super().__init__(filename, inspect_result, load_time, wrap_time)
         self.unit_list = []
-        self.whitelist_list = []
         # And load all of the content from that file
         self.unit_list.extend(self.discover_units(
             inspect_result, filename, text, provider))
-        self.whitelist_list.extend(self.discover_whitelists(
-            inspect_result, filename, text, provider))
 
     def inspect(self, filename: str, text: str, provider: "Provider1",
                 validate: bool, validation_kwargs: "Dict[str, Any]", check:
@@ -110,9 +103,8 @@ class ProviderContentPlugIn(PlugIn):
         :meth:`plugin_object`
 
         .. note::
-            This method must *not* access neither :attr:`unit_list` nor
-            :attr:`whitelist_list`. If needed, it can collect its own state in
-            private instance attributes.
+            This method must *not* access :attr:`unit_list`. If needed, it can
+            collect its own state in private instance attributes.
         """
 
     def discover_units(
@@ -132,23 +124,6 @@ class ProviderContentPlugIn(PlugIn):
         """
         yield self.make_file_unit(filename, provider)
 
-    def discover_whitelists(
-        self, inspect_result: "Any", filename: str, text: str,
-        provider: "Provider1"
-    ) -> "Iterable[WhiteList]":
-        """
-        Discover all whitelists that were loaded by this plug-in
-
-        :param wrap_result:
-            whatever was returned on the call to :meth:`wrap()`.
-        :returns:
-            an iterable of whitelists.
-
-        .. note::
-            this method is always called *after* :meth:`wrap()`.
-        """
-        return ()
-
     def make_file_unit(self, filename, provider, role=None, base=None):
         if role is None or base is None:
             role, base, plugin_cls = provider.classify(filename)
@@ -161,71 +136,6 @@ class ProviderContentPlugIn(PlugIn):
             virtual=True)
 
 
-class WhiteListPlugIn(ProviderContentPlugIn):
-    """
-    A specialized :class:`plainbox.impl.secure.plugins.IPlugIn` that loads
-    :class:`plainbox.impl.secure.qualifiers.WhiteList` instances from a file.
-    """
-
-    def inspect(self, filename: str, text: str, provider: "Provider1",
-                validate: bool, validation_kwargs: "Dict[str, Any]", check:
-                bool, context: "???") -> "WhiteList":
-        if provider is not None:
-            implicit_namespace = provider.namespace
-        else:
-            implicit_namespace = None
-        origin = Origin(FileTextSource(filename), 1, text.count('\n'))
-        return WhiteList.from_string(
-            text, filename=filename, origin=origin,
-            implicit_namespace=implicit_namespace)
-
-    def discover_units(
-        self, inspect_result: "WhiteList", filename: str, text: str,
-        provider: "Provider1"
-    ) -> "Iterable[Unit]":
-        if provider is not None:
-            yield self.make_file_unit(
-                filename, provider,
-                # NOTE: don't guess what this file is for
-                role=FileRole.legacy_whitelist, base=provider.whitelists_dir)
-            yield self.make_test_plan_unit(filename, text, provider)
-
-    def discover_whitelists(
-        self, inspect_result: "WhiteList", filename: str, text: str,
-        provider: "Provider1"
-    ) -> "Iterable[WhiteList]":
-        yield inspect_result
-
-    def make_test_plan_unit(self, filename, text, provider):
-        name = os.path.basename(os.path.splitext(filename)[0])
-        origin = Origin(FileTextSource(filename), 1, text.count('\n'))
-        field_offset_map = {'include': 0}
-        return TestPlanUnit({
-            'unit': TestPlanUnit.Meta.name,
-            'id': name,
-            'name': name,
-            'include': str(text),  # delazify content
-        }, origin=origin, provider=provider, field_offset_map=field_offset_map,
-            virtual=True)
-
-    # NOTE: This version of __init__() exists solely so that provider can
-    # default to None. This is still used in some places and must be supported.
-    def __init__(self, filename, text, load_time, provider=None, *,
-                 validate=False, validation_kwargs=None,
-                 check=True, context=None):
-        super().__init__(
-            filename, text, load_time, provider, validate=validate,
-            validation_kwargs=validation_kwargs, check=check, context=context)
-
-    # NOTE: this version of plugin_name() is just for legacy code support
-    @property
-    def plugin_name(self):
-        """
-        plugin name, the name of the WhiteList
-        """
-        return self.plugin_object.name
-
-
 class UnitPlugIn(ProviderContentPlugIn):
     """
     A specialized :class:`plainbox.impl.secure.plugins.IPlugIn` that loads a
@@ -307,23 +217,6 @@ class UnitPlugIn(ProviderContentPlugIn):
             yield unit
         yield self.make_file_unit(filename, provider)
 
-    def discover_whitelists(
-        self, inspect_result: "List[Unit]", filename: str, text: str,
-        provider: "Provider1"
-    ) -> "Iterable[WhiteList]":
-        for unit in (unit for unit in inspect_result
-                     if unit.Meta.name == 'test plan'):
-            if unit.include is not None:
-                patterns = []
-                for line in unit.include.split('\n'):
-                    if '#' in line:
-                        line = line.split('#')[0]
-                    if line:
-                        patterns.append('${}^'.format(line))
-                yield WhiteList(
-                    patterns, name=unit.partial_id, origin=unit.origin,
-                    implicit_namespace=unit.provider.namespace)
-
     # NOTE: this version of plugin_object() is just for legacy code support
     @property
     def plugin_object(self):
@@ -393,8 +286,6 @@ class ProviderContentEnumerator:
                 dir_list.append(provider.bin_dir)
             if provider.locale_dir:
                 dir_list.append(provider.locale_dir)
-            if provider.whitelists_dir:
-                dir_list.append(provider.whitelists_dir)
         # Find all the files that belong to a provider
         self._content_collection = LazyFsPlugInCollection(
             dir_list, ext=None, recursive=True)
@@ -429,8 +320,7 @@ class ProviderContentClassifier:
 
     The secondary role is to provide a hint on what PlugIn to use to load such
     content (as units). In practice the majority of files are loaded with the
-    :class:`UnitPlugIn` class. Legacy ``.whitelist`` files are loaded with the
-    :class:`WhiteListPlugIn` class instead. All other files are handled by the
+    :class:`UnitPlugIn` class. All other files are handled by the
     :class:`ProviderContentPlugIn`.
 
     .. note::
@@ -508,8 +398,6 @@ class ProviderContentClassifier:
             classify_fn_list.append(self._classify_pxu_jobs)
         if self.provider.units_dir:
             classify_fn_list.append(self._classify_pxu_units)
-        if self.provider.whitelists_dir:
-            classify_fn_list.append(self._classify_whitelist)
         if self.provider.data_dir:
             classify_fn_list.append(self._classify_data)
         if self.provider.bin_dir:
@@ -568,13 +456,6 @@ class ProviderContentClassifier:
                 return (FileRole.unit_source, self.provider.units_dir,
                         UnitPlugIn)
 
-    def _classify_whitelist(self, filename: str):
-        """ classify .whitelist files in whitelist_dir as whitelist """
-        if (filename.startswith(self.provider.whitelists_dir) and
-                filename.endswith(".whitelist")):
-            return (FileRole.legacy_whitelist, self.provider.whitelists_dir,
-                    WhiteListPlugIn)
-
     def _classify_data(self, filename: str):
         """ classify files in data_dir as data """
         if filename.startswith(self.provider.data_dir):
@@ -676,7 +557,7 @@ class ProviderContentLoader:
     :attr is_loaded:
         Flag indicating if the content loader has loaded all of the content
     :attr unit_list:
-        A list of loaded whitelist objects
+        A list of loaded units objects
     :attr problem_list:
         A list of problems experienced while loading any of the content
     :attr path_map:
@@ -691,7 +572,6 @@ class ProviderContentLoader:
         self.provider = provider
         self.is_loaded = False
         self.unit_list = []
-        self.whitelist_list = []
         self.problem_list = []
         self.path_map = collections.defaultdict(list)  # path -> list(unit)
         self.id_map = collections.defaultdict(list)  # id -> list(unit)
@@ -720,7 +600,6 @@ class ProviderContentLoader:
             self.problem_list.append(exc)
         else:
             self.unit_list.extend(plugin.unit_list)
-            self.whitelist_list.extend(plugin.whitelist_list)
             for unit in plugin.unit_list:
                 if hasattr(unit.Meta.fields, 'id'):
                     self.id_map[unit.id].append(unit)
@@ -732,7 +611,7 @@ class Provider1(IProvider1):
     """
     A v1 provider implementation.
 
-    A provider is a container of jobs and whitelists. It provides additional
+    A provider is a container of jobs and test plans. It provides additional
     meta-data and knows about location of essential directories to both load
     structured data and provide runtime information for job execution.
 
@@ -741,8 +620,8 @@ class Provider1(IProvider1):
     """
 
     def __init__(self, name, namespace, version, description, secure,
-                 gettext_domain, units_dir, jobs_dir, whitelists_dir, data_dir,
-                 bin_dir, locale_dir, base_dir, *, validate=False,
+                 gettext_domain, units_dir, jobs_dir, data_dir, bin_dir,
+                 locale_dir, base_dir, *, validate=False,
                  validation_kwargs=None, check=True, context=None):
         """
         Initialize a provider with a set of meta-data and directories.
@@ -778,9 +657,6 @@ class Provider1(IProvider1):
         :param jobs_dir:
             path of the directory with job definitions
 
-        :param whitelists_dir:
-            path of the directory with whitelists definitions (aka test-plans)
-
         :param data_dir:
             path of the directory with files used by jobs at runtime
 
@@ -791,8 +667,8 @@ class Provider1(IProvider1):
             path of the directory with locale database (translation catalogs)
 
         :param base_dir:
-            path of the directory with (perhaps) all of jobs_dir,
-            whitelists_dir, data_dir, bin_dir, locale_dir. This may be None.
+            path of the directory with (perhaps) all of jobs_dir, data_dir,
+            bin_dir, locale_dir. This may be None.
             This is also the effective value of $CHECKBOX_SHARE
 
         :param validate:
@@ -820,7 +696,6 @@ class Provider1(IProvider1):
         # Directories
         self._units_dir = units_dir
         self._jobs_dir = jobs_dir
-        self._whitelists_dir = whitelists_dir
         self._data_dir = data_dir
         self._bin_dir = bin_dir
         self._locale_dir = locale_dir
@@ -843,9 +718,6 @@ class Provider1(IProvider1):
         if not self._loader.is_loaded:
             self._loader.load(self._load_kwargs)
 
-    def _load_whitelists(self):
-        self._ensure_loaded()
-
     def _load_units(self, validate, validation_kwargs, check, context):
         self._ensure_loaded()
 
@@ -890,10 +762,10 @@ class Provider1(IProvider1):
             definition.description, secure,
             definition.effective_gettext_domain,
             definition.effective_units_dir, definition.effective_jobs_dir,
-            definition.effective_whitelists_dir, definition.effective_data_dir,
-            definition.effective_bin_dir, definition.effective_locale_dir,
-            definition.location or None, validate=validate,
-            validation_kwargs=validation_kwargs, check=check, context=context)
+            definition.effective_data_dir, definition.effective_bin_dir,
+            definition.effective_locale_dir, definition.location or None,
+            validate=validate, validation_kwargs=validation_kwargs,
+            check=check, context=context)
 
     def __repr__(self):
         return "<{} name:{!r}>".format(self.__class__.__name__, self.name)
@@ -966,13 +838,6 @@ class Provider1(IProvider1):
         return self._jobs_dir
 
     @property
-    def whitelists_dir(self):
-        """
-        absolute path of the whitelist directory
-        """
-        return self._whitelists_dir
-
-    @property
     def data_dir(self):
         """
         absolute path of the data directory
@@ -1002,8 +867,8 @@ class Provider1(IProvider1):
     @property
     def base_dir(self):
         """
-        path of the directory with (perhaps) all of jobs_dir, whitelists_dir,
-        data_dir, bin_dir, locale_dir. This may be None
+        path of the directory with (perhaps) all of jobs_dir, data_dir,
+        bin_dir, locale_dir. This may be None
         """
         return self._base_dir
 
@@ -1136,20 +1001,6 @@ class Provider1(IProvider1):
             unit.role in (FileRole.script, FileRole.binary))
 
     @property
-    def whitelist_list(self):
-        """
-        List of loaded whitelists.
-
-        .. warning::
-            :class:`WhiteList` is currently deprecated. You should never need
-            to access them in any new code.  They are entirely replaced by
-            :class:`TestPlan`. This property is provided for completeness and
-            it will be **removed** once whitelists classes are no longer used.
-        """
-        self._ensure_loaded()
-        return self._loader.whitelist_list
-
-    @property
     def problem_list(self):
         """
         list of problems encountered by the loading process
@@ -1506,43 +1357,6 @@ class Provider1Definition(Config):
         if implicit is not None and os.path.isdir(implicit):
             return implicit
 
-    whitelists_dir = Variable(
-        section='PlainBox Provider',
-        help_text=_("Pathname of the directory with whitelists definitions"),
-        validator_list=[
-            # NOTE: it *can* be unset
-            NotEmptyValidator(),
-            AbsolutePathValidator(),
-            ExistingDirectoryValidator(),
-        ])
-
-    @property
-    def implicit_whitelists_dir(self):
-        """
-        implicit value of whitelists_dir (if Unset)
-
-        The implicit value is only defined if location is not Unset. It is the
-        'whitelists' subdirectory of the directory that location points to.
-        """
-        if self.location is not Unset:
-            return os.path.join(self.location, "whitelists")
-
-    @property
-    def effective_whitelists_dir(self):
-        """
-        effective value of whitelists_dir
-
-        The effective value is :meth:`whitelists_dir` itself, unless it is
-        Unset. If it is Unset the effective value is the
-        :meth:`implicit_whitelists_dir`, if that value would be valid. The
-        effective value may be None.
-        """
-        if self.whitelists_dir is not Unset:
-            return self.whitelists_dir
-        implicit = self.implicit_whitelists_dir
-        if implicit is not None and os.path.isdir(implicit):
-            return implicit
-
     data_dir = Variable(
         section='PlainBox Provider',
         help_text=_("Pathname of the directory with provider data"),
@@ -1708,7 +1522,6 @@ class Provider1PlugIn(PlugIn):
             definition.location = os.path.dirname(filename)
             definition.units_dir = Unset
             definition.jobs_dir = Unset
-            definition.whitelists_dir = Unset
             definition.data_dir = Unset
             definition.bin_dir = Unset
             definition.locale_dir = Unset
diff --git a/plainbox/impl/secure/qualifiers.py b/plainbox/impl/secure/qualifiers.py
index 773d953..d1ee659 100644
--- a/plainbox/impl/secure/qualifiers.py
+++ b/plainbox/impl/secure/qualifiers.py
@@ -210,28 +210,6 @@ class JobIdQualifier(SimpleQualifier):
             self.__class__.__name__, self._id, self._inclusive)
 
 
-class NonLocalJobQualifier(SimpleQualifier):
-    """
-    A JobQualifier that designates only non local jobs
-    """
-
-    def __init__(self, origin, inclusive=True):
-        super().__init__(origin, inclusive)
-
-    def get_simple_match(self, job):
-        """
-        Check if the given job matches this qualifier.
-
-        This method should not be called directly, it is an implementation
-        detail of SimpleQualifier class.
-        """
-        return job.plugin != 'local'
-
-    def __repr__(self):
-        return "{0}(inclusive={1})".format(
-            self.__class__.__name__, self._inclusive)
-
-
 class IMatcher(metaclass=abc.ABCMeta):
     """
     Interface for objects that perform some kind of comparison on a value
@@ -441,206 +419,6 @@ class NonPrimitiveQualifierOrigin(Exception):
     """
 
 
-# NOTE: using CompositeQualifier seems strange but it's a tested proven
-# component so all we have to ensure is that we read the whitelist files
-# correctly.
-class WhiteList(CompositeQualifier):
-    """
-    A qualifier that understands checkbox whitelist files.
-
-    A whitelist file is a plain text, line oriented file. Each line represents
-    a regular expression pattern that can be matched against the id of a job.
-
-    The file can contain simple shell-style comments that begin with the pound
-    or hash key (#). Those are ignored. Comments can span both a fraction of a
-    line as well as the whole line.
-
-    For historical reasons each pattern has an implicit '^' and '$' prepended
-    and appended (respectively) to the actual pattern specified in the file.
-    """
-
-    def __init__(self, pattern_list, name=None, origin=None,
-                 implicit_namespace=None):
-        """
-        Initialize a WhiteList object with the specified list of patterns.
-
-        The patterns must be already mangled with '^' and '$'.
-        """
-        self._name = name
-        self._origin = origin
-        self._implicit_namespace = implicit_namespace
-        if implicit_namespace is not None:
-            # If we have an implicit namespace then transform all the patterns
-            # without the namespace operator ('::')
-            namespace_pattern = implicit_namespace.replace('.', '\\.')
-
-            def transform_pattern(maybe_partial_id_pattern):
-                if "::" not in maybe_partial_id_pattern:
-                    return "^{}::{}$".format(
-                        namespace_pattern, maybe_partial_id_pattern[1:-1])
-                else:
-                    return maybe_partial_id_pattern
-            qualifier_list = [
-                RegExpJobQualifier(
-                    transform_pattern(pattern), origin, inclusive=True)
-                for pattern in pattern_list]
-        else:
-            # Otherwise just use the patterns directly
-            qualifier_list = [
-                RegExpJobQualifier(pattern, origin, inclusive=True)
-                for pattern in pattern_list]
-        super().__init__(qualifier_list)
-
-    def __repr__(self):
-        return "<{} name:{!r}>".format(self.__class__.__name__, self.name)
-
-    @property
-    def name(self):
-        """
-        name of this WhiteList (might be None)
-        """
-        return self._name
-
-    @name.setter
-    def name(self, value):
-        """
-        set a new name for a WhiteList
-        """
-        self._name = value
-
-    @property
-    def origin(self):
-        """
-        origin object associated with this WhiteList (might be None)
-        """
-        return self._origin
-
-    @property
-    def implicit_namespace(self):
-        """
-        namespace used to qualify patterns without explicit namespace
-        """
-        return self._implicit_namespace
-
-    @classmethod
-    def from_file(cls, pathname, implicit_namespace=None):
-        """
-        Load and initialize the WhiteList object from the specified file.
-
-        :param pathname:
-            file to load
-        :param implicit_namespace:
-            (optional) implicit namespace for jobs that are using partial
-            identifiers (all jobs)
-        :returns:
-            a fresh WhiteList object
-        """
-        pattern_list, max_lineno = cls._load_patterns(pathname)
-        name = os.path.splitext(os.path.basename(pathname))[0]
-        origin = Origin(FileTextSource(pathname), 1, max_lineno)
-        return cls(pattern_list, name, origin, implicit_namespace)
-
-    @classmethod
-    def from_string(cls, text, *, filename=None, name=None, origin=None,
-                    implicit_namespace=None):
-        """
-        Load and initialize the WhiteList object from the specified string.
-
-        :param text:
-            full text of the whitelist
-        :param filename:
-            (optional, keyword-only) filename from which text was read from.
-            This simulates a call to :meth:`from_file()` which properly
-            computes the name and origin of the whitelist.
-        :param name:
-            (optional) name of the whitelist, only used if filename is not
-            specified.
-        :param origin:
-            (optional) origin of the whitelist, only used if a filename is not
-            specified.  If omitted a default origin value will be constructed
-            out of UnknownTextSource instance
-        :param implicit_namespace:
-            (optional) implicit namespace for jobs that are using partial
-            identifiers (all jobs)
-        :returns:
-            a fresh WhiteList object
-
-        The optional filename or a pair of name and origin arguments may be
-        provided in order to have additional meta-data. This is typically
-        needed when the :meth:`from_file()` method cannot be used as the caller
-        already has the full text of the intended file available.
-        """
-        _logger.debug("Loaded whitelist from %r", filename)
-        pattern_list, max_lineno = cls._parse_patterns(text)
-        # generate name and origin if filename is provided
-        if filename is not None:
-            name = WhiteList.name_from_filename(filename)
-            origin = Origin(FileTextSource(filename), 1, max_lineno)
-        else:
-            # otherwise generate origin if it's not specified
-            if origin is None:
-                origin = Origin(UnknownTextSource(), 1, max_lineno)
-        return cls(pattern_list, name, origin, implicit_namespace)
-
-    @classmethod
-    def name_from_filename(cls, filename):
-        """
-        Compute the name of a whitelist based on the name
-        of the file it is stored in.
-        """
-        return os.path.splitext(os.path.basename(filename))[0]
-
-    @classmethod
-    def _parse_patterns(cls, text):
-        """
-        Load whitelist patterns from the specified text
-
-        :param text:
-            string of text, including newlines, to parse
-        :returns:
-            (pattern_list, lineno) where lineno is the final line number
-            (1-based) and pattern_list is a list of regular expression strings
-            parsed from the whitelist.
-        """
-        from plainbox.impl.xparsers import Re
-        from plainbox.impl.xparsers import Visitor
-        from plainbox.impl.xparsers import WhiteList
-
-        class WhiteListVisitor(Visitor):
-
-            def __init__(self):
-                self.pattern_list = []
-                self.lineno = 0
-
-            def visit_Re_node(self, node: Re):
-                self.pattern_list.append(r"^{}$".format(node.text.strip()))
-                self.lineno = max(node.lineno, self.lineno)
-                return super().generic_visit(node)
-
-            visit_ReFixed_node = visit_Re_node
-            visit_RePattern_node = visit_Re_node
-            visit_ReErr_node = visit_Re_node
-
-        visitor = WhiteListVisitor()
-        visitor.visit(WhiteList.parse(text))
-        return visitor.pattern_list, visitor.lineno
-
-    @classmethod
-    def _load_patterns(cls, pathname):
-        """
-        Load whitelist patterns from the specified file
-
-        :param pathname:
-            pathname of the file to load and parse
-        :returns:
-            (pattern_list, lineno) where lineno is the final line number
-            (1-based) and pattern_list is a list of regular expression strings
-            parsed from the whitelist.
-        """
-        with open(pathname, "rt", encoding="UTF-8") as stream:
-            return cls._parse_patterns(stream.read())
-
-
 def get_flat_primitive_qualifier_list(qualifier_list):
     return list(itertools.chain(*[
         qual.get_primitive_qualifiers()
@@ -659,7 +437,7 @@ def select_jobs(job_list, qualifier_list):
         A sub-list of JobDefinition objects, selected from job_list.
     """
     # Flatten the qualifier list, so that we can see the fine structure of
-    # composite objects, such as whitelists.
+    # composite objects.
     flat_qualifier_list = get_flat_primitive_qualifier_list(qualifier_list)
     # Short-circuit if there are no jobs to select. Min is used later and this
     # will allow us to assume that the matrix is not empty.
diff --git a/plainbox/impl/secure/test_launcher1.py b/plainbox/impl/secure/test_launcher1.py
index c270be5..247b306 100644
--- a/plainbox/impl/secure/test_launcher1.py
+++ b/plainbox/impl/secure/test_launcher1.py
@@ -110,33 +110,6 @@ class TrustedLauncherTests(TestCase):
         # Ensure that the return value of subprocess.call() is returned
         self.assertEqual(retval, mock_call())
 
-    @mock.patch.dict('os.environ', clear=True)
-    @mock.patch('plainbox.impl.job.JobDefinition.from_rfc822_record')
-    @mock.patch('plainbox.impl.secure.launcher1.load_rfc822_records')
-    @mock.patch('subprocess.check_output')
-    def test_run_local_job(self, mock_check_output, mock_load_rfc822_records,
-                           mock_from_rfc822_record):
-        # Create a mock job and add it to the launcher
-        job = mock.Mock(spec=JobDefinition, name='job', plugin='local')
-        self.launcher.add_job_list([job])
-        # Create two mock rfc822 records
-        record1 = mock.Mock(spec=RFC822Record, name='record')
-        record2 = mock.Mock(spec=RFC822Record, name='record')
-        # Ensure that load_rfc822_records() returns some mocked records
-        mock_load_rfc822_records.return_value = [record1, record2]
-        # Run the tested method
-        job_list = self.launcher.run_generator_job(job.checksum, None)
-        # Ensure that we run the job command via job.shell
-        mock_check_output.assert_called_with(
-            [job.shell, '-c', job.command], env={}, universal_newlines=True)
-        # Ensure that we parse all of the output
-        mock_load_rfc822_records.assert_called_with(
-            mock_check_output(), source=JobOutputTextSource(job))
-        # Ensure that we return the jobs back
-        self.assertEqual(len(job_list), 2)
-        self.assertEqual(job_list[0], mock_from_rfc822_record(record1))
-        self.assertEqual(job_list[1], mock_from_rfc822_record(record2))
-
 
 class MainTests(TestCase):
     """
@@ -189,7 +162,7 @@ class MainTests(TestCase):
           -g CHECKSUM, --generator CHECKSUM
                                 also run a job with this checksum (assuming \
 it is a
-                                local job)
+                                resource job)
           -G NAME=VALUE [NAME=VALUE ...], --generator-environment NAME=VALUE \
 [NAME=VALUE ...]
                                 environment passed to the generator job
@@ -257,9 +230,9 @@ it is a
         verify what happens when `plainbox-trusted-launcher-1` is called with
         both --hash and --via that both are okay and designate existing jobs.
         """
-        # Create a mock (local) job, give it a predictable checksum
-        local_job = mock.Mock(
-            name='local_job',
+        # Create a mock generator job, give it a predictable checksum
+        generator_job = mock.Mock(
+            name='generator_job',
             spec=JobDefinition,
             checksum='5678')
         # Create a mock (target) job, give it a predictable checksum
@@ -267,16 +240,16 @@ it is a
             name='target_job',
             spec=JobDefinition,
             checksum='1234')
-        # Ensure this local job is enumerated by the provider
-        self.provider.job_list = [local_job]
-        # Ensure that the target job is generated by the local job
-        mock_launcher.run_local_job.return_value = [target_job]
+        # Ensure this generator job is enumerated by the provider
+        self.provider.job_list = [generator_job]
+        # Ensure that the target job is generated by the generator job
+        mock_launcher.run_generator_job.return_value = [target_job]
         # Run the program with io intercept
         with TestIO(combined=True) as io:
             retval = main(['--target=1234', '--generator=5678'])
-        # Ensure that the local job command was invoked
+        # Ensure that the generator job command was invoked
         mock_launcher().run_generator_job.assert_called_with(
-            local_job.checksum, None)
+            generator_job.checksum, None)
         # Ensure that the target job command was invoked
         mock_launcher().run_shell_from_job.assert_called_with(
             target_job.checksum, None)
diff --git a/plainbox/impl/secure/test_qualifiers.py b/plainbox/impl/secure/test_qualifiers.py
index b02cf2b..e177796 100644
--- a/plainbox/impl/secure/test_qualifiers.py
+++ b/plainbox/impl/secure/test_qualifiers.py
@@ -39,14 +39,12 @@ from plainbox.impl.secure.qualifiers import CompositeQualifier
 from plainbox.impl.secure.qualifiers import FieldQualifier
 from plainbox.impl.secure.qualifiers import IMatcher
 from plainbox.impl.secure.qualifiers import JobIdQualifier
-from plainbox.impl.secure.qualifiers import NonLocalJobQualifier
 from plainbox.impl.secure.qualifiers import NonPrimitiveQualifierOrigin
 from plainbox.impl.secure.qualifiers import OperatorMatcher
 from plainbox.impl.secure.qualifiers import PatternMatcher
 from plainbox.impl.secure.qualifiers import RegExpJobQualifier
 from plainbox.impl.secure.qualifiers import select_jobs
 from plainbox.impl.secure.qualifiers import SimpleQualifier
-from plainbox.impl.secure.qualifiers import WhiteList
 from plainbox.impl.testing_utils import make_job
 from plainbox.vendor import mock
 
@@ -378,56 +376,6 @@ class JobIdQualifierTests(TestCase):
             JobIdQualifier('*', self.origin).designates(make_job('name')))
 
 
-class NonLocalJobQualifierTests(TestCase):
-    """
-    Test cases for NonLocalJobQualifier class
-    """
-
-    def setUp(self):
-        self.origin = mock.Mock(name='origin', spec_set=Origin)
-        self.qualifier = NonLocalJobQualifier(self.origin)
-
-    def test_init(self):
-        """
-        verify that init assigns stuff to properties correctly
-        """
-        self.assertEqual(self.qualifier.origin, self.origin)
-
-    def test_is_primitive(self):
-        """
-        verify that LocalJobQualifier.is_primitive is True
-        """
-        self.assertTrue(self.qualifier.is_primitive)
-
-    def test_repr(self):
-        """
-        verify that NonLocalJobQualifier.__repr__() works as expected
-        """
-        self.assertEqual(
-            repr(self.qualifier), "NonLocalJobQualifier(inclusive=True)")
-
-    def test_get_vote(self):
-        """
-        verify that NonLocalJobQualifier.get_vote() works as expected
-        """
-        self.assertEqual(
-            NonLocalJobQualifier(self.origin).get_vote(
-                JobDefinition({'name': 'foo', 'plugin': 'shell'})),
-            IJobQualifier.VOTE_INCLUDE)
-        self.assertEqual(
-            NonLocalJobQualifier(self.origin, inclusive=False).get_vote(
-                JobDefinition({'name': 'foo', 'plugin': 'shell'})),
-            IJobQualifier.VOTE_EXCLUDE)
-        self.assertEqual(
-            NonLocalJobQualifier(self.origin).get_vote(
-                JobDefinition({'name': 'bar', 'plugin': 'local'})),
-            IJobQualifier.VOTE_IGNORE)
-        self.assertEqual(
-            NonLocalJobQualifier(self.origin, inclusive=False).get_vote(
-                JobDefinition({'name': 'bar', 'plugin': 'local'})),
-            IJobQualifier.VOTE_IGNORE)
-
-
 class CompositeQualifierTests(TestCase):
     """
     Test cases for CompositeQualifier class
@@ -537,185 +485,6 @@ class CompositeQualifierTests(TestCase):
             CompositeQualifier([]).origin
 
 
-class WhiteListTests(TestCase):
-    """
-    Test cases for WhiteList class
-    """
-
-    _name = 'whitelist.txt'
-
-    _content = [
-        "# this is a comment",
-        "foo # this is another comment",
-        "bar",
-        ""
-    ]
-
-    @contextmanager
-    def mocked_file(self, name, content):
-        m_open = mock.MagicMock(name='open', spec=open)
-        m_stream = mock.MagicMock(spec=TextIOWrapper)
-        m_stream.__enter__.return_value = m_stream
-        # The next two lines are complementary, either will suffice but the
-        # test may need changes if the code that reads stuff changes.
-        m_stream.__iter__.side_effect = lambda: iter(content)
-        m_stream.read.return_value = "\n".join(content)
-        m_open.return_value = m_stream
-        with mock.patch('plainbox.impl.secure.qualifiers.open', m_open,
-                        create=True):
-            yield
-        m_open.assert_called_once_with(name, "rt", encoding="UTF-8")
-
-    def test_load_patterns(self):
-        with self.mocked_file(self._name, self._content):
-            pattern_list, max_lineno = WhiteList._load_patterns(self._name)
-        self.assertEqual(pattern_list, ['^foo$', '^bar$'])
-        self.assertEqual(max_lineno, 3)
-
-    def test_designates(self):
-        """
-        verify that WhiteList.designates() works
-        """
-        self.assertTrue(
-            WhiteList.from_string("foo").designates(make_job('foo')))
-        self.assertTrue(
-            WhiteList.from_string("foo\nbar\n").designates(make_job('foo')))
-        self.assertTrue(
-            WhiteList.from_string("foo\nbar\n").designates(make_job('bar')))
-        # Note, it's not matching either!
-        self.assertFalse(
-            WhiteList.from_string("foo").designates(make_job('foobar')))
-        self.assertFalse(
-            WhiteList.from_string("bar").designates(make_job('foobar')))
-
-    def test_from_file(self):
-        """
-        verify that WhiteList.from_file() works
-        """
-        with self.mocked_file(self._name, self._content):
-            whitelist = WhiteList.from_file(self._name)
-        # verify that the patterns are okay
-        self.assertEqual(
-            repr(whitelist.qualifier_list[0]),
-            "RegExpJobQualifier('^foo$', inclusive=True)")
-        # verify that whitelist name got set
-        self.assertEqual(whitelist.name, "whitelist")
-        # verify that the origin got set
-        self.assertEqual(
-            whitelist.origin,
-            Origin(FileTextSource("whitelist.txt"), 1, 3))
-
-    def test_from_string(self):
-        """
-        verify that WhiteList.from_string() works
-        """
-        whitelist = WhiteList.from_string("\n".join(self._content))
-        # verify that the patterns are okay
-        self.assertEqual(
-            repr(whitelist.qualifier_list[0]),
-            "RegExpJobQualifier('^foo$', inclusive=True)")
-        # verify that whitelist name is the empty default
-        self.assertEqual(whitelist.name, None)
-        # verify that the origin got set to the default constructed value
-        self.assertEqual(whitelist.origin, Origin(UnknownTextSource(), 1, 3))
-
-    def test_from_empty_string(self):
-        """
-        verify that WhiteList.from_string("") works
-        """
-        WhiteList.from_string("")
-
-    def test_from_string__with_name_and_origin(self):
-        """
-        verify that WhiteList.from_string() works when passing name and origin
-        """
-        # construct a whitelist with some dummy data, the names, pathnames and
-        # line ranges are arbitrary
-        whitelist = WhiteList.from_string(
-            "\n".join(self._content), name="somefile",
-            origin=Origin(FileTextSource("somefile.txt"), 1, 3))
-        # verify that the patterns are okay
-        self.assertEqual(
-            repr(whitelist.qualifier_list[0]),
-            "RegExpJobQualifier('^foo$', inclusive=True)")
-        # verify that whitelist name is copied
-        self.assertEqual(whitelist.name, "somefile")
-        # verify that the origin is copied
-        self.assertEqual(
-            whitelist.origin, Origin(FileTextSource("somefile.txt"), 1, 3))
-
-    def test_from_string__with_filename(self):
-        """
-        verify that WhiteList.from_string() works when passing filename
-        """
-        # construct a whitelist with some dummy data, the names, pathnames and
-        # line ranges are arbitrary
-        whitelist = WhiteList.from_string(
-            "\n".join(self._content), filename="somefile.txt")
-        # verify that the patterns are okay
-        self.assertEqual(
-            repr(whitelist.qualifier_list[0]),
-            "RegExpJobQualifier('^foo$', inclusive=True)")
-        # verify that whitelist name is derived from the filename
-        self.assertEqual(whitelist.name, "somefile")
-        # verify that the origin is properly derived from the filename
-        self.assertEqual(
-            whitelist.origin, Origin(FileTextSource("somefile.txt"), 1, 3))
-
-    def test_repr(self):
-        """
-        verify that custom repr works
-        """
-        whitelist = WhiteList([], name="test")
-        self.assertEqual(repr(whitelist), "<WhiteList name:'test'>")
-
-    def test_name_getter(self):
-        """
-        verify that WhiteList.name getter works
-        """
-        self.assertEqual(WhiteList([], "foo").name, "foo")
-
-    def test_name_setter(self):
-        """
-        verify that WhiteList.name setter works
-        """
-        whitelist = WhiteList([], "foo")
-        whitelist.name = "bar"
-        self.assertEqual(whitelist.name, "bar")
-
-    def test_name_from_filename(self):
-        """
-        verify how name_from_filename() works
-        """
-        self.assertEqual(
-            WhiteList.name_from_filename("some/path/foo.whitelist"), "foo")
-        self.assertEqual(WhiteList.name_from_filename("foo.whitelist"), "foo")
-        self.assertEqual(WhiteList.name_from_filename("foo."), "foo")
-        self.assertEqual(WhiteList.name_from_filename("foo"), "foo")
-        self.assertEqual(
-            WhiteList.name_from_filename("foo.notawhitelist"), "foo")
-
-    def test_namespace_behavior(self):
-        """
-        verify that WhiteList() correctly respects namespace declarations
-        and uses implict_namespace to fully qualifiy all patterns
-        """
-        whitelist = WhiteList.from_string(
-            "foo\n"
-            "example\\.org::bar\n",
-            implicit_namespace="other.example.org")
-        # verify that the implicit namespace was recorded
-        self.assertEqual(
-            whitelist.implicit_namespace, "other.example.org")
-        # verify that the patterns are okay
-        self.assertEqual(
-            whitelist.qualifier_list[0].pattern_text,
-            "^other\\.example\\.org::foo$")
-        self.assertEqual(
-            whitelist.qualifier_list[1].pattern_text,
-            "^example\\.org::bar$")
-
-
 class FunctionTests(TestCase):
 
     def setUp(self):
diff --git a/plainbox/impl/session/assistant.py b/plainbox/impl/session/assistant.py
index 1ea7ad7..db60157 100644
--- a/plainbox/impl/session/assistant.py
+++ b/plainbox/impl/session/assistant.py
@@ -44,6 +44,7 @@ from plainbox.impl.developer import UnexpectedMethodCall
 from plainbox.impl.developer import UsageExpectation
 from plainbox.impl.jobcache import ResourceJobCache
 from plainbox.impl.result import JobResultBuilder
+from plainbox.impl.providers import get_providers
 from plainbox.impl.runner import JobRunner
 from plainbox.impl.runner import JobRunnerUIDelegate
 from plainbox.impl.secure.origin import Origin
@@ -60,7 +61,6 @@ from plainbox.impl.session.restart import detect_restart_strategy
 from plainbox.impl.session.storage import SessionStorageRepository
 from plainbox.impl.transport import OAuthTransport
 from plainbox.impl.transport import TransportError
-from plainbox.public import get_providers
 from plainbox.vendor import morris
 
 _logger = logging.getLogger("plainbox.session.assistant")
@@ -837,9 +837,8 @@ class SessionAssistant:
 
         During the bootstrap phase resource jobs that are associated with job
         templates may generate new jobs according to the information specified
-        in the template. In addition, local jobs can generate arbitrary
-        (unrestricted) units. Both of those mechanism are subject to the
-        validation system (invalid units are discarded).
+        in the template. This mechanism is subject to the validation system
+        (invalid units are discarded).
 
         When this method returns (which can take a while) the session is now
         ready for running any jobs.
@@ -850,8 +849,8 @@ class SessionAssistant:
         """
         UsageExpectation.of(self).enforce()
         # NOTE: there is next-to-none UI here as bootstrap jobs are limited to
-        # just resource and local jobs (including their dependencies) so there
-        # should be very little UI required.
+        # just resource jobs (including their dependencies) so there should be
+        # very little UI required.
         desired_job_list = select_jobs(
             self._context.state.job_list,
             [plan.get_bootstrap_qualifier() for plan in (
diff --git a/plainbox/impl/session/jobs.py b/plainbox/impl/session/jobs.py
index 22a138b..809c72c 100644
--- a/plainbox/impl/session/jobs.py
+++ b/plainbox/impl/session/jobs.py
@@ -27,6 +27,7 @@ particular session. The :class:`JobState` class holds references to a
 that prevent the job from being runnable in a particular session.
 """
 
+from enum import IntEnum
 import logging
 
 from plainbox.abc import IJobResult
@@ -35,7 +36,6 @@ from plainbox.impl import pod
 from plainbox.impl.resource import ResourceExpression
 from plainbox.impl.result import MemoryJobResult
 from plainbox.impl.unit.job import JobDefinition
-from plainbox.vendor.enum import IntEnum
 
 logger = logging.getLogger("plainbox.session.jobs")
 
diff --git a/plainbox/impl/session/manager.py b/plainbox/impl/session/manager.py
index 9a056fa..20616d0 100644
--- a/plainbox/impl/session/manager.py
+++ b/plainbox/impl/session/manager.py
@@ -39,6 +39,7 @@ import tempfile
 
 from plainbox.i18n import gettext as _, ngettext
 from plainbox.impl import pod
+from plainbox.impl.providers import get_providers
 from plainbox.impl.session.resume import SessionResumeHelper
 from plainbox.impl.session.state import SessionDeviceContext
 from plainbox.impl.session.state import SessionState
@@ -47,7 +48,6 @@ from plainbox.impl.session.storage import SessionStorage
 from plainbox.impl.session.storage import SessionStorageRepository
 from plainbox.impl.session.suspend import SessionSuspendHelper
 from plainbox.impl.unit.testplan import TestPlanUnit
-from plainbox.public import get_providers
 from plainbox.vendor import morris
 
 logger = logging.getLogger("plainbox.session.manager")
@@ -187,7 +187,7 @@ class SessionManager(pod.POD):
             return self.default_device_context.state
 
     @classmethod
-    def create(cls, repo=None, legacy_mode=False, prefix='pbox-'):
+    def create(cls, repo=None, prefix='pbox-'):
         """
         Create an empty session manager.
 
@@ -205,24 +205,18 @@ class SessionManager(pod.POD):
             constructed with the default location.
         :ptype repo:
             :class:`~plainbox.impl.session.storage.SessionStorageRepository`.
-        :param legacy_mode:
-            Propagated to
-            :meth:`~plainbox.impl.session.storage.SessionStorage.create()` to
-            ensure that legacy (single session) mode is used.
-        :ptype legacy_mode:
-            bool
         :return:
             fresh :class:`SessionManager` instance
         """
         logger.debug("SessionManager.create()")
         if repo is None:
             repo = SessionStorageRepository()
-        storage = SessionStorage.create(repo.location, legacy_mode, prefix)
+        storage = SessionStorage.create(repo.location, prefix)
         WellKnownDirsHelper(storage).populate()
         return cls([], storage)
 
     @classmethod
-    def create_with_state(cls, state, repo=None, legacy_mode=False):
+    def create_with_state(cls, state, repo=None):
         """
         Create a session manager by wrapping existing session state.
 
@@ -237,26 +231,19 @@ class SessionManager(pod.POD):
             constructed with the default location.
         :ptype repo:
             :class:`~plainbox.impl.session.storage.SessionStorageRepository`.
-        :param legacy_mode:
-            Propagated to
-            :meth:`~plainbox.impl.session.storage.SessionStorage.create()`
-            to ensure that legacy (single session) mode is used.
-        :ptype legacy_mode:
-            bool
         :return:
             fresh :class:`SessionManager` instance
         """
         logger.debug("SessionManager.create_with_state()")
         if repo is None:
             repo = SessionStorageRepository()
-        storage = SessionStorage.create(repo.location, legacy_mode)
+        storage = SessionStorage.create(repo.location)
         WellKnownDirsHelper(storage).populate()
         context = SessionDeviceContext(state)
         return cls([context], storage)
 
     @classmethod
-    def create_with_unit_list(cls, unit_list=None, repo=None,
-                              legacy_mode=False):
+    def create_with_unit_list(cls, unit_list=None, repo=None):
         """
         Create a session manager with a fresh session.
 
@@ -272,12 +259,6 @@ class SessionManager(pod.POD):
             constructed with the default location.
         :ptype repo:
             :class:`~plainbox.impl.session.storage.SessionStorageRepository`.
-        :param legacy_mode:
-            Propagated to
-            :meth:`~plainbox.impl.session.storage.SessionStorage.create()`
-            to ensure that legacy (single session) mode is used.
-        :ptype legacy_mode:
-            bool
         :return:
             fresh :class:`SessionManager` instance
         """
@@ -287,7 +268,7 @@ class SessionManager(pod.POD):
         state = SessionState(unit_list)
         if repo is None:
             repo = SessionStorageRepository()
-        storage = SessionStorage.create(repo.location, legacy_mode)
+        storage = SessionStorage.create(repo.location)
         context = SessionDeviceContext(state)
         WellKnownDirsHelper(storage).populate()
         return cls([context], storage)
@@ -480,7 +461,6 @@ class SessionManager(pod.POD):
             'com.canonical.plainbox::html': 'html',
             'com.canonical.plainbox::json': 'json',
             'com.canonical.plainbox::junit': 'junit',
-            'com.canonical.plainbox::rfc822': 'rfc822',
             'com.canonical.plainbox::tar': 'tar',
             'com.canonical.plainbox::text': 'text',
             'com.canonical.plainbox::xlsx': 'xlsx'
@@ -498,8 +478,7 @@ class SessionManager(pod.POD):
             Identifier of the exporter unit (which must have been loaded
             into the session device context of the first device). For
             backwards compatibility this can also be any of the legacy
-            identifiers ``tar``, ``html``, ``json``, ``rfc822``, ``text`` or
-            ``xlsx``.
+            identifiers ``tar``, ``html``, ``json``, ``text`` or ``xlsx``.
         :param option_list:
             (optional) A list of options to pass to the exporter. Each option
             is a string. Some strings may be of form 'key=value' but those are
diff --git a/plainbox/impl/session/state.py b/plainbox/impl/session/state.py
index 0631de1..c7c6601 100644
--- a/plainbox/impl/session/state.py
+++ b/plainbox/impl/session/state.py
@@ -645,10 +645,6 @@ class SessionState:
         Not all the jobs from this list are going to be executed (or selected
         for execution) by the user.
 
-        It may change at runtime because of local jobs. Note that in upcoming
-        changes this will start out empty and will be changeable dynamically.
-        It can still change due to local jobs but there is no API yes.
-
         This list cannot have any duplicates, if that is the case a
         :class:`DependencyDuplicateError` is raised. This has to be handled
         externally and is a sign that the job database is corrupted or has
@@ -660,8 +656,7 @@ class SessionState:
         This list contains all the known units, including all the know job
         definitions (and in the future, all test plans).
 
-        It may change at runtime because of local jobs and template
-        instantiations.
+        It may change at runtime because of template instantiations.
 
     :ivar dict job_state_map: mapping that tracks the state of each job
 
@@ -971,7 +966,7 @@ class SessionState:
             if job.automated and estimate_automated is not None:
                 if job.estimated_duration is not None:
                     estimate_automated += job.estimated_duration
-                elif job.plugin != 'local':
+                else:
                     estimate_automated = None
             elif not job.automated and estimate_manual is not None:
                 # We add a fixed extra amount of seconds to the run time
@@ -993,8 +988,8 @@ class SessionState:
         Results also change the ready map (jobs that can run) because of
         dependency relations.
 
-        Some results have deeper meaning, those are results for local and
-        resource jobs. They are discussed in detail below:
+        Some results have deeper meaning, those are results for resource jobs.
+        They are discussed in detail below:
 
         Resource jobs produce resource records which are used as data to run
         requirement expressions against. Each time a result for a resource job
@@ -1002,11 +997,6 @@ class SessionState:
         records. A new entry is created in the resource map (entirely replacing
         any old entries), with a list of the resources that were parsed from
         the IO log.
-
-        Local jobs produce more jobs. Like with resource jobs, their IO log is
-        parsed and interpreted as additional jobs. Unlike in resource jobs
-        local jobs don't replace anything. They cannot replace an existing job
-        with the same id.
         """
         job.controller.observe_result(self, job, result)
         self._recompute_job_readiness()
@@ -1108,8 +1098,7 @@ class SessionState:
             return new_job
         else:
             # If there is a clash report DependencyDuplicateError only when the
-            # hashes are different. This prevents a common "problem" where
-            # "__foo__" local jobs just load all jobs from the "foo" category.
+            # hashes are different.
             if new_job != existing_job:
                 raise DependencyDuplicateError(existing_job, new_job)
             self._add_job_siblings_unit(new_job, recompute)
diff --git a/plainbox/impl/session/storage.py b/plainbox/impl/session/storage.py
index de9620a..c290a24 100644
--- a/plainbox/impl/session/storage.py
+++ b/plainbox/impl/session/storage.py
@@ -54,8 +54,6 @@ class SessionStorageRepository:
     :meth:SessionStorage.remove()`)
     """
 
-    _LAST_SESSION_SYMLINK = "last-session"
-
     def __init__(self, location=None):
         """
         Initialize new repository at the specified location.
@@ -75,35 +73,6 @@ class SessionStorageRepository:
         """
         return self._location
 
-    def get_last_storage(self):
-        """
-        Find the last session storage object created in this repository.
-
-        :returns:
-            SessionStorage object associated with the last session created in
-            this repository using legacy mode.
-
-        .. note::
-            This will only return storage objects that were created using
-            legacy mode. Nonlegacy storage objects will not be returned this
-            way.
-        """
-        pathname = os.path.join(self.location, self._LAST_SESSION_SYMLINK)
-        try:
-            last_storage = os.readlink(pathname)
-        except OSError:
-            # The symlink can be gone or not be a real symlink
-            # in that case just ignore it and return None
-            return None
-        else:
-            # The link may be relative so let's ensure we know the full
-            # pathname for the subsequent check (which may be performed
-            # from another directory)
-            last_storage = os.path.join(self._location, last_storage)
-        # If the link points to a directory, assume it's okay
-        if os.path.isdir(last_storage):
-            return SessionStorage(last_storage)
-
     def get_storage_list(self):
         """
         Enumerate stored sessions in the repository.
@@ -251,7 +220,7 @@ class SessionStorage:
         return os.path.join(self._location, self._SESSION_FILE)
 
     @classmethod
-    def create(cls, base_dir, legacy_mode=False, prefix='pbox-'):
+    def create(cls, base_dir, prefix='pbox-'):
         """
         Create a new :class:`SessionStorage` in a random subdirectory
         of the specified base directory. The base directory is also
@@ -262,25 +231,9 @@ class SessionStorage:
             Typically the base directory should be obtained from
             :meth:`SessionStorageRepository.get_default_location()`
 
-        :param legacy_mode:
-            If False (defaults to True) then the caller is expected to
-            handle multiple sessions by itself.
-
         :param prefix:
             String which should prefix all session filenames. The prefix is
             sluggified before use.
-
-        .. note::
-            Legacy mode is where applications using PlainBox API can only
-            handle one session. Creating another session replaces whatever was
-            stored before. In non-legacy mode applications can enumerate
-            sessions, create arbitrary number of sessions at the same time
-            and remove sessions once they are no longer necessary.
-
-            Legacy mode is implemented with a symbolic link called
-            'last-session' that keeps track of the last session created using
-            ``legacy_mode=True``. When a new legacy-mode session is created
-            the target of that symlink is read and recursively removed.
         """
         if not os.path.exists(base_dir):
             os.makedirs(base_dir)
@@ -298,57 +251,8 @@ class SessionStorage:
         os.mkdir(location)
         logger.debug(_("Created new storage in %r"), location)
         self = cls(location)
-        if legacy_mode:
-            self._replace_legacy_session(base_dir)
         return self
 
-    def _replace_legacy_session(self, base_dir):
-        """
-        Remove the previous legacy session and update the 'last-session'
-        symlink so that it points to this session storage directory.
-        """
-        symlink_pathname = os.path.join(
-            base_dir, SessionStorageRepository._LAST_SESSION_SYMLINK)
-        # Try to read and remove the storage referenced to by last-session
-        # symlink. This can fail if the link file is gone (which is harmless)
-        # or when it is not an actual symlink (which means that the
-        # repository is corrupted).
-        try:
-            symlink_target = os.readlink(symlink_pathname)
-        except OSError as exc:
-            if exc.errno == errno.ENOENT:
-                pass
-            elif exc.errno == errno.EINVAL:
-                logger.warning(
-                    _("%r is not a symlink, repository %r must be corrupted"),
-                    symlink_pathname, base_dir)
-            else:
-                logger.warning(
-                    _("Unable to read symlink target from %r: %r"),
-                    symlink_pathname, exc)
-        else:
-            logger.debug(
-                _("Removing storage associated with last session %r"),
-                symlink_target)
-            # Remove the old session, note that the symlink may be broken so
-            # let's ignore any errors here
-            shutil.rmtree(symlink_target, ignore_errors=True)
-            # Remove the last-session symlink itself
-            logger.debug(
-                _("Removing symlink associated with last session: %r"),
-                symlink_pathname)
-            os.unlink(symlink_pathname)
-        finally:
-            # Finally put the last-session synlink that points to this storage
-            logger.debug(
-                _("Linking storage %r to last session"), self.location)
-            try:
-                os.symlink(self.location, symlink_pathname)
-            except OSError as exc:
-                logger.error(
-                    _("Cannot link %r as %r: %r"),
-                    self.location, symlink_pathname, exc)
-
     def remove(self):
         """
         Remove all filesystem entries associated with this instance.
@@ -367,164 +271,7 @@ class SessionStorage:
 
         :raises IOError, OSError:
             on various problems related to accessing the filesystem
-
-        :raises NotImplementedError:
-            when openat(2) is not available on this platform. Should never
-            happen on Linux or Windows where appropriate checks divert to a
-            correct implementation that is not using them.
-        """
-        if sys.platform == 'linux' or sys.platform == 'linux2':
-            if sys.version_info[0:2] >= (3, 3):
-                return self._load_checkpoint_unix_py33()
-            else:
-                return self._load_checkpoint_unix_py32()
-        elif sys.platform == 'win32':
-            return self._load_checkpoint_win32_py33()
-        raise NotImplementedError(
-            "platform/python combination is not supported: {} + {}".format(
-                sys.version, sys.platform))
-
-    def save_checkpoint(self, data):
-        """
-        Save checkpoint data to the filesystem.
-
-        The directory associated with this :class:`SessionStorage` must already
-        exist. Typically the instance should be obtained by calling
-        :meth:`SessionStorage.create()` which will ensure that this is already
-        the case.
-
-        :raises TypeError:
-            if data is not a bytes object.
-
-        :raises LockedStorageError:
-            if leftovers from previous save_checkpoint() have been detected.
-            Normally those should never be here but in certain cases that is
-            possible. Callers might want to call :meth:`break_lock()`
-            to resolve the problem and try again.
-
-        :raises IOError, OSError:
-            on various problems related to accessing the filesystem.
-            Typically permission errors may be reported here.
-
-        :raises NotImplementedError:
-            when openat(2), renameat(2), unlinkat(2) are not available on this
-            platform. Should never happen on Linux or Windows where appropriate
-            checks divert to a correct implementation that is not using them.
         """
-        if sys.platform == 'linux' or sys.platform == 'linux2':
-            if sys.version_info[0:2] >= (3, 3):
-                return self._save_checkpoint_unix_py33(data)
-            else:
-                return self._save_checkpoint_unix_py32(data)
-        elif sys.platform == 'win32':
-            if sys.version_info[0:2] >= (3, 3):
-                return self._save_checkpoint_win32_py33(data)
-        raise NotImplementedError(
-            "platform/python combination is not supported: {} + {}".format(
-                sys.version, sys.platform))
-
-    def break_lock(self):
-        """
-        Forcibly unlock the storage by removing a file created during
-        atomic filesystem operations of save_checkpoint().
-
-        This method might be useful if save_checkpoint()
-        raises LockedStorageError. It removes the "next" file that is used
-        for atomic rename.
-        """
-        _next_session_pathname = os.path.join(
-            self._location, self._SESSION_FILE_NEXT)
-        logger.debug(
-            # TRANSLATORS: unlinking as in deleting a file
-            # Please keep the 'next' string untranslated
-            _("Forcibly unlinking 'next' file %r"), _next_session_pathname)
-        os.unlink(_next_session_pathname)
-
-    def _load_checkpoint_win32_py33(self):
-        logger.debug(_("Loading checkpoint (%s)"), "Windows")
-        _session_pathname = os.path.join(self._location, self._SESSION_FILE)
-        try:
-            # Open the current session file in the location directory
-            session_fd = os.open(_session_pathname, os.O_RDONLY | os.O_BINARY)
-            logger.debug(
-                _("Opened session state file %r as descriptor %d"),
-                _session_pathname, session_fd)
-            # Stat the file to know how much to read
-            session_stat = os.fstat(session_fd)
-            logger.debug(
-                # TRANSLATORS: stat is a system call name, don't translate it
-                _("Stat'ed session state file: %s"), session_stat)
-            try:
-                # Read session data
-                logger.debug(ngettext(
-                    "Reading %d byte of session state",
-                    "Reading %d bytes of session state",
-                    session_stat.st_size), session_stat.st_size)
-                data = os.read(session_fd, session_stat.st_size)
-                logger.debug(ngettext(
-                    "Read %d byte of session state",
-                    "Read %d bytes of session state", len(data)), len(data))
-                if len(data) != session_stat.st_size:
-                    raise IOError(_("partial read?"))
-            finally:
-                # Close the session file
-                logger.debug(_("Closed descriptor %d"), session_fd)
-                os.close(session_fd)
-        except IOError as exc:
-            if exc.errno == errno.ENOENT:
-                # Treat lack of 'session' file as an empty file
-                return b''
-            raise
-        else:
-            return data
-
-    def _load_checkpoint_unix_py32(self):
-        _session_pathname = os.path.join(self._location, self._SESSION_FILE)
-        # Open the location directory
-        location_fd = os.open(self._location, os.O_DIRECTORY)
-        logger.debug(
-            _("Opened session directory %r as descriptor %d"),
-            self._location, location_fd)
-        try:
-            # Open the current session file in the location directory
-            session_fd = os.open(_session_pathname, os.O_RDONLY)
-            logger.debug(
-                _("Opened session state file %r as descriptor %d"),
-                _session_pathname, session_fd)
-            # Stat the file to know how much to read
-            session_stat = os.fstat(session_fd)
-            logger.debug(
-                # TRANSLATORS: stat is a system call name, don't translate it
-                _("Stat'ed session state file: %s"), session_stat)
-            try:
-                # Read session data
-                logger.debug(ngettext(
-                    "Reading %d byte of session state",
-                    "Reading %d bytes of session state",
-                    session_stat.st_size), session_stat.st_size)
-                data = os.read(session_fd, session_stat.st_size)
-                logger.debug(ngettext(
-                    "Read %d byte of session state",
-                    "Read %d bytes of session state", len(data)), len(data))
-                if len(data) != session_stat.st_size:
-                    raise IOError(_("partial read?"))
-            finally:
-                # Close the session file
-                logger.debug(_("Closed descriptor %d"), session_fd)
-                os.close(session_fd)
-        except IOError as exc:
-            if exc.errno == errno.ENOENT:
-                # Treat lack of 'session' file as an empty file
-                return b''
-            raise
-        else:
-            return data
-        finally:
-            # Close the location directory
-            logger.debug(_("Closed descriptor %d"), location_fd)
-            os.close(location_fd)
-
-    def _load_checkpoint_unix_py33(self):
         # Open the location directory
         location_fd = os.open(self._location, os.O_DIRECTORY)
         try:
@@ -552,225 +299,28 @@ class SessionStorage:
             # Close the location directory
             os.close(location_fd)
 
-    def _save_checkpoint_win32_py33(self, data):
-        # NOTE: this is like _save_checkpoint_py32 but without location_fd
-        # wich cannot be opened on windows (no os.O_DIRECTORY)
-        #
-        # NOTE: The windows version is relatively new and under-tested
-        # but then again we don't expect to run tests *on* windows, only
-        # *from* windows so hard data retention requirements are of lesser
-        # importance.
-        if not isinstance(data, bytes):
-            raise TypeError("data must be bytes")
-        logger.debug(ngettext(
-            "Saving %d byte of data (%s)",
-            "Saving %d bytes of data (%s)",
-            len(data)), len(data), "Windows")
-        # Helper pathnames, needed because we don't have *at functions
-        _next_session_pathname = os.path.join(
-            self._location, self._SESSION_FILE_NEXT)
-        _session_pathname = os.path.join(self._location, self._SESSION_FILE)
-        # Open the "next" file in the location_directory
-        #
-        # Use "write" + "create" + "exclusive" flags so that no race
-        # condition is possible.
-        #
-        # This will never return -1, it throws IOError when anything is
-        # wrong. The caller has to catch this.
-        #
-        # As a special exception, this code handles EEXISTS and converts
-        # that to LockedStorageError that can be especially handled by
-        # some layer above.
-        try:
-            next_session_fd = os.open(
-                _next_session_pathname,
-                os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_BINARY, 0o644)
-        except IOError as exc:
-            if exc.errno == errno.EEXISTS:
-                raise LockedStorageError()
-            else:
-                raise
-        logger.debug(
-            _("Opened next session file %s as descriptor %d"),
-            _next_session_pathname, next_session_fd)
-        try:
-            # Write session data to disk
-            #
-            # I cannot find conclusive evidence but it seems that
-            # os.write() handles partial writes internally. In case we do
-            # get a partial write _or_ we run out of disk space, raise an
-            # explicit IOError.
-            num_written = os.write(next_session_fd, data)
-            logger.debug(ngettext(
-                "Wrote %d byte of data to descriptor %d",
-                "Wrote %d bytes of data to descriptor %d",
-                num_written), num_written, next_session_fd)
-            if num_written != len(data):
-                raise IOError(_("partial write?"))
-        except Exception as exc:
-            logger.warning(_("Unable to complete write: %s"), exc)
-            # If anything goes wrong we should unlink the next file.
-            # TRANSLATORS: unlinking as in deleting a file
-            logger.warning(_("Unlinking %r: %r"), _next_session_pathname, exc)
-            os.unlink(_next_session_pathname)
-        else:
-            # If the write was successful we must flush kernel buffers.
-            #
-            # We want to be sure this data is really on disk by now as we
-            # may crash the machine soon after this method exits.
-            logger.debug(
-                # TRANSLATORS: please don't translate fsync()
-                _("Calling fsync() on descriptor %d"), next_session_fd)
-            try:
-                os.fsync(next_session_fd)
-            except OSError as exc:
-                logger.warning(_("Cannot synchronize file %r: %s"),
-                               _next_session_pathname, exc)
-        finally:
-            # Close the new session file
-            logger.debug(_("Closing descriptor %d"), next_session_fd)
-            os.close(next_session_fd)
-        # Rename FILE_NEXT over FILE.
-        logger.debug(_("Renaming %r to %r"),
-                     _next_session_pathname, _session_pathname)
-        try:
-            os.replace(_next_session_pathname, _session_pathname)
-        except Exception as exc:
-            # Same as above, if we fail we need to unlink the next file
-            # otherwise any other attempts will not be able to open() it
-            # with O_EXCL flag.
-            logger.warning(
-                _("Unable to rename/overwrite %r to %r: %r"),
-                _next_session_pathname, _session_pathname, exc)
-            # TRANSLATORS: unlinking as in deleting a file
-            logger.warning(_("Unlinking %r"), _next_session_pathname)
-            os.unlink(_next_session_pathname)
-
-    def _save_checkpoint_unix_py32(self, data):
-        # NOTE: this is like _save_checkpoint_py33 but without all the
-        # *at() functions (openat, renameat)
-        #
-        # Since we cannot use those functions there is an implicit race
-        # condition on all open() calls with another process that renames
-        # any of the directories that are part of the opened path.
-        #
-        # I don't think we can really do anything about this in userspace
-        # so this, python 3.2 specific version, just does the best effort
-        # implementation. Some of the comments were redacted but
-        # but keep in mind that the rename race is always there.
-        if not isinstance(data, bytes):
-            raise TypeError("data must be bytes")
-        logger.debug(ngettext(
-            "Saving %d byte of data (%s)",
-            "Saving %d bytes of data (%s)",
-            len(data)), len(data), "UNIX, python 3.2 or older")
-        # Helper pathnames, needed because we don't have *at functions
-        _next_session_pathname = os.path.join(
-            self._location, self._SESSION_FILE_NEXT)
-        _session_pathname = os.path.join(self._location, self._SESSION_FILE)
-        # Open the location directory, we need to fsync that later
-        # XXX: this may fail, maybe we should keep the fd open all the time?
-        location_fd = os.open(self._location, os.O_DIRECTORY)
-        logger.debug(
-            _("Opened %r as descriptor %d"), self._location, location_fd)
-        try:
-            # Open the "next" file in the location_directory
-            #
-            # Use "write" + "create" + "exclusive" flags so that no race
-            # condition is possible.
-            #
-            # This will never return -1, it throws IOError when anything is
-            # wrong. The caller has to catch this.
-            #
-            # As a special exception, this code handles EEXISTS and converts
-            # that to LockedStorageError that can be especially handled by
-            # some layer above.
-            try:
-                next_session_fd = os.open(
-                    _next_session_pathname,
-                    os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
-            except IOError as exc:
-                if exc.errno == errno.EEXISTS:
-                    raise LockedStorageError()
-                else:
-                    raise
-            logger.debug(
-                _("Opened next session file %s as descriptor %d"),
-                _next_session_pathname, next_session_fd)
-            try:
-                # Write session data to disk
-                #
-                # I cannot find conclusive evidence but it seems that
-                # os.write() handles partial writes internally. In case we do
-                # get a partial write _or_ we run out of disk space, raise an
-                # explicit IOError.
-                num_written = os.write(next_session_fd, data)
-                logger.debug(ngettext(
-                    "Wrote %d byte of data to descriptor %d",
-                    "Wrote %d bytes of data to descriptor %d",
-                    num_written), num_written, next_session_fd)
-                if num_written != len(data):
-                    raise IOError(_("partial write?"))
-            except Exception as exc:
-                logger.warning(_("Unable to complete write: %r"), exc)
-                # If anything goes wrong we should unlink the next file.
-                # TRANSLATORS: unlinking as in deleting a file
-                logger.warning(_("Unlinking %r"), _next_session_pathname)
-                os.unlink(_next_session_pathname)
-            else:
-                # If the write was successful we must flush kernel buffers.
-                #
-                # We want to be sure this data is really on disk by now as we
-                # may crash the machine soon after this method exits.
-                logger.debug(
-                    # TRANSLATORS: please don't translate fsync()
-                    _("Calling fsync() on descriptor %d"), next_session_fd)
-                try:
-                    os.fsync(next_session_fd)
-                except OSError as exc:
-                    logger.warning(_("Cannot synchronize file %r: %s"),
-                                   _next_session_pathname, exc)
-            finally:
-                # Close the new session file
-                logger.debug(_("Closing descriptor %d"), next_session_fd)
-                os.close(next_session_fd)
-            # Rename FILE_NEXT over FILE.
-            logger.debug(_("Renaming %r to %r"),
-                         _next_session_pathname, _session_pathname)
-            try:
-                os.rename(_next_session_pathname, _session_pathname)
-            except Exception as exc:
-                # Same as above, if we fail we need to unlink the next file
-                # otherwise any other attempts will not be able to open() it
-                # with O_EXCL flag.
-                logger.warning(
-                    _("Unable to rename/overwrite %r to %r: %r"),
-                    _next_session_pathname, _session_pathname, exc)