Merge ~sylvain-pineau/checkbox-ng:drop-legacy-commands into checkbox-ng:master

[Sylvain Pineau]

Drop legacy commands (including the checkbox sru) to only keep checkbox-cli as the unique entry point.

The two missing commands (check-config and submit) have been transfered to checkbox-cli subcommands.
With the removal of checkbox sru, we can also say goodbye to the old textland bits and drop all sru specific options from the config module.

- checkbox-cli as a launcher tested with 16.04 certification test plan.
- check-config ok (properly see ~/.config/checkbox.conf).
- submit ok (tested both xml and tar.xz with both prod and staging endpoints - only staging for the submission service).

PLEASE DO NOT MERGE UNTIL SRU TOOLS ARE UPDATED IN THE LAB. (Contact: Tai)

[Maciej Kisielewski (kissiel)]

As of 61decd1 commit everything looks (and works) good.
I wonder if there are any configurations using the old syntax... Guess we'll learn after this lands :-)

review: Approve

[Taihsiang Ho (tai271828)]

SRU tools is ready to merge. Please refer to:

https://code.launchpad.net/~taihsiangho/checkbox-ng/+git/packaging/+merge/326360
https://code.launchpad.net/~taihsiangho/checkbox-ng/+git/packaging/+merge/326361

review: Approve

[Taihsiang Ho (tai271828)]

It should be this https://code.launchpad.net/~taihsiangho/checkbox-ng/+git/checkbox-ng/+merge/326363 instead of mr326361

diff --git a/checkbox_ng/commands/__init__.py b/checkbox_ng/commands/__init__.py
deleted file mode 100644
index a7ea4d3..0000000
--- a/checkbox_ng/commands/__init__.py
+++ /dev/null
@@ -1,63 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 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/>.
-
-"""
-:mod:`checkbox_ng.commands` -- shared code for checkbox-ng sub-commands
-=======================================================================
-"""
-
-from plainbox.impl.clitools import CommandBase
-
-
-class CheckboxCommand(CommandBase):
-    """
-    Simple interface class for checkbox-ng commands.
-
-    Command objects like this are consumed by CheckBoxNGTool subclasses to
-    implement hierarchical command system. The API supports arbitrary many sub
-    commands in arbitrary nesting arrangement.
-    """
-
-    gettext_domain = "checkbox-ng"
-
-    def __init__(self, provider_loader, config_loader):
-        """
-        Initialize a command with the specified arguments.
-
-        :param provider_loader:
-            A callable returning a list of Provider1 objects
-        :param config_loader:
-            A callable returning a Config object
-        """
-        self._provider_loader = provider_loader
-        self._config_loader = config_loader
-
-    @property
-    def provider_loader(self):
-        """
-        a callable returning a list of PlainBox providers associated with this
-        command
-        """
-        return self._provider_loader
-
-    @property
-    def config_loader(self):
-        """
-        a callable returning a Config object
-        """
-        return self._config_loader
diff --git a/checkbox_ng/commands/cli.py b/checkbox_ng/commands/cli.py
deleted file mode 100644
index e7d6c45..0000000
--- a/checkbox_ng/commands/cli.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013-2014 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.commands.cli` -- Command line sub-command
-===========================================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-
-from argparse import SUPPRESS
-from gettext import gettext as _
-from logging import getLogger
-
-from plainbox.impl.commands import PlainBoxCommand
-from plainbox.impl.commands.cmd_checkbox import CheckBoxCommandMixIn
-from plainbox.impl.commands.inv_check_config import CheckConfigInvocation
-
-from checkbox_ng.commands.newcli import CliInvocation2
-
-
-logger = getLogger("checkbox.ng.commands.cli")
-
-
-class CliCommand(PlainBoxCommand, CheckBoxCommandMixIn):
-    """
-    Command for running tests using the command line UI.
-    """
-    gettext_domain = "checkbox-ng"
-
-    def __init__(self, provider_loader, config_loader, settings):
-        self.provider_loader = provider_loader
-        self.config_loader = config_loader
-        self.settings = settings
-
-    def invoked(self, ns):
-        # Run check-config, if requested
-        if ns.check_config:
-            retval = CheckConfigInvocation(self.config_loader).run()
-            return retval
-        return CliInvocation2(
-            self.provider_loader, self.loader_config, ns, self.settings
-        ).run()
-
-    def register_parser(self, subparsers):
-        parser = subparsers.add_parser(self.settings['subparser_name'],
-                                       help=self.settings['subparser_help'])
-        parser.set_defaults(command=self)
-        parser.set_defaults(dry_run=False)
-        parser.add_argument(
-            "--check-config",
-            action="store_true",
-            help=_("run check-config"))
-        group = parser.add_argument_group(title=_("user interface options"))
-        parser.set_defaults(color=None)
-        group.add_argument(
-            '--no-color', dest='color', action='store_false', help=SUPPRESS)
-        group.add_argument(
-            '--non-interactive', action='store_true',
-            help=_("skip tests that require interactivity"))
-        group.add_argument(
-            '--dont-suppress-output', action="store_true", default=False,
-            help=_("don't suppress the output of certain job plugin types"))
-        # Call enhance_parser from CheckBoxCommandMixIn
-        self.enhance_parser(parser)
diff --git a/checkbox_ng/commands/launcher.py b/checkbox_ng/commands/launcher.py
deleted file mode 100644
index 87eb180..0000000
--- a/checkbox_ng/commands/launcher.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 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/>.
-
-"""
-:mod:`checkbox_ng.commands.launcher` -- `checkbox launcher` command
-===================================================================
-"""
-
-from argparse import SUPPRESS
-from gettext import gettext as _
-import itertools
-import logging
-import os
-
-from checkbox_ng.commands import CheckboxCommand
-from checkbox_ng.commands.newcli import CliInvocation2
-from checkbox_ng.commands.submit import SubmitCommand
-from checkbox_ng.config import CheckBoxConfig
-
-from plainbox.impl.commands.cmd_checkbox import CheckBoxCommandMixIn
-from plainbox.impl.launcher import LauncherDefinition
-
-logger = logging.getLogger("checkbox.ng.commands.launcher")
-
-
-class LauncherCommand(CheckboxCommand, CheckBoxCommandMixIn, SubmitCommand):
-    """
-    run a customized testing session
-
-    This command can be used as an interpreter for the so-called launchers.
-    Those launchers are small text files that define the parameters of the test
-    and can be executed directly to run a customized checkbox-ng testing
-    session.
-    """
-
-    def __init__(self, provider_loader, config_loader):
-        self._provider_loader = provider_loader
-        self.config = config_loader()
-
-    def invoked(self, ns):
-        try:
-            with open(ns.launcher, 'rt', encoding='UTF-8') as stream:
-                first_line = stream.readline()
-                if not first_line.startswith("#!"):
-                    stream.seek(0)
-                text = stream.read()
-        except IOError as exc:
-            logger.error(_("Unable to load launcher definition: %s"), exc)
-            return 1
-        generic_launcher = LauncherDefinition()
-        generic_launcher.read_string(text)
-        launcher = generic_launcher.get_concrete_launcher()
-        launcher.read_string(text)
-        if launcher.problem_list:
-            logger.error(_("Unable to start launcher because of errors:"))
-            for problem in launcher.problem_list:
-                logger.error("%s", str(problem))
-            return 1
-        # Override the default CheckBox configuration with the one provided
-        # by the launcher
-        self.config.Meta.filename_list = list(
-            itertools.chain(
-                *zip(
-                    itertools.islice(
-                        CheckBoxConfig.Meta.filename_list, 0, None, 2),
-                    itertools.islice(
-                        CheckBoxConfig.Meta.filename_list, 1, None, 2),
-                    ('/etc/xdg/{}'.format(launcher.config_filename),
-                        os.path.expanduser(
-                            '~/.config/{}'.format(launcher.config_filename)))))
-            )
-        self.config.read(self.config.Meta.filename_list)
-        ns.dry_run = False
-        ns.dont_suppress_output = launcher.dont_suppress_output
-        return CliInvocation2(
-            self.provider_loader, lambda: self.config, ns, launcher
-        ).run()
-
-    def register_parser(self, subparsers):
-        parser = self.add_subcommand(subparsers)
-        self.register_arguments(parser)
-
-    def register_arguments(self, parser):
-        parser.add_argument(
-            '--no-color', dest='color', action='store_false', help=SUPPRESS)
-        parser.set_defaults(color=None)
-        parser.add_argument(
-            "launcher", metavar=_("LAUNCHER"),
-            help=_("launcher definition file to use"))
-        parser.set_defaults(command=self)
-        parser.conflict_handler = 'resolve'
-        # Call enhance_parser from CheckBoxCommandMixIn
-        self.enhance_parser(parser)
-        group = parser.add_argument_group(title=_("user interface options"))
-        group.add_argument(
-            '--non-interactive', action='store_true',
-            help=_("skip tests that require interactivity"))
-        # Call register_optional_arguments from SubmitCommand
-        self.register_optional_arguments(parser)
diff --git a/checkbox_ng/commands/newcli.py b/checkbox_ng/commands/newcli.py
deleted file mode 100644
index 8d359c0..0000000
--- a/checkbox_ng/commands/newcli.py
+++ /dev/null
@@ -1,491 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013-2014 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.commands.cli` -- Command line sub-command
-===========================================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-
-from gettext import gettext as _
-from logging import getLogger
-from shutil import copyfileobj
-import io
-import operator
-import os
-import re
-import subprocess
-import sys
-
-from plainbox.abc import IJobResult
-from plainbox.impl.commands.inv_run import RunInvocation
-from plainbox.impl.exporter import ByteStringStreamTranslator
-from plainbox.impl.secure.config import Unset, ValidationError
-from plainbox.impl.secure.origin import CommandLineTextSource
-from plainbox.impl.secure.origin import Origin
-from plainbox.impl.secure.qualifiers import FieldQualifier
-from plainbox.impl.secure.qualifiers import OperatorMatcher
-from plainbox.impl.secure.qualifiers import RegExpJobQualifier
-from plainbox.impl.secure.qualifiers import select_jobs
-from plainbox.impl.session import SessionMetaData
-from plainbox.impl.session.jobs import InhibitionCause
-from plainbox.impl.transport import TransportError
-from plainbox.impl.transport import get_all_transports
-from plainbox.vendor.textland import get_display
-
-from checkbox_ng.misc import SelectableJobTreeNode
-from checkbox_ng.ui import ScrollableTreeNode
-from checkbox_ng.ui import ShowMenu
-from checkbox_ng.ui import ShowRerun
-from checkbox_ng.ui import ShowWelcome
-
-
-logger = getLogger("checkbox.ng.commands.newcli")
-
-
-class CliInvocation2(RunInvocation):
-    """
-    Invocation of the 'checkbox cli' command.
-
-    :ivar ns:
-        The argparse namespace obtained from CliCommand
-    :ivar _launcher:
-        launcher specific to 'checkbox cli'
-    :ivar _display:
-        A textland display object
-    :ivar _qualifier_list:
-        A list of job qualifiers used to build the session desired_job_list
-    """
-
-    def __init__(self, provider_loader, config_loader, ns, launcher,
-                 display=None):
-        super().__init__(provider_loader, config_loader, ns, ns.color)
-        if display is None:
-            display = get_display()
-        self._launcher = launcher
-        self._display = display
-        self._qualifier_list = []
-        self._testplan_list = []
-        self.select_qualifier_list()
-        # MAAS-deployed server images need "tput reset" to keep ugliness
-        # from happening....
-        subprocess.check_call(['tput', 'reset'])
-
-    @property
-    def launcher(self):
-        """
-        TBD: 'checkbox cli' specific launcher settings
-        """
-        return self._launcher
-
-    @property
-    def display(self):
-        """
-        A TextLand display object
-        """
-        return self._display
-
-    def select_qualifier_list(self):
-        # Add whitelists
-        if 'whitelist' in self.ns and self.ns.whitelist:
-            for whitelist_file in self.ns.whitelist:
-                qualifier = self.get_whitelist_from_file(
-                    whitelist_file.name, whitelist_file)
-                if qualifier is not None:
-                    self._qualifier_list.append(qualifier)
-        # Add all the --include jobs
-        for pattern in self.ns.include_pattern_list:
-            origin = Origin(CommandLineTextSource('-i', pattern), None, None)
-            try:
-                qualifier = RegExpJobQualifier(
-                    '^{}$'.format(pattern), origin, inclusive=True)
-            except Exception as exc:
-                logger.warning(
-                    _("Incorrect pattern %r: %s"), pattern, exc)
-            else:
-                self._qualifier_list.append(qualifier)
-        # Add all the --exclude jobs
-        for pattern in self.ns.exclude_pattern_list:
-            origin = Origin(CommandLineTextSource('-x', pattern), None, None)
-            try:
-                qualifier = RegExpJobQualifier(
-                    '^{}$'.format(pattern), origin, inclusive=False)
-            except Exception as exc:
-                logger.warning(
-                    _("Incorrect pattern %r: %s"), pattern, exc)
-            else:
-                self._qualifier_list.append(qualifier)
-        if self.config.whitelist is not Unset:
-            self._qualifier_list.append(
-                self.get_whitelist_from_file(self.config.whitelist))
-
-    def select_testplan(self):
-        # Add the test plan
-        if self.ns.test_plan is not None:
-            for provider in self.provider_list:
-                for unit in provider.id_map[self.ns.test_plan]:
-                    if unit.Meta.name == 'test plan':
-                        self._qualifier_list.append(unit.get_qualifier())
-                        self._testplan_list.append(unit)
-                        return
-            else:
-                logger.error(_("There is no test plan: %s"), self.ns.test_plan)
-
-    def run(self):
-        return self.do_normal_sequence()
-
-    def do_normal_sequence(self):
-        """
-        Proceed through normal set of steps that are required to runs jobs
-
-        .. note::
-            This version is overridden as there is no better way to manage this
-            pile rather than having a copy-paste + edits piece of text until
-            arrowhead replaced plainbox run internals with a flow chart that
-            can be derived meaningfully.
-
-            For now just look for changes as compared to run.py's version.
-        """
-        # Create transport early so that we can handle bugs before starting the
-        # session.
-        self.create_transport()
-        if self.is_interactive:
-            resumed = self.maybe_resume_session()
-        else:
-            self.create_manager(None)
-            resumed = False
-        # XXX: we don't want to know about new jobs just yet
-        self.state.on_job_added.disconnect(self.on_job_added)
-        # Create the job runner so that we can do stuff
-        self.create_runner()
-        # If we haven't resumed then do some one-time initialization
-        if not resumed:
-            # Show the welcome message
-            self.show_welcome_screen()
-            # Process testplan command line options
-            self.select_testplan()
-            # Maybe allow the user to do a manual whitelist selection
-            if not self._qualifier_list:
-                self.maybe_interactively_select_testplans()
-            if self._testplan_list:
-                self.manager.test_plans = tuple(self._testplan_list)
-            # Store the application-identifying meta-data and checkpoint the
-            # session.
-            self.store_application_metadata()
-            self.metadata.flags.add(SessionMetaData.FLAG_INCOMPLETE)
-            self.manager.checkpoint()
-            # Run all the local jobs. We need to do this to see all the things
-            # the user may select
-            if self.is_interactive:
-                self.select_local_jobs()
-                self.run_all_selected_jobs()
-            self.interactively_pick_jobs_to_run()
-        # Maybe ask the secure launcher to prompt for the password now. This is
-        # imperfect as we are going to run local jobs and we cannot see if they
-        # might need root or not. This cannot be fixed before template jobs are
-        # added and local jobs deprecated and removed (at least not being a
-        # part of the session we want to execute).
-        self.maybe_warm_up_authentication()
-        self.print_estimated_duration()
-        self.run_all_selected_jobs()
-        if self.is_interactive:
-            while True:
-                if self.maybe_rerun_jobs():
-                    continue
-                else:
-                    break
-        self.export_and_send_results()
-        if SessionMetaData.FLAG_INCOMPLETE in self.metadata.flags:
-            print(self.C.header("Session Complete!", "GREEN"))
-            self.metadata.flags.remove(SessionMetaData.FLAG_INCOMPLETE)
-            self.manager.checkpoint()
-        return 0
-
-    def store_application_metadata(self):
-        super().store_application_metadata()
-        self.metadata.app_blob = b''
-
-    def show_welcome_screen(self):
-        text = self.launcher.text
-        if self.is_interactive and text:
-            self.display.run(ShowWelcome(text))
-
-    def maybe_interactively_select_testplans(self):
-        if self.launcher.skip_whitelist_selection:
-            self._qualifier_list.extend(self.get_default_testplans())
-        elif self.is_interactive:
-            self._qualifier_list.extend(
-                self.get_interactively_picked_testplans())
-        elif self.launcher.whitelist_selection:
-            self._qualifier_list.extend(self.get_default_testplans())
-        logger.info(_("Selected testplans: %r"), self._qualifier_list)
-
-    def get_interactively_picked_testplans(self):
-        """
-        Show an interactive dialog that allows the user to pick a list of
-        testplans. The set of testplans is limited to those offered by the
-        'default_providers' setting.
-
-        :returns:
-            A list of selected testplans
-        """
-        testplans = []
-        testplan_selection = []
-        for provider in self.provider_list:
-            testplans.extend(
-                [unit for unit in provider.unit_list if
-                 unit.Meta.name == 'test plan' and
-                 re.search(self.launcher.whitelist_filter, unit.partial_id)])
-        testplan_name_list = [testplan.tr_name() for testplan in testplans]
-        testplan_selection = [
-            testplans.index(t) for t in testplans if
-            re.search(self.launcher.whitelist_selection, t.partial_id)]
-        selected_list = self.display.run(
-            ShowMenu(_("Suite selection"), testplan_name_list,
-                     testplan_selection))
-        if not selected_list:
-            raise SystemExit(_("No testplan selected, aborting"))
-        self._testplan_list.extend(
-            [testplans[selected_index] for selected_index in selected_list])
-        return [testplans[selected_index].get_qualifier() for selected_index
-                in selected_list]
-
-    def get_default_testplans(self):
-        testplans = []
-        for provider in self.provider_list:
-            testplans.extend([
-                unit.get_qualifier() for unit in provider.unit_list if
-                unit.Meta.name == 'test plan' and re.search(
-                    self.launcher.whitelist_selection, unit.partial_id)])
-        return testplans
-
-    def create_transport(self):
-        """
-        Create the ISessionStateTransport based on the command line options
-
-        This sets the :ivar:`_transport`.
-        """
-        # TODO:
-        self._transport = None
-
-    @property
-    def expected_app_id(self):
-        return 'checkbox'
-
-    def select_local_jobs(self):
-        print(self.C.header(_("Selecting Job Generators")))
-        # Create a qualifier list that will pick all local jobs out of the
-        # subset of jobs also enumerated by the whitelists we've already
-        # picked.
-        #
-        # Since each whitelist is a qualifier that selects jobs enumerated
-        # within, we only need to and an exclusive qualifier that deselects
-        # non-local jobs and we're done.
-        qualifier_list = []
-        qualifier_list.extend(self._qualifier_list)
-        origin = Origin.get_caller_origin()
-        qualifier_list.append(FieldQualifier(
-            'plugin', OperatorMatcher(operator.ne, 'local'), origin,
-            inclusive=False))
-        local_job_list = select_jobs(
-            self.manager.state.job_list, qualifier_list)
-        self._update_desired_job_list(local_job_list)
-
-    def interactively_pick_jobs_to_run(self):
-        print(self.C.header(_("Selecting Jobs For Execution")))
-        self._update_desired_job_list(select_jobs(
-            self.manager.state.job_list, self._qualifier_list))
-        if self.launcher.skip_test_selection or not self.is_interactive:
-            return
-        tree = SelectableJobTreeNode.create_tree(
-            self.manager.state, self.manager.state.run_list)
-        title = _('Choose tests to run on your system:')
-        self.display.run(ScrollableTreeNode(tree, title))
-        # NOTE: tree.selection is correct but ordered badly.  To retain
-        # the original ordering we should just treat it as a mask and
-        # use it to filter jobs from desired_job_list.
-        wanted_set = frozenset(tree.selection + tree.resource_jobs)
-        job_list = [job for job in self.manager.state.run_list
-                    if job in wanted_set]
-        self._update_desired_job_list(job_list)
-
-    def export_and_send_results(self):
-        if self.is_interactive:
-            print(self.C.header(_("Results")))
-            exporter = self.manager.create_exporter(
-                '2013.com.canonical.plainbox::text')
-            exported_stream = io.BytesIO()
-            exporter.dump_from_session_manager(self.manager, exported_stream)
-            exported_stream.seek(0)  # Need to rewind the file, puagh
-            # This requires a bit more finesse, as exporters output bytes
-            # and stdout needs a string.
-            translating_stream = ByteStringStreamTranslator(
-                sys.stdout, "utf-8")
-            copyfileobj(exported_stream, translating_stream)
-        # FIXME: this should probably not go to plainbox but checkbox-ng
-        base_dir = os.path.join(
-            os.getenv(
-                'XDG_DATA_HOME', os.path.expanduser("~/.local/share/")),
-            "plainbox")
-        if not os.path.exists(base_dir):
-            os.makedirs(base_dir)
-        exp_options = ['with-sys-info', 'with-summary', 'with-job-description',
-                       'with-text-attachments', 'with-certification-status',
-                       'with-job-defs', 'with-io-log', 'with-comments']
-        print()
-        if self.launcher.exporter is not Unset:
-            exporters = self.launcher.exporter
-        else:
-            exporters = [
-                '2013.com.canonical.plainbox::hexr',
-                '2013.com.canonical.plainbox::html',
-                '2013.com.canonical.plainbox::xlsx',
-                '2013.com.canonical.plainbox::json',
-            ]
-        for unit_name in exporters:
-            exporter = self.manager.create_exporter(
-                unit_name, exp_options, strict=False)
-            extension = exporter.unit.file_extension
-            results_path = os.path.join(
-                base_dir, 'submission.{}'.format(extension))
-            with open(results_path, "wb") as stream:
-                exporter.dump_from_session_manager(self.manager, stream)
-            print(_("View results") + " ({}): file://{}".format(
-                extension, results_path))
-        self.submission_file = os.path.join(base_dir, 'submission.xml')
-        if self.launcher.submit_to is not Unset:
-            if self.launcher.submit_to == 'certification':
-                # If we supplied a submit_url in the launcher, it
-                # should override the one in the config.
-                if self.launcher.submit_url:
-                    self.config.c3_url = self.launcher.submit_url
-                # Same behavior for submit_to_hexr (a boolean flag which
-                # should result in adding "submit_to_hexr=1" to transport
-                # options later on)
-                if self.launcher.submit_to_hexr:
-                    self.config.submit_to_hexr = True
-                # for secure_id, config (which is user-writable) should
-                # override launcher (which is not)
-                if not self.config.secure_id:
-                    self.config.secure_id = self.launcher.secure_id
-                # Override the secure_id configuration with the one provided
-                # by the command-line option
-                if self.ns.secure_id:
-                    self.config.secure_id = self.ns.secure_id
-                if self.config.secure_id is Unset:
-                    again = True
-                    if not self.is_interactive:
-                        again = False
-                    while again:
-                        # TRANSLATORS: Do not translate the {} format marker.
-                        if self.ask_for_confirmation(
-                            _("\nSubmit results to {0}?".format(
-                                self.launcher.submit_url))):
-                            try:
-                                self.config.secure_id = input(_("Secure ID: "))
-                            except ValidationError:
-                                print(
-                                    _("ERROR: Secure ID must be 15-character "
-                                      "(or more) alphanumeric string"))
-                            else:
-                                again = False
-                                self.submit_certification_results()
-                        else:
-                            again = False
-                else:
-                    # Automatically try to submit results if the secure_id is
-                    # valid
-                    self.submit_certification_results()
-
-    def submit_certification_results(self):
-        from checkbox_ng.certification import InvalidSecureIDError
-        transport_cls = get_all_transports().get('certification')
-        # TRANSLATORS: Do not translate the {} format markers.
-        print(_("Submitting results to {0} for secure_id {1}").format(
-            self.config.c3_url, self.config.secure_id))
-        option_chunks = []
-        option_chunks.append("secure_id={0}".format(self.config.secure_id))
-        if self.config.submit_to_hexr:
-            option_chunks.append("submit_to_hexr=1")
-        # Assemble the option string
-        options_string = ",".join(option_chunks)
-        # Create the transport object
-        try:
-            transport = transport_cls(
-                self.config.c3_url, options_string)
-        except InvalidSecureIDError as exc:
-            print(exc)
-            return False
-        with open(self.submission_file, "r", encoding='utf-8') as stream:
-            try:
-                # Send the data, reading from the fallback file
-                result = transport.send(stream, self.config)
-                if 'url' in result:
-                    # TRANSLATORS: Do not translate the {} format marker.
-                    print(_("Successfully sent, submission status"
-                            " at {0}").format(result['url']))
-                else:
-                    # TRANSLATORS: Do not translate the {} format marker.
-                    print(_("Successfully sent, server response"
-                            ": {0}").format(result))
-            except TransportError as exc:
-                print(str(exc))
-
-    def maybe_rerun_jobs(self):
-        # create a list of jobs that qualify for rerunning
-        rerun_candidates = []
-        for job in self.manager.state.run_list:
-            job_state = self.manager.state.job_state_map[job.id]
-            if job_state.result.outcome in (
-                IJobResult.OUTCOME_FAIL, IJobResult.OUTCOME_CRASH,
-                    IJobResult.OUTCOME_NOT_SUPPORTED):
-                rerun_candidates.append(job)
-
-        # bail-out early if no job qualifies for rerunning
-        if not rerun_candidates:
-            return False
-        tree = SelectableJobTreeNode.create_tree(
-            self.manager.state, rerun_candidates)
-        # nothing to select in root node and categories - bailing out
-        if not tree.jobs and not tree._categories:
-            return False
-        # deselect all by default
-        tree.set_descendants_state(False)
-        self.display.run(ShowRerun(tree, _("Select jobs to re-run")))
-        wanted_set = frozenset(tree.selection)
-        if not wanted_set:
-            # nothing selected - nothing to run
-            return False
-        # include resource jobs that selected jobs depend on
-        resources_to_rerun = []
-        for job in wanted_set:
-            job_state = self.manager.state.job_state_map[job.id]
-            for inhibitor in job_state.readiness_inhibitor_list:
-                if inhibitor.cause == InhibitionCause.FAILED_DEP:
-                    resources_to_rerun.append(inhibitor.related_job)
-        # reset outcome of jobs that are selected for re-running
-        for job in list(wanted_set) + resources_to_rerun:
-            from plainbox.impl.result import MemoryJobResult
-            self.manager.state.job_state_map[job.id].result = \
-                MemoryJobResult({})
-        self.run_all_selected_jobs()
-        return True
diff --git a/checkbox_ng/commands/sru.py b/checkbox_ng/commands/sru.py
deleted file mode 100644
index 7db7b71..0000000
--- a/checkbox_ng/commands/sru.py
+++ /dev/null
@@ -1,174 +0,0 @@
-# This file is part of Checkbox.
-#
-#
-# Copyright 2013 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.commands.sru` -- sru sub-command
-==================================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-import sys
-
-from gettext import gettext as _
-from plainbox.impl.commands import PlainBoxCommand
-from plainbox.impl.commands.inv_check_config import CheckConfigInvocation
-from plainbox.impl.ingredients import CanonicalCommand
-from plainbox.impl.secure.config import ValidationError, Unset
-
-
-class sru(CanonicalCommand):
-
-    """
-    Run stable release update (sru) tests.
-
-    Stable release updates are periodic fixes for nominated bugs that land in
-    existing supported Ubuntu releases. To ensure a certain level of quality
-    all SRU updates affecting hardware enablement are automatically tested
-    on a pool of certified machines.
-    """
-
-    def __init__(self, config):
-        """Init method to store the config settings."""
-        self.config = config
-        if not self.config.test_plan:
-            self.config.test_plan = "2013.com.canonical.certification::sru"
-
-    def register_arguments(self, parser):
-        """Method called to register command line arguments."""
-        parser.add_argument(
-            '--secure_id', metavar=_("SECURE-ID"),
-            # NOTE: --secure-id is optional only when set in a config file
-            required=self.config.secure_id is Unset,
-            help=_("Canonical hardware identifier"))
-        parser.add_argument(
-            '-T', '--test-plan',
-            action="store",
-            metavar=_("TEST-PLAN-ID"),
-            default=None,
-            # TRANSLATORS: this is in imperative form
-            help=_("load the specified test plan"))
-        parser.add_argument(
-            '--staging', action='store_true', default=False,
-            help=_("Send the data to non-production test server"))
-        parser.add_argument(
-            "--check-config",
-            action="store_true",
-            help=_("run check-config before starting"))
-
-    def invoked(self, ctx):
-        """Method called when the command is invoked."""
-        # Copy command-line arguments over configuration variables
-        try:
-            if ctx.args.secure_id:
-                self.config.secure_id = ctx.args.secure_id
-            if ctx.args.test_plan:
-                self.config.test_plan = ctx.args.test_plan
-            if ctx.args.staging:
-                self.config.staging = ctx.args.staging
-        except ValidationError as exc:
-            print(_("Configuration problems prevent running SRU tests"))
-            print(exc)
-            return 1
-        ctx.sa.use_alternate_configuration(self.config)
-        # Run check-config, if requested
-        if ctx.args.check_config:
-            retval = CheckConfigInvocation(lambda: self.config).run()
-            if retval != 0:
-                return retval
-        self.transport = self._create_transport(
-            ctx.sa, self.config.secure_id, self.config.staging)
-        self.ctx = ctx
-        try:
-            self._collect_info(ctx.rc, ctx.sa)
-            self._save_results(ctx.rc, ctx.sa)
-            self._send_results(
-                ctx.rc, ctx.sa, self.config.secure_id, self.config.staging)
-        except KeyboardInterrupt:
-            return 1
-
-    def _save_results(self, rc, sa):
-        rc.reset()
-        rc.padding = (1, 1, 0, 1)
-        path = sa.export_to_file(
-            "2013.com.canonical.plainbox::hexr", (), '/tmp')
-        rc.para(_("Results saved to {0}").format(path))
-
-    def _send_results(self, rc, sa, secure_id, staging):
-        rc.reset()
-        rc.padding = (1, 1, 0, 1)
-        rc.para(_("Sending hardware report to Canonical Certification"))
-        rc.para(_("Server URL is: {0}").format(self.transport.url))
-        result = sa.export_to_transport(
-            "2013.com.canonical.plainbox::hexr", self.transport)
-        if 'url' in result:
-            rc.para(result['url'])
-
-    def _create_transport(self, sa, secure_id, staging):
-        return sa.get_canonical_certification_transport(
-            secure_id, staging=staging)
-
-    def _collect_info(self, rc, sa):
-        sa.select_providers('*')
-        sa.start_new_session(_("SRU Session"))
-        sa.select_test_plan(self.config.test_plan)
-        sa.bootstrap()
-        for job_id in sa.get_static_todo_list():
-            job = sa.get_job(job_id)
-            builder = sa.run_job(job_id, 'silent', False)
-            result = builder.get_result()
-            sa.use_job_result(job_id, result)
-            rc.para("- {0}: {1}".format(job.id, result))
-            if result.comments:
-                rc.padding = (0, 0, 0, 2)
-                rc.para("{0}".format(result.comments))
-                rc.reset()
-
-
-class SRUCommand(PlainBoxCommand):
-
-    """
-    Command for running Stable Release Update (SRU) tests.
-
-    Stable release updates are periodic fixes for nominated bugs that land in
-    existing supported Ubuntu releases. To ensure a certain level of quality
-    all SRU updates affecting hardware enablement are automatically tested
-    on a pool of certified machines.
-    """
-
-    gettext_domain = "checkbox-ng"
-
-    def __init__(self, provider_loader, config_loader):
-        self.provider_loader = provider_loader
-        # This command does funky things to the command line parser and it
-        # needs to load the config subsystem *early* so let's just load it now.
-        self.config = config_loader()
-
-    def invoked(self, ns):
-        """Method called when the command is invoked."""
-        return sru(self.config).main(sys.argv[2:], exit=False)
-
-    def register_parser(self, subparsers):
-        """Method called to register command line arguments."""
-        parser = subparsers.add_parser(
-            "sru", help=_("run automated stable release update tests"))
-        parser.set_defaults(command=self)
-        sru(self.config).register_arguments(parser)
diff --git a/checkbox_ng/commands/submit.py b/checkbox_ng/commands/submit.py
deleted file mode 100644
index 6d24a8a..0000000
--- a/checkbox_ng/commands/submit.py
+++ /dev/null
@@ -1,154 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2014 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.commands.submit` -- the submit sub-command
-============================================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-
-from argparse import ArgumentTypeError
-from plainbox.i18n import docstring
-from plainbox.i18n import gettext as _
-from plainbox.i18n import gettext_noop as N_
-import re
-
-from plainbox.impl.commands import PlainBoxCommand
-from plainbox.impl.secure.config import Unset
-from plainbox.impl.transport import TransportError
-from plainbox.impl.transport import SECURE_ID_PATTERN
-
-from checkbox_ng.certification import CertificationTransport
-
-
-class SubmitInvocation:
-    """
-    Helper class instantiated to perform a particular invocation of the submit
-    command. Unlike the SRU command itself, this class is instantiated each
-    time.
-    """
-
-    def __init__(self, ns):
-        self.ns = ns
-
-    def run(self):
-        options_string = "secure_id={0}".format(self.ns.secure_id)
-        transport = CertificationTransport(self.ns.url, options_string)
-
-        try:
-            with open(self.ns.submission, "r", encoding='utf-8') as subm_file:
-                result = transport.send(subm_file)
-        except (TransportError, OSError) as exc:
-            raise SystemExit(exc)
-        else:
-            if 'url' in result:
-                # TRANSLATORS: Do not translate the {} format marker.
-                print(_("Successfully sent, submission status"
-                        " at {0}").format(result['url']))
-            else:
-                # TRANSLATORS: Do not translate the {} format marker.
-                print(_("Successfully sent, server response"
-                        ": {0}").format(result))
-
-
-@docstring(
-    # TRANSLATORS: please leave various options (both long and short forms),
-    # environment variables and paths in their original form. Also keep the
-    # special @EPILOG@ string. The first line of the translation is special and
-    # is used as the help message. Please keep the pseudo-statement form and
-    # don't finish the sentence with a dot. Pay extra attention to whitespace.
-    # It must be correctly preserved or the result won't work. In particular
-    # the leading whitespace *must* be preserved and *must* have the same
-    # length on each line.
-    N_("""
-    submit test results to the Canonical certification website
-
-    This command sends the XML results file to the Certification website.
-    """))
-class SubmitCommand(PlainBoxCommand):
-
-    gettext_domain = "checkbox-ng"
-
-    def __init__(self, config_loader):
-        self.config = config_loader()
-
-    def invoked(self, ns):
-        return SubmitInvocation(ns).run()
-
-    def register_parser(self, subparsers):
-        parser = subparsers.add_parser("submit", help=_(
-            "submit test results to the Canonical certification website"))
-        self.register_arguments(parser)
-
-    def register_arguments(self, parser):
-        parser.set_defaults(command=self)
-        parser.add_argument(
-            'submission', help=_("The path to the results xml file"))
-        self.register_optional_arguments(parser, required=True)
-
-    def register_optional_arguments(self, parser, required=False):
-        if self.config.secure_id is not Unset:
-            parser.set_defaults(secure_id=self.config.secure_id)
-
-        def secureid(secure_id):
-            if not re.match(SECURE_ID_PATTERN, secure_id):
-                raise ArgumentTypeError(
-                    _("must be 15-character (or more) alphanumeric string"))
-            return secure_id
-
-        required_check = False
-        if required:
-            required_check = self.config.secure_id is Unset
-        parser.add_argument(
-            '--secure_id', metavar=_("SECURE-ID"),
-            required=required_check,
-            type=secureid,
-            help=_("associate submission with a machine using this SECURE-ID"))
-
-        # Interpret this setting here
-        # Please remember the Unset.__bool__() return False
-        # After Interpret the setting,
-        # self.config.submit_to_c3 should has value or be Unset.
-        try:
-            if (self.config.submit_to_c3 and
-                (self.config.submit_to_c3.lower() in ('yes', 'true') or
-                    int(self.config.submit_to_c3) == 1)):
-                # self.config.c3_url has a default value written in config.py
-                parser.set_defaults(url=self.config.c3_url)
-            else:
-                # if submit_to_c3 is castable to int but not 1
-                # this is still set as Unset
-                # otherwise url requirement will be None
-                self.config.submit_to_c3 = Unset
-        except ValueError:
-            # When submit_to_c3 is something other than 'yes', 'true',
-            # castable to integer, it raises ValueError.
-            # e.g. 'no', 'false', 'asdf' ...etc.
-            # In this case, it is still set as Unset.
-            self.config.submit_to_c3 = Unset
-
-        required_check = False
-        if required:
-            required_check = self.config.submit_to_c3 is Unset
-        parser.add_argument(
-            '--url', metavar=_("URL"),
-            required=required_check,
-            help=_("destination to submit to"))
diff --git a/checkbox_ng/commands/test_sru.py b/checkbox_ng/commands/test_sru.py
deleted file mode 100644
index 8d456ee..0000000
--- a/checkbox_ng/commands/test_sru.py
+++ /dev/null
@@ -1,56 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-plainbox.impl.commands.test_sru
-===============================
-
-Test definitions for plainbox.impl.box module
-"""
-
-from inspect import cleandoc
-from unittest import TestCase
-
-from plainbox.testing_utils.io import TestIO
-
-from checkbox_ng.main import main
-
-
-class TestSru(TestCase):
-
-    def test_help(self):
-        with TestIO(combined=True) as io:
-            with self.assertRaises(SystemExit) as call:
-                main(['sru', '--help'])
-            self.assertEqual(call.exception.args, (0,))
-        self.maxDiff = None
-        expected = """
-        usage: checkbox sru [-h] --secure_id SECURE-ID [-T TEST-PLAN-ID] [--staging]
-                            [--check-config]
-
-        optional arguments:
-          -h, --help            show this help message and exit
-          --secure_id SECURE-ID
-                                Canonical hardware identifier
-          -T TEST-PLAN-ID, --test-plan TEST-PLAN-ID
-                                load the specified test plan
-          --staging             Send the data to non-production test server
-          --check-config        run check-config before starting
-        """
-        self.assertEqual(io.combined, cleandoc(expected) + "\n")
diff --git a/checkbox_ng/config.py b/checkbox_ng/config.py
index 7107dc0..c84f2b8 100644
--- a/checkbox_ng/config.py
+++ b/checkbox_ng/config.py
@@ -22,13 +22,10 @@
 =====================================================
 """
 
-from gettext import gettext as _
 import itertools
 import os
 
 from plainbox.impl.applogic import PlainBoxConfig
-from plainbox.impl.secure import config
-from plainbox.impl.transport import SECURE_ID_PATTERN
 
 
 class CheckBoxConfig(PlainBoxConfig):
@@ -36,44 +33,6 @@ class CheckBoxConfig(PlainBoxConfig):
     Configuration for checkbox-ng
     """
 
-    secure_id = config.Variable(
-        section="sru",
-        help_text=_("Secure ID of the system"),
-        validator_list=[config.PatternValidator(SECURE_ID_PATTERN)])
-
-    submit_to_c3 = config.Variable(
-        section="submission",
-        help_text=_("Whether to send the submission data to c3"))
-
-    submit_to_hexr = config.Variable(
-        section="submission",
-        help_text=_("Whether to also send the submission data to HEXR"),
-        kind=bool)
-
-    # TODO: Add a validator to check if URL looks fine
-    c3_url = config.Variable(
-        section="sru",
-        help_text=_("URL of the certification website"),
-        default="https://certification.canonical.com/submissions/submit/")
-
-    fallback_file = config.Variable(
-        section="sru",
-        help_text=_("Location of the fallback file"))
-
-    whitelist = config.Variable(
-        section="sru",
-        help_text=_("Optional whitelist with which to run SRU testing"))
-
-    test_plan = config.Variable(
-        section="sru",
-        help_text=_("Optional test plan with which to run SRU testing"))
-
-    staging = config.Variable(
-        section="sru",
-        kind=bool,
-        default=False,
-        help_text=_("Send the data to non-production test server"))
-
     class Meta(PlainBoxConfig.Meta):
         # TODO: properly depend on xdg and use real code that also handles
         # XDG_CONFIG_HOME.
diff --git a/checkbox_ng/launcher/checkbox_cli.py b/checkbox_ng/launcher/checkbox_cli.py
index 1317ed2..7c368c7 100644
--- a/checkbox_ng/launcher/checkbox_cli.py
+++ b/checkbox_ng/launcher/checkbox_cli.py
@@ -38,16 +38,15 @@ from plainbox.impl.ingredients import RenderingContextIngredient
 from plainbox.impl.ingredients import SessionAssistantIngredient
 from plainbox.impl.launcher import DefaultLauncherDefinition
 from plainbox.impl.launcher import LauncherDefinition
-from plainbox.vendor.textland import get_display
 
 from checkbox_ng.launcher.subcommands import (
-    Launcher, List, Run, StartProvider, ListBootstrapped
+    CheckConfig, Launcher, List, Run, StartProvider, Submit, ListBootstrapped
 )
 
 
 _ = gettext.gettext
 
-_logger = logging.getLogger("checkbox-launcher")
+_logger = logging.getLogger("checkbox-cli")
 
 
 class DisplayIngredient(Ingredient):
@@ -125,7 +124,6 @@ class CheckboxCommandRecipe(CommandRecipe):
             LauncherIngredient(),
             SessionAssistantIngredient(),
             RenderingContextIngredient(),
-            DisplayIngredient(),
         ]
 
 
@@ -141,10 +139,12 @@ class CheckboxCommand(CanonicalCommand):
     bug_report_url = "https://bugs.launchpad.net/checkbox-ng/+filebug"
 
     sub_commands = (
+        ('check-config', CheckConfig),
         ('launcher', Launcher),
         ('list', List),
         ('run', Run),
         ('startprovider', StartProvider),
+        ('submit', Submit),
         ('list-bootstrapped', ListBootstrapped),
     )
 
@@ -179,6 +179,7 @@ def main():
     # $ checkbox-cli launcher my-launcher ->  same as ^
     # to achieve that the following code 'injects launcher subcommand to argv
     known_cmds = [x[0] for x in CheckboxCommand.sub_commands]
+    known_cmds += ['-h', '--help']
     if not (set(known_cmds) & set(sys.argv[1:])):
         sys.argv.insert(1, 'launcher')
     CheckboxCommand().main()
diff --git a/checkbox_ng/launcher/subcommands.py b/checkbox_ng/launcher/subcommands.py
index 7f52cda..155824a 100644
--- a/checkbox_ng/launcher/subcommands.py
+++ b/checkbox_ng/launcher/subcommands.py
@@ -37,6 +37,7 @@ from guacamole import Command
 from plainbox.abc import IJobResult
 from plainbox.i18n import ngettext
 from plainbox.impl.color import Colorizer
+from plainbox.impl.commands.inv_check_config import CheckConfigInvocation
 from plainbox.impl.commands.inv_run import Action
 from plainbox.impl.commands.inv_run import NormalUI
 from plainbox.impl.commands.inv_startprovider import (
@@ -55,8 +56,10 @@ from plainbox.impl.session.restart import get_strategy_by_name
 from plainbox.impl.transport import TransportError
 from plainbox.impl.transport import InvalidSecureIDError
 from plainbox.impl.transport import get_all_transports
+from plainbox.impl.transport import SECURE_ID_PATTERN
 from plainbox.public import get_providers
 
+from checkbox_ng.config import CheckBoxConfig
 from checkbox_ng.launcher.stages import MainLoopStage
 from checkbox_ng.urwid_ui import CategoryBrowser
 from checkbox_ng.urwid_ui import ReRunBrowser
@@ -67,6 +70,73 @@ _ = gettext.gettext
 _logger = logging.getLogger("checkbox-ng.launcher.subcommands")
 
 
+class CheckConfig(Command):
+    def invoked(self, ctx):
+        return CheckConfigInvocation(lambda: CheckBoxConfig.get()).run()
+
+
+class Submit(Command):
+    def register_arguments(self, parser):
+        def secureid(secure_id):
+            if not re.match(SECURE_ID_PATTERN, secure_id):
+                raise ArgumentTypeError(
+                    _("must be 15-character (or more) alphanumeric string"))
+            return secure_id
+        parser.add_argument(
+            'secure_id', metavar=_("SECURE-ID"),
+            type=secureid,
+            help=_("associate submission with a machine using this SECURE-ID"))
+        parser.add_argument(
+            "submission", metavar=_("SUBMISSION"),
+            help=_("The path to the results file"))
+        parser.add_argument(
+            "-s", "--staging", action="store_true",
+            help=_("Use staging environment"))
+
+    def invoked(self, ctx):
+        transport_cls = None
+        enc = None
+        mode = 'rb'
+        options_string = "secure_id={0}".format(ctx.args.secure_id)
+        url = ('https://submission.canonical.com/'
+               'v1/submission/hardware/{}'.format(ctx.args.secure_id))
+        if ctx.args.staging:
+            url = ('https://submission.staging.canonical.com/'
+                   'v1/submission/hardware/{}'.format(ctx.args.secure_id))
+        if ctx.args.submission.endswith('xml'):
+            from checkbox_ng.certification import CertificationTransport
+            transport_cls = CertificationTransport
+            mode = 'r'
+            enc = 'utf-8'
+            url = ('https://certification.canonical.com/'
+                   'submissions/submit/')
+            if ctx.args.staging:
+                url = ('https://certification.staging.canonical.com/'
+                       'submissions/submit/')
+        else:
+            from checkbox_ng.certification import SubmissionServiceTransport
+            transport_cls = SubmissionServiceTransport
+        transport = transport_cls(url, options_string)
+        try:
+            with open(ctx.args.submission, mode, encoding=enc) as subm_file:
+                result = transport.send(subm_file)
+        except (TransportError, OSError) as exc:
+            raise SystemExit(exc)
+        else:
+            if result and 'url' in result:
+                # TRANSLATORS: Do not translate the {} format marker.
+                print(_("Successfully sent, submission status"
+                        " at {0}").format(result['url']))
+            elif result and 'status_url' in result:
+                # TRANSLATORS: Do not translate the {} format marker.
+                print(_("Successfully sent, submission status"
+                        " at {0}").format(result['status_url']))
+            else:
+                # TRANSLATORS: Do not translate the {} format marker.
+                print(_("Successfully sent, server response"
+                        ": {0}").format(result))
+
+
 class StartProvider(Command):
     def register_arguments(self, parser):
         parser.add_argument(
@@ -114,10 +184,6 @@ class Launcher(Command, MainLoopStage):
             print(_("Launcher seems valid."))
             return
         self.launcher = ctx.cmd_toplevel.launcher
-        if not self.launcher.launcher_version:
-            # it's a legacy launcher, use legacy way of running commands
-            from checkbox_ng.tools import CheckboxLauncherTool
-            raise SystemExit(CheckboxLauncherTool().main(sys.argv[1:]))
         logging_level = {
             'normal': logging.WARNING,
             'verbose': logging.INFO,
@@ -897,6 +963,7 @@ class List(Command):
             print(_("--format applies only to 'all-jobs' group.  Ignoring..."))
         print_objs(ctx.args.GROUP, ctx.args.attrs)
 
+
 class ListBootstrapped(Command):
     name = 'list-bootstrapped'
 
diff --git a/checkbox_ng/main.py b/checkbox_ng/main.py
deleted file mode 100644
index 178edd9..0000000
--- a/checkbox_ng/main.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012-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/>.
-
-"""
-:mod:`checkbox_ng.main` -- entry points for command line tools
-==============================================================
-"""
-
-import logging
-
-from plainbox.impl.logging import setup_logging
-
-from checkbox_ng.tools import CheckboxLauncherTool
-from checkbox_ng.tools import CheckboxSubmitTool
-from checkbox_ng.tools import CheckboxTool
-
-
-logger = logging.getLogger("checkbox.ng.main")
-
-
-def main(argv=None):
-    """
-    checkbox command line utility
-    """
-    raise SystemExit(CheckboxTool().main(argv))
-
-
-def submit(argv=None):
-    """
-    checkbox-submit command line utility
-    """
-    raise SystemExit(CheckboxSubmitTool().main(argv))
-
-
-def launcher(argv=None):
-    """
-    checkbox-launcher command line utility
-    """
-    raise SystemExit(CheckboxLauncherTool().main(argv))
-
-
-# Setup logging before anything else starts working.
-# If we do it in main() or some other place then unit tests will see
-# "leaked" log files which are really closed when the runtime shuts
-# down but not when the tests are finishing
-setup_logging()
diff --git a/checkbox_ng/misc.py b/checkbox_ng/misc.py
deleted file mode 100644
index e5547cd..0000000
--- a/checkbox_ng/misc.py
+++ /dev/null
@@ -1,476 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013-2014 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.misc` -- Other stuff
-======================================
-
-.. warning::
-
-    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
-"""
-
-from gettext import gettext as _
-from logging import getLogger
-
-from plainbox.abc import IJobResult
-
-
-logger = getLogger("checkbox.ng.commands.cli")
-
-
-class JobTreeNode:
-
-    r"""
-    JobTreeNode class is used to store a tree structure.
-
-    A tree consists of a collection of JobTreeNode instances connected in a
-    hierarchical way where nodes are used as categories, jobs belonging to a
-    category are listed in the node leaves.
-
-    Example::
-               / Job A
-         Root-|
-              |                 / Job B
-               \--- Category X |
-                                \ Job C
-    """
-
-    def __init__(self, name=None):
-        """ Initialize the job tree node with a given name. """
-        self._name = name if name else 'Root'
-        self._parent = None
-        self._categories = []
-        self._jobs = []
-
-    @property
-    def name(self):
-        """ name of this node. """
-        return self._name
-
-    @property
-    def parent(self):
-        """ parent node for this node. """
-        return self._parent
-
-    @property
-    def categories(self):
-        """ list of sub categories. """
-        return self._categories
-
-    @property
-    def jobs(self):
-        """ job(s) belonging to this node/category. """
-        return self._jobs
-
-    @property
-    def depth(self):
-        """ level of depth for this node. """
-        return (self._parent.depth + 1) if self._parent else 0
-
-    def __str__(self):
-        """ same as self.name. """
-        return self.name
-
-    def __repr__(self):
-        """ Get a representation of this node for debugging. """
-        return "<JobTreeNode name:{!r}>".format(self.name)
-
-    def add_category(self, category):
-        """
-        Add a new category to this node.
-
-        :param category:
-            The node instance to be added as a category.
-        """
-        self._categories.append(category)
-        # Always keep this list sorted to easily find a given child by index
-        self._categories.sort(key=lambda item: item.name)
-        category._parent = self
-
-    def add_job(self, job):
-        """
-        Add a new job to this node.
-
-        :param job:
-            The job instance to be added to this node.
-        """
-        self._jobs.append(job)
-        # Always keep this list sorted to easily find a given leaf by index
-        # Note bisect.insort(a, x) cannot be used here as JobDefinition are
-        # not sortable
-        self._jobs.sort(key=lambda item: item.id)
-
-    def get_ancestors(self):
-        """ Get the list of ancestors from here to the root of the tree.  """
-        ancestors = []
-        node = self
-        while node.parent is not None:
-            ancestors.append(node.parent)
-            node = node.parent
-        return ancestors
-
-    def get_descendants(self):
-        """ Return a list of all descendant category nodes.  """
-        descendants = []
-        for category in self.categories:
-            descendants.append(category)
-            descendants.extend(category.get_descendants())
-        return descendants
-
-    @classmethod
-    def create_tree(cls, session_state, job_list):
-        """
-        Build a rooted JobTreeNode from a job list.
-
-        :argument session_state:
-            A session state object
-        :argument job_list:
-            List of jobs to consider for building the tree.
-        """
-        builder = TreeBuilder(session_state, cls)
-        for job in job_list:
-            builder.auto_add_job(job)
-        return builder.root_node
-
-    @classmethod
-    def create_simple_tree(cls, sa, job_list):
-        """
-        Build a rooted JobTreeNode from a job list.
-
-        :argument sa:
-            A session assistant object
-        :argument job_list:
-            List of jobs to consider for building the tree.
-        """
-        root_node = cls()
-        for job in job_list:
-            cat_id = sa.get_job_state(job.id).effective_category_id
-            cat_name = sa.get_category(cat_id).tr_name()
-            matches = [n for n in root_node.categories if n.name == cat_name]
-            if not matches:
-                node = cls(cat_name)
-                root_node.add_category(node)
-            else:
-                node = matches[0]
-            node.add_job(job)
-        return root_node
-
-    @classmethod
-    def create_rerun_tree(cls, sa, job_list):
-        """
-        Build a rooted JobTreeNode from a job list for the re-run screen.
-        The jobs are categorized by their outcome (failed, skipped, ...)
-        instead of by the category they belong to.
-
-        :argument sa:
-            A session assistant object
-        :argument job_list:
-            List of jobs to consider for building the tree.
-        """
-        section_names = {
-            IJobResult.OUTCOME_FAIL: _("Failed Jobs"),
-            IJobResult.OUTCOME_SKIP: _("Skipped Jobs"),
-            IJobResult.OUTCOME_CRASH: _("Crashed Jobs"),
-        }
-        root_node = cls()
-        for job in job_list:
-            cat_id = sa.get_job_state(job.id).effective_category_id
-            cat_name = sa.get_category(cat_id).tr_name()
-            job_outcome = sa.get_job_state(job.id).result.outcome
-            job_section = section_names[job_outcome]
-            matches = [n for n in root_node.categories if n.name == job_section]
-            if not matches:
-                node = cls(job_section)
-                root_node.add_category(node)
-            else:
-                node = matches[0]
-
-            node.add_job(job)
-        return root_node
-
-
-class TreeBuilder:
-
-    """
-    Builder for :class:`JobTreeNode`.
-
-
-    Helper class that assists in building a tree of :class:`JobTreeNode`
-    objects out of job definitions and their associations, as expressed by
-    :attr:`JobState.via_job` associated with each job.
-
-    The builder is a single-use object and should be re-created for each new
-    construct. Internally it stores the job_state_map of the
-    :class:`SessionState` it was created with as well as additional helper
-    state.
-    """
-
-    def __init__(self, session_state: "SessionState", node_cls):
-        self._job_state_map = session_state.job_state_map
-        self._node_cls = node_cls
-        self._root_node = node_cls()
-        self._category_node_map = {}  # id -> node
-
-    @property
-    def root_node(self):
-        return self._root_node
-
-    def auto_add_job(self, job):
-        """
-        Add a job to the tree, automatically creating category nodes as needed.
-
-        :param job:
-            The job definition to add.
-        """
-        if job.plugin == 'local':
-            # For local jobs, just create the category node but don't add the
-            # local job itself there.
-            self.get_or_create_category_node(job)
-        else:
-            # For all other jobs, look at the parent job (if any) and create
-            # the category node out of that node. This never fails as "None" is
-            # the root_node object.
-            state = self._job_state_map[job.id]
-            node = self.get_or_create_category_node(state.via_job)
-            # Then add that job to the category node
-            node.add_job(job)
-
-    def get_or_create_category_node(self, category_job):
-        """
-        Get a category node for a given job.
-
-        Get or create a :class:`JobTreeNode` that corresponds to the
-        category defined (somehow) by the job ``category_job``.
-
-        :param category_job:
-            The job that describes the category. This is either a
-            plugin="local" job or a plugin="resource" job. This can also be
-            None, which is a shorthand to say "root node".
-        :returns:
-            The ``root_node`` if ``category_job`` is None. A freshly
-            created node, created with :func:`create_category_node()` if
-            the category_job was never seen before (as recorded by the
-            category_node_map).
-        """
-        logger.debug("get_or_create_category_node(%r)", category_job)
-        if category_job is None:
-            return self._root_node
-        if category_job.id not in self._category_node_map:
-            category_node = self.create_category_node(category_job)
-            # The category is added to its parent, that's either the root
-            # (if we're standalone) or the non-root category this one
-            # belongs to.
-            category_state = self._job_state_map[category_job.id]
-            if category_state.via_job is not None:
-                parent_category_node = self.get_or_create_category_node(
-                    category_state.via_job)
-            else:
-                parent_category_node = self._root_node
-            parent_category_node.add_category(category_node)
-        else:
-            category_node = self._category_node_map[category_job.id]
-        return category_node
-
-    def create_category_node(self, category_job):
-        """
-        Create a category node for a given job.
-
-        Create a :class:`JobTreeNode` that corresponds to the category defined
-        (somehow) by the job ``category_job``.
-
-        :param category_job:
-            The job that describes the node to create.
-        :returns:
-            A fresh node with appropriate data.
-        """
-        logger.debug("create_category_node(%r)", category_job)
-        if category_job.summary == category_job.partial_id:
-            category_node = self._node_cls(category_job.description)
-        else:
-            category_node = self._node_cls(category_job.summary)
-        self._category_node_map[category_job.id] = category_node
-        return category_node
-
-
-class SelectableJobTreeNode(JobTreeNode):
-    """
-    Implementation of a node in a tree that can be selected/deselected
-    """
-    def __init__(self, job=None):
-        super().__init__(job)
-        self.selected = True
-        self.job_selection = {}
-        self.expanded = True
-        self.current_index = 0
-        self._resource_jobs = []
-
-    def __len__(self):
-        l = 0
-        if self.expanded:
-            for category in self.categories:
-                l += 1 + len(category)
-            for job in self.jobs:
-                l += 1
-        return l
-
-    def get_node_by_index(self, index, tree=None):
-        """
-        Return the node found at the position given by index considering the
-        tree from a top-down list view.
-        """
-        if tree is None:
-            tree = self
-        if self.expanded:
-            for category in self.categories:
-                if index == tree.current_index:
-                    tree.current_index = 0
-                    return (category, None)
-                else:
-                    tree.current_index += 1
-                result = category.get_node_by_index(index, tree)
-                if result[0] is not None and result[1] is not None:
-                    return result
-            for job in self.jobs:
-                if index == tree.current_index:
-                    tree.current_index = 0
-                    return (job, self)
-                else:
-                    tree.current_index += 1
-        return (None, None)
-
-    def render(self, cols=80, as_summary=True):
-        """
-        Return the tree as a simple list of categories and jobs suitable for
-        display. Jobs are properly indented to respect the tree hierarchy
-        and selection marks are added automatically at the beginning of each
-        element.
-
-        The node titles should not exceed the width of a the terminal and
-        thus are cut to fit inside.
-
-        :param cols:
-            The number of columns to render.
-        :param as_summary:
-            Whether we display the job summaries or their partial IDs.
-        """
-        self._flat_list = []
-        if self.expanded:
-            for category in self.categories:
-                prefix = '[ ]'
-                if category.selected:
-                    prefix = '[X]'
-                line = ''
-                title = category.name
-                if category.jobs or category.categories:
-                    if category.expanded:
-                        line = prefix + self.depth * '   ' + ' - ' + title
-                    else:
-                        line = prefix + self.depth * '   ' + ' + ' + title
-                else:
-                    line = prefix + self.depth * '   ' + '   ' + title
-                if len(line) > cols:
-                    col_max = cols - 4  # includes len('...') + a space
-                    line = line[:col_max] + '...'
-                self._flat_list.append(line)
-                self._flat_list.extend(category.render(cols, as_summary))
-            for job in self.jobs:
-                prefix = '[ ]'
-                if self.job_selection[job]:
-                    prefix = '[X]'
-                if as_summary:
-                    title = job.tr_summary()
-                else:
-                    title = job.partial_id
-                line = prefix + self.depth * '   ' + '   ' + title
-                if len(line) > cols:
-                    col_max = cols - 4  # includes len('...') + a space
-                    line = line[:col_max] + '...'
-                self._flat_list.append(line)
-        return self._flat_list
-
-    def add_job(self, job):
-        if job.plugin == 'resource':
-            # I don't want the user to see resources but I need to keep
-            # track of them to put them in the final selection. I also
-            # don't want to add them to the tree.
-            self._resource_jobs.append(job)
-            return
-        super().add_job(job)
-        self.job_selection[job] = True
-
-    @property
-    def selection(self):
-        """
-        Return all the jobs currently selected
-        """
-        self._selection_list = []
-        for category in self.categories:
-            self._selection_list.extend(category.selection)
-        for job in self.job_selection:
-            if self.job_selection[job]:
-                self._selection_list.append(job)
-        return self._selection_list
-
-    @property
-    def resource_jobs(self):
-        """Return all the resource jobs."""
-        return self._resource_jobs
-
-    def set_ancestors_state(self, new_state):
-        """
-        Set the selection state of all ancestors consistently
-        """
-        # If child is set, then all ancestors must be set
-        if new_state:
-            parent = self.parent
-            while parent:
-                parent.selected = new_state
-                parent = parent.parent
-        # If child is not set, then all ancestors mustn't be set
-        # unless another child of the ancestor is set
-        else:
-            parent = self.parent
-            while parent:
-                if any((category.selected
-                        for category in parent.categories)):
-                    break
-                if any((parent.job_selection[job]
-                        for job in parent.job_selection)):
-                    break
-                parent.selected = new_state
-                parent = parent.parent
-
-    def update_selected_state(self):
-        """
-        Update the category state according to its job selection
-        """
-        if any((self.job_selection[job] for job in self.job_selection)):
-            self.selected = True
-        else:
-            self.selected = False
-
-    def set_descendants_state(self, new_state):
-        """
-        Set the selection state of all descendants recursively
-        """
-        self.selected = new_state
-        for job in self.job_selection:
-            self.job_selection[job] = new_state
-        for category in self.categories:
-            category.set_descendants_state(new_state)
diff --git a/checkbox_ng/test_config.py b/checkbox_ng/test_config.py
deleted file mode 100644
index 33e3a24..0000000
--- a/checkbox_ng/test_config.py
+++ /dev/null
@@ -1,46 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-checkbox_ng.test_config
-=======================
-
-Test definitions for checkbox_ng.config module
-"""
-
-from unittest import TestCase
-
-from plainbox.impl.secure.config import Unset
-
-from checkbox_ng.config import CheckBoxConfig
-
-
-class PlainBoxConfigTests(TestCase):
-
-    def test_smoke(self):
-        config = CheckBoxConfig()
-        self.assertIs(config.secure_id, Unset)
-        secure_id = "0123456789ABCDE"
-        config.secure_id = secure_id
-        self.assertEqual(config.secure_id, secure_id)
-        with self.assertRaises(ValueError):
-            config.secure_id = "bork"
-        self.assertEqual(config.secure_id, secure_id)
-        del config.secure_id
-        self.assertIs(config.secure_id, Unset)
diff --git a/checkbox_ng/test_main.py b/checkbox_ng/test_main.py
deleted file mode 100644
index 1d2981d..0000000
--- a/checkbox_ng/test_main.py
+++ /dev/null
@@ -1,93 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012-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/>.
-
-"""
-checkbox_ng.test_main
-=====================
-
-Test definitions for checkbox_ng.main module
-"""
-
-from inspect import cleandoc
-from unittest import TestCase
-
-from plainbox.impl.clitools import ToolBase
-from plainbox.testing_utils.io import TestIO
-
-from checkbox_ng import __version__ as version
-from checkbox_ng.main import main
-
-
-class TestMain(TestCase):
-
-    def test_version(self):
-        with TestIO(combined=True) as io:
-            with self.assertRaises(SystemExit) as call:
-                main(['--version'])
-            self.assertEqual(call.exception.args, (0,))
-        self.assertEqual(io.combined, "{}\n".format(version))
-
-    def test_help(self):
-        with TestIO(combined=True) as io:
-            with self.assertRaises(SystemExit) as call:
-                main(['--help'])
-        self.assertEqual(call.exception.args, (0,))
-        self.maxDiff = None
-        expected = """
-        usage: checkbox [-h] [--version] [-v] [-D] [-C] [-T LOGGER] [-P] [-I]
-                        {sru,check-config,submit,launcher,self-test} ...
-
-        positional arguments:
-          {sru,check-config,submit,launcher,self-test}
-            sru                 run automated stable release update tests
-            check-config        check and display plainbox configuration
-            submit              submit test results to the Canonical certification
-                                website
-            launcher            run a customized testing session
-            self-test           run unit and integration tests
-
-        optional arguments:
-          -h, --help            show this help message and exit
-          --version             show program's version number and exit
-
-        logging and debugging:
-          -v, --verbose         be more verbose (same as --log-level=INFO)
-          -D, --debug           enable DEBUG messages on the root logger
-          -C, --debug-console   display DEBUG messages in the console
-          -T LOGGER, --trace LOGGER
-                                enable DEBUG messages on the specified logger (can be
-                                used multiple times)
-          -P, --pdb             jump into pdb (python debugger) when a command crashes
-          -I, --debug-interrupt
-                                crash on SIGINT/KeyboardInterrupt, useful with --pdb
-        """
-        self.assertEqual(io.combined, cleandoc(expected) + "\n")
-
-    def test_run_without_args(self):
-        with TestIO(combined=True) as io:
-            with self.assertRaises(SystemExit) as call:
-                main([])
-            self.assertEqual(call.exception.args, (2,))
-        expected = """
-        usage: checkbox [-h] [--version] [-v] [-D] [-C] [-T LOGGER] [-P] [-I]
-                        {sru,check-config,submit,launcher,self-test} ...
-        checkbox: error: too few arguments
-
-        """
-        self.assertEqual(io.combined, cleandoc(expected) + "\n")
diff --git a/checkbox_ng/test_misc.py b/checkbox_ng/test_misc.py
deleted file mode 100644
index efb26ac..0000000
--- a/checkbox_ng/test_misc.py
+++ /dev/null
@@ -1,183 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2014 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-checkbox_ng.commands.test_cli
-=============================
-
-Test definitions for checkbox_ng.commands.cli module
-"""
-
-from unittest import TestCase
-
-from plainbox.impl.session import SessionState
-from plainbox.impl.testing_utils import make_job
-from plainbox.impl.unit.job import JobDefinition
-
-from checkbox_ng.misc import JobTreeNode
-from checkbox_ng.misc import SelectableJobTreeNode
-
-
-class TestJobTreeNode(TestCase):
-
-    def setUp(self):
-        A = make_job('A')
-        B = make_job('B', plugin='local', description='foo')
-        C = make_job('C')
-        D = make_job('D', plugin='shell')
-        E = make_job('E', plugin='local', description='bar')
-        F = make_job('F', plugin='shell')
-        G = make_job('G', plugin='local', description='baz')
-        R = make_job('R', plugin='resource')
-        Z = make_job('Z', plugin='local', description='zaz')
-        state = SessionState([A, B, C, D, E, F, G, R, Z])
-        # D and E are a child of B
-        state.job_state_map[D.id].via_job = B
-        state.job_state_map[E.id].via_job = B
-        # F is a child of E
-        state.job_state_map[F.id].via_job = E
-        self.tree = JobTreeNode.create_tree(
-            state, [R, B, C, D, E, F, G, A, Z])
-
-    def test_create_tree(self):
-        self.assertIsInstance(self.tree, JobTreeNode)
-        self.assertEqual(len(self.tree.categories), 3)
-        [self.assertIsInstance(c, JobTreeNode) for c in self.tree.categories]
-        self.assertEqual(len(self.tree.jobs), 3)
-        [self.assertIsInstance(j, JobDefinition) for j in self.tree.jobs]
-        self.assertIsNone(self.tree.parent)
-        self.assertEqual(self.tree.depth, 0)
-        node = self.tree.categories[1]
-        self.assertEqual(node.name, 'foo')
-        self.assertEqual(len(node.categories), 1)
-        [self.assertIsInstance(c, JobTreeNode) for c in node.categories]
-        self.assertEqual(len(node.jobs), 1)
-        [self.assertIsInstance(j, JobDefinition) for j in node.jobs]
-
-
-class TestSelectableJobTreeNode(TestCase):
-
-    def setUp(self):
-        self.A = make_job('a', name='A')
-        self.B = make_job('b', name='B', plugin='local', description='foo')
-        self.C = make_job('c', name='C')
-        self.D = make_job('d', name='D', plugin='shell')
-        self.E = make_job('e', name='E', plugin='shell')
-        self.F = make_job('f', name='F', plugin='resource', description='baz')
-        state = SessionState([self.A, self.B, self.C, self.D, self.E, self.F])
-        # D and E are a child of B
-        state.job_state_map[self.D.id].via_job = self.B
-        state.job_state_map[self.E.id].via_job = self.B
-        self.tree = SelectableJobTreeNode.create_tree(state, [
-            self.A,
-            self.B,
-            self.C,
-            self.D,
-            self.E,
-            self.F
-        ])
-
-    def test_create_tree(self):
-        self.assertIsInstance(self.tree, SelectableJobTreeNode)
-        self.assertEqual(len(self.tree.categories), 1)
-        [self.assertIsInstance(c, SelectableJobTreeNode)
-            for c in self.tree.categories]
-        self.assertEqual(len(self.tree.jobs), 2)
-        [self.assertIsInstance(j, JobDefinition) for j in self.tree.jobs]
-        self.assertTrue(self.tree.selected)
-        [self.assertTrue(self.tree.job_selection[j])
-            for j in self.tree.job_selection]
-        self.assertTrue(self.tree.expanded)
-        self.assertIsNone(self.tree.parent)
-        self.assertEqual(self.tree.depth, 0)
-
-    def test_get_node_by_index(self):
-        self.assertEqual(self.tree.get_node_by_index(0)[0].name, 'foo')
-        self.assertEqual(self.tree.get_node_by_index(1)[0].name, 'D')
-        self.assertEqual(self.tree.get_node_by_index(2)[0].name, 'E')
-        self.assertEqual(self.tree.get_node_by_index(3)[0].name, 'A')
-        self.assertEqual(self.tree.get_node_by_index(4)[0].name, 'C')
-        self.assertIsNone(self.tree.get_node_by_index(5)[0])
-
-    def test_render(self):
-        expected = ['[X] - foo',
-                    '[X]      d',
-                    '[X]      e',
-                    '[X]   a',
-                    '[X]   c']
-        self.assertEqual(self.tree.render(), expected)
-
-    def test_render_deselected_all(self):
-        self.tree.set_descendants_state(False)
-        expected = ['[ ] - foo',
-                    '[ ]      d',
-                    '[ ]      e',
-                    '[ ]   a',
-                    '[ ]   c']
-        self.assertEqual(self.tree.render(), expected)
-
-    def test_render_reselected_all(self):
-        self.tree.set_descendants_state(False)
-        self.tree.set_descendants_state(True)
-        expected = ['[X] - foo',
-                    '[X]      d',
-                    '[X]      e',
-                    '[X]   a',
-                    '[X]   c']
-        self.assertEqual(self.tree.render(), expected)
-
-    def test_render_with_child_collapsed(self):
-        self.tree.categories[0].expanded = False
-        expected = ['[X] + foo',
-                    '[X]   a',
-                    '[X]   c']
-        self.assertEqual(self.tree.render(), expected)
-
-    def test_set_ancestors_state(self):
-        self.tree.set_descendants_state(False)
-        node = self.tree.categories[0]
-        node.job_selection[self.E] = True
-        node.update_selected_state()
-        node.set_ancestors_state(node.selected)
-        expected = ['[X] - foo',
-                    '[ ]      d',
-                    '[X]      e',
-                    '[ ]   a',
-                    '[ ]   c']
-        self.assertEqual(self.tree.render(), expected)
-        node.selected = not(node.selected)
-        node.set_ancestors_state(node.selected)
-        node.set_descendants_state(node.selected)
-        expected = ['[ ] - foo',
-                    '[ ]      d',
-                    '[ ]      e',
-                    '[ ]   a',
-                    '[ ]   c']
-        self.assertEqual(self.tree.render(), expected)
-
-    def test_selection(self):
-        self.tree.set_descendants_state(False)
-        node = self.tree.categories[0]
-        node.job_selection[self.D] = True
-        node.update_selected_state()
-        node.set_ancestors_state(node.selected)
-        # Note that in addition to the selected (D) test, we need the
-        # tree selection to contain the resource (F), even though the
-        # user never saw it in the previous tests for visual presentation.
-        self.assertEqual(self.tree.selection, [self.D])
diff --git a/checkbox_ng/tools.py b/checkbox_ng/tools.py
deleted file mode 100644
index 1aa8f37..0000000
--- a/checkbox_ng/tools.py
+++ /dev/null
@@ -1,146 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2012-2015 Canonical Ltd.
-# Written by:
-#   Zygmunt Krynicki <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.tools` -- top-level command line tools
-========================================================
-"""
-
-import logging
-import os
-
-from plainbox.impl.clitools import SingleCommandToolMixIn
-from plainbox.impl.clitools import ToolBase
-from plainbox.impl.commands.cmd_selftest import SelfTestCommand
-from plainbox.public import get_providers
-
-from checkbox_ng import __version__ as version
-from checkbox_ng.config import CheckBoxConfig
-from checkbox_ng.tests import load_unit_tests
-
-
-logger = logging.getLogger("checkbox.ng.tools")
-
-
-class CheckboxToolBase(ToolBase):
-    """
-    Base class for all checkbox-ng tools.
-
-    This class contains some shared code like configuration, providers, i18n
-    and version handling.
-    """
-
-    def _load_config(self):
-        return self.get_config_cls().get()
-
-    def _load_providers(self):
-        return get_providers()
-
-    @classmethod
-    def get_exec_version(cls):
-        """
-        Get the version of the checkbox-ng package
-        """
-        return version
-
-    @classmethod
-    def get_config_cls(cls):
-        """
-        Get particular sub-class of the Config class to use
-        """
-        return CheckBoxConfig
-
-    def get_gettext_domain(self):
-        """
-        Get the 'checkbox-ng' gettext domain
-        """
-        return "checkbox-ng"
-
-    def get_locale_dir(self):
-        """
-        Get an optional development locale directory specific to checkbox-ng
-        """
-        return os.getenv("CHECKBOX_NG_LOCALE_DIR", None)
-
-
-class CheckboxTool(CheckboxToolBase):
-    """
-    Tool that implements the new checkbox command.
-
-    This tool has two sub-commands:
-
-        checkbox sru - to run stable release update testing
-        checkbox check-config - to validate and display system configuration
-    """
-
-    @classmethod
-    def get_exec_name(cls):
-        return "checkbox"
-
-    def add_subcommands(self, subparsers, early_ns=None):
-        from checkbox_ng.commands.launcher import LauncherCommand
-        from checkbox_ng.commands.sru import SRUCommand
-        from checkbox_ng.commands.submit import SubmitCommand
-        from plainbox.impl.commands.cmd_check_config import CheckConfigCommand
-        SRUCommand(
-            self._load_providers, self._load_config
-        ).register_parser(subparsers)
-        CheckConfigCommand(
-            self._load_config
-        ).register_parser(subparsers)
-        SubmitCommand(
-            self._load_config
-        ).register_parser(subparsers)
-        LauncherCommand(
-            self._load_providers, self._load_config
-        ).register_parser(subparsers)
-        SelfTestCommand(load_unit_tests).register_parser(subparsers)
-
-
-class CheckboxSubmitTool(SingleCommandToolMixIn, CheckboxToolBase):
-    """
-    A tool class that implements checkbox-submit.
-
-    This tool implements the submit feature to send test results to the
-    Canonical certification website
-    """
-
-    @classmethod
-    def get_exec_name(cls):
-        return "checkbox-submit"
-
-    def get_command(self):
-        from checkbox_ng.commands.submit import SubmitCommand
-        return SubmitCommand(self._load_config)
-
-
-class CheckboxLauncherTool(SingleCommandToolMixIn, CheckboxToolBase):
-    """
-    A tool class that implements checkbox-launcher.
-
-    This tool implements configurable text-mode-graphics launchers that perform
-    a pre-defined testing session based on the launcher profile.
-    """
-
-    @classmethod
-    def get_exec_name(cls):
-        return "checkbox-launcher"
-
-    def get_command(self):
-        from checkbox_ng.commands.launcher import LauncherCommand
-        return LauncherCommand(self._load_providers, self._load_config)
diff --git a/checkbox_ng/ui.py b/checkbox_ng/ui.py
deleted file mode 100644
index 322c522..0000000
--- a/checkbox_ng/ui.py
+++ /dev/null
@@ -1,363 +0,0 @@
-# This file is part of Checkbox.
-#
-# Copyright 2013-2015 Canonical Ltd.
-# Written by:
-#   Sylvain Pineau <[e-mail]>
-#
-# Checkbox is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 3,
-# as published by the Free Software Foundation.
-
-#
-# Checkbox is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
-
-"""
-:mod:`checkbox_ng.ui` -- user interface elements
-================================================
-"""
-
-from gettext import gettext as _
-from logging import getLogger
-import textwrap
-
-from plainbox.vendor.textland import DrawingContext
-from plainbox.vendor.textland import EVENT_KEYBOARD
-from plainbox.vendor.textland import EVENT_RESIZE
-from plainbox.vendor.textland import Event
-from plainbox.vendor.textland import IApplication
-from plainbox.vendor.textland import Size
-from plainbox.vendor.textland import TextImage
-from plainbox.vendor.textland import NORMAL, REVERSE
-
-
-logger = getLogger("checkbox.ng.ui")
-
-
-class ShowWelcome(IApplication):
-    """
-    Display a welcome message
-    """
-    def __init__(self, text):
-        self.image = TextImage(Size(0, 0))
-        self.text = text
-
-    def consume_event(self, event: Event):
-        if event.kind == EVENT_RESIZE:
-            self.image = TextImage(event.data)  # data is the new size
-        elif event.kind == EVENT_KEYBOARD and event.data.key == "enter":
-            raise StopIteration
-        self.repaint(event)
-        return self.image
-
-    def repaint(self, event: Event):
-        ctx = DrawingContext(self.image)
-        i = 0
-        ctx.border()
-        for paragraph in self.text.splitlines():
-            i += 1
-            for line in textwrap.fill(
-                    paragraph,
-                    self.image.size.width - 8,
-                    replace_whitespace=False).splitlines():
-                ctx.move_to(4, i)
-                ctx.print(line)
-                i += 1
-        ctx.move_to(4, i + 1)
-        ctx.attributes.style = REVERSE
-        ctx.print(_("< Continue >"))
-
-
-class ShowMenu(IApplication):
-    """
-    Display the appropriate menu and return the selected options
-    """
-    def __init__(self, title, menu, selection=[0], multiple_allowed=True):
-        self.image = TextImage(Size(0, 0))
-        self.title = title
-        self.menu = menu
-        self.option_count = len(menu)
-        self.position = 0  # Zero-based index of the selected menu option
-        self.multiple_allowed = multiple_allowed
-        if self.option_count:
-            self.selection = selection
-        else:
-            self.selection = []
-
-    def consume_event(self, event: Event):
-        if event.kind == EVENT_RESIZE:
-            self.image = TextImage(event.data)  # data is the new size
-        elif event.kind == EVENT_KEYBOARD:
-            if event.data.key == "down":
-                if self.position < self.option_count:
-                    self.position += 1
-                else:
-                    self.position = 0
-            elif event.data.key == "up":
-                if self.position > 0:
-                    self.position -= 1
-                else:
-                    self.position = self.option_count
-            elif (event.data.key == "enter" and
-                  self.position == self.option_count):
-                raise StopIteration(self.selection)
-            elif event.data.key == "space":
-                if self.position in self.selection:
-                    self.selection.remove(self.position)
-                elif self.position < self.option_count:
-                    self.selection.append(self.position)
-                    if not self.multiple_allowed:
-                        self.selection = [self.position]
-        self.repaint(event)
-        return self.image
-
-    def repaint(self, event: Event):
-        ctx = DrawingContext(self.image)
-        ctx.border(tm=1)
-        ctx.attributes.style = REVERSE
-        ctx.print(' ' * self.image.size.width)
-        ctx.move_to(1, 0)
-        ctx.print(self.title)
-
-        # Display all the menu items
-        for i in range(self.option_count):
-            ctx.attributes.style = NORMAL
-            if i == self.position:
-                ctx.attributes.style = REVERSE
-            # Display options from line 3, column 4
-            ctx.move_to(4, 3 + i)
-            ctx.print("[{}] - {}".format(
-                'X' if i in self.selection else ' ',
-                self.menu[i].replace('ihv-', '')))
-
-        # Display "OK" at bottom of menu
-        ctx.attributes.style = NORMAL
-        if self.position == self.option_count:
-            ctx.attributes.style = REVERSE
-        # Add an empty line before the last option
-        ctx.move_to(4, 4 + self.option_count)
-        ctx.print("< OK >")
-
-
-class ScrollableTreeNode(IApplication):
-    """
-    Class used to interact with a SelectableJobTreeNode
-    """
-    def __init__(self, tree, title):
-        self.image = TextImage(Size(0, 0))
-        self.tree = tree
-        self.title = title
-        self.top = 0  # Top line number
-        self.highlight = 0  # Highlighted line number
-        self.summary = True
-
-    def consume_event(self, event: Event):
-        if event.kind == EVENT_RESIZE:
-            self.image = TextImage(event.data)  # data is the new size
-        elif event.kind == EVENT_KEYBOARD:
-            self.image = TextImage(self.image.size)
-            if event.data.key == "up":
-                self._scroll("up")
-            elif event.data.key == "down":
-                self._scroll("down")
-            elif event.data.key == "space":
-                self._selectNode()
-            elif event.data.key == "enter":
-                self._toggleNode()
-            elif event.data.key in 'sS':
-                self.tree.set_descendants_state(True)
-            elif event.data.key in 'dD':
-                self.tree.set_descendants_state(False)
-            elif event.data.key in 'iI':
-                self.summary = not self.summary
-            elif event.data.key in 'tT':
-                raise StopIteration
-        self.repaint(event)
-        return self.image
-
-    def repaint(self, event: Event):
-        ctx = DrawingContext(self.image)
-        ctx.border(tm=1, bm=1)
-        cols = self.image.size.width
-        extra_cols = 0
-        if cols > 80:
-            extra_cols = cols - 80
-        ctx.attributes.style = REVERSE
-        ctx.print(' ' * cols)
-        ctx.move_to(1, 0)
-        bottom = self.top + self.image.size.height - 4
-        ctx.print(self.title)
-        ctx.move_to(1, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        ctx.print(_("Enter"))
-        ctx.move_to(6, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print(_(": Expand/Collapse"))
-        ctx.move_to(27, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("S")
-        ctx.move_to(28, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("elect All")
-        ctx.move_to(41, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("D")
-        ctx.move_to(42, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("eselect All")
-        ctx.move_to(66 + extra_cols, self.image.size.height - 1)
-        ctx.print(_("Start "))
-        ctx.move_to(72 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("T")
-        ctx.move_to(73 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("esting")
-        for i, line in enumerate(self.tree.render(cols - 3,
-                                    as_summary=self.summary)[self.top:bottom]):
-            ctx.move_to(2, i + 2)
-            if i != self.highlight:
-                ctx.attributes.style = NORMAL
-            else:  # highlight the current line
-                ctx.attributes.style = REVERSE
-            ctx.print(line)
-
-    def _selectNode(self):
-        """
-        Mark a node/job as selected for this test run.
-        See :meth:`SelectableJobTreeNode.set_ancestors_state()` and
-        :meth:`SelectableJobTreeNode.set_descendants_state()` for details
-        about the automatic selection of parents and descendants.
-        """
-        node, category = self.tree.get_node_by_index(self.top + self.highlight)
-        if category:  # then the selected node is a job not a category
-            job = node
-            category.job_selection[job] = not(category.job_selection[job])
-            category.update_selected_state()
-            category.set_ancestors_state(category.job_selection[job])
-        else:
-            node.selected = not(node.selected)
-            node.set_descendants_state(node.selected)
-            node.set_ancestors_state(node.selected)
-
-    def _toggleNode(self):
-        """
-        Expand/collapse a node
-        """
-        node, is_job = self.tree.get_node_by_index(self.top + self.highlight)
-        if node is not None and not is_job:
-            node.expanded = not(node.expanded)
-
-    def _scroll(self, direction):
-        visible_length = len(self.tree)
-        # Scroll the tree view
-        if (direction == "up" and
-                self.highlight == 0 and self.top != 0):
-            self.top -= 1
-            return
-        elif (direction == "down" and
-                (self.highlight + 1) == (self.image.size.height - 4) and
-                (self.top + self.image.size.height - 4) != visible_length):
-            self.top += 1
-            return
-        # Move the highlighted line
-        if (direction == "up" and
-                (self.top != 0 or self.highlight != 0)):
-            self.highlight -= 1
-        elif (direction == "down" and
-                (self.top + self.highlight + 1) != visible_length and
-                (self.highlight + 1) != (self.image.size.height - 4)):
-            self.highlight += 1
-
-
-class ShowRerun(ScrollableTreeNode):
-    """ Display the re-run screen."""
-    def __init__(self, tree, title):
-        super().__init__(tree, title)
-
-    def consume_event(self, event: Event):
-        if event.kind == EVENT_RESIZE:
-            self.image = TextImage(event.data)  # data is the new size
-        elif event.kind == EVENT_KEYBOARD:
-            self.image = TextImage(self.image.size)
-            if event.data.key == "up":
-                self._scroll("up")
-            elif event.data.key == "down":
-                self._scroll("down")
-            elif event.data.key == "space":
-                self._selectNode()
-            elif event.data.key == "enter":
-                self._toggleNode()
-            elif event.data.key in 'sS':
-                self.tree.set_descendants_state(True)
-            elif event.data.key in 'dD':
-                self.tree.set_descendants_state(False)
-            elif event.data.key in 'fF':
-                self.tree.set_descendants_state(False)
-                raise StopIteration
-            elif event.data.key in 'rR':
-                raise StopIteration
-        self.repaint(event)
-        return self.image
-
-    def repaint(self, event: Event):
-        ctx = DrawingContext(self.image)
-        ctx.border(tm=1, bm=1)
-        cols = self.image.size.width
-        extra_cols = 0
-        if cols > 80:
-            extra_cols = cols - 80
-        ctx.attributes.style = REVERSE
-        ctx.print(' ' * cols)
-        ctx.move_to(1, 0)
-        bottom = self.top + self.image.size.height - 4
-        ctx.print(self.title)
-        ctx.move_to(1, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        ctx.print(_("Enter"))
-        ctx.move_to(6, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print(_(": Expand/Collapse"))
-        ctx.move_to(27, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("S")
-        ctx.move_to(28, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("elect All")
-        ctx.move_to(41, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("D")
-        ctx.move_to(42, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("eselect All")
-        ctx.move_to(63 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("F")
-        ctx.move_to(64 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print(_("inish"))
-        ctx.move_to(73 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = REVERSE
-        # FIXME: i18n problem
-        ctx.print("R")
-        ctx.move_to(74 + extra_cols, self.image.size.height - 1)
-        ctx.attributes.style = NORMAL
-        ctx.print("e-run")
-        for i, line in enumerate(self.tree.render(cols - 3)[self.top:bottom]):
-            ctx.move_to(2, i + 2)
-            if i != self.highlight:
-                ctx.attributes.style = NORMAL
-            else:  # highlight the current line
-                ctx.attributes.style = REVERSE
-            ctx.print(line)
diff --git a/po/POTFILES.in b/po/POTFILES.in
index c9804d5..8934fc2 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -1,19 +1,13 @@
 [encoding: UTF-8]
+./docs/conf.py
 ./checkbox_ng/__init__.py
 ./checkbox_ng/certification.py
-./checkbox_ng/commands/__init__.py
-./checkbox_ng/commands/cli.py
-./checkbox_ng/commands/launcher.py
-./checkbox_ng/commands/newcli.py
-./checkbox_ng/commands/sru.py
-./checkbox_ng/commands/submit.py
-./checkbox_ng/commands/test_sru.py
 ./checkbox_ng/config.py
-./checkbox_ng/launchpad.py
-./checkbox_ng/main.py
+./checkbox_ng/launcher/__init__.py
+./checkbox_ng/launcher/checkbox_cli.py
+./checkbox_ng/launcher/stages.py
+./checkbox_ng/launcher/subcommands.py
 ./checkbox_ng/test_certification.py
-./checkbox_ng/test_config.py
-./checkbox_ng/test_main.py
-./checkbox_ng/test_misc.py
 ./checkbox_ng/tests.py
-./checkbox_ng/ui.py
+./checkbox_ng/urwid_ui.py
+./setup.py
diff --git a/setup.py b/setup.py
index b6226bf..f4ddbf5 100755
--- a/setup.py
+++ b/setup.py
@@ -68,9 +68,6 @@ setup(
     entry_points={
         'console_scripts': [
             'checkbox-cli=checkbox_ng.launcher.checkbox_cli:main',
-            'checkbox=checkbox_ng.main:main',
-            'checkbox-submit=checkbox_ng.main:submit',
-            'checkbox-launcher=checkbox_ng.main:launcher',
         ],
         'plainbox.transport': [
             'certification='