Merge lp:~jeffmarcom/opencompute/checkbox-ocp_update-plainbox into lp:opencompute/checkbox

[Jeff Marcom]

Update the plainbox code to current trunk in lp:checkbox

This updates the included version of plainbox within checkbox for the opencompute project.

[Jeff Lane  (bladernr)]

big, but looks ok as best as I can tell. Seems to build and such.

review: Approve

[Jeff Marcom (jeffmarcom)]

The attempt to merge lp:~jeffmarcom/opencompute/checkbox-ocp_update-plainbox into lp:opencompute/checkbox failed. Below is the output from the failed tests.

=== modified file 'debian/changelog'
--- debian/changelog	2013-08-21 16:23:56 +0000
+++ debian/changelog	2013-09-13 17:12:45 +0000
@@ -1,3 +1,12 @@
+
+checkbox (1.16.7~OCP) UNRELEASED; urgency=low
+
+  [ Jeff Marcom ]
+  * Updated plainbox based on version 0.4.dev in lp:checkbox (16.12)
+
+ -- Jeff Marcom <[e-mail]>  Fri, 13 Sept 2013 10:13:04 -0400
+
+
 checkbox (1.16.6~OCP) UNRELEASED; urgency=low
 
   [ Jeff Marcom ]

=== modified file 'plainbox/MANIFEST.in'
--- plainbox/MANIFEST.in	2013-05-09 18:39:35 +0000
+++ plainbox/MANIFEST.in	2013-09-13 17:12:45 +0000
@@ -1,9 +1,10 @@
 include README.md
 include COPYING
 include mk-interesting-graphs.sh
-recursive-include plainbox/test-data/ *.json *.xml *.txt
+recursive-include plainbox/test-data *.json *.xml *.txt
 recursive-include docs *.rst
 include docs/conf.py
-include plainbox/data/report/hardware-1_0.rng
+recursive-include plainbox/data/report *.rng *.css *.xsl *.js
+recursive-include plainbox/data/report/images *.png
 include contrib/policykit_yes/org.freedesktop.policykit.pkexec.policy
 include contrib/policykit_auth_admin_keep/org.freedesktop.policykit.pkexec.policy

=== added file 'plainbox/contrib/com.canonical.certification.PlainBox1.service'
--- plainbox/contrib/com.canonical.certification.PlainBox1.service	1970-01-01 00:00:00 +0000
+++ plainbox/contrib/com.canonical.certification.PlainBox1.service	2013-09-13 17:12:45 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=com.canonical.certification.PlainBox1
+Exec=/usr/bin/plainbox service

=== added file 'plainbox/contrib/dbus-mini-client.py'
--- plainbox/contrib/dbus-mini-client.py	1970-01-01 00:00:00 +0000
+++ plainbox/contrib/dbus-mini-client.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,430 @@
+#!/usr/bin/env python3
+########
+#This simple script provides a small reference and example of how to
+#invoke plainbox methods through d-bus to accomplish useful tasks.
+#
+#Use of the d-feet tool is suggested for interactive exploration of
+#the plainbox objects, interfaces and d-bus API. However, d-feet can be
+#cumbersome to use for more advanced testing and experimentation.
+#
+#This script can be adapted to fit other testing needs as well.
+#
+#To run it, first launch plainbox in service mode using the stub provider:
+#    $ plainbox -c stub service
+#
+#then run the script itself. It does the following things:
+#
+# 1- Obtain a whitelist and a job provider
+# 2- Use the whitelist to "qualify" jobs offered by the provider,
+#    In essence filtering them to obtain a desired list of jobs to run.
+# 3- Run each job in the run_list, this implicitly updates the session's
+#    results and state map.
+# 4- Print the job names and outcomes and some other data
+# 5- Export the session's data (job results) to xml in /tmp.
+#####
+
+import dbus
+from gi.repository import GObject
+from dbus.mainloop.glib import DBusGMainLoop
+from plainbox.abc import IJobResult
+
+bus = dbus.SessionBus(mainloop=DBusGMainLoop())
+
+# TODO: Create a class to remove all global var.
+current_job_path = None
+service = None
+session_object_path = None
+session_object = None
+run_list = None
+desired_job_list = None
+whitelist = None
+exports_count = 0
+
+def main():
+    global service
+    global session_object_path
+    global session_object
+    global run_list
+    global desired_job_list
+    global whitelist
+
+    whitelist = bus.get_object(
+        'com.canonical.certification.PlainBox1',
+        '/plainbox/whitelist/stub'
+    )
+
+    provider = bus.get_object(
+        'com.canonical.certification.PlainBox1',
+        '/plainbox/provider/stubbox'
+    )
+
+    #whitelist = bus.get_object(
+    #    'com.canonical.certification.PlainBox1',
+    #    '/plainbox/whitelist/default'
+    #)
+
+    #provider = bus.get_object(
+    #    'com.canonical.certification.PlainBox1',
+    #    '/plainbox/provider/checkbox'
+    #)
+
+    #A provider manages objects other than jobs.
+    provider_objects = provider.GetManagedObjects(
+        dbus_interface='org.freedesktop.DBus.ObjectManager')
+
+    #Create a session and "seed" it with my job list:
+    job_list = [k for k, v in provider_objects.items() if not 'whitelist' in k]
+    service = bus.get_object(
+        'com.canonical.certification.PlainBox1',
+        '/plainbox/service1'
+    )
+    session_object_path = service.CreateSession(
+        job_list,
+        dbus_interface='com.canonical.certification.PlainBox.Service1'
+    )
+    session_object = bus.get_object(
+        'com.canonical.certification.PlainBox1',
+        session_object_path
+    )
+
+    if session_object.PreviousSessionFile():
+        if ask_for_resume():
+            session_object.Resume()
+        else:
+            session_object.Clean()
+
+    #to get only the *jobs* that are designated by the whitelist.
+    desired_job_list = [
+        object for object in provider_objects if whitelist.Designates(
+            object,
+            dbus_interface='com.canonical.certification.PlainBox.WhiteList1')]
+
+    desired_local_job_list = sorted([
+        object for object in desired_job_list if
+        bus.get_object('com.canonical.certification.PlainBox1', object).Get(
+            'com.canonical.certification.CheckBox.JobDefinition1',
+            'plugin') == 'local'
+    ])
+
+    #Now I update the desired job list.
+    session_object.UpdateDesiredJobList(
+        desired_local_job_list,
+        dbus_interface='com.canonical.certification.PlainBox.Session1'
+    )
+
+    #Now, the run_list contains the list of jobs I actually need to run \o/
+    run_list = session_object.Get(
+        'com.canonical.certification.PlainBox.Session1',
+        'run_list'
+    )
+
+    # Add some signal receivers
+    bus.add_signal_receiver(
+        catchall_local_job_result_available_signals_handler,
+        dbus_interface="com.canonical.certification.PlainBox.Service1",
+        signal_name="JobResultAvailable")
+
+    # Start running jobs
+    print("[ Running All Local Jobs ]".center(80, '='))
+    run_local_jobs()
+
+    #PersistentSave can be called at any point to checkpoint session state.
+    #In here, we're just calling it at the end, as an example.
+    print("[ Saving the session ]".center(80, '='))
+    session_object.PersistentSave()
+
+
+def ask_for_outcome(prompt=None, allowed=None):
+    if prompt is None:
+        prompt = "what is the outcome? "
+    if allowed is None:
+        allowed = (IJobResult.OUTCOME_PASS, "p",
+                   IJobResult.OUTCOME_FAIL, "f",
+                   IJobResult.OUTCOME_SKIP, "s")
+    answer = None
+    while answer not in allowed:
+        print("Allowed answers are: {}".format(", ".join(allowed)))
+        answer = input(prompt)
+        # Useful shortcuts for testing
+        if answer == "f":
+            answer = IJobResult.OUTCOME_FAIL
+        if answer == "p":
+            answer = IJobResult.OUTCOME_PASS
+        if answer == "s":
+            answer = IJobResult.OUTCOME_SKIP
+    return answer
+
+
+def ask_for_test(prompt=None, allowed=None):
+    if prompt is None:
+        prompt = "Run the test command? "
+    if allowed is None:
+        allowed = ("y",
+                   "n",
+                   )
+    answer = None
+    while answer not in allowed:
+        print("Allowed answers are: {}".format(", ".join(allowed)))
+        answer = input(prompt)
+    return answer
+
+def ask_for_resume():
+    prompt = "Do you want to resume the previous session [Y/n]? "
+    allowed = ('', 'y', 'Y', 'n', 'N')
+    answer = None
+    while answer not in allowed:
+        answer = input(prompt)
+    return False if answer in ('n', 'N') else True
+
+
+# Asynchronous calls need reply handlers
+def handle_export_reply(s):
+    print("Export to buffer: I got {} bytes of export data".format(len(s)))
+    maybe_quit_after_export()
+
+def handle_export_to_file_reply(s):
+    print("Export to file: completed to {}".format(s))
+    maybe_quit_after_export()
+
+def maybe_quit_after_export():
+    # Two asynchronous callbacks calling this may result in a race
+    # condition. Don't do this at home, use a semaphore or lock.
+    global exports_count
+    exports_count += 1
+    if exports_count >= 2:
+        loop.quit()
+
+def handle_error(e):
+    print(str(e))
+    loop.quit()
+
+
+def catchall_ask_for_outcome_signals_handler(current_runner_path):
+    global current_job_path
+    job_def_object = bus.get_object(
+        'com.canonical.certification.PlainBox1', current_job_path)
+    job_cmd = job_def_object.Get(
+        'com.canonical.certification.CheckBox.JobDefinition1',
+        'command')
+    job_runner_object = bus.get_object(
+        'com.canonical.certification.PlainBox1', current_runner_path)
+    if job_cmd:
+        run_test = ask_for_test()
+        if run_test == 'y':
+            job_runner_object.RunCommand()
+            return
+    outcome_from_command = job_runner_object.Get(
+            'com.canonical.certification.PlainBox.RunningJob1',
+            'outcome_from_command')
+    print("Return code from the command indicates: {} ".format(
+          outcome_from_command))
+    outcome = ask_for_outcome()
+    comments = 'Test plainbox comments'
+    job_runner_object.SetOutcome(
+        outcome,
+        comments,
+        dbus_interface='com.canonical.certification.PlainBox.RunningJob1')
+
+
+def catchall_io_log_generated_signals_handler(offset, name, data):
+    try:
+        print("(<{}:{:05}>) {}".format(
+            name, int(offset), data.decode('UTF-8').rstrip()))
+    except UnicodeDecodeError:
+        pass
+
+
+def catchall_local_job_result_available_signals_handler(job, result):
+    # XXX: check if the job path actually matches the current_job_path
+     # Update the session job state map and run new jobs
+    global session_object
+    session_object.UpdateJobResult(
+        job, result,
+        reply_handler=run_local_jobs,
+        error_handler=handle_error,
+        dbus_interface='com.canonical.certification.PlainBox.Session1')
+
+
+def catchall_job_result_available_signals_handler(job, result):
+    # XXX: check if the job path actually matches the current_job_path
+     # Update the session job state map and run new jobs
+    global session_object
+    session_object.UpdateJobResult(
+        job, result,
+        reply_handler=run_jobs,
+        error_handler=handle_error,
+        dbus_interface='com.canonical.certification.PlainBox.Session1')
+
+
+def run_jobs():
+    global run_list
+    #Now the actual run, job by job.
+    if run_list:
+        job_path = run_list.pop(0)
+        global current_job_path
+        global session_object_path
+        current_job_path = job_path
+        job_def_object = bus.get_object(
+            'com.canonical.certification.PlainBox', current_job_path)
+        job_name = job_def_object.Get(
+            'com.canonical.certification.PlainBox.JobDefinition1', 'name')
+        job_desc = job_def_object.Get(
+            'com.canonical.certification.PlainBox.JobDefinition1',
+            'description')
+        print("[ {} ]".format(job_name).center(80, '-'))
+        if job_desc:
+            print(job_desc)
+            print("^" * len(job_desc.splitlines()[-1]))
+            print()
+        service.RunJob(session_object_path, job_path)
+    else:
+        show_results()
+
+
+def run_local_jobs():
+    global run_list
+    global desired_job_list
+    global whitelist
+    if run_list:
+        job_path = run_list.pop(0)
+        global current_job_path
+        global session_object_path
+        current_job_path = job_path
+        job_def_object = bus.get_object(
+            'com.canonical.certification.PlainBox1', current_job_path)
+        job_name = job_def_object.Get(
+            'com.canonical.certification.PlainBox.JobDefinition1', 'name')
+        job_desc = job_def_object.Get(
+            'com.canonical.certification.PlainBox.JobDefinition1',
+            'description')
+        print("[ {} ]".format(job_name).center(80, '-'))
+        if job_desc:
+            print(job_desc)
+        service.RunJob(session_object_path, job_path)
+    else:
+        #Now I update the desired job list to get jobs created from local jobs.
+        session_object.UpdateDesiredJobList(
+            desired_job_list,
+            dbus_interface='com.canonical.certification.PlainBox.Session1'
+        )
+        bus.add_signal_receiver(
+            catchall_ask_for_outcome_signals_handler,
+            dbus_interface="com.canonical.certification.PlainBox.Service1",
+            signal_name="AskForOutcome")
+
+        bus.add_signal_receiver(
+            catchall_io_log_generated_signals_handler,
+            dbus_interface="com.canonical.certification.PlainBox.Service1",
+            signal_name="IOLogGenerated",
+            byte_arrays=True)  # To easily convert the byte arrays to strings
+
+        # Replace the job result handler we created for local jobs for by the
+        # one dedicated to regular job types
+        bus.remove_signal_receiver(
+            catchall_local_job_result_available_signals_handler,
+            dbus_interface="com.canonical.certification.PlainBox.Service1",
+            signal_name="JobResultAvailable")
+
+        bus.add_signal_receiver(
+            catchall_job_result_available_signals_handler,
+            dbus_interface="com.canonical.certification.PlainBox.Service1",
+            signal_name="JobResultAvailable")
+
+        job_list = session_object.Get(
+            'com.canonical.certification.PlainBox.Session1',
+            'job_list'
+        )
+
+        #to get only the *jobs* that are designated by the whitelist.
+        desired_job_list = [
+            object for object in job_list if whitelist.Designates(
+                object,
+                dbus_interface=
+                'com.canonical.certification.PlainBox.WhiteList1')]
+
+        #Now I update the desired job list.
+        # XXX: Remove previous local jobs from this list to avoid evaluating
+        # them twice
+        session_object.UpdateDesiredJobList(
+            desired_job_list,
+            dbus_interface='com.canonical.certification.PlainBox.Session1'
+        )
+
+        #Now, the run_list contains the list of jobs I actually need to run \o/
+        run_list = session_object.Get(
+            'com.canonical.certification.PlainBox.Session1',
+            'run_list'
+        )
+
+        print("[ Running All Jobs ]".center(80, '='))
+        run_jobs()
+
+
+def show_results():
+    global session_object_path
+    session_object = bus.get_object(
+        'com.canonical.certification.PlainBox1',
+        session_object_path
+    )
+    job_state_map = session_object.Get(
+        'com.canonical.certification.PlainBox.Session1', 'job_state_map')
+    print("[ Results ]".center(80, '='))
+    for k, job_state_path in job_state_map.items():
+        job_state_object = bus.get_object(
+            'com.canonical.certification.PlainBox1',
+            job_state_path
+        )
+        # Get the job definition object and some properties
+        job_def_path = job_state_object.Get(
+            'com.canonical.certification.PlainBox.JobState1', 'job')
+        job_def_object = bus.get_object(
+            'com.canonical.certification.PlainBox1', job_def_path)
+        job_name = job_def_object.Get(
+            'com.canonical.certification.PlainBox.JobDefinition1', 'name')
+        # Ask the via value (e.g. to comptute job categories)
+        # if a job is a child of a local job
+        job_via = job_def_object.Get(
+            'com.canonical.certification.CheckBox.JobDefinition1', 'via')
+
+        # Get the current job result object and the outcome property
+        job_result_path = job_state_object.Get(
+            'com.canonical.certification.PlainBox.JobState1', 'result')
+        job_result_object = bus.get_object(
+            'com.canonical.certification.PlainBox1', job_result_path)
+        outcome = job_result_object.Get(
+            'com.canonical.certification.PlainBox.Result1', 'outcome')
+        comments = job_result_object.Get(
+            'com.canonical.certification.PlainBox.Result1', 'comments')
+        io_log = job_result_object.Get(
+            'com.canonical.certification.PlainBox.Result1',
+            'io_log', byte_arrays=True)
+
+        print("{:55s} {:15s} {}".format(job_name, outcome, comments))
+    export_session()
+
+def export_session():
+    service.ExportSessionToFile(
+        session_object_path,
+        "xml",
+        [''],
+        "/tmp/report.xml",
+        reply_handler=handle_export_to_file_reply,
+        error_handler=handle_error
+    )
+    # The exports will apparently run in parallel. The callbacks
+    # are responsible for ensuring exiting after this.
+    service.ExportSession(
+        session_object_path,
+        "xml",
+        [''],
+        reply_handler=handle_export_reply,
+        error_handler=handle_error
+    )
+
+# Start the first call after a short delay
+GObject.timeout_add(5, main)
+loop = GObject.MainLoop()
+loop.run()
+
+# Stop the Plainbox dbus service
+service.Exit()

=== added file 'plainbox/docs/author/checkbox-job-format.rst'
--- plainbox/docs/author/checkbox-job-format.rst	1970-01-01 00:00:00 +0000
+++ plainbox/docs/author/checkbox-job-format.rst	2013-09-13 17:12:45 +0000
@@ -0,0 +1,168 @@
+===================================
+Checkbox job file format and fields
+===================================
+
+This file contains NO examples, this is on purpose since the jobs
+directory contains several hundred examples showcasing all the features
+described here.
+
+File format and location
+------------------------
+Jobs are expressed as sections in text files that conform somewhat to
+the rfc822 specification format. Each section defines a single job. The
+section is delimited with an empty newline. Within each section, each
+field starts with the field name, a colon, a space and then the field
+contents. Multiple-line fields can be input by having a newline right
+after the colon, and then entering text lines after that, each line
+should start with at least one space.
+
+Fields that can be used on a job
+--------------------------------
+:name:
+    (mandatory) - A name for the job. Should be unique, an error will
+    be generated if there are duplicates. Should contain characters in 
+    [a-z0-9/-].
+    
+:plugin:
+
+    (mandatory) - For historical reasons it's called "plugin" but it's
+    better thought of as describing the "type" of job. The allowed types
+    are:
+
+     :manual: jobs that require the user to perform an action and then
+          decide on the test's outcome.
+     :shell: jobs that run without user intervention and
+         automatically set the test's outcome.
+     :user-interact: jobs that require the user to perform an
+         interaction, after which the outcome is automatically set.
+     :user-verify: jobs that automatically perform an action or test
+         and then request the user to decide on the test's outcome.
+     :attachment: jobs whose command output will be attached to the
+         test report or submission.
+     :local: a job whose command output needs to be in :term:`CheckBox` job
+         format. Jobs output by a local job will be added to the set of
+         available jobs to be run.
+     :resource: A job whose command output results in a set of rfc822
+          records, containing key/value pairs, and that can be used in other
+          jobs' ``requires`` expressions.
+
+:requires:
+    (optional). If specified, the job will only run if the conditions
+    expressed in this field are met.
+
+    Conditions are of the form ``<resource>.<key> <comparison-operator>
+    'value' (and|or) ...`` . Comparison operators can be ==, != and ``in``.
+    Values to compare to can be scalars or (in the case of the ``in``
+    operator) arrays or tuples. The ``not in`` operator is explicitly
+    unsupported.
+    
+    Requirements can be logically chained with ``or`` and
+    ``and`` operators. They can also be placed in multiple lines,
+    respecting the rfc822 multi-line syntax, in which case all
+    requirements must be met for the job to run ( ``and`` ed).
+    
+    The :term:`PlainBox` resource program evaluator is extensively documented,
+    to see a detailed description including rationale and implementation of
+    :term:`CheckBox` "legacy" compatibility, see :ref:`Resources in Plainbox
+    <resources>`.
+
+:depends:
+    (optional). If specified, the job will only run if all the listed
+    jobs have run and passed. Multiple job names, separated by spaces,
+    can be specified.
+
+:command:
+    (optional). A command can be provided, to be executed under specific
+    circumstances. For ``manual``, ``user-interact`` and ``user-verify``
+    jobs, the command will be executed when the user presses a "test"
+    button present in the user interface. For ``shell`` jobs, the
+    command will be executed unconditionally as soon as the job is
+    started. In both cases the exit code from the command (0 for
+    success, !0 for failure) will be used to set the test's outcome. For
+    ``manual``, ``user-interact`` and ``user-verify`` jobs, the user can
+    override the command's outcome.  The command will be run using the
+    default system shell. If a specific shell is needed it should be
+    instantiated in the command. A multi-line command or shell script
+    can be used with the usual multi-line syntax.
+
+    Note that a ``shell`` job without a command will do nothing.
+
+:description:
+    (mandatory). Provides a textual description for the job. This is
+    mostly to aid people reading job descriptions in figuring out what a
+    job does. 
+    
+    The description field, however, is used specially in ``manual``,
+    ``user-interact`` and ``user-verify`` jobs. For these jobs, the
+    description will be shown in the user interface, and in these cases
+    it's expected to contain instructions for the user to follow, as
+    well as criteria for him to decide whether the job passes or fails.
+    For these types of jobs, the description needs to contain a few
+    sub-fields, in order:
+
+    :PURPOSE: This indicates the purpose or intent of the test.
+    :STEPS: A numbered list of steps for the user to follow.
+    :INFO:
+        (optional). Additional information about the test. This is
+        commonly used to present command output for the user to validate.
+        For this purpose, the ``$output`` substitution variable can be used
+        (actually, it can be used anywhere in the description). If present,
+        it will be replaced by the standard output generated from running
+        the job's command (commonly when the user presses the "Test"
+        button).
+    :VERIFICATION:
+        A question for the user to answer, deciding whether the test
+        passes or fails. The question should be phrased in such a way
+        that an answer of **Yes** means the test passed, and an answer of
+        **No** means it failed.
+:user:
+    (optional). If specified, the job will be run as the user specified
+    here. This is most commonly used to run jobs as the superuser
+    (root).
+
+:environ:
+    (optional). If specified, the listed environment variables
+    (separated by spaces) will be taken from the invoking environment
+    (i.e. the one :term:`CheckBox` is run under) and set to that value on the
+    job execution environment (i.e.  the one the job will run under).
+    Note that only the *variable names* should be listed, not the
+    *values*, which will be taken from the existing environment. This
+    only makes sense for jobs that also have the ``user`` attribute.
+    This key provides a mechanism to account for security policies in
+    ``sudo`` and ``pkexec``, which provide a sanitized execution
+    environment, with the downside that useful configuration specified
+    in environment variables may be lost in the process.
+
+:estimated_duration:
+    (optional) This field contains metadata about how long the job is
+    expected to run for, as a positive float value indicating
+    the estimated job duration in seconds.
+
+===========================
+Extension of the job format
+===========================
+
+The :term:`CheckBox` job format can be considered "extensible", in that
+additional keys can be added to existing jobs to contain additional
+data that may be needed.
+
+In order for these extra fields to be exposed through the API (i.e. as
+properties of JobDefinition instances), they need to be declared as
+properties in (:mod:`plainbox.impl.job`). This is a good place to document,
+via a docstring, what the field is for and how to interpret it.
+
+Implementation note: if additional fields are added, *:term:`CheckBox`* needs
+to be also told about them, the reason is that :term:`CheckBox` *does* perform
+validation of the job descriptions, ensuring they contain only known fields and
+that fields contain expected data types. The jobs_info plugin contains the job
+schema declaration and can be consulted to verify the known fields, whether
+they are optional or mandatory, and the type of data they're expected to
+contain.
+
+Also, :term:`CheckBox` validates that fields contain data of a specific type,
+so care must be taken not to simply change contents of fields if
+:term:`CheckBox` compatibility of jobs is desired.
+
+:term:`PlainBox` does this validation on a per-accessor basis, so data in each
+field must make sense as defined by that field's accessor. There is no need,
+however, to declare field type beforehand.

=== modified file 'plainbox/docs/author/index.rst'
--- plainbox/docs/author/index.rst	2013-03-25 16:40:57 +0000
+++ plainbox/docs/author/index.rst	2013-09-13 17:12:45 +0000
@@ -11,6 +11,9 @@
     is a guiding point for subsequent editions that will expand and provide
     real value.
 
+.. toctree::
+   checkbox-job-format.rst 
+
 Personas and stories
 --------------------
 

=== modified file 'plainbox/docs/dev/reference.rst'
--- plainbox/docs/dev/reference.rst	2013-05-14 09:04:30 +0000
+++ plainbox/docs/dev/reference.rst	2013-09-13 17:12:45 +0000
@@ -94,6 +94,11 @@
     :undoc-members:
     :show-inheritance:
 
+.. automodule:: plainbox.impl.exporter.html
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 .. automodule:: plainbox.impl.secure
     :members:
     :undoc-members:
@@ -144,11 +149,6 @@
     :undoc-members:
     :show-inheritance:
 
-.. automodule:: plainbox.impl.mock_job
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
 .. automodule:: plainbox.impl.resource
     :members:
     :undoc-members:
@@ -173,6 +173,43 @@
     :undoc-members:
     :show-inheritance:
 
+.. automodule:: plainbox.impl.session.state
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.jobs
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.storage
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.suspend
+    :members:
+    :undoc-members:
+    :private-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.resume
+    :members:
+    :undoc-members:
+    :private-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.legacy
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session.manager
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
 .. automodule:: plainbox.impl.testing_utils
     :members:
     :undoc-members:

=== modified file 'plainbox/docs/dev/resources.rst'
--- plainbox/docs/dev/resources.rst	2013-05-11 13:56:36 +0000
+++ plainbox/docs/dev/resources.rst	2013-09-13 17:12:45 +0000
@@ -1,3 +1,5 @@
+.. _resources:
+
 Resources
 =========
 

=== modified file 'plainbox/plainbox/abc.py'
--- plainbox/plainbox/abc.py	2013-02-25 11:02:58 +0000
+++ plainbox/plainbox/abc.py	2013-09-13 17:12:45 +0000
@@ -114,13 +114,46 @@
     # XXX: We could also store stuff like job duration and other meta-data but
     # I wanted to avoid polluting this proposal with mundane details
 
-    @abstractproperty
-    def job(self):
-        """
-        Definition of the job
+    # The outcome of a job is a one-word classification how how it ran.  There
+    # are several values that were not used in the original implementation but
+    # their existence helps to organize and implement plainbox. They are
+    # discussed below to make their intended meaning more detailed than is
+    # possible from the variable name alone.
+    #
+    # The None outcome - a job that basically did not run at all.
+    OUTCOME_NONE = None
+    # The pass and fail outcomes are the two most essential, and externally
+    # visible, job outcomes. They can be provided by either automated or manual
+    # "classifier" - a script or a person that clicks a "pass" or "fail"
+    # button.
+    OUTCOME_PASS = 'pass'
+    OUTCOME_FAIL = 'fail'
+    # The skip outcome is used when the operator selected a job but then
+    # skipped it. This is typically used for a manual job that is tedious or
+    # was selected by accident.
+    OUTCOME_SKIP = 'skip'
+    # The not supported outcome is used when a job was about to run but a
+    # dependency or resource requirement prevent it from running.  XXX: perhaps
+    # this should be called "not available", not supported has the "unsupported
+    # code" feeling associated with it.
+    OUTCOME_NOT_SUPPORTED = 'not-supported'
+    # A temporary state that should be removed later on, used to indicate that
+    # job runner is not implemented but the job "ran" so to speak.
+    OUTCOME_NOT_IMPLEMENTED = 'not-implemented'
+    # A temporary state before the user decides on the outcome of a manual
+    # job or any other job that requires manual verification
+    OUTCOME_UNDECIDED = 'undecided'
 
-        The object implements IJobDefinition
-        """
+    # List of all valid values of OUTCOME_xxx
+    ALL_OUTCOME_LIST = [
+        OUTCOME_NONE,
+        OUTCOME_PASS,
+        OUTCOME_FAIL,
+        OUTCOME_SKIP,
+        OUTCOME_NOT_SUPPORTED,
+        OUTCOME_NOT_IMPLEMENTED,
+        OUTCOME_UNDECIDED,
+    ]
 
     @abstractproperty
     def outcome(self):
@@ -204,3 +237,79 @@
         May raise NotImplementedError if the user interface cannot provide this
         answer.
         """
+
+
+class IProviderBackend1(metaclass=ABCMeta):
+    """
+    Provider for the current type of tests.
+
+    This class provides the APIs required by the internal implementation
+    that are not considered normal public APIs. The only consumer of the
+    those methods and properties are internal to plainbox.
+    """
+
+    @abstractproperty
+    def CHECKBOX_SHARE(self):
+        """
+        Return the required value of CHECKBOX_SHARE environment variable.
+
+        .. note::
+            This variable is only required by one script.
+            It would be nice to remove this later on.
+        """
+
+    @abstractproperty
+    def extra_PYTHONPATH(self):
+        """
+        Return additional entry for PYTHONPATH, if needed.
+
+        This entry is required for CheckBox scripts to import the correct
+        CheckBox python libraries.
+
+        .. note::
+            The result may be None
+        """
+
+    @abstractproperty
+    def extra_PATH(self):
+        """
+        Return additional entry for PATH
+
+        This entry is required to lookup CheckBox scripts.
+        """
+
+
+class IProvider1(metaclass=ABCMeta):
+    """
+    Provider for the current type of tests
+
+    Also known as the 'checkbox-like' provider.
+    """
+
+    @abstractproperty
+    def name(self):
+        """
+        name of this provider
+
+        This name should be dbus-friendly. It should not be localizable.
+        """
+
+    @abstractproperty
+    def description(self):
+        """
+        description of this providr
+
+        This name should be dbus-friendly. It should not be localizable.
+        """
+
+    @abstractmethod
+    def get_builtin_jobs(self):
+        """
+        Load all the built-in jobs and return them
+        """
+
+    @abstractmethod
+    def get_builtin_whitelists(self):
+        """
+        Load all the built-in whitelists and return them
+        """

=== added file 'plainbox/plainbox/data/report/checkbox.js'
--- plainbox/plainbox/data/report/checkbox.js	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/data/report/checkbox.js	2013-09-13 17:12:45 +0000
@@ -0,0 +1,16 @@
+function showHide(what) {
+    var heading = document.getElementById(what);
+    var contents = document.getElementById(what + "-contents");
+    var headingcontents = heading.innerHTML;
+    var newcontents;
+
+    if (contents.style.display != "block") {
+        newcontents = headingcontents.replace("closed", "open");
+        contents.style.display = "block";
+    } else {
+        newcontents = headingcontents.replace("open", "closed");
+        contents.style.display = "none";
+    }
+
+    heading.innerHTML = newcontents;
+}

=== added directory 'plainbox/plainbox/data/report/images'
=== added file 'plainbox/plainbox/data/report/images/body_bg.png'
Binary files plainbox/plainbox/data/report/images/body_bg.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/body_bg.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/bullet.png'
Binary files plainbox/plainbox/data/report/images/bullet.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/bullet.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/closed.png'
Binary files plainbox/plainbox/data/report/images/closed.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/closed.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/fail.png'
Binary files plainbox/plainbox/data/report/images/fail.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/fail.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/header_bg.png'
Binary files plainbox/plainbox/data/report/images/header_bg.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/header_bg.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/open.png'
Binary files plainbox/plainbox/data/report/images/open.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/open.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/pass.png'
Binary files plainbox/plainbox/data/report/images/pass.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/pass.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/images/skip.png'
Binary files plainbox/plainbox/data/report/images/skip.png	1970-01-01 00:00:00 +0000 and plainbox/plainbox/data/report/images/skip.png	2013-09-13 17:12:45 +0000 differ
=== added file 'plainbox/plainbox/data/report/styles.css'
--- plainbox/plainbox/data/report/styles.css	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/data/report/styles.css	2013-09-13 17:12:45 +0000
@@ -0,0 +1,258 @@
+body {
+    font-family: "Ubuntu Beta", "Bitstream Vera Sans", DejaVu Sans, Tahoma, sans-serif;
+    color: #333;
+    background: white url(report/images/body_bg.png);
+    font-size: 12px;
+    line-height: 14px;
+    margin: 0px;
+    padding: 0px;
+}
+#container {
+    background: #f7f6f5;
+    margin: 0px auto 20px;
+    padding: 0px;
+    width: 976px;
+}
+#container-inner {
+    background-color: #dfdcd9;
+}
+#header, #container-inner {
+    -moz-border-radius: 0px 0px 5px 5px;
+    -webkit-border-bottom-left-radius: 5px;
+    -webkit-border-bottom-right-radius: 5px;
+    -moz-box-shadow: #bbb 0px 0px 5px;
+    -webkit-box-shadow: #bbb 0px 0px 5px;
+}
+#header {
+    background: #dd4814 url(report/images/header_bg.png) top left repeat-x;
+    height: 64px;
+    margin: 0px;
+    padding: 0px;
+    position: relative;
+}
+
+#menu-search {
+    height: 40px;
+    margin: 0 16px;
+}
+
+#title {
+    padding: 28px 24px;
+}
+
+#content {
+    /*padding: 32px 80px 32px 80px;*/
+    padding: 32px 240px 32px 160px;
+    margin: 0 16px 16px;
+    width: 544px;
+    background-color: #fff;
+    -moz-border-radius: 4px;
+    -webkit-border-radius: 4px;
+}
+#end-content {
+    clear: both;
+}
+
+#content-panel {
+    width: 446px;
+    margin: 0px 0px 0px 0px;
+    padding: 8px 8px 32px 8px;
+    background-color: #fff;
+    -moz-border-radius: 4px;
+    -webkit-border-radius: 4px;
+}
+
+#copyright {
+    background-position: 803px 40px;
+    background-repeat: no-repeat;
+    text-align: center;
+    margin: 0 16px;
+    padding: 40px 0 0 0;
+    height: 32px;
+}
+#copyright p {
+    color: #aea79f;
+    font-size: 10px;
+    line-height: 14px;
+    margin: 2px 0;
+}
+
+#footer {
+    padding-top: 16px;
+}
+#footer * {
+    font-size: 10px;
+    line-height: 14px;
+}
+#footer p {
+    margin: 0;
+    padding-bottom: 3px;
+    border-bottom: 1px dotted #aea79f;
+}
+#footer p.footer-title {
+    font-weight: bold;
+}
+#footer .footer-div {
+    width: 144px;
+    float: left;
+    margin-left: 16px;
+}
+#footer .last-div {
+    margin-right: 16px;
+}
+#footer ul {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+#footer li {
+    margin: 0;
+    padding: 3px 0;
+    border-bottom: 1px dotted #aea79f;
+}
+
+h1, h2, h3, h4, h5 {
+    padding: 0;
+    margin: 0;
+    font-weight: normal;
+}
+h1 {
+    font-size: 36px;
+    line-height: 40px;
+    color: #dd4814;
+}
+h2 {
+    font-size: 24px;
+    line-height: 28px;
+    margin-bottom: 8px;
+}
+h3 {
+    font-size: 16px;
+    line-height: 20px;
+    margin-bottom: 8px;
+}
+h3.link-other {
+    color: #333;
+}
+h3.link-services {
+    color: #fff;
+}
+h4 {
+    font-size: 12px;
+    line-height: 14px;
+}
+h4.partners {
+    color: #333;
+    font-size: 16px;
+    line-height: 20px;
+}
+h5 {
+    color: #333;
+    font-size: 10px;
+    line-height: 14px;
+}
+h1 span.grey, h2 span.grey, h1 span, h2 span{
+    color: #aea79f;
+}
+p {
+    font-size: 12px;
+    line-height: 14px;
+    margin-bottom: 8px;
+}
+strong {
+    font-weight: bold;
+}
+
+a {
+    color: #333;
+    text-decoration: none;
+}
+a:hover {
+    color: #dd4814;
+    text-decoration: underline;
+}
+div.footer-div:hover a, div#content:hover a {
+    color: #dd4814;
+    text-decoration: none;
+}
+div.footer-div:hover a:hover, div#content:hover a:hover {
+    color: #dd4814;
+    text-decoration: underline;
+}
+
+ul {
+    margin-bottom: 16px;
+    list-style-image: url(report/images/bullet.png);
+}
+ul li {
+    margin-bottom: 8px;
+    line-height: 14px;
+}
+ul li:last-child {
+    margin-bottom: 0px;
+}
+
+p.call-to-action {
+    color: #333;
+}
+p.case-study {
+    color: #333;
+}
+p.highlight {
+    font-size: 16px;
+    line-height: 20px;
+}
+p.introduction {
+    color: #333;
+    font-size: 16px;
+    line-height: 20px;
+}
+p.services {
+    color: #fff;
+}
+p.small-text {
+    color: #333;
+    font-size: 10px;
+}
+
+/* Clearing floats without extra markup
+Based on How To Clear Floats Without Structural Markup by PiE
+[http://www.positioniseverything.net/easyclearing.html] */
+.clearfix:after {
+    content: ".";
+    display: block;
+    height: 0;
+    clear: both;
+    visibility: hidden;
+}
+.clearfix {
+    -moz-border-radius: 5px 5px 5px 5px;
+    -webkit-border-bottom-top-radius: 5px;
+    -webkit-border-bottom-left-radius: 5px;
+    -webkit-border-bottom-bottom-radius: 5px;
+    -webkit-border-bottom-right-radius: 5px;
+    -moz-box-shadow: #bbb 0px 0px 5px;
+    -webkit-box-shadow: #bbb 0px 0px 5px;
+    display: inline-block;
+}  /* for IE/Mac */
+td
+{
+    margin: 0;
+    padding-bottom: 3px;
+    border-bottom: 1px dotted #aea79f;
+    font-size: 10px;
+    line-height: 14px;
+}
+.resultimg
+{
+    height: 12px;
+}
+.disclosureimg
+{
+	height:		.75em;
+	vertical-align:	middle;
+}
+.data
+{
+	display:	none;
+}

=== modified file 'plainbox/plainbox/impl/applogic.py'
--- plainbox/plainbox/impl/applogic.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/applogic.py	2013-09-13 17:12:45 +0000
@@ -30,8 +30,9 @@
 import os
 import re
 
+from plainbox.abc import IJobResult
 from plainbox.impl import config
-from plainbox.impl.result import JobResult
+from plainbox.impl.result import MemoryJobResult
 
 
 class IJobQualifier(metaclass=ABCMeta):
@@ -66,6 +67,13 @@
         self._pattern = re.compile(pattern)
         self._pattern_text = pattern
 
+    @property
+    def pattern_text(self):
+        """
+        text of the regular expression embedded in this qualifier
+        """
+        return self._pattern_text
+
     def designates(self, job):
         return self._pattern.match(job.name)
 
@@ -113,6 +121,86 @@
         return False
 
 
+# NOTE: using CompositeQualifier seems strange but it's a tested proven
+# component so all we have to ensure is that we read the whitelist files
+# correctly.
+class WhiteList(CompositeQualifier):
+    """
+    A qualifier that understands checkbox whitelist files.
+
+    A whitelist file is a plain text, line oriented file. Each line represents
+    a regular expression pattern that can be matched against the name of a job.
+
+    The file can contain simple shell-style comments that begin with the pound
+    or hash key (#). Those are ignored. Comments can span both a fraction of a
+    line as well as the whole line.
+
+    For historical reasons each pattern has an implicit '^' and '$' prepended
+    and appended (respectively) to the actual pattern specified in the file.
+    """
+
+    def __init__(self, pattern_list, name=None):
+        """
+        Initialize a whitelist object with the specified list of patterns.
+
+        The patterns must be already mangled with '^' and '$'.
+        """
+        inclusive = [RegExpJobQualifier(pattern) for pattern in pattern_list]
+        exclusive = ()
+        super(WhiteList, self).__init__(inclusive, exclusive)
+        self._name = name
+
+    def __repr__(self):
+        return "<{} name:{!r}>".format(self.__class__.__name__, self.name)
+
+    @property
+    def name(self):
+        """
+        name of this WhiteList (might be None)
+        """
+        return self._name
+
+    @classmethod
+    def from_file(cls, pathname):
+        """
+        Load and initialize the WhiteList object from the specified file.
+
+        :param pathname: file to load
+        :returns: a fresh WhiteList object
+        """
+        pattern_list = cls._load_patterns(pathname)
+        name = os.path.splitext(os.path.basename(pathname))[0]
+        return cls(pattern_list, name=name)
+
+    @classmethod
+    def _load_patterns(self, pathname):
+        """
+        Load whitelist patterns from the specified file
+        """
+        pattern_list = []
+        # Load the file
+        with open(pathname, "rt", encoding="UTF-8") as stream:
+            for line in stream:
+                # Strip shell-style comments if there are any
+                try:
+                    index = line.index("#")
+                except ValueError:
+                    pass
+                else:
+                    line = line[:index]
+                # Strip whitespace
+                line = line.strip()
+                # Skip empty lines (especially after stripping comments)
+                if line == "":
+                    continue
+                # Surround the pattern with ^ and $
+                # so that it wont just match a part of the job name.
+                regexp_pattern = r"^{pattern}$".format(pattern=line)
+                # Accumulate patterns into the list
+                pattern_list.append(regexp_pattern)
+        return pattern_list
+
+
 def get_matching_job_list(job_list, qualifier):
     """
     Get a list of jobs that are designated by the specified qualifier.
@@ -137,16 +225,15 @@
         # OUTCOME_NOT_SUPPORTED _except_ if any of the inhibitors point to
         # a job with an OUTCOME_SKIP outcome, if that is the case mirror
         # that outcome. This makes 'skip' stronger than 'not-supported'
-        outcome = JobResult.OUTCOME_NOT_SUPPORTED
+        outcome = IJobResult.OUTCOME_NOT_SUPPORTED
         for inhibitor in job_state.readiness_inhibitor_list:
             if inhibitor.cause != inhibitor.FAILED_DEP:
                 continue
             related_job_state = session.job_state_map[
                 inhibitor.related_job.name]
-            if related_job_state.result.outcome == JobResult.OUTCOME_SKIP:
-                outcome = JobResult.OUTCOME_SKIP
-        job_result = JobResult({
-            'job': job,
+            if related_job_state.result.outcome == IJobResult.OUTCOME_SKIP:
+                outcome = IJobResult.OUTCOME_SKIP
+        job_result = MemoryJobResult({
             'outcome': outcome,
             'comments': job_state.get_readiness_description()
         })
@@ -177,9 +264,20 @@
         section="sru",
         help_text="Location of the fallback file")
 
+    whitelist = config.Variable(
+        section="sru",
+        help_text="Optional whitelist with which to run SRU testing")
+
     environment = config.Section(
         help_text="Environment variables for scripts and jobs")
 
+    default_provider = config.Variable(
+        section="common",
+        help_text="Name of the default provider to use",
+        validator_list=[
+            config.ChoiceValidator(['auto', 'src', 'deb', 'stub', 'ihv'])],
+        default="auto")
+
     class Meta:
 
         # TODO: properly depend on xdg and use real code that also handles

=== modified file 'plainbox/plainbox/impl/box.py'
--- plainbox/plainbox/impl/box.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/box.py	2013-09-13 17:12:45 +0000
@@ -26,55 +26,28 @@
     THIS MODULE DOES NOT HAVE STABLE PUBLIC API
 """
 
-import argparse
-import errno
 import logging
-import pdb
-import sys
 
 from plainbox import __version__ as version
 from plainbox.impl.applogic import PlainBoxConfig
-from plainbox.impl.checkbox import CheckBox
+from plainbox.impl.commands import PlainBoxToolBase
 from plainbox.impl.commands.check_config import CheckConfigCommand
 from plainbox.impl.commands.dev import DevCommand
 from plainbox.impl.commands.run import RunCommand
 from plainbox.impl.commands.selftest import SelfTestCommand
+from plainbox.impl.commands.service import ServiceCommand
 from plainbox.impl.commands.sru import SRUCommand
-from plainbox.impl.logging import setup_logging, adjust_logging
+from plainbox.impl.logging import setup_logging
 
 
 logger = logging.getLogger("plainbox.box")
 
 
-class PlainBox:
+class PlainBoxTool(PlainBoxToolBase):
     """
     Command line interface to PlainBox
     """
 
-    def __init__(self):
-        """
-        Initialize all the variables, real stuff happens in main()
-        """
-        self._early_parser = None  # set in _early_init()
-        self._config = None  # set in _late_init()
-        self._checkbox = None  # set in _late_init()
-        self._parser = None  # set in _late_init()
-
-    def main(self, argv=None):
-        """
-        Run as if invoked from command line directly
-        """
-        self.early_init()
-        early_ns = self._early_parser.parse_args(argv)
-        self.late_init(early_ns)
-        logger.debug("parsed early namespace: %s", early_ns)
-        # parse the full command line arguments, this is also where we
-        # do argcomplete-dictated exit if bash shell completion is requested
-        ns = self._parser.parse_args(argv)
-        logger.debug("parsed full namespace: %s", ns)
-        self.final_init(ns)
-        return self.dispatch_and_catch_exceptions(ns)
-
     @classmethod
     def get_config_cls(cls):
         """
@@ -107,221 +80,17 @@
         top-level subcommands.
         """
         # TODO: switch to plainbox plugins
-        RunCommand(self._checkbox).register_parser(subparsers)
+        RunCommand(self._provider).register_parser(subparsers)
         SelfTestCommand().register_parser(subparsers)
-        SRUCommand(self._checkbox, self._config).register_parser(subparsers)
+        SRUCommand(self._provider, self._config).register_parser(subparsers)
         CheckConfigCommand(self._config).register_parser(subparsers)
-        DevCommand(self._checkbox, self._config).register_parser(subparsers)
-
-    def early_init(self):
-        """
-        Do very early initialization. This is where we initalize stuff even
-        without seeing a shred of command line data or anything else.
-        """
-        self._early_parser = self.construct_early_parser()
-
-    def late_init(self, early_ns):
-        """
-        Initialize with early command line arguments being already parsed
-        """
-        adjust_logging(
-            level=early_ns.log_level, trace_list=early_ns.trace,
-            debug_console=early_ns.debug_console)
-        # Load plainbox configuration
-        self._config = self.get_config_cls().get()
-        # Load and initialize checkbox provider
-        # TODO: rename to provider, switch to plugins
-        self._checkbox = CheckBox(
-            mode=None if early_ns.checkbox == 'auto' else early_ns.checkbox)
-        # Construct the full command line argument parser
-        self._parser = self.construct_parser()
-
-    def final_init(self, ns):
-        """
-        Do some final initialization just before the command gets
-        dispatched. This is empty here but maybe useful for subclasses.
-        """
-
-    def construct_early_parser(self):
-        """
-        Create a parser that captures some of the early data we need to
-        be able to have a real parser and initialize the rest.
-        """
-        parser = argparse.ArgumentParser(add_help=False)
-        # Fake --help and --version
-        parser.add_argument("-h", "--help", action="store_const", const=None)
-        parser.add_argument("--version", action="store_const", const=None)
-        self.add_early_parser_arguments(parser)
-        # A catch-all net for everything else
-        parser.add_argument("rest", nargs="...")
-        return parser
-
-    def construct_parser(self):
-        parser = argparse.ArgumentParser(prog=self.get_exec_name())
-        parser.add_argument(
-            "--version", action="version", version=self.get_exec_version())
-        # Add all the things really parsed by the early parser so that it
-        # shows up in --help and bash tab completion.
-        self.add_early_parser_arguments(parser)
-        subparsers = parser.add_subparsers()
-        self.add_subcommands(subparsers)
-        # Enable argcomplete if it is available.
-        try:
-            import argcomplete
-        except ImportError:
-            pass
-        else:
-            argcomplete.autocomplete(parser)
-        return parser
-
-    def add_early_parser_arguments(self, parser):
-        # Since we need a CheckBox instance to create the main argument parser
-        # and we need to be able to specify where Checkbox is, we parse that
-        # option alone before parsing everything else
-        # TODO: rename this to -p | --provider
-        parser.add_argument(
-            '-c', '--checkbox',
-            action='store',
-            # TODO: have some public API for this, pretty please
-            choices=list(CheckBox._DIRECTORY_MAP.keys()) + ['auto'],
-            default='auto',
-            help="where to find the installation of CheckBox.")
-        group = parser.add_argument_group(
-            title="logging and debugging")
-        # Add the --log-level argument
-        group.add_argument(
-            "-l", "--log-level",
-            action="store",
-            choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'),
-            default=None,
-            help=argparse.SUPPRESS)
-        # Add the --verbose argument
-        group.add_argument(
-            "-v", "--verbose",
-            dest="log_level",
-            action="store_const",
-            const="INFO",
-            help="be more verbose (same as --log-level=INFO)")
-        # Add the --debug flag
-        group.add_argument(
-            "-D", "--debug",
-            dest="log_level",
-            action="store_const",
-            const="DEBUG",
-            help="enable DEBUG messages on the root logger")
-        # Add the --debug flag
-        group.add_argument(
-            "-C", "--debug-console",
-            action="store_true",
-            help="display DEBUG messages in the console")
-        # Add the --trace flag
-        group.add_argument(
-            "-T", "--trace",
-            metavar="LOGGER",
-            action="append",
-            default=[],
-            help=("enable DEBUG messages on the specified logger "
-                  "(can be used multiple times)"))
-        # Add the --pdb flag
-        group.add_argument(
-            "-P", "--pdb",
-            action="store_true",
-            default=False,
-            help="jump into pdb (python debugger) when a command crashes")
-        # Add the --debug-interrupt flag
-        group.add_argument(
-            "-I", "--debug-interrupt",
-            action="store_true",
-            default=False,
-            help="crash on SIGINT/KeyboardInterrupt, useful with --pdb")
-
-    def dispatch_command(self, ns):
-        # Argh the horrror!
-        #
-        # Since CPython revision cab204a79e09 (landed for python3.3)
-        # http://hg.python.org/cpython/diff/cab204a79e09/Lib/argparse.py
-        # the argparse module behaves differently than it did in python3.2
-        #
-        # In practical terms subparsers are now optional in 3.3 so all of the
-        # commands are no longer required parameters.
-        #
-        # To compensate, on python3.3 and beyond, when the user just runs
-        # plainbox without specifying the command, we manually, explicitly do
-        # what python3.2 did: call parser.error(_('too few arguments'))
-        if (sys.version_info[:2] >= (3, 3)
-                and getattr(ns, "command", None) is None):
-            self._parser.error(argparse._("too few arguments"))
-        else:
-            return ns.command.invoked(ns)
-
-    def dispatch_and_catch_exceptions(self, ns):
-        try:
-            return self.dispatch_command(ns)
-        except SystemExit:
-            # Don't let SystemExit be caught in the logic below, we really
-            # just want to exit when that gets thrown.
-            logger.debug("caught SystemExit, exiting")
-            # We may want to raise SystemExit as it can carry a status code
-            # along and we cannot just consume that.
-            raise
-        except BaseException as exc:
-            logger.debug("caught %r, deciding on what to do next", exc)
-            # For all other exceptions (and I mean all), do a few checks
-            # and perform actions depending on the command line arguments
-            # By default we want to re-raise the exception
-            action = 'raise'
-            # We want to ignore IOErrors that are really EPIPE
-            if isinstance(exc, IOError):
-                if exc.errno == errno.EPIPE:
-                    action = 'ignore'
-            # We want to ignore KeyboardInterrupt unless --debug-interrupt
-            # was passed on command line
-            elif isinstance(exc, KeyboardInterrupt):
-                if ns.debug_interrupt:
-                    action = 'debug'
-                else:
-                    action = 'ignore'
-            else:
-                # For all other execptions, debug if requested
-                if ns.pdb:
-                    action = 'debug'
-            logger.debug("action for exception %r is %s", exc, action)
-            if action == 'ignore':
-                return 0
-            elif action == 'raise':
-                logging.getLogger("plainbox.crashes").fatal(
-                    "Executable %r invoked with %r has crashed",
-                    self.get_exec_name(), ns, exc_info=1)
-                raise
-            elif action == 'debug':
-                logger.error("caught runaway exception: %r", exc)
-                logger.error("starting debugger...")
-                pdb.post_mortem()
-                return 1
+        DevCommand(self._provider, self._config).register_parser(subparsers)
+        ServiceCommand(self._provider, self._config).register_parser(
+            subparsers)
 
 
 def main(argv=None):
-    # Another try/catch block for catching KeyboardInterrupt
-    # This one is really only meant for the early init abort
-    # (when someone runs main but bails out before we really
-    # get to the point when we do something useful and setup
-    # all the exception handlers).
-    try:
-        raise SystemExit(PlainBox().main(argv))
-    except KeyboardInterrupt:
-        pass
-
-
-def get_builtin_jobs():
-    raise NotImplementedError("get_builtin_jobs() not implemented")
-
-
-def save(something, somewhere):
-    raise NotImplementedError("save() not implemented")
-
-
-def run(*args, **kwargs):
-    raise NotImplementedError("run() not implemented")
+    raise SystemExit(PlainBoxTool().main(argv))
 
 
 # Setup logging before anything else starts working.

=== modified file 'plainbox/plainbox/impl/commands/__init__.py'
--- plainbox/plainbox/impl/commands/__init__.py	2013-02-25 11:02:58 +0000
+++ plainbox/plainbox/impl/commands/__init__.py	2013-09-13 17:12:45 +0000
@@ -27,11 +27,26 @@
 """
 
 from abc import abstractmethod, ABCMeta
+import argparse
+import errno
+import logging
+import pdb
+import sys
+
+from plainbox.impl.logging import adjust_logging
+from plainbox.impl.providers.v1 import all_providers
+
+
+logger = logging.getLogger("plainbox.commands")
 
 
 class PlainBoxCommand(metaclass=ABCMeta):
     """
-    Simple interface class for plainbox commands
+    Simple interface class for plainbox commands.
+
+    Command objects like this are consumed by PlainBoxTool subclasses to
+    implement hierarchical command system. The API supports arbitrary
+    many sub commands in arbitrary nesting arrangement.
     """
 
     @abstractmethod
@@ -49,3 +64,309 @@
         command. The subparsers argument is the return value of
         ArgumentParser.add_subparsers()
         """
+
+
+class PlainBoxToolBase(metaclass=ABCMeta):
+    """
+    Base class for implementing commands like 'plainbox'.
+
+    The tools support a variety of sub-commands, logging and debugging
+    support. If argcomplete module is available and used properly in
+    the shell then advanced tab-completion is also available.
+
+    There are three methods to implement for a basic tool. Those are:
+
+    1. :meth:`get_config_cls()` -- to know which config to use
+    2. :meth:`get_exec_name()` -- to know how the command will be called
+    3. :meth:`add_subcommands()` -- to add some actual commands to execute
+
+    This class has some complex control flow to support important
+    and interesting use cases. There are some concerns to people
+    that subclass this in order to implement their own command line tools.
+
+    The first concern is that input is parsed with two parsers, the early
+    parser and the full parser. The early parser quickly checks for a fraction
+    of supported arguments and uses that data to initialize environment
+    before construction of a full parser is possible. The full parser
+    sees the reminder of the input and does not re-parse things that where
+    already handled.
+
+    The second concern is that this command natively supports the concept
+    of a config object and a provider object. This may not be desired by
+    all users but it is the current state as of this writing. This means
+    that by the time eary init is done we have a known provider and config
+    objects that can be used to instantiate command objects
+    in :meth:`add_subcommands()`. This API might change when full
+    multi-provider is available but details are not known yet.
+    """
+
+    def __init__(self):
+        """
+        Initialize all the variables, real stuff happens in main()
+        """
+        self._early_parser = None  # set in _early_init()
+        self._config = None  # set in _late_init()
+        self._provider = None  # set in _late_init()
+        self._parser = None  # set in _late_init()
+
+    def main(self, argv=None):
+        """
+        Run as if invoked from command line directly
+        """
+        # Another try/catch block for catching KeyboardInterrupt
+        # This one is really only meant for the early init abort
+        # (when someone runs main but bails out before we really
+        # get to the point when we do something useful and setup
+        # all the exception handlers).
+        try:
+            self.early_init()
+            early_ns = self._early_parser.parse_args(argv)
+            self.late_init(early_ns)
+            logger.debug("parsed early namespace: %s", early_ns)
+            # parse the full command line arguments, this is also where we
+            # do argcomplete-dictated exit if bash shell completion
+            # is requested
+            ns = self._parser.parse_args(argv)
+            logger.debug("parsed full namespace: %s", ns)
+            self.final_init(ns)
+        except KeyboardInterrupt:
+            pass
+        else:
+            return self.dispatch_and_catch_exceptions(ns)
+
+    @classmethod
+    @abstractmethod
+    def get_config_cls(cls):
+        """
+        Get the Config class that is used by this implementation.
+
+        This can be overriden by subclasses to use a different config class
+        that is suitable for the particular application.
+        """
+
+    @classmethod
+    @abstractmethod
+    def get_exec_name(cls):
+        """
+        Get the name of this executable
+        """
+
+    @classmethod
+    @abstractmethod
+    def get_exec_version(cls):
+        """
+        Get the version reported by this executable
+        """
+
+    @abstractmethod
+    def add_subcommands(self, subparsers):
+        """
+        Add top-level subcommands to the argument parser.
+
+        This can be overriden by subclasses to use a different set of
+        top-level subcommands.
+        """
+
+    def early_init(self):
+        """
+        Do very early initialization. This is where we initalize stuff even
+        without seeing a shred of command line data or anything else.
+        """
+        self._early_parser = self.construct_early_parser()
+
+    def late_init(self, early_ns):
+        """
+        Initialize with early command line arguments being already parsed
+        """
+        adjust_logging(
+            level=early_ns.log_level, trace_list=early_ns.trace,
+            debug_console=early_ns.debug_console)
+        # Load plainbox configuration
+        self._config = self.get_config_cls().get()
+        # Load and initialize checkbox provider
+        # TODO: rename to provider, switch to plugins
+        all_providers.load()
+        # If the default value of 'None' was set for the checkbox (provider)
+        # argument then load the actual provider name from the configuration
+        # object (default for that is 'auto').
+        if early_ns.checkbox is None:
+            early_ns.checkbox = self._config.default_provider
+        assert early_ns.checkbox in ('auto', 'src', 'deb', 'stub', 'ihv')
+        if early_ns.checkbox == 'auto':
+            provider_name = 'checkbox-auto'
+        elif early_ns.checkbox == 'src':
+            provider_name = 'checkbox-src'
+        elif early_ns.checkbox == 'deb':
+            provider_name = 'checkbox-deb'
+        elif early_ns.checkbox == 'stub':
+            provider_name = 'stubbox'
+        elif early_ns.checkbox == 'ihv':
+            provider_name = 'ihv'
+        self._provider = all_providers.get_by_name(
+            provider_name).plugin_object()
+        # Construct the full command line argument parser
+        self._parser = self.construct_parser()
+
+    def final_init(self, ns):
+        """
+        Do some final initialization just before the command gets
+        dispatched. This is empty here but maybe useful for subclasses.
+        """
+
+    def construct_early_parser(self):
+        """
+        Create a parser that captures some of the early data we need to
+        be able to have a real parser and initialize the rest.
+        """
+        parser = argparse.ArgumentParser(add_help=False)
+        # Fake --help and --version
+        parser.add_argument("-h", "--help", action="store_const", const=None)
+        parser.add_argument("--version", action="store_const", const=None)
+        self.add_early_parser_arguments(parser)
+        # A catch-all net for everything else
+        parser.add_argument("rest", nargs="...")
+        return parser
+
+    def construct_parser(self):
+        parser = argparse.ArgumentParser(prog=self.get_exec_name())
+        parser.add_argument(
+            "--version", action="version", version=self.get_exec_version())
+        # Add all the things really parsed by the early parser so that it
+        # shows up in --help and bash tab completion.
+        self.add_early_parser_arguments(parser)
+        subparsers = parser.add_subparsers()
+        self.add_subcommands(subparsers)
+        # Enable argcomplete if it is available.
+        try:
+            import argcomplete
+        except ImportError:
+            pass
+        else:
+            argcomplete.autocomplete(parser)
+        return parser
+
+    def add_early_parser_arguments(self, parser):
+        # Since we need a CheckBox instance to create the main argument parser
+        # and we need to be able to specify where Checkbox is, we parse that
+        # option alone before parsing everything else
+        # TODO: rename this to -p | --provider
+        parser.add_argument(
+            '-c', '--checkbox',
+            action='store',
+            # TODO: have some public API for this, pretty please
+            choices=['src', 'deb', 'auto', 'stub', 'ihv'],
+            # None is a special value that means 'use whatever configured'
+            default=None,
+            help="where to find the installation of CheckBox.")
+        group = parser.add_argument_group(
+            title="logging and debugging")
+        # Add the --log-level argument
+        group.add_argument(
+            "-l", "--log-level",
+            action="store",
+            choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'),
+            default=None,
+            help=argparse.SUPPRESS)
+        # Add the --verbose argument
+        group.add_argument(
+            "-v", "--verbose",
+            dest="log_level",
+            action="store_const",
+            const="INFO",
+            help="be more verbose (same as --log-level=INFO)")
+        # Add the --debug flag
+        group.add_argument(
+            "-D", "--debug",
+            dest="log_level",
+            action="store_const",
+            const="DEBUG",
+            help="enable DEBUG messages on the root logger")
+        # Add the --debug flag
+        group.add_argument(
+            "-C", "--debug-console",
+            action="store_true",
+            help="display DEBUG messages in the console")
+        # Add the --trace flag
+        group.add_argument(
+            "-T", "--trace",
+            metavar="LOGGER",
+            action="append",
+            default=[],
+            help=("enable DEBUG messages on the specified logger "
+                  "(can be used multiple times)"))
+        # Add the --pdb flag
+        group.add_argument(
+            "-P", "--pdb",
+            action="store_true",
+            default=False,
+            help="jump into pdb (python debugger) when a command crashes")
+        # Add the --debug-interrupt flag
+        group.add_argument(
+            "-I", "--debug-interrupt",
+            action="store_true",
+            default=False,
+            help="crash on SIGINT/KeyboardInterrupt, useful with --pdb")
+
+    def dispatch_command(self, ns):
+        # Argh the horrror!
+        #
+        # Since CPython revision cab204a79e09 (landed for python3.3)
+        # http://hg.python.org/cpython/diff/cab204a79e09/Lib/argparse.py
+        # the argparse module behaves differently than it did in python3.2
+        #
+        # In practical terms subparsers are now optional in 3.3 so all of the
+        # commands are no longer required parameters.
+        #
+        # To compensate, on python3.3 and beyond, when the user just runs
+        # plainbox without specifying the command, we manually, explicitly do
+        # what python3.2 did: call parser.error(_('too few arguments'))
+        if (sys.version_info[:2] >= (3, 3)
+                and getattr(ns, "command", None) is None):
+            self._parser.error(argparse._("too few arguments"))
+        else:
+            return ns.command.invoked(ns)
+
+    def dispatch_and_catch_exceptions(self, ns):
+        try:
+            return self.dispatch_command(ns)
+        except SystemExit:
+            # Don't let SystemExit be caught in the logic below, we really
+            # just want to exit when that gets thrown.
+            logger.debug("caught SystemExit, exiting")
+            # We may want to raise SystemExit as it can carry a status code
+            # along and we cannot just consume that.
+            raise
+        except BaseException as exc:
+            logger.debug("caught %r, deciding on what to do next", exc)
+            # For all other exceptions (and I mean all), do a few checks
+            # and perform actions depending on the command line arguments
+            # By default we want to re-raise the exception
+            action = 'raise'
+            # We want to ignore IOErrors that are really EPIPE
+            if isinstance(exc, IOError):
+                if exc.errno == errno.EPIPE:
+                    action = 'ignore'
+            # We want to ignore KeyboardInterrupt unless --debug-interrupt
+            # was passed on command line
+            elif isinstance(exc, KeyboardInterrupt):
+                if ns.debug_interrupt:
+                    action = 'debug'
+                else:
+                    action = 'ignore'
+            else:
+                # For all other execptions, debug if requested
+                if ns.pdb:
+                    action = 'debug'
+            logger.debug("action for exception %r is %s", exc, action)
+            if action == 'ignore':
+                return 0
+            elif action == 'raise':
+                logging.getLogger("plainbox.crashes").fatal(
+                    "Executable %r invoked with %r has crashed",
+                    self.get_exec_name(), ns, exc_info=1)
+                raise
+            elif action == 'debug':
+                logger.error("caught runaway exception: %r", exc)
+                logger.error("starting debugger...")
+                pdb.post_mortem()
+                return 1

=== modified file 'plainbox/plainbox/impl/commands/analyze.py'
--- plainbox/plainbox/impl/commands/analyze.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/analyze.py	2013-09-13 17:12:45 +0000
@@ -31,7 +31,7 @@
 from plainbox.impl.commands import PlainBoxCommand
 from plainbox.impl.commands.checkbox import CheckBoxCommandMixIn
 from plainbox.impl.commands.checkbox import CheckBoxInvocationMixIn
-from plainbox.impl.session import SessionState
+from plainbox.impl.session import SessionStateLegacyAPI as SessionState
 from plainbox.impl.runner import JobRunner
 
 
@@ -40,8 +40,8 @@
 
 class AnalyzeInvocation(CheckBoxInvocationMixIn):
 
-    def __init__(self, checkbox, ns):
-        super(AnalyzeInvocation, self).__init__(checkbox)
+    def __init__(self, provider, ns):
+        super(AnalyzeInvocation, self).__init__(provider)
         self.ns = ns
         self.job_list = self.get_job_list(ns)
         self.desired_job_list = self._get_matching_job_list(ns, self.job_list)
@@ -64,7 +64,7 @@
         with self.session.open():
             runner = JobRunner(
                 self.session.session_dir, self.session.jobs_io_log_dir,
-                command_io_delegate=self, outcome_callback=None)
+                command_io_delegate=self, interaction_callback=None)
             again = True
             while again:
                 for job in self.session.run_list:
@@ -127,11 +127,11 @@
     Implementation of ``$ plainbox dev analyze``
     """
 
-    def __init__(self, checkbox):
-        self.checkbox = checkbox
+    def __init__(self, provider):
+        self.provider = provider
 
     def invoked(self, ns):
-        return AnalyzeInvocation(self.checkbox, ns).run()
+        return AnalyzeInvocation(self.provider, ns).run()
 
     def register_parser(self, subparsers):
         parser = subparsers.add_parser(

=== modified file 'plainbox/plainbox/impl/commands/checkbox.py'
--- plainbox/plainbox/impl/commands/checkbox.py	2013-05-10 16:49:14 +0000
+++ plainbox/plainbox/impl/commands/checkbox.py	2013-09-13 17:12:45 +0000
@@ -32,14 +32,14 @@
 
 class CheckBoxInvocationMixIn:
 
-    def __init__(self, checkbox):
-        self.checkbox = checkbox
+    def __init__(self, provider):
+        self.provider = provider
 
     def get_job_list(self, ns):
         """
         Load and return a list of JobDefinition instances
         """
-        return self.checkbox.get_builtin_jobs()
+        return self.provider.get_builtin_jobs()
 
     def _get_matching_job_list(self, ns, job_list):
         # Find jobs that matched patterns
@@ -47,27 +47,29 @@
         # Pre-seed the include pattern list with data read from
         # the whitelist file.
         if ns.whitelist:
-            ns.include_pattern_list.extend([
-                pattern.strip()
-                for pattern in ns.whitelist.readlines()])
+            for whitelist in ns.whitelist:
+                ns.include_pattern_list.extend([
+                    pattern.strip()
+                    for pattern in whitelist.readlines()])
         # Decide which of the known jobs to include
-        for job in job_list:
-            # Reject all jobs that match any of the exclude
-            # patterns, matching strictly from the start to
-            # the end of the line.
+        if ns.exclude_pattern_list:
             for pattern in ns.exclude_pattern_list:
+                # Reject all jobs that match any of the exclude
+                # patterns, matching strictly from the start to
+                # the end of the line.
                 regexp_pattern = r"^{pattern}$".format(pattern=pattern)
-                if re.match(regexp_pattern, job.name):
-                    break
-            else:
-                # Then accept (include) all job that matches
+                for job in job_list:
+                    if re.match(regexp_pattern, job.name):
+                        job_list.remove(job)
+        if ns.include_pattern_list:
+            for pattern in ns.include_pattern_list:
+                # Accept (include) all job that matches
                 # any of include patterns, matching strictly
                 # from the start to the end of the line.
-                for pattern in ns.include_pattern_list:
-                    regexp_pattern = r"^{pattern}$".format(pattern=pattern)
+                regexp_pattern = r"^{pattern}$".format(pattern=pattern)
+                for job in job_list:
                     if re.match(regexp_pattern, job.name):
                         matching_job_list.append(job)
-                        break
         return matching_job_list
 
 
@@ -95,6 +97,7 @@
         # TODO: Find a way to handle the encoding of the file
         group.add_argument(
             '-w', '--whitelist',
+            action="append",
             metavar="WHITELIST",
             type=FileType("rt"),
             help="Load whitelist containing run patterns")

=== modified file 'plainbox/plainbox/impl/commands/dev.py'
--- plainbox/plainbox/impl/commands/dev.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/dev.py	2013-09-13 17:12:45 +0000
@@ -45,8 +45,8 @@
     Command hub for various development commands.
     """
 
-    def __init__(self, checkbox, config):
-        self.checkbox = checkbox
+    def __init__(self, provider, config):
+        self.provider = provider
         self.config = config
 
     def invoked(self, ns):
@@ -56,9 +56,9 @@
         parser = subparsers.add_parser(
             "dev", help="development commands")
         subdev = parser.add_subparsers()
-        ScriptCommand(self.checkbox, self.config).register_parser(subdev)
-        SpecialCommand(self.checkbox).register_parser(subdev)
-        AnalyzeCommand(self.checkbox).register_parser(subdev)
+        ScriptCommand(self.provider, self.config).register_parser(subdev)
+        SpecialCommand(self.provider).register_parser(subdev)
+        AnalyzeCommand(self.provider).register_parser(subdev)
         ParseCommand().register_parser(subdev)
         CrashCommand().register_parser(subdev)
         LogTestCommand().register_parser(subdev)

=== modified file 'plainbox/plainbox/impl/commands/run.py'
--- plainbox/plainbox/impl/commands/run.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/run.py	2013-09-13 17:12:45 +0000
@@ -35,17 +35,19 @@
 
 from requests.exceptions import ConnectionError, InvalidSchema, HTTPError
 
+from plainbox.abc import IJobResult
+from plainbox.impl.providers.checkbox import CheckBoxDebProvider
 from plainbox.impl.commands import PlainBoxCommand
 from plainbox.impl.commands.checkbox import CheckBoxCommandMixIn
 from plainbox.impl.commands.checkbox import CheckBoxInvocationMixIn
 from plainbox.impl.depmgr import DependencyDuplicateError
 from plainbox.impl.exporter import ByteStringStreamTranslator
 from plainbox.impl.exporter import get_all_exporters
-from plainbox.impl.result import JobResult
+from plainbox.impl.result import DiskJobResult, MemoryJobResult
 from plainbox.impl.runner import JobRunner
 from plainbox.impl.runner import authenticate_warmup
 from plainbox.impl.runner import slugify
-from plainbox.impl.session import SessionState
+from plainbox.impl.session import SessionStateLegacyAPI as SessionState
 from plainbox.impl.transport import get_all_transports
 
 
@@ -54,8 +56,8 @@
 
 class RunInvocation(CheckBoxInvocationMixIn):
 
-    def __init__(self, checkbox, ns):
-        super(RunInvocation, self).__init__(checkbox)
+    def __init__(self, provider, ns):
+        super(RunInvocation, self).__init__(provider)
         self.ns = ns
 
     def run(self):
@@ -110,25 +112,46 @@
         except ValueError as exc:
             raise SystemExit(str(exc))
 
-    def ask_for_resume(self, prompt=None, allowed=None):
-        # FIXME: Add support/callbacks for a GUI
-        if prompt is None:
-            prompt = "Do you want to resume the previous session [Y/n]? "
-        if allowed is None:
-            allowed = ('', 'y', 'Y', 'n', 'N')
+    def ask_for_resume(self):
+        return self.ask_user(
+            "Do you want to resume the previous session?", ('y', 'n')
+        ).lower() == "y"
+
+    def ask_for_resume_action(self):
+        return self.ask_user(
+            "What do you want to do with that job?", ('skip', 'fail', 'run'))
+
+    def ask_user(self, prompt, allowed):
         answer = None
         while answer not in allowed:
-            answer = input(prompt)
-        return False if answer in ('n', 'N') else True
+            answer = input("{} [{}] ".format(prompt, ", ".join(allowed)))
+        return answer
+
+    def _maybe_skip_last_job_after_resume(self, session):
+        last_job = session.metadata.running_job_name
+        if last_job is None:
+            return
+        print("We have previously tried to execute {}".format(last_job))
+        action = self.ask_for_resume_action()
+        if action == 'skip':
+            result = MemoryJobResult({
+                'outcome': 'skip',
+                'comment': "Skipped after resuming execution"
+            })
+        elif action == 'fail':
+            result = MemoryJobResult({
+                'outcome': 'fail',
+                'comment': "Failed after resuming execution"
+            })
+        elif action == 'run':
+            result = None
+        if result:
+            session.update_job_result(
+                session.job_state_map[last_job].job, result)
+            session.metadata.running_job_name = None
+            session.persistent_save()
 
     def _run_jobs(self, ns, job_list, exporter, transport=None):
-        # Ask the password before anything else in order to run jobs requiring
-        # privileges
-        if self.checkbox._mode == 'deb':
-            print("[ Authentication ]".center(80, '='))
-            return_code = authenticate_warmup()
-            if return_code:
-                raise SystemExit(return_code)
         # Compute the run list, this can give us notification about problems in
         # the selected jobs. Currently we just display each problem
         matching_job_list = self._get_matching_job_list(ns, job_list)
@@ -150,18 +173,28 @@
             if session.previous_session_file():
                 if self.ask_for_resume():
                     session.resume()
+                    self._maybe_skip_last_job_after_resume(session)
                 else:
                     session.clean()
+            session.metadata.title = " ".join(sys.argv)
+            session.persistent_save()
             self._update_desired_job_list(session, matching_job_list)
+            # Ask the password before anything else in order to run jobs
+            # requiring privileges
+            if self._auth_warmup_needed(session):
+                print("[ Authentication ]".center(80, '='))
+                return_code = authenticate_warmup()
+                if return_code:
+                    raise SystemExit(return_code)
             if (sys.stdin.isatty() and sys.stdout.isatty() and not
                     ns.not_interactive):
-                outcome_callback = self.ask_for_outcome
+                interaction_callback = self._interaction_callback
             else:
-                outcome_callback = None
+                interaction_callback = None
             runner = JobRunner(
                 session.session_dir,
                 session.jobs_io_log_dir,
-                outcome_callback=outcome_callback,
+                interaction_callback=interaction_callback,
                 dry_run=ns.dry_run
             )
             self._run_jobs_with_session(ns, session, runner)
@@ -189,6 +222,18 @@
         # FIXME: sensible return value
         return 0
 
+    def _auth_warmup_needed(self, session):
+        # Don't use authentication warm-up in modes other than 'deb' as it
+        # makes no sense to do so.
+        if not isinstance(self.provider, CheckBoxDebProvider):
+            return False
+        # Don't use authentication warm-up if none of the jobs on the run list
+        # requires it.
+        if all(job.user is None for job in session.run_list):
+            return False
+        # Otherwise, do pre-authentication
+        return True
+
     def _save_results(self, output_file, input_stream):
         if output_file is sys.stdout:
             print("[ Results ]".center(80, '='))
@@ -203,18 +248,32 @@
         if output_file is not sys.stdout:
             output_file.close()
 
-    def ask_for_outcome(self, prompt=None, allowed=None):
+    def _interaction_callback(self, runner, job, config, prompt=None,
+                             allowed_outcome=None):
+        result = {}
         if prompt is None:
-            prompt = "what is the outcome? "
-        if allowed is None:
-            allowed = (JobResult.OUTCOME_PASS,
-                       JobResult.OUTCOME_FAIL,
-                       JobResult.OUTCOME_SKIP)
-        answer = None
-        while answer not in allowed:
-            print("Allowed answers are: {}".format(", ".join(allowed)))
-            answer = input(prompt)
-        return answer
+            prompt = "Select an outcome or an action: "
+        if allowed_outcome is None:
+            allowed_outcome = [IJobResult.OUTCOME_PASS,
+                               IJobResult.OUTCOME_FAIL,
+                               IJobResult.OUTCOME_SKIP]
+        allowed_actions = ['comments']
+        if job.command:
+            allowed_actions.append('test')
+        result['outcome'] = IJobResult.OUTCOME_UNDECIDED
+        while result['outcome'] not in allowed_outcome:
+            print("Allowed answers are: {}".format(", ".join(allowed_outcome +
+                                                             allowed_actions)))
+            choice = input(prompt)
+            if choice in allowed_outcome:
+                result['outcome'] = choice
+                break
+            elif choice == 'test':
+                (result['return_code'],
+                 result['io_log_filename']) = runner._run_command(job, config)
+            elif choice == 'comments':
+                result['comments'] = input('Please enter your comments:\n')
+        return DiskJobResult(result)
 
     def _update_desired_job_list(self, session, desired_job_list):
         problem_list = session.update_desired_job_list(desired_job_list)
@@ -224,6 +283,18 @@
             for problem in problem_list:
                 print(" * {}".format(problem))
             print("Problematic jobs will not be considered")
+        (estimated_duration_auto,
+         estimated_duration_manual) = session.get_estimated_duration()
+        if estimated_duration_auto:
+            print("Estimated duration is {:.2f} for automated jobs.".format(
+                  estimated_duration_auto))
+        else:
+            print("Estimated duration cannot be determined for automated jobs.")
+        if estimated_duration_manual:
+            print("Estimated duration is {:.2f} for manual jobs.".format(
+                  estimated_duration_manual))
+        else:
+            print("Estimated duration cannot be determined for manual jobs.")
 
     def _run_jobs_with_session(self, ns, session, runner):
         # TODO: run all resource jobs concurrently with multiprocessing
@@ -272,13 +343,16 @@
         if job_state.can_start():
             print("Running... (output in {}.*)".format(
                 join(session.jobs_io_log_dir, slugify(job.name))))
+            session.metadata.running_job_name = job.name
+            session.persistent_save()
             job_result = runner.run_job(job)
+            session.metadata.running_job_name = None
+            session.persistent_save()
             print("Outcome: {}".format(job_result.outcome))
             print("Comments: {}".format(job_result.comments))
         else:
-            job_result = JobResult({
-                'job': job,
-                'outcome': JobResult.OUTCOME_NOT_SUPPORTED,
+            job_result = MemoryJobResult({
+                'outcome': IJobResult.OUTCOME_NOT_SUPPORTED,
                 'comments': job_state.get_readiness_description()
             })
         if job_result is not None:
@@ -287,11 +361,11 @@
 
 class RunCommand(PlainBoxCommand, CheckBoxCommandMixIn):
 
-    def __init__(self, checkbox):
-        self.checkbox = checkbox
+    def __init__(self, provider):
+        self.provider = provider
 
     def invoked(self, ns):
-        return RunInvocation(self.checkbox, ns).run()
+        return RunInvocation(self.provider, ns).run()
 
     def register_parser(self, subparsers):
         parser = subparsers.add_parser("run", help="run a test job")

=== modified file 'plainbox/plainbox/impl/commands/script.py'
--- plainbox/plainbox/impl/commands/script.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/script.py	2013-09-13 17:12:45 +0000
@@ -48,8 +48,8 @@
     the command is to be invoked.
     """
 
-    def __init__(self, checkbox, config, job_name):
-        self.checkbox = checkbox
+    def __init__(self, provider, config, job_name):
+        self.provider = provider
         self.config = config
         self.job_name = job_name
 
@@ -67,8 +67,10 @@
             bait_dir = os.path.join(scratch, 'files-created-in-current-dir')
             os.mkdir(bait_dir)
             with TestCwd(bait_dir):
-                return_code, fjson = runner._run_command(job, self.config)
+                return_code, record_path = runner._run_command(
+                    job, self.config)
             self._display_side_effects(scratch)
+            self._display_script_outcome(job, return_code)
         return return_code
 
     def _display_file(self, pathname, origin):
@@ -85,9 +87,13 @@
                 self._display_file(
                     os.path.join(dirpath, filename), scratch)
 
+    def _display_script_outcome(self, job, return_code):
+        print(job.name, "returned", return_code)
+        print("command:", job.command)
+
     def _get_job(self):
         job_list = get_matching_job_list(
-            self.checkbox.get_builtin_jobs(),
+            self.provider.get_builtin_jobs(),
             NameJobQualifier(self.job_name))
         if len(job_list) == 0:
             return None
@@ -101,12 +107,12 @@
     unconditionally.
     """
 
-    def __init__(self, checkbox, config):
-        self.checkbox = checkbox
+    def __init__(self, provider, config):
+        self.provider = provider
         self.config = config
 
     def invoked(self, ns):
-        return ScriptInvocation(self.checkbox, self.config, ns.job_name).run()
+        return ScriptInvocation(self.provider, self.config, ns.job_name).run()
 
     def register_parser(self, subparsers):
         parser = subparsers.add_parser(

=== added file 'plainbox/plainbox/impl/commands/service.py'
--- plainbox/plainbox/impl/commands/service.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/service.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,132 @@
+# 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 as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`plainbox.impl.commands.service` -- service sub-command
+============================================================
+
+"""
+
+import logging
+import os
+
+from dbus import StarterBus, SessionBus
+from dbus.mainloop.glib import DBusGMainLoop, threads_init
+from dbus.service import BusName
+from gi.repository import GObject
+
+from plainbox.impl.commands import PlainBoxCommand
+from plainbox.impl.highlevel import Service
+from plainbox.impl.service import ServiceWrapper
+
+
+logger = logging.getLogger("plainbox.commands.service")
+
+
+def connect_to_session_bus():
+    """
+    Connect to the session bus properly.
+
+    Returns a tuple (session_bus, loop) where loop is a GObject.MainLoop
+    instance. The loop is there so that you can listen to signals.
+    """
+    # We'll need an event loop to observe signals. We will need the instance
+    # later below so let's keep it. Note that we're not passing it directly
+    # below as DBus needs specific API. The DBusGMainLoop class that we
+    # instantiate and pass is going to work with this instance transparently.
+    #
+    # NOTE: DBus tutorial suggests that we should create the loop _before_
+    # connecting to the bus.
+    logger.debug("Setting up glib-based event loop")
+    # Make sure gobject threads don't crash
+    GObject.threads_init()
+    threads_init()
+    loop = GObject.MainLoop()
+    # Let's get the system bus object.
+    logger.debug("Connecting to DBus session bus")
+    if os.getenv("DBUS_STARTER_ADDRESS"):
+        session_bus = StarterBus(mainloop=DBusGMainLoop())
+    else:
+        session_bus = SessionBus(mainloop=DBusGMainLoop())
+    return session_bus, loop
+
+
+class ServiceInvocation:
+
+    def __init__(self, provider, config, ns):
+        self.provider = provider
+        self.config = config
+        self.ns = ns
+
+    def run(self):
+        bus, loop = connect_to_session_bus()
+        logger.info("Setting up DBus objects...")
+        provider_list = [self.provider]
+        session_list = []  # TODO: load sessions
+        logger.debug("Constructing Service object")
+        service_obj = Service(provider_list, session_list)
+        logger.debug("Constructing ServiceWrapper")
+        service_wrp = ServiceWrapper(service_obj, on_exit=lambda: loop.quit())
+        logger.info("Publishing all objects on DBus")
+        service_wrp.publish_related_objects(bus)
+        logger.info("Publishing all managed objects (events should fire there)")
+        service_wrp.publish_managed_objects()
+        logger.debug("Attempting to claim bus name: %s", self.ns.bus_name)
+        bus_name = BusName(self.ns.bus_name, bus)
+        logger.info(
+            "PlainBox DBus service ready, claimed name: %s",
+            bus_name.get_name())
+        try:
+            loop.run()
+        except KeyboardInterrupt:
+            logger.warning((
+                "Main loop interrupted!"
+                " It is recommended to call the Exit() method on the"
+                " exported service object instead"))
+        finally:
+            logger.debug("Releasing %s", bus_name)
+            # XXX: ugly but that's how one can reliably release a bus name
+            del bus_name
+            # Remove objects from the bus
+            service_wrp.remove_from_connection()
+            logger.debug("Closing %s", bus)
+            bus.close()
+            logger.debug("Main loop terminated, exiting...")
+
+
+class ServiceCommand(PlainBoxCommand):
+    """
+    DBus service for PlainBox
+    """
+
+    # XXX: Maybe drop provider / config and handle them differently
+    def __init__(self, provider, config):
+        self.provider = provider
+        self.config = config
+
+    def invoked(self, ns):
+        return ServiceInvocation(self.provider, self.config, ns).run()
+
+    def register_parser(self, subparsers):
+        parser = subparsers.add_parser("service", help="spawn dbus service")
+        parser.add_argument(
+            '--bus-name', action="store",
+            default="com.canonical.certification.PlainBox1",
+            help="Use the specified DBus bus name")
+        parser.set_defaults(command=self)

=== modified file 'plainbox/plainbox/impl/commands/special.py'
--- plainbox/plainbox/impl/commands/special.py	2013-05-13 08:49:00 +0000
+++ plainbox/plainbox/impl/commands/special.py	2013-09-13 17:12:45 +0000
@@ -38,8 +38,8 @@
 
 class SpecialInvocation(CheckBoxInvocationMixIn):
 
-    def __init__(self, checkbox, ns):
-        super(SpecialInvocation, self).__init__(checkbox)
+    def __init__(self, provider, ns):
+        super(SpecialInvocation, self).__init__(provider)
         self.ns = ns
 
     def run(self):
@@ -124,11 +124,11 @@
     Implementation of ``$ plainbox special``
     """
 
-    def __init__(self, checkbox):
-        self.checkbox = checkbox
+    def __init__(self, provider):
+        self.provider = provider
 
     def invoked(self, ns):
-        return SpecialInvocation(self.checkbox, ns).run()
+        return SpecialInvocation(self.provider, ns).run()
 
     def register_parser(self, subparsers):
         parser = subparsers.add_parser(

=== modified file 'plainbox/plainbox/impl/commands/sru.py'
--- plainbox/plainbox/impl/commands/sru.py	2013-05-10 16:49:15 +0000
+++ plainbox/plainbox/impl/commands/sru.py	2013-09-13 17:12:45 +0000
@@ -28,21 +28,24 @@
 """
 import logging
 import os
+import sys
 import tempfile
 
 from requests.exceptions import ConnectionError, InvalidSchema, HTTPError
 
+from plainbox.impl.applogic import WhiteList
 from plainbox.impl.applogic import get_matching_job_list
 from plainbox.impl.applogic import run_job_if_possible
-from plainbox.impl.checkbox import WhiteList
 from plainbox.impl.commands import PlainBoxCommand
 from plainbox.impl.commands.check_config import CheckConfigInvocation
+from plainbox.impl.commands.checkbox import CheckBoxCommandMixIn
+from plainbox.impl.commands.checkbox import CheckBoxInvocationMixIn
 from plainbox.impl.config import ValidationError, Unset
 from plainbox.impl.depmgr import DependencyDuplicateError
 from plainbox.impl.exporter import ByteStringStreamTranslator
 from plainbox.impl.exporter.xml import XMLSessionStateExporter
 from plainbox.impl.runner import JobRunner
-from plainbox.impl.session import SessionState
+from plainbox.impl.session import SessionStateLegacyAPI as SessionState
 from plainbox.impl.transport.certification import CertificationTransport
 from plainbox.impl.transport.certification import InvalidSecureIDError
 
@@ -50,20 +53,26 @@
 logger = logging.getLogger("plainbox.commands.sru")
 
 
-class _SRUInvocation:
+class _SRUInvocation(CheckBoxInvocationMixIn):
     """
     Helper class instantiated to perform a particular invocation of the sru
     command. Unlike the SRU command itself, this class is instantiated each
     time.
     """
 
-    def __init__(self, checkbox, config, ns):
-        self.checkbox = checkbox
+    def __init__(self, provider, config, ns):
+        self.provider = provider
         self.config = config
         self.ns = ns
-        self.whitelist = WhiteList.from_file(os.path.join(
-            self.checkbox.whitelists_dir, "sru.whitelist"))
-        self.job_list = self.checkbox.get_builtin_jobs()
+        if self.ns.whitelist:
+            self.whitelist = WhiteList.from_file(self.ns.whitelist[0].name)
+        elif self.config.whitelist is not Unset:
+            self.whitelist = WhiteList.from_file(self.config.whitelist)
+        else:
+            self.whitelist = WhiteList.from_file(os.path.join(
+                self.provider.whitelists_dir, "sru.whitelist"))
+
+        self.job_list = self.provider.get_builtin_jobs()
         # XXX: maybe allow specifying system_id from command line?
         self.exporter = XMLSessionStateExporter(system_id=None)
         self.session = None
@@ -91,7 +100,7 @@
                 self.session.session_dir,
                 self.session.jobs_io_log_dir,
                 command_io_delegate=self,
-                outcome_callback=None,  # SRU runs are never interactive
+                interaction_callback=None,  # SRU runs are never interactive
                 dry_run=self.ns.dry_run
             )
             self._run_all_jobs()
@@ -178,9 +187,11 @@
 
     def _run_single_job(self, job):
         print("- {}:".format(job.name), end=' ')
+        sys.stdout.flush()
         job_state, job_result = run_job_if_possible(
             self.session, self.runner, self.config, job)
         print("{0}".format(job_result.outcome))
+        sys.stdout.flush()
         if job_result.comments is not None:
             print("comments: {0}".format(job_result.comments))
         if job_state.readiness_inhibitor_list:
@@ -190,7 +201,7 @@
         self.session.update_job_result(job, job_result)
 
 
-class SRUCommand(PlainBoxCommand):
+class SRUCommand(PlainBoxCommand, CheckBoxCommandMixIn):
     """
     Command for running Stable Release Update (SRU) tests.
 
@@ -204,8 +215,8 @@
     plainbox core on realistic workloads.
     """
 
-    def __init__(self, checkbox, config):
-        self.checkbox = checkbox
+    def __init__(self, provider, config):
+        self.provider = provider
         self.config = config
 
     def invoked(self, ns):
@@ -226,7 +237,7 @@
             retval = CheckConfigInvocation(self.config).run()
             if retval != 0:
                 return retval
-        return _SRUInvocation(self.checkbox, self.config, ns).run()
+        return _SRUInvocation(self.provider, self.config, ns).run()
 
     def register_parser(self, subparsers):
         parser = subparsers.add_parser(
@@ -262,6 +273,12 @@
             action='store',
             help=("POST the test report XML to this URL"
                   " (%(default)s)"))
+        group.add_argument(
+            '--staging',
+            dest='c3_url',
+            action='store_const',
+            const='https://certification.staging.canonical.com/submissions/submit/',
+            help='Override --destination to use the staging certification website')
         group = parser.add_argument_group(title="execution options")
         group.add_argument(
             '-n', '--dry-run',
@@ -269,3 +286,6 @@
             default=False,
             help=("Skip all usual jobs."
                   " Only local, resource and attachment jobs are started"))
+        # Call enhance_parser from CheckBoxCommandMixIn
+        self.enhance_parser(parser)
+

=== modified file 'plainbox/plainbox/impl/commands/test_dev.py'
--- plainbox/plainbox/impl/commands/test_dev.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/test_dev.py	2013-09-13 17:12:45 +0000
@@ -39,17 +39,17 @@
     def setUp(self):
         self.parser = argparse.ArgumentParser(prog='test')
         self.subparsers = self.parser.add_subparsers()
-        self.checkbox = mock.Mock()
+        self.provider = mock.Mock()
         self.config = mock.Mock()
         self.ns = mock.Mock()
 
     def test_init(self):
-        dev_cmd = DevCommand(self.checkbox, self.config)
-        self.assertIs(dev_cmd.checkbox, self.checkbox)
+        dev_cmd = DevCommand(self.provider, self.config)
+        self.assertIs(dev_cmd.provider, self.provider)
         self.assertIs(dev_cmd.config, self.config)
 
     def test_register_parser(self):
-        DevCommand(self.checkbox, self.config).register_parser(
+        DevCommand(self.provider, self.config).register_parser(
             self.subparsers)
         with TestIO() as io:
             self.parser.print_help()

=== modified file 'plainbox/plainbox/impl/commands/test_run.py'
--- plainbox/plainbox/impl/commands/test_run.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/test_run.py	2013-09-13 17:12:45 +0000
@@ -29,11 +29,16 @@
 import shutil
 import tempfile
 
+from collections import OrderedDict
 from inspect import cleandoc
 from mock import patch
 from unittest import TestCase
 
 from plainbox.impl.box import main
+from plainbox.impl.exporter.json import JSONSessionStateExporter
+from plainbox.impl.exporter.rfc822 import RFC822SessionStateExporter
+from plainbox.impl.exporter.text import TextSessionStateExporter
+from plainbox.impl.exporter.xml import XMLSessionStateExporter
 from plainbox.testing_utils.io import TestIO
 
 
@@ -46,6 +51,12 @@
         self._sandbox = tempfile.mkdtemp()
         self._env = os.environ
         os.environ['XDG_CACHE_HOME'] = self._sandbox
+        self._exporters = OrderedDict([
+            ('json', JSONSessionStateExporter),
+            ('rfc822', RFC822SessionStateExporter),
+            ('text', TextSessionStateExporter),
+            ('xml', XMLSessionStateExporter),
+        ])
 
     def test_help(self):
         with TestIO(combined=True) as io:
@@ -107,12 +118,16 @@
             self.assertEqual(call.exception.args, (0,))
         expected1 = """
         ===============================[ Analyzing Jobs ]===============================
+        Estimated duration cannot be determined for automated jobs.
+        Estimated duration cannot be determined for manual jobs.
         ==============================[ Running All Jobs ]==============================
         ==================================[ Results ]===================================
         """
         expected2 = """
         ===============================[ Authentication ]===============================
         ===============================[ Analyzing Jobs ]===============================
+        Estimated duration cannot be determined for automated jobs.
+        Estimated duration cannot be determined for manual jobs.
         ==============================[ Running All Jobs ]==============================
         ==================================[ Results ]===================================
         """
@@ -123,7 +138,9 @@
     def test_output_format_list(self):
         with TestIO(combined=True) as io:
             with self.assertRaises(SystemExit) as call:
-                main(['run', '--output-format=?'])
+                with patch('plainbox.impl.commands.run.get_all_exporters') as mock_get_all_exporters:
+                    mock_get_all_exporters.return_value = self._exporters
+                    main(['run', '--output-format=?'])
             self.assertEqual(call.exception.args, (0,))
         expected = """
         Available output formats: json, rfc822, text, xml
@@ -133,7 +150,9 @@
     def test_output_option_list(self):
         with TestIO(combined=True) as io:
             with self.assertRaises(SystemExit) as call:
-                main(['run', '--output-option=?'])
+                with patch('plainbox.impl.commands.run.get_all_exporters') as mock_get_all_exporters:
+                    mock_get_all_exporters.return_value = self._exporters
+                    main(['run', '--output-option=?'])
             self.assertEqual(call.exception.args, (0,))
         expected = """
         Each format may support a different set of options

=== modified file 'plainbox/plainbox/impl/commands/test_script.py'
--- plainbox/plainbox/impl/commands/test_script.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/commands/test_script.py	2013-09-13 17:12:45 +0000
@@ -32,7 +32,7 @@
 
 from plainbox.impl.applogic import PlainBoxConfig
 from plainbox.impl.commands.script import ScriptInvocation, ScriptCommand
-from plainbox.impl.provider import DummyProvider1
+from plainbox.impl.providers.v1 import DummyProvider1
 from plainbox.impl.testing_utils import make_job
 from plainbox.testing_utils.io import TestIO
 
@@ -42,17 +42,17 @@
     def setUp(self):
         self.parser = argparse.ArgumentParser(prog='test')
         self.subparsers = self.parser.add_subparsers()
-        self.checkbox = mock.Mock()
+        self.provider = mock.Mock()
         self.config = mock.Mock()
         self.ns = mock.Mock()
 
     def test_init(self):
-        script_cmd = ScriptCommand(self.checkbox, self.config)
-        self.assertIs(script_cmd.checkbox, self.checkbox)
+        script_cmd = ScriptCommand(self.provider, self.config)
+        self.assertIs(script_cmd.provider, self.provider)
         self.assertIs(script_cmd.config, self.config)
 
     def test_register_parser(self):
-        ScriptCommand(self.checkbox, self.config).register_parser(
+        ScriptCommand(self.provider, self.config).register_parser(
             self.subparsers)
         with TestIO() as io:
             self.parser.print_help()
@@ -75,26 +75,26 @@
 
     @mock.patch("plainbox.impl.commands.script.ScriptInvocation")
     def test_invoked(self, patched_ScriptInvocation):
-        retval = ScriptCommand(self.checkbox, self.config).invoked(self.ns)
+        retval = ScriptCommand(self.provider, self.config).invoked(self.ns)
         patched_ScriptInvocation.assert_called_once_with(
-            self.checkbox, self.config, self.ns.job_name)
+            self.provider, self.config, self.ns.job_name)
         self.assertEqual(
             retval, patched_ScriptInvocation(
-                self.checkbox, self.config,
+                self.provider, self.config,
                 self.ns.job_name).run.return_value)
 
 
 class ScriptInvocationTests(TestCase):
 
     def setUp(self):
-        self.checkbox = mock.Mock()
+        self.provider = mock.Mock()
         self.config = PlainBoxConfig()
         self.job_name = mock.Mock()
 
     def test_init(self):
         script_inv = ScriptInvocation(
-            self.checkbox, self.config, self.job_name)
-        self.assertIs(script_inv.checkbox, self.checkbox)
+            self.provider, self.config, self.job_name)
+        self.assertIs(script_inv.provider, self.provider)
         self.assertIs(script_inv.config, self.config)
         self.assertIs(script_inv.job_name, self.job_name)
 
@@ -124,22 +124,27 @@
         self.assertEqual(retval, 125)
 
     def test_job_with_command(self):
+        dummy_name = 'foo'
+        dummy_command = 'echo ok'
         provider = DummyProvider1([
-            make_job('foo', command='echo ok')])
-        script_inv = ScriptInvocation(provider, self.config, 'foo')
+            make_job(dummy_name, command=dummy_command)])
+        script_inv = ScriptInvocation(provider, self.config, dummy_name)
         with TestIO() as io:
             retval = script_inv.run()
         self.assertEqual(
             io.stdout, cleandoc(
                 """
                 (job foo, <stdout:00001>) ok
-                """) + '\n')
+                """) + '\n' + "{} returned 0\n".format(dummy_name) +
+                "command: {}\n".format(dummy_command))
         self.assertEqual(retval, 0)
 
     def test_job_with_command_making_files(self):
+        dummy_name = 'foo'
+        dummy_command = 'echo ok > file'
         provider = DummyProvider1([
-            make_job('foo', command='echo ok > file')])
-        script_inv = ScriptInvocation(provider, self.config, 'foo')
+            make_job(dummy_name, command=dummy_command)])
+        script_inv = ScriptInvocation(provider, self.config, dummy_name)
         with TestIO() as io:
             retval = script_inv.run()
         self.maxDiff = None
@@ -148,5 +153,6 @@
                 """
                 Leftover file detected: 'files-created-in-current-dir/file':
                   files-created-in-current-dir/file:1: ok
-                """) + '\n')
+                """) + '\n' + "{} returned 0\n".format(dummy_name) +
+                "command: {}\n".format(dummy_command))
         self.assertEqual(retval, 0)

=== modified file 'plainbox/plainbox/impl/commands/test_sru.py'
--- plainbox/plainbox/impl/commands/test_sru.py	2013-04-24 17:50:58 +0000
+++ plainbox/plainbox/impl/commands/test_sru.py	2013-09-13 17:12:45 +0000
@@ -41,7 +41,8 @@
         self.maxDiff = None
         expected = """
         usage: plainbox sru [-h] [--check-config] --secure-id SECURE-ID
-                            [--fallback FILE] [--destination URL] [-n]
+                            [--fallback FILE] [--destination URL] [--staging] [-n]
+                            [-i PATTERN] [-x PATTERN] [-w WHITELIST]
 
         optional arguments:
           -h, --help            show this help message and exit
@@ -55,9 +56,21 @@
                                 (unset)
           --destination URL     POST the test report XML to this URL (https://certific
                                 ation.canonical.com/submissions/submit/)
+          --staging             Override --destination to use the staging
+                                certification website
 
         execution options:
           -n, --dry-run         Skip all usual jobs. Only local, resource and
                                 attachment jobs are started
+
+        job definition options:
+          -i PATTERN, --include-pattern PATTERN
+                                Run jobs matching the given regular expression.
+                                Matches from the start to the end of the line.
+          -x PATTERN, --exclude-pattern PATTERN
+                                Do not run jobs matching the given regular expression.
+                                Matches from the start to the end of the line.
+          -w WHITELIST, --whitelist WHITELIST
+                                Load whitelist containing run patterns
         """
         self.assertEqual(io.combined, cleandoc(expected) + "\n")

=== modified file 'plainbox/plainbox/impl/config.py'
--- plainbox/plainbox/impl/config.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/config.py	2013-09-13 17:12:45 +0000
@@ -543,3 +543,16 @@
     def __call__(self, variable, new_value):
         if not self.pattern.match(new_value):
             return "does not match pattern: {!r}".format(self.pattern_text)
+
+
+class ChoiceValidator(IValidator):
+    """
+    A validator ensuring that values are in a given set
+    """
+
+    def __init__(self, choice_list):
+        self.choice_list = choice_list
+
+    def __call__(self, variable, new_value):
+        if new_value not in self.choice_list:
+            return "must be one of {}".format(", ".join(self.choice_list))

=== added directory 'plainbox/plainbox/impl/dbus'
=== added file 'plainbox/plainbox/impl/dbus/__init__.py'
--- plainbox/plainbox/impl/dbus/__init__.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/dbus/__init__.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,47 @@
+# 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 as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`plainbox.impl.dbus` -- DBus support code for PlainBox
+===========================================================
+"""
+
+__all__ = [
+    'service',
+    'exceptions',
+    'Signature',
+    'Struct',
+    'types',
+    'INTROSPECTABLE_IFACE',
+    'PEER_IFACE',
+    'PROPERTIES_IFACE',
+    'OBJECT_MANAGER_IFACE',
+]
+
+from dbus import INTROSPECTABLE_IFACE
+from dbus import PEER_IFACE
+from dbus import PROPERTIES_IFACE
+from dbus import Signature
+from dbus import Struct
+from dbus import exceptions
+from dbus import types
+
+OBJECT_MANAGER_IFACE = "org.freedesktop.DBus.ObjectManager"
+
+from plainbox.impl.dbus import service

=== added file 'plainbox/plainbox/impl/dbus/decorators.py'
--- plainbox/plainbox/impl/dbus/decorators.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/dbus/decorators.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,351 @@
+"""Service-side D-Bus decorators."""
+
+# Copyright (C) 2003, 2004, 2005, 2006 Red Hat Inc. <http://www.redhat.com/>
+# Copyright (C) 2003 David Zeuthen
+# Copyright (C) 2004 Rob Taylor
+# Copyright (C) 2005, 2006 Collabora Ltd. <http://www.collabora.co.uk/>
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use, copy,
+# modify, merge, publish, distribute, sublicense, and/or sell copies
+# of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+__all__ = ('method', 'signal')
+__docformat__ = 'restructuredtext'
+
+import inspect
+
+from dbus import validate_interface_name, Signature, validate_member_name
+from dbus.lowlevel import SignalMessage
+from dbus.exceptions import DBusException
+from dbus._compat import is_py2
+
+
+def method(dbus_interface, in_signature=None, out_signature=None,
+           async_callbacks=None,
+           sender_keyword=None, path_keyword=None, destination_keyword=None,
+           message_keyword=None, connection_keyword=None,
+           byte_arrays=False,
+           rel_path_keyword=None, **kwargs):
+    """Factory for decorators used to mark methods of a `dbus.service.Object`
+    to be exported on the D-Bus.
+
+    The decorated method will be exported over D-Bus as the method of the
+    same name on the given D-Bus interface.
+
+    :Parameters:
+        `dbus_interface` : str
+            Name of a D-Bus interface
+        `in_signature` : str or None
+            If not None, the signature of the method parameters in the usual
+            D-Bus notation
+        `out_signature` : str or None
+            If not None, the signature of the return value in the usual
+            D-Bus notation
+        `async_callbacks` : tuple containing (str,str), or None
+            If None (default) the decorated method is expected to return
+            values matching the `out_signature` as usual, or raise
+            an exception on error. If not None, the following applies:
+
+            `async_callbacks` contains the names of two keyword arguments to
+            the decorated function, which will be used to provide a success
+            callback and an error callback (in that order).
+
+            When the decorated method is called via the D-Bus, its normal
+            return value will be ignored; instead, a pair of callbacks are
+            passed as keyword arguments, and the decorated method is
+            expected to arrange for one of them to be called.
+
+            On success the success callback must be called, passing the
+            results of this method as positional parameters in the format
+            given by the `out_signature`.
+
+            On error the decorated method may either raise an exception
+            before it returns, or arrange for the error callback to be
+            called with an Exception instance as parameter.
+
+        `sender_keyword` : str or None
+            If not None, contains the name of a keyword argument to the
+            decorated function, conventionally ``'sender'``. When the
+            method is called, the sender's unique name will be passed as
+            this keyword argument.
+
+        `path_keyword` : str or None
+            If not None (the default), the decorated method will receive
+            the destination object path as a keyword argument with this
+            name. Normally you already know the object path, but in the
+            case of "fallback paths" you'll usually want to use the object
+            path in the method's implementation.
+
+            For fallback objects, `rel_path_keyword` (new in 0.82.2) is
+            likely to be more useful.
+
+            :Since: 0.80.0?
+
+        `rel_path_keyword` : str or None
+            If not None (the default), the decorated method will receive
+            the destination object path, relative to the path at which the
+            object was exported, as a keyword argument with this
+            name. For non-fallback objects the relative path will always be
+            '/'.
+
+            :Since: 0.82.2
+
+        `destination_keyword` : str or None
+            If not None (the default), the decorated method will receive
+            the destination bus name as a keyword argument with this name.
+            Included for completeness - you shouldn't need this.
+
+            :Since: 0.80.0?
+
+        `message_keyword` : str or None
+            If not None (the default), the decorated method will receive
+            the `dbus.lowlevel.MethodCallMessage` as a keyword argument
+            with this name.
+
+            :Since: 0.80.0?
+
+        `connection_keyword` : str or None
+            If not None (the default), the decorated method will receive
+            the `dbus.connection.Connection` as a keyword argument
+            with this name. This is generally only useful for objects
+            that are available on more than one connection.
+
+            :Since: 0.82.0
+
+        `utf8_strings` : bool
+            If False (default), D-Bus strings are passed to the decorated
+            method as objects of class dbus.String, a unicode subclass.
+
+            If True, D-Bus strings are passed to the decorated method
+            as objects of class dbus.UTF8String, a str subclass guaranteed
+            to be encoded in UTF-8.
+
+            This option does not affect object-paths and signatures, which
+            are always 8-bit strings (str subclass) encoded in ASCII.
+
+            :Since: 0.80.0
+
+        `byte_arrays` : bool
+            If False (default), a byte array will be passed to the decorated
+            method as an `Array` (a list subclass) of `Byte` objects.
+
+            If True, a byte array will be passed to the decorated method as
+            a `ByteArray`, a str subclass. This is usually what you want,
+            but is switched off by default to keep dbus-python's API
+            consistent.
+
+            :Since: 0.80.0
+    """
+    validate_interface_name(dbus_interface)
+
+    def decorator(func):
+        # If the function is decorated and uses @functools.wrapper then use the
+        # __wrapped__ attribute to look at the original function signature.
+        #
+        # This allows us to see past the generic *args, **kwargs seen on most decorators.
+        if hasattr(func, '__wrapped__'):
+            args = inspect.getfullargspec(func.__wrapped__)[0]
+        else:
+            args = inspect.getfullargspec(func)[0]
+        args.pop(0)
+        if async_callbacks:
+            if type(async_callbacks) != tuple:
+                raise TypeError('async_callbacks must be a tuple of (keyword for return callback, keyword for error callback)')
+            if len(async_callbacks) != 2:
+                raise ValueError('async_callbacks must be a tuple of (keyword for return callback, keyword for error callback)')
+            args.remove(async_callbacks[0])
+            args.remove(async_callbacks[1])
+
+        if sender_keyword:
+            args.remove(sender_keyword)
+        if rel_path_keyword:
+            args.remove(rel_path_keyword)
+        if path_keyword:
+            args.remove(path_keyword)
+        if destination_keyword:
+            args.remove(destination_keyword)
+        if message_keyword:
+            args.remove(message_keyword)
+        if connection_keyword:
+            args.remove(connection_keyword)
+
+        if in_signature:
+            in_sig = tuple(Signature(in_signature))
+
+            if len(in_sig) > len(args):
+                raise ValueError('input signature is longer than the number of arguments taken')
+            elif len(in_sig) < len(args):
+                raise ValueError('input signature is shorter than the number of arguments taken')
+
+        func._dbus_is_method = True
+        func._dbus_async_callbacks = async_callbacks
+        func._dbus_interface = dbus_interface
+        func._dbus_in_signature = in_signature
+        func._dbus_out_signature = out_signature
+        func._dbus_sender_keyword = sender_keyword
+        func._dbus_path_keyword = path_keyword
+        func._dbus_rel_path_keyword = rel_path_keyword
+        func._dbus_destination_keyword = destination_keyword
+        func._dbus_message_keyword = message_keyword
+        func._dbus_connection_keyword = connection_keyword
+        func._dbus_args = args
+        func._dbus_get_args_options = dict(byte_arrays=byte_arrays)
+        if is_py2:
+            func._dbus_get_args_options['utf8_strings'] = kwargs.get(
+                'utf8_strings', False)
+        elif 'utf8_strings' in kwargs:
+            raise TypeError("unexpected keyword argument 'utf8_strings'")
+        return func
+
+    return decorator
+
+
+def signal(dbus_interface, signature=None, path_keyword=None,
+           rel_path_keyword=None):
+    """Factory for decorators used to mark methods of a `dbus.service.Object`
+    to emit signals on the D-Bus.
+
+    Whenever the decorated method is called in Python, after the method
+    body is executed, a signal with the same name as the decorated method,
+    with the given D-Bus interface, will be emitted from this object.
+
+    :Parameters:
+        `dbus_interface` : str
+            The D-Bus interface whose signal is emitted
+        `signature` : str
+            The signature of the signal in the usual D-Bus notation
+
+        `path_keyword` : str or None
+            A keyword argument to the decorated method. If not None,
+            that argument will not be emitted as an argument of
+            the signal, and when the signal is emitted, it will appear
+            to come from the object path given by the keyword argument.
+
+            Note that when calling the decorated method, you must always
+            pass in the object path as a keyword argument, not as a
+            positional argument.
+
+            This keyword argument cannot be used on objects where
+            the class attribute ``SUPPORTS_MULTIPLE_OBJECT_PATHS`` is true.
+
+            :Deprecated: since 0.82.0. Use `rel_path_keyword` instead.
+
+        `rel_path_keyword` : str or None
+            A keyword argument to the decorated method. If not None,
+            that argument will not be emitted as an argument of
+            the signal.
+
+            When the signal is emitted, if the named keyword argument is given,
+            the signal will appear to come from the object path obtained by
+            appending the keyword argument to the object's object path.
+            This is useful to implement "fallback objects" (objects which
+            own an entire subtree of the object-path tree).
+
+            If the object is available at more than one object-path on the
+            same or different connections, the signal will be emitted at
+            an appropriate object-path on each connection - for instance,
+            if the object is exported at /abc on connection 1 and at
+            /def and /x/y/z on connection 2, and the keyword argument is
+            /foo, then signals will be emitted from /abc/foo and /def/foo
+            on connection 1, and /x/y/z/foo on connection 2.
+
+            :Since: 0.82.0
+    """
+    validate_interface_name(dbus_interface)
+
+    if path_keyword is not None:
+        from warnings import warn
+        warn(DeprecationWarning('dbus.service.signal::path_keyword has been '
+                                'deprecated since dbus-python 0.82.0, and '
+                                'will not work on objects that support '
+                                'multiple object paths'),
+             DeprecationWarning, stacklevel=2)
+        if rel_path_keyword is not None:
+            raise TypeError('dbus.service.signal::path_keyword and '
+                            'rel_path_keyword cannot both be used')
+
+    def decorator(func):
+        member_name = func.__name__
+        validate_member_name(member_name)
+
+        def emit_signal(self, *args, **keywords):
+            abs_path = None
+            if path_keyword is not None:
+                if self.SUPPORTS_MULTIPLE_OBJECT_PATHS:
+                    raise TypeError('path_keyword cannot be used on the '
+                                    'signals of an object that supports '
+                                    'multiple object paths')
+                abs_path = keywords.pop(path_keyword, None)
+                if (abs_path != self.__dbus_object_path__ and
+                    not self.__dbus_object_path__.startswith(abs_path + '/')):
+                    raise ValueError('Path %r is not below %r', abs_path,
+                                     self.__dbus_object_path__)
+
+            rel_path = None
+            if rel_path_keyword is not None:
+                rel_path = keywords.pop(rel_path_keyword, None)
+
+            func(self, *args, **keywords)
+
+            for location in self.locations:
+                if abs_path is None:
+                    # non-deprecated case
+                    if rel_path is None or rel_path in ('/', ''):
+                        object_path = location[1]
+                    else:
+                        # will be validated by SignalMessage ctor in a moment
+                        object_path = location[1] + rel_path
+                else:
+                    object_path = abs_path
+
+                message = SignalMessage(object_path,
+                                                       dbus_interface,
+                                                       member_name)
+                message.append(signature=signature, *args)
+
+                location[0].send_message(message)
+        # end emit_signal
+
+        args = inspect.getargspec(func)[0]
+        args.pop(0)
+
+        for keyword in rel_path_keyword, path_keyword:
+            if keyword is not None:
+                try:
+                    args.remove(keyword)
+                except ValueError:
+                    raise ValueError('function has no argument "%s"' % keyword)
+
+        if signature:
+            sig = tuple(Signature(signature))
+
+            if len(sig) > len(args):
+                raise ValueError('signal signature is longer than the number of arguments provided')
+            elif len(sig) < len(args):
+                raise ValueError('signal signature is shorter than the number of arguments provided')
+
+        emit_signal.__name__ = func.__name__
+        emit_signal.__doc__ = func.__doc__
+        emit_signal._dbus_is_signal = True
+        emit_signal._dbus_interface = dbus_interface
+        emit_signal._dbus_signature = signature
+        emit_signal._dbus_args = args
+        return emit_signal
+
+    return decorator

=== added file 'plainbox/plainbox/impl/dbus/service.py'
--- plainbox/plainbox/impl/dbus/service.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/dbus/service.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,662 @@
+# 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 as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`plainbox.impl.dbus.service` -- DBus Service support code for PlainBox
+===========================================================================
+"""
+
+import logging
+import threading
+import weakref
+
+import _dbus_bindings
+import dbus
+import dbus.service
+import dbus.exceptions
+
+from plainbox.impl.signal import Signal
+from plainbox.impl.dbus import INTROSPECTABLE_IFACE
+from plainbox.impl.dbus import OBJECT_MANAGER_IFACE
+from plainbox.impl.dbus import PROPERTIES_IFACE
+# Note: use our own version of the decorators because
+# vanilla versions choke on annotations
+from plainbox.impl.dbus.decorators import method, signal
+
+
+# This is the good old standard python property decorator
+_property = property
+
+__all__ = [
+    'Interface',
+    'Object',
+    'method',
+    'property',
+    'signal',
+]
+
+logger = logging.getLogger("plainbox.dbus")
+
+
+class InterfaceType(dbus.service.InterfaceType):
+    """
+    Subclass of :class:`dbus.service.InterfaceType` that also handles
+    properties.
+    """
+
+    def _reflect_on_property(cls, func):
+        reflection_data = (
+            '    <property name="{}" type="{}" access="{}"/>\n').format(
+                func._dbus_property, func._signature,
+                func.dbus_access_flag)
+        return reflection_data
+
+
+#Subclass of :class:`dbus.service.Interface` that also handles properties
+Interface = InterfaceType('Interface', (dbus.service.Interface,), {})
+
+
+class property:
+    """
+    property that handles DBus stuff
+    """
+
+    def __init__(self, signature, dbus_interface, dbus_property=None,
+                 setter=False):
+        """
+        Initialize new dbus_property with the given interface name.
+
+        If dbus_property is not specified it is set to the name of the
+        decorated method. In special circumstances you may wish to specify
+        alternate dbus property name explicitly.
+
+        If setter is set to True then the implicit decorated function is a
+        setter, not the default getter. This allows to define write-only
+        properties.
+        """
+        self.__name__ = None
+        self.__doc__ = None
+        self._signature = signature
+        self._dbus_interface = dbus_interface
+        self._dbus_property = dbus_property
+        self._getf = None
+        self._setf = None
+        self._implicit_setter = setter
+
+    def __repr__(self):
+        return "<dbus.service.property {!r}>".format(self.__name__)
+
+    @_property
+    def dbus_access_flag(self):
+        """
+        access flag of this DBus property
+
+        :returns: either "readwrite", "read" or "write"
+        :raises TypeError: if the property is ill-defined
+        """
+        if self._getf and self._setf:
+            return "readwrite"
+        elif self._getf:
+            return "read"
+        elif self._setf:
+            return "write"
+        else:
+            raise TypeError(
+                "property provides neither readable nor writable")
+
+    @_property
+    def dbus_interface(self):
+        """
+        name of the DBus interface of this DBus property
+        """
+        return self._dbus_interface
+
+    @_property
+    def dbus_property(self):
+        """
+        name of this DBus property
+        """
+        return self._dbus_property
+
+    @_property
+    def signature(self):
+        """
+        signature of this DBus property
+        """
+        return self._signature
+
+    @_property
+    def setter(self):
+        """
+        decorator for setter functions
+
+        This property can be used to decorate additional method that
+        will be used as a property setter. Otherwise properties cannot
+        be assigned.
+        """
+        def decorator(func):
+            self._setf = func
+            return self
+        return decorator
+
+    @_property
+    def getter(self):
+        """
+        decorator for getter functions
+
+        This property can be used to decorate additional method that
+        will be used as a property getter. It is only provider for parity
+        as by default, the @dbus.service.property() decorator designates
+        a getter function. This behavior can be controlled by passing
+        setter=True to the property initializer.
+        """
+        def decorator(func):
+            self._getf = func
+            return self
+        return decorator
+
+    def __call__(self, func):
+        """
+        Decorate a getter function and return the property object
+
+        This method sets __name__, __doc__ and _dbus_property.
+        """
+        self.__name__ = func.__name__
+        if self.__doc__ is None:
+            self.__doc__ = func.__doc__
+        if self._dbus_property is None:
+            self._dbus_property = func.__name__
+        if self._implicit_setter:
+            return self.setter(func)
+        else:
+            return self.getter(func)
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        else:
+            if self._getf is None:
+                raise dbus.exceptions.DBusException(
+                    "property is not readable")
+            return self._getf(instance)
+
+    def __set__(self, instance, value):
+        if self._setf is None:
+            raise dbus.exceptions.DBusException(
+                "property is not writable")
+        self._setf(instance, value)
+
+    # This little helper is here is to help :meth:`Object.Introspect()`
+    # figure out how to handle properties.
+    _dbus_is_property = True
+
+
+class Object(Interface, dbus.service.Object):
+    """
+    dbus.service.Object subclass that providers additional features.
+
+    This class providers the following additional features:
+
+    * Implementation of the PROPERTIES_IFACE. This includes the methods
+      Get(), Set(), GetAll() and the signal PropertiesChanged()
+
+    * Implementation of the OBJECT_MANAGER_IFACE. This includes the method
+      GetManagedObjects() and signals InterfacesAdded() and
+      InterfacesRemoved().
+
+    * Tracking of object-path-to-object association using the new
+      :meth:`find_object_by_path()` method
+
+    * Selective activation of any of the above interfaces using
+      :meth:`should_expose_interface()` method.
+
+    * Improved version of the INTROSPECTABLE_IFACE that understands properties
+    """
+
+    def __init__(self, conn=None, object_path=None, bus_name=None):
+        dbus.service.Object.__init__(self, conn, object_path, bus_name)
+        self._managed_object_list = []
+
+    # [ Public DBus methods of the INTROSPECTABLE_IFACE interface ]
+
+    @method(
+        dbus_interface=INTROSPECTABLE_IFACE,
+        in_signature='', out_signature='s',
+        path_keyword='object_path', connection_keyword='connection')
+    def Introspect(self, object_path, connection):
+        """
+        Return a string of XML encoding this object's supported interfaces,
+        methods and signals.
+        """
+        logger.debug("Introspect(object_path=%r)", object_path)
+        reflection_data = (
+            _dbus_bindings.DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE)
+        reflection_data += '<node name="%s">\n' % object_path
+        interfaces = self._dct_entry
+        for (name, funcs) in interfaces.items():
+            # Allow classes to ignore certain interfaces This is useful because
+            # this class implements all kinds of methods internally (for
+            # simplicity) but does not really advertise them all directly
+            # unless asked to.
+            if not self.should_expose_interface(name):
+                continue
+            reflection_data += '  <interface name="%s">\n' % (name)
+            for func in funcs.values():
+                if getattr(func, '_dbus_is_method', False):
+                    reflection_data += self.__class__._reflect_on_method(func)
+                elif getattr(func, '_dbus_is_signal', False):
+                    reflection_data += self.__class__._reflect_on_signal(func)
+                elif getattr(func, '_dbus_is_property', False):
+                    reflection_data += (
+                        self.__class__._reflect_on_property(func))
+            reflection_data += '  </interface>\n'
+        for name in connection.list_exported_child_objects(object_path):
+            reflection_data += '  <node name="%s"/>\n' % name
+        reflection_data += '</node>\n'
+        logger.debug("Introspect() returns: %s", reflection_data)
+        return reflection_data
+
+    # [ Public DBus methods of the PROPERTIES_IFACE interface ]
+
+    @dbus.service.method(
+        dbus_interface=dbus.PROPERTIES_IFACE,
+        in_signature="ss", out_signature="v")
+    def Get(self, interface_name, property_name):
+        """
+        Get the value of a property @property_name on interface
+        @interface_name.
+        """
+        logger.debug(
+            "%r.Get(%r, %r) -> ...",
+            self, interface_name, property_name)
+        try:
+            props = self._dct_entry[interface_name]
+        except KeyError:
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "No such interface {}".format(interface_name))
+        try:
+            prop = props[property_name]
+        except KeyError:
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "No such property {}:{}".format(
+                    interface_name, property_name))
+        try:
+            value = prop.__get__(self, self.__class__)
+        except dbus.exceptions.DBusException:
+            raise
+        except Exception as exc:
+            logger.exception(
+                "runaway exception from Get(%r, %r)",
+                interface_name, property_name)
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "Unable to get property interface/property {}:{}: {!r}".format(
+                    interface_name, property_name, exc))
+        else:
+            logger.debug(
+                "%r.Get(%r, %r) -> %r",
+                self, interface_name, property_name, value)
+            return value
+
+    @dbus.service.method(
+        dbus_interface=dbus.PROPERTIES_IFACE,
+        in_signature="ssv", out_signature="")
+    def Set(self, interface_name, property_name, value):
+        logger.debug(
+            "%r.Set(%r, %r, %r) -> ...",
+            self, interface_name, property_name, value)
+        try:
+            props = self._dct_entry[interface_name]
+        except KeyError:
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "No such interface {}".format(interface_name))
+        try:
+            # Map the real property name
+            prop = {
+                prop.dbus_property: prop
+                for prop in props.values()
+                if isinstance(prop, property)
+            }[property_name]
+            if not isinstance(prop, property):
+                raise KeyError(property_name)
+        except KeyError:
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "No such property {}:{}".format(
+                    interface_name, property_name))
+        try:
+            prop.__set__(self, value)
+        except dbus.exceptions.DBusException:
+            raise
+        except Exception as exc:
+            logger.exception(
+                "runaway exception from %r.Set(%r, %r, %r)",
+                self, interface_name, property_name, value)
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "Unable to set property {}:{}: {!r}".format(
+                    interface_name, property_name, exc))
+        logger.debug(
+            "%r.Set(%r, %r, %r) -> None",
+            self, interface_name, property_name, value)
+
+    @dbus.service.method(
+        dbus_interface=dbus.PROPERTIES_IFACE,
+        in_signature="s", out_signature="a{sv}")
+    def GetAll(self, interface_name):
+        logger.debug("%r.GetAll(%r)", self, interface_name)
+        try:
+            props = self._dct_entry[interface_name]
+        except KeyError:
+            raise dbus.exceptions.DBusException(
+                dbus.PROPERTIES_IFACE,
+                "No such interface {}".format(interface_name))
+        result = {}
+        for prop in props.values():
+            if not isinstance(prop, property):
+                continue
+            prop_name = prop.dbus_property
+            try:
+                prop_value = prop.__get__(self, self.__class__)
+            except:
+                logger.exception(
+                    "Unable to read property %r from %r", prop, self)
+            else:
+                result[prop_name] = prop_value
+        return result
+
+    @dbus.service.signal(
+        dbus_interface=dbus.PROPERTIES_IFACE,
+        signature='sa{sv}as')
+    def PropertiesChanged(
+            self, interface_name, changed_properties, invalidated_properties):
+        logger.debug(
+            "PropertiesChanged(%r, %r, %r)",
+            interface_name, changed_properties, invalidated_properties)
+
+    # [ Public DBus methods of the OBJECT_MANAGER_IFACE interface ]
+
+    @dbus.service.method(
+        dbus_interface=OBJECT_MANAGER_IFACE,
+        in_signature="", out_signature="a{oa{sa{sv}}}")
+    def GetManagedObjects(self):
+        logger.debug("%r.GetManagedObjects() -> ...", self)
+        result = {}
+        for obj in self._managed_object_list:
+            logger.debug("Looking for stuff exported by %r", obj)
+            result[obj] = {}
+            for iface_name in obj._dct_entry.keys():
+                props = obj.GetAll(iface_name)
+                if len(props):
+                    result[obj][iface_name] = props
+        logger.debug("%r.GetManagedObjects() -> %r", self, result)
+        return result
+
+    @dbus.service.signal(
+        dbus_interface=OBJECT_MANAGER_IFACE,
+        signature='oa{sa{sv}}')
+    def InterfacesAdded(self, object_path, interfaces_and_properties):
+        logger.debug("%r.InterfacesAdded(%r, %r)",
+                     self, object_path, interfaces_and_properties)
+
+    @dbus.service.signal(
+        dbus_interface=OBJECT_MANAGER_IFACE, signature='oas')
+    def InterfacesRemoved(self, object_path, interfaces):
+        logger.debug("%r.InterfacesRemoved(%r, %r)",
+                     self, object_path, interfaces)
+
+    # [ Overridden methods of dbus.service.Object ]
+
+    def add_to_connection(self, connection, path):
+        """
+        Version of dbus.service.Object.add_to_connection() that keeps track of
+        all object paths.
+        """
+        with self._object_path_map_lock:
+            # Super-call add_to_connection(). This can fail which is
+            # okay as we haven't really modified anything yet.
+            super(Object, self).add_to_connection(connection, path)
+            # Touch self.connection, this will fail if the call above failed
+            # and self._connection (mind the leading underscore) is still None.
+            # It will also fail if the object is being exposed on multiple
+            # connections (so self._connection is _MANY). We are interested in
+            # the second check as _MANY connections are not supported here.
+            self.connection
+            # If everything is okay, just add the specified path to the
+            # _object_path_to_object_map.
+            self._object_path_to_object_map[path] = self
+
+    def remove_from_connection(self, connection=None, path=None):
+        with self._object_path_map_lock:
+            # Touch self.connection, this triggers a number of interesting
+            # checks, in particular checks for self._connection (mind the
+            # leading underscore) being _MANY or being None. Both of those
+            # throw an AttributeError that we can simply propagate at this
+            # point.
+            self.connection
+            # Create a copy of locations. This is required because locations
+            # are modified by remove_from_connection() which can also fail.  If
+            # we were to use self.locations here directly we would have to undo
+            # any changes if remove_from_connection() raises an exception.
+            # Instead it is easier to first super-call remove_from_connection()
+            # and then do what we need to at this layer, after
+            # remove_from_connection() finishes successfully.
+            locations_copy = list(self.locations)
+            # Super-call remove_from_connection()
+            super(Object, self).remove_from_connection(connection, path)
+            # If either path or connection are none then treat them like
+            # match-any wild-cards. The same logic is implemented in the
+            # superclass version of this method.
+            if path is None or connection is None:
+                # Location is a tuple of at least two elements, connection and
+                # path. There may be other elements added later so let's not
+                # assume this is a simple pair.
+                for location in locations_copy:
+                    location_conn = location[0]
+                    location_path = location[1]
+                    # If (connection matches or is None)
+                    # and (path matches or is None)
+                    # then remove that association
+                    if ((location_conn == connection or connection is None)
+                            and (path == location_path or path is None)):
+                        del self._object_path_to_object_map[location_path]
+            else:
+                # If connection and path were specified, just remove the
+                # association from the specified path.
+                del self._object_path_to_object_map[path]
+
+    # [ Custom Extension Methods ]
+
+    def should_expose_interface(self, iface_name):
+        """
+        Check if the specified interface should be exposed.
+
+        This method controls which of the interfaces are visible as implemented
+        by this Object. By default objects don't implement any interface expect
+        for PEER_IFACE. There are two more interfaces that are implemented
+        internally but need to be explicitly exposed: the PROPERTIES_IFACE and
+        OBJECT_MANAGER_IFACE.
+
+        Typically subclasses should NOT override this method, instead
+        subclasses should define class-scope HIDDEN_INTERFACES as a
+        frozenset() of classes to hide and remove one of the entries found in
+        _STD_INTERFACES from it to effectively enable that interface.
+        """
+        return iface_name not in self.HIDDEN_INTERFACES
+
+    @classmethod
+    def find_object_by_path(cls, object_path):
+        """
+        Find and return the object that is exposed as object_path on any
+        connection. Using multiple connections is not supported at this time.
+
+        .. note::
+            This obviously only works for objects exposed from the same
+            application. The main use case is to have a way to lookup object
+            paths that may be passed as arguments and also originate in the
+            same application.
+        """
+        # XXX: ideally this would be per-connection method.
+        with cls._object_path_map_lock:
+            return cls._object_path_to_object_map[object_path]
+
+    @_property
+    def managed_objects(self):
+        """
+        list of of managed objects.
+
+        This collection is a part of the OBJECT_MANAGER_IFACE. While it can be
+        manipulated directly (technically) it should only be manipulated using
+        :meth:`add_managed_object()`, :meth:`add_manage_object_list()`,
+        :meth:`remove_managed_object()` and
+        :meth:`remove_managed_object_list()` as they send appropriate DBus
+        signals.
+        """
+        return self._managed_object_list
+
+    def add_managed_object(self, obj):
+        self.add_managed_object_list([obj])
+
+    def remove_managed_object(self, obj):
+        self.remove_managed_object_list([obj])
+
+    def add_managed_object_list(self, obj_list):
+        logger.debug("Adding managed objects: %s", obj_list)
+        for obj in obj_list:
+            if not isinstance(obj, Object):
+                raise TypeError("obj must be of type {!r}".format(Object))
+        old = self._managed_object_list
+        new = list(old)
+        new.extend(obj_list)
+        self._managed_object_list = new
+        self._on_managed_objects_changed(old, new)
+
+    def remove_managed_object_list(self, obj_list):
+        logger.debug("Removing managed objects: %s", obj_list)
+        for obj in obj_list:
+            if not isinstance(obj, Object):
+                raise TypeError("obj must be of type {!r}".format(Object))
+        old = self._managed_object_list
+        new = list(old)
+        for obj in obj_list:
+            new.remove(obj)
+        self._managed_object_list = new
+        self._on_managed_objects_changed(old, new)
+
+    # [ Custom Private Implementation Data ]
+
+    _STD_INTERFACES = frozenset([
+        INTROSPECTABLE_IFACE,
+        OBJECT_MANAGER_IFACE,
+        # TODO: peer interface is not implemented in this class
+        # PEER_IFACE,
+        PROPERTIES_IFACE
+    ])
+
+    HIDDEN_INTERFACES = frozenset([
+        OBJECT_MANAGER_IFACE,
+        PROPERTIES_IFACE
+    ])
+
+    # Lock protecting access to _object_path_to_object_map.
+    # XXX: ideally this would be a per-connection attribute
+    _object_path_map_lock = threading.Lock()
+
+    # Map of object_path -> dbus.service.Object instances
+    # XXX: ideally this would be a per-connection attribute
+    _object_path_to_object_map = weakref.WeakValueDictionary()
+
+    # [ Custom Private Implementation Methods ]
+
+    @_property
+    def _dct_key(self):
+        """
+        the key indexing this Object in Object.__class__._dbus_class_table
+        """
+        return self.__class__.__module__ + '.' + self.__class__.__name__
+
+    @_property
+    def _dct_entry(self):
+        """
+        same as self.__class__._dbus_class_table[self._dct_key]
+        """
+        return self.__class__._dbus_class_table[self._dct_key]
+
+    @Signal.define
+    def _on_managed_objects_changed(self, old_objs, new_objs):
+        logger.debug("%r._on_managed_objects_changed(%r, %r)",
+                     self, old_objs, new_objs)
+        for obj in frozenset(new_objs) - frozenset(old_objs):
+            ifaces_and_props = {}
+            for iface_name in obj._dct_entry.keys():
+                try:
+                    props = obj.GetAll(iface_name)
+                except dbus.exceptions.DBusException as exc:
+                    logger.warning("Caught %r", exc)
+                else:
+                    if len(props):
+                        ifaces_and_props[iface_name] = props
+            self.InterfacesAdded(obj.__dbus_object_path__, ifaces_and_props)
+        for obj in frozenset(old_objs) - frozenset(new_objs):
+            ifaces = list(obj._dct_entry.keys())
+            self.InterfacesRemoved(obj.__dbus_object_path__, ifaces)
+
+
+class ObjectWrapper(Object):
+    """
+    Wrapper for a single python object which makes it easier to expose over
+    DBus as a service. The object should be injected into something that
+    extends dbus.service.Object class.
+
+    The class maintains an association between each wrapper and native object
+    and offers methods for converting between the two.
+    """
+
+    # Lock protecting access to _native_id_to_wrapper_map
+    _native_id_map_lock = threading.Lock()
+
+    # Man of id(wrapper.native) -> wrapper
+    _native_id_to_wrapper_map = weakref.WeakValueDictionary()
+
+    def __init__(self, native, conn=None, object_path=None, bus_name=None):
+        """
+        Create a new wrapper for the specified native object
+        """
+        super(ObjectWrapper, self).__init__(conn, object_path, bus_name)
+        with self._native_id_map_lock:
+            self._native_id_to_wrapper_map[id(native)] = self
+        self._native = native
+
+    @_property
+    def native(self):
+        """
+        native python object being wrapped by this wrapper
+        """
+        return self._native
+
+    @classmethod
+    def find_wrapper_by_native(cls, native):
+        """
+        Find the wrapper associated with the specified native object
+        """
+        with cls._native_id_map_lock:
+            return cls._native_id_to_wrapper_map[id(native)]

=== modified file 'plainbox/plainbox/impl/exporter/__init__.py'
--- plainbox/plainbox/impl/exporter/__init__.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/exporter/__init__.py	2013-09-13 17:12:45 +0000
@@ -148,6 +148,9 @@
                 continue
             data['result_map'][job_name] = OrderedDict()
             data['result_map'][job_name]['outcome'] = job_state.result.outcome
+            if job_state.result.execution_duration:
+                data['result_map'][job_name]['execution_duration'] = \
+                    job_state.result.execution_duration
             if self.OPTION_WITH_COMMENTS in self._option_list:
                 data['result_map'][job_name]['comments'] = \
                     job_state.result.comments
@@ -155,12 +158,12 @@
             # Add Parent hash if requested
             if self.OPTION_WITH_JOB_VIA in self._option_list:
                 data['result_map'][job_name]['via'] = \
-                    job_state.result.job.via
+                    job_state.job.via
 
             # Add Job hash if requested
             if self.OPTION_WITH_JOB_HASH in self._option_list:
                 data['result_map'][job_name]['hash'] = \
-                    job_state.result.job.get_checksum()
+                    job_state.job.get_checksum()
 
             # Add Job definitions if requested
             if self.OPTION_WITH_JOB_DEFS in self._option_list:
@@ -170,17 +173,17 @@
                              'command',
                              'description',
                              ):
-                    if not getattr(job_state.result.job, prop):
+                    if not getattr(job_state.job, prop):
                         continue
                     data['result_map'][job_name][prop] = getattr(
-                        job_state.result.job, prop)
+                        job_state.job, prop)
 
             # Add Attachments if requested
-            if job_state.result.job.plugin == 'attachment':
+            if job_state.job.plugin == 'attachment':
                 if self.OPTION_WITH_ATTACHMENTS in self._option_list:
                     raw_bytes = b''.join(
                         (record[2] for record in
-                         job_state.result.io_log if record[1] == 'stdout'))
+                         job_state.result.get_io_log() if record[1] == 'stdout'))
                     data['attachment_map'][job_name] = \
                         base64.standard_b64encode(raw_bytes).decode('ASCII')
                 continue  # Don't add attachments IO logs to the result_map
@@ -191,12 +194,12 @@
                 # saved, discarding stream name and the relative timestamp.
                 if self.OPTION_SQUASH_IO_LOG in self._option_list:
                     io_log_data = self._squash_io_log(
-                        job_state.result.io_log)
+                        job_state.result.get_io_log())
                 elif self.OPTION_FLATTEN_IO_LOG in self._option_list:
                     io_log_data = self._flatten_io_log(
-                        job_state.result.io_log)
+                        job_state.result.get_io_log())
                 else:
-                    io_log_data = self._io_log(job_state.result.io_log)
+                    io_log_data = self._io_log(job_state.result.get_io_log())
                 data['result_map'][job_name]['io_log'] = io_log_data
         return data
 
@@ -288,8 +291,10 @@
     for entry_point in sorted(iterator, key=lambda ep: ep.name):
         try:
             exporter_cls = entry_point.load()
+        except pkg_resources.DistributionNotFound as exc:
+            logger.info("Unable to load %s: %s", entry_point, exc)
         except ImportError as exc:
-            logger.exception("Unable to import {}: {}", entry_point, exc)
+            logger.exception("Unable to import %s: %s", entry_point, exc)
         else:
             exporter_map[entry_point.name] = exporter_cls
     return exporter_map

=== added file 'plainbox/plainbox/impl/exporter/html.py'
--- plainbox/plainbox/impl/exporter/html.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/exporter/html.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,145 @@
+# This file is part of Checkbox.
+#
+# Copyright 2013 Canonical Ltd.
+# Written by:
+#   Sylvain Pineau <[e-mail]>
+#   Zygmunt Krynicki <[e-mail]>
+#   Daniel Manrique <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`plainbox.impl.exporter.html`
+==================================
+
+HTML exporter for human consumption
+
+.. warning::
+    THIS MODULE DOES NOT HAVE A STABLE PUBLIC API
+"""
+
+from string import Template
+import base64
+import logging
+import mimetypes
+
+from lxml import etree as ET
+from pkg_resources import resource_filename
+
+from plainbox.impl.exporter.xml import XMLSessionStateExporter
+
+
+logger = logging.getLogger("plainbox.exporter.html")
+
+
+class HTMLResourceInliner(object):
+    """ A helper class to inline resources referenced in an lxml tree.
+    """
+    def _resource_content(self, url):
+        try:
+            with open(url, 'rb') as f:
+                file_contents = f.read()
+        except (IOError, OSError):
+            logger.warning("Unable to load resource %s, not inlining",
+                           url)
+            return ""
+        type, encoding = mimetypes.guess_type(url)
+        if not encoding:
+            encoding = "utf-8"
+        if type in("text/css", "application/javascript"):
+            return file_contents.decode(encoding)
+        elif type in("image/png", "image/jpg"):
+            b64_data = base64.b64encode(file_contents)
+            b64_data = b64_data.decode("ascii")
+            return_string = "data:{};base64,{}".format(type, b64_data)
+            return return_string
+        else:
+            logger.warning("Resource of type %s unknown", type)
+            #Strip it out, better not to have it.
+            return ""
+
+    def inline_resources(self, document_tree):
+        """
+        Replace references to external resources by an in-place (inlined)
+        representation of each resource.
+
+        Currently images, stylesheets and scripts are inlined.
+
+        Only local (i.e. file) resources/locations are supported. If a
+        non-local resource is requested for inlining, it will be removed
+        (replaced by a blank string), with the goal that the resulting
+        lxml tree will not reference any unreachable resources.
+
+        :param document_tree:
+            lxml tree to process.
+
+        :returns:
+            lxml tree with some elements replaced by their inlined
+            representation.
+        """
+        # Try inlining using result_tree here.
+        for node in document_tree.xpath('//script'):
+            # These have  src attribute, need to remove the
+            # attribute and add the content of the src file
+            # as the node's text
+            src = node.attrib.pop('src')
+            node.text = self._resource_content(src)
+
+        for node in document_tree.xpath('//link[@rel="stylesheet"]'):
+            # These have a href attribute and need to be completely replaced
+            # by a new <style> node with contents of the href file
+            # as its text.
+            src = node.attrib.pop('href')
+            type = node.attrib.pop('type')
+            style_elem = ET.Element("style")
+            style_elem.attrib['type'] = type
+            style_elem.text = self._resource_content(src)
+            node.getparent().append(style_elem)
+            # Now zorch the existing node
+            node.getparent().remove(node)
+
+        for node in document_tree.xpath('//img'):
+            # src attribute points to a file and needs to
+            # contain the base64 encoded version of that file.
+            src = node.attrib.pop('src')
+            node.attrib['src'] = self._resource_content(src)
+        return document_tree
+
+
+class HTMLSessionStateExporter(XMLSessionStateExporter):
+    """
+    Session state exporter creating HTML documents.
+
+    It basically applies an xslt to the XMLSessionStateExporter output,
+    and then inlines some resources to produce a monolithic report in a
+    single file.
+    """
+
+    def dump(self, data, stream):
+        """
+        Public method to dump the HTML report to a stream
+        """
+        root = self.get_root_element(data)
+        self.xslt_filename = resource_filename(
+            "plainbox", "data/report/checkbox.xsl")
+        template_substitutions = {
+            'PLAINBOX_ASSETS': resource_filename("plainbox", "data/")}
+        with open(self.xslt_filename, encoding="UTF-8") as xslt_file:
+            xslt_template = Template(xslt_file.read())
+        xslt_data = xslt_template.substitute(template_substitutions)
+        xslt_root = ET.XML(xslt_data)
+        transformer = ET.XSLT(xslt_root)
+        r_tree = transformer(root)
+        inlined_result_tree = HTMLResourceInliner().inline_resources(r_tree)
+        stream.write(ET.tostring(inlined_result_tree, pretty_print=True))

=== added file 'plainbox/plainbox/impl/exporter/test_html.py'
--- plainbox/plainbox/impl/exporter/test_html.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/exporter/test_html.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,142 @@
+# This file is part of Checkbox.
+#
+# Copyright 2013 Canonical Ltd.
+# Written by:
+#   Sylvain Pineau <[e-mail]>
+#   Zygmunt Krynicki <[e-mail]>
+#   Daniel Manrique <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+plainbox.impl.exporter.test_html
+================================
+
+Test definitions for plainbox.impl.exporter.html module
+"""
+from io import StringIO
+from string import Template
+from unittest import TestCase
+import io
+
+from lxml import etree as ET
+from pkg_resources import resource_filename
+from pkg_resources import resource_string
+
+from plainbox.testing_utils import resource_json
+from plainbox.impl.exporter.html import HTMLResourceInliner
+from plainbox.impl.exporter.html import HTMLSessionStateExporter
+
+
+class HTMLInlinerTests(TestCase):
+    def setUp(self):
+        template_substitutions = {
+            'PLAINBOX_ASSETS': resource_filename("plainbox", "data/")}
+        test_file_location = "test-data/html-exporter/html-inliner.html"
+        test_file = resource_filename("plainbox",
+                                      test_file_location)
+        with open(test_file) as html_file:
+            html_template = Template(html_file.read())
+        html_content = html_template.substitute(template_substitutions)
+        self.tree = ET.parse(StringIO(html_content), ET.HTMLParser())
+        # Now self.tree contains a tree with adequately-substituted
+        # paths and resources
+        inliner = HTMLResourceInliner()
+        self.inlined_tree = inliner.inline_resources(self.tree)
+
+    def test_script_inlining(self):
+        """Test that a <script> resource gets inlined."""
+        for node in self.inlined_tree.xpath('//script'):
+            self.assertTrue(node.text)
+
+    def test_img_inlining(self):
+        """
+        Test that a <img> gets inlined.
+        It should be replaced by a base64 representation of the
+        referenced image's data as per RFC2397.
+        """
+        for node in self.inlined_tree.xpath('//img'):
+            # Skip image that purposefully points to a remote
+            # resource
+            if node.attrib.get('class') != "remote_resource":
+                self.assertTrue("base64" in node.attrib['src'])
+
+    def test_css_inlining(self):
+        """Test that a <style> resource gets inlined."""
+        for node in self.inlined_tree.xpath('//style'):
+            # Skip a fake remote_resource node that's purposefully
+            # not inlined
+            if not 'nonexistent_resource' in node.attrib['type']:
+                self.assertTrue("body" in node.text)
+
+    def test_remote_resource_inlining(self):
+        """
+        Test that a resource with a non-local (i.e. not file://
+        url) does NOT get inlined (rather it's replaced by an
+        empty string). We use <style> in this test.
+        """
+        for node in self.inlined_tree.xpath('//style'):
+            # The not-inlined remote_resource
+            if 'nonexistent_resource' in node.attrib['type']:
+                self.assertTrue(node.text == "")
+
+    def test_unfindable_file_inlining(self):
+        """
+        Test that a resource whose file does not exist does NOT
+        get inlined, and is instead replaced by empty string.
+        We use <img> in this test.
+        """
+        for node in self.inlined_tree.xpath('//img'):
+            if node.attrib.get('class') == "remote_resource":
+                self.assertEqual("", node.attrib['src'])
+
+
+class HTMLExporterTests(TestCase):
+
+    def setUp(self):
+        data = resource_json(
+            "plainbox", "test-data/xml-exporter/example-data.json",
+            exact=True)
+        exporter = HTMLSessionStateExporter(
+            system_id="",
+            timestamp="2012-12-21T12:00:00",
+            client_version="1.0")
+        stream = io.BytesIO()
+        exporter.dump(data, stream)
+        self.actual_result = stream.getvalue()  # This is bytes
+        self.assertIsInstance(self.actual_result, bytes)
+
+    def test_html_output(self):
+        """
+        Test that output from the exporter is HTML (or at least,
+        appears to be).
+        """
+        # A pretty simplistic test since we just validate the output
+        # appears to be HTML. Looking at the exporter's code, it's mostly
+        # boilerplate use of lxml and etree, so let's not fall into testing
+        # an external library.
+        self.assertIn(b"<html>",
+                      self.actual_result)
+        self.assertIn(b"<title>System Testing Report</title>",
+                      self.actual_result)
+
+    def test_perfect_match(self):
+        """
+        Test that output from the exporter exactly matches known
+        good HTML output, inlining and everything included.
+        """
+        expected_result = resource_string(
+            "plainbox", "test-data/html-exporter/example-data.html"
+        )  # unintuitively, resource_string returns bytes
+        self.assertEqual(self.actual_result, expected_result)

=== modified file 'plainbox/plainbox/impl/exporter/test_init.py'
--- plainbox/plainbox/impl/exporter/test_init.py	2013-06-22 06:06:21 +0000
+++ plainbox/plainbox/impl/exporter/test_init.py	2013-09-13 17:12:45 +0000
@@ -29,13 +29,14 @@
 from tempfile import TemporaryDirectory
 from unittest import TestCase
 
+from plainbox.abc import IJobResult
 from plainbox.impl.exporter import ByteStringStreamTranslator
 from plainbox.impl.exporter import SessionStateExporterBase
 from plainbox.impl.exporter import classproperty
 from plainbox.impl.job import JobDefinition
-from plainbox.impl.result import JobResult, IOLogRecord
+from plainbox.impl.result import MemoryJobResult, IOLogRecord
 from plainbox.impl.session import SessionState
-from plainbox.impl.testing_utils import make_io_log, make_job, make_job_result
+from plainbox.impl.testing_utils import make_job, make_job_result
 
 
 class ClassPropertyTests(TestCase):
@@ -76,8 +77,8 @@
         job_b = make_job('job_b')
         session = SessionState([job_a, job_b])
         session.update_desired_job_list([job_a, job_b])
-        result_a = make_job_result(job_a, 'pass')
-        result_b = make_job_result(job_b, 'fail')
+        result_a = make_job_result(outcome=IJobResult.OUTCOME_PASS)
+        result_b = make_job_result(outcome=IJobResult.OUTCOME_FAIL)
         session.update_job_result(job_a, result_a)
         session.update_job_result(job_b, result_b)
         return session
@@ -115,22 +116,16 @@
         })
         session = SessionState([job_a, job_b])
         session.update_desired_job_list([job_a, job_b])
-        result_a = JobResult({
-            'job': job_a,
-            'outcome': 'pass',
+        result_a = MemoryJobResult({
+            'outcome': IJobResult.OUTCOME_PASS,
             'return_code': 0,
-            'io_log': make_io_log(
-                (IOLogRecord(0, 'stdout', b'testing\n'),),
-                session_dir)
+            'io_log': [(0, 'stdout', b'testing\n')],
         })
-        result_b = JobResult({
-            'job': job_b,
-            'outcome': 'pass',
+        result_b = MemoryJobResult({
+            'outcome': IJobResult.OUTCOME_PASS,
             'return_code': 0,
             'comments': 'foo',
-            'io_log': make_io_log(
-                (IOLogRecord(0, 'stdout', b'ready: yes\n'),),
-                session_dir)
+            'io_log': [(0, 'stdout', b'ready: yes\n')],
         })
         session.update_job_result(job_a, result_a)
         session.update_job_result(job_b, result_b)

=== added file 'plainbox/plainbox/impl/exporter/xlsx.py'
--- plainbox/plainbox/impl/exporter/xlsx.py	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/exporter/xlsx.py	2013-09-13 17:12:45 +0000
@@ -0,0 +1,570 @@
+# This file is part of Checkbox.
+#
+# Copyright 2013 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 as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Checkbox is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Checkbox.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+:mod:`plainbox.impl.exporter.xlsx`
+=================================
+
+XLSX exporter
+
+.. warning::
+    THIS MODULE DOES NOT HAVE A STABLE PUBLIC API
+"""
+
+from base64 import standard_b64decode
+from collections import defaultdict, OrderedDict
+import re
+
+from plainbox.impl.exporter import SessionStateExporterBase
+from plainbox.abc import IJobResult
+from xlsxwriter.workbook import Workbook
+from xlsxwriter.utility import xl_rowcol_to_cell
+
+
+class XLSXSessionStateExporter(SessionStateExporterBase):
+    """
+    Session state exporter creating XLSX documents
+
+    The hardware devices are extracted from the content of the following
+    attachment:
+        * lspci_attachment
+
+    The following resource jobs are needed to populate the system info section
+    of this report:
+        * dmi
+        * device
+        * cpuinfo
+        * meminfo
+        * package
+    """
+
+    OPTION_WITH_SYSTEM_INFO = 'with-sys-info'
+    OPTION_WITH_SUMMARY = 'with-summary'
+    OPTION_WITH_DESCRIPTION = 'with-job-description'
+    OPTION_WITH_TEXT_ATTACHMENTS = 'with-text-attachments'
+
+    SUPPORTED_OPTION_LIST = (
+        OPTION_WITH_SYSTEM_INFO,
+        OPTION_WITH_SUMMARY,
+        OPTION_WITH_DESCRIPTION,
+        OPTION_WITH_TEXT_ATTACHMENTS,
+    )
+
+    def __init__(self, option_list=None):
+        """
+        Initialize a new XLSXSessionStateExporter.
+        """
+        # Super-call with empty option list
+        super(XLSXSessionStateExporter, self).__init__(())
+        # All the "options" are simply a required configuration element and are
+        # not optional in any way. There is no way to opt-out.
+        if option_list is None:
+            option_list = ()
+        for option in option_list:
+            if option not in self.supported_option_list:
+                raise ValueError("Unsupported option: {}".format(option))
+        self._option_list = (
+            SessionStateExporterBase.OPTION_WITH_IO_LOG,
+            SessionStateExporterBase.OPTION_FLATTEN_IO_LOG,
+            SessionStateExporterBase.OPTION_WITH_JOB_DEFS,
+            SessionStateExporterBase.OPTION_WITH_JOB_VIA,
+            SessionStateExporterBase.OPTION_WITH_JOB_HASH,
+            SessionStateExporterBase.OPTION_WITH_RESOURCE_MAP,
+            SessionStateExporterBase.OPTION_WITH_ATTACHMENTS)
+        self._option_list += tuple(option_list)
+        self.total_pass = 0
+        self.total_fail = 0
+        self.total_skip = 0
+        self.total = 0
+
+    def _set_formats(self):
+        # Main Title format (Orange)
+        self.format01 = self.workbook.add_format({
+            'align': 'left', 'size': 24, 'font_color': '#DC4C00',
+        })
+        # Default font
+        self.format02 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'size': 10,
+        })
+        # Titles
+        self.format03 = self.workbook.add_format({
+            'align': 'left', 'size': 12, 'bold': 1,
+        })
+        # Titles + borders
+        self.format04 = self.workbook.add_format({
+            'align': 'left', 'size': 12, 'bold': 1, 'border': 7
+        })
+        # System info with borders
+        self.format05 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'border': 7,
+        })
+        # System info with borders, grayed out background
+        self.format06 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'border': 7, 'bg_color': '#E6E6E6',
+        })
+        # Headlines (center)
+        self.format07 = self.workbook.add_format({
+            'align': 'center', 'size': 10, 'bold': 1,
+        })
+        # Table rows without borders
+        self.format08 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+        })
+        # Table rows without borders, grayed out background
+        self.format09 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'bg_color': '#E6E6E6',
+        })
+        # Green background / Size 8
+        self.format10 = self.workbook.add_format({
+            'align': 'center', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'bg_color': 'lime', 'border': 7, 'border_color': 'white',
+        })
+        # Red background / Size 8
+        self.format11 = self.workbook.add_format({
+            'align': 'center', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'bg_color': 'red', 'border': 7, 'border_color': 'white',
+        })
+        # Gray background / Size 8
+        self.format12 = self.workbook.add_format({
+            'align': 'center', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'bg_color': 'gray', 'border': 7, 'border_color': 'white',
+        })
+        # Attachments
+        self.format13 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'text_wrap': 1, 'size': 8,
+            'font': 'Courier New',
+        })
+        # Invisible man
+        self.format14 = self.workbook.add_format({'font_color': 'white'})
+        # Headlines (left-aligned)
+        self.format15 = self.workbook.add_format({
+            'align': 'left', 'size': 10, 'bold': 1,
+        })
+        # Table rows without borders, indent level 1
+        self.format16 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'size': 8, 'indent': 1,
+        })
+        # Table rows without borders, grayed out background, indent level 1
+        self.format17 = self.workbook.add_format({
+            'align': 'left', 'valign': 'vcenter', 'size': 8,
+            'bg_color': '#E6E6E6', 'indent': 1,
+        })
+
+    def _hw_collection(self, data):
+        hw_info = defaultdict(lambda: 'NA')
+        if 'dmi' in data['resource_map']:
+            result = ['{} {} ({})'.format(i['vendor'], i['product'],
+                      i['version']) for i in data["resource_map"]['dmi']
+                      if i['category'] == 'SYSTEM']
+            if result:
+                hw_info['platform'] = result.pop()
+            result = ['{}'.format(i['version'])
+                      for i in data["resource_map"]['dmi']
+                      if i['category'] == 'BIOS']
+            if result:
+                hw_info['bios'] = result.pop()
+        if 'cpuinfo' in data['resource_map']:
+            result = ['{} x {}'.format(i['model'], i['count'])
+                      for i in data["resource_map"]['cpuinfo']]
+            if result:
+                hw_info['processors'] = result.pop()
+        if 'lspci_attachment' in data['attachment_map']:
+            lspci = data['attachment_map']['lspci_attachment']
+            content = standard_b64decode(lspci.encode()).decode("UTF-8")
+            match = re.search('ISA bridge.*?:\s(?P<chipset>.*?)\sLPC', content)
+            if match:
+                hw_info['chipset'] = match.group('chipset')
+            match = re.search(
+                'Audio device.*?:\s(?P<audio>.*?)\s\[\w+:\w+]', content)
+            if match:
+                hw_info['audio'] = match.group('audio')
+            match = re.search(
+                'Ethernet controller.*?:\s(?P<nic>.*?)\s\[\w+:\w+]', content)
+            if match:
+                hw_info['nic'] = match.group('nic')
+            match = re.search(
+                'Network controller.*?:\s(?P<wireless>.*?)\s\[\w+:\w+]',
+                content)
+            if match:
+                hw_info['wireless'] = match.group('wireless')
+            for i, match in enumerate(re.finditer(
+                'VGA compatible controller.*?:\s(?P<video>.*?)\s\[\w+:\w+]',
+                content), start=1
+            ):
+                hw_info['video{}'.format(i)] = match.group('video')
+            vram = 0
+            for match in re.finditer(
+                    'Memory.+ prefetchable\) \[size=(?P<vram>\d+)M\]',
+                    content):
+                vram += int(match.group('vram'))
+            if vram:
+                hw_info['vram'] = '{} MiB'.format(vram)
+        if 'meminfo' in data['resource_map']:
+            result = ['{} GiB'.format(format(int(i['total']) / 1073741824,
+                      '.1f')) for i in data["resource_map"]['meminfo']]
+            if result:
+                hw_info['memory'] = result.pop()
+        if 'device' in data['resource_map']:
+            result = ['{}'.format(i['product'])
+                      for i in data["resource_map"]['device']
+                      if ('category' in i and
+                      i['category'] == 'BLUETOOTH' and 'driver' in i)]
+            if result:
+                hw_info['bluetooth'] = result.pop()
+        return hw_info
+
+    def write_systeminfo(self, data):
+        self.worksheet1.set_column(0, 0, 4)
+        self.worksheet1.set_column(1, 1, 34)
+        self.worksheet1.set_column(2, 3, 58)
+        hw_info = self._hw_collection(data)
+        self.worksheet1.write(5, 1, 'Platform Name', self.format03)
+        self.worksheet1.write(5, 2, hw_info['platform'], self.format03)
+        self.worksheet1.write(7, 1, 'BIOS', self.format04)
+        self.worksheet1.write(7, 2, hw_info['bios'], self.format06)
+        self.worksheet1.write(8, 1, 'Processors', self.format04)
+        self.worksheet1.write(8, 2, hw_info['processors'], self.format05)
+        self.worksheet1.write(9, 1, 'Chipset', self.format04)
+        self.worksheet1.write(9, 2, hw_info['chipset'], self.format06)
+        self.worksheet1.write(10, 1, 'Memory', self.format04)
+        self.worksheet1.write(10, 2, hw_info['memory'], self.format05)
+        self.worksheet1.write(11, 1, 'Video (on board)', self.format04)
+        self.worksheet1.write(11, 2, hw_info['video1'], self.format06)
+        self.worksheet1.write(12, 1, 'Video (add-on)', self.format04)
+        self.worksheet1.write(12, 2, hw_info['video2'], self.format05)
+        self.worksheet1.write(13, 1, 'Video memory', self.format04)
+        self.worksheet1.write(13, 2, hw_info['vram'], self.format06)
+        self.worksheet1.write(14, 1, 'Audio', self.format04)
+        self.worksheet1.write(14, 2, hw_info['audio'], self.format05)
+        self.worksheet1.write(15, 1, 'NIC', self.format04)
+        self.worksheet1.write(15, 2, hw_info['nic'], self.format06)
+        self.worksheet1.write(16, 1, 'Wireless', self.format04)
+        self.worksheet1.write(16, 2, hw_info['wireless'], self.format05)
+        self.worksheet1.write(17, 1, 'Bluetooth', self.format04)
+        self.worksheet1.write(17, 2, hw_info['bluetooth'], self.format06)
+        if "package" in data["resource_map"]:
+            self.worksheet1.write(19, 1, 'Packages Installed', self.format03)
+            self.worksheet1.write_row(
+                21, 1, ['Name', 'Version'], self.format07
+            )
+            for i in range(20, 22):
+                self.worksheet1.set_row(
+                    i, None, None, {'level': 1, 'hidden': True}
+                )
+            for i, pkg in enumerate(data["resource_map"]["package"]):
+                self.worksheet1.write_row(
+                    22 + i, 1,
+                    [pkg['name'], pkg['version']],
+                    self.format08 if i % 2 else self.format09
+                )
+                self.worksheet1.set_row(
+                    22 + i, None, None, {'level': 1, 'hidden': True}
+                )
+            self.worksheet1.set_row(
+                22+len(data["resource_map"]["package"]),
+                None, None, {'collapsed': True}
+            )
+
+    def write_summary(self, data):
+        self.worksheet2.set_column(0, 0, 5)
+        self.worksheet2.set_column(1, 1, 2)
+        self.worksheet2.set_column(3, 3, 27)
+        self.worksheet2.write(3, 1, 'Failures summary', self.format03)
+        self.worksheet2.write(4, 1, '✔', self.format10)
+        self.worksheet2.write(
+            4, 2,
+            '{} Tests passed - Success Rate: {:.2f}% ({}/{})'.format(
+            self.total_pass, self.total_pass / self.total * 100,
+            self.total_pass, self.total), self.format02)
+        self.worksheet2.write(5, 1, '✘', self.format11)
+        self.worksheet2.write(
+            5, 2,
+            '{} Tests failed - Failure Rate: {:.2f}% ({}/{})'.format(
+            self.total_fail, self.total_fail / self.total * 100,
+            self.total_fail, self.total), self.format02)
+        self.worksheet2.write(6, 1, '-', self.format12)
+        self.worksheet2.write(
+            6, 2,
+            '{} Tests skipped - Skip Rate: {:.2f}% ({}/{})'.format(
+            self.total_skip, self.total_skip / self.total * 100,
+            self.total_skip, self.total), self.format02)
+        self.worksheet2.write_column(
+            'L3', ['Fail', 'Skip', 'Pass'], self.format14)
+        self.worksheet2.write_column(
+            'M3', [self.total_fail, self.total_skip, self.total_pass],
+            self.format14)
+        # Configure the series.
+        chart = self.workbook.add_chart({'type': 'pie'})
+        chart.set_legend({'position': 'none'})
+        chart.add_series({
+            'points': [
+                {'fill': {'color': 'red'}},
+                {'fill': {'color': 'gray'}},
+                {'fill': {'color': 'lime'}},
+            ],
+            'categories': '=Summary!$L$3:$L$5',
+            'values': '=Summary!$M$3:$M$5'}
+        )
+        # Insert the chart into the worksheet.
+        self.worksheet2.insert_chart('F4', chart, {
+            'x_offset': 0, 'y_offset': 10, 'x_scale': 0.25, 'y_scale': 0.25
+        })
+
+    def _set_category_status(self, result_map, via, child):
+        for parent in [j for j in result_map if result_map[j]['hash'] == via]:
+            if 'category_status' not in result_map[parent]:
+                result_map[parent]['category_status'] = None
+            child_status = result_map[child]['outcome']
+            if 'category_status' in result_map[child]:
+                child_status = result_map[child]['category_status']
+            if child_status == IJobResult.OUTCOME_FAIL:
+                result_map[parent]['category_status'] = IJobResult.OUTCOME_FAIL
+            elif (
+                child_status == IJobResult.OUTCOME_PASS and
+                result_map[parent]['category_status'] != IJobResult.OUTCOME_FAIL
+            ):
+                result_map[parent]['category_status'] = IJobResult.OUTCOME_PASS
+            elif (
+                result_map[parent]['category_status'] not in
+                (IJobResult.OUTCOME_PASS, IJobResult.OUTCOME_FAIL)
+            ):
+                result_map[parent]['category_status'] = IJobResult.OUTCOME_SKIP
+
+    def _tree(self, result_map, via=None, level=0, max_level=0):
+        res = {}
+        for job_name in [j for j in result_map if result_map[j]['via'] == via]:
+            if re.search(
+                    'resource|attachment',
+                    result_map[job_name]['plugin']):
+                continue
+            level += 1
+            # Find the maximum depth of the test tree
+            if level > max_level:
+                max_level = level
+            res[job_name], max_level = self._tree(
+                result_map, result_map[job_name]['hash'], level, max_level)
+            # Generate parent categories status
+            if via is not None:
+                self._set_category_status(result_map, via, job_name)
+            level -= 1
+        return res, max_level
+
+    def _write_job(self, tree, result_map, max_level, level=0):
+        for job, children in OrderedDict(
+                sorted(
+                    tree.items(),
+                    key=lambda t: 'z' + t[0] if t[1] else 'a' + t[0])).items():
+            self._lineno += 1
+            if children:
+                self.worksheet3.write(
+                    self._lineno, level + 1,
+                    result_map[job]['description'], self.format15)
+                if (
+                    result_map[job]['category_status'] ==
+                    IJobResult.OUTCOME_PASS
+                ):
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'PASS', self.format10)
+                elif (
+                    result_map[job]['category_status'] ==
+                    IJobResult.OUTCOME_FAIL
+                ):
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'FAIL', self.format11)
+                elif (
+                    result_map[job]['category_status'] ==
+                    IJobResult.OUTCOME_SKIP
+                ):
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'skip', self.format12)
+                if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                    self.worksheet4.write(
+                        self._lineno, level + 1,
+                        result_map[job]['description'], self.format15)
+                if level:
+                    self.worksheet3.set_row(
+                        self._lineno, 13, None, {'level': level})
+                    if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                        self.worksheet4.set_row(
+                            self._lineno, 13, None, {'level': level})
+                else:
+                    self.worksheet3.set_row(self._lineno, 13)
+                    if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                        self.worksheet4.set_row(self._lineno, 13)
+                self._write_job(children, result_map, max_level, level + 1)
+            else:
+                self.worksheet3.write(
+                    self._lineno, max_level + 1, job,
+                    self.format08 if self._lineno % 2 else self.format09)
+                if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                    link_cell = xl_rowcol_to_cell(self._lineno, max_level + 1)
+                    self.worksheet3.write_url(
+                        self._lineno, max_level + 1,
+                        'internal:Test Descriptions!' + link_cell,
+                        self.format08 if self._lineno % 2 else self.format09,
+                        job)
+                    self.worksheet4.write(
+                        self._lineno, max_level + 1, job,
+                        self.format08 if self._lineno % 2 else self.format09)
+                self.total += 1
+                if result_map[job]['outcome'] == IJobResult.OUTCOME_PASS:
+                    self.worksheet3.write(
+                        self._lineno, max_level, '✔', self.format10)
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'PASS', self.format10)
+                    self.total_pass += 1
+                elif result_map[job]['outcome'] == IJobResult.OUTCOME_FAIL:
+                    self.worksheet3.write(
+                        self._lineno, max_level, '✘', self.format11)
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'FAIL', self.format11)
+                    self.total_fail += 1
+                elif result_map[job]['outcome'] == IJobResult.OUTCOME_SKIP:
+                    self.worksheet3.write(
+                        self._lineno, max_level, '-', self.format12)
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, 'skip', self.format12)
+                    self.total_skip += 1
+                elif result_map[job]['outcome'] == \
+                        IJobResult.OUTCOME_NOT_SUPPORTED:
+                    self.worksheet3.write(
+                        self._lineno, max_level, '-', self.format12)
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2,
+                        'not supported', self.format12)
+                    self.total_skip += 1
+                else:
+                    self.worksheet3.write(
+                        self._lineno, max_level, '-',    self.format12)
+                    self.worksheet3.write(
+                        self._lineno, max_level + 2, None, self.format12)
+                    self.total_skip += 1
+                io_log = ' '
+                if result_map[job]['io_log']:
+                    io_log = standard_b64decode(
+                        result_map[job]['io_log'].encode()).decode(
+                            'UTF-8').rstrip()
+                io_lines = len(io_log.splitlines()) - 1
+                desc_lines = len(result_map[job]['description'].splitlines())
+                desc_lines -= 1
+                self.worksheet3.write(
+                    self._lineno, max_level + 3, io_log,
+                    self.format16 if self._lineno % 2 else self.format17)
+                if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                    self.worksheet4.write(
+                        self._lineno, max_level + 2,
+                        result_map[job]['description'],
+                        self.format16 if self._lineno % 2 else self.format17)
+                if level:
+                    self.worksheet3.set_row(
+                        self._lineno, 12 + 9.71 * io_lines,
+                        None, {'level': level})
+                    if self.OPTION_WITH_DESCRIPTION in self._option_list:
+                        self.worksheet4.set_row(
+                            self._lineno, 12 + 9.71 * desc_lines,
+                            None, {'level': level})
+                else: