Merge ~kissiel/checkbox-ng:config-refactor-proposable into checkbox-ng:master

[Maciej Kisielewski]

This is a major refactor of configs handling in Checkbox.

[Sylvain Pineau (sylvain-pineau)]

Too avoid confusion, what do you think about keeping only one dir to store the config file as opposed to:

search_dirs = [
+ '$SNAP_DATA',
+ '/etc/xdg/',
+ '~/.config/',
+ ]

/var/tmp/checkbox-ng/ already keeps the manifest.json and the sessions data.

AFAIK it would require packaging updates for:
1. https://git.launchpad.net/~checkbox-dev/plainbox-provider-certification-server/+git/packaging/tree/debian/plainbox-provider-certification-server.install#n1
2. https://git.launchpad.net/~oem-qa/oem-qa-checkbox/+git/oem-plainbox/tree/debian/plainbox-provider-oem-somerville.install#n1

[Sylvain Pineau (sylvain-pineau)]

Unless someone frequently installs multiple checkbox-project snaps on a system I see no reason to keep $SNAP_DATA/checkbox.conf but that implies a rework of https://git.launchpad.net/checkbox-support/tree/checkbox_support/snap_utils/config.py#n57

[Sylvain Pineau (sylvain-pineau)]

Is it doable to get rid of plainbox/impl/secure/config.py completely too?

review: Needs Information

[Maciej Kisielewski (kissiel)]

So the real shortstat of this branch is now:
 19 files changed, 732 insertions(+), 1263 deletions(-)

> Is it doable to get rid of plainbox/impl/secure/config.py completely too?
I did what I can to remove dependencies from that module in this refactor. But to completely remove it we would need to refactor provider_manager that heavily depends on it.

[Jonathan Cave (jocave)]

Fix needed below

review: Needs Fixing

[Jonathan Cave (jocave)]

From Sylvain:
> Too avoid confusion, what do you think about keeping only one dir to store the config file

I see this as a useful long term goal, but not something that should be a requirement for this refactor

[Maciej Kisielewski (kissiel)]

Added support for auxiliary configs.

[Sylvain Pineau (sylvain-pineau)]

Conflicts (at least in launcher/stages.py)

review: Needs Fixing

[Jonathan Cave (jocave)]

Thanks for restoring the conf file location functionality. The recursive function looks like it should work to me, although I'm somewhat worried someone might actually use it at some point!

+1, assuming the requested rebase is completed

review: Approve

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

The merge was fine but running tests failed.

"10.38.105.54"
"10.38.105.108"
"10.38.105.197"
[xenial] [13:15:40] starting container
[bionic] [13:15:41] starting container
[focal] [13:15:47] starting container
Device project added to xenial-testing
Device project added to bionic-testing
Device project added to focal-testing
"10.38.105.54"
[xenial] [13:15:58] provisioning container
"10.38.105.124"
[bionic] [13:16:01] provisioning container
"10.38.105.62"
[focal] [13:16:10] provisioning container
[xenial] [13:22:55] Starting tests...
[xenial] Found a test script: ./requirements/001-container-tests-plainbox-egg-info
[xenial] [13:22:55] 001-container-tests-plainbox-egg-info: PASS
[xenial] Found a test script: ./requirements/container-tests-checkbox-documentation
[xenial] [13:22:59] container-tests-checkbox-documentation: PASS
[xenial] Found a test script: ./requirements/container-tests-checkbox-ng-unit
[xenial] [13:23:03] container-tests-checkbox-ng-unit: FAIL
[xenial] output: https://paste.ubuntu.com/p/X5cGV8pHGQ/
[xenial] Found a test script: ./requirements/container-tests-providers-internal
[xenial] [13:23:08] container-tests-providers-internal: PASS
[xenial] [13:23:08] Fixing file permissions in source directory
[xenial] [13:23:08] Destroying container
[bionic] [13:23:24] Starting tests...
[bionic] Found a test script: ./requirements/001-container-tests-plainbox-egg-info
[bionic] [13:23:25] 001-container-tests-plainbox-egg-info: PASS
[bionic] Found a test script: ./requirements/container-tests-checkbox-documentation
[bionic] [13:23:30] container-tests-checkbox-documentation: PASS
[bionic] Found a test script: ./requirements/container-tests-checkbox-ng-unit
[bionic] [13:23:34] container-tests-checkbox-ng-unit: FAIL
[bionic] output: https://paste.ubuntu.com/p/sYDF6vSRdY/
[bionic] Found a test script: ./requirements/container-tests-providers-internal
[bionic] [13:23:39] container-tests-providers-internal: PASS
[bionic] [13:23:39] Fixing file permissions in source directory
[bionic] [13:23:40] Destroying container
[focal] [13:23:55] Starting tests...
[focal] Found a test script: ./requirements/001-container-tests-plainbox-egg-info
[focal] [13:23:56] 001-container-tests-plainbox-egg-info: PASS
[focal] Found a test script: ./requirements/container-tests-checkbox-documentation
[focal] [13:23:59] container-tests-checkbox-documentation: PASS
[focal] Found a test script: ./requirements/container-tests-checkbox-ng-unit
[focal] [13:24:04] container-tests-checkbox-ng-unit: FAIL
[focal] output: https://paste.ubuntu.com/p/YRchj97r34/
[focal] Found a test script: ./requirements/container-tests-providers-internal
[focal] [13:24:07] container-tests-providers-internal: PASS
[focal] [13:24:07] Fixing file permissions in source directory
[focal] [13:24:08] Destroying container

review: Needs Fixing

5a15e96... by Maciej Kisielewski on 2022-01-10

Remove: old plainbox API bits

[Maciej Kisielewski (kissiel)]

This is freshly rebased on top of all the removals that happened last year. Additionally it has one more small removal from old plainbox API. It passes all the tests. Including the problematic bionic and xenial ones.

[Jonathan Cave (jocave)]

I tested this out and found with a controller side running this code and the SUT side running current stable code.

Launcher file: https://pastebin.canonical.com/p/2BSjVz5nS5/

I found that the session got stuck in an endless auto-retry loop (note that auto-retry is "no" in the launcher). Switch the controller back to master resulted in expected no auto-retry behaviour.

review: Needs Fixing

[Maciej Kisielewski (kissiel)]

Those changes remote an RemoteAPI bump, so let's land this targeting RAPI-bump branch (stuff that should be on master, but are grouped together so only one bump is made).

[Jonathan Cave (jocave)]

Ok, sounds good to me. A coordinated landing would be good so that we can get the controller side containers rebuilt and try things out on edge

review: Approve

Unmerged commits

6a7c860... by Maciej Kisielewski on 2021-11-17

Add: support auxiliary config filenames

1e479bf... by Maciej Kisielewski on 2020-11-11

Change: refactor configs, add origins for values

This patch changes how configs (and launchers) are stored inside checkbox.
Apart from removing quite a lot of code, it also makes checkbox record the
place where particular config variable came from.

5a15e96... by Maciej Kisielewski on 2022-01-10

Remove: old plainbox API bits

diff --git a/checkbox_ng/config.py b/checkbox_ng/config.py
index 5a4ba11..a8e8ad0 100644
--- a/checkbox_ng/config.py
+++ b/checkbox_ng/config.py
@@ -23,55 +23,62 @@
 =====================================================
 """
 import gettext
-import itertools
 import logging
 import os
 
-from plainbox.impl.launcher import DefaultLauncherDefinition
-from plainbox.impl.launcher import LauncherDefinition
+from plainbox.impl.config import Configuration
 
 
 _ = gettext.gettext
 
 _logger = logging.getLogger("config")
 
+
+SEARCH_DIRS = [
+        '$SNAP_DATA',
+        '/etc/xdg/',
+        '~/.config/',
+    ]
+
+
 def expand_all(path):
+    """Expand both: envvars and ~ in `path`."""
     return os.path.expandvars(os.path.expanduser(path))
 
-def load_configs(launcher_file=None):
-    # launcher can override the default name of config files to look for
-    # so first we need to establish the filename to look for
-    configs = []
-    config_filename = 'checkbox.conf'
-    launcher = DefaultLauncherDefinition()
-    if launcher_file:
-        configs.append(launcher_file)
-        generic_launcher = LauncherDefinition()
-        if not os.path.exists(launcher_file):
-            _logger.error(_(
-                "Unable to load launcher '%s'. File not found!"),
-                launcher_file)
-            raise SystemExit(1)
-        generic_launcher.read(launcher_file)
-        config_filename = os.path.expandvars(os.path.expanduser(
-            generic_launcher.config_filename))
-        launcher = generic_launcher.get_concrete_launcher()
-    if os.path.isabs(config_filename):
-        configs.append(config_filename)
+
+def load_configs(launcher_file=None, cfg=None):
+    """
+    Read a chain of configs/launchers.
+
+    In theory there can be a very long list of configs that are linked by
+    specifying config_filename in each. Each time this happen we need to
+    consider the new one and override all the values contained therein.
+    And after this chain is exhausted the values in the launcher should
+    take precedence over the previously read.
+    Warning: some recursion ahead.
+    """
+    if not cfg:
+        cfg = Configuration()
+    previous_cfg_name = cfg.get_value('config', 'config_filename')
+    if os.path.isabs(expand_all(previous_cfg_name)):
+        cfg.update_from_another(
+            Configuration.from_path(expand_all(previous_cfg_name)),
+            'config file: {}'.format(previous_cfg_name))
     else:
-        search_dirs = [
-            '$SNAP_DATA',
-            '/etc/xdg/',
-            '~/.config/',
-        ]
-        for d in search_dirs:
-            config = expand_all(os.path.join(d, config_filename))
+        for sdir in SEARCH_DIRS:
+            config = expand_all(os.path.join(sdir, previous_cfg_name))
             if os.path.exists(config):
-                configs.append(config)
-    launcher.read(configs)
-    if launcher.problem_list:
-        _logger.error(_("Unable to start launcher because of errors:"))
-        for problem in launcher.problem_list:
-            _logger.error("%s", str(problem))
-        raise SystemExit(1)
-    return launcher
+                cfg.update_from_another(
+                    Configuration.from_path(config),
+                    'config file: {}'.format(config))
+            else:
+                _logger.info(
+                    "Referenced config file doesn't exist: %s", config)
+    new_cfg_filename = cfg.get_value('config', 'config_filename')
+    if new_cfg_filename != previous_cfg_name:
+        load_configs(launcher_file, cfg)
+    if launcher_file:
+        cfg.update_from_another(
+            Configuration.from_path(launcher_file),
+            'Launcher file: {}'.format(launcher_file))
+    return cfg
diff --git a/checkbox_ng/launcher/check_config.py b/checkbox_ng/launcher/check_config.py
index 359d3ca..0ac3088 100644
--- a/checkbox_ng/launcher/check_config.py
+++ b/checkbox_ng/launcher/check_config.py
@@ -1,6 +1,6 @@
 # This file is part of Checkbox.
 #
-# Copyright 2018-2019 Canonical Ltd.
+# Copyright 2018-2021 Canonical Ltd.
 # Written by:
 #   Maciej Kisielewski <[e-mail]>
 #
@@ -15,41 +15,38 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-from plainbox.impl.secure.config import ValidationError
-from plainbox.i18n import gettext as _
+"""This module contains the implementation of the `check-config` subcmd."""
 
 from checkbox_ng.config import load_configs
 
 
 class CheckConfig():
-    def invoked(self, ctx):
+    """Implementation of the `check-config` sub-command."""
+    @staticmethod
+    def invoked(_):
+        """Function that's run with `check-config` invocation."""
         config = load_configs()
-        print(_("Configuration files:"))
-        for filename in config.filename_list:
-            print(" - {}".format(filename))
-        for variable in config.Meta.variable_list:
-            print("   [{0}]".format(variable.section))
-            print("   {0}={1}".format(
-                variable.name,
-                variable.__get__(config, config.__class__)))
-        for section in config.Meta.section_list:
-            print("   [{0}]".format(section.name))
-            section_value = section.__get__(config, config.__class__)
-            if section_value:
-                for key, value in sorted(section_value.items()):
-                    print("   {0}={1}".format(key, value))
-        if config.problem_list:
-            print(_("Problems:"))
-            for problem in config.problem_list:
-                if isinstance(problem, ValidationError):
-                    print(_(" - variable {0}: {1}").format(
-                        problem.variable.name, problem.message))
-                else:
-                    print(" - {0}".format(problem.message))
-            return 1
-        else:
-            print(_("No validation problems found"))
+        print("Configuration files:")
+        for source in config.sources:
+            print(" - {}".format(source))
+        for sect_name, section in config.sections.items():
+            print("   [{0}]".format(sect_name))
+            for var_name in section.keys():
+                value = config.get_value(sect_name, var_name)
+                if isinstance(value, list):
+                    value = ', '.join(value)
+                origin = config.get_origin(sect_name, var_name)
+                origin = "From {}".format(origin) if origin else "(Default)"
+                key_val = "{}={}".format(var_name, value)
+                print("     {0: <34} {1}".format(key_val, origin))
+        problems = config.get_problems()
+        if not problems:
+            print("No problems with config(s) found!")
             return 0
+        print('Problems:')
+        for problem in problems:
+            print('- ', problem)
+        return 1
 
     def register_arguments(self, parser):
-        pass
+        """Register extra args for this subcmd. No extra args ATM."""
diff --git a/checkbox_ng/launcher/checkbox_cli.py b/checkbox_ng/launcher/checkbox_cli.py
index b69da17..9740eb8 100644
--- a/checkbox_ng/launcher/checkbox_cli.py
+++ b/checkbox_ng/launcher/checkbox_cli.py
@@ -27,8 +27,6 @@ import subprocess
 import sys
 
 from plainbox.impl.jobcache import ResourceJobCache
-from plainbox.impl.launcher import DefaultLauncherDefinition
-from plainbox.impl.launcher import LauncherDefinition
 from plainbox.impl.session.assistant import SessionAssistant
 
 from checkbox_ng.config import load_configs
diff --git a/checkbox_ng/launcher/master.py b/checkbox_ng/launcher/master.py
index 730fc02..2db2f7e 100644
--- a/checkbox_ng/launcher/master.py
+++ b/checkbox_ng/launcher/master.py
@@ -37,8 +37,7 @@ from functools import partial
 from tempfile import SpooledTemporaryFile
 
 from plainbox.impl.color import Colorizer
-from plainbox.impl.launcher import DefaultLauncherDefinition
-from plainbox.impl.secure.config import Unset
+from plainbox.impl.config import Configuration
 from plainbox.impl.session.remote_assistant import RemoteSessionAssistant
 from plainbox.vendor import rpyc
 from checkbox_ng.urwid_ui import TestPlanBrowser
@@ -111,7 +110,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
 
     @property
     def is_interactive(self):
-        return (self.launcher.ui_type == 'interactive' and
+        return (self.launcher.get_value('ui', 'type') == 'interactive' and
                 sys.stdin.isatty() and sys.stdout.isatty())
 
     @property
@@ -129,7 +128,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self._is_bootstrapping = False
         self._target_host = ctx.args.host
         self._normal_user = ''
-        self.launcher = DefaultLauncherDefinition()
+        self.launcher = Configuration()
         if ctx.args.launcher:
             expanded_path = os.path.expanduser(ctx.args.launcher)
             if not os.path.exists(expanded_path):
@@ -137,7 +136,8 @@ class RemoteMaster(ReportsStage, MainLoopStage):
                     expanded_path))
             with open(expanded_path, 'rt') as f:
                 self._launcher_text = f.read()
-            self.launcher.read_string(self._launcher_text)
+            self.launcher = Configuration.from_text(
+                    self._launcher_text, 'Remote:{}'.format(expanded_path))
         if ctx.args.user:
             self._normal_user = ctx.args.user
         timeout = 600
@@ -267,8 +267,8 @@ class RemoteMaster(ReportsStage, MainLoopStage):
             tps = self.sa.start_session(configuration)
         except RuntimeError as exc:
             raise SystemExit(exc.args[0]) from exc
-        if self.launcher.test_plan_forced:
-            self.select_tp(self.launcher.test_plan_default_selection)
+        if self.launcher.get_value('test plan', 'forced'):
+            self.select_tp(self.launcher.get_value('test plan', 'unit'))
             self.select_jobs(self.jobs)
         else:
             self.interactively_choose_tp(tps)
@@ -311,8 +311,8 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         return val.lower() in ('y', 'yes', 't', 'true', 'on', '1')
 
     def select_jobs(self, all_jobs):
-        if self.launcher.test_selection_forced:
-            if self.launcher.manifest is not Unset:
+        if self.launcher.get_value('test selection', 'forced'):
+            if self.launcher.manifest:
                 self.sa.save_manifest(
                     {manifest_id:
                      self._strtobool(self.launcher.manifest[manifest_id]) for
@@ -352,7 +352,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         Returns True if the remote should keep running.
         And False if it should quit.
         """
-        if self.launcher.ui_type == 'silent':
+        if self.launcher.get_value('ui', 'type'):
             self._sa.terminate()
             return False
         response = interrupt_dialog(self._target_host)
@@ -372,7 +372,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
 
     def finish_session(self):
         print(self.C.header("Results"))
-        if self.launcher.local_submission:
+        if self.launcher.get_value('launcher', 'local_submission'):
             # Disable SIGINT while we save local results
             with contextlib.ExitStack() as stack:
                 tmp_sig = signal.signal(signal.SIGINT, signal.SIG_IGN)
@@ -390,7 +390,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self.run_jobs()
 
     def _handle_last_job_after_resume(self, resumed_session_info):
-        if self.launcher.ui_type == 'silent':
+        if self.launcher.get_value('ui', 'type') == 'silent':
             time.sleep(20)
         else:
             resume_dialog(10)
@@ -420,11 +420,11 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self._run_jobs(jobs_repr, total_num)
         rerun_candidates = self.sa.get_rerun_candidates('manual')
         if rerun_candidates:
-            if self.launcher.ui_type == 'interactive':
+            if self.launcher.get_value('ui', 'type') == 'interactive':
                 while True:
                     if not self._maybe_manual_rerun_jobs():
                         break
-        if self.launcher.auto_retry:
+        if self.launcher.get_value('ui', 'auto_retry'):
             while True:
                 if not self._maybe_auto_rerun_jobs():
                     break
@@ -510,7 +510,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         if not rerun_candidates:
             return False
         # we wait before retrying
-        delay = self.launcher.delay_before_retry
+        delay = self.launcher.get_value('ui', 'delay_before_retry')
         _logger.info(_("Waiting {} seconds before retrying failed"
                        " jobs...".format(delay)))
         time.sleep(delay)
diff --git a/checkbox_ng/launcher/stages.py b/checkbox_ng/launcher/stages.py
index 84bdfe1..7c44561 100644
--- a/checkbox_ng/launcher/stages.py
+++ b/checkbox_ng/launcher/stages.py
@@ -26,9 +26,11 @@ import json
 import logging
 import os
 import time
+import textwrap
 
 from plainbox.abc import IJobResult
 from plainbox.i18n import pgettext as C_
+from plainbox.impl.config import Configuration
 from plainbox.impl.result import JobResultBuilder
 from plainbox.impl.result import tr_outcome
 from plainbox.impl.transport import InvalidSecureIDError
@@ -316,42 +318,44 @@ class ReportsStage(CheckboxUiStage):
         self._export_fn = export_fn
 
     def _prepare_stock_report(self, report):
-        # this is purposefully not using pythonic dict-keying for better
-        # readability
-        if not self.sa.config.transports:
-            self.sa.config.transports = dict()
-        if not self.sa.config.exporters:
-            self.sa.config.exporters = dict()
-        if not self.sa.config.reports:
-            self.sa.config.reports = dict()
+
+        new_origin = 'stock_reports'
         if report == 'text':
-            self.sa.config.exporters['text'] = {
-                'unit': 'com.canonical.plainbox::text'}
-            self.sa.config.transports['stdout'] = {
-                'type': 'stream', 'stream': 'stdout'}
-            # '1_' prefix ensures ordering amongst other stock reports. This
-            # report name does not appear anywhere (because of forced: yes)
-            self.sa.config.reports['1_text_to_screen'] = {
-                'transport': 'stdout', 'exporter': 'text', 'forced': 'yes'}
+            additional_config = Configuration.from_text(textwrap.dedent("""
+                [exporter:text]
+                unit = com.canonical.plainbox::text
+                [transport:stdout]
+                stream = stdout
+                type = stream
+                [report:1_text_to_screen]
+                exporter = text
+                forced = yes
+                transport = stdout
+            """), new_origin)
+            self.sa.config.update_from_another(additional_config, new_origin)
         elif report == 'certification':
-            self.sa.config.exporters['tar'] = {
-                'unit': 'com.canonical.plainbox::tar'}
-            self.sa.config.transports['c3'] = {
-                'type': 'submission-service',
-                'secure_id': self.sa.config.transports.get('c3', {}).get(
-                    'secure_id', None)}
-            self.sa.config.reports['upload to certification'] = {
-                'transport': 'c3', 'exporter': 'tar'}
+            additional_config = Configuration.from_text(textwrap.dedent("""
+                [exporter:tar]
+                unit = com.canonical.plainbox::tar
+                [transport:c3]
+                type = submission-service
+                [report:upload to certification]
+                exporter = tar
+                transport = c3
+            """), new_origin)
+            self.sa.config.update_from_another(additional_config, new_origin)
         elif report == 'certification-staging':
-            self.sa.config.exporters['tar'] = {
-                'unit': 'com.canonical.plainbox::tar'}
-            self.sa.config.transports['c3-staging'] = {
-                'type': 'submission-service',
-                'secure_id': self.sa.config.transports.get('c3', {}).get(
-                    'secure_id', None),
-                'staging': 'yes'}
-            self.sa.config.reports['upload to certification-staging'] = {
-                'transport': 'c3-staging', 'exporter': 'tar'}
+            additional_config = Configuration.from_text(textwrap.dedent("""
+                [exporter:tar]
+                unit = com.canonical.plainbox::tar
+                [transport:c3]
+                staging = yes
+                type = submission-service
+                [report:upload to certification-staging]
+                exporter = tar
+                transport = c3
+            """), new_origin)
+            self.sa.config.update_from_another(additional_config, new_origin)
         elif report == 'submission_files':
             # LP:1585326 maintain isoformat but removing ':' chars that cause
             # issues when copying files.
@@ -364,21 +368,21 @@ class ReportsStage(CheckboxUiStage):
                                        ('tar', '.tar.xz')]:
                 path = os.path.join(self.base_dir, ''.join(
                     ['submission_', timestamp, file_ext]))
-                self.sa.config.transports['{}_file'.format(exporter)] = {
-                    'type': 'file',
-                    'path': path}
-                if exporter not in self.sa.config.exporters:
-                    self.sa.config.exporters[exporter] = {
-                        'unit': 'com.canonical.plainbox::{}'.format(
-                            exporter)}
-                if not self.sa.config.exporters[exporter].get('unit'):
-                    unit = 'com.canonical.plainbox::{}'.format(exporter)
-                    self.sa.config.exporters[exporter]['unit'] = unit
-                self.sa.config.reports['2_{}_file'.format(exporter)] = {
-                    'transport': '{}_file'.format(exporter),
-                    'exporter': '{}'.format(exporter),
-                    'forced': 'yes'
-                }
+                template = textwrap.dedent("""
+                    [transport:{exporter}_file]
+                    path = {path}
+                    type = file
+                    [exporter:{exporter}]
+                    unit = com.canonical.plainbox::{exporter}
+                    [report:2_{exporter}_file]
+                    exporter = {exporter}
+                    forced = yes
+                    transport = {exporter}_file
+                """)
+                additional_config = Configuration.from_text(
+                    template.format(exporter=exporter, path=path), new_origin)
+                self.sa.config.update_from_another(
+                    additional_config, new_origin)
 
     def _prepare_transports(self):
         self.base_dir = os.path.join(
@@ -394,7 +398,9 @@ class ReportsStage(CheckboxUiStage):
         # depending on the type of transport we need to pick variable that
         # serves as the 'where' param for the transport. In case of
         # certification site the URL is supplied here
-        tr_type = self.sa.config.transports[transport]['type']
+        transport_cfg = self.sa.config.get_parametric_sections(
+            'transport')[transport]
+        tr_type = transport_cfg['type']
         if tr_type not in self._available_transports:
             _logger.error(_("Unrecognized type '%s' of transport '%s'"),
                           tr_type, transport)
@@ -402,14 +408,11 @@ class ReportsStage(CheckboxUiStage):
         cls = self._available_transports[tr_type]
         if tr_type == 'file':
             self.transports[transport] = cls(
-                os.path.expanduser(
-                    self.sa.config.transports[transport]['path']))
+                os.path.expanduser(transport_cfg['path']))
         elif tr_type == 'stream':
-            self.transports[transport] = cls(
-                self.sa.config.transports[transport]['stream'])
+            self.transports[transport] = cls(transport_cfg['stream'])
         elif tr_type == 'submission-service':
-            secure_id = self.sa.config.transports[transport].get(
-                'secure_id', None)
+            secure_id = transport_cfg.get('secure_id', None)
             if self.is_interactive:
                 new_description = input(self.C.BLUE(_(
                     'Enter submission description (press Enter to skip): ')))
@@ -425,7 +428,7 @@ class ReportsStage(CheckboxUiStage):
                 options = "secure_id={}".format(secure_id)
             else:
                 options = ""
-            if self.sa.config.transports[transport].get('staging', False):
+            if transport_cfg.get('staging', False):
                 url = ('https://certification.staging.canonical.com/'
                        'api/v1/submission/{}/'.format(secure_id))
             elif os.getenv('C3_URL'):
@@ -437,14 +440,15 @@ class ReportsStage(CheckboxUiStage):
             self.transports[transport] = cls(url, options)
 
     def _export_results(self):
-        if 'none' not in self.sa.config.stock_reports:
-            for report in self.sa.config.stock_reports:
+        stock_reports = self.sa.config.get_value('launcher', 'stock_reports')
+        if 'none' not in stock_reports:
+            for report in stock_reports:
                 if report in ['certification', 'certification-staging']:
                     # skip stock c3 report if secure_id is not given from
                     # config files or launchers, and the UI is non-interactive
                     # (silent)
-                    if ('c3' not in self.sa.config.transports and
-                            not self.is_interactive):
+                    if ('transport:c3' not in self.sa.config.sections.keys()
+                            and not self.is_interactive):
                         continue
                     # don't generate stock c3 reports if sideloaded providers
                     # were in use, something that should only be done during
@@ -457,7 +461,9 @@ class ReportsStage(CheckboxUiStage):
         # reports are stored in an ordinary dict(), so sorting them ensures
         # the same order of submitting them between runs, and if they
         # share common prefix, they are next to each other
-        for name, params in sorted(self.sa.config.reports.items()):
+        for name, params in sorted(
+                self.sa.config.get_parametric_sections('report').items()):
+
             # don't generate stock c3 reports if sideloaded providers
             # were in use, something that should only be done during
             # development
@@ -476,8 +482,10 @@ class ReportsStage(CheckboxUiStage):
                 cmd = 'y'
             if cmd == 'n':
                 continue
-            exporter_id = self.sa.config.exporters[params['exporter']]['unit']
-            exporter_options = self.sa.config.exporters[
+            all_exporters = self.sa.config.get_parametric_sections('exporter')
+            exporter_id = self.sa.config.get_parametric_sections('exporter')[
+                    params['exporter']]['unit']
+            exp_options = self.sa.config.get_parametric_sections('exporter')[
                     params['exporter']].get('options', '').split()
             done_sending = False
             while not done_sending:
@@ -489,7 +497,7 @@ class ReportsStage(CheckboxUiStage):
                     else:
                         try:
                             result = self.sa.export_to_transport(
-                                exporter_id, transport, exporter_options)
+                                exporter_id, transport, exp_options)
                         except ExporterError as exc:
                             _logger.warning(
                                 _("Problem occured when preparing %s report:"
@@ -512,14 +520,14 @@ class ReportsStage(CheckboxUiStage):
                 except InvalidSecureIDError:
                     _logger.warning(_("Invalid secure_id"))
                     if self._retry_dialog():
-                        self.sa.config.transports['c3'].pop('secure_id')
+                        self.sa.config.sections['transports']['c3'].pop(
+                            'secure_id')
                         continue
-                except Exception:
+                except Exception as exc:
                     _logger.error(
                         _("Problem with a '%s' report using '%s' exporter "
-                          "sent to '%s' transport."),
-                        name, exporter_id, transport.url)
-                self._reset_auto_submission_retries()
+                          "sent to '%s' transport. Reason %s"),
+                        name, exporter_id, transport.url, exc)
                 done_sending = True
 
     def _retry_dialog(self):
@@ -541,3 +549,14 @@ class ReportsStage(CheckboxUiStage):
                 return True
 
         return False
+
+template = textwrap.dedent("""
+    [transport:{exporter}_file]
+    type = file
+    path = {path}
+    [exporter:{exporter}]
+    unit = com.canonical.plainbox::{exporter}
+    [report:2_{exporter}_file]
+    transport = {exporter}_file
+    exporter = {exporter}
+    forced = yes""")
diff --git a/checkbox_ng/launcher/subcommands.py b/checkbox_ng/launcher/subcommands.py
index b4f4350..1c51ac5 100644
--- a/checkbox_ng/launcher/subcommands.py
+++ b/checkbox_ng/launcher/subcommands.py
@@ -42,7 +42,6 @@ from plainbox.impl.execution import UnifiedRunner
 from plainbox.impl.highlevel import Explorer
 from plainbox.impl.result import MemoryJobResult
 from plainbox.impl.runner import slugify
-from plainbox.impl.secure.config import Unset
 from plainbox.impl.secure.sudo_broker import sudo_password_provider
 from plainbox.impl.session.assistant import SA_RESTARTABLE
 from plainbox.impl.session.restart import detect_restart_strategy
@@ -168,10 +167,10 @@ class Launcher(MainLoopStage, ReportsStage):
         return self._C
 
     def get_sa_api_version(self):
-        return self.launcher.api_version
+        return '0.99'
 
     def get_sa_api_flags(self):
-        return self.launcher.api_flags
+        return [SA_RESTARTABLE]
 
     def invoked(self, ctx):
         if ctx.args.version:
@@ -184,12 +183,12 @@ class Launcher(MainLoopStage, ReportsStage):
             # exited by now, so validation passed
             print(_("Launcher seems valid."))
             return
-        self.launcher = load_configs(ctx.args.launcher)
+        self.configuration = load_configs(ctx.args.launcher)
         logging_level = {
             'normal': logging.WARNING,
             'verbose': logging.INFO,
             'debug': logging.DEBUG,
-        }[self.launcher.verbosity]
+        }[self.configuration.get_value('ui', 'verbosity')]
         if not ctx.args.verbose and not ctx.args.debug:
             # Command line args take precendence
             logging.basicConfig(level=logging_level)
@@ -200,25 +199,28 @@ class Launcher(MainLoopStage, ReportsStage):
             # replace the previously built SA with the defaults
             self._configure_restart(ctx)
             self._prepare_transports()
-            ctx.sa.use_alternate_configuration(self.launcher)
+            ctx.sa.use_alternate_configuration(self.configuration)
             if not self._maybe_resume_session():
                 self._start_new_session()
                 self._pick_jobs_to_run()
             if not self.ctx.sa.get_static_todo_list():
                 return 0
-            if 'submission_files' in self.launcher.stock_reports:
+            if 'submission_files' in self.configuration.get_value(
+                    'launcher', 'stock_reports'):
                 print("Reports will be saved to: {}".format(self.base_dir))
             # we initialize the nb of attempts for all the selected jobs...
             for job_id in self.ctx.sa.get_dynamic_todo_list():
                 job_state = self.ctx.sa.get_job_state(job_id)
-                job_state.attempts = self.launcher.max_attempts
+                job_state.attempts = self.configuration.get_value(
+                    'ui', 'max_attempts')
             # ... before running them
             self._run_jobs(self.ctx.sa.get_dynamic_todo_list())
-            if self.is_interactive and not self.launcher.auto_retry:
+            if self.is_interactive and not self.configuration.get_value(
+                'ui', 'auto_retry'):
                 while True:
                     if not self._maybe_rerun_jobs():
                         break
-            elif self.launcher.auto_retry:
+            elif self.configuration.get_value('ui', 'auto_retry'):
                 while True:
                     if not self._maybe_auto_rerun_jobs():
                         break
@@ -235,37 +237,14 @@ class Launcher(MainLoopStage, ReportsStage):
 
         We can then interact with the user when we encounter OUTCOME_UNDECIDED.
         """
-        return (self.launcher.ui_type == 'interactive' and
-                sys.stdin.isatty() and sys.stdout.isatty())
+        return (self.configuration.get_value('ui', 'type')  == 'interactive'
+                and sys.stdin.isatty() and sys.stdout.isatty())
 
     def _configure_restart(self, ctx):
         if SA_RESTARTABLE not in self.get_sa_api_flags():
             return
-        if self.launcher.restart_strategy:
-            try:
-                cls = get_strategy_by_name(
-                    self.launcher.restart_strategy)
-                kwargs = copy.deepcopy(self.launcher.restart)
-                # [restart] section has the kwargs for the strategy initializer
-                # and the 'strategy' which is not one, let's pop it
-                kwargs.pop('strategy')
-                strategy = cls(**kwargs)
-                ctx.sa.use_alternate_restart_strategy(strategy)
-
-            except KeyError:
-                _logger.warning(_('Unknown restart strategy: %s', (
-                    self.launcher.restart_strategy)))
-                _logger.warning(_(
-                    'Using automatically detected restart strategy'))
-                try:
-                    strategy = detect_restart_strategy()
-                except LookupError as exc:
-                    _logger.warning(exc)
-                    _logger.warning(_('Automatic restart disabled!'))
-                    strategy = None
-        else:
+        try:
             strategy = detect_restart_strategy()
-        if strategy:
             # gluing the command with pluses b/c the middle part
             # (launcher path) is optional
             snap_name = os.getenv('SNAP_NAME')
@@ -282,6 +261,9 @@ class Launcher(MainLoopStage, ReportsStage):
             respawn_cmd += '--resume {}'  # interpolate with session_id
             ctx.sa.configure_application_restart(
                 lambda session_id: [respawn_cmd.format(session_id)])
+        except LookupError as exc:
+            _logger.warning(exc)
+            _logger.warning(_('Automatic restart disabled!'))
 
     def _maybe_resume_session(self):
         resume_candidates = list(self.ctx.sa.get_resumable_sessions())
@@ -338,18 +320,21 @@ class Launcher(MainLoopStage, ReportsStage):
 
     def _start_new_session(self):
         print(_("Preparing..."))
-        title = self.ctx.args.title or self.launcher.session_title
-        title = title or self.launcher.app_id
-        if self.launcher.app_version:
-            title += ' {}'.format(self.launcher.app_version)
+        title = self.ctx.args.title or self.configuration.get_value(
+            'launcher', 'session_title')
+        title = title or self.configuration.get_value('launcher', 'app_id')
+        if self.configuration.get_value('launcher', 'app_version'):
+            title += ' {}'.format(self.configuration.get_value(
+                'launcher', 'app_version'))
         runner_kwargs = {
-            'normal_user_provider': lambda: self.launcher.normal_user,
+            'normal_user_provider': lambda: self.configuration.get_value(
+                'daemon', 'normal_user'),
             'password_provider': sudo_password_provider.get_sudo_password,
             'stdin': None,
         }
         self.ctx.sa.start_new_session(title, UnifiedRunner, runner_kwargs)
-        if self.launcher.test_plan_forced:
-            tp_id = self.launcher.test_plan_default_selection
+        if self.configuration.get_value('test plan', 'forced'):
+            tp_id = self.configuration.get_value('test plan', 'unit')
             if tp_id not in self.ctx.sa.get_test_plans():
                 _logger.error(_(
                     'The test plan "%s" is not available!'), tp_id)
@@ -365,7 +350,8 @@ class Launcher(MainLoopStage, ReportsStage):
             if tp_id is None:
                 raise SystemExit(_("No test plan selected."))
         self.ctx.sa.select_test_plan(tp_id)
-        description = self.ctx.args.message or self.launcher.session_desc
+        description = self.ctx.args.message or self.configuration.get_value(
+                'launcher', 'session_desc')
         self.ctx.sa.update_app_blob(json.dumps(
             {'testplan_id': tp_id,
              'description': description}).encode("UTF-8"))
@@ -380,7 +366,7 @@ class Launcher(MainLoopStage, ReportsStage):
     def _interactively_pick_test_plan(self):
         test_plan_ids = self.ctx.sa.get_test_plans()
         filtered_tp_ids = set()
-        for filter in self.launcher.test_plan_filters:
+        for filter in self.configuration.get_value('test plan', 'filter'):
             filtered_tp_ids.update(fnmatch.filter(test_plan_ids, filter))
         tp_info_list = self._generate_tp_infos(filtered_tp_ids)
         if not tp_info_list:
@@ -388,19 +374,20 @@ class Launcher(MainLoopStage, ReportsStage):
             return
         selected_tp = TestPlanBrowser(
             _("Select test plan"), tp_info_list,
-            self.launcher.test_plan_default_selection).run()
+            self.configuration.get_value('test plan', 'unit')).run()
         return selected_tp
 
     def _strtobool(self, val):
         return val.lower() in ('y', 'yes', 't', 'true', 'on', '1')
 
     def _pick_jobs_to_run(self):
-        if self.launcher.test_selection_forced:
-            if self.launcher.manifest is not Unset:
+        if self.configuration.get_value('test selection', 'forced'):
+            if self.configuration.manifest:
                 self.ctx.sa.save_manifest(
                     {manifest_id:
-                     self._strtobool(self.launcher.manifest[manifest_id]) for
-                     manifest_id in self.launcher.manifest}
+                     self._strtobool(
+                         self.configuration.manifest[manifest_id]) for
+                     manifest_id in self.configuration.manifest}
                 )
             # by default all tests are selected; so we're done here
             return
@@ -492,7 +479,7 @@ class Launcher(MainLoopStage, ReportsStage):
         if not rerun_candidates:
             return False
         # we wait before retrying
-        delay = self.launcher.delay_before_retry
+        delay = self.configuration.get_value('ui', 'delay_before_retry')
         _logger.info(_("Waiting {} seconds before retrying failed"
                        " jobs...".format(delay)))
         time.sleep(delay)
@@ -525,10 +512,11 @@ class Launcher(MainLoopStage, ReportsStage):
             def considering_job(self, job, job_state):
                 pass
         show_out = True
-        if self.launcher.output == 'hide-resource-and-attachment':
+        output = self.configuration.get_value('ui', 'output')
+        if output == 'hide-resource-and-attachment':
             if job.plugin in ('local', 'resource', 'attachment'):
                 show_out = False
-        elif self.launcher.output in ['hide', 'hide-automated']:
+        elif output in ['hide', 'hide-automated']:
             if job.plugin in ('shell', 'local', 'resource', 'attachment'):
                 show_out = False
         if 'suppress-output' in job.get_flag_set():
diff --git a/plainbox/impl/applogic.py b/plainbox/impl/applogic.py
index 1d90dfd..84f9906 100644
--- a/plainbox/impl/applogic.py
+++ b/plainbox/impl/applogic.py
@@ -31,7 +31,6 @@ import os
 from plainbox.abc import IJobResult
 from plainbox.i18n import gettext as _
 from plainbox.impl.result import MemoryJobResult
-from plainbox.impl.secure import config
 from plainbox.impl.secure.qualifiers import select_jobs
 from plainbox.impl.session import SessionManager
 from plainbox.impl.session.jobs import InhibitionCause
@@ -80,23 +79,6 @@ def run_job_if_possible(session, runner, config, job, update=True, ui=None):
     return job_state, job_result
 
 
-class PlainBoxConfig(config.Config):
-    """
-    Configuration for PlainBox itself
-    """
-
-    environment = config.Section(
-        help_text=_("Environment variables for scripts and jobs"))
-
-    class Meta:
-
-        # TODO: properly depend on xdg and use real code that also handles
-        # XDG_CONFIG_HOME.
-        filename_list = [
-            '/etc/xdg/plainbox.conf',
-            os.path.expanduser('~/.config/plainbox.conf')]
-
-
 def get_all_exporter_names():
     """
     Get the identifiers (names) of all the supported session state exporters.
diff --git a/plainbox/impl/commands/__init__.py b/plainbox/impl/commands/__init__.py
index 5a26853..efdb1f6 100644
--- a/plainbox/impl/commands/__init__.py
+++ b/plainbox/impl/commands/__init__.py
@@ -47,7 +47,6 @@ class PlainBoxToolBase(ToolBase):
     1. :meth:`get_exec_name()` -- to know how the command will be called
     2. :meth:`get_exec_version()` -- to know how the version of the tool
     3. :meth:`add_subcommands()` -- to add some actual commands to execute
-    4. :meth:`get_config_cls()` -- to know which config to use
 
     This class has some complex control flow to support important and
     interesting use cases. There are some concerns to people that subclass this
@@ -69,16 +68,6 @@ class PlainBoxToolBase(ToolBase):
     known yet.
     """
 
-    @classmethod
-    @abc.abstractmethod
-    def get_config_cls(cls):
-        """
-        Get the Config class that is used by this implementation.
-
-        This can be overridden by subclasses to use a different config class
-        that is suitable for the particular application.
-        """
-
     def _load_config(self):
         return self.get_config_cls().get()
 
diff --git a/plainbox/impl/config.py b/plainbox/impl/config.py
new file mode 100644
index 0000000..05b4def
--- /dev/null
+++ b/plainbox/impl/config.py
@@ -0,0 +1,383 @@
+# This file is part of Checkbox.
+#
+# Copyright 2021-2022 Canonical Ltd.
+# Written by:
+#   Maciej Kisielewski <[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/>.
+"""
+This module defines class for handling Checkbox configs.
+
+If we ever need to add validators to config variables, the addition should be
+done in VarSpec (the fourth 'field').
+"""
+import io
+import logging
+import os
+import shlex
+
+from configparser import ConfigParser
+from collections import namedtuple, OrderedDict
+
+logger = logging.getLogger(__name__)
+
+
+class Configuration:
+    """
+    Checkbox configuration storing objects.
+
+    Checkbox configs store various information on how to run the Checkbox.
+    For instance what reports to generate, should the session be interactive,
+    and many others. Look at CONFIG_SPEC for details.
+    """
+    def __init__(self, source=None):
+        """Create a new configuration object filled with default values."""
+        self.sections = OrderedDict()
+        self._origins = dict()
+        self._problems = []
+        # sources is similar to origins, but instead of keeping an info on
+        # each variable, we note what configs got read in general
+        self._sources = [source] if source else []
+        for section, contents in CONFIG_SPEC:
+            if isinstance(contents, ParametricSection):
+                # we don't know what the actual section name will be,
+                # so let's wait with the creation until we know the full name
+                continue
+            if isinstance(contents, DynamicSection):
+                self.sections[section] = DynamicSection()
+            else:
+                self.sections[section] = OrderedDict()
+            self._origins[section] = dict()
+            for name, spec in sorted(contents.items()):
+                self.sections[section][name] = spec.default
+                self._origins[section][name] = ''
+
+    @property
+    def environment(self):
+        """Return contents of the environment section."""
+        return self.sections['environment']
+
+    @property
+    def manifest(self):
+        """Return contents of the manifest section."""
+        return self.sections['manifest']
+
+    @property
+    def sources(self):
+        """Return list of sources for this configuration."""
+        return self._sources
+
+    def notice_problem(self, problem):
+        """ Record and log problem encountered when building configuration."""
+        self._problems.append(problem)
+        logger.warning(problem)
+
+    def get_problems(self):
+        """Return a list of problem as strings."""
+        return self._problems
+
+    def get_value(self, section, name):
+        """Return a value of given `name` from given `section`,"""
+        return self.sections[section][name]
+
+    def get_origin(self, section, name):
+        """Return origin of the value."""
+        return self._origins[section][name]
+
+    def update_from_another(self, configuration, origin):
+        """
+        Update this configuration with values from `configuration`.
+
+        Only the values that are not defaults from 'configuration` are taken
+        into account.
+        """
+        for section, variables in configuration.sections.items():
+            for name in variables.keys():
+                new_origin = configuration.get_origin(section, name)
+                if new_origin:
+                    if ':' in section and section not in self.sections.keys():
+                        self.sections[section] = OrderedDict()
+                        self._origins[section] = dict()
+                    self.sections[section][name] = configuration.get_value(
+                        section, name)
+                    self._origins[section][name] = origin or new_origin
+        self._sources += configuration.sources
+        self._problems += configuration.get_problems()
+
+    def dyn_set_value(self, section, name, value, origin):
+        """Set a value of a var from a dynamic section."""
+        if section == 'environment':
+            name = name.upper()
+        self.sections[section][name] = value
+        self._origins[section][name] = origin
+
+    def set_value(self, section, name, value, origin):
+        """Set a new value for variable and update its origin."""
+        # we are kind off guaranteed that section will be found in the spec
+        # but let's make linters happy
+        if section in self._DYNAMIC_SECTIONS:
+            self.dyn_set_value(section, name, value, origin)
+            return
+        parametrized = False
+        if ':' in section:
+            parametrized = True
+            prefix, _ = section.split(':')
+        if parametrized:
+            # TODO: do the check here for typing
+            pass
+
+        index = -1
+        for i, (sect_name, spec) in enumerate(CONFIG_SPEC):
+            if sect_name == section:
+                index = i
+            if isinstance(spec, ParametricSection):
+                if parametrized and sect_name == prefix:
+                    if name not in spec:
+                        problem = (
+                            "Unexpected variable '{}' in section [{}] "
+                            "Origin: {}").format(name, section, origin)
+                        self.notice_problem(problem)
+                        return
+                    index = i
+        if index == -1:
+            # this should happen only for parametric sections
+            problem = "Unexpected section [{}]. Origin: {}".format(
+                section, origin)
+            self.notice_problem(problem)
+            return
+
+        assert index > -1
+        kind = CONFIG_SPEC[index][1][name].kind
+        try:
+            if kind == list:
+                value = shlex.split(value.replace(',', ' '))
+            else:
+                value = kind(value)
+            if parametrized:
+                # we couldn't have known the param names eariler (in __init__)
+                # but now we do know them, so let's create the dict to hold
+                # the values
+                if section not in self.sections.keys():
+                    self.sections[section] = OrderedDict()
+                    self._origins[section] = dict()
+            self.sections[section][name] = value
+            self._origins[section][name] = origin
+        except TypeError:
+            problem = (
+                "Problem with setting field {} in section [{}] "
+                "'{}' cannot be used as {}. Origin: {}").format(
+                    name, section, value, kind, origin)
+            self.notice_problem(problem)
+
+    def get_parametric_sections(self, prefix):
+        """
+        Return a dict of parametrised section that share the same prefix.
+
+        The resulting dict is keyed by the parameter, the values are dicts
+        with the declared variables.
+
+        E.g.
+        If there's two sections: [report:myrep] and [report:other]
+        The resulting dict will have two keys: myrep and other.
+        """
+        result = dict()
+        # check if there is such section declared in the SPEC
+        for sect_name, section in CONFIG_SPEC:
+            if not isinstance(section, ParametricSection):
+                continue
+            if sect_name == prefix:
+                break
+        else:
+            raise ValueError("No such section in the spec ({}".format(prefix))
+        for sect_name, section in self.sections.items():
+            sect_prefix, _, sect_param = sect_name.partition(':')
+            if sect_prefix == prefix:
+                result[sect_param] = section
+        return result
+
+    @classmethod
+    def from_text(cls, text, origin):
+        """
+        Create a new configuration with values from the text.
+
+        Behaves just the same as the from_ini_file method, but accepts string
+        as the param.
+        """
+        return cls.from_ini_file(io.StringIO(text), origin)
+
+    @classmethod
+    def from_path(cls, path):
+        """Create a new configuration with values stored in a file at path."""
+        cfg = Configuration()
+        if not os.path.isfile(path):
+            cfg.notice_problem("{} file not found".format(path))
+            return cfg
+        with open(path, 'rt') as ini_file:
+            return cls.from_ini_file(ini_file, path)
+
+    @classmethod
+    def from_ini_file(cls, ini_file, origin):
+        """
+        Create a new configuration with values from the ini file.
+
+        ini_file should be a file object.
+
+        This function is designed not to fail (raise), so if some entry in the
+        ini file is misdefined then it should be ignored and the default value
+        should be kept. Each such problem is kept in the self._problems list.
+        """
+        cfg = Configuration(origin)
+        parser = ConfigParser(delimiters='=')
+        parser.read_string(ini_file.read())
+        for sect_name, section in parser.items():
+            if sect_name == 'DEFAULT':
+                for var_name in section:
+                    problem = "[DEFAULT] section is not supported"
+                    cfg.notice_problem(problem)
+                continue
+            if ':' in sect_name:
+                for var_name, var in section.items():
+                    cfg.set_value(sect_name, var_name, var, origin)
+                continue
+            if sect_name not in cfg.sections:
+                problem = "Unexpected section [{}]. Origin: {}".format(
+                    sect_name, origin)
+                cfg.notice_problem(problem)
+                continue
+            for var_name, var in section.items():
+                is_dyn = sect_name in cls._DYNAMIC_SECTIONS
+                if var_name not in cfg.sections[sect_name] and not is_dyn:
+                    problem = (
+                        "Unexpected variable '{}' in section [{}] "
+                        "Origin: {}").format(var_name, sect_name, origin)
+                    cfg.notice_problem(problem)
+                    continue
+                cfg.set_value(sect_name, var_name, var, origin)
+        return cfg
+
+    _DYNAMIC_SECTIONS = ('environment', 'manifest')
+
+
+VarSpec = namedtuple('VarSpec', ['kind', 'default', 'help'])
+
+
+class ParametricSection(dict):
+    """ Dict for storing parametric section's contents."""
+
+
+class DynamicSection(dict):
+    """
+    Dict for storing dynamic section's contents.
+
+    This is an extra type to record the fact that this is a different section
+    compared to the predefined ones. It works and isn't very complex, but
+    a different way of storing this information might be more elegant.
+    """
+
+
+# in order to maintain the section order the CONFIG_SPEC is a list of pairs,
+# where the first value is the name of the section and the other is a dict
+# of variable specs.
+CONFIG_SPEC = [
+    ('config', {
+        'config_filename': VarSpec(
+            str, 'checkbox.conf',
+            'Name of the configuration file to look for.'),
+    }),
+    ('launcher', {
+        'launcher_version': VarSpec(
+            int, 1, "Version of launcher to use"),
+        'app_id': VarSpec(
+            str, 'checkbox-cli', "Identifier of the application"),
+        'app_version': VarSpec(
+            str, '', "Version of the application"),
+        'stock_reports': VarSpec(
+            list, ['text', 'certification', 'submission_files'],
+            "List of stock reports to use"),
+        'local_submission': VarSpec(
+            bool, True, ("Send/generate submission report locally when using "
+                         "checkbox remote")),
+        'session_title': VarSpec(
+            str, 'session title',
+            ("A title to be applied to the sessions created using this "
+                "launcher that can be used in report generation")),
+        'session_desc': VarSpec(
+            str, '', ("A string that can be applied to sessions created using "
+                      "this launcher. Useful for storing some contextual "
+                      "infomation about the session")),
+    }),
+    ('test plan', {
+        'filter': VarSpec(
+            list, ['*'],
+            "Constrain interactive choice to test plans matching this glob"),
+        'unit': VarSpec(str, '', "Select this test plan by default."),
+        'forced': VarSpec(
+            bool, False, "Don't allow the user to change test plan."),
+    }),
+    ('test selection', {
+        'forced': VarSpec(
+            bool, False, "Don't allow the user to alter test selection."),
+        'exclude': VarSpec(
+            list, [], "Exclude test matching patterns from running."),
+    }),
+    ('ui', {
+        'type': VarSpec(str, 'interactive', "Type of user interface to use."),
+        'output': VarSpec(str, 'show', "Silence or restrict command output."),
+        'dont_suppress_output': VarSpec(
+            bool, False,
+            "Don't suppress the output of certain job plugin types."),
+        'verbosity': VarSpec(str, 'normal', "Verbosity level."),
+        'auto_retry': VarSpec(
+            bool, False,
+            "Automatically retry failed jobs at the end of the session."),
+        'max_attempts': VarSpec(
+            int, 3,
+            "Number of attempts to run a job when in auto-retry mode."),
+        'delay_before_retry': VarSpec(
+            int, 1, ("Delay (in seconds) before "
+                     "retrying failed jobs in auto-retry mode.")),
+    }),
+    ('daemon', {
+        'normal_user': VarSpec(
+            str, '', "Username to use for jobs that don't specify user."),
+    }),
+    ('restart', {
+        'strategy': VarSpec(str, '', "Use alternative restart strategy."),
+    }),
+    ('report', ParametricSection({
+        'exporter': VarSpec(
+            str, '', "Name of the exporter to use"),
+        'transport': VarSpec(
+            str, '', "Name of the transport to use"),
+        'forced': VarSpec(
+            bool, False, "Don't ask the user if they want the report."),
+    })),
+    ('transport', ParametricSection({
+        'type': VarSpec(
+            str, '', "Type of transport to use."),
+        'stream': VarSpec(
+            str, 'stdout', "Stream to use - stdout or stderr."),
+        'path': VarSpec(
+            str, '', "Path to where the report should be saved to."),
+        'secure_id': VarSpec(
+            str, '',  "Secure ID to use."),
+        'staging': VarSpec(
+            bool, False, "Pushes to staging C3 instead of normal C3."),
+    })),
+    ('exporter', ParametricSection({
+        'unit': VarSpec(str, '', "ID of the exporter to use."),
+        'options': VarSpec(list, [], "Flags to forward to the exporter."),
+    })),
+    ('environment', DynamicSection()),
+    ('manifest', DynamicSection()),
+]
diff --git a/plainbox/impl/ctrl.py b/plainbox/impl/ctrl.py
index 5facd64..2242114 100644
--- a/plainbox/impl/ctrl.py
+++ b/plainbox/impl/ctrl.py
@@ -60,7 +60,6 @@ from plainbox.impl.resource import ExpressionCannotEvaluateError
 from plainbox.impl.resource import ExpressionFailedError
 from plainbox.impl.resource import ResourceProgramError
 from plainbox.impl.resource import Resource
-from plainbox.impl.secure.config import Unset
 from plainbox.impl.secure.origin import JobOutputTextSource
 from plainbox.impl.secure.providers.v1 import Provider1
 from plainbox.impl.secure.rfc822 import RFC822SyntaxError
diff --git a/plainbox/impl/launcher.py b/plainbox/impl/launcher.py
deleted file mode 100644
index 16b3059..0000000
--- a/plainbox/impl/launcher.py
+++ /dev/null
@@ -1,258 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2014-2016 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#   Maciej Kisielewski <[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.launcher` -- launcher definition
-==================================================
-"""
-
-from gettext import gettext as _
-import logging
-
-from plainbox.impl.applogic import PlainBoxConfig
-from plainbox.impl.secure import config
-from plainbox.impl.session.assistant import SA_RESTARTABLE
-from plainbox.impl.session.assistant import get_all_sa_flags
-from plainbox.impl.session.assistant import get_known_sa_api_versions
-from plainbox.impl.transport import get_all_transports
-from plainbox.impl.transport import SECURE_ID_PATTERN
-
-
-logger = logging.getLogger("plainbox.launcher")
-
-
-class LauncherDefinition(PlainBoxConfig):
-    """
-    Launcher definition.
-
-    Launchers are small executables using one of the available user interfaces
-    as the interpreter. This class contains all the available options that can
-    be set inside the launcher, that will affect the user interface at runtime.
-    This generic launcher definition class helps to pick concrete version of
-    the launcher definition.
-    """
-    launcher_version = config.Variable(
-        section="launcher",
-        help_text=_("Version of launcher to use"))
-
-    config_filename = config.Variable(
-        section="config",
-        default="checkbox.conf",
-        help_text=_("Name of custom configuration file"))
-
-    def get_concrete_launcher(self):
-        """Create appropriate LauncherDefinition instance.
-
-        Depending on the value of launcher_version variable appropriate
-        LauncherDefinition class is chosen and its instance returned.
-
-        :returns: LauncherDefinition instance
-        :raises KeyError: for unknown launcher_version values
-        """
-        return {'1': LauncherDefinition1}[self.launcher_version]()
-
-
-class LauncherDefinition1(LauncherDefinition):
-    """
-    Definition for launchers version 1.
-
-    As specced in https://goo.gl/qJYtPX
-    """
-
-    def __init__(self):
-        super().__init__()
-
-    launcher_version = config.Variable(
-        section="launcher",
-        default='1',
-        help_text=_("Version of launcher to use"))
-
-    app_id = config.Variable(
-        section='launcher',
-        default='checkbox-cli',
-        help_text=_('Identifier of the application'))
-
-    app_version = config.Variable(
-        section='launcher',
-        help_text=_('Version of the application'))
-
-    api_flags = config.Variable(
-        section='launcher',
-        kind=list,
-        default=[SA_RESTARTABLE],
-        validator_list=[config.SubsetValidator(get_all_sa_flags())],
-        help_text=_('List of feature-flags the application requires'))
-
-    api_version = config.Variable(
-        section='launcher',
-        default='0.99',
-        validator_list=[config.ChoiceValidator(
-            get_known_sa_api_versions())],
-        help_text=_('Version of API the launcher uses'))
-
-    stock_reports = config.Variable(
-        section='launcher',
-        kind=list,
-        validator_list=[
-            config.SubsetValidator({
-                'text', 'certification', 'certification-staging',
-                'submission_files', 'none'}),
-            config.OneOrTheOtherValidator(
-                {'none'}, {'text', 'certification', 'certification-staging',
-                           'submission_files'}),
-        ],
-        default=['text', 'certification', 'submission_files'],
-        help_text=_('List of stock reports to use'))
-
-    local_submission = config.Variable(
-        section='launcher',
-        kind=bool,
-        default=True,
-        help_text=_("Send/generate submission report locally when using "
-                    "checkbox remote"))
-
-    session_title = config.Variable(
-        section='launcher',
-        default='session title',
-        help_text=_("A title to be applied to the sessions created using "
-                    "this launcher that can be used in report generation"))
-
-    session_desc = config.Variable(
-        section='launcher',
-        default='',
-        help_text=_("A string that can be applied to sessions created using "
-                    "this launcher. Useful for storing some contextual "
-                    "infomation about the session"))
-
-    test_plan_filters = config.Variable(
-        section='test plan',
-        name='filter',
-        default=['*'],
-        kind=list,
-        help_text=_('Constrain interactive choice to test plans matching this'
-                    'glob'))
-
-    test_plan_default_selection = config.Variable(
-        section='test plan',
-        name='unit',
-        help_text=_('Select this test plan by default.'))
-
-    test_plan_forced = config.Variable(
-        section='test plan',
-        name='forced',
-        kind=bool,
-        default=False,
-        help_text=_("Don't allow the user to change test plan."))
-
-    test_selection_forced = config.Variable(
-        section='test selection',
-        name='forced',
-        kind=bool,
-        default=False,
-        help_text=_("Don't allow the user to alter test selection."))
-
-    test_exclude = config.Variable(
-        section='test selection',
-        name='exclude',
-        default=[],
-        kind=list,
-        help_text=_("Exclude test matching the patterns from running"))
-
-    ui_type = config.Variable(
-        section='ui',
-        name='type',
-        default='interactive',
-        validator_list=[config.ChoiceValidator(
-            ['interactive', 'silent'])],
-        help_text=_('Type of stock user interface to use.'))
-
-    output = config.Variable(
-        section='ui',
-        default='show',
-        validator_list=[config.ChoiceValidator(
-            ['show', 'hide', 'hide-resource-and-attachment',
-             'hide-automated'])],
-        help_text=_('Silence or restrict command output'))
-
-    dont_suppress_output = config.Variable(
-        section="ui", kind=bool, default=False,
-        help_text=_("Don't suppress the output of certain job plugin types."))
-
-    verbosity = config.Variable(
-        section="ui", validator_list=[config.ChoiceValidator(
-            ['normal', 'verbose', 'debug'])], help_text=_('Verbosity level'),
-        default='normal')
-
-    auto_retry = config.Variable(
-        section='ui',
-        kind=bool,
-        default=False,
-        help_text=_("Automatically retry failed jobs at the end"
-                    " of the session."))
-
-    max_attempts = config.Variable(
-        section='ui',
-        kind=int,
-        default=3,
-        help_text=_("Number of attempts to run a job when in auto-retry mode."))
-
-    delay_before_retry = config.Variable(
-        section='ui',
-        kind=int,
-        default=1,
-        help_text=_("Delay (in seconds) before retrying failed jobs in"
-                    " auto-retry mode."))
-
-    normal_user = config.Variable(
-        section='daemon',
-        kind=str,
-        default='',
-        help_text=_("Username to use for jobs that don't specify user"))
-
-    restart_strategy = config.Variable(
-        section='restart',
-        name='strategy',
-        help_text=_('Use alternative restart strategy'))
-
-    restart = config.Section(
-        help_text=_('Restart strategy parameters'))
-
-    reports = config.ParametricSection(
-        name='report',
-        help_text=_('Report declaration'))
-
-    exporters = config.ParametricSection(
-        name='exporter',
-        help_text=_('Exporter declaration'))
-
-    transports = config.ParametricSection(
-        name='transport',
-        help_text=_('Transport declaration'))
-
-    environment = config.Section(
-        help_text=_('Environment variables to use'))
-
-    daemon = config.Section(
-        name='daemon',
-        help_text=_('Daemon-specific configuration'))
-
-    manifest = config.Section(
-        help_text=_('Manifest entries to use'))
-
-DefaultLauncherDefinition = LauncherDefinition1
diff --git a/plainbox/impl/runner.py b/plainbox/impl/runner.py
index f46a99f..fae15fb 100644
--- a/plainbox/impl/runner.py
+++ b/plainbox/impl/runner.py
@@ -50,7 +50,6 @@ from plainbox.i18n import gettext as _
 from plainbox.impl.result import IOLogRecord
 from plainbox.impl.result import IOLogRecordWriter
 from plainbox.impl.result import JobResultBuilder
-from plainbox.impl.secure.config import Unset
 from plainbox.vendor import extcmd
 from plainbox.vendor import morris
 
diff --git a/plainbox/impl/secure/test_config.py b/plainbox/impl/secure/test_config.py
deleted file mode 100644
index 1efab12..0000000
--- a/plainbox/impl/secure/test_config.py
+++ /dev/null
@@ -1,608 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013, 2014 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/>.
-
-"""
-plainbox.impl.secure.test_config
-================================
-
-Test definitions for plainbox.impl.secure.config module
-"""
-from io import StringIO
-from unittest import TestCase
-import configparser
-
-from plainbox.impl.secure.config import ChoiceValidator
-from plainbox.impl.secure.config import ConfigMetaData
-from plainbox.impl.secure.config import KindValidator
-from plainbox.impl.secure.config import NotEmptyValidator
-from plainbox.impl.secure.config import NotUnsetValidator
-from plainbox.impl.secure.config import OneOrTheOtherValidator
-from plainbox.impl.secure.config import PatternValidator
-from plainbox.impl.secure.config import ParametricSection
-from plainbox.impl.secure.config import PlainBoxConfigParser, Config
-from plainbox.impl.secure.config import ValidationError
-from plainbox.impl.secure.config import Variable, Section, Unset
-from plainbox.impl.secure.config import understands_Unset
-from plainbox.vendor import mock
-
-
-class UnsetTests(TestCase):
-
-    def test_str(self):
-        self.assertEqual(str(Unset), "unset")
-
-    def test_repr(self):
-        self.assertEqual(repr(Unset), "Unset")
-
-    def test_bool(self):
-        self.assertEqual(bool(Unset), False)
-
-
-class understands_Unset_Tests(TestCase):
-
-    def test_func(self):
-        @understands_Unset
-        def func():
-            pass
-
-        self.assertTrue(hasattr(func, 'understands_Unset'))
-        self.assertTrue(getattr(func, 'understands_Unset'))
-
-    def test_cls(self):
-        @understands_Unset
-        class cls:
-            pass
-
-        self.assertTrue(hasattr(cls, 'understands_Unset'))
-        self.assertTrue(getattr(cls, 'understands_Unset'))
-
-
-class VariableTests(TestCase):
-
-    def test_name(self):
-        v1 = Variable()
-        self.assertIsNone(v1.name)
-        v2 = Variable('var')
-        self.assertEqual(v2.name, 'var')
-        v3 = Variable(name='var')
-        self.assertEqual(v3.name, 'var')
-
-    def test_section(self):
-        v1 = Variable()
-        self.assertEqual(v1.section, 'DEFAULT')
-        v2 = Variable(section='foo')
-        self.assertEqual(v2.section, 'foo')
-
-    def test_kind(self):
-        v1 = Variable(kind=bool)
-        self.assertIs(v1.kind, bool)
-        v2 = Variable(kind=int)
-        self.assertIs(v2.kind, int)
-        v3 = Variable(kind=float)
-        self.assertIs(v3.kind, float)
-        v4 = Variable(kind=str)
-        self.assertIs(v4.kind, str)
-        v5 = Variable()
-        self.assertIs(v5.kind, str)
-        v6 = Variable(kind=list)
-        self.assertIs(v6.kind, list)
-        with self.assertRaises(ValueError):
-            Variable(kind=dict)
-
-    def test_validator_list__default(self):
-        """
-        verify that each Variable has a validator_list and that by default,
-        that list contains a KindValidator as the first element
-        """
-        self.assertEqual(Variable().validator_list, [KindValidator])
-
-    def test_validator_list__explicit(self):
-        """
-        verify that each Variable has a validator_list and that, if
-        customized, the list contains the custom validators, preceded by
-        the implicit KindValidator object
-        """
-        def DummyValidator(variable, new_value):
-            """ Dummy validator for the test below"""
-            pass
-        var = Variable(validator_list=[DummyValidator])
-        self.assertEqual(var.validator_list, [KindValidator, DummyValidator])
-
-    def test_validator_list__with_NotUnsetValidator(self):
-        """
-        verify that each Variable has a validator_list and that, if
-        customized, and if using NotUnsetValidator it will take precedence
-        over all other validators, including the implicit KindValidator
-        """
-        var = Variable(validator_list=[NotUnsetValidator()])
-        self.assertEqual(
-            var.validator_list, [NotUnsetValidator(), KindValidator])
-
-
-class SectionTests(TestCase):
-
-    def test_name(self):
-        s1 = Section()
-        self.assertIsNone(s1.name)
-        s2 = Section('sec')
-        self.assertEqual(s2.name, 'sec')
-        s3 = Variable(name='sec')
-        self.assertEqual(s3.name, 'sec')
-
-
-class ConfigTests(TestCase):
-
-    def test_Meta_present(self):
-        class TestConfig(Config):
-            pass
-        self.assertTrue(hasattr(TestConfig, 'Meta'))
-
-    def test_Meta_base_cls(self):
-        class TestConfig(Config):
-            pass
-        self.assertTrue(issubclass(TestConfig.Meta, ConfigMetaData))
-
-        class HelperMeta:
-            pass
-
-        class TestConfigWMeta(Config):
-            Meta = HelperMeta
-        self.assertTrue(issubclass(TestConfigWMeta.Meta, ConfigMetaData))
-        self.assertTrue(issubclass(TestConfigWMeta.Meta, HelperMeta))
-
-    def test_Meta_variable_list(self):
-        class TestConfig(Config):
-            v1 = Variable()
-            v2 = Variable()
-        self.assertEqual(
-            TestConfig.Meta.variable_list,
-            [TestConfig.v1, TestConfig.v2])
-
-    def test_variable_smoke(self):
-        class TestConfig(Config):
-            v = Variable()
-        conf = TestConfig()
-        self.assertIs(conf.v, Unset)
-        conf.v = "value"
-        self.assertEqual(conf.v, "value")
-        del conf.v
-        self.assertIs(conf.v, Unset)
-
-    def _get_featureful_config(self):
-        # define a featureful config class
-        class TestConfig(Config):
-            v1 = Variable()
-            v2 = Variable(section="v23_section")
-            v3 = Variable(section="v23_section")
-            v_unset = Variable()
-            v_bool = Variable(section="type_section", kind=bool)
-            v_int = Variable(section="type_section", kind=int)
-            v_float = Variable(section="type_section", kind=float)
-            v_list = Variable(section="type_section", kind=list)
-            v_str = Variable(section="type_section", kind=str)
-            s = Section()
-            ps = ParametricSection()
-        conf = TestConfig()
-        # assign value to each variable, except v3_unset
-        conf.v1 = "v1 value"
-        conf.v2 = "v2 value"
-        conf.v3 = "v3 value"
-        conf.v_bool = True
-        conf.v_int = -7
-        conf.v_float = 1.5
-        conf.v_str = "hi"
-        conf.v_list = ['foo', 'bar']
-        # assign value to the section
-        conf.s = {"a": 1, "b": 2}
-        conf.ps = {"foo": {"c": 3, "d": 4}}
-        return conf
-
-    def test_get_parser_obj(self):
-        """
-        verify that Config.get_parser_obj() properly writes all the data to the
-        ConfigParser object.
-        """
-        conf = self._get_featureful_config()
-        parser = conf.get_parser_obj()
-        # verify that section and section-less variables work
-        self.assertEqual(parser.get("DEFAULT", "v1"), "v1 value")
-        self.assertEqual(parser.get("v23_section", "v2"), "v2 value")
-        self.assertEqual(parser.get("v23_section", "v3"), "v3 value")
-        # verify that unset variable is not getting set to anything
-        with self.assertRaises(configparser.Error):
-            parser.get("DEFAULT", "v_unset")
-        # verify that various types got converted correctly and still resolve
-        # to correct typed values
-        self.assertEqual(parser.get("type_section", "v_bool"), "True")
-        self.assertEqual(parser.getboolean("type_section", "v_bool"), True)
-        self.assertEqual(parser.get("type_section", "v_int"), "-7")
-        self.assertEqual(parser.getint("type_section", "v_int"), -7)
-        self.assertEqual(parser.get("type_section", "v_float"), "1.5")
-        self.assertEqual(parser.getfloat("type_section", "v_float"), 1.5)
-        self.assertEqual(parser.get("type_section", "v_str"), "hi")
-        # verify that section work okay
-        self.assertEqual(parser.get("s", "a"), "1")
-        self.assertEqual(parser.get("s", "b"), "2")
-        # verify that parametric section works okay
-        self.assertEqual(parser.get("ps:foo", "c"), "3")
-        self.assertEqual(parser.get("ps:foo", "d"), "4")
-
-    def test_write(self):
-        """
-        verify that Config.write() works
-        """
-        conf = self._get_featureful_config()
-        with StringIO() as stream:
-            conf.write(stream)
-            self.assertEqual(stream.getvalue(), (
-                "[DEFAULT]\n"
-                "v1 = v1 value\n"
-                "\n"
-                "[v23_section]\n"
-                "v2 = v2 value\n"
-                "v3 = v3 value\n"
-                "\n"
-                "[type_section]\n"
-                "v_bool = True\n"
-                "v_float = 1.5\n"
-                "v_int = -7\n"
-                "v_list = foo, bar\n"
-                "v_str = hi\n"
-                "\n"
-                "[s]\n"
-                "a = 1\n"
-                "b = 2\n"
-                "\n"
-                "[ps:foo]\n"
-                "c = 3\n"
-                "d = 4\n"
-                "\n"))
-
-    def test_section_smoke(self):
-        class TestConfig(Config):
-            s = Section()
-        conf = TestConfig()
-        self.assertIs(conf.s, Unset)
-        with self.assertRaises(TypeError):
-            conf.s['key'] = "key-value"
-        conf.s = {}
-        self.assertEqual(conf.s, {})
-        conf.s['key'] = "key-value"
-        self.assertEqual(conf.s['key'], "key-value")
-        del conf.s
-        self.assertIs(conf.s, Unset)
-
-    def test_read_string(self):
-        class TestConfig(Config):
-            v = Variable()
-        conf = TestConfig()
-        conf.read_string(
-            "[DEFAULT]\n"
-            "v = 1")
-        self.assertEqual(conf.v, "1")
-        self.assertEqual(len(conf.problem_list), 0)
-
-    def test_read_list_with_spaces(self):
-        class TestConfig(Config):
-            l = Variable(kind=list)
-        conf = TestConfig()
-        conf.read_string('[DEFAULT]\nl = foo bar')
-        self.assertEqual(conf.l, ['foo', 'bar'])
-        self.assertEqual(len(conf.problem_list), 0)
-
-    def test_read_list_with_commas(self):
-        class TestConfig(Config):
-            l = Variable(kind=list)
-        conf = TestConfig()
-        conf.read_string('[DEFAULT]\nl = foo,bar')
-        self.assertEqual(conf.l, ['foo', 'bar'])
-        self.assertEqual(len(conf.problem_list), 0)
-
-    def test_read_list_quoted_strings(self):
-        class TestConfig(Config):
-            l = Variable(kind=list)
-        conf = TestConfig()
-        conf.read_string('[DEFAULT]\nl = foo "bar baz"')
-        self.assertEqual(conf.l, ['foo', 'bar baz'])
-        self.assertEqual(len(conf.problem_list), 0)
-
-    def test_read_string_calls_validate_whole(self):
-        """
-        verify that Config.read_string() calls validate_whole()"
-        """
-        conf = Config()
-        with mock.patch.object(conf, 'validate_whole') as mocked_validate:
-            conf.read_string('')
-        mocked_validate.assert_called_once_with()
-
-    def test_read_calls_validate_whole(self):
-        """
-        verify that Config.read() calls validate_whole()"
-        """
-        conf = Config()
-        with mock.patch.object(conf, 'validate_whole') as mocked_validate:
-            conf.read([])
-        mocked_validate.assert_called_once_with()
-
-    def test_read__handles_errors_from_validate_whole(self):
-        """
-        verify that Config.read() collects errors from validate_whole()".
-        """
-        class TestConfig(Config):
-            v = Variable()
-
-            def validate_whole(self):
-                raise ValidationError(TestConfig.v, self.v, "v is evil")
-        conf = TestConfig()
-        conf.read([])
-        self.assertEqual(len(conf.problem_list), 1)
-        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
-        self.assertEqual(conf.problem_list[0].new_value, Unset)
-        self.assertEqual(conf.problem_list[0].message, "v is evil")
-
-    def test_read_string__does_not_ignore_nonmentioned_variables(self):
-        class TestConfig(Config):
-            v = Variable(validator_list=[NotUnsetValidator()])
-        conf = TestConfig()
-        conf.read_string("")
-        # Because Unset is the default, sadly
-        self.assertEqual(conf.v, Unset)
-        # But there was a problem noticed
-        self.assertEqual(len(conf.problem_list), 1)
-        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
-        self.assertEqual(conf.problem_list[0].new_value, Unset)
-        self.assertEqual(conf.problem_list[0].message,
-                         "must be set to something")
-
-    def test_read_string__handles_errors_from_validate_whole(self):
-        """
-        verify that Config.read_strig() collects errors from validate_whole()".
-        """
-        class TestConfig(Config):
-            v = Variable()
-
-            def validate_whole(self):
-                raise ValidationError(TestConfig.v, self.v, "v is evil")
-        conf = TestConfig()
-        conf.read_string("")
-        self.assertEqual(len(conf.problem_list), 1)
-        self.assertEqual(conf.problem_list[0].variable, TestConfig.v)
-        self.assertEqual(conf.problem_list[0].new_value, Unset)
-        self.assertEqual(conf.problem_list[0].message, "v is evil")
-
-
-class ConfigMetaDataTests(TestCase):
-
-    def test_filename_list(self):
-        self.assertEqual(ConfigMetaData.filename_list, [])
-
-    def test_variable_list(self):
-        self.assertEqual(ConfigMetaData.variable_list, [])
-
-    def test_section_list(self):
-        self.assertEqual(ConfigMetaData.section_list, [])
-
-    def test_parametric_section_list(self):
-        self.assertEqual(ConfigMetaData.parametric_section_list, [])
-
-
-class PlainBoxConfigParserTest(TestCase):
-
-    def test_parser(self):
-        conf_file = StringIO("[testsection]\nlower = low\nUPPER = up")
-        config = PlainBoxConfigParser()
-        config.read_file(conf_file)
-
-        self.assertEqual(['testsection'], config.sections())
-        all_keys = list(config['testsection'].keys())
-        self.assertTrue('lower' in all_keys)
-        self.assertTrue('UPPER' in all_keys)
-        self.assertFalse('upper' in all_keys)
-
-    def test_parametric_sections_parsing(self):
-        class TestConfig(Config):
-            ps = ParametricSection()
-        conf_str = "[ps:foo]\nval = baz\n[ps:bar]\nvar = biz"
-        config = TestConfig()
-        config.read_string(conf_str)
-        self.assertEqual(
-            config.ps,
-            {'foo': {'val': 'baz'}, 'bar': {'var': 'biz'}})
-
-
-class KindValidatorTests(TestCase):
-
-    class _Config(Config):
-        var_bool = Variable(kind=bool)
-        var_int = Variable(kind=int)
-        var_float = Variable(kind=float)
-        var_str = Variable(kind=str)
-
-    def test_error_msg(self):
-        """
-        verify that KindValidator() has correct error message for each type
-        """
-        bad_value = object()
-        self.assertEqual(
-            KindValidator(self._Config.var_bool, bad_value),
-            "expected a boolean")
-        self.assertEqual(
-            KindValidator(self._Config.var_int, bad_value),
-            "expected an integer")
-        self.assertEqual(
-            KindValidator(self._Config.var_float, bad_value),
-            "expected a floating point number")
-        self.assertEqual(
-            KindValidator(self._Config.var_str, bad_value),
-            "expected a string")
-
-
-class PatternValidatorTests(TestCase):
-
-    class _Config(Config):
-        var = Variable()
-
-    def test_smoke(self):
-        """
-        verify that PatternValidator works as intended
-        """
-        validator = PatternValidator("foo.+")
-        self.assertEqual(validator(self._Config.var, "foobar"), None)
-        self.assertEqual(
-            validator(self._Config.var, "foo"),
-            "does not match pattern: 'foo.+'")
-
-    def test_comparison_works(self):
-        self.assertTrue(PatternValidator('foo') == PatternValidator('foo'))
-        self.assertTrue(PatternValidator('foo') != PatternValidator('bar'))
-        self.assertTrue(PatternValidator('foo') != object())
-
-
-class ChoiceValidatorTests(TestCase):
-
-    class _Config(Config):
-        var = Variable()
-
-    def test_smoke(self):
-        """
-        verify that ChoiceValidator works as intended
-        """
-        validator = ChoiceValidator(["foo", "bar"])
-        self.assertEqual(validator(self._Config.var, "foo"), None)
-        self.assertEqual(
-            validator(self._Config.var, "omg"),
-            "var must be one of foo, bar. Got 'omg'")
-
-    def test_comparison_works(self):
-        self.assertTrue(ChoiceValidator(["a"]) == ChoiceValidator(["a"]))
-        self.assertTrue(ChoiceValidator(["a"]) != ChoiceValidator(["b"]))
-        self.assertTrue(ChoiceValidator(["a"]) != object())
-
-
-class NotUnsetValidatorTests(TestCase):
-    """
-    Tests for the NotUnsetValidator class
-    """
-
-    class _Config(Config):
-        var = Variable()
-
-    def test_understands_Unset(self):
-        """
-        verify that Unset can be handled at all
-        """
-        self.assertTrue(getattr(NotUnsetValidator, "understands_Unset"))
-
-    def test_rejects_unset_values(self):
-        """
-        verify that Unset variables are rejected
-        """
-        validator = NotUnsetValidator()
-        self.assertEqual(
-            validator(self._Config.var, Unset), "must be set to something")
-
-    def test_accepts_other_values(self):
-        """
-        verify that other values are accepted
-        """
-        validator = NotUnsetValidator()
-        self.assertIsNone(validator(self._Config.var, None))
-        self.assertIsNone(validator(self._Config.var, "string"))
-        self.assertIsNone(validator(self._Config.var, 15))
-
-    def test_supports_custom_message(self):
-        """
-        verify that custom message is used
-        """
-        validator = NotUnsetValidator("value required!")
-        self.assertEqual(
-            validator(self._Config.var, Unset), "value required!")
-
-    def test_comparison_works(self):
-        """
-        verify that comparison works as expected
-        """
-        self.assertTrue(NotUnsetValidator() == NotUnsetValidator())
-        self.assertTrue(NotUnsetValidator("?") == NotUnsetValidator("?"))
-        self.assertTrue(NotUnsetValidator() != NotUnsetValidator("?"))
-        self.assertTrue(NotUnsetValidator() != object())
-
-
-class NotEmptyValidatorTests(TestCase):
-
-    class _Config(Config):
-        var = Variable()
-
-    def test_rejects_empty_values(self):
-        validator = NotEmptyValidator()
-        self.assertEqual(validator(self._Config.var, ""), "cannot be empty")
-
-    def test_supports_custom_message(self):
-        validator = NotEmptyValidator("name required!")
-        self.assertEqual(validator(self._Config.var, ""), "name required!")
-
-    def test_isnt_broken(self):
-        validator = NotEmptyValidator()
-        self.assertEqual(validator(self._Config.var, "some value"), None)
-
-    def test_comparison_works(self):
-        self.assertTrue(NotEmptyValidator() == NotEmptyValidator())
-        self.assertTrue(NotEmptyValidator("?") == NotEmptyValidator("?"))
-        self.assertTrue(NotEmptyValidator() != NotEmptyValidator("?"))
-        self.assertTrue(NotEmptyValidator() != object())
-
-
-class OneOrTheOtherValidatorTests(TestCase):
-
-    class _Config(Config):
-        var = Variable("The Name", kind=list)
-
-    def test_pass_validation(self):
-        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
-        value = ['foo']
-        self.assertIsNone(validator(self._Config.var, value))
-        value = ['bar']
-        self.assertIsNone(validator(self._Config.var, value))
-
-    def test_fail_validation(self):
-        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
-        value = ['foo', 'bar']
-        self.assertEquals(
-            validator(self._Config.var, value),
-            "The Name can only use values from {'foo'} or from {'bar'}")
-
-    def test_pass_empty(self):
-        validator = OneOrTheOtherValidator({'foo'}, {'bar'})
-        value = []
-        self.assertIsNone(validator(self._Config.var, value))
-
-    def test_comparison_works(self):
-        self.assertEqual(
-            OneOrTheOtherValidator({'foo'}, {'bar'}),
-            OneOrTheOtherValidator({'foo'}, {'bar'})
-        )
-        self.assertEqual(
-            OneOrTheOtherValidator({1, 2}, {3, 4}),
-            OneOrTheOtherValidator({2, 1}, {4, 3})
-        )
-        self.assertNotEqual(
-            OneOrTheOtherValidator({1}, {2}),
-            OneOrTheOtherValidator({1}, {'foo'})
-        )
-        self.assertNotEqual(OneOrTheOtherValidator({1}, {2}), object())
diff --git a/plainbox/impl/session/assistant.py b/plainbox/impl/session/assistant.py
index b2d6991..c560828 100644
--- a/plainbox/impl/session/assistant.py
+++ b/plainbox/impl/session/assistant.py
@@ -38,16 +38,15 @@ from plainbox.abc import IJobResult
 from plainbox.abc import IJobRunnerUI
 from plainbox.abc import ISessionStateTransport
 from plainbox.i18n import gettext as _
-from plainbox.impl.applogic import PlainBoxConfig
 from plainbox.impl.decorators import raises
 from plainbox.impl.developer import UnexpectedMethodCall
 from plainbox.impl.developer import UsageExpectation
 from plainbox.impl.execution import UnifiedRunner
+from plainbox.impl.config import Configuration
 from plainbox.impl.providers import get_providers
 from plainbox.impl.result import JobResultBuilder
 from plainbox.impl.result import MemoryJobResult
 from plainbox.impl.runner import JobRunnerUIDelegate
-from plainbox.impl.secure.config import Unset
 from plainbox.impl.secure.origin import Origin
 from plainbox.impl.secure.qualifiers import select_jobs
 from plainbox.impl.secure.qualifiers import FieldQualifier
@@ -162,7 +161,7 @@ class SessionAssistant:
         self._app_version = app_version
         self._api_version = api_version
         self._api_flags = api_flags
-        self._config = PlainBoxConfig().get()
+        self._config = Configuration()
         Unit.config = self._config
         self._execution_ctrl_list = None  # None is "default"
         self._ctrl_setup_list = []
@@ -297,8 +296,7 @@ class SessionAssistant:
         Use alternate configuration object.
 
         :param config:
-            A configuration object that implements a superset of the plainbox
-            configuration.
+            A Checkbox configuration object.
         :raises UnexpectedMethodCall:
             If the call is made at an unexpected time. Do not catch this error.
             It is a bug in your program. The error message will indicate what
@@ -311,7 +309,7 @@ class SessionAssistant:
         UsageExpectation.of(self).enforce()
         self._config = config
         self._exclude_qualifiers = []
-        for pattern in self._config.test_exclude:
+        for pattern in self._config.get_value('test selection', 'exclude'):
             self._exclude_qualifiers.append(
                 RegExpJobQualifier(pattern, None, False))
         Unit.config = config
@@ -1199,7 +1197,7 @@ class SessionAssistant:
         if os.path.isfile(manifest):
             with open(manifest, 'rt', encoding='UTF-8') as stream:
                 manifest_cache = json.load(stream)
-        if self._config is not None and self._config.manifest is not Unset:
+        if self._config is not None and self._config.manifest:
             for manifest_id in self._config.manifest:
                 manifest_cache.update(
                     {manifest_id: self._config.manifest[manifest_id]})
@@ -1362,11 +1360,8 @@ class SessionAssistant:
                             f.writelines(self._restart_cmd_callback(
                                 self.get_session_id()))
             if not native:
-                if self._config.environment is Unset:
-                    result = self._runner.run_job(job, job_state, ui=ui)
-                else:
-                    result = self._runner.run_job(job, job_state,
-                                                  self._config.environment, ui)
+                result = self._runner.run_job(job, job_state,
+                                              self._config.environment, ui)
                 builder = result.get_builder()
             else:
                 builder = JobResultBuilder(
diff --git a/plainbox/impl/session/remote_assistant.py b/plainbox/impl/session/remote_assistant.py
index a975fc9..7c02140 100644
--- a/plainbox/impl/session/remote_assistant.py
+++ b/plainbox/impl/session/remote_assistant.py
@@ -29,6 +29,7 @@ from tempfile import SpooledTemporaryFile
 from threading import Thread, Lock
 from subprocess import CalledProcessError, check_output
 
+from plainbox.impl.config import Configuration
 from plainbox.impl.execution import UnifiedRunner
 from plainbox.impl.session.assistant import SessionAssistant
 from plainbox.impl.session.assistant import SA_RESTARTABLE
@@ -273,20 +274,20 @@ class RemoteSessionAssistant():
 
         self._launcher = load_configs()
         if configuration['launcher']:
-            self._launcher.read_string(configuration['launcher'], False)
-            if self._launcher.session_title:
-                session_title = self._launcher.session_title
-            if self._launcher.session_desc:
-                session_desc = self._launcher.session_desc
+            self._launcher = Configuration.from_text(
+                configuration['launcher'], 'Remote launcher')
+            session_title = self._launcher.get_value(
+                'launcher', 'session_title') or session_title
+            session_desc = self._launcher.get_value(
+                'launcher', 'session_desc') or session_desc
 
         self._sa.use_alternate_configuration(self._launcher)
 
         if configuration['normal_user']:
             self._normal_user = configuration['normal_user']
         else:
-            self._normal_user = self._launcher.normal_user
-            if not self._normal_user:
-                self._normal_user = _guess_normal_user()
+            self._normal_user = self._launcher.get_value(
+                    'daemon', 'normal_user') or _guess_normal_user()
         runner_kwargs = {
             'normal_user_provider': lambda: self._normal_user,
             'stdin': self._pipe_to_subproc,
@@ -305,7 +306,7 @@ class RemoteSessionAssistant():
         self._session_id = self._sa.get_session_id()
         tps = self._sa.get_test_plans()
         filtered_tps = set()
-        for filter in self._launcher.test_plan_filters:
+        for filter in self._launcher.get_value('test plan', 'filter'):
             filtered_tps.update(fnmatch.filter(tps, filter))
         filtered_tps = list(filtered_tps)
         response = zip(filtered_tps, [self._sa.get_test_plan(
@@ -335,10 +336,11 @@ class RemoteSessionAssistant():
     def finish_bootstrap(self):
         self._sa.finish_bootstrap()
         self._state = Bootstrapped
-        if self._launcher.auto_retry:
+        if self._launcher.get_value('ui', 'auto_retry'):
             for job_id in self._sa.get_static_todo_list():
                 job_state = self._sa.get_job_state(job_id)
-                job_state.attempts = self._launcher.max_attempts
+                job_state.attempts = self._launcher.get_value(
+                        'ui', 'max_attempts')
         return self._sa.get_static_todo_list()
 
     def get_manifest_repr(self):
@@ -363,10 +365,12 @@ class RemoteSessionAssistant():
 
     def _get_ui_for_job(self, job):
         show_out = True
-        if self._launcher.output == 'hide-resource-and-attachment':
+        if self._launcher.get_value(
+                'ui', 'output') == 'hide-resource-and-attachment':
             if job.plugin in ('local', 'resource', 'attachment'):
                 show_out = False
-        elif self._launcher.output in ['hide', 'hide-automated']:
+        elif self._launcher.get_value(
+                'ui', 'output') in ['hide', 'hide-automated']:
             if job.plugin in ('shell', 'local', 'resource', 'attachment'):
                 show_out = False
         if 'suppress-output' in job.get_flag_set():
@@ -558,7 +562,7 @@ class RemoteSessionAssistant():
         if self._state != Bootstrapping:
             if not self._sa.get_dynamic_todo_list():
                 if (
-                    self._launcher.auto_retry and
+                    self._launcher.get_value('ui', 'auto_retry') and
                     self.get_rerun_candidates('auto')
                 ):
                     self._state = TestsSelected
@@ -644,11 +648,12 @@ class RemoteSessionAssistant():
         meta = self._sa.resume_session(session_id, runner_kwargs=runner_kwargs)
         app_blob = json.loads(meta.app_blob.decode("UTF-8"))
         launcher = app_blob['launcher']
-        self._launcher.read_string(launcher, False)
+        self._launcher = Configuration.from_text(launcher, 'Remote launcher')
         self._sa.use_alternate_configuration(self._launcher)
 
         self._normal_user = app_blob.get(
-            'effective_normal_user', self._launcher.normal_user)
+            'effective_normal_user', self._launcher.get_value(
+                'daemon', 'normal_user'))
         _logger.info(
             "normal_user after loading metadata: %r", self._normal_user)
         test_plan_id = app_blob['testplan_id']
@@ -684,12 +689,12 @@ class RemoteSessionAssistant():
 
         # some jobs have already been run, so we need to update the attempts
         # count for future auto-rerunning
-        if self._launcher.auto_retry:
+        if self._launcher.get_value('ui', 'auto_retry'):
             for job_id in [
                     job.id for job in self.get_rerun_candidates('auto')]:
                 job_state = self._sa.get_job_state(job_id)
-                job_state.attempts = self._launcher.max_attempts - len(
-                    job_state.result_history)
+                job_state.attempts = self._launcher.get_value(
+                        'ui', 'max_attempts') - len(job_state.result_history)
 
         self._state = TestsSelected
 
diff --git a/plainbox/impl/test_config.py b/plainbox/impl/test_config.py
new file mode 100644
index 0000000..fce0700
--- /dev/null
+++ b/plainbox/impl/test_config.py
@@ -0,0 +1,130 @@
+# This file is part of Checkbox.
+#
+# Copyright 2020 Canonical Ltd.
+# Written by:
+#   Maciej Kisielewski <[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/>.
+"""
+This module contains tests for the new Checkbox Config module
+"""
+from contextlib import contextmanager
+import logging
+from unittest import TestCase
+from unittest.mock import mock_open, patch
+
+from plainbox.impl.config import Configuration
+
+
+@contextmanager
+def muted_logging():
+    """Disable logging so the test that use this have no output."""
+    saved_level = logging.root.getEffectiveLevel()
+    logging.root.setLevel(logging.CRITICAL)
+    yield
+    logging.root.setLevel(saved_level)
+
+
+class ConfigurationTests(TestCase):
+    """Tests for the Configuration class."""
+
+    def test_empty_file_yields_defaults(self):
+        """A default configuration instance should have default values."""
+        # let's check a few values from random sections
+        cfg = Configuration()
+        self.assertEqual(cfg.get_value('test plan', 'filter'), ['*'])
+        self.assertTrue(cfg.get_value('launcher', 'local_submission'))
+        self.assertEqual(cfg.get_value('daemon', 'normal_user'), '')
+
+    @patch('os.path.isfile', return_value=True)
+    def test_one_var_overwrites(self, _):
+        """
+        One variable properly shadows defaults.
+
+        Having one (good) value in config should yield a config with
+        defaults except the one var placed in the config file.
+        """
+        ini_data = """
+        [launcher]
+        stock_reports = text
+        """
+        with patch('builtins.open', mock_open(read_data=ini_data)):
+            cfg = Configuration.from_path('unit test')
+        self.assertEqual(cfg.get_value('test plan', 'filter'), ['*'])
+        self.assertTrue(cfg.get_value('launcher', 'local_submission'))
+        self.assertEqual(cfg.get_value('daemon', 'normal_user'), '')
+        self.assertEqual(cfg.get_origin('daemon', 'normal_user'), '')
+        self.assertEqual(cfg.get_value('launcher', 'stock_reports'), ['text'])
+        self.assertEqual(
+            cfg.get_origin('launcher', 'stock_reports'),
+            'unit test')
+
+    @patch('os.path.isfile', return_value=True)
+    def test_string_list_distinction(self, _):
+        """
+        Parsing of lists and multi-word strings.
+
+        Depending on the config spec the field can be considered a string
+        (with spaces) or a list.
+        """
+        ini_data = """
+        [launcher]
+        launcher_version = 1
+        stock_reports = submission_files, text
+        session_title = A session title
+        """
+        with patch('builtins.open', mock_open(read_data=ini_data)):
+            cfg = Configuration.from_path('unit test')
+        self.assertEqual(
+            cfg.get_value('launcher', 'stock_reports'),
+            ['submission_files', 'text'])
+        self.assertEqual(
+            cfg.get_value('launcher', 'session_title'),
+            'A session title')
+
+    @patch('os.path.isfile', return_value=True)
+    def test_unexpected_content(self, _):
+        """
+        Yield problems with extra data in configs.
+        """
+        ini_data = """
+        [launcher]
+        barfoo = 5
+        [foobar]
+        """
+        with muted_logging():
+            with patch('builtins.open', mock_open(read_data=ini_data)):
+                cfg = Configuration.from_path('unit test')
+            self.assertEqual(len(cfg.get_problems()), 2)
+
+    def test_default_vars_are_not_supported(self):
+        """
+        Yield a problem when variable is defined in the [DEFAULT] section.
+        """
+        ini_data = """
+        [DEFAULT]
+        badvar = 4
+        """
+        with muted_logging():
+            with patch('builtins.open', mock_open(read_data=ini_data)):
+                cfg = Configuration.from_path('unit test')
+            self.assertEqual(len(cfg.get_problems()), 1)
+
+    @patch('os.path.isfile', return_value=False)
+    def test_ini_not_found(self, _):
+        """
+        Yield a problem when an ini file cannot be opened.
+        """
+        with muted_logging():
+            cfg = Configuration.from_path('invalid path')
+        self.assertEqual(len(cfg.get_problems()), 1)
diff --git a/plainbox/impl/test_launcher.py b/plainbox/impl/test_launcher.py
deleted file mode 100644
index 47b47d1..0000000
--- a/plainbox/impl/test_launcher.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2016 Canonical Ltd.
-# Written by:
-#   Maciej Kisielewski <[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.test_launcher
-=========================
-
-Test definitions for plainbox.imlp.launcher module
-"""
-
-from unittest import TestCase
-from textwrap import dedent
-
-from plainbox.impl.secure.config import Unset
-
-from plainbox.impl.launcher import LauncherDefinition
-from plainbox.impl.launcher import LauncherDefinition1
-
-
-class LauncherDefinitionTests(TestCase):
-    launcher_version_legacy = dedent("""
-    [launcher]
-    """)
-    launcher_version_1 = dedent("""
-    [launcher]
-    launcher_version = 1
-    """)
-    launcher_version_future = dedent("""
-    [launcher]
-    launcher_version = 2
-    """)
-
-    def test_get_concrete_launcher_legacy(self):
-        l = LauncherDefinition()
-        l.read_string(self.launcher_version_legacy)
-        with self.assertRaises(KeyError):
-            l.get_concrete_launcher()
-
-    def test_get_concrete_launcher_launcher1(self):
-        l = LauncherDefinition()
-        l.read_string(self.launcher_version_1)
-        cls = l.get_concrete_launcher().__class__
-        self.assertIs(cls, LauncherDefinition1)
-
-    def test_get_concrete_launcher_future_raises(self):
-        l = LauncherDefinition()
-        l.read_string(self.launcher_version_future)
-        with self.assertRaises(KeyError):
-            l.get_concrete_launcher()
-
-
-class LauncherDefinition1Tests(TestCase):
-
-    def test_defaults(self):
-        empty_launcher = dedent("""
-        [launcher]
-        launcher_version = 1
-        """)
-        l = LauncherDefinition1()
-        l.read_string(empty_launcher)
-        self.assertEqual(l.api_version, '0.99')
-        self.assertEqual(l.app_id, 'checkbox-cli')
-        self.assertEqual(l.api_flags, ['restartable'])
-        self.assertEqual(l.test_plan_filters, ['*'])
-        self.assertEqual(l.test_plan_default_selection, Unset)
-        self.assertEqual(l.test_plan_forced, False)
-        self.assertEqual(l.test_selection_forced, False)
-        self.assertEqual(l.ui_type, 'interactive')
-        self.assertEqual(l.auto_retry, False)
-        self.assertEqual(l.max_attempts, 3)
-        self.assertEqual(l.delay_before_retry, 1)
-        self.assertEqual(l.restart_strategy, Unset)
-
-    def test_smoke(self):
-        definition = dedent("""
-        [launcher]
-        launcher_version = 1
-        api_version = 0.99
-        api_flags = restartable
-        app_id = FOOBAR
-        [test plan]
-        unit = 2000.the.chosen.one
-        filter = 2000*, 3000* tp_foo*
-        forced = yes
-        [test selection]
-        forced = yes
-        [ui]
-        type = silent
-        auto_retry = yes
-        max_attempts = 5
-        delay_before_retry = 60
-        [restart]
-        strategy = magic
-        [report:foo_report]
-        exporter = bar_exporter
-        transport = file
-        [exporter:bar_exporter]
-        unit = bar_exporter_unit
-        [transport:file]
-        path = /tmp/path
-        """)
-        l = LauncherDefinition1()
-        l.read_string(definition)
-        self.assertEqual(l.api_version, '0.99')
-        self.assertEqual(l.app_id, 'FOOBAR')
-        self.assertEqual(l.api_flags, ['restartable'])
-        self.assertEqual(l.test_plan_filters, ['2000*', '3000*', 'tp_foo*'])
-        self.assertEqual(l.test_plan_default_selection, '2000.the.chosen.one')
-        self.assertEqual(l.test_plan_forced, True)
-        self.assertEqual(l.test_selection_forced, True)
-        self.assertEqual(l.ui_type, 'silent')
-        self.assertEqual(l.auto_retry, True)
-        self.assertEqual(l.max_attempts, 5)
-        self.assertEqual(l.delay_before_retry, 60)
-        self.assertEqual(l.restart_strategy, 'magic')
-        self.assertEqual(l.reports, {
-            'foo_report': {'exporter': 'bar_exporter', 'transport': 'file'}})
-        self.assertEqual(l.exporters, {
-            'bar_exporter': {'unit': 'bar_exporter_unit'}})
-        self.assertEqual(l.transports, {
-            'file': {'path': '/tmp/path'}})
diff --git a/plainbox/impl/unit/unit.py b/plainbox/impl/unit/unit.py
index cd7b365..8041683 100644
--- a/plainbox/impl/unit/unit.py
+++ b/plainbox/impl/unit/unit.py
@@ -36,7 +36,6 @@ from jinja2 import Template
 from plainbox.i18n import gettext as _
 from plainbox.impl.decorators import cached_property
 from plainbox.impl.decorators import instance_method_lru_cache
-from plainbox.impl.secure.config import Unset
 from plainbox.impl.secure.origin import Origin
 from plainbox.impl.secure.rfc822 import normalize_rfc822_value
 from plainbox.impl.symbol import Symbol
@@ -609,7 +608,7 @@ class Unit(metaclass=UnitType):
 
     @instance_method_lru_cache(maxsize=None)
     def _checkbox_env(self):
-        if self.config is not None and self.config.environment is not Unset:
+        if self.config is not None and self.config.environment:
             return self.config.environment
         else:
             return {}