Merge ~sylvain-pineau/checkbox-ng:revert-remote-api-bump into checkbox-ng:master

[Sylvain Pineau]

Revert the remote api branch

[Maciej Kisielewski (kissiel)]

Yeah, +1

review: Approve

[Sylvain Pineau (sylvain-pineau)]

self-approved

review: Approve

diff --git a/checkbox_ng/config.py b/checkbox_ng/config.py
index a8e8ad0..5a4ba11 100644
--- a/checkbox_ng/config.py
+++ b/checkbox_ng/config.py
@@ -23,62 +23,55 @@
 =====================================================
 """
 import gettext
+import itertools
 import logging
 import os
 
-from plainbox.impl.config import Configuration
+from plainbox.impl.launcher import DefaultLauncherDefinition
+from plainbox.impl.launcher import LauncherDefinition
 
 
 _ = 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, 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))
+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)
     else:
-        for sdir in SEARCH_DIRS:
-            config = expand_all(os.path.join(sdir, previous_cfg_name))
+        search_dirs = [
+            '$SNAP_DATA',
+            '/etc/xdg/',
+            '~/.config/',
+        ]
+        for d in search_dirs:
+            config = expand_all(os.path.join(d, config_filename))
             if os.path.exists(config):
-                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
+                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
diff --git a/checkbox_ng/launcher/check_config.py b/checkbox_ng/launcher/check_config.py
index 0ac3088..359d3ca 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-2021 Canonical Ltd.
+# Copyright 2018-2019 Canonical Ltd.
 # Written by:
 #   Maciej Kisielewski <[e-mail]>
 #
@@ -15,38 +15,41 @@
 #
 # 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 the implementation of the `check-config` subcmd."""
+from plainbox.impl.secure.config import ValidationError
+from plainbox.i18n import gettext as _
 
 from checkbox_ng.config import load_configs
 
 
 class CheckConfig():
-    """Implementation of the `check-config` sub-command."""
-    @staticmethod
-    def invoked(_):
-        """Function that's run with `check-config` invocation."""
+    def invoked(self, ctx):
         config = load_configs()
-        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!")
+        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"))
             return 0
-        print('Problems:')
-        for problem in problems:
-            print('- ', problem)
-        return 1
 
     def register_arguments(self, parser):
-        """Register extra args for this subcmd. No extra args ATM."""
+        pass
diff --git a/checkbox_ng/launcher/checkbox_cli.py b/checkbox_ng/launcher/checkbox_cli.py
index 9740eb8..b69da17 100644
--- a/checkbox_ng/launcher/checkbox_cli.py
+++ b/checkbox_ng/launcher/checkbox_cli.py
@@ -27,6 +27,8 @@ 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 6f28444..730fc02 100644
--- a/checkbox_ng/launcher/master.py
+++ b/checkbox_ng/launcher/master.py
@@ -37,7 +37,8 @@ from functools import partial
 from tempfile import SpooledTemporaryFile
 
 from plainbox.impl.color import Colorizer
-from plainbox.impl.config import Configuration
+from plainbox.impl.launcher import DefaultLauncherDefinition
+from plainbox.impl.secure.config import Unset
 from plainbox.impl.session.remote_assistant import RemoteSessionAssistant
 from plainbox.vendor import rpyc
 from checkbox_ng.urwid_ui import TestPlanBrowser
@@ -110,7 +111,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
 
     @property
     def is_interactive(self):
-        return (self.launcher.get_value('ui', 'type') == 'interactive' and
+        return (self.launcher.ui_type == 'interactive' and
                 sys.stdin.isatty() and sys.stdout.isatty())
 
     @property
@@ -128,7 +129,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self._is_bootstrapping = False
         self._target_host = ctx.args.host
         self._normal_user = ''
-        self.launcher = Configuration()
+        self.launcher = DefaultLauncherDefinition()
         if ctx.args.launcher:
             expanded_path = os.path.expanduser(ctx.args.launcher)
             if not os.path.exists(expanded_path):
@@ -136,8 +137,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
                     expanded_path))
             with open(expanded_path, 'rt') as f:
                 self._launcher_text = f.read()
-            self.launcher = Configuration.from_text(
-                    self._launcher_text, 'Remote:{}'.format(expanded_path))
+            self.launcher.read_string(self._launcher_text)
         if ctx.args.user:
             self._normal_user = ctx.args.user
         timeout = 600
@@ -185,9 +185,21 @@ class RemoteMaster(ReportsStage, MainLoopStage):
                     nonlocal keep_running
                     keep_running = False
                     server_msg = msg
-                conn.root.register_master_blaster(quitter)
+                with contextlib.suppress(AttributeError):
+                    # TODO: REMOTE_API
+                    # when bumping the remote api make this bit obligatory
+                    # i.e. remove the suppressing
+                    conn.root.register_master_blaster(quitter)
                 self._sa = conn.root.get_sa()
                 self.sa.conn = conn
+                # TODO: REMOTE API RAPI: Remove this API on the next RAPI bump
+                # the check and bailout is not needed if the slave as up to
+                # date as this master, so after bumping RAPI we can assume
+                # that slave is always passwordless
+                if not self.sa.passwordless_sudo:
+                    raise SystemExit(
+                        _("This version of Checkbox requires the service"
+                          " to be run as root"))
                 try:
                     slave_api_version = self.sa.get_remote_api_version()
                 except AttributeError:
@@ -255,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.get_value('test plan', 'forced'):
-            self.select_tp(self.launcher.get_value('test plan', 'unit'))
+        if self.launcher.test_plan_forced:
+            self.select_tp(self.launcher.test_plan_default_selection)
             self.select_jobs(self.jobs)
         else:
             self.interactively_choose_tp(tps)
@@ -299,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.get_value('test selection', 'forced'):
-            if self.launcher.manifest:
+        if self.launcher.test_selection_forced:
+            if self.launcher.manifest is not Unset:
                 self.sa.save_manifest(
                     {manifest_id:
                      self._strtobool(self.launcher.manifest[manifest_id]) for
@@ -340,7 +352,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         Returns True if the remote should keep running.
         And False if it should quit.
         """
-        if self.launcher.get_value('ui', 'type') == 'silent':
+        if self.launcher.ui_type == 'silent':
             self._sa.terminate()
             return False
         response = interrupt_dialog(self._target_host)
@@ -360,7 +372,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
 
     def finish_session(self):
         print(self.C.header("Results"))
-        if self.launcher.get_value('launcher', 'local_submission'):
+        if self.launcher.local_submission:
             # Disable SIGINT while we save local results
             with contextlib.ExitStack() as stack:
                 tmp_sig = signal.signal(signal.SIGINT, signal.SIG_IGN)
@@ -378,7 +390,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         self.run_jobs()
 
     def _handle_last_job_after_resume(self, resumed_session_info):
-        if self.launcher.get_value('ui', 'type') == 'silent':
+        if self.launcher.ui_type == 'silent':
             time.sleep(20)
         else:
             resume_dialog(10)
@@ -408,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.get_value('ui', 'type') == 'interactive':
+            if self.launcher.ui_type == 'interactive':
                 while True:
                     if not self._maybe_manual_rerun_jobs():
                         break
-        if self.launcher.get_value('ui', 'auto_retry'):
+        if self.launcher.auto_retry:
             while True:
                 if not self._maybe_auto_rerun_jobs():
                     break
@@ -498,7 +510,7 @@ class RemoteMaster(ReportsStage, MainLoopStage):
         if not rerun_candidates:
             return False
         # we wait before retrying
-        delay = self.launcher.get_value('ui', 'delay_before_retry')
+        delay = self.launcher.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 05566be..126324b 100644
--- a/checkbox_ng/launcher/stages.py
+++ b/checkbox_ng/launcher/stages.py
@@ -26,11 +26,9 @@ 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
@@ -318,44 +316,42 @@ class ReportsStage(CheckboxUiStage):
         self._export_fn = export_fn
 
     def _prepare_stock_report(self, report):
-
-        new_origin = 'stock_reports'
+        # 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()
         if report == 'text':
-            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)
+            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'}
         elif report == 'certification':
-            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)
+            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'}
         elif report == 'certification-staging':
-            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)
+            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'}
         elif report == 'submission_files':
             # LP:1585326 maintain isoformat but removing ':' chars that cause
             # issues when copying files.
@@ -368,21 +364,21 @@ class ReportsStage(CheckboxUiStage):
                                        ('tar', '.tar.xz')]:
                 path = os.path.join(self.base_dir, ''.join(
                     ['submission_', timestamp, file_ext]))
-                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)
+                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'
+                }
 
     def _prepare_transports(self):
         self.base_dir = os.path.join(
@@ -398,9 +394,7 @@ 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
-        transport_cfg = self.sa.config.get_parametric_sections(
-            'transport')[transport]
-        tr_type = transport_cfg['type']
+        tr_type = self.sa.config.transports[transport]['type']
         if tr_type not in self._available_transports:
             _logger.error(_("Unrecognized type '%s' of transport '%s'"),
                           tr_type, transport)
@@ -408,11 +402,14 @@ class ReportsStage(CheckboxUiStage):
         cls = self._available_transports[tr_type]
         if tr_type == 'file':
             self.transports[transport] = cls(
-                os.path.expanduser(transport_cfg['path']))
+                os.path.expanduser(
+                    self.sa.config.transports[transport]['path']))
         elif tr_type == 'stream':
-            self.transports[transport] = cls(transport_cfg['stream'])
+            self.transports[transport] = cls(
+                self.sa.config.transports[transport]['stream'])
         elif tr_type == 'submission-service':
-            secure_id = transport_cfg.get('secure_id', None)
+            secure_id = self.sa.config.transports[transport].get(
+                'secure_id', None)
             if self.is_interactive:
                 new_description = input(self.C.BLUE(_(
                     'Enter submission description (press Enter to skip): ')))
@@ -428,7 +425,7 @@ class ReportsStage(CheckboxUiStage):
                 options = "secure_id={}".format(secure_id)
             else:
                 options = ""
-            if transport_cfg.get('staging', False):
+            if self.sa.config.transports[transport].get('staging', False):
                 url = ('https://certification.staging.canonical.com/'
                        'api/v1/submission/{}/'.format(secure_id))
             elif os.getenv('C3_URL'):
@@ -440,15 +437,14 @@ class ReportsStage(CheckboxUiStage):
             self.transports[transport] = cls(url, options)
 
     def _export_results(self):
-        stock_reports = self.sa.config.get_value('launcher', 'stock_reports')
-        if 'none' not in stock_reports:
-            for report in stock_reports:
+        if 'none' not in self.sa.config.stock_reports:
+            for report in self.sa.config.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 ('transport:c3' not in self.sa.config.sections.keys()
-                            and not self.is_interactive):
+                    if ('c3' not in self.sa.config.transports 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
@@ -461,9 +457,7 @@ 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.get_parametric_sections('report').items()):
-
+        for name, params in sorted(self.sa.config.reports.items()):
             # don't generate stock c3 reports if sideloaded providers
             # were in use, something that should only be done during
             # development
@@ -482,10 +476,8 @@ class ReportsStage(CheckboxUiStage):
                 cmd = 'y'
             if cmd == 'n':
                 continue
-            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')[
+            exporter_id = self.sa.config.exporters[params['exporter']]['unit']
+            exporter_options = self.sa.config.exporters[
                     params['exporter']].get('options', '').split()
             done_sending = False
             while not done_sending:
@@ -497,7 +489,7 @@ class ReportsStage(CheckboxUiStage):
                     else:
                         try:
                             result = self.sa.export_to_transport(
-                                exporter_id, transport, exp_options)
+                                exporter_id, transport, exporter_options)
                         except ExporterError as exc:
                             _logger.warning(
                                 _("Problem occured when preparing %s report:"
@@ -525,14 +517,14 @@ class ReportsStage(CheckboxUiStage):
                         done_sending = True
                         continue
                     if self._retry_dialog():
-                        self.sa.config.sections['transports']['c3'].pop(
-                            'secure_id')
+                        self.sa.config.transports['c3'].pop('secure_id')
                         continue
-                except Exception as exc:
+                except Exception:
                     _logger.error(
                         _("Problem with a '%s' report using '%s' exporter "
-                          "sent to '%s' transport. Reason %s"),
-                        name, exporter_id, transport.url, exc)
+                          "sent to '%s' transport."),
+                        name, exporter_id, transport.url)
+                self._reset_auto_submission_retries()
                 done_sending = True
 
     def _retry_dialog(self):
@@ -554,14 +546,3 @@ 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 1d3c278..69f4a4a 100644
--- a/checkbox_ng/launcher/subcommands.py
+++ b/checkbox_ng/launcher/subcommands.py
@@ -42,6 +42,7 @@ 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
@@ -167,10 +168,10 @@ class Launcher(MainLoopStage, ReportsStage):
         return self._C
 
     def get_sa_api_version(self):
-        return '0.99'
+        return self.launcher.api_version
 
     def get_sa_api_flags(self):
-        return [SA_RESTARTABLE]
+        return self.launcher.api_flags
 
     def invoked(self, ctx):
         if ctx.args.version:
@@ -183,12 +184,12 @@ class Launcher(MainLoopStage, ReportsStage):
             # exited by now, so validation passed
             print(_("Launcher seems valid."))
             return
-        self.configuration = load_configs(ctx.args.launcher)
+        self.launcher = load_configs(ctx.args.launcher)
         logging_level = {
             'normal': logging.WARNING,
             'verbose': logging.INFO,
             'debug': logging.DEBUG,
-        }[self.configuration.get_value('ui', 'verbosity')]
+        }[self.launcher.verbosity]
         if not ctx.args.verbose and not ctx.args.debug:
             # Command line args take precendence
             logging.basicConfig(level=logging_level)
@@ -199,28 +200,25 @@ 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.configuration)
+            ctx.sa.use_alternate_configuration(self.launcher)
             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.configuration.get_value(
-                    'launcher', 'stock_reports'):
+            if 'submission_files' in self.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.configuration.get_value(
-                    'ui', 'max_attempts')
+                job_state.attempts = self.launcher.max_attempts
             # ... before running them
             self._run_jobs(self.ctx.sa.get_dynamic_todo_list())
-            if self.is_interactive and not self.configuration.get_value(
-                'ui', 'auto_retry'):
+            if self.is_interactive and not self.launcher.auto_retry:
                 while True:
                     if not self._maybe_rerun_jobs():
                         break
-            elif self.configuration.get_value('ui', 'auto_retry'):
+            elif self.launcher.auto_retry:
                 while True:
                     if not self._maybe_auto_rerun_jobs():
                         break
@@ -237,18 +235,23 @@ class Launcher(MainLoopStage, ReportsStage):
 
         We can then interact with the user when we encounter OUTCOME_UNDECIDED.
         """
-        return (self.configuration.get_value('ui', 'type')  == 'interactive'
-                and sys.stdin.isatty() and sys.stdout.isatty())
+        return (self.launcher.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.configuration.get_value('restart', 'strategy'):
+        if self.launcher.restart_strategy:
             try:
                 cls = get_strategy_by_name(
-                    self.configuration.get_value('restart', 'strategy'))
-                strategy = cls(**self.configuration.get_strategy_kwargs())
+                    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)))
@@ -278,7 +281,7 @@ class Launcher(MainLoopStage, ReportsStage):
                 respawn_cmd += os.path.abspath(ctx.args.launcher) + ' '
             respawn_cmd += '--resume {}'  # interpolate with session_id
             ctx.sa.configure_application_restart(
-                lambda session_id: [respawn_cmd.format(session_id)], 'local')
+                lambda session_id: [respawn_cmd.format(session_id)])
 
     def _maybe_resume_session(self):
         resume_candidates = list(self.ctx.sa.get_resumable_sessions())
@@ -335,21 +338,18 @@ class Launcher(MainLoopStage, ReportsStage):
 
     def _start_new_session(self):
         print(_("Preparing..."))
-        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'))
+        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)
         runner_kwargs = {
-            'normal_user_provider': lambda: self.configuration.get_value(
-                'daemon', 'normal_user'),
+            'normal_user_provider': lambda: self.launcher.normal_user,
             'password_provider': sudo_password_provider.get_sudo_password,
             'stdin': None,
         }
         self.ctx.sa.start_new_session(title, UnifiedRunner, runner_kwargs)
-        if self.configuration.get_value('test plan', 'forced'):
-            tp_id = self.configuration.get_value('test plan', 'unit')
+        if self.launcher.test_plan_forced:
+            tp_id = self.launcher.test_plan_default_selection
             if tp_id not in self.ctx.sa.get_test_plans():
                 _logger.error(_(
                     'The test plan "%s" is not available!'), tp_id)
@@ -365,8 +365,7 @@ 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.configuration.get_value(
-                'launcher', 'session_desc')
+        description = self.ctx.args.message or self.launcher.session_desc
         self.ctx.sa.update_app_blob(json.dumps(
             {'testplan_id': tp_id,
              'description': description}).encode("UTF-8"))
@@ -381,7 +380,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.configuration.get_value('test plan', 'filter'):
+        for filter in self.launcher.test_plan_filters:
             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:
@@ -389,20 +388,19 @@ class Launcher(MainLoopStage, ReportsStage):
             return
         selected_tp = TestPlanBrowser(
             _("Select test plan"), tp_info_list,
-            self.configuration.get_value('test plan', 'unit')).run()
+            self.launcher.test_plan_default_selection).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.configuration.get_value('test selection', 'forced'):
-            if self.configuration.manifest:
+        if self.launcher.test_selection_forced:
+            if self.launcher.manifest is not Unset:
                 self.ctx.sa.save_manifest(
                     {manifest_id:
-                     self._strtobool(
-                         self.configuration.manifest[manifest_id]) for
-                     manifest_id in self.configuration.manifest}
+                     self._strtobool(self.launcher.manifest[manifest_id]) for
+                     manifest_id in self.launcher.manifest}
                 )
             # by default all tests are selected; so we're done here
             return
@@ -494,7 +492,7 @@ class Launcher(MainLoopStage, ReportsStage):
         if not rerun_candidates:
             return False
         # we wait before retrying
-        delay = self.configuration.get_value('ui', 'delay_before_retry')
+        delay = self.launcher.delay_before_retry
         _logger.info(_("Waiting {} seconds before retrying failed"
                        " jobs...".format(delay)))
         time.sleep(delay)
@@ -527,11 +525,10 @@ class Launcher(MainLoopStage, ReportsStage):
             def considering_job(self, job, job_state):
                 pass
         show_out = True
-        output = self.configuration.get_value('ui', 'output')
-        if output == 'hide-resource-and-attachment':
+        if self.launcher.output == 'hide-resource-and-attachment':
             if job.plugin in ('local', 'resource', 'attachment'):
                 show_out = False
-        elif output in ['hide', 'hide-automated']:
+        elif self.launcher.output in ['hide', 'hide-automated']:
             if job.plugin in ('shell', 'local', 'resource', 'attachment'):
                 show_out = False
         if 'suppress-output' in job.get_flag_set():
@@ -751,7 +748,7 @@ class Run(MainLoopStage):
             respawn_cmd = sys.argv[0]  # entry-point to checkbox
         respawn_cmd += ' --resume {}'  # interpolate with session_id
         self.sa.configure_application_restart(
-            lambda session_id: [respawn_cmd.format(session_id)], 'local')
+            lambda session_id: [respawn_cmd.format(session_id)])
 
 
 class List():
diff --git a/plainbox/impl/applogic.py b/plainbox/impl/applogic.py
index 84f9906..1d90dfd 100644
--- a/plainbox/impl/applogic.py
+++ b/plainbox/impl/applogic.py
@@ -31,6 +31,7 @@ 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
@@ -79,6 +80,23 @@ 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 efdb1f6..5a26853 100644
--- a/plainbox/impl/commands/__init__.py
+++ b/plainbox/impl/commands/__init__.py
@@ -47,6 +47,7 @@ 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
@@ -68,6 +69,16 @@ 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
 deleted file mode 100644
index 044862d..0000000
--- a/plainbox/impl/config.py
+++ /dev/null
@@ -1,398 +0,0 @@
-# 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 copy
-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 get_strategy_kwargs(self):
-        """Return custom restart strategy parameters."""
-        kwargs = copy.deepcopy(self.sections['restart'])
-        # [restart] section has the kwargs for the strategy initializer
-        # and the 'strategy' which is not one, let's pop it
-        kwargs.pop('strategy')
-        return kwargs
-
-    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, parser):
-        """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(',', ' '))
-            elif kind == bool:
-                value = parser.getboolean(section, name)
-            elif kind == float:
-                value = parser.getfloat(section, name)
-            elif kind == int:
-                value = parser.getint(section, name)
-            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, parser)
-                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, parser)
-        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 2242114..5facd64 100644
--- a/plainbox/impl/ctrl.py
+++ b/plainbox/impl/ctrl.py
@@ -60,6 +60,7 @@ 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
 new file mode 100644
index 0000000..16b3059
--- /dev/null
+++ b/plainbox/impl/launcher.py
@@ -0,0 +1,258 @@
+# 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 fae15fb..f46a99f 100644
--- a/plainbox/impl/runner.py
+++ b/plainbox/impl/runner.py
@@ -50,6 +50,7 @@ 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
 new file mode 100644
index 0000000..1efab12
--- /dev/null
+++ b/plainbox/impl/secure/test_config.py
@@ -0,0 +1,608 @@
+# 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 fa852c8..41ec411 100644
--- a/plainbox/impl/session/assistant.py
+++ b/plainbox/impl/session/assistant.py
@@ -38,15 +38,16 @@ 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
@@ -161,7 +162,7 @@ class SessionAssistant:
         self._app_version = app_version
         self._api_version = api_version
         self._api_flags = api_flags
-        self._config = Configuration()
+        self._config = PlainBoxConfig().get()
         Unit.config = self._config
         self._execution_ctrl_list = None  # None is "default"
         self._ctrl_setup_list = []
@@ -210,8 +211,7 @@ class SessionAssistant:
 
     @raises(UnexpectedMethodCall, LookupError)
     def configure_application_restart(
-            self, cmd_callback, session_type:
-            'Callable[[str], List[str]], str') -> None:
+            self, cmd_callback: 'Callable[[str], List[str]]') -> None:
         """
         Configure automatic restart capability.
 
@@ -219,8 +219,6 @@ class SessionAssistant:
             A callable (function or lambda) that when called with a single
             string argument, session_id, returns a list of strings describing
             how to execute the tool in order to restart a particular session.
-        :param session_type:
-            Kind of the session we're running. Either 'local' or 'remote'
         :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
@@ -247,6 +245,25 @@ class SessionAssistant:
         """
         UsageExpectation.of(self).enforce()
         if self._restart_strategy is None:
+            # 'checkbox-slave' is deprecated, it's here so people can resume
+            # old session, the next if statement can be changed to just checking
+            # for 'remote' type
+            # session_type = 'remote' if self._metadata.title == 'remote'
+            #                         else 'local'
+            # with the next release or when we do inclusive naming refactor
+            # or roughly after April of 2022
+            # TODO: REMOTE API RAPI:
+            # this heuristic of guessing session type from the title
+            # should be changed to a proper arg/flag with the Remote API bump
+            remote_types = ('remote', 'checkbox-slave')
+            session_type = 'local'
+            try:
+                app_blob = json.loads(self._metadata.app_blob.decode("UTF-8"))
+                session_type = app_blob['type']
+                if session_type in remote_types:
+                    session_type = 'remote'
+            except (AttributeError, ValueError, KeyError):
+                session_type = 'local'
             self._restart_strategy = detect_restart_strategy(
                 self, session_type=session_type)
         self._restart_cmd_callback = cmd_callback
@@ -300,7 +317,8 @@ class SessionAssistant:
         Use alternate configuration object.
 
         :param config:
-            A Checkbox configuration object.
+            A configuration object that implements a superset of the plainbox
+            configuration.
         :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
@@ -313,7 +331,7 @@ class SessionAssistant:
         UsageExpectation.of(self).enforce()
         self._config = config
         self._exclude_qualifiers = []
-        for pattern in self._config.get_value('test selection', 'exclude'):
+        for pattern in self._config.test_exclude:
             self._exclude_qualifiers.append(
                 RegExpJobQualifier(pattern, None, False))
         Unit.config = config
@@ -1201,7 +1219,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:
+        if self._config is not None and self._config.manifest is not Unset:
             for manifest_id in self._config.manifest:
                 manifest_cache.update(
                     {manifest_id: self._config.manifest[manifest_id]})
@@ -1364,8 +1382,11 @@ class SessionAssistant:
                             f.writelines(self._restart_cmd_callback(
                                 self.get_session_id()))
             if not native:
-                result = self._runner.run_job(job, job_state,
-                                              self._config.environment, ui)
+                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)
                 builder = result.get_builder()
             else:
                 builder = JobResultBuilder(
diff --git a/plainbox/impl/session/remote_assistant.py b/plainbox/impl/session/remote_assistant.py
index e15961b..e3c6c11 100644
--- a/plainbox/impl/session/remote_assistant.py
+++ b/plainbox/impl/session/remote_assistant.py
@@ -28,7 +28,6 @@ from contextlib import suppress
 from tempfile import SpooledTemporaryFile
 from threading import Thread, Lock
 
-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
@@ -141,7 +140,7 @@ class BackgroundExecutor(Thread):
 class RemoteSessionAssistant():
     """Remote execution enabling wrapper for the SessionAssistant"""
 
-    REMOTE_API_VERSION = 12
+    REMOTE_API_VERSION = 11
 
     def __init__(self, cmd_callback):
         _logger.debug("__init__()")
@@ -274,20 +273,20 @@ class RemoteSessionAssistant():
 
         self._launcher = load_configs()
         if configuration['launcher']:
-            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._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._sa.use_alternate_configuration(self._launcher)
 
         if configuration['normal_user']:
             self._normal_user = configuration['normal_user']
         else:
-            self._normal_user = self._launcher.get_value(
-                    'daemon', 'normal_user') or _guess_normal_user()
+            self._normal_user = self._launcher.normal_user
+            if not self._normal_user:
+                self._normal_user = _guess_normal_user()
         runner_kwargs = {
             'normal_user_provider': lambda: self._normal_user,
             'stdin': self._pipe_to_subproc,
@@ -301,13 +300,12 @@ class RemoteSessionAssistant():
             'effective_normal_user': self._normal_user,
         }).encode("UTF-8")
         self._sa.update_app_blob(new_blob)
-        self._sa.configure_application_restart(
-            self._cmd_callback, session_type='remote')
+        self._sa.configure_application_restart(self._cmd_callback)
 
         self._session_id = self._sa.get_session_id()
         tps = self._sa.get_test_plans()
         filtered_tps = set()
-        for filter in self._launcher.get_value('test plan', 'filter'):
+        for filter in self._launcher.test_plan_filters:
             filtered_tps.update(fnmatch.filter(tps, filter))
         filtered_tps = list(filtered_tps)
         response = zip(filtered_tps, [self._sa.get_test_plan(
@@ -324,6 +322,11 @@ class RemoteSessionAssistant():
         self._sa.update_app_blob(json.dumps(
             {'testplan_id': test_plan_id, }).encode("UTF-8"))
         self._sa.select_test_plan(test_plan_id)
+        # TODO: REMOTE API RAPI: Change this API on the next RAPI bump
+        # previously the function returned bool signifying the need for sudo
+        # password. With slave being guaranteed to never need it anymor
+        # we can make this funciton return nothing
+        return False
 
     @allowed_when(Started)
     def get_bootstrapping_todo_list(self):
@@ -332,11 +335,10 @@ class RemoteSessionAssistant():
     def finish_bootstrap(self):
         self._sa.finish_bootstrap()
         self._state = Bootstrapped
-        if self._launcher.get_value('ui', 'auto_retry'):
+        if self._launcher.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.get_value(
-                        'ui', 'max_attempts')
+                job_state.attempts = self._launcher.max_attempts
         return self._sa.get_static_todo_list()
 
     def get_manifest_repr(self):
@@ -361,12 +363,10 @@ class RemoteSessionAssistant():
 
     def _get_ui_for_job(self, job):
         show_out = True
-        if self._launcher.get_value(
-                'ui', 'output') == 'hide-resource-and-attachment':
+        if self._launcher.output == 'hide-resource-and-attachment':
             if job.plugin in ('local', 'resource', 'attachment'):
                 show_out = False
-        elif self._launcher.get_value(
-                'ui', 'output') in ['hide', 'hide-automated']:
+        elif self._launcher.output in ['hide', 'hide-automated']:
             if job.plugin in ('shell', 'local', 'resource', 'attachment'):
                 show_out = False
         if 'suppress-output' in job.get_flag_set():
@@ -522,6 +522,27 @@ class RemoteSessionAssistant():
             "todo": self._sa.get_dynamic_todo_list(),
         }
 
+    def get_master_public_key(self):
+        # TODO: REMOTE API RAPI: Remove this API on the next RAPI bump
+        # this key is only for RAPI compliance. It will never be used as
+        # this master requires slave to be completely sudoless
+        return (
+            b'-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMII'
+            b'BCgKCAQEA5r0bjOA+IH5lDKkW3OYb\nDuEjf5VKgUlDSJJuyBlfLTBIXZ8j3s98'
+            b'6AbV0zB62rAcgiFrBOzx51IzBDBmHI8V\nYYpEa+q4OP4yprYpSg6xzX6LRQapC'
+            b'Iv9BAqN4MWrKBukGMzJyemIVEPv4BSHL5L/\nLY98Mwh4dAXxj5ZdsoVPqgeMo8'
+            b'dxfYEOwVRJvSkseIhxRL6tvgP37c48ApUyjdUO\n3C2YgqJRx7mKKDyLOvhDVEl'
+            b'MqkAfp6qS/8xcGBTEqn08dDQIgPl8KofpC9GXMGbK\nV9FGP+c1bpA3vMOfnpsE'
+            b'WCju2qDoTSKJTm3VMZj88mqH7nOpbk7JI/Yz0EmtNXOM\n6QIDAQAB\n-----EN'
+            b'D PUBLIC KEY-----')
+
+    def save_password(self, password):
+        """Store sudo password"""
+        # TODO: REMOTE API RAPI: Remove this API on the next RAPI bump
+        # if the slave is running it means we don't need password
+        # so we can consider call to this function as passing
+        return True
+
     def finish_job(self, result=None):
         # assert the thread completed
         self.session_change_lock.acquire(blocking=False)
@@ -537,7 +558,7 @@ class RemoteSessionAssistant():
         if self._state != Bootstrapping:
             if not self._sa.get_dynamic_todo_list():
                 if (
-                    self._launcher.get_value('ui', 'auto_retry') and
+                    self._launcher.auto_retry and
                     self.get_rerun_candidates('auto')
                 ):
                     self._state = TestsSelected
@@ -623,12 +644,11 @@ 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 = Configuration.from_text(launcher, 'Remote launcher')
+        self._launcher.read_string(launcher, False)
         self._sa.use_alternate_configuration(self._launcher)
 
         self._normal_user = app_blob.get(
-            'effective_normal_user', self._launcher.get_value(
-                'daemon', 'normal_user'))
+            'effective_normal_user', self._launcher.normal_user)
         _logger.info(
             "normal_user after loading metadata: %r", self._normal_user)
         test_plan_id = app_blob['testplan_id']
@@ -664,12 +684,12 @@ class RemoteSessionAssistant():
 
         # some jobs have already been run, so we need to update the attempts
         # count for future auto-rerunning
-        if self._launcher.get_value('ui', 'auto_retry'):
+        if self._launcher.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.get_value(
-                        'ui', 'max_attempts') - len(job_state.result_history)
+                job_state.attempts = self._launcher.max_attempts - len(
+                    job_state.result_history)
 
         self._state = TestsSelected
 
@@ -695,6 +715,12 @@ class RemoteSessionAssistant():
         return self._sa._manager
 
     @property
+    def passwordless_sudo(self):
+        # TODO: REMOTE API RAPI: Remove this API on the next RAPI bump
+        # if the slave is still running it means it's very passwordless
+        return True
+
+    @property
     def sideloaded_providers(self):
         return self._sa.sideloaded_providers
 
diff --git a/plainbox/impl/test_config.py b/plainbox/impl/test_config.py
 deleted file mode 100644
index fce0700..0000000
--- a/plainbox/impl/test_config.py
+++ /dev/null
@@ -1,130 +0,0 @@
-# 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
 new file mode 100644
index 0000000..47b47d1
--- /dev/null
+++ b/plainbox/impl/test_launcher.py
@@ -0,0 +1,136 @@
+# 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 8041683..cd7b365 100644
--- a/plainbox/impl/unit/unit.py
+++ b/plainbox/impl/unit/unit.py
@@ -36,6 +36,7 @@ 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
@@ -608,7 +609,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:
+        if self.config is not None and self.config.environment is not Unset:
             return self.config.environment
         else:
             return {}
diff --git a/plainbox/vendor/rpyc/__init__.py b/plainbox/vendor/rpyc/__init__.py
index 4ad98f7..9cd71d5 100644
--- a/plainbox/vendor/rpyc/__init__.py
+++ b/plainbox/vendor/rpyc/__init__.py
@@ -46,7 +46,7 @@ from plainbox.vendor.rpyc.core import (SocketStream, TunneledSocketStream, PipeS
                        Connection, Service, BaseNetref, AsyncResult, GenericException,
                        AsyncResultTimeout, VoidService, SlaveService, MasterService, ClassicService)
 from plainbox.vendor.rpyc.utils.factory import (connect_stream, connect_channel, connect_pipes,
-                                connect_stdpipes, connect, ssl_connect, list_services, discover, connect_by_service, connect_subproc,
+                                connect_stdpipes, connect, ssl_connect, discover, connect_by_service, connect_subproc,
                                 connect_thread, ssh_connect)
 from plainbox.vendor.rpyc.utils.helpers import async_, timed, buffiter, BgServingThread, restricted
 from plainbox.vendor.rpyc.utils import classic
diff --git a/plainbox/vendor/rpyc/core/async_.py b/plainbox/vendor/rpyc/core/async_.py
index b46f4d0..fd69027 100644
--- a/plainbox/vendor/rpyc/core/async_.py
+++ b/plainbox/vendor/rpyc/core/async_.py
@@ -1,5 +1,4 @@
 import time  # noqa: F401
-from threading import Event
 from plainbox.vendor.rpyc.lib import Timeout
 from plainbox.vendor.rpyc.lib.compat import TimeoutError as AsyncResultTimeout
 
@@ -13,14 +12,14 @@ class AsyncResult(object):
 
     def __init__(self, conn):
         self._conn = conn
-        self._is_ready = Event()
+        self._is_ready = False
         self._is_exc = None
         self._obj = None
         self._callbacks = []
         self._ttl = Timeout(None)
 
     def __repr__(self):
-        if self._is_ready.is_set():
+        if self._is_ready:
             state = "ready"
         elif self._is_exc:
             state = "error"
@@ -28,14 +27,14 @@ class AsyncResult(object):
             state = "expired"
         else:
             state = "pending"
-        return "<AsyncResult object ({}) at 0x{:08x}>".format((state), (id(self)))
+        return "<AsyncResult object (%s) at 0x%08x>" % (state, id(self))
 
     def __call__(self, is_exc, obj):
         if self.expired:
             return
         self._is_exc = is_exc
         self._obj = obj
-        self._is_ready.set()
+        self._is_ready = True
         for cb in self._callbacks:
             cb(self)
         del self._callbacks[:]
@@ -44,9 +43,9 @@ class AsyncResult(object):
         """Waits for the result to arrive. If the AsyncResult object has an
         expiry set, and the result did not arrive within that timeout,
         an :class:`AsyncResultTimeout` exception is raised"""
-        while not self._is_ready.is_set() and not self._ttl.expired():
+        while not self._is_ready and not self._ttl.expired():
             self._conn.serve(self._ttl)
-        if not self._is_ready.is_set():
+        if not self._is_ready:
             raise AsyncResultTimeout("result expired")
 
     def add_callback(self, func):
@@ -57,7 +56,7 @@ class AsyncResult(object):
 
         :param func: the callback function to add
         """
-        if self._is_ready.is_set():
+        if self._is_ready:
             func(self)
         else:
             self._callbacks.append(func)
@@ -73,12 +72,12 @@ class AsyncResult(object):
     @property
     def ready(self):
         """Indicates whether the result has arrived"""
-        if self._is_ready.is_set():
+        if self._is_ready:
             return True
         if self._ttl.expired():
             return False
         self._conn.poll_all()
-        return self._is_ready.is_set()
+        return self._is_ready
 
     @property
     def error(self):
@@ -88,7 +87,7 @@ class AsyncResult(object):
     @property
     def expired(self):
         """Indicates whether the AsyncResult has expired"""
-        return not self._is_ready.is_set() and self._ttl.expired()
+        return not self._is_ready and self._ttl.expired()
 
     @property
     def value(self):
diff --git a/plainbox/vendor/rpyc/core/brine.py b/plainbox/vendor/rpyc/core/brine.py
index 20fa5c2..0545cb3 100644
--- a/plainbox/vendor/rpyc/core/brine.py
+++ b/plainbox/vendor/rpyc/core/brine.py
@@ -1,6 +1,6 @@
 """*Brine* is a simple, fast and secure object serializer for **immutable** objects.
 
-The following types are supported: ``int``, ``bool``, ``str``, ``float``,
+The following types are supported: ``int``, ``long``, ``bool``, ``str``, ``float``,
 ``unicode``, ``bytes``, ``slice``, ``complex``, ``tuple`` (of simple types),
 ``frozenset`` (of simple types) as well as the following singletons: ``None``,
 ``NotImplemented``, and ``Ellipsis``.
@@ -17,7 +17,7 @@ Example::
  >>> x == z
  True
 """
-from plainbox.vendor.rpyc.lib.compat import Struct, BytesIO, BYTES_LITERAL
+from plainbox.vendor.rpyc.lib.compat import Struct, BytesIO, is_py_3k, BYTES_LITERAL
 
 
 # singletons
@@ -30,7 +30,7 @@ TAG_NOT_IMPLEMENTED = b"\x05"
 TAG_ELLIPSIS = b"\x06"
 # types
 TAG_UNICODE = b"\x08"
-# deprecated w/ py2 support TAG_LONG = b"\x09"
+TAG_LONG = b"\x09"
 TAG_STR1 = b"\x0a"
 TAG_STR2 = b"\x0b"
 TAG_STR3 = b"\x0c"
@@ -49,7 +49,10 @@ TAG_FLOAT = b"\x18"
 TAG_SLICE = b"\x19"
 TAG_FSET = b"\x1a"
 TAG_COMPLEX = b"\x1b"
-IMM_INTS = dict((i, bytes([i + 0x50])) for i in range(-0x30, 0xa0))
+if is_py_3k:
+    IMM_INTS = dict((i, bytes([i + 0x50])) for i in range(-0x30, 0xa0))
+else:
+    IMM_INTS = dict((i, chr(i + 0x50)) for i in range(-0x30, 0xa0))
 
 I1 = Struct("!B")
 I4 = Struct("!L")
@@ -153,6 +156,13 @@ def _dump_str(obj, stream):
     _dump_bytes(obj.encode("utf8"), stream)
 
 
+if not is_py_3k:
+    @register(_dump_registry, long)  # noqa: F821
+    def _dump_long(obj, stream):
+        stream.append(TAG_LONG)
+        _dump_int(obj, stream)
+
+
 @register(_dump_registry, tuple)
 def _dump_tuple(obj, stream):
     lenobj = len(obj)
@@ -175,7 +185,7 @@ def _dump_tuple(obj, stream):
 
 
 def _undumpable(obj, stream):
-    raise TypeError("cannot dump {}".format((obj)))
+    raise TypeError("cannot dump %r" % (obj,))
 
 
 def _dump(obj, stream):
@@ -219,6 +229,18 @@ def _load_empty_str(stream):
     return b""
 
 
+if is_py_3k:
+    @register(_load_registry, TAG_LONG)
+    def _load_long(stream):
+        obj = _load(stream)
+        return int(obj)
+else:
+    @register(_load_registry, TAG_LONG)
+    def _load_long(stream):
+        obj = _load(stream)
+        return long(obj)  # noqa: F821
+
+
 @register(_load_registry, TAG_FLOAT)
 def _load_float(stream):
     return F8.unpack(stream.read(8))[0]
@@ -294,10 +316,16 @@ def _load_tup_l1(stream):
     return tuple(_load(stream) for i in range(l))
 
 
-@register(_load_registry, TAG_TUP_L4)
-def _load_tup_l4(stream):
-    l, = I4.unpack(stream.read(4))
-    return tuple(_load(stream) for i in range(l))
+if is_py_3k:
+    @register(_load_registry, TAG_TUP_L4)
+    def _load_tup_l4(stream):
+        l, = I4.unpack(stream.read(4))
+        return tuple(_load(stream) for i in range(l))
+else:
+    @register(_load_registry, TAG_TUP_L4)
+    def _load_tup_l4(stream):
+        l, = I4.unpack(stream.read(4))
+        return tuple(_load(stream) for i in xrange(l))  # noqa
 
 
 @register(_load_registry, TAG_SLICE)
@@ -357,7 +385,12 @@ def load(data):
     return _load(stream)
 
 
-simple_types = frozenset([type(None), int, bool, float, bytes, str, complex, type(NotImplemented), type(Ellipsis)])
+if is_py_3k:
+    simple_types = frozenset([type(None), int, bool, float, bytes, str, complex,
+                              type(NotImplemented), type(Ellipsis)])
+else:
+    simple_types = frozenset([type(None), int, long, bool, float, bytes, unicode, complex,  # noqa: F821
+                              type(NotImplemented), type(Ellipsis)])
 
 
 def dumpable(obj):
diff --git a/plainbox/vendor/rpyc/core/consts.py b/plainbox/vendor/rpyc/core/consts.py
index 300186b..31a532d 100644
--- a/plainbox/vendor/rpyc/core/consts.py
+++ b/plainbox/vendor/rpyc/core/consts.py
@@ -37,9 +37,6 @@ HANDLE_INSTANCECHECK = 20
 # optimized exceptions
 EXC_STOP_ITERATION = 1
 
-# IO values
-STREAM_CHUNK = 64000  # read/write chunk is 64KB, too large of a value will degrade response for other clients
-
 # DEBUG
 # for k in globals().keys():
 #    globals()[k] = k
diff --git a/plainbox/vendor/rpyc/core/netref.py b/plainbox/vendor/rpyc/core/netref.py
index 9287906..fd15ef1 100644
--- a/plainbox/vendor/rpyc/core/netref.py
+++ b/plainbox/vendor/rpyc/core/netref.py
@@ -4,7 +4,7 @@ of *magic*, so beware.
 import sys
 import types
 from plainbox.vendor.rpyc.lib import get_methods, get_id_pack
-from plainbox.vendor.rpyc.lib.compat import pickle, maxint, with_metaclass
+from plainbox.vendor.rpyc.lib.compat import pickle, is_py_3k, maxint, with_metaclass
 from plainbox.vendor.rpyc.core import consts
 
 
@@ -16,7 +16,6 @@ DELETED_ATTRS = frozenset([
     '__array_struct__', '__array_interface__',
 ])
 
-"""the set of attributes that are local to the netref object"""
 LOCAL_ATTRS = frozenset([
     '____conn__', '____id_pack__', '____refcount__', '__class__', '__cmp__', '__del__', '__delattr__',
     '__dir__', '__doc__', '__getattr__', '__getattribute__', '__hash__', '__instancecheck__',
@@ -25,25 +24,39 @@ LOCAL_ATTRS = frozenset([
     '__weakref__', '__dict__', '__methods__', '__exit__',
     '__eq__', '__ne__', '__lt__', '__gt__', '__le__', '__ge__',
 ]) | DELETED_ATTRS
+"""the set of attributes that are local to the netref object"""
 
-"""a list of types considered built-in (shared between connections)
-this is needed because iterating the members of the builtins module is not enough,
-some types (e.g NoneType) are not members of the builtins module.
-TODO: this list is not complete.
-"""
 _builtin_types = [
     type, object, bool, complex, dict, float, int, list, slice, str, tuple, set,
-    frozenset, BaseException, Exception, type(None), types.BuiltinFunctionType, types.GeneratorType,
+    frozenset, Exception, type(None), types.BuiltinFunctionType, types.GeneratorType,
     types.MethodType, types.CodeType, types.FrameType, types.TracebackType,
-    types.ModuleType, types.FunctionType, types.MappingProxyType,
+    types.ModuleType, types.FunctionType,
 
     type(int.__add__),      # wrapper_descriptor
     type((1).__add__),      # method-wrapper
     type(iter([])),         # listiterator
     type(iter(())),         # tupleiterator
     type(iter(set())),      # setiterator
-    bytes, bytearray, type(iter(range(10))), memoryview
 ]
+"""a list of types considered built-in (shared between connections)"""
+
+try:
+    BaseException
+except NameError:
+    pass
+else:
+    _builtin_types.append(BaseException)
+
+if is_py_3k:
+    _builtin_types.extend([
+        bytes, bytearray, type(iter(range(10))), memoryview,
+    ])
+    xrange = range
+else:
+    _builtin_types.extend([
+        basestring, unicode, long, xrange, type(iter(xrange(10))), file,  # noqa
+        types.InstanceType, types.ClassType, types.DictProxyType,
+    ])
 _normalized_builtin_types = {}
 
 
@@ -88,9 +101,9 @@ class NetrefMetaclass(type):
 
     def __repr__(self):
         if self.__module__:
-            return "<netref class '{}.{}'>".format((self.__module__), (self.__name__))
+            return "<netref class '%s.%s'>" % (self.__module__, self.__name__)
         else:
-            return "<netref class '{}'>".format((self.__name__))
+            return "<netref class '%s'>" % (self.__name__,)
 
 
 class BaseNetref(with_metaclass(NetrefMetaclass, object)):
@@ -303,24 +316,19 @@ def class_factory(id_pack, methods):
     name_pack = id_pack[0]
     class_descriptor = None
     if name_pack is not None:
-        # attempt to resolve __class__ using normalized builtins first
-        _builtin_class = _normalized_builtin_types.get(name_pack)
-        if _builtin_class is not None:
-            class_descriptor = NetrefClass(_builtin_class)
-        # then by imported modules (this also tries all builtins under "builtins")
-        else:
-            _module = None
-            cursor = len(name_pack)
-            while cursor != -1:
-                _module = sys.modules.get(name_pack[:cursor])
-                if _module is None:
-                    cursor = name_pack[:cursor].rfind('.')
-                    continue
-                _class_name = name_pack[cursor + 1:]
-                _class = getattr(_module, _class_name, None)
-                if _class is not None and hasattr(_class, '__class__'):
-                    class_descriptor = NetrefClass(_class)
-                break
+        # attempt to resolve __class__ using sys.modules (i.e. builtins and imported modules)
+        _module = None
+        cursor = len(name_pack)
+        while cursor != -1:
+            _module = sys.modules.get(name_pack[:cursor])
+            if _module is None:
+                cursor = name_pack[:cursor].rfind('.')
+                continue
+            _class_name = name_pack[cursor + 1:]
+            _class = getattr(_module, _class_name, None)
+            if _class is not None and hasattr(_class, '__class__'):
+                class_descriptor = NetrefClass(_class)
+            break
     ns['__class__'] = class_descriptor
     netref_name = class_descriptor.owner.__name__ if class_descriptor is not None else name_pack
     # create methods that must perform a syncreq
diff --git a/plainbox/vendor/rpyc/core/protocol.py b/plainbox/vendor/rpyc/core/protocol.py
index 703d499..56cd9a9 100644
--- a/plainbox/vendor/rpyc/core/protocol.py
+++ b/plainbox/vendor/rpyc/core/protocol.py
@@ -8,7 +8,7 @@ import gc  # noqa: F401
 
 from threading import Lock, Condition
 from plainbox.vendor.rpyc.lib import spawn, Timeout, get_methods, get_id_pack
-from plainbox.vendor.rpyc.lib.compat import pickle, next, maxint, select_error, acquire_lock  # noqa: F401
+from plainbox.vendor.rpyc.lib.compat import pickle, next, is_py_3k, maxint, select_error, acquire_lock  # noqa: F401
 from plainbox.vendor.rpyc.lib.colls import WeakValueDict, RefCountingColl
 from plainbox.vendor.rpyc.core import consts, brine, vinegar, netref
 from plainbox.vendor.rpyc.core.async_ import AsyncResult
@@ -39,7 +39,7 @@ DEFAULT_CONFIG = dict(
                     '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__',
                     '__rxor__', '__setitem__', '__setslice__', '__str__', '__sub__',
                     '__truediv__', '__xor__', 'next', '__length_hint__', '__enter__',
-                    '__exit__', '__next__', '__format__']),
+                    '__exit__', '__next__', ]),
     exposed_prefix="exposed_",
     allow_getattr=True,
     allow_setattr=False,
@@ -60,8 +60,6 @@ DEFAULT_CONFIG = dict(
     endpoints=None,
     logger=None,
     sync_request_timeout=30,
-    before_closed=None,
-    close_catchall=False,
 )
 """
 The default configuration dictionary of the protocol. You can override these parameters
@@ -140,7 +138,7 @@ class Connection(object):
         self._config = DEFAULT_CONFIG.copy()
         self._config.update(config)
         if self._config["connid"] is None:
-            self._config["connid"] = "conn{}".format((next(_connection_id_generator)))
+            self._config["connid"] = "conn%d" % (next(_connection_id_generator),)
 
         self._HANDLERS = self._request_handlers()
         self._channel = channel
@@ -169,7 +167,7 @@ class Connection(object):
 
     def __repr__(self):
         a, b = object.__repr__(self).split(" object ")
-        return "{} {!r} object {}".format((a), (self._config['connid']), (b))
+        return "%s %r object %s" % (a, self._config["connid"], b)
 
     def _cleanup(self, _anyway=True):  # IO
         if self._closed and not _anyway:
@@ -188,19 +186,17 @@ class Connection(object):
         # self._config.clear()
         del self._HANDLERS
 
-    def close(self):  # IO
+    def close(self, _catchall=True):  # IO
         """closes the connection, releasing all held resources"""
         if self._closed:
             return
+        self._closed = True
         try:
-            self._closed = True
-            if self._config.get("before_closed"):
-                self._config["before_closed"](self.root)
             self._async_request(consts.HANDLE_CLOSE)
         except EOFError:
             pass
         except Exception:
-            if not self._config["close_catchall"]:
+            if not _catchall:
                 raise
         finally:
             self._cleanup(_anyway=True)
@@ -298,7 +294,7 @@ class Connection(object):
                 proxy = self._netref_factory(id_pack)
                 self._proxy_cache[id_pack] = proxy
             return proxy
-        raise ValueError("invalid label {!r}".format((label)))
+        raise ValueError("invalid label %r" % (label,))
 
     def _netref_factory(self, id_pack):  # boxing
         """id_pack is for remote, so when class id fails to directly match """
@@ -367,7 +363,7 @@ class Connection(object):
             obj = self._unbox_exc(args)
             self._seq_request_callback(msg, seq, True, obj)
         else:
-            raise ValueError("invalid message type: {!r}".format((msg)))
+            raise ValueError("invalid message type: %r" % (msg,))
 
     def serve(self, timeout=1, wait_for_lock=True):  # serving
         """Serves a single request or reply that arrives within the given
@@ -492,7 +488,7 @@ class Connection(object):
         """
         timeout = kwargs.pop("timeout", None)
         if kwargs:
-            raise TypeError("got unexpected keyword argument(s) {list(kwargs.keys()}")
+            raise TypeError("got unexpected keyword argument(s) %s" % (list(kwargs.keys()),))
         res = AsyncResult(self)
         self._async_request(handler, args, res)
         if timeout is not None:
@@ -509,7 +505,7 @@ class Connection(object):
     def _check_attr(self, obj, name, perm):  # attribute access
         config = self._config
         if not config[perm]:
-            raise AttributeError("cannot access {!r}".format((name)))
+            raise AttributeError("cannot access %r" % (name,))
         prefix = config["allow_exposed_attrs"] and config["exposed_prefix"]
         plain = config["allow_all_attrs"]
         plain |= config["allow_exposed_attrs"] and name.startswith(prefix)
@@ -522,13 +518,18 @@ class Connection(object):
             return prefix + name
         if plain:
             return name  # chance for better traceback
-        raise AttributeError("cannot access {!r}".format((name)))
+        raise AttributeError("cannot access %r" % (name,))
 
     def _access_attr(self, obj, name, args, overrider, param, default):  # attribute access
-        if type(name) is bytes:
-            name = str(name, "utf8")
-        elif type(name) is not str:
-            raise TypeError("name must be a string")
+        if is_py_3k:
+            if type(name) is bytes:
+                name = str(name, "utf8")
+            elif type(name) is not str:
+                raise TypeError("name must be a string")
+        else:
+            if type(name) not in (str, unicode):  # noqa
+                raise TypeError("name must be a string")
+            name = str(name)  # IronPython issue #10 + py3k issue
         accessor = getattr(type(obj), overrider, None)
         if accessor is None:
             accessor = default
@@ -637,7 +638,7 @@ class Connection(object):
             # since __mro__ is not a safe attribute the request is forwarded using the proxy connection
             # relates to issue #346 or tests.test_netref_hierachy.Test_Netref_Hierarchy.test_StandardError
             conn = obj.____conn__
-            return conn.sync_request(consts.HANDLE_INSPECT, other_id_pack)
+            return conn.sync_request(consts.HANDLE_INSPECT, id_pack)
         # Create a name pack which would be familiar here and see if there is a hit
         other_id_pack2 = (other_id_pack[0], other_id_pack[1], 0)
         if other_id_pack[0] in netref.builtin_classes_cache:
diff --git a/plainbox/vendor/rpyc/core/service.py b/plainbox/vendor/rpyc/core/service.py
index 6159b75..55526be 100644
--- a/plainbox/vendor/rpyc/core/service.py
+++ b/plainbox/vendor/rpyc/core/service.py
@@ -9,7 +9,7 @@ can interoperate, you're good to go.
 from functools import partial
 
 from plainbox.vendor.rpyc.lib import hybridmethod
-from plainbox.vendor.rpyc.lib.compat import execute
+from plainbox.vendor.rpyc.lib.compat import execute, is_py_3k
 from plainbox.vendor.rpyc.core.protocol import Connection
 
 
@@ -137,10 +137,7 @@ class ModuleNamespace(object):
         return self.__cache[name]
 
     def __getattr__(self, name):
-        try:
-            return self[name]
-        except ImportError:
-            raise AttributeError(name)
+        return self[name]
 
 
 class Slave(object):
@@ -218,13 +215,14 @@ class MasterService(Service):
     @staticmethod
     def _install(conn, slave):
         modules = ModuleNamespace(slave.getmodule)
+        builtin = modules.builtins if is_py_3k else modules.__builtin__
         conn.modules = modules
         conn.eval = slave.eval
         conn.execute = slave.execute
         conn.namespace = slave.namespace
-        conn.builtins = modules.builtins
-        conn.builtin = modules.builtins  # TODO: cruft from py2 that requires cleanup elsewhere and CHANGELOG note
-        from rpyc.utils.classic import teleport_function
+        conn.builtin = builtin
+        conn.builtins = builtin
+        from plainbox.vendor.rpyc.utils.classic import teleport_function
         conn.teleport = partial(teleport_function, conn)
 
 
diff --git a/plainbox/vendor/rpyc/core/stream.py b/plainbox/vendor/rpyc/core/stream.py
index 7d3cab7..6c8d790 100644
--- a/plainbox/vendor/rpyc/core/stream.py
+++ b/plainbox/vendor/rpyc/core/stream.py
@@ -8,7 +8,6 @@ import socket
 import errno
 from plainbox.vendor.rpyc.lib import safe_import, Timeout, socket_backoff_connect
 from plainbox.vendor.rpyc.lib.compat import poll, select_error, BYTES_LITERAL, get_exc_errno, maxint  # noqa: F401
-from plainbox.vendor.rpyc.core.consts import STREAM_CHUNK
 win32file = safe_import("win32file")
 win32pipe = safe_import("win32pipe")
 win32event = safe_import("win32event")
@@ -112,7 +111,7 @@ class SocketStream(Stream):
     """A stream over a socket"""
 
     __slots__ = ("sock",)
-    MAX_IO_CHUNK = STREAM_CHUNK
+    MAX_IO_CHUNK = 64000  # read/write chunk is 64KB, too large of a value will degrade response for other clients
 
     def __init__(self, sock):
         self.sock = sock
@@ -292,7 +291,7 @@ class PipeStream(Stream):
     """A stream over two simplex pipes (one used to input, another for output)"""
 
     __slots__ = ("incoming", "outgoing")
-    MAX_IO_CHUNK = STREAM_CHUNK
+    MAX_IO_CHUNK = 32000
 
     def __init__(self, incoming, outgoing):
         outgoing.flush()
@@ -370,7 +369,7 @@ class Win32PipeStream(Stream):
 
     __slots__ = ("incoming", "outgoing", "_fileno", "_keepalive")
     PIPE_BUFFER_SIZE = 130000
-    MAX_IO_CHUNK = STREAM_CHUNK
+    MAX_IO_CHUNK = 32000
 
     def __init__(self, incoming, outgoing):
         import msvcrt
diff --git a/plainbox/vendor/rpyc/core/vinegar.py b/plainbox/vendor/rpyc/core/vinegar.py
index db1f3e1..b766b58 100644
--- a/plainbox/vendor/rpyc/core/vinegar.py
+++ b/plainbox/vendor/rpyc/core/vinegar.py
@@ -22,6 +22,7 @@ except ImportError:
 from plainbox.vendor.rpyc.core import brine
 from plainbox.vendor.rpyc.core import consts
 from plainbox.vendor.rpyc import version
+from plainbox.vendor.rpyc.lib.compat import is_py_3k
 
 
 REMOTE_LINE_START = "\n\n========= Remote Traceback "
@@ -29,6 +30,13 @@ REMOTE_LINE_END = " =========\n"
 REMOTE_LINE = "{0}({{}}){1}".format(REMOTE_LINE_START, REMOTE_LINE_END)
 
 
+try:
+    BaseException
+except NameError:
+    # python 2.4 compatible
+    BaseException = Exception
+
+
 def dump(typ, val, tb, include_local_traceback, include_local_version):
     """Dumps the given exceptions info, as returned by ``sys.exc_info()``
 
@@ -127,15 +135,23 @@ def load(val, import_custom_exceptions, instantiate_custom_exceptions, instantia
     else:
         cls = None
 
-    if not isinstance(cls, type) or not issubclass(cls, BaseException):
-        cls = None
+    if is_py_3k:
+        if not isinstance(cls, type) or not issubclass(cls, BaseException):
+            cls = None
+    else:
+        if not isinstance(cls, (type, ClassType)):
+            cls = None
+        elif issubclass(cls, ClassType) and not instantiate_oldstyle_exceptions:
+            cls = None
+        elif not issubclass(cls, BaseException):
+            cls = None
 
     if cls is None:
-        fullname = "{}.{}".format((modname), (clsname))
+        fullname = "%s.%s" % (modname, clsname)
         # py2: `type()` expects `str` not `unicode`!
         fullname = str(fullname)
         if fullname not in _generic_exceptions_cache:
-            fakemodule = {"__module__": "{}/{}".format((__name__), (modname))}
+            fakemodule = {"__module__": "%s/%s" % (__name__, modname)}
             if isinstance(GenericException, ClassType):
                 _generic_exceptions_cache[fullname] = ClassType(fullname, (GenericException,), fakemodule)
             else:
diff --git a/plainbox/vendor/rpyc/lib/__init__.py b/plainbox/vendor/rpyc/lib/__init__.py
index 6462d36..d96656b 100644
--- a/plainbox/vendor/rpyc/lib/__init__.py
+++ b/plainbox/vendor/rpyc/lib/__init__.py
@@ -19,8 +19,8 @@ class MissingModule(object):
 
     def __getattr__(self, name):
         if name.startswith("__"):  # issue 71
-            raise AttributeError("module {!r} not found".format((self.__name)))
-        raise ImportError("module {!r} not found".format((self.__name)))
+            raise AttributeError("module %r not found" % (self.__name,))
+        raise ImportError("module %r not found" % (self.__name,))
 
     def __bool__(self):
         return False
@@ -96,7 +96,7 @@ def spawn_waitready(init, main):
     return thread, stack.pop()
 
 
-class Timeout(object):
+class Timeout:
 
     def __init__(self, timeout):
         if isinstance(timeout, Timeout):
@@ -175,7 +175,7 @@ def get_id_pack(obj):
                 else:
                     name_pack = '{0}.{1}'.format(obj.__class__.__module__, obj.__name__)
             elif inspect.ismodule(obj):
-                name_pack = '{0}.{1}'.format(obj.__module__, obj.__name__)
+                name_pack = '{0}.{1}'.format(obj__module__, obj.__name__)
                 print(name_pack)
             elif hasattr(obj, '__module__'):
                 name_pack = '{0}.{1}'.format(obj.__module__, obj.__name__)
diff --git a/plainbox/vendor/rpyc/lib/compat.py b/plainbox/vendor/rpyc/lib/compat.py
index 63c48fe..35be8fd 100644
--- a/plainbox/vendor/rpyc/lib/compat.py
+++ b/plainbox/vendor/rpyc/lib/compat.py
@@ -7,7 +7,6 @@ import time
 
 is_py_3k = (sys.version_info[0] >= 3)
 is_py_gte38 = is_py_3k and (sys.version_info[1] >= 8)
-is_py_gte37 = is_py_3k and (sys.version_info[1] >= 7)
 
 
 if is_py_3k:
diff --git a/plainbox/vendor/rpyc/utils/authenticators.py b/plainbox/vendor/rpyc/utils/authenticators.py
index 63ee828..0d97882 100644
--- a/plainbox/vendor/rpyc/utils/authenticators.py
+++ b/plainbox/vendor/rpyc/utils/authenticators.py
@@ -71,7 +71,7 @@ class SSLAuthenticator(object):
         else:
             self.cert_reqs = cert_reqs
         if ssl_version is None:
-            self.ssl_version = ssl.PROTOCOL_TLS
+            self.ssl_version = ssl.PROTOCOL_TLSv1
         else:
             self.ssl_version = ssl_version
 
diff --git a/plainbox/vendor/rpyc/utils/classic.py b/plainbox/vendor/rpyc/utils/classic.py
index 3903a79..2f97dcf 100644
--- a/plainbox/vendor/rpyc/utils/classic.py
+++ b/plainbox/vendor/rpyc/utils/classic.py
@@ -2,11 +2,10 @@ from __future__ import with_statement
 import sys
 import os
 import inspect
-from plainbox.vendor.rpyc.lib.compat import pickle, execute
+from plainbox.vendor.rpyc.lib.compat import pickle, execute, is_py_3k  # noqa: F401
 from plainbox.vendor.rpyc.core.service import ClassicService, Slave
 from plainbox.vendor.rpyc.utils import factory
 from plainbox.vendor.rpyc.core.service import ModuleNamespace  # noqa: F401
-from plainbox.vendor.rpyc.core.consts import STREAM_CHUNK
 from contextlib import contextmanager
 
 
@@ -172,7 +171,7 @@ def connect_multiprocess(args={}):
 # remoting utilities
 # ===============================================================================
 
-def upload(conn, localpath, remotepath, filter=None, ignore_invalid=False, chunk_size=STREAM_CHUNK):
+def upload(conn, localpath, remotepath, filter=None, ignore_invalid=False, chunk_size=16000):
     """uploads a file or a directory to the given remote path
 
     :param localpath: the local file or directory
@@ -187,10 +186,10 @@ def upload(conn, localpath, remotepath, filter=None, ignore_invalid=False, chunk
         upload_file(conn, localpath, remotepath, chunk_size)
     else:
         if not ignore_invalid:
-            raise ValueError("cannot upload {!r}".format((localpath)))
+            raise ValueError("cannot upload %r" % (localpath,))
 
 
-def upload_file(conn, localpath, remotepath, chunk_size=STREAM_CHUNK):
+def upload_file(conn, localpath, remotepath, chunk_size=16000):
     with open(localpath, "rb") as lf:
         with conn.builtin.open(remotepath, "wb") as rf:
             while True:
@@ -200,7 +199,7 @@ def upload_file(conn, localpath, remotepath, chunk_size=STREAM_CHUNK):
                 rf.write(buf)
 
 
-def upload_dir(conn, localpath, remotepath, filter=None, chunk_size=STREAM_CHUNK):
+def upload_dir(conn, localpath, remotepath, filter=None, chunk_size=16000):
     if not conn.modules.os.path.isdir(remotepath):
         conn.modules.os.makedirs(remotepath)
     for fn in os.listdir(localpath):
@@ -210,7 +209,7 @@ def upload_dir(conn, localpath, remotepath, filter=None, chunk_size=STREAM_CHUNK
             upload(conn, lfn, rfn, filter=filter, ignore_invalid=True, chunk_size=chunk_size)
 
 
-def download(conn, remotepath, localpath, filter=None, ignore_invalid=False, chunk_size=STREAM_CHUNK):
+def download(conn, remotepath, localpath, filter=None, ignore_invalid=False, chunk_size=16000):
     """
     download a file or a directory to the given remote path
 
@@ -221,15 +220,15 @@ def download(conn, remotepath, localpath, filter=None, ignore_invalid=False, chu
     :param chunk_size: the IO chunk size
     """
     if conn.modules.os.path.isdir(remotepath):
-        download_dir(conn, remotepath, localpath, filter, chunk_size)
+        download_dir(conn, remotepath, localpath, filter)
     elif conn.modules.os.path.isfile(remotepath):
         download_file(conn, remotepath, localpath, chunk_size)
     else:
         if not ignore_invalid:
-            raise ValueError("cannot download {!r}".format((remotepath)))
+            raise ValueError("cannot download %r" % (remotepath,))
 
 
-def download_file(conn, remotepath, localpath, chunk_size=STREAM_CHUNK):
+def download_file(conn, remotepath, localpath, chunk_size=16000):
     with conn.builtin.open(remotepath, "rb") as rf:
         with open(localpath, "wb") as lf:
             while True:
@@ -239,17 +238,17 @@ def download_file(conn, remotepath, localpath, chunk_size=STREAM_CHUNK):
                 lf.write(buf)
 
 
-def download_dir(conn, remotepath, localpath, filter=None, chunk_size=STREAM_CHUNK):
+def download_dir(conn, remotepath, localpath, filter=None, chunk_size=16000):
     if not os.path.isdir(localpath):
         os.makedirs(localpath)
     for fn in conn.modules.os.listdir(remotepath):
         if not filter or filter(fn):
             rfn = conn.modules.os.path.join(remotepath, fn)
             lfn = os.path.join(localpath, fn)
-            download(conn, rfn, lfn, filter=filter, ignore_invalid=True, chunk_size=chunk_size)
+            download(conn, rfn, lfn, filter=filter, ignore_invalid=True)
 
 
-def upload_package(conn, module, remotepath=None, chunk_size=STREAM_CHUNK):
+def upload_package(conn, module, remotepath=None, chunk_size=16000):
     """
     uploads a module or a package to the remote party
 
@@ -385,17 +384,12 @@ def teleport_function(conn, func, globals=None, def_=True):
             import os
             return (os.getpid() + y) * x
 
-    .. note:: While it is not forbidden to "teleport" functions across different Python
-              versions, it *may* result in errors due to Python bytecode differences. It is
-              recommended to ensure both the client and the server are of the same Python
-              version when using this function.
-
     :param conn: the RPyC connection
     :param func: the function object to be delivered to the other party
     """
     if globals is None:
         globals = conn.namespace
-    from rpyc.utils.teleportation import export_function
+    from plainbox.vendor.rpyc.utils.teleportation import export_function
     exported = export_function(func)
     return conn.modules["rpyc.utils.teleportation"].import_function(
         exported, globals, def_)
diff --git a/plainbox/vendor/rpyc/utils/factory.py b/plainbox/vendor/rpyc/utils/factory.py
index aa59a7e..23acc1f 100644
--- a/plainbox/vendor/rpyc/utils/factory.py
+++ b/plainbox/vendor/rpyc/utils/factory.py
@@ -5,7 +5,7 @@ cases)
 from __future__ import with_statement
 import socket
 from contextlib import closing
-from functools import partial
+
 import threading
 try:
     from thread import interrupt_main
@@ -19,7 +19,7 @@ except ImportError:
 
 from plainbox.vendor.rpyc.core.channel import Channel
 from plainbox.vendor.rpyc.core.stream import SocketStream, TunneledSocketStream, PipeStream
-from plainbox.vendor.rpyc.core.service import VoidService, MasterService, SlaveService
+from plainbox.vendor.rpyc.core.service import VoidService
 from plainbox.vendor.rpyc.utils.registry import UDPRegistryClient
 from plainbox.vendor.rpyc.lib import safe_import, spawn
 ssl = safe_import("ssl")
@@ -29,10 +29,6 @@ class DiscoveryError(Exception):
     pass
 
 
-class ForbiddenError(Exception):
-    pass
-
-
 # ------------------------------------------------------------------------------
 # API
 # ------------------------------------------------------------------------------
@@ -220,26 +216,16 @@ def discover(service_name, host=None, registrar=None, timeout=2):
         registrar = UDPRegistryClient(timeout=timeout)
     addrs = registrar.discover(service_name)
     if not addrs:
-        raise DiscoveryError("no servers exposing {!r} were found".format((service_name)))
+        raise DiscoveryError("no servers exposing %r were found" % (service_name,))
     if host:
         ips = socket.gethostbyname_ex(host)[2]
         addrs = [(h, p) for h, p in addrs if h in ips]
     if not addrs:
-        raise DiscoveryError("no servers exposing {} were found on {}".format((service_name), (host)))
+        raise DiscoveryError("no servers exposing %r were found on %r" % (service_name, host))
     return addrs
 
 
-def list_services(registrar=None, timeout=2):
-    services = ()
-    if registrar is None:
-        registrar = UDPRegistryClient(timeout=timeout)
-    services = registrar.list()
-    if services is None:
-        raise ForbiddenError("Registry doesn't allow listing")
-    return services
-
-
-def connect_by_service(service_name, host=None, registrar=None, timeout=2, service=VoidService, config={}):
+def connect_by_service(service_name, host=None, service=VoidService, config={}):
     """create a connection to an arbitrary server that exposes the requested service
 
     :param service_name: the service to discover
@@ -254,13 +240,13 @@ def connect_by_service(service_name, host=None, registrar=None, timeout=2, servi
     # some of which could be dead. We iterate over the list returned and return the first
     # one we could connect to. If none of the registered servers is responsive we re-throw
     # the exception
-    addrs = discover(service_name, host=host, registrar=registrar, timeout=timeout)
+    addrs = discover(service_name, host=host)
     for host, port in addrs:
         try:
             return connect(host, port, service, config=config)
         except socket.error:
             pass
-    raise DiscoveryError("All services are down: {}".format((addrs)))
+    raise DiscoveryError("All services are down: %s" % (addrs,))
 
 
 def connect_subproc(args, service=VoidService, config={}):
@@ -278,27 +264,6 @@ def connect_subproc(args, service=VoidService, config={}):
     return conn
 
 
-def _server(listener, remote_service, remote_config, args=None):
-    try:
-        with closing(listener):
-            client = listener.accept()[0]
-        conn = connect_stream(SocketStream(client), service=remote_service, config=remote_config)
-        if isinstance(args, dict):
-            _oldstyle = (MasterService, SlaveService)
-            is_newstyle = isinstance(remote_service, type) and not issubclass(remote_service, _oldstyle)
-            is_newstyle |= not isinstance(remote_service, type) and not isinstance(remote_service, _oldstyle)
-            is_voidservice = isinstance(remote_service, type) and issubclass(remote_service, VoidService)
-            is_voidservice |= not isinstance(remote_service, type) and isinstance(remote_service, VoidService)
-            if is_newstyle and not is_voidservice:
-                conn._local_root.exposed_namespace.update(args)
-            elif not is_voidservice:
-                conn._local_root.namespace.update(args)
-
-        conn.serve_all()
-    except KeyboardInterrupt:
-        interrupt_main()
-
-
 def connect_thread(service=VoidService, config={}, remote_service=VoidService, remote_config={}):
     """starts an rpyc server on a new thread, bound to an arbitrary port,
     and connects to it over a socket.
@@ -311,8 +276,18 @@ def connect_thread(service=VoidService, config={}, remote_service=VoidService, r
     listener = socket.socket()
     listener.bind(("localhost", 0))
     listener.listen(1)
-    remote_server = partial(_server, listener, remote_service, remote_config)
-    spawn(remote_server)
+
+    def server(listener=listener):
+        with closing(listener):
+            client = listener.accept()[0]
+        conn = connect_stream(SocketStream(client), service=remote_service,
+                              config=remote_config)
+        try:
+            conn.serve_all()
+        except KeyboardInterrupt:
+            interrupt_main()
+
+    spawn(server)
     host, port = listener.getsockname()
     return connect(host, port, service=service, config=config)
 
@@ -336,8 +311,19 @@ def connect_multiprocess(service=VoidService, config={}, remote_service=VoidServ
     listener = socket.socket()
     listener.bind(("localhost", 0))
     listener.listen(1)
-    remote_server = partial(_server, listener, remote_service, remote_config, args)
-    t = Process(target=remote_server)
+
+    def server(listener=listener, args=args):
+        with closing(listener):
+            client = listener.accept()[0]
+        conn = connect_stream(SocketStream(client), service=remote_service, config=remote_config)
+        try:
+            for k in args:
+                conn._local_root.exposed_namespace[k] = args[k]
+            conn.serve_all()
+        except KeyboardInterrupt:
+            interrupt_main()
+
+    t = Process(target=server)
     t.start()
     host, port = listener.getsockname()
     return connect(host, port, service=service, config=config)
diff --git a/plainbox/vendor/rpyc/utils/helpers.py b/plainbox/vendor/rpyc/utils/helpers.py
index 67be083..521e226 100644
--- a/plainbox/vendor/rpyc/utils/helpers.py
+++ b/plainbox/vendor/rpyc/utils/helpers.py
@@ -34,7 +34,7 @@ def buffiter(obj, chunk=10, max_chunk=1000, factor=2):
             print id, name, dob
     """
     if factor < 1:
-        raise ValueError("factor must be >= 1, got {!r}".format((factor)))
+        raise ValueError("factor must be >= 1, got %r" % (factor,))
     it = iter(obj)
     count = chunk
     while True:
@@ -102,7 +102,7 @@ class _Async(object):
         return asyncreq(self.proxy, HANDLE_CALL, args, tuple(kwargs.items()))
 
     def __repr__(self):
-        return "async_({!r})".format((self.proxy))
+        return "async_(%r)" % (self.proxy,)
 
 
 _async_proxies_cache = WeakValueDict()
@@ -145,9 +145,9 @@ def async_(proxy):
     if pid in _async_proxies_cache:
         return _async_proxies_cache[pid]
     if not hasattr(proxy, "____conn__") or not hasattr(proxy, "____id_pack__"):
-        raise TypeError("'proxy' must be a Netref: {!r}".format((proxy)))
+        raise TypeError("'proxy' must be a Netref: %r", (proxy,))
     if not callable(proxy):
-        raise TypeError("'proxy' must be callable: {!r}".format((proxy)))
+        raise TypeError("'proxy' must be callable: %r" % (proxy,))
     caller = _Async(proxy)
     _async_proxies_cache[id(caller)] = _async_proxies_cache[pid] = caller
     return caller
@@ -186,7 +186,7 @@ class timed(object):
         return res
 
     def __repr__(self):
-        return "timed({!r}, {!r})".format((self.proxy.proxy), (self.timeout))
+        return "timed(%r, %r)" % (self.proxy.proxy, self.timeout)
 
 
 class BgServingThread(object):
diff --git a/plainbox/vendor/rpyc/utils/registry.py b/plainbox/vendor/rpyc/utils/registry.py
index b9a58ff..315d9f3 100644
--- a/plainbox/vendor/rpyc/utils/registry.py
+++ b/plainbox/vendor/rpyc/utils/registry.py
@@ -1,8 +1,13 @@
 """
-RPyC Registry Server maintains service information on RPyC services for *Service Registry and Discovery patterns*. Service Registry and Discovery patterns solve the connectivity problem for communication between services and external consumers. RPyC services will register with the server when :code:`auto_register` is :code:`True`.
+RPyC **registry server** implementation. The registry is much like
+`Avahi <http://en.wikipedia.org/wiki/Avahi_(software)>`_ or
+`Bonjour <http://en.wikipedia.org/wiki/Bonjour_(software)>`_, but tailored to
+the needs of RPyC. Also, neither of them supports (or supported) Windows,
+and Bonjour has a restrictive license. Moreover, they are too "powerful" for
+what RPyC needed and required too complex a setup.
 
-Service registries such as `Avahi <http://en.wikipedia.org/wiki/Avahi_(software)>`_ and
-`Bonjour <http://en.wikipedia.org/wiki/Bonjour_(software)>`_ are alternatives to the RPyC Registry Server. These alternatives do no support Windows and have more restrictive licensing.
+If anyone wants to implement the RPyC registry using Avahi, Bonjour, or any
+other zeroconf implementation -- I'll be happy to include them.
 
 Refer to :file:`rpyc/scripts/rpyc_registry.py` for more info.
 """
@@ -26,7 +31,7 @@ REGISTRY_PORT = 18811
 class RegistryServer(object):
     """Base registry server"""
 
-    def __init__(self, listenersock, pruning_timeout=None, logger=None, allow_listing=False):
+    def __init__(self, listenersock, pruning_timeout=None, logger=None):
         self.sock = listenersock
         self.port = self.sock.getsockname()[1]
         self.active = False
@@ -36,7 +41,6 @@ class RegistryServer(object):
         self.pruning_timeout = pruning_timeout
         if logger is None:
             logger = self._get_logger()
-        self.allow_listing = allow_listing
         self.logger = logger
 
     def _get_logger(self):
@@ -75,7 +79,7 @@ class RegistryServer(object):
     def cmd_query(self, host, name):
         """implementation of the ``query`` command"""
         name = name.upper()
-        self.logger.debug("querying for {!r}".format((name)))
+        self.logger.debug("querying for %r", name)
         if name not in self.services:
             self.logger.debug("no such service")
             return ()
@@ -85,35 +89,24 @@ class RegistryServer(object):
         servers = []
         for addrinfo, t in all_servers:
             if t < oldest:
-                self.logger.debug("discarding stale {}:{}".format((addrinfo[0]), (addrinfo[1])))
+                self.logger.debug("discarding stale %s:%s", *addrinfo)
                 self._remove_service(name, addrinfo)
             else:
                 servers.append(addrinfo)
 
-        self.logger.debug("replying with {!r}".format((servers)))
+        self.logger.debug("replying with %r", servers)
         return tuple(servers)
 
-    def cmd_list(self, host):
-        """implementation for the ``list`` command"""
-        self.logger.debug("querying for services list:")
-        if not self.allow_listing:
-            self.logger.debug("listing is disabled")
-            return None
-        services = tuple(self.services.keys())
-        self.logger.debug("replying with {}".format((services)))
-
-        return services
-
     def cmd_register(self, host, names, port):
         """implementation of the ``register`` command"""
-        self.logger.debug("registering {}:{} as {}".format((host), (port), (', '.join(names))))
+        self.logger.debug("registering %s:%s as %s", host, port, ", ".join(names))
         for name in names:
             self._add_service(name.upper(), (host, port))
         return "OK"
 
     def cmd_unregister(self, host, port):
         """implementation of the ``unregister`` command"""
-        self.logger.debug("unregistering {}:{}".format((host), (port)))
+        self.logger.debug("unregistering %s:%s", host, port)
         for name in list(self.services.keys()):
             self._remove_service(name, (host, port))
         return "OK"
@@ -135,11 +128,11 @@ class RegistryServer(object):
             except Exception:
                 continue
             if magic != "RPYC":
-                self.logger.warn("invalid magic: {!r}".format((magic)))
+                self.logger.warn("invalid magic: %r", magic)
                 continue
-            cmdfunc = getattr(self, "cmd_{}".format((cmd.lower())), None)
+            cmdfunc = getattr(self, "cmd_%s" % (cmd.lower(),), None)
             if not cmdfunc:
-                self.logger.warn("unknown command: {!r}".format((cmd)))
+                self.logger.warn("unknown command: %r", cmd)
                 continue
 
             try:
@@ -155,8 +148,7 @@ class RegistryServer(object):
             raise ValueError("server is already running")
         if self.sock is None:
             raise ValueError("object disposed")
-        addrinfo = self.sock.getsockname()[:2]
-        self.logger.debug("server started on {}:{}".format((addrinfo[0]), (addrinfo[1])))
+        self.logger.debug("server started on %s:%s", *self.sock.getsockname()[:2])
         try:
             self.active = True
             self._work()
@@ -182,17 +174,17 @@ class UDPRegistryServer(RegistryServer):
 
     TIMEOUT = 1.0
 
-    def __init__(self, host="0.0.0.0", port=REGISTRY_PORT, pruning_timeout=None, logger=None, allow_listing=False):
+    def __init__(self, host="0.0.0.0", port=REGISTRY_PORT, pruning_timeout=None, logger=None):
         family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, 0,
                                                                   socket.SOCK_DGRAM)[0]
         sock = socket.socket(family, socktype, proto)
         sock.bind(sockaddr)
         sock.settimeout(self.TIMEOUT)
         RegistryServer.__init__(self, sock, pruning_timeout=pruning_timeout,
-                                logger=logger, allow_listing=allow_listing)
+                                logger=logger)
 
     def _get_logger(self):
-        return logging.getLogger("REGSRV/UDP/{}".format((self.port)))
+        return logging.getLogger("REGSRV/UDP/%d" % (self.port,))
 
     def _recv(self):
         return self.sock.recvfrom(MAX_DGRAM_SIZE)
@@ -212,9 +204,10 @@ class TCPRegistryServer(RegistryServer):
     TIMEOUT = 3.0
 
     def __init__(self, host="0.0.0.0", port=REGISTRY_PORT, pruning_timeout=None,
-                 logger=None, reuse_addr=True, allow_listing=False):
+                 logger=None, reuse_addr=True):
 
-        family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM)[0]
+        family, socktype, proto, _, sockaddr = socket.getaddrinfo(host, port, 0,
+                                                                  socket.SOCK_STREAM)[0]
         sock = socket.socket(family, socktype, proto)
         if reuse_addr and sys.platform != "win32":
             # warning: reuseaddr is not what you expect on windows!
@@ -223,11 +216,11 @@ class TCPRegistryServer(RegistryServer):
         sock.listen(10)
         sock.settimeout(self.TIMEOUT)
         RegistryServer.__init__(self, sock, pruning_timeout=pruning_timeout,
-                                logger=logger, allow_listing=allow_listing)
+                                logger=logger)
         self._connected_sockets = {}
 
     def _get_logger(self):
-        return logging.getLogger("REGSRV/TCP/{}".format((self.port)))
+        return logging.getLogger("REGSRV/TCP/%d" % (self.port,))
 
     def _recv(self):
         sock2, _ = self.sock.accept()
@@ -274,13 +267,6 @@ class RegistryClient(object):
         """
         raise NotImplementedError()
 
-    def list(self):
-        """
-        Send a query for the full lists of exposed servers
-        :returns: a list of `` service_name ``
-        """
-        raise NotImplementedError()
-
     def register(self, aliases, port):
         """Registers the given service aliases with the given TCP port. This
         API is intended to be called only by an RPyC server.
@@ -307,7 +293,6 @@ class UDPRegistryClient(RegistryClient):
     Example::
 
         registrar = UDPRegistryClient()
-        list_of_services = registrar.list()
         list_of_servers = registrar.discover("foo")
 
     .. note::
@@ -349,26 +334,8 @@ class UDPRegistryClient(RegistryClient):
                 servers = brine.load(data)
         return servers
 
-    def list(self):
-        sock = socket.socket(self.sock_family, socket.SOCK_DGRAM)
-
-        with closing(sock):
-            if self.bcast:
-                sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
-            data = brine.dump(("RPYC", "LIST", ()))
-            sock.sendto(data, (self.ip, self.port))
-            sock.settimeout(self.timeout)
-
-            try:
-                data, _ = sock.recvfrom(MAX_DGRAM_SIZE)
-            except (socket.error, socket.timeout):
-                services = ()
-            else:
-                services = brine.load(data)
-        return services
-
     def register(self, aliases, port, interface=""):
-        self.logger.info("registering on {}:{}".format((self.ip), (self.port)))
+        self.logger.info("registering on %s:%s", self.ip, self.port)
         sock = socket.socket(self.sock_family, socket.SOCK_DGRAM)
         with closing(sock):
             sock.bind((interface, 0))
@@ -393,14 +360,14 @@ class UDPRegistryClient(RegistryClient):
                 except Exception:
                     continue
                 if reply == "OK":
-                    self.logger.info("registry {}:{} acknowledged".format((rip), (rport)))
+                    self.logger.info("registry %s:%s acknowledged", rip, rport)
                     return True
             else:
                 self.logger.warn("no registry acknowledged")
                 return False
 
     def unregister(self, port):
-        self.logger.info("unregistering from {}:{}".format((self.ip), (self.port)))
+        self.logger.info("unregistering from %s:%s", self.ip, self.port)
         sock = socket.socket(self.sock_family, socket.SOCK_DGRAM)
         with closing(sock):
             if self.bcast:
@@ -416,7 +383,6 @@ class TCPRegistryClient(RegistryClient):
     Example::
 
         registrar = TCPRegistryClient("localhost")
-        list_of_services = registrar.list()
         list_of_servers = registrar.discover("foo")
 
     .. note::
@@ -446,24 +412,8 @@ class TCPRegistryClient(RegistryClient):
                 servers = brine.load(data)
         return servers
 
-    def list(self):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        with closing(sock):
-            sock.settimeout(self.timeout)
-            data = brine.dump(("RPYC", "LIST", ()))
-            sock.connect((self.ip, self.port))
-            sock.send(data)
-
-            try:
-                data = sock.recv(MAX_DGRAM_SIZE)
-            except (socket.error, socket.timeout):
-                servers = ()
-            else:
-                servers = brine.load(data)
-        return servers
-
     def register(self, aliases, port, interface=""):
-        self.logger.info("registering on {}:{}".format((self.ip), (self.port)))
+        self.logger.info("registering on %s:%s", self.ip, self.port)
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         with closing(sock):
             sock.bind((interface, 0))
@@ -486,12 +436,12 @@ class TCPRegistryClient(RegistryClient):
                 self.logger.warn("received corrupted data from registry")
                 return False
             if reply == "OK":
-                self.logger.info("registry {}:{} acknowledged".format((self.ip), (self.port)))
+                self.logger.info("registry %s:%s acknowledged", self.ip, self.port)
 
             return True
 
     def unregister(self, port):
-        self.logger.info("unregistering from {}:{}".format((self.ip), (self.port)))
+        self.logger.info("unregistering from %s:%s", self.ip, self.port)
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         with closing(sock):
             sock.settimeout(self.timeout)
diff --git a/plainbox/vendor/rpyc/utils/server.py b/plainbox/vendor/rpyc/utils/server.py
index 2e73ecb..d50e118 100644
--- a/plainbox/vendor/rpyc/utils/server.py
+++ b/plainbox/vendor/rpyc/utils/server.py
@@ -26,8 +26,8 @@ class Server(object):
     """Base server implementation
 
     :param service: the :class:`~rpyc.core.service.Service` to expose
-    :param hostname: the host to bind to. By default, the 'wildcard address' is used to listen on all interfaces.
-                     if not properly secured, the server can receive traffic from unintended or even malicious sources.
+    :param hostname: the host to bind to. Default is IPADDR_ANY, but you may
+                     want to restrict it only to ``localhost`` in some setups
     :param ipv6: whether to create an IPv6 or IPv4 socket. The default is IPv4
     :param port: the TCP port to bind to
     :param backlog: the socket's backlog (passed to ``listen()``)
@@ -47,9 +47,9 @@ class Server(object):
                              on embedded platforms with limited battery)
     """
 
-    def __init__(self, service, hostname=None, ipv6=False, port=0,
+    def __init__(self, service, hostname="", ipv6=False, port=0,
                  backlog=socket.SOMAXCONN, reuse_addr=True, authenticator=None, registrar=None,
-                 auto_register=None, protocol_config=None, logger=None, listener_timeout=0.5,
+                 auto_register=None, protocol_config={}, logger=None, listener_timeout=0.5,
                  socket_path=None):
         self.active = False
         self._closed = False
@@ -60,15 +60,11 @@ class Server(object):
             self.auto_register = bool(registrar)
         else:
             self.auto_register = auto_register
-
-        if protocol_config is None:
-            protocol_config = {}
-
         self.protocol_config = protocol_config
         self.clients = set()
 
         if socket_path is not None:
-            if hostname is not None or port != 0 or ipv6 is not False:
+            if hostname != "" or port != 0 or ipv6 is not False:
                 raise ValueError("socket_path is mutually exclusive with: hostname, port, ipv6")
             self.listener = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
             self.listener.bind(socket_path)
@@ -76,18 +72,20 @@ class Server(object):
             self.host, self.port = "", socket_path
         else:
             if ipv6:
-                family = socket.AF_INET6
+                if hostname == "localhost" and sys.platform != "win32":
+                    # on windows, you should bind to localhost even for ipv6
+                    hostname = "localhost6"
+                self.listener = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
             else:
-                family = socket.AF_INET
-            self.listener = socket.socket(family, socket.SOCK_STREAM)
-            address = socket.getaddrinfo(hostname, port, family=family, type=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP, flags=socket.AI_PASSIVE)[0][-1]
+                self.listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
             if reuse_addr and sys.platform != "win32":
                 # warning: reuseaddr is not what you'd expect on windows!
                 # it allows you to bind an already bound port, resulting in
                 # "unexpected behavior" (quoting MSDN)
                 self.listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            self.listener.bind(address)
+
+            self.listener.bind((hostname, port))
             self.listener.settimeout(listener_timeout)
 
             # hack for IPv6 (the tuple can be longer than 2)
@@ -95,7 +93,7 @@ class Server(object):
             self.host, self.port = sockname[0], sockname[1]
 
         if logger is None:
-            logger = logging.getLogger("{}/{}".format((self.service.get_service_name()), (self.port)))
+            logger = logging.getLogger("%s/%s" % (self.service.get_service_name(), self.port))
         self.logger = logger
         if "logger" not in self.protocol_config:
             self.protocol_config["logger"] = self.logger
@@ -153,7 +151,7 @@ class Server(object):
             return
 
         sock.setblocking(True)
-        self.logger.info("accepted {} with fd {}".format((addrinfo), (sock.fileno())))
+        self.logger.info("accepted %s with fd %s", addrinfo, sock.fileno())
         self.clients.add(sock)
         self._accept_method(sock)
 
@@ -171,10 +169,10 @@ class Server(object):
                 try:
                     sock2, credentials = self.authenticator(sock)
                 except AuthenticationError:
-                    self.logger.info("{} failed to authenticate... rejecting connection".format((addrinfo)))
+                    self.logger.info("%s failed to authenticate, rejecting connection", addrinfo)
                     return
                 else:
-                    self.logger.info("{} authenticated successfully".format((addrinfo)))
+                    self.logger.info("%s authenticated successfully", addrinfo)
             else:
                 credentials = None
                 sock2 = sock
@@ -194,16 +192,16 @@ class Server(object):
     def _serve_client(self, sock, credentials):
         addrinfo = sock.getpeername()
         if credentials:
-            self.logger.info("welcome {} ({!r})".format((addrinfo), (credentials)))
+            self.logger.info("welcome %s (%r)", addrinfo, credentials)
         else:
-            self.logger.info("welcome {}".format((addrinfo)))
+            self.logger.info("welcome %s", addrinfo)
         try:
             config = dict(self.protocol_config, credentials=credentials,
                           endpoints=(sock.getsockname(), addrinfo), logger=self.logger)
             conn = self.service._connect(Channel(SocketStream(sock)), config)
             self._handle_connection(conn)
         finally:
-            self.logger.info("goodbye {}".format((addrinfo)))
+            self.logger.info("goodbye %s", addrinfo)
 
     def _handle_connection(self, conn):
         """This methoed should implement the server's logic."""
@@ -212,7 +210,7 @@ class Server(object):
     def _bg_register(self):
         interval = self.registrar.REREGISTER_INTERVAL
         self.logger.info("started background auto-register thread "
-                         "(interval = {})".format((interval)))
+                         "(interval = %s)", interval)
         tnext = 0
         try:
             while self.active:
@@ -247,11 +245,12 @@ class Server(object):
             # Note that for AF_UNIX the following won't work (but we are safe
             # since we already saved the socket_path into self.port):
             self.port = self.listener.getsockname()[1]
-        self.logger.info("server started on [{}]:{}".format((self.host), (self.port)))
+        self.logger.info("server started on [%s]:%s", self.host, self.port)
         self.active = True
 
     def _register(self):
         if self.auto_register:
+            self.auto_register = False
             spawn(self._bg_register)
 
     def start(self):
@@ -341,7 +340,7 @@ class ThreadPoolServer(Server):
         self.workers = []
         for i in range(self.nbthreads):
             t = spawn(self._serve_clients)
-            t.setName("Worker{}".format((i)))
+            t.setName('Worker%i' % i)
             self.workers.append(t)
         # setup a thread for polling inactive connections
         self.polling_thread = spawn(self._poll_inactive_clients)
@@ -382,7 +381,7 @@ class ThreadPoolServer(Server):
             pass
 
         # close connection
-        self.logger.info("Closing connection for fd {}".format((fd)))
+        self.logger.info("Closing connection for fd %d", fd)
         if conn:
             conn.close()
 
@@ -420,7 +419,7 @@ class ThreadPoolServer(Server):
             except Exception:
                 ex = sys.exc_info()[1]
                 # "Caught exception in Worker thread" message
-                self.logger.warning("Failed to poll clients, caught exception : {}".format((ex)))
+                self.logger.warning("Failed to poll clients, caught exception : %s", str(ex))
                 # wait a bit so that we do not loop too fast in case of error
                 time.sleep(0.2)
 
@@ -468,7 +467,7 @@ class ThreadPoolServer(Server):
                 time.sleep(0.2)
 
     def _authenticate_and_build_connection(self, sock):
-        '''Authenticate a client and if it succeeds, wraps the socket in a connection object.
+        '''Authenticate a client and if it succees, wraps the socket in a connection object.
         Note that this code is cut and paste from the rpyc internals and may have to be
         changed if rpyc evolves'''
         # authenticate
@@ -477,27 +476,27 @@ class ThreadPoolServer(Server):
         else:
             credentials = None
         # build a connection
-        addrinfo = sock.getpeername()
-        config = dict(self.protocol_config, credentials=credentials, connid="{}".format(addrinfo),
-                      endpoints=(sock.getsockname(), addrinfo))
+        h, p = sock.getpeername()
+        config = dict(self.protocol_config, credentials=credentials, connid="%s:%d" % (h, p),
+                      endpoints=(sock.getsockname(), (h, p)))
         return sock, self.service._connect(Channel(SocketStream(sock)), config)
 
     def _accept_method(self, sock):
         '''Implementation of the accept method : only pushes the work to the internal queue.
         In case the queue is full, raises an AsynResultTimeout error'''
         try:
-            addrinfo = None
+            h, p = None, None
             # authenticate and build connection object
             sock, conn = self._authenticate_and_build_connection(sock)
             # put the connection in the active queue
-            addrinfo = sock.getpeername()
+            h, p = sock.getpeername()
             fd = conn.fileno()
-            self.logger.debug("Created connection to {addrinfo} with fd {fd}")
+            self.logger.debug("Created connection to %s:%d with fd %d", h, p, fd)
             self.fd_to_conn[fd] = conn
             self._add_inactive_connection(fd)
             self.clients.clear()
         except Exception:
-            err_msg = "Failed to serve client for {}, caught exception".format(addrinfo)
+            err_msg = "Failed to serve client for {}:{}, caught exception".format(h, p)
             self.logger.exception(err_msg)
             sock.close()
 
@@ -564,6 +563,7 @@ class GeventServer(Server):
 
     def _register(self):
         if self.auto_register:
+            self.auto_register = False
             gevent.spawn(self._bg_register)
 
     def _accept_method(self, sock):
diff --git a/plainbox/vendor/rpyc/utils/teleportation.py b/plainbox/vendor/rpyc/utils/teleportation.py
index a06af70..451c93d 100644
--- a/plainbox/vendor/rpyc/utils/teleportation.py
+++ b/plainbox/vendor/rpyc/utils/teleportation.py
@@ -1,21 +1,48 @@
 import opcode
-
-from plainbox.vendor.rpyc.lib.compat import is_py_gte38
+import sys
+try:
+    import __builtin__
+except ImportError:
+    import builtins as __builtin__  # noqa: F401
+from plainbox.vendor.rpyc.lib.compat import is_py_3k, is_py_gte38
 from types import CodeType, FunctionType
-from plainbox.vendor.rpyc.core import brine, netref
-from dis import _unpack_opargs
+from plainbox.vendor.rpyc.core import brine
+from plainbox.vendor.rpyc.core import netref
 
 CODEOBJ_MAGIC = "MAg1c J0hNNzo0hn ZqhuBP17LQk8"
 
 
 # NOTE: dislike this kind of hacking on the level of implementation details,
 # should search for a more reliable/future-proof way:
-CODE_HAVEARG_SIZE = 3
+CODE_HAVEARG_SIZE = 2 if sys.version_info >= (3, 6) else 3
+try:
+    from dis import _unpack_opargs
+except ImportError:
+    # COPIED from 3.5's `dis.py`, this should hopefully be correct for <=3.5:
+    def _unpack_opargs(code):
+        extended_arg = 0
+        n = len(code)
+        i = 0
+        while i < n:
+            op = code[i]
+            offset = i
+            i = i + 1
+            arg = None
+            if op >= opcode.HAVE_ARGUMENT:
+                arg = code[i] + code[i + 1] * 256 + extended_arg
+                extended_arg = 0
+                i = i + 2
+                if op == opcode.EXTENDED_ARG:
+                    extended_arg = arg * 65536
+            yield (offset, op, arg)
 
 
 def decode_codeobj(codeobj):
     # adapted from dis.dis
-    codestr = codeobj.co_code
+    if is_py_3k:
+        codestr = codeobj.co_code
+    else:
+        codestr = [ord(ch) for ch in codeobj.co_code]
     free = None
     for i, op, oparg in _unpack_opargs(codestr):
         opname = opcode.opname[op]
@@ -46,7 +73,7 @@ def _export_codeobj(cobj):
         elif isinstance(const, CodeType):
             consts2.append(_export_codeobj(const))
         else:
-            raise TypeError(f"Cannot export a function with non-brinable constants: {const!r}")
+            raise TypeError("Cannot export a function with non-brinable constants: %r" % (const,))
 
     if is_py_gte38:
         # Constructor was changed in 3.8 to support "advanced" programming styles
@@ -54,41 +81,50 @@ def _export_codeobj(cobj):
                     cobj.co_stacksize, cobj.co_flags, cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames,
                     cobj.co_filename, cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars,
                     cobj.co_cellvars)
-    else:
+    elif is_py_3k:
         exported = (cobj.co_argcount, cobj.co_kwonlyargcount, cobj.co_nlocals, cobj.co_stacksize, cobj.co_flags,
                     cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
                     cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
+    else:
+        exported = (cobj.co_argcount, cobj.co_nlocals, cobj.co_stacksize, cobj.co_flags,
+                    cobj.co_code, tuple(consts2), cobj.co_names, cobj.co_varnames, cobj.co_filename,
+                    cobj.co_name, cobj.co_firstlineno, cobj.co_lnotab, cobj.co_freevars, cobj.co_cellvars)
+
     assert brine.dumpable(exported)
     return (CODEOBJ_MAGIC, exported)
 
 
 def export_function(func):
-    closure = func.__closure__
-    code = func.__code__
-    defaults = func.__defaults__
-    kwdefaults = func.__kwdefaults__
-    if kwdefaults is not None:
-        kwdefaults = tuple(kwdefaults.items())
-
-    if closure:
+    if is_py_3k:
+        func_closure = func.__closure__
+        func_code = func.__code__
+        func_defaults = func.__defaults__
+    else:
+        func_closure = func.func_closure
+        func_code = func.func_code
+        func_defaults = func.func_defaults
+
+    if func_closure:
         raise TypeError("Cannot export a function closure")
-    if not brine.dumpable(defaults):
-        raise TypeError("Cannot export a function with non-brinable defaults (__defaults__)")
-    if not brine.dumpable(kwdefaults):
-        raise TypeError("Cannot export a function with non-brinable defaults (__kwdefaults__)")
+    if not brine.dumpable(func_defaults):
+        raise TypeError("Cannot export a function with non-brinable defaults (func_defaults)")
 
-    return func.__name__, func.__module__, defaults, kwdefaults, _export_codeobj(code)[1]
+    return func.__name__, func.__module__, func_defaults, _export_codeobj(func_code)[1]
 
 
 def _import_codetup(codetup):
-    # Handle tuples sent from 3.8 as well as 3 < version < 3.8.
-    if len(codetup) == 16:
-        (argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
-         filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
+    if is_py_3k:
+        # Handle tuples sent from 3.8 as well as 3 < version < 3.8.
+        if len(codetup) == 16:
+            (argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+             filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
+        else:
+            (argcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+             filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
+            posonlyargcount = 0
     else:
-        (argcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
+        (argcount, nlocals, stacksize, flags, code, consts, names, varnames,
          filename, name, firstlineno, lnotab, freevars, cellvars) = codetup
-        posonlyargcount = 0
 
     consts2 = []
     for const in consts:
@@ -100,14 +136,17 @@ def _import_codetup(codetup):
     if is_py_gte38:
         codetup = (argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames,
                    filename, name, firstlineno, lnotab, freevars, cellvars)
-    else:
+    elif is_py_3k:
         codetup = (argcount, kwonlyargcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name,
                    firstlineno, lnotab, freevars, cellvars)
+    else:
+        codetup = (argcount, nlocals, stacksize, flags, code, consts, names, varnames, filename, name, firstlineno,
+                   lnotab, freevars, cellvars)
     return CodeType(*codetup)
 
 
 def import_function(functup, globals=None, def_=True):
-    name, modname, defaults, kwdefaults, codetup = functup
+    name, modname, defaults, codetup = functup
     if globals is None:
         try:
             mod = __import__(modname, None, None, "*")
@@ -116,13 +155,11 @@ def import_function(functup, globals=None, def_=True):
         globals = mod.__dict__
     # function globals must be real dicts, sadly:
     if isinstance(globals, netref.BaseNetref):
-        from rpyc.utils.classic import obtain
+        from plainbox.vendor.rpyc.utils.classic import obtain
         globals = obtain(globals)
     globals.setdefault('__builtins__', __builtins__)
     codeobj = _import_codetup(codetup)
     funcobj = FunctionType(codeobj, globals, name, defaults)
-    if kwdefaults is not None:
-        funcobj.__kwdefaults__ = {t[0]: t[1] for t in kwdefaults}
     if def_:
         globals[name] = funcobj
     return funcobj
diff --git a/plainbox/vendor/rpyc/utils/zerodeploy.py b/plainbox/vendor/rpyc/utils/zerodeploy.py
index a246e64..bbc4922 100644
--- a/plainbox/vendor/rpyc/utils/zerodeploy.py
+++ b/plainbox/vendor/rpyc/utils/zerodeploy.py
@@ -55,7 +55,7 @@ $EXTRA_SETUP$
 t = ServerCls(SlaveService, hostname = "localhost", port = 0, reuse_addr = True, logger = logger)
 thd = t._start_in_thread()
 
-sys.stdout.write(f"{t.port}\n")
+sys.stdout.write("%s\n" % (t.port,))
 sys.stdout.flush()
 
 try:
@@ -111,7 +111,7 @@ class DeployedServer(object):
             major = sys.version_info[0]
             minor = sys.version_info[1]
             cmd = None
-            for opt in [f"python{major}.{minor}", f"python{major}"]:
+            for opt in ["python%s.%s" % (major, minor), "python%s" % (major,)]:
                 try:
                     cmd = remote_machine[opt]
                 except CommandNotFound:
@@ -155,26 +155,15 @@ class DeployedServer(object):
         if self.proc is not None:
             try:
                 self.proc.terminate()
-                self.proc.communicate()
             except Exception:
                 pass
             self.proc = None
         if self.tun is not None:
             try:
-                self.tun._session.proc.terminate()
-                self.tun._session.proc.communicate()
                 self.tun.close()
             except Exception:
                 pass
             self.tun = None
-        if self.remote_machine is not None:
-            try:
-                self.remote_machine._session.proc.terminate()
-                self.remote_machine._session.proc.communicate()
-                self.remote_machine.close()
-            except Exception:
-                pass
-            self.remote_machine = None
         if self._tmpdir_ctx is not None:
             try:
                 self._tmpdir_ctx.__exit__(None, None, None)
diff --git a/plainbox/vendor/rpyc/version.py b/plainbox/vendor/rpyc/version.py
index 3028d79..d7618e4 100644
--- a/plainbox/vendor/rpyc/version.py
+++ b/plainbox/vendor/rpyc/version.py
@@ -1,3 +1,3 @@
-version = (5, 1, 0)
+version = (4, 1, 4)
 version_string = ".".join(map(str, version))
-release_date = "2022-02-26"
+release_date = "2020.1.30"