Merge lp:~ubuntu-branches/ubuntu/saucy/checkbox/saucy-201308281227 into lp:ubuntu/saucy/checkbox

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/saucy/checkbox reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/saucy/checkbox/saucy-201308281227. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

1884. By Daniel Manrique on 2013-05-15

* New upstream release (LP: #1180545):
* Launchpad automated translation updates
* scripts/graphics_stress_test, scripts/rotation_test: make sure to
  always reset the "screen" variable. Somehow the NVIDIA driver manages
  to make it unusable after the first time. (LP: #1172667)
* checkbox/parsers/submission.py - publish kernel-release information to
  interested parties.
* scripts/rendercheck_test - change nargs='+' to action='append' for blacklist
  option so it works as expected.
  jobs/rendercheck.txt.in - blacklist gradients test as it is known to produce
  false positives. (LP: #1093718)
* plugins/hexr_transport.py - added plugin for submitting to HEXR and
  certification based on certify_new_transport from checkbox-certification.
  examples/checkbox-qt.ini - blacklisted hexr_transport as we won't use it
  examples/checkbox-cli.ini - blacklisted hexr_transport as we won't use it
  examples/checkbox-urwid.ini - blacklisted hexr_transport as we won't use it
* Ensured that button strings from the "continue" dialog are translatable
  (LP: #1176695)

* checkbox/parsers/cpuinfo.py - split on first instance of ':' in cpuinfo
  output lines to avoid splitting into more than 2 items. Also fixed a pep8
  issue discovered while working on this. (LP: #1180496)
* scripts/cpu_offlining: Modified script to no longer offline cpu0 to resolve
  a bug on ARM. Modified output so most of it is redirected to stderr for
  fail cases, we don't need that much for success cases. (LP: #1078897)
* jobs/mediacard.txt.in: Modified test instructions to be less confusing
  (LP: #970857)
* scripts/cpu_topology: define the cpuinfo nested dicts on creation rather
  than define elements during parsing of /proc/cpuinfo (LP: #1111878)
* scripts/lsmod_info: Corrected error handling for the check_output() call to
  trap the correct error. (LP: #1103647)
* jobs/camera.txt.in: removed an extraneous requres line for gir1.2
  scripts/camera_test: added code to determine what version of gst we're
  using and set video type and plugin accordingly. (LP: #1100594)
* scripts/network_check: added ability to specify custom target URL for
  debugging failures (LP: #1128017)
* scripts/removable_storage_test: Added error handling to trap OSError on
  non-writable media and modified output to handle subsequent
  ZeroDivisionError issues when summarizing test results.
  jobs/media.txt.in: Modified instructions for SD/SDHC to specify using
  UNLOCKED cards to avoid issues when testing read-only media (LP: #1153894)
* jobs/suspend.txt.in, scripts/gpu_test: Remove the need of running the script
  with the root user, restore the workspaces switch and the HTML5 video
  playback ; remove the extra suspend/resume (LP: #1172851)
* checkbox/parsers/udevadm.py: Only filter devices without product AND vendor
  information (LP: #1167733)

=== modified file 'checkbox/parsers/cpuinfo.py'
=== modified file 'debian/changelog'
--- debian/changelog	2013-08-02 10:56:56 +0000
+++ debian/changelog	2013-08-28 12:37:27 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 checkbox (0.16.4) saucy; urgency=low
 
   [ Jeff Lane ]
@@ -224,6 +225,69 @@
 
  -- Daniel Manrique <[e-mail]>  Wed, 15 May 2013 16:39:12 -0400
 
+=======
+checkbox (0.16.1) saucy; urgency=low
+
+  * New upstream release (LP: #1180545):
+
+  * Launchpad automated translation updates
+
+  [ Alberto Milone ]
+  * scripts/graphics_stress_test, scripts/rotation_test: make sure to
+    always reset the "screen" variable. Somehow the NVIDIA driver manages
+    to make it unusable after the first time. (LP: #1172667)
+
+  [ Brendan Donegan ]
+  * checkbox/parsers/submission.py - publish kernel-release information to
+    interested parties.
+  * scripts/rendercheck_test - change nargs='+' to action='append' for blacklist
+    option so it works as expected.
+    jobs/rendercheck.txt.in - blacklist gradients test as it is known to produce
+    false positives. (LP: #1093718)
+  * plugins/hexr_transport.py - added plugin for submitting to HEXR and 
+    certification based on certify_new_transport from checkbox-certification.
+    examples/checkbox-qt.ini - blacklisted hexr_transport as we won't use it
+    examples/checkbox-cli.ini - blacklisted hexr_transport as we won't use it
+    examples/checkbox-urwid.ini - blacklisted hexr_transport as we won't use it
+
+  [ Daniel Manrique ]
+  * Ensured that button strings from the "continue" dialog are translatable
+    (LP: #1176695) 
+  
+  [ Jeff Lane ]
+  * checkbox/parsers/cpuinfo.py - split on first instance of ':' in cpuinfo
+    output lines to avoid splitting into more than 2 items. Also fixed a pep8
+    issue discovered while working on this. (LP: #1180496)
+  * scripts/cpu_offlining: Modified script to no longer offline cpu0 to resolve
+    a bug on ARM. Modified output so most of it is redirected to stderr for
+    fail cases, we don't need that much for success cases. (LP: #1078897) 
+  * jobs/mediacard.txt.in: Modified test instructions to be less confusing
+    (LP: #970857)
+  * scripts/cpu_topology: define the cpuinfo nested dicts on creation rather
+    than define elements during parsing of /proc/cpuinfo (LP: #1111878)
+  * scripts/lsmod_info: Corrected error handling for the check_output() call to
+    trap the correct error. (LP: #1103647)
+  * jobs/camera.txt.in: removed an extraneous requres line for gir1.2
+    scripts/camera_test: added code to determine what version of gst we're
+    using and set video type and plugin accordingly. (LP: #1100594)
+  * scripts/network_check: added ability to specify custom target URL for
+    debugging failures (LP: #1128017)
+  * scripts/removable_storage_test: Added error handling to trap OSError on
+    non-writable media and modified output to handle subsequent
+    ZeroDivisionError issues when summarizing test results.
+    jobs/media.txt.in: Modified instructions for SD/SDHC to specify using
+    UNLOCKED cards to avoid issues when testing read-only media (LP: #1153894)
+
+  [ Sylvain Pineau ]
+  * jobs/suspend.txt.in, scripts/gpu_test: Remove the need of running the script
+    with the root user, restore the workspaces switch and the HTML5 video
+    playback ; remove the extra suspend/resume (LP: #1172851)
+  * checkbox/parsers/udevadm.py: Only filter devices without product AND vendor
+    information (LP: #1167733)
+
+ -- Daniel Manrique <[e-mail]>  Wed, 15 May 2013 16:39:12 -0400
+
+>>>>>>> MERGE-SOURCE
 checkbox (0.16) saucy; urgency=low
 
   * New upstream release (LP: #1178403):

=== modified file 'debian/po/ast.po'
--- debian/po/ast.po	2013-08-02 10:56:56 +0000
+++ debian/po/ast.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/cs.po'
--- debian/po/cs.po	2013-08-02 10:56:56 +0000
+++ debian/po/cs.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/de.po'
--- debian/po/de.po	2013-08-02 10:56:56 +0000
+++ debian/po/de.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/en_AU.po'
--- debian/po/en_AU.po	2013-08-02 10:56:56 +0000
+++ debian/po/en_AU.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/en_GB.po'
--- debian/po/en_GB.po	2013-08-02 10:56:56 +0000
+++ debian/po/en_GB.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/es.po'
--- debian/po/es.po	2013-08-02 10:56:56 +0000
+++ debian/po/es.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/fr.po'
--- debian/po/fr.po	2013-08-02 10:56:56 +0000
+++ debian/po/fr.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/gl.po'
--- debian/po/gl.po	2013-08-02 10:56:56 +0000
+++ debian/po/gl.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/he.po'
--- debian/po/he.po	2013-08-02 10:56:56 +0000
+++ debian/po/he.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/hu.po'
--- debian/po/hu.po	2013-08-02 10:56:56 +0000
+++ debian/po/hu.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/id.po'
--- debian/po/id.po	2013-08-02 10:56:56 +0000
+++ debian/po/id.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/it.po'
--- debian/po/it.po	2013-08-02 10:56:56 +0000
+++ debian/po/it.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/ja.po'
--- debian/po/ja.po	2013-08-02 10:56:56 +0000
+++ debian/po/ja.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/nl.po'
--- debian/po/nl.po	2013-08-02 10:56:56 +0000
+++ debian/po/nl.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/oc.po'
--- debian/po/oc.po	2013-08-02 10:56:56 +0000
+++ debian/po/oc.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/pl.po'
--- debian/po/pl.po	2013-08-02 10:56:56 +0000
+++ debian/po/pl.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/pt_BR.po'
--- debian/po/pt_BR.po	2013-08-02 10:56:56 +0000
+++ debian/po/pt_BR.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/ro.po'
--- debian/po/ro.po	2013-08-02 10:56:56 +0000
+++ debian/po/ro.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/ru.po'
--- debian/po/ru.po	2013-08-02 10:56:56 +0000
+++ debian/po/ru.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/tr.po'
--- debian/po/tr.po	2013-08-02 10:56:56 +0000
+++ debian/po/tr.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/uk.po'
--- debian/po/uk.po	2013-08-02 10:56:56 +0000
+++ debian/po/uk.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/zh_CN.po'
--- debian/po/zh_CN.po	2013-08-02 10:56:56 +0000
+++ debian/po/zh_CN.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'debian/po/zh_TW.po'
--- debian/po/zh_TW.po	2013-08-02 10:56:56 +0000
+++ debian/po/zh_TW.po	2013-08-28 12:37:27 +0000
@@ -15,8 +15,13 @@
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
+<<<<<<< TREE
 "X-Launchpad-Export-Date: 2013-07-24 05:13+0000\n"
 "X-Generator: Launchpad (build 16700)\n"
+=======
+"X-Launchpad-Export-Date: 2013-05-09 05:18+0000\n"
+"X-Generator: Launchpad (build 16598)\n"
+>>>>>>> MERGE-SOURCE
 
 #. Type: string
 #. Description

=== modified file 'jobs/graphics.txt.in'
=== modified file 'jobs/mediacard.txt.in'
--- jobs/mediacard.txt.in	2013-08-02 10:56:56 +0000
+++ jobs/mediacard.txt.in	2013-08-28 12:37:27 +0000
@@ -78,6 +78,52 @@
      The verification of this test is automated. Do not change the
      automatically selected result.
 
+<<<<<<< TREE
+=======
+plugin: user-interact
+name: mediacard/sd-insert-after-suspend
+depends: suspend/suspend_advanced
+command: removable_storage_watcher --memorycard insert sdio usb scsi
+_description:
+ PURPOSE:
+     This test will check that the systems media card reader can
+     detect the insertion of an UNLOCKED SD card after the system
+     has been suspended
+ STEPS:
+     1. Click "Test" and insert an UNLOCKED SD card into the reader.
+        If a file browser opens up, you can safely close it.
+        (Note: this test will time-out after 20 seconds.)
+     2. Do not remove the device after this test.
+ VERIFICATION:
+     The verification of this test is automated. Do not change the
+     automatically selected result.
+
+plugin: shell
+name: mediacard/sd-storage-after-suspend
+depends: mediacard/sd-insert-after-suspend
+user: root
+command: removable_storage_test -s 268400000 --memorycard sdio usb scsi
+_description:
+ This test is automated and executes after the mediacard/sd-insert-after-suspend test
+ is run. It tests reading and writing to the SD card after the system has been suspended.
+
+plugin: user-interact
+name: mediacard/sd-remove-after-suspend
+depends: mediacard/sd-insert-after-suspend
+command: removable_storage_watcher --memorycard remove sdio usb scsi
+_description:
+ PURPOSE:
+     This test will check that the system correctly detects 
+     the removal of an SD card from the systems card reader 
+     after the system has been suspended.
+ STEPS:
+     1. Click "Test" and remove the SD card from the reader.
+        (Note: this test will time-out after 20 seconds.)
+ VERIFICATION:
+     The verification of this test is automated. Do not change the
+     automatically selected result.
+
+>>>>>>> MERGE-SOURCE
 plugin: shell
 name: mediacard/sd-preinserted
 user: root
@@ -130,6 +176,51 @@
      automatically selected result.
 
 plugin: user-interact
+<<<<<<< TREE
+=======
+name: mediacard/sdhc-insert-after-suspend
+depends: suspend/suspend_advanced
+command: removable_storage_watcher --memorycard insert sdio usb scsi
+_description:
+ PURPOSE:
+     This test will check that the systems media card reader can
+     detect the insertion of an UNLOCKED SDHC media card after the 
+     system has been suspended
+ STEPS:
+     1. Click "Test" and insert an UNLOCKED SDHC card into the reader.
+        If a file browser opens up, you can safely close it.
+        (Note: this test will time-out after 20 seconds.)
+     2. Do not remove the device after this test.
+ VERIFICATION:
+     The verification of this test is automated. Do not change the
+     automatically selected result.
+
+plugin: shell
+name: mediacard/sdhc-storage-after-suspend
+depends: mediacard/sdhc-insert-after-suspend
+user: root
+command: removable_storage_test -s 268400000 --memorycard sdio usb scsi
+_description:
+ This test is automated and executes after the mediacard/sdhc-insert-after-suspend test
+ is run. It tests reading and writing to the SDHC card after the system has been suspended.
+
+plugin: user-interact
+name: mediacard/sdhc-remove-after-suspend
+depends: mediacard/sdhc-insert-after-suspend
+command: removable_storage_watcher --memorycard remove sdio usb scsi
+_description:
+ PURPOSE:
+     This test will check that the system correctly detects the removal
+     of an SDHC card from the systems card reader after the system has been suspended.
+ STEPS:
+     1. Click "Test" and remove the SDHC card from the reader.
+        (Note: this test will time-out after 20 seconds.)
+ VERIFICATION:
+     The verification of this test is automated. Do not change the
+     automatically selected result.
+
+plugin: user-interact
+>>>>>>> MERGE-SOURCE
 name: mediacard/cf-insert
 command: removable_storage_watcher --memorycard insert sdio usb scsi
 _description:

=== modified file 'jobs/resource.txt.in'
--- jobs/resource.txt.in	2013-07-12 14:51:00 +0000
+++ jobs/resource.txt.in	2013-08-28 12:37:27 +0000
@@ -56,6 +56,12 @@
 command:
     find -H $(echo "$PATH" | sed -e 's/:/ /g') -maxdepth 1 -type f -executable -printf "name: %f\n\n"
 
+name: executable
+plugin: resource
+description: Generates a resource for all available executables
+command:
+    find -H $(echo "$PATH" | sed -e 's/:/ /g') -maxdepth 1 -type f -executable -printf "name: %f\n\n"
+
 name: device
 plugin: resource
 command: udev_resource

=== added directory 'plainbox'
=== added file 'plainbox/MANIFEST.in.OTHER'
--- plainbox/MANIFEST.in.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/MANIFEST.in.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,9 @@
+include README.md
+include COPYING
+include mk-interesting-graphs.sh
+recursive-include plainbox/test-data/ *.json *.xml *.txt
+recursive-include docs *.rst
+include docs/conf.py
+include plainbox/data/report/hardware-1_0.rng
+include contrib/policykit_yes/org.freedesktop.policykit.pkexec.policy
+include contrib/policykit_auth_admin_keep/org.freedesktop.policykit.pkexec.policy

=== added directory 'plainbox/contrib'
=== added directory 'plainbox/contrib/policykit_auth_admin_keep'
=== added file 'plainbox/contrib/policykit_auth_admin_keep/org.freedesktop.policykit.pkexec.policy'
--- plainbox/contrib/policykit_auth_admin_keep/org.freedesktop.policykit.pkexec.policy	1970-01-01 00:00:00 +0000
+++ plainbox/contrib/policykit_auth_admin_keep/org.freedesktop.policykit.pkexec.policy	2013-08-28 12:37:27 +0000
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
+<policyconfig>
+
+  <!--
+    Policy definitions for PlainBox system actions.
+    (C) 2013 Canonical Ltd.
+    Author: Sylvain Pineau <[e-mail]>
+  -->
+
+  <vendor>PlainBox</vendor>
+  <vendor_url>https://launchpad.net/checkbox</vendor_url>
+  <icon_name>checkbox</icon_name>
+
+  <action id="org.freedesktop.policykit.pkexec.run-plainbox-job">
+    <description>Run Job command</description>
+    <message>Please enter your password. Some tests require root access to run properly. Your password will never be stored and will never be submitted with test results.</message>
+    <defaults>
+      <allow_any>no</allow_any>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/checkbox-trusted-launcher</annotate>
+    <annotate key="org.freedesktop.policykit.exec.allow_gui">TRUE</annotate>
+  </action>
+
+</policyconfig>
+

=== added directory 'plainbox/contrib/policykit_yes'
=== added file 'plainbox/contrib/policykit_yes/org.freedesktop.policykit.pkexec.policy.OTHER'
--- plainbox/contrib/policykit_yes/org.freedesktop.policykit.pkexec.policy.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/contrib/policykit_yes/org.freedesktop.policykit.pkexec.policy.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
+<policyconfig>
+
+  <!--
+    Policy definitions for PlainBox system actions.
+    (C) 2013 Canonical Ltd.
+    Author: Sylvain Pineau <[e-mail]>
+  -->
+
+  <vendor>PlainBox</vendor>
+  <vendor_url>https://launchpad.net/checkbox</vendor_url>
+  <icon_name>checkbox</icon_name>
+
+  <action id="org.freedesktop.policykit.pkexec.run-plainbox-job">
+    <description>Run Job command</description>
+    <defaults>
+      <allow_any>no</allow_any>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>yes</allow_active>
+    </defaults>
+    <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/checkbox-trusted-launcher</annotate>
+    <annotate key="org.freedesktop.policykit.exec.allow_gui">TRUE</annotate>
+  </action>
+
+</policyconfig>
+

=== added directory 'plainbox/docs'
=== added directory 'plainbox/docs/dev'
=== added file 'plainbox/docs/dev/architecture.rst.OTHER'
--- plainbox/docs/dev/architecture.rst.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/docs/dev/architecture.rst.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,40 @@
+PlainBox Architecture
+=====================
+
+This document explains the architecture of PlainBox internals. It should be
+always up-to-date and accurate to the extent of the scope of this overview.
+
+.. toctree::
+   :maxdepth: 3
+
+   trusted-launcher.rst
+   config.rst
+   resources.rst
+   old.rst
+
+General design considerations
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+PlainBox is a reimplementation of CheckBox that replaces a reactor / event /
+plugin architecture with a monolithic core and tightly integrated components.
+
+The implementation models a few of the externally-visible concepts such as
+jobs, resources and resource programs but also has some additional design that
+was not present in CheckBox before.
+
+The goal of the rewrite is to provide the right model and APIs for user
+interfaces in order to build the kind of end-user solution that we could not
+build with CheckBox.
+
+This is expressed by additional functionality that is there only to provide the
+higher layers with the right data (failure reason, descriptions, etc.). The
+code is also intended to be highly testable. Test coverage at the time of
+writing this document was exceeding 80%
+
+The core requirement for the current phase of PlainBox development is feature
+parity with CheckBox and gradual shift from one to another in the daily
+responsibilities of the Hardware Certification team. Currently PlainBox
+implements a large chunk of core / essential features from CheckBox. While not
+all features are present the core is considered almost feature complete at this
+stage.
+

=== added file 'plainbox/docs/dev/old.rst.OTHER'
--- plainbox/docs/dev/old.rst.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/docs/dev/old.rst.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,343 @@
+Old Architecture Notes
+======================
+
+.. warning::
+
+    This section needs maintenance
+
+Application Skeleton
+^^^^^^^^^^^^^^^^^^^^
+
+This skeleton represents a typical application based on PlainBox. It enumerates
+the essential parts of the APIs from the point of view of an application
+developer.
+
+1. Instantiate :class:`plainbox.impl.checkbox.CheckBox` then call
+   :meth:`plainbox.impl.checkbox.CheckBox.get_builtin_jobs()` to discover all
+   known jobs. In the future this might be replaced by a step that obtains jobs
+   from a named provider.
+
+3. Instantiate :class:`plainbox.impl.runner.JobRunner` so that we can run jobs
+
+4. Instantiate :class:`plainbox.impl.session.SessionState` so that we can keep
+   track of application state.
+
+   - Potentially restore an earlier, interrupted, testing session by calling
+     :meth:`plainbox.impl.session.SessionState.restore()`
+
+   - Potentially remove an earlier, interrupted, testing session by calling
+     :meth:`plainbox.impl.session.SessionState.discard()`
+
+   - Potentially start a new test session by calling
+     :meth:`plainbox.impl.session.SessionState.open()`
+
+5. Allow the user to select jobs that should be executed and update session
+   state by calling
+   :meth:`plainbox.impl.session.SessionState.update_desired_job_list()`
+
+6. For each job in :attr:`plainbox.impl.SessionState.run_list`:
+
+   1. Check if we want to run the job (if we have a result for it from previous
+      runs) or if we must run it (for jobs that cannot be persisted across
+      suspend)
+
+   2. Check if the job can be started by looking at
+      :meth:`plainbox.impl.session.JobState.can_start()`
+
+      - optionally query for additional data on why a job cannot be started and
+        present that to the user.
+
+      - optionally abort the sequence and go to step 5 or the outer loop.
+
+   3. Call :meth:`plainbox.impl.runner.JobRunner.run_job()` with the current
+      job and store the result.
+
+        - optionally ask the user to perform some manipulation
+
+        - optionally ask the user to qualify the outcome
+
+        - optionally ask the user for additional comments
+
+   4. Call :meth:`plainbox.impl.session.SessionState.update_job_result()` to
+      update readiness of jobs that depend on the outcome or output of current
+      job.
+
+   5. Call :meth:`plainbox.impl.session.SessionState.checkpoint()` to ensure
+      that testing can resume after system crash or shutdown.
+
+7. Instantiate the selected state exporter, for example
+   :class:`plainbox.impl.exporters.json.JSONSessionStateExporter` so that we
+   can use it to save test results.
+
+    - optionally pass configuration options to customize the subset and the
+      presentation of the session state
+
+8. Call
+   :meth:`plainbox.impl.exporters.SessionStateExporterBase.get_session_data_subset()`
+   followed by :meth:`plainbox.impl.exporters.SessionStateExporterBase.dump()`
+   to save results to a file.
+
+9. Call :meth:`plainbox.impl.session.SessionState.close()` to remove any
+   nonvolatile temporary storage that was needed for the session.
+
+Essential classes
+=================
+
+:class:`~plainbox.impl.session.SessionState`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Class representing all state needed during a single program session.
+
+Usage
+-----
+
+The general idea is that you feed the session with a list of known jobs and
+a subset of jobs that you want to run and in return get an ordered list of
+jobs to run.
+
+It is expected that the user will select / deselect and run jobs. This
+class can react to both actions by recomputing the dependency graph and
+updating the read states accordingly.
+
+As the user runs subsequent jobs the results of those jobs are exposed to
+the session with :meth:`update_job_result()`. This can cause subsequent
+jobs to become available (not inhibited by anything). Note that there is no
+notification of changes at this time.
+
+The session does almost nothing by itself, it learns about everything by
+observing job results coming from the job runner
+(:class:`plainbox.impl.runner.JobRunner`) that applications need to
+instantiate.
+
+Suspend and resume
+------------------
+
+The session can save check-point data after each job is executed. This
+allows the system to survive and continue after a catastrophic failure
+(broken suspend, power failure) or continue across tests that require the
+machine to reboot.
+
+.. todo::
+
+    Create a section on suspend/resume design
+
+Implementation notes
+--------------------
+
+Internally it ties into :class:`plainbox.impl.depmgr.DependencySolver` for
+resolving dependencies. The way the session objects are used allows them to
+return various problems back to the UI level - those are all the error
+classes from :mod:`plainbox.impl.depmgr`:
+
+    - :class:`plainbox.impl.depmgr.DependencyCycleError`
+
+    - :class:`plainbox.impl.depmgr.DependencyDuplicateError`
+
+    - :class:`plainbox.impl.depmgr.DependencyMissingError`
+
+Normally *none* of those errors should ever happen, they are only provided
+so that we don't choke when a problem really happens. Everything is checked
+and verified early before starting a job so typical unit and integration
+testing should capture broken job definitions (for example, with cyclic
+dependencies) being added to the repository.
+
+Implementation issues
+---------------------
+
+There are two issues that are known at this time:
+
+* There is too much checkbox-specific knowledge which really belongs
+  elsewhere. We are working to remove that so that non-checkbox jobs
+  can be introduced later. There is a branch in progress that entirely
+  removes that and moves it to a new concept called SessionController.
+  In that design the session delegates understanding of results to a
+  per-job session controller and exposes some APIs to alter the state
+  that was previously internal (most notably a way to add new jobs and
+  resources).
+
+* The way jobs are currently selected is unfortunate because of local jobs
+  that can add new jobs to the system. This causes considerable complexity
+  at the application level where the application must check if each
+  executed job is a 'local' job and re-compute the desired_job_list. This
+  should be replaced by a matcher function that can be passed to
+  SessionState once so that desired_job_list is re-evaluated internally
+  whenever job_list changes.
+
+
+:class:`~plainbox.impl.job.JobDefinition`
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:term:`CheckBox` has a concept of a :term:`job`. Jobs are named units of
+testing work that can be executed. Typical jobs range from automated CPU power
+management checks, BIOS tests, semi-automated peripherals testing to all manual
+validation by following a script (intended for humans).
+
+Jobs are distributed in plain text files, formated as a loose RFC822 documents
+where typically a single text file contains a few dozen different jobs that
+belong to one topic, for example, all bluetooth tests.
+
+Tests have a number of properties that will not be discussed in detail here,
+they are all documented in :class:`plainbox.impl.job.JobDefinition`. From the
+architecture point of view the four essential properties of a job are *name*,
+*plugin* and *requires* and *depends*. Those are discussed in detail below.
+
+JobDefinition.name
+------------------
+
+The *name* field must be unique and is referred to by other parts of the system
+(such as whitelists). Typically jobs follow a simple naming pattern
+'category/detail', eg, 'networking/modem_connection'. The name must be _unique_
+and this is enforced by the core.
+
+JobDefinition.plugin
+--------------------
+
+The *plugin* field is an archaism from CheckBox and a misnomer (as PlainBox
+does not have any plugins). In the CheckBox architecture it would instruct the
+core which plugin should process that job. In PlainBox it is a way to encode
+what type of a job is being processed. There is a finite set of types that are
+documented below. 
+
+plugin == "shell"
+#################
+
+This value is used for fully automated jobs. Everything the job needs to do is
+automated (preparation, execution, verification) and fully handled by the
+command that is associated with a job.
+
+plugin == "manual" 
+##################
+
+This value is used for fully manual jobs. It has no special handling in the core
+apart from requiring a human-provided outcome (pass/fail classification) 
+
+.. _local:
+
+plugin == "local"
+#################
+
+This value is used for special job generator jobs. The output of such jobs is
+interpreted as additional jobs and is identical in effect to loading such jobs
+from a job definition file. 
+
+There are two practical uses for such jobs:
+
+* Some local jobs are used to generate a number of jobs for each object.
+  This is needed where the tested machine may have a number of such objects
+  and each requires unique testing. A good example is a computer where all
+  network tests are explicitly "instantiated" for each network card
+  present.
+ 
+  This is a valid use case but is rather unfortunate for architecture of
+  PlainBox and there is a desire to replace it with equally-expressive
+  pattern jobs. The advantage is that unlike local jobs (which cannot be
+  "discovered" without enduring any potential side effects that may be
+  caused by the job script command) pattern jobs would allow the core to
+  determine the names of jobs that can be generated and, for example,
+  automatically determine that a pattern job needs to be executed as a
+  dependency of a phantom (yet undetermined) job with a given name.
+
+  The solution with "pattern" jobs may be executed in future phases of
+  PlainBox development. Currently there is no support for that at all.
+
+  Currently PlainBox cannot determine job dependencies across local jobs.
+  That is, unless a local job is explicitly requested (in the desired job
+  list) PlainBox will not be able to run a job that is generated by a local
+  job at all and will treat it as if that job never existed.
+
+* Some local jobs are used to create a form of informal "category".
+  Typically all such jobs have a leading and trailing double underscore,
+  for example '__audio__'. This is currently being used by CheckBox for
+  building a hierarchical tree of tests that the user may select.
+
+  Since this has the same flaws as described above (for pattern jobs) it
+  will likely be replaced by an explicit category field that can be
+  specified each job.
+
+plugin == "resource"
+####################
+
+This value is used for special "data" or "environment" jobs. Their output is
+parsed as a list of RFC822 records and is kept by the core during a testing session.
+
+They are primarily used to determine if a given job can be started. For
+example, a particular bluetooth test may use the _requires_ field to indicate
+that it depends (via a resource dependency) on a job that enumerates devices
+and that one of those devices must be a bluetooth device.
+
+plugin == "user-interact"
+#########################
+
+For all intents and purposes it is equivalent to "manual". The actual
+difference is that a user is expected to perform some physical manipulation
+before an automated test.
+
+plugin == "user-verify"
+#######################
+
+For all intents and purposes it is equivalent to "manual". The actual
+difference is that a user is expected to perform manual verification after an
+automated test.
+
+JobDefinition.depends
+---------------------
+
+The *depends* field is used to express dependencies between two jobs. If job A
+has depends on job B then A cannot start if B is not both finished and
+successful. PlainBox understands this dependency and can automatically sort and
+execute jobs in proper order. In many places of the code this is referred to as
+a "direct dependency" (in contrast to "resource dependency")
+
+The actual syntax is not strictly specified, PlainBox interprets this field as
+a list of tokens delimited by comma or any whitespace (including newlines).
+
+A job may depend on any number of other jobs. There are a number of failure
+modes associated with this feature, all of which are detected and handled by
+PlainBox. Typically they only arise when during CheckBox job development
+(editing actual job files) and are always a sign of a human error. No released
+version of CheckBox or PlainBox should ever encounter any of those issues.
+
+The actual problems are:
+
+* dependency cycles, where job either directly or indirectly depends on
+  itself
+
+* missing dependencies where some job refers to a job that is not defined
+  anywhere.
+
+* duplicate jobs where two jobs with the same name (but different
+  definition) are being introduced to the system.
+
+In all of those cases the core removes the offending job and tries to work
+regardless of the problem. This is intended more as a development aid rather
+than a reliability feature as no released versions of either project should
+cause this problem.
+
+JobDefinition.command
+---------------------
+
+The *command* field is used when the job needs to call an external command.
+Typically all shell jobs define a command to run.
+
+"Manual" jobs can also define a command to run as part of the test procedure.
+
+JobDefinition.user
+------------------
+
+The *user* field is used when the job requires to run as a specific user
+(e.g. root).
+
+The job command will be run via pkexec to get the necessary
+permissions.
+
+.. _environ:
+
+JobDefinition.environ
+---------------------
+
+The *environ* field is used to pass additional environmental keys from the user
+session to the new environment set up when the job command is run by another
+user (root, most of the time).
+
+The actual syntax is not strictly specified, PlainBox interprets this field as
+a list of tokens delimited by comma or any whitespace (including newlines).

=== added file 'plainbox/docs/dev/reference.rst.OTHER'
--- plainbox/docs/dev/reference.rst.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/docs/dev/reference.rst.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,179 @@
+.. _code_reference:
+
+.. toctree::
+   :maxdepth: 2
+
+Code reference
+==============
+
+.. note::
+
+    Unless stated otherwise all API is unstable. PlainBox does not offer
+    general API stability at this time.
+
+.. automodule:: plainbox
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.public
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.abc
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.tests
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.testing_utils
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.testing_utils.cwd
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.testing_utils.io
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.testing_utils.testcases
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.vendor
+    :members:
+
+.. automodule:: plainbox.vendor.extcmd
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.commands
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.commands.selftest
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.exporter
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.exporter.json
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.exporter.rfc822
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.exporter.text
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.secure
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.secure.checkbox_trusted_launcher
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.transport
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.transport.certification
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.box
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.checkbox
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.config
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.depmgr
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.integration_tests
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.job
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.mock_job
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.resource
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.result
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.rfc822
+    :members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.runner
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.session
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+.. automodule:: plainbox.impl.testing_utils
+    :members:
+    :undoc-members:
+    :show-inheritance:

=== added file 'plainbox/docs/dev/resources.rst.OTHER'
--- plainbox/docs/dev/resources.rst.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/docs/dev/resources.rst.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,259 @@
+Resources
+=========
+
+Resources are a mechanism that allows to constrain certain :term:`job` to
+execute only on devices with appropriate hardware or software dependencies.
+This mechanism allows some types of jobs to publish resource objects to an
+abstract namespace and to a way to evaluate a resource program to determine if
+a job can be started.
+
+Resources in PlainBox
+=====================
+
+The following chapters explain how resources actually work in :term:`PlainBox`.
+Currently there *is* a subtle difference between this and the original
+:term:`CheckBox` implementation.
+
+Resource programs
+-----------------
+
+Resource programs are multi-line statements that can be embedded in job
+definitions. By far, the most common use case is to check if a required package
+is installed, and thus, the job can use it as a part of a test. A check like
+this looks like this::
+
+    package.name == "fwts"
+
+This resource program codifies that the job needs the ``fwts`` package to run.
+There is a companion job with the same name that interrogates the local package
+database and publishes a set of resource objects. Each such object is a
+collection of arbitrary key-value pairs. The ``package`` job simply publishes
+the ``name`` and ``version`` of each installed package but the mechanism is
+generic and applies to all resources.
+
+As stated, resource programs can be multi-line, a real world example of that is
+presented below::
+
+     device.category == 'CDROM'
+     optical_drive.cd == 'writable'
+
+This example is much like the one above, referring to some resources, here
+coming from jobs ``device`` and ``optical_drive``. What is important to point
+out is that, as a rule of a thumb, multi line programs have an implicit ``and``
+operator between each line. This program would only evaluate to True if there
+is a writable CD-ROM available.
+
+Each resource program is composed of resource expressions. Each line maps
+directly onto one expression so the example program above uses two resource
+expressions.
+
+Resource expressions
+--------------------
+
+Resource expressions are evaluated like normal python programs. They use all of
+the same syntax, semantics and behavior. None of the operators are overridden
+to do anything unexpected. The evaluator tries to follow the principle of least
+surprise but this is not always possible.
+
+Resource expressions cannot execute arbitrary python code. In general almost
+everything is disallowed, except as noted below:
+
+* Expressions can use any literals (strings, numbers, True, False, lists and tuples)
+* Expressions can use boolean operators (``and``, ``or``, ``not``)
+* Expressions can use all comparison operators
+* Expressions can use all binary and unary operators 
+* Expressions can use the set membership operator (``in``) 
+* Expressions can use read-only attribute access
+
+Anything else is rejected as an invalid resource expression.
+
+In addition to that, each resource expression must use exactly one variable,
+which must be used like an object with attributes. The name of that variable
+must correspond to the name of the job that generates resources. Attempts to
+use more than one variable or to not use any variables are detected early and
+rejected as invalid resource expressions.
+
+The name of the variable determines which resource group to use. It must match
+the name of the job that generates such resources.
+
+In the examples elsewhere in this page the  ``package`` resources are generated
+by the ``package`` job. PlainBox uses this to know which resources to try but
+also to implicitly to express dependencies so that the ``package`` job does not
+have to be explicitly selected and marked for execution prior to the job that
+in fact depends on it. This is all done automatically.
+
+Evaluation
+----------
+
+Due to mandatory compatibility with existing :term:`CheckBox` jobs there are
+some unexpected aspects of how evaluation is performed. Those are marked as
+**unexpected** below:
+
+1. First PlainBox looks at the resource program and splits it into lines. Each
+   non-empty line is parsed and converted to a resource expression.
+   
+2. **unexpected** Each resource expression is repeatedly evaluated, once for
+   each resource from the group determined by the variable name. All exceptions
+   are silently ignored and treated as if the iteration had evaluated to False.
+   The whole resource expression evaluates to ``True`` if any of the iterations
+   evaluated to ``True``. In other words, there is an implicit ``any()`` around
+   each resource expression, iterating over all resources. 
+
+3. **unexpected** The resource program evaluates to ``True`` only if all
+   resource expressions evaluated to ``True``. In other words, there is an
+   implicit ``and`` between each line.
+
+Limitations
+-----------
+
+The design of resource programs has the following shortcomings. The list is
+non-exhaustive, it only contains issues that we came across found not to work
+in practice.
+
+Exactly one variable per expression
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Each resource expression must refer to exactly one variable. This is a side
+effect of the way the evaluator works. It basically bind one object (a
+particular resource) to that variable and evaluates the expression.
+
+The expression parser / syntax analyzer identifies expressions with this
+problem early and rejects them with an appropriate error message. Here are
+some examples of hypothetical expressions that exhibit this problem.
+
+"I want to have mplayer and an audio device so that I can play some sounds"::
+
+    device.category == "AUDIO" and package.name == "mplayer"
+
+To work around this, split the expression to two separate expressions. The
+evaluator will put an implicit ``and`` between them and it will do exactly what
+you intended::
+
+    device.category == "AUDIO"
+    package.name == "mplayer"
+
+"I want to always run this test"::
+
+    True
+
+To work around this, simply remove the requirement program entirely!
+
+"I want to never run this test"::
+
+    False
+
+To work around this remove this job from the selection. You may also use a
+special resource that produces one constant value, and check that it is equal
+to something different.
+
+Exactly one resource bound to a variable at once
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+It's not possible to refer to two different resources, from the same resource
+group, in one resource expression. In other terms, the variable always points
+to one object, it is not a collection of objects.
+
+For example, let's consider this program::
+
+    package.name == 'xorg' and package.name == 'procps'
+
+Seemingly the intent was to ensure that both ``xorg`` and ``procps`` are
+installed. The reason why this does not work is that at each iteration of the
+the expression evaluator, the name ``package`` refers to exactly one resource
+object. In other words, that expression is equivalent to this one::
+
+    A == True and A == False
+
+This type of error is not captured by our limited semantic analyzer. It will
+silently evaluate to False and inhibit the job from being stated.
+
+To work around this, split the expression to two consecutive lines. As stated
+in rule 3 in the list above, there is an implicit ``and`` operator between all
+expressions. A working example that expresses the same intent looks like this::
+
+    package.name == 'xorg'
+    package.name == 'procps'
+
+Operator != is useless
+^^^^^^^^^^^^^^^^^^^^^^
+
+This is strange at first but quickly becomes obvious once you recall rule 2
+from the list above. That rule states that the expression is evaluated
+repeatedly for each resource from a particular group and that any ``True``
+iteration marks the whole expression as ``True``).
+
+Let's look at a real-world example::
+
+    xinput.device_class == 'XITouchClass' and xinput.touch_mode != 'dependent'
+
+So seemingly, the intent here was to have at least ``xinput`` resource with a
+``device_class`` attribute equal to ``XITouchClass`` that has ``touch_mode``
+attribute equal to anything but ``dependent``.
+
+Now let's assume that we have exactly two resources in the ``xinput`` group::
+
+    device_class: XITouchClass
+    touch_mode: dependant
+
+    device_class: XITouchClass
+    touch_mode: something else
+
+Now, this expression will evaluate to ``True``, as the second resource fulfils
+the requirements. Is this what the test designer had expected? That's hard to
+say. The problem here is that this expression can be understood as *at least
+one resource isn't something* **or** *all resources weren't something*. Both
+are equally valid desires and, depending on how the test is implemented, may or
+many not work correctly in practice.
+
+Currently there is no workaround. We are considering adding a new syntax that
+would allow to specify this explicitly. The proposal is documented below as
+"implicit any(), explicit all()"
+
+Everything is a string
+^^^^^^^^^^^^^^^^^^^^^^
+
+Resource programs are regular python programs evaluated in unusual ways but
+all of the variables that are exposed through the resource object are strings.
+
+This has considerable impact on comparison, unless you are comparing to a
+string the comparison will always silently fail as python has dynamic but
+strict, not loose types (there is no implicit type conversion). To alleviate
+this problem several type names / conversion functions are allowed in
+requirement programs. Those are:
+
+* :py:class:`int`, to convert to integer numbers
+* :py:class:`float`, to convert to floating point numbers
+* :py:class:`bool`, to convert to a boolean context
+
+Considered enhancements
+-----------------------
+
+We are currently considering one improvement to resource programs. This would
+allow us to introduce a fix that resolves some issues in a backwards compatible
+way. Technical aspects are not yet resolved as that extension would not be
+available in :term:`CheckBox` until CheckBox can be built on top of
+:term:`PlainBox`
+
+Implicit any(), explicit all()
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This proposal changes the way resource expressions are evaluated.
+
+The implicit ``any()`` implemented as a loop over all resources from the
+resource group designated by variable name would be configurable.
+
+A developer may choose to wrap the whole expression in the ``all()`` function
+to indicate that the expression inside ``all()`` must evaluate to ``True`` for
+**all** iterations (all resources).
+
+This would allow solving the case where a job can only run, for example, when a
+certain package is **not** installed.  This could be expressed as::
+
+    all(package.name != 'ubuntu-desktop')
+
+Resources in CheckBox
+=====================
+
+The following chapters explain how resources originally worked in
+:term:`CheckBox`. Only notable differences from :term:`PlainBox` implementation
+are listed.

=== added file 'plainbox/docs/dev/trusted-launcher.rst'
--- plainbox/docs/dev/trusted-launcher.rst	1970-01-01 00:00:00 +0000
+++ plainbox/docs/dev/trusted-launcher.rst	2013-08-28 12:37:27 +0000
@@ -0,0 +1,209 @@
+Running jobs as root
+====================
+
+:term:`PlainBox` is started without any privilege.
+But several tests need to start commands requiring privileges.
+
+Such tests will call a trusted launcher, a standalone script
+which does not depend on the :term:`PlainBox` core modules.
+`polkit <http://www.freedesktop.org/wiki/Software/polkit>`_
+will control access to system resources.
+The trusted launcher has to be started using
+`pkexec <http://www.freedesktop.org/software/polkit/docs/0.105/pkexec.1.html>`_
+so that the related policy file works as expected.
+
+To avoid a security hole that allows anyone to run anything as root,
+the launcher can only run jobs installed in a system-wide directory.
+This way we are not weaken the trust system as root access is required
+to install both components (the trusted runner and jobs).
+The :term:`PlainBox` process will send an identifier which is matched by a well-known
+list in the trusted launcher. This identifier is the job hash:
+
+.. code-block:: bash
+
+    $ pkexec trusted-launcher JOB-HASH
+
+See :meth:`plainbox.impl.secure.checkbox_trusted_launcher.BaseJob.get_checksum()` for details about job hashes.
+
+Using Polkit
+^^^^^^^^^^^^
+
+Available authentication methods 
+--------------------------------
+
+.. note::
+
+    Only applicable to the package version of PlainBox
+
+PlainBox comes with two authentication methods but both aim to retain the
+granted privileges for the life of the :term:`PlainBox` process.
+
+*   The first method will ask the password only once and show the following
+    agent on desktop systems (a text-based agent is available for servers):
+
+    .. code-block:: text
+    
+        +-----------------------------------------------------------------------------+
+        | [X]                            Authenticate                                 |
+        +-----------------------------------------------------------------------------+
+        |                                                                             |
+        | [Icon] Please enter your password. Some tests require root access to run    |
+        |        properly. Your password will never be stored and will never be       |
+        |        submitted with test results.                                         |
+        |                                                                             |
+        |        An application is attempting to perform an action that requires      |
+        |        privileges.                                                          |
+        |        Authentication as the super user is required to perform this action. |
+        |                                                                             |
+        |        Password: [________________________________________________________] |
+        |                                                                             |
+        | [V] Details:                                                                |
+        |  Action: org.freedesktop.policykit.pkexec.run-plainbox-job                  |
+        |  Vendor: PlainBox                                                           |
+        |                                                                             |
+        |                                                     [Cancel] [Authenticate] |
+        +-----------------------------------------------------------------------------+
+
+    The following policy file has to be installed in :file:`/usr/share/polkit-1/actions/`
+    on Ubuntu systems.
+    Asking the password just one time and keeps the authentication for forthcoming
+    calls is provided by the **allow_active** element and the **auth_admin_keep** value.
+    
+    Check the `polkit actions <http://www.freedesktop.org/software/polkit/docs/0.105/polkit.8.html#polkit-declaring-actions>`_
+    documentation for details about the other parameters.
+
+    .. code-block:: xml
+    
+        <?xml version="1.0" encoding="UTF-8"?>
+        <!DOCTYPE policyconfig PUBLIC
+         "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+         "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
+        <policyconfig>
+        
+          <vendor>PlainBox</vendor>
+          <vendor_url>https://launchpad.net/checkbox</vendor_url>
+          <icon_name>checkbox</icon_name>
+        
+          <action id="org.freedesktop.policykit.pkexec.run-plainbox-job">
+            <description>Run Job command</description>
+            <message>Authentication is required to run a job command.</message>
+            <defaults>
+              <allow_any>no</allow_any>
+              <allow_inactive>no</allow_inactive>
+              <allow_active>auth_admin_keep</allow_active>
+            </defaults>
+            <annotate key="org.freedesktop.policykit.exec.path">/usr/bin/checkbox-trusted-launcher</annotate>
+            <annotate key="org.freedesktop.policykit.exec.allow_gui">TRUE</annotate>
+          </action>
+        
+        </policyconfig>
+
+*  The second method is only intended to be used in headless mode (like `SRU`).
+   The only difference with the above method is that **allow_active** will be set to **yes**.
+
+.. note::
+
+    The two policy files are available in the PlainBox :file:`contrib/` directory.
+
+Environment settings with pkexec 
+--------------------------------
+
+`pkexec <http://www.freedesktop.org/software/polkit/docs/0.105/pkexec.1.html>`_ 
+allows an authorized user to execute a command as another user.
+But the environment that ``command`` will run it, will be set to a minimal known
+and safe environment in order to avoid injecting code through ``LD_LIBRARY_PATH``
+or similar mechanisms.
+
+However, some jobs commands require specific enviroment variables such as the
+name of an access point for a wireless test. Those kind of variables must be
+available to the trusted launcher.
+To do so, the enviromment mapping is sent to the launcher like key/value pairs
+are sent to the env(1) command:
+
+.. code-block:: bash
+
+    $ pkexec trusted-launcher JOB-HASH [NAME=VALUE [NAME=VALUE ...]]
+
+Each NAME will be set to VALUE in the environment given that they are known
+and defined in the :ref:`JobDefinition.environ <environ>` parameter.
+
+Checkbox trusted launcher
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The checkbox trusted launcher is the minimal code needed to be able to run a
+:term:`CheckBox` job command.
+
+It offers base classes for the following core subclasses:
+
+* :class:`plainbox.impl.rfc822.RFC822Record`
+* :class:`plainbox.impl.job.JobDefinition`
+
+The only duplicated code is the RFC822 parser, where all logging features have
+been removed.
+
+The :class:`plainbox.impl.secure.checkbox_trusted_launcher.Runner` class just
+executes the command process with :py:func:`os.execve`.
+
+Internally the checkbox trusted launcher looks for jobs in the system locations defined in 
+:attr:`plainbox.impl.secure.checkbox_trusted_launcher.Runner.CHECKBOXES` which defaults to :file:`/usr/share/checkbox*`.
+This way the launcher can match all :term:`CheckBox` variants, like ``checkbox-oem(-.*)?``
+
+Usage
+-----
+
+.. code-block:: text
+
+    checkbox-trusted-launcher [-h] (--hash HASH | --warmup)
+                              [--via LOCAL-JOB-HASH]
+                              [NAME=VALUE [NAME=VALUE ...]]
+    
+    positional arguments:
+      NAME=VALUE            Set each NAME to VALUE in the string environment
+    
+    optional arguments:
+      -h, --help            show this help message and exit
+      --hash HASH           job hash to match
+      --warmup              Return immediately, only useful when used with
+                            pkexec(1)
+      --via LOCAL-JOB-HASH  Local job hash to use to match the generated job
+
+.. note::
+
+    Check all job hashes with ``plainbox special -J``
+
+As stated in the polkit chapter, only a trusted subset of the environment mapping
+will be set using :py:func:`os.execve` to run the command.
+Only the variables defined in the job environ property are allowed to avoid
+compromising the root environment.
+Needed modifications like adding ``CHECKBOX_SHARE`` and new paths to scripts are
+managed by the checkbox-trusted-launcher.
+
+Authentication on PlainBox startup
+----------------------------------
+
+To avoid prompting the password at the first test requiring privileges, :term:`PlainBox`
+will call the ``checkbox-trusted-launcher`` with the ``--warmup`` option.
+It's like a NOOP and it will return immediately, but thanks to the installed policy file
+the authentication will be kept.
+
+.. note::
+
+    When running the development version from a branch, the usual polkit
+    authentication agent will pop up to ask the password each and every time.
+    This is the only difference.
+
+Special case of jobs using the CheckBox local plugin
+----------------------------------------------------
+
+For jobs generated from :ref:`local <local>` jobs (e.g. disk/read_performance.*)
+the trusted launcher is started with ``--via`` meaning that we have to first
+eval a local job to find a hash match.
+Once a match is found, the job command is executed using :py:func:`os.execve`.
+
+.. code-block:: bash
+
+    $ pkexec checkbox-trusted-launcher --hash JOB-HASH --via LOCAL-JOB-HASH
+
+.. note::
+
+    it will obviously fail if any local job can ever generate another local job.

=== added file 'plainbox/docs/usage.rst.OTHER'
--- plainbox/docs/usage.rst.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/docs/usage.rst.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,93 @@
+.. _usage:
+
+Usage
+=====
+
+Currently :term:`PlainBox` has no graphical user interface. To use it you need
+to use the command line.
+
+Basically there is just one command that does everything we can do so far, that
+is :command:`plainbox run`. It has a number of options that tell it which
+:term:`job` to run and what to do with results.
+
+PlainBox has built-in help system so running :command:`plainbox run --help`
+will give you instant information about all the various arguments and options
+that are available. This document is not intended to replace that.
+
+Running a specific job
+^^^^^^^^^^^^^^^^^^^^^^
+
+To run a specific :term:`job` pass it to the ``--include-pattern`` or ``-i``
+option.
+
+For example, to run the ``cpu/scaling_test`` job:
+
+.. code-block:: bash
+
+    $ plainbox run -i cpu/scaling_test
+
+.. note::
+
+    The option ``-i`` can be provided any number of times.
+
+Running jobs related to a specific area
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+PlainBox has no concept of job categories but you can simulate that by
+running all jobs that follow a specific naming pattern. For example, to run
+all of the USB tests you can run the following command:
+
+.. code-block:: bash
+
+    $ plainbox run -i 'usb/.*'
+
+To list all known jobs run:
+
+.. code-block:: bash
+
+    plainbox special --list-jobs
+
+Running a white list
+^^^^^^^^^^^^^^^^^^^^
+
+To run a :term:`white list` pass the ``--whitelist`` or ``-w`` option.
+
+For example, to run the default white list run:
+
+.. code-block:: bash
+
+    $ plainbox run -w /usr/share/checkbox/data/whitelists/default.whitelist
+
+Saving test results as XML
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To generate an XML file that can be sent to the :term:`certification website`
+you need to pass two additional options:
+
+1. ``--output-format=xml``
+2. ``--output-file=NAME`` where *NAME* is a file name
+
+For example, to get the default certification tests ready to be submitted
+run this command:
+
+.. code-block:: bash
+
+    $ plainbox run --whitelist=/usr/share/checkbox/data/whitelists/default.whitelist --output-format=xml --output-file=submission.xml
+
+Running stable release update tests
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+PlainBox has special support for running stable release updates tests in an
+automated manner. This runs all the jobs from the *sru.whitelist* and sends the
+results to the certification website.
+
+To run SRU tests you will need to know the so-called :term:`Secure ID` of the
+device you are testing. Once you know that all you need to do is run:
+
+.. code-block:: bash
+
+    $ plainbox sru $secure_id submission.xml
+
+The second argument, submission.xml, is a name of the fallback file that is
+only created when sending the data to the certification website fails to work
+for any reason.

=== added file 'plainbox/mk-venv.sh.OTHER'
--- plainbox/mk-venv.sh.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/mk-venv.sh.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,195 @@
+#!/bin/sh
+# Create a virtualenv for working with plainbox.
+#
+# This ensures that 'plainbox' command exists and is in PATH and that the
+# plainbox module is correctly located can be imported.
+#
+# This is how Zygmunt Krynicki works, feel free to use or adjust to your needs
+
+VENV_PATH=
+install_missing=0
+# Parse arguments:
+while [ -n "$1" ]; do
+    case "$1" in
+        --help|-h)
+            echo "Usage: mk-venv.sh [LOCATION]"
+            echo ""
+            echo "Create a virtualenv for working with plainbox in LOCATION"
+            exit 0
+            ;;
+        --install-missing)
+            install_missing=1
+            shift
+            ;;
+        *)
+            if [ -z "$VENV_PATH" ]; then
+                VENV_PATH="$1"
+                shift
+            else
+                echo "Error: too many arguments: '$1'"
+                exit 1
+            fi
+            ;;
+    esac
+done
+
+# Apply defaults to arguments without values
+if [ -z "$VENV_PATH" ]; then
+    # Use sensible defaults for vagrant
+    if [ "$LOGNAME" = "vagrant" ]; then
+        VENV_PATH=/tmp/venv
+    else
+        VENV_PATH=/ramdisk/venv
+    fi
+fi
+
+# Do a sanity check on lsb_release that is missing on Fedora the last time I
+# had a look at it.
+if [ "x$(which lsb_release)" = "x" ]; then
+    echo "This script requires the 'lsb_release' command"
+    exit 1
+fi
+
+# The code below is a mixture of Debian/Ubuntu packages and pypi packages.
+# It is designed to work on Ubuntu 12.04 or later.
+# There are _some_ differences between how each release is handled.
+#
+# Non Ubuntu systems are not tested as they don't have the required checkbox
+# package. Debian might be supported once we have JobBox and stuff like Fedora
+# would need a whole new approach but patches are welcome [CLA required] 
+if [ "$(lsb_release --short --id)" != "Ubuntu" ] && [ $(lsb_release --short --id --upstream) != "Ubuntu" ]; then
+    echo "Only Ubuntu is supported by this script."
+    echo "If you are interested in using it with your distribution"
+    echo "then please join us in #ubuntu-quality on freenode"
+    echo
+    echo "Alternatively you can use vagrant to develop plainbox"
+    echo "on any operating system, even Windows ;-)" 
+    echo
+    echo "See: http://www.vagrantup.com/ for details"
+    exit 1
+fi
+# From now on we can assume a Debian-like system
+
+# Do some conditional stuff depending on the particular Ubuntu release 
+enable_system_site=0
+install_coverage=0
+install_distribute=0
+install_pip=0
+# We need:
+# python3:
+#   because that's what plainbox is written in
+# python3-dev
+#   because we may pip-install stuff as well and we want to build native extensions
+# python3-pkg-resources:
+#   because it is used by plainbox to locate files and extension points
+# python3-setuptools:
+#   because it is used by setup.py 
+# python3-lxml:
+#   because that's how we validate RealaxNG schemas
+# python3-mock:
+#   because that's what we used to construct some of our tests
+# python3-sphinx:
+#   because that's how we build our documentation
+# python-virtualenv:
+#   because that's how we create the virtualenv to work in
+# checkbox:
+#   because plainbox depends on it as a job provider 
+required_pkgs_base="python3 python3-dev python3-pkg-resources python3-setuptools python3-lxml python3-mock python3-sphinx python-virtualenv checkbox"
+
+# The defaults, install everything from pip and all the base packages
+enable_system_site=1
+install_distribute=1
+install_pip=1
+install_coverage=1
+install_requests=1
+required_pkgs="$required_pkgs_base"
+
+case "$(lsb_release --short --release)" in
+    12.04|0.2)
+        # Ubuntu 12.04, this is the LTS release that we have to support despite
+        # any difficulties. It has python3.2 and all of our core dependencies
+        # although some packages are old by 13.04 standards, make sure to be
+        # careful with testing against older APIs.
+        ;;
+    12.10)
+        ;;
+    13.04)
+        # On Raring we can use the system package for python3-requests
+        install_distribute=0
+        install_pip=0
+        install_requests=0
+        required_pkgs="$required_pkgs_base python3-requests"
+        ;;
+    *)
+        echo "Using this version of Ubuntu for development is not supported"
+        echo "Unsupported version: $(lsb_release --short --release)"
+        exit 1
+        ;;
+esac
+
+# Check if we can create a virtualenv
+if [ ! -d $(dirname $VENV_PATH) ]; then
+    echo "This script requires $(dirname $VENV_PATH) directory to exist"
+    echo "You can use different directory by passing it as argument"
+    echo "For a quick temporary location just pass /tmp/venv"
+    exit 1
+fi
+
+# Check if there's one already there
+if [ -d $VENV_PATH ]; then
+    echo "$VENV_PATH seems to already exist"
+    exit 1
+fi
+
+# Ensure that each required package is installed 
+for pkg_name in $required_pkgs; do
+    # Ensure virtualenv is installed 
+    if [ "$(dpkg -s $pkg_name 2>/dev/null | grep '^Status' 2>/dev/null)" != "Status: install ok installed" ]; then
+        if [ "$install_missing" -eq 1 ]; then
+            echo "Installing required package: $pkg_name"
+            sudo apt-get install $pkg_name --yes
+        else
+            echo "Required package is not installed: '$pkg_name'"
+            echo "Either install it manually with:"
+            echo "$ sudo apt-get install $pkg_name"
+            echo "Or rerun this script with --install-missing"
+            exit 1
+        fi
+    fi
+done
+
+# Create a virtualenv
+if [ $enable_system_site -eq 1 ]; then
+    virtualenv --system-site-packages -p python3 $VENV_PATH
+else
+    virtualenv -p python3 $VENV_PATH
+fi
+
+# Activate it to install additional stuff
+. $VENV_PATH/bin/activate
+
+# Install / upgrade distribute
+if [ $install_distribute -eq 1 ]; then
+    pip install --upgrade https://github.com/checkbox/external-tarballs/raw/master/pypi/coverage-3.6.tar.gz
+fi
+
+# Install / upgrade pip
+if [ $install_pip -eq 1 ]; then
+    pip install --upgrade https://github.com/checkbox/external-tarballs/raw/master/pypi/pip-1.3.1.tar.gz
+fi
+
+# Install coverage if required
+if [ $install_coverage -eq 1 ]; then
+    pip install --upgrade https://github.com/checkbox/external-tarballs/raw/master/pypi/coverage-3.6.tar.gz
+fi
+
+# Install requests if required
+if [ $install_requests -eq 1 ]; then
+    pip install --upgrade https://github.com/checkbox/external-tarballs/raw/master/pypi/requests-1.1.0.tar.gz
+fi
+
+# "develop" plainbox
+http_proxy=http://127.0.0.1:9/ python3 setup.py develop
+
+echo "To activate your virtualenv run:"
+echo "$ . $VENV_PATH/bin/activate"

=== added directory 'plainbox/plainbox'
=== added directory 'plainbox/plainbox/impl'
=== added file 'plainbox/plainbox/impl/box.py.OTHER'
--- plainbox/plainbox/impl/box.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/box.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,130 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 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.box` -- command line interface
+==================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
+from argparse import _ as argparse_gettext
+from logging import basicConfig
+from logging import getLogger
+import argparse
+import sys
+
+from plainbox import __version__ as version
+from plainbox.impl.applogic import PlainBoxConfig
+from plainbox.impl.checkbox import CheckBox
+from plainbox.impl.commands.run import RunCommand
+from plainbox.impl.commands.selftest import SelfTestCommand
+from plainbox.impl.commands.special import SpecialCommand
+from plainbox.impl.commands.sru import SRUCommand
+from plainbox.impl.commands.check_config import CheckConfigCommand
+
+
+logger = getLogger("plainbox.box")
+
+
+class PlainBox:
+    """
+    High-level plainbox object
+    """
+
+    def __init__(self):
+        self._checkbox = CheckBox()
+
+    def main(self, argv=None):
+        # TODO: setup sane logging system that works just as well for Joe user
+        # that runs checkbox from the CD as well as for checkbox developers and
+        # custom debugging needs.  It would be perfect^Hdesirable not to create
+        # another broken, never-rotated, uncapped logging crap that kills my
+        # SSD by writing junk to ~/.cache/
+        basicConfig(level="WARNING")
+        config = PlainBoxConfig.get()
+        parser = self._construct_parser(config)
+        ns = parser.parse_args(argv)
+        # Set the desired log level
+        getLogger("").setLevel(ns.log_level)
+        # 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):
+            parser.error(argparse_gettext("too few arguments"))
+        else:
+            return ns.command.invoked(ns)
+
+    def _construct_parser(self, config):
+        parser = ArgumentParser(
+            prog="plainbox", formatter_class=ArgumentDefaultsHelpFormatter)
+        parser.add_argument(
+            "-v", "--version", action="version",
+            version="{}.{}.{}".format(*version[:3]))
+        parser.add_argument(
+            "-l", "--log-level", action="store",
+            choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'),
+            default='WARNING',
+            help=argparse.SUPPRESS)
+        subparsers = parser.add_subparsers()
+        RunCommand(self._checkbox).register_parser(subparsers)
+        SpecialCommand(self._checkbox).register_parser(subparsers)
+        SelfTestCommand().register_parser(subparsers)
+        SRUCommand(self._checkbox, config).register_parser(subparsers)
+        CheckConfigCommand(config).register_parser(subparsers)
+        #group = parser.add_argument_group(title="user interface options")
+        #group.add_argument(
+        #    "-u", "--ui", action="store",
+        #    default=None, choices=('headless', 'text', 'graphics'),
+        #    help="select the UI front-end (defaults to auto)")
+        return parser
+
+
+def main(argv=None):
+    # Instantiate a global plainbox instance
+    # XXX: Allow one to control the checkbox= argument via
+    # environment or config.
+    box = PlainBox()
+    retval = box.main(argv)
+    raise SystemExit(retval)
+
+
+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")

=== added directory 'plainbox/plainbox/impl/commands'
=== added file 'plainbox/plainbox/impl/commands/checkbox.py.OTHER'
--- plainbox/plainbox/impl/commands/checkbox.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/checkbox.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,100 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012-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.checkbox` -- mix-in for checkbox commands
+======================================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+import re
+from argparse import FileType
+
+
+class CheckBoxInvocationMixIn:
+
+    def __init__(self, checkbox):
+        self.checkbox = checkbox
+
+    def get_job_list(self, ns):
+        """
+        Load and return a list of JobDefinition instances
+        """
+        return self.checkbox.get_builtin_jobs()
+
+    def _get_matching_job_list(self, ns, job_list):
+        # Find jobs that matched patterns
+        matching_job_list = []
+        # 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()])
+        # 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.
+            for pattern in ns.exclude_pattern_list:
+                regexp_pattern = r"^{pattern}$".format(pattern=pattern)
+                if re.match(regexp_pattern, job.name):
+                    break
+            else:
+                # Then 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)
+                    if re.match(regexp_pattern, job.name):
+                        matching_job_list.append(job)
+                        break
+        return matching_job_list
+
+
+class CheckBoxCommandMixIn:
+    """
+    Mix-in class for plainbox commands that want to discover and load checkbox
+    jobs
+    """
+
+    def enhance_parser(self, parser):
+        """
+        Add common options for job selection to an existing parser
+        """
+        group = parser.add_argument_group(title="job definition options")
+        group.add_argument(
+            '-i', '--include-pattern', action="append",
+            metavar='PATTERN', default=[], dest='include_pattern_list',
+            help=("Run jobs matching the given regular expression. Matches "
+                  "from the start to the end of the line."))
+        group.add_argument(
+            '-x', '--exclude-pattern', action="append",
+            metavar="PATTERN", default=[], dest='exclude_pattern_list',
+            help=("Do not run jobs matching the given regular expression. "
+                  "Matches from the start to the end of the line."))
+        # TODO: Find a way to handle the encoding of the file
+        group.add_argument(
+            '-w', '--whitelist',
+            metavar="WHITELIST",
+            type=FileType("rt"),
+            help="Load whitelist containing run patterns")

=== added file 'plainbox/plainbox/impl/commands/run.py.OTHER'
--- plainbox/plainbox/impl/commands/run.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/run.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,340 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012-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.run` -- run sub-command
+====================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+from argparse import FileType
+from logging import getLogger
+from os.path import join
+from shutil import copyfileobj
+import io
+import sys
+
+from requests.exceptions import ConnectionError, InvalidSchema, HTTPError
+
+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.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.transport import get_all_transports
+
+
+logger = getLogger("plainbox.commands.run")
+
+
+class RunInvocation(CheckBoxInvocationMixIn):
+
+    def __init__(self, checkbox, ns):
+        super(RunInvocation, self).__init__(checkbox)
+        self.ns = ns
+
+    def run(self):
+        ns = self.ns
+        if ns.output_format == '?':
+            self._print_output_format_list(ns)
+            return 0
+        elif ns.output_options == '?':
+            self._print_output_option_list(ns)
+            return 0
+        elif ns.transport == '?':
+            self._print_transport_list(ns)
+            return 0
+        else:
+            exporter = self._prepare_exporter(ns)
+            transport = self._prepare_transport(ns)
+            job_list = self.get_job_list(ns)
+            return self._run_jobs(ns, job_list, exporter, transport)
+
+    def _print_output_format_list(self, ns):
+        print("Available output formats: {}".format(
+            ', '.join(get_all_exporters())))
+
+    def _print_output_option_list(self, ns):
+        print("Each format may support a different set of options")
+        for name, exporter_cls in get_all_exporters().items():
+            print("{}: {}".format(
+                name, ", ".join(exporter_cls.supported_option_list)))
+
+    def _print_transport_list(self, ns):
+        print("Available transports: {}".format(
+            ', '.join(get_all_transports())))
+
+    def _prepare_exporter(self, ns):
+        exporter_cls = get_all_exporters()[ns.output_format]
+        if ns.output_options:
+            option_list = ns.output_options.split(',')
+        else:
+            option_list = None
+        try:
+            exporter = exporter_cls(option_list)
+        except ValueError as exc:
+            raise SystemExit(str(exc))
+        return exporter
+
+    def _prepare_transport(self, ns):
+        if ns.transport not in get_all_transports():
+            return None
+        transport_cls = get_all_transports()[ns.transport]
+        try:
+            return transport_cls(ns.transport_where, ns.transport_options)
+        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')
+        answer = None
+        while answer not in allowed:
+            answer = input(prompt)
+        return False if answer in ('n', 'N') else True
+
+    def _run_jobs(self, ns, job_list, exporter, transport=None):
+        # Ask the password before anything else in order to run jobs requiring
+        # privileges
+        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)
+        print("[ Analyzing Jobs ]".center(80, '='))
+        # Create a session that handles most of the stuff needed to run jobs
+        try:
+            session = SessionState(job_list)
+        except DependencyDuplicateError as exc:
+            # Handle possible DependencyDuplicateError that can happen if
+            # someone is using plainbox for job development.
+            print("The job database you are currently using is broken")
+            print("At least two jobs contend for the name {0}".format(
+                exc.job.name))
+            print("First job defined in: {0}".format(exc.job.origin))
+            print("Second job defined in: {0}".format(
+                exc.duplicate_job.origin))
+            raise SystemExit(exc)
+        with session.open():
+            if session.previous_session_file():
+                if self.ask_for_resume():
+                    session.resume()
+                else:
+                    session.clean()
+            self._update_desired_job_list(session, matching_job_list)
+            if (sys.stdin.isatty() and sys.stdout.isatty() and not
+                    ns.not_interactive):
+                outcome_callback = self.ask_for_outcome
+            else:
+                outcome_callback = None
+            runner = JobRunner(
+                session.session_dir,
+                session.jobs_io_log_dir,
+                outcome_callback=outcome_callback,
+                dry_run=ns.dry_run
+            )
+            self._run_jobs_with_session(ns, session, runner)
+            # Get a stream with exported session data.
+            exported_stream = io.BytesIO()
+            data_subset = exporter.get_session_data_subset(session)
+            exporter.dump(data_subset, exported_stream)
+            exported_stream.seek(0)  # Need to rewind the file, puagh
+            # Write the stream to file if requested
+            self._save_results(ns.output_file, exported_stream)
+            # Invoke the transport?
+            if transport:
+                exported_stream.seek(0)
+                try:
+                    transport.send(exported_stream.read())
+                except InvalidSchema as exc:
+                    print("Invalid destination URL: {0}".format(exc))
+                except ConnectionError as exc:
+                    print(("Unable to connect "
+                           "to destination URL: {0}").format(exc))
+                except HTTPError as exc:
+                    print(("Server returned an error when "
+                           "receiving or processing: {0}").format(exc))
+
+        # FIXME: sensible return value
+        return 0
+
+    def _save_results(self, output_file, input_stream):
+        if output_file is sys.stdout:
+            print("[ Results ]".center(80, '='))
+            # This requires a bit more finesse, as exporters output bytes
+            # and stdout needs a string.
+            translating_stream = ByteStringStreamTranslator(
+                output_file, "utf-8")
+            copyfileobj(input_stream, translating_stream)
+        else:
+            print("Saving results to {}".format(output_file.name))
+            copyfileobj(input_stream, output_file)
+        if output_file is not sys.stdout:
+            output_file.close()
+
+    def ask_for_outcome(self, prompt=None, allowed=None):
+        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
+
+    def _update_desired_job_list(self, session, desired_job_list):
+        problem_list = session.update_desired_job_list(desired_job_list)
+        if problem_list:
+            print("[ Warning ]".center(80, '*'))
+            print("There were some problems with the selected jobs")
+            for problem in problem_list:
+                print(" * {}".format(problem))
+            print("Problematic jobs will not be considered")
+
+    def _run_jobs_with_session(self, ns, session, runner):
+        # TODO: run all resource jobs concurrently with multiprocessing
+        # TODO: make local job discovery nicer, it would be best if
+        # desired_jobs could be managed entirely internally by SesionState. In
+        # such case the list of jobs to run would be changed during iteration
+        # but would be otherwise okay).
+        print("[ Running All Jobs ]".center(80, '='))
+        again = True
+        while again:
+            again = False
+            for job in session.run_list:
+                # Skip jobs that already have result, this is only needed when
+                # we run over the list of jobs again, after discovering new
+                # jobs via the local job output
+                if session.job_state_map[job.name].result.outcome is not None:
+                    continue
+                self._run_single_job_with_session(ns, session, runner, job)
+                session.persistent_save()
+                if job.plugin == "local":
+                    # After each local job runs rebuild the list of matching
+                    # jobs and run everything again
+                    new_matching_job_list = self._get_matching_job_list(
+                        ns, session.job_list)
+                    self._update_desired_job_list(
+                        session, new_matching_job_list)
+                    again = True
+                    break
+
+    def _run_single_job_with_session(self, ns, session, runner, job):
+        print("[ {} ]".format(job.name).center(80, '-'))
+        if job.description is not None:
+            print(job.description)
+            print("^" * len(job.description.splitlines()[-1]))
+            print()
+        job_state = session.job_state_map[job.name]
+        logger.debug("Job name: %s", job.name)
+        logger.debug("Plugin: %s", job.plugin)
+        logger.debug("Direct dependencies: %s", job.get_direct_dependencies())
+        logger.debug("Resource dependencies: %s",
+                     job.get_resource_dependencies())
+        logger.debug("Resource program: %r", job.requires)
+        logger.debug("Command: %r", job.command)
+        logger.debug("Can start: %s", job_state.can_start())
+        logger.debug("Readiness: %s", job_state.get_readiness_description())
+        if job_state.can_start():
+            print("Running... (output in {}.*)".format(
+                join(session.jobs_io_log_dir, slugify(job.name))))
+            job_result = runner.run_job(job)
+            print("Outcome: {}".format(job_result.outcome))
+            print("Comments: {}".format(job_result.comments))
+        else:
+            job_result = JobResult({
+                'job': job,
+                'outcome': JobResult.OUTCOME_NOT_SUPPORTED,
+                'comments': job_state.get_readiness_description()
+            })
+        if job_result is not None:
+            session.update_job_result(job, job_result)
+
+
+class RunCommand(PlainBoxCommand, CheckBoxCommandMixIn):
+
+    def __init__(self, checkbox):
+        self.checkbox = checkbox
+
+    def invoked(self, ns):
+        return RunInvocation(self.checkbox, ns).run()
+
+    def register_parser(self, subparsers):
+        parser = subparsers.add_parser("run", help="run a test job")
+        parser.set_defaults(command=self)
+        group = parser.add_argument_group(title="user interface options")
+        group.add_argument(
+            '--not-interactive', action='store_true',
+            help="Skip tests that require interactivity")
+        group.add_argument(
+            '-n', '--dry-run', action='store_true',
+            help="Don't actually run any jobs")
+        group = parser.add_argument_group("output options")
+        assert 'text' in get_all_exporters()
+        group.add_argument(
+            '-f', '--output-format', default='text',
+            metavar='FORMAT', choices=['?'] + list(
+                get_all_exporters().keys()),
+            help=('Save test results in the specified FORMAT'
+                  ' (pass ? for a list of choices)'))
+        group.add_argument(
+            '-p', '--output-options', default='',
+            metavar='OPTIONS',
+            help=('Comma-separated list of options for the export mechanism'
+                  ' (pass ? for a list of choices)'))
+        group.add_argument(
+            '-o', '--output-file', default='-',
+            metavar='FILE', type=FileType("wb"),
+            help=('Save test results to the specified FILE'
+                  ' (or to stdout if FILE is -)'))
+        group.add_argument(
+            '-t', '--transport',
+            metavar='TRANSPORT', choices=['?'] + list(
+                get_all_transports().keys()),
+            help=('use TRANSPORT to send results somewhere'
+                  ' (pass ? for a list of choices)'))
+        group.add_argument(
+            '--transport-where',
+            metavar='WHERE',
+            help=('Where to send data using the selected transport.'
+                  ' This is passed as-is and is transport-dependent.'))
+        group.add_argument(
+            '--transport-options',
+            metavar='OPTIONS',
+            help=('Comma-separated list of key-value options (k=v) to '
+                  ' be passed to the transport.'))
+        # Call enhance_parser from CheckBoxCommandMixIn
+        self.enhance_parser(parser)

=== added file 'plainbox/plainbox/impl/commands/special.py.OTHER'
--- plainbox/plainbox/impl/commands/special.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/special.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,159 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012-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.special` -- special sub-command
+============================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+from logging import getLogger
+
+from plainbox.impl.commands import PlainBoxCommand
+from plainbox.impl.commands.checkbox import CheckBoxCommandMixIn
+from plainbox.impl.commands.checkbox import CheckBoxInvocationMixIn
+
+
+logger = getLogger("plainbox.commands.special")
+
+
+class SpecialInvocation(CheckBoxInvocationMixIn):
+
+    def __init__(self, checkbox, ns):
+        super(SpecialInvocation, self).__init__(checkbox)
+        self.ns = ns
+
+    def run(self):
+        ns = self.ns
+        job_list = self.get_job_list(ns)
+        # Now either do a special action or run the jobs
+        if ns.special == "list-jobs":
+            self._print_job_list(ns, job_list)
+        elif ns.special == "list-job-hashes":
+            self._print_job_hash_list(ns, job_list)
+        elif ns.special == "list-expr":
+            self._print_expression_list(ns, job_list)
+        elif ns.special == "dep-graph":
+            self._print_dot_graph(ns, job_list)
+        # Always succeed
+        return 0
+
+    def _get_matching_job_list(self, ns, job_list):
+        matching_job_list = super(
+            SpecialInvocation, self)._get_matching_job_list(ns, job_list)
+        # As a special exception, when ns.special is set and we're either
+        # listing jobs or job dependencies then when no run pattern was
+        # specified just operate on the whole set. The ns.special check
+        # prevents people starting plainbox from accidentally running _all_
+        # jobs without prompting.
+        if ns.special is not None and not ns.include_pattern_list:
+            matching_job_list = job_list
+        return matching_job_list
+
+    def _print_job_list(self, ns, job_list):
+        matching_job_list = self._get_matching_job_list(ns, job_list)
+        for job in matching_job_list:
+            print("{}".format(job))
+
+    def _print_job_hash_list(self, ns, job_list):
+        matching_job_list = self._get_matching_job_list(ns, job_list)
+        for job in matching_job_list:
+            print("{} {}".format(job.get_checksum(), job))
+
+    def _print_expression_list(self, ns, job_list):
+        matching_job_list = self._get_matching_job_list(ns, job_list)
+        expressions = set()
+        for job in matching_job_list:
+            prog = job.get_resource_program()
+            if prog is not None:
+                for expression in prog.expression_list:
+                    expressions.add(expression.text)
+        for expression in sorted(expressions):
+            print(expression)
+
+    def _print_dot_graph(self, ns, job_list):
+        matching_job_list = self._get_matching_job_list(ns, job_list)
+        print('digraph dependency_graph {')
+        print('\tnode [shape=box];')
+        for job in matching_job_list:
+            if job.plugin == "resource":
+                print('\t"{}" [shape=ellipse,color=blue];'.format(job.name))
+            elif job.plugin == "attachment":
+                print('\t"{}" [color=green];'.format(job.name))
+            elif job.plugin == "local":
+                print('\t"{}" [shape=invtriangle,color=red];'.format(
+                    job.name))
+            elif job.plugin == "shell":
+                print('\t"{}" [];'.format(job.name))
+            elif job.plugin in ("manual", "user-verify", "user-interact"):
+                print('\t"{}" [color=orange];'.format(job.name))
+            for dep_name in job.get_direct_dependencies():
+                print('\t"{}" -> "{}";'.format(job.name, dep_name))
+            prog = job.get_resource_program()
+            if ns.dot_resources and prog is not None:
+                for expression in prog.expression_list:
+                    print('\t"{}" [shape=ellipse,color=blue];'.format(
+                        expression.resource_name))
+                    print('\t"{}" -> "{}" [style=dashed, label="{}"];'.format(
+                        job.name, expression.resource_name,
+                        expression.text.replace('"', "'")))
+        print("}")
+
+
+class SpecialCommand(PlainBoxCommand, CheckBoxCommandMixIn):
+    """
+    Implementation of ``$ plainbox special``
+    """
+
+    def __init__(self, checkbox):
+        self.checkbox = checkbox
+
+    def invoked(self, ns):
+        return SpecialInvocation(self.checkbox, ns).run()
+
+    def register_parser(self, subparsers):
+        parser = subparsers.add_parser(
+            "special", help="special/internal commands")
+        parser.set_defaults(command=self)
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument(
+            '-j', '--list-jobs',
+            help="List jobs instead of running them",
+            action="store_const", const="list-jobs", dest="special")
+        group.add_argument(
+            '-J', '--list-job-hashes',
+            help="List jobs with hashes instead of running them",
+            action="store_const", const="list-job-hashes", dest="special")
+        group.add_argument(
+            '-e', '--list-expressions',
+            help="List all unique resource expressions",
+            action="store_const", const="list-expr", dest="special")
+        group.add_argument(
+            '-d', '--dot',
+            help="Print a graph of jobs instead of running them",
+            action="store_const", const="dep-graph", dest="special")
+        parser.add_argument(
+            '--dot-resources',
+            help="Render resource relationships (for --dot)",
+            action='store_true')
+        # Call enhance_parser from CheckBoxCommandMixIn
+        self.enhance_parser(parser)

=== added file 'plainbox/plainbox/impl/commands/sru.py.OTHER'
--- plainbox/plainbox/impl/commands/sru.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/sru.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,271 @@
+# 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.sru` -- sru sub-command
+====================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+import logging
+import os
+import tempfile
+
+from requests.exceptions import ConnectionError, InvalidSchema, HTTPError
+
+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.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.transport.certification import CertificationTransport
+from plainbox.impl.transport.certification import InvalidSecureIDError
+
+
+logger = logging.getLogger("plainbox.commands.sru")
+
+
+class _SRUInvocation:
+    """
+    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
+        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()
+        # XXX: maybe allow specifying system_id from command line?
+        self.exporter = XMLSessionStateExporter(system_id=None)
+        self.session = None
+        self.runner = None
+
+    def run(self):
+        # Compute the run list, this can give us notification about problems in
+        # the selected jobs. Currently we just display each problem
+        # Create a session that handles most of the stuff needed to run jobs
+        try:
+            self.session = SessionState(self.job_list)
+        except DependencyDuplicateError as exc:
+            # Handle possible DependencyDuplicateError that can happen if
+            # someone is using plainbox for job development.
+            print("The job database you are currently using is broken")
+            print("At least two jobs contend for the name {0}".format(
+                exc.job.name))
+            print("First job defined in: {0}".format(exc.job.origin))
+            print("Second job defined in: {0}".format(
+                exc.duplicate_job.origin))
+            raise SystemExit(exc)
+        with self.session.open():
+            self._set_job_selection()
+            self.runner = JobRunner(
+                self.session.session_dir,
+                self.session.jobs_io_log_dir,
+                command_io_delegate=self,
+                outcome_callback=None,  # SRU runs are never interactive
+                dry_run=self.ns.dry_run
+            )
+            self._run_all_jobs()
+            if self.config.fallback_file is not Unset:
+                self._save_results()
+            self._submit_results()
+        # FIXME: sensible return value
+        return 0
+
+    def _set_job_selection(self):
+        desired_job_list = get_matching_job_list(self.job_list, self.whitelist)
+        problem_list = self.session.update_desired_job_list(desired_job_list)
+        if problem_list:
+            logger.warning("There were some problems with the selected jobs")
+            for problem in problem_list:
+                logger.warning("- %s", problem)
+            logger.warning("Problematic jobs will not be considered")
+
+    def _save_results(self):
+        print("Saving results to {0}".format(self.config.fallback_file))
+        data = self.exporter.get_session_data_subset(self.session)
+        with open(self.config.fallback_file, "wt", encoding="UTF-8") as stream:
+            translating_stream = ByteStringStreamTranslator(stream, "UTF-8")
+            self.exporter.dump(data, translating_stream)
+
+    def _submit_results(self):
+        print("Submitting results to {0} for secure_id {1}".format(
+              self.config.c3_url, self.config.secure_id))
+        options_string = "secure_id={0}".format(self.config.secure_id)
+        # Create the transport object
+        try:
+            transport = CertificationTransport(
+                self.config.c3_url, options_string, self.config)
+        except InvalidSecureIDError as exc:
+            print(exc)
+            return False
+        # Prepare the data for submission
+        data = self.exporter.get_session_data_subset(self.session)
+        with tempfile.NamedTemporaryFile(mode='w+b') as stream:
+            # Dump the data to the temporary file
+            self.exporter.dump(data, stream)
+            # Flush and rewind
+            stream.flush()
+            stream.seek(0)
+            try:
+                # Send the data, reading from the temporary file
+                result = transport.send(stream)
+                if 'url' in result:
+                    print("Successfully sent, submission status at {0}".format(
+                          result['url']))
+                else:
+                    print("Successfully sent, server response: {0}".format(
+                          result))
+
+            except InvalidSchema as exc:
+                print("Invalid destination URL: {0}".format(exc))
+            except ConnectionError as exc:
+                print("Unable to connect to destination URL: {0}".format(exc))
+            except HTTPError as exc:
+                print(("Server returned an error when "
+                       "receiving or processing: {0}").format(exc))
+            except IOError as exc:
+                print("Problem reading a file: {0}".format(exc))
+
+    def _run_all_jobs(self):
+        again = True
+        while again:
+            again = False
+            for job in self.session.run_list:
+                # Skip jobs that already have result, this is only needed when
+                # we run over the list of jobs again, after discovering new
+                # jobs via the local job output
+                result = self.session.job_state_map[job.name].result
+                if result.outcome is not None:
+                    continue
+                self._run_single_job(job)
+                self.session.persistent_save()
+                if job.plugin == "local":
+                    # After each local job runs rebuild the list of matching
+                    # jobs and run everything again
+                    self._set_job_selection()
+                    again = True
+                    break
+
+    def _run_single_job(self, job):
+        print("- {}:".format(job.name), end=' ')
+        job_state, job_result = run_job_if_possible(
+            self.session, self.runner, self.config, job)
+        print("{0}".format(job_result.outcome))
+        if job_result.comments is not None:
+            print("comments: {0}".format(job_result.comments))
+        if job_state.readiness_inhibitor_list:
+            print("inhibitors:")
+        for inhibitor in job_state.readiness_inhibitor_list:
+            print("  * {}".format(inhibitor))
+        self.session.update_job_result(job, job_result)
+
+
+class SRUCommand(PlainBoxCommand):
+    """
+    Command for running Stable Release Update (SRU) tests.
+
+    Stable release updates are periodic fixes for nominated bugs that land in
+    existing supported Ubuntu releases. To ensure a certain level of quality
+    all SRU updates affecting hardware enablement are automatically tested
+    on a pool of certified machines.
+
+    This command is _temporary_ and will eventually migrate to the checkbox
+    side. Its intended lifecycle is for the development and validation of
+    plainbox core on realistic workloads.
+    """
+
+    def __init__(self, checkbox, config):
+        self.checkbox = checkbox
+        self.config = config
+
+    def invoked(self, ns):
+        # Copy command-line arguments over configuration variables
+        try:
+            if ns.secure_id:
+                self.config.secure_id = ns.secure_id
+            if ns.fallback_file and ns.fallback_file is not Unset:
+                self.config.fallback_file = ns.fallback_file
+            if ns.c3_url:
+                self.config.c3_url = ns.c3_url
+        except ValidationError as exc:
+            print("Configuration problems prevent running SRU tests")
+            print(exc)
+            return 1
+        # Run check-config, if requested
+        if ns.check_config:
+            retval = CheckConfigInvocation(self.config).run()
+            if retval != 0:
+                return retval
+        return _SRUInvocation(self.checkbox, self.config, ns).run()
+
+    def register_parser(self, subparsers):
+        parser = subparsers.add_parser(
+            "sru", help="run automated stable release update tests")
+        parser.set_defaults(command=self)
+        parser.add_argument(
+            "--check-config",
+            action="store_true",
+            help="Run plainbox check-config before starting")
+        group = parser.add_argument_group("sru-specific options")
+        # Set defaults from based on values from the config file
+        group.set_defaults(
+            secure_id=self.config.secure_id,
+            c3_url=self.config.c3_url,
+            fallback_file=self.config.fallback_file)
+        group.add_argument(
+            '--secure-id', metavar="SECURE-ID",
+            action='store',
+            # NOTE: --secure-id is optional only when set in a config file
+            required=self.config.secure_id is Unset,
+            help=("Associate submission with a machine using this SECURE-ID"
+                  " (%(default)s)"))
+        group.add_argument(
+            '--fallback', metavar="FILE",
+            dest='fallback_file',
+            action='store',
+            default=Unset,
+            help=("If submission fails save the test report as FILE"
+                  " (%(default)s)"))
+        group.add_argument(
+            '--destination', metavar="URL",
+            dest='c3_url',
+            action='store',
+            help=("POST the test report XML to this URL"
+                  " (%(default)s)"))
+        group = parser.add_argument_group(title="execution options")
+        group.add_argument(
+            '-n', '--dry-run',
+            action='store_true',
+            default=False,
+            help=("Skip all usual jobs."
+                  " Only local, resource and attachment jobs are started"))

=== added file 'plainbox/plainbox/impl/commands/test_run.py.OTHER'
--- plainbox/plainbox/impl/commands/test_run.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/commands/test_run.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,142 @@
+# This file is part of Checkbox.
+#
+# Copyright 2013 Canonical Ltd.
+# Written by:
+#   Zygmunt Krynicki <[e-mail]>
+#   Daniel Manrique  <[e-mail]>
+#
+# Checkbox is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License 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.commands.test_run
+===============================
+
+Test definitions for plainbox.impl.run module
+"""
+
+import os
+import shutil
+import tempfile
+
+from inspect import cleandoc
+from mock import patch
+from unittest import TestCase
+
+from plainbox.impl.box import main
+from plainbox.testing_utils.io import TestIO
+
+
+class TestRun(TestCase):
+
+    def setUp(self):
+        # session data are kept in XDG_CACHE_HOME/plainbox/.session
+        # To avoid resuming a real session, we have to select a temporary
+        # location instead
+        self._sandbox = tempfile.mkdtemp()
+        self._env = os.environ
+        os.environ['XDG_CACHE_HOME'] = self._sandbox
+
+    def test_help(self):
+        with TestIO(combined=True) as io:
+            with self.assertRaises(SystemExit) as call:
+                main(['run', '--help'])
+            self.assertEqual(call.exception.args, (0,))
+        self.maxDiff = None
+        expected = """
+        usage: plainbox run [-h] [--not-interactive] [-n] [-f FORMAT] [-p OPTIONS]
+                            [-o FILE] [-t TRANSPORT] [--transport-where WHERE]
+                            [--transport-options OPTIONS] [-i PATTERN] [-x PATTERN]
+                            [-w WHITELIST]
+
+        optional arguments:
+          -h, --help            show this help message and exit
+
+        user interface options:
+          --not-interactive     Skip tests that require interactivity
+          -n, --dry-run         Don't actually run any jobs
+
+        output options:
+          -f FORMAT, --output-format FORMAT
+                                Save test results in the specified FORMAT (pass ? for
+                                a list of choices)
+          -p OPTIONS, --output-options OPTIONS
+                                Comma-separated list of options for the export
+                                mechanism (pass ? for a list of choices)
+          -o FILE, --output-file FILE
+                                Save test results to the specified FILE (or to stdout
+                                if FILE is -)
+          -t TRANSPORT, --transport TRANSPORT
+                                use TRANSPORT to send results somewhere (pass ? for a
+                                list of choices)
+          --transport-where WHERE
+                                Where to send data using the selected transport. This
+                                is passed as-is and is transport-dependent.
+          --transport-options OPTIONS
+                                Comma-separated list of key-value options (k=v) to be
+                                passed to the transport.
+
+        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")
+
+    def test_run_without_args(self):
+        with TestIO(combined=True) as io:
+            with self.assertRaises(SystemExit) as call:
+                with patch('plainbox.impl.commands.run.authenticate_warmup') as mock_warmup:
+                    mock_warmup.return_value = 0
+                    main(['run'])
+            self.assertEqual(call.exception.args, (0,))
+        expected = """
+        ===============================[ Authentication ]===============================
+        ===============================[ Analyzing Jobs ]===============================
+        ==============================[ Running All Jobs ]==============================
+        ==================================[ Results ]===================================
+        """
+        self.assertEqual(io.combined, cleandoc(expected) + "\n")
+
+    def test_output_format_list(self):
+        with TestIO(combined=True) as io:
+            with self.assertRaises(SystemExit) as call:
+                main(['run', '--output-format=?'])
+            self.assertEqual(call.exception.args, (0,))
+        expected = """
+        Available output formats: json, rfc822, text, xml
+        """
+        self.assertEqual(io.combined, cleandoc(expected) + "\n")
+
+    def test_output_option_list(self):
+        with TestIO(combined=True) as io:
+            with self.assertRaises(SystemExit) as call:
+                main(['run', '--output-option=?'])
+            self.assertEqual(call.exception.args, (0,))
+        expected = """
+        Each format may support a different set of options
+        json: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments, machine-json
+        rfc822: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments
+        text: with-io-log, squash-io-log, flatten-io-log, with-run-list, with-job-list, with-resource-map, with-job-defs, with-attachments, with-comments
+        xml: 
+        """
+        self.assertEqual(io.combined, cleandoc(expected) + "\n")
+
+    def tearDown(self):
+        shutil.rmtree(self._sandbox)
+        os.environ = self._env

=== added file 'plainbox/plainbox/impl/config.py.OTHER'
--- plainbox/plainbox/impl/config.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/config.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,544 @@
+# 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.config` -- configuration
+============================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE A STABLE PUBLIC API
+"""
+
+from abc import ABCMeta, abstractmethod
+import collections
+import configparser
+import logging
+import re
+
+
+logger = logging.getLogger("plainbox.config")
+
+
+class INameTracking(metaclass=ABCMeta):
+    """
+    Interface for classes that are instantiated as a part of definition of
+    another class. The purpose of this interface is to allow instances to learn
+    about the name (python identifier) that was assigned to the instance at
+    class definition time.
+
+    Subclasses must define the _set_tracked_name() method.
+    """
+
+    @abstractmethod
+    def _set_tracked_name(self, name):
+        """
+        Set the that corresponds to the symbol used in class definition. This
+        can be a no-op if the name was already set by other means
+        """
+
+
+class ConfigMetaData:
+    """
+    Class containing meta-data about a Config class
+
+    Sub-classes of this class are automatically added to each Config subclass
+    as a Meta class-level attribute.
+
+    This class has typically two attributes:
+
+        :cvar variable_list:
+            A list of all Variable objects defined in the class
+
+        :cvar section_list:
+            A list of all Section object defined in the class
+
+        :cvar filename_list:
+            A list of config files (pathnames) to read on call to
+            :meth:`Config.read`
+    """
+    variable_list = []
+    section_list = []
+    filename_list = []
+
+
+class UnsetType:
+    """
+    Class of the Unset object
+    """
+
+    def __str__(self):
+        return "unset"
+
+    def __repr__(self):
+        return "Unset"
+
+
+Unset = UnsetType()
+
+
+class Variable(INameTracking):
+    """
+    Variable that can be used in a configuration systems
+    """
+
+    _KIND_CHOICE = (bool, int, float, str)
+
+    def __init__(self, name=None, *, section='DEFAULT', kind=str,
+                 default=Unset, validator_list=None, help_text=None):
+        # Ensure kind is correct
+        if kind not in self._KIND_CHOICE:
+            raise ValueError("unsupported kind")
+        # Ensure that we have a validator_list, even if empty
+        if validator_list is None:
+            validator_list = []
+        # Insert a KindValidator as the first validator to run
+        validator_list.insert(0, KindValidator)
+        # Assign all the attributes
+        self._name = name
+        self._section = section
+        self._kind = kind
+        self._default = default
+        self._validator_list = validator_list
+        self._help_text = help_text
+        self._validate_default_value()
+        # Workaround for Sphinx breaking if __doc__ is a property
+        self.__doc__ = self.help_text or self.__class__.__doc__
+
+    def _validate_default_value(self):
+        """
+        Validate the default value, unless it is Unset
+        """
+        if self.default is Unset:
+            return
+        for validator in self.validator_list:
+            message = validator(self, self.default)
+            if message is not None:
+                raise ValidationError(self, self.default, message)
+
+    def _set_tracked_name(self, name):
+        """
+        Internal method used by :meth:`ConfigMeta.__new__`
+        """
+        if self._name is None:
+            self._name = name
+
+    @property
+    def name(self):
+        """
+        name of this variable
+        """
+        return self._name
+
+    @property
+    def section(self):
+        """
+        name of the section this variable belongs to (in a configuration file)
+        """
+        return self._section
+
+    @property
+    def kind(self):
+        """
+        the "poor man's type", can be only str (default), bool, float or int
+        """
+        return self._kind
+
+    @property
+    def default(self):
+        """
+        a default value, if any
+        """
+        return self._default
+
+    @property
+    def validator_list(self):
+        """
+        a optional list of :class:`Validator` instances that are enforced on
+        the value
+        """
+        return self._validator_list
+
+    @property
+    def help_text(self):
+        """
+        an optional help text associated with this variable
+        """
+        return self._help_text
+
+    def __repr__(self):
+        return "<Variable name:{!r}>".format(self.name)
+
+    def __get__(self, instance, owner):
+        """
+        Get the value of a variable
+
+        Missing variables return the default value
+        """
+        if instance is None:
+            return self
+        try:
+            return instance._get_variable(self._name)
+        except KeyError:
+            return self.default
+
+    def __set__(self, instance, new_value):
+        """
+        Set the value of a variable
+
+        :raises ValidationError: if the new value is incorrect
+        """
+        # Check it against all validators
+        for validator in self.validator_list:
+            message = validator(self, new_value)
+            if message is not None:
+                raise ValidationError(self, new_value, message)
+        # Assign it to the backing store of the instance
+        instance._set_variable(self.name, new_value)
+
+    def __delete__(self, instance):
+        # NOTE: this is quite confusing, this method is a companion to __get__
+        # and __set__ but __del__ is entirely unrelated (object garbage
+        # collected, do final cleanup) so don't think this is a mistake
+        instance._del_variable(self._name)
+
+
+class Section(INameTracking):
+    """
+    A section of a configuration file.
+    """
+
+    def __init__(self, name=None, *, help_text=None):
+        self._name = name
+        self._help_text = help_text
+        # Workaround for Sphinx breaking if __doc__ is a property
+        self.__doc__ = self.help_text or self.__class__.__doc__
+
+    def _set_tracked_name(self, name):
+        """
+        Internal method used by :meth:`ConfigMeta.__new__`
+        """
+        if self._name is None:
+            self._name = name
+
+    @property
+    def name(self):
+        """
+        name of this section
+        """
+        return self._name
+
+    @property
+    def help_text(self):
+        """
+        an optional help text associated with this section
+        """
+        return self._help_text
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        try:
+            return instance._get_section(self._name)
+        except KeyError:
+            return Unset
+
+    def __set__(self, instance, new_value):
+        instance._set_section(self.name, new_value)
+
+    def __delete__(self, instance):
+        instance._del_section(self.name)
+
+
+class ConfigMeta(type):
+    """
+    Meta class for all configuration classes.
+
+    This meta class handles assignment of '_name' attribute to each
+    :class:`Variable` instance created in the class body.
+
+    It also accumulates such instances and assigns them to variable_list in a
+    helper Meta class which is assigned back to the namespace
+    """
+
+    def __new__(mcls, name, bases, namespace, **kwargs):
+        # Keep track of variables and sections from base class
+        variable_list = []
+        section_list = []
+        if 'Meta' in namespace:
+            if hasattr(namespace['Meta'], 'variable_list'):
+                variable_list = namespace['Meta'].variable_list[:]
+            if hasattr(namespace['Meta'], 'section_list'):
+                section_list = namespace['Meta'].section_list[:]
+        # Discover all Variable and Section instances
+        # defined in the class namespace
+        for name, item in namespace.items():
+            if isinstance(item, INameTracking):
+                item._set_tracked_name(name)
+            if isinstance(item, Variable):
+                variable_list.append(item)
+            elif isinstance(item, Section):
+                section_list.append(item)
+        # Get or create the class of the 'Meta' object.
+        #
+        # This class should always inherit from ConfigMetaData and whatever the
+        # user may have defined as Meta.
+        Meta_name = "Meta"
+        Meta_bases = (ConfigMetaData,)
+        Meta_ns = {
+            'variable_list': variable_list,
+            'section_list': section_list
+        }
+        if 'Meta' in namespace:
+            user_Meta_cls = namespace['Meta']
+            if not isinstance(user_Meta_cls, type):
+                raise TypeError("Meta must be a class")
+            Meta_bases = (user_Meta_cls, ConfigMetaData)
+        # Create a new type for the Meta class
+        namespace['Meta'] = type.__new__(
+            type(ConfigMetaData), Meta_name, Meta_bases, Meta_ns)
+        # Create a new type for the Config subclass
+        return type.__new__(mcls, name, bases, namespace)
+
+    @classmethod
+    def __prepare__(mcls, name, bases, **kwargs):
+        return collections.OrderedDict()
+
+
+class PlainBoxConfigParser(configparser.ConfigParser):
+    """
+    A simple ConfigParser subclass that does not lowercase
+    key names.
+    """
+    def optionxform(self, option):
+        return option
+
+
+class Config(metaclass=ConfigMeta):
+    """
+    Base class for configuration systems
+
+    :ivar _var:
+        storage backend for Variable definitions
+
+    :ivar _section:
+        storage backend for Section definitions
+
+    :ivar _filename_list:
+        list of pathnames to files that were loaded by the last call to
+        :meth:`read()`
+
+    :ivar _problem_list:
+        list of :class:`ValidationError` that were detected by the last call to
+        :meth:`read()`
+    """
+
+    def __init__(self):
+        """
+        Initialize an empty Config object
+        """
+        self._var = {}
+        self._section = {}
+        self._filename_list = []
+        self._problem_list = []
+
+    @property
+    def problem_list(self):
+        """
+        list of :class:`ValidationError` that were detected by the last call to
+        :meth:`read()`
+        """
+        return self._problem_list
+
+    @property
+    def filename_list(self):
+        """
+        list of pathnames to files that were loaded by the last call to
+        :meth:`read()`
+        """
+        return self._filename_list
+
+    @classmethod
+    def get(cls):
+        """
+        Get an instance of this Config class with all the configuration loaded
+        from default locations. The locations are determined by
+        Meta.filename_list attribute.
+
+        :returns: fresh :class:`Config` instance
+
+        """
+        self = cls()
+        self.read(cls.Meta.filename_list)
+        return self
+
+    def read(self, filename_list):
+        """
+        Load and merge settings from many files.
+
+        This method tries to open each file from the list of filenames, parse
+        it as an INI file using :class:`PlainBoxConfigParser` (a simple
+        ConfigParser subclass that respects the case of key names). The list of
+        files actually accessed is saved as available as
+        :attr:`Config.filename_list`.
+
+        If any problem is detected during parsing (e.g. syntax errors) those
+        are captured and added to the :attr:`Config.problem_list`.
+
+        After all files are loaded each :class:`Variable` and :class:`Section`
+        defined in the :class:`Config` class is assigned with the data from the
+        merged configuration data.
+
+        Any variables that cannot be assigned and raise
+        :class:`ValidationError` are ignored but the list of problems is saved.
+
+        All unused configuration (extra variables that are not defined as
+        either Variable or Section class) is silently ignored.
+
+        .. note::
+            This method resets :ivar:`_problem_list` and
+            :ivar:`_filename_list`.
+        """
+        parser = PlainBoxConfigParser()
+        # Reset filename list and problem list
+        self._filename_list = []
+        self._problem_list = []
+        # Try loading all of the config files
+        try:
+            self._filename_list = parser.read(filename_list)
+        except configparser.Error as exc:
+            self._problem_list.append(exc)
+        # Pick a reader function appropriate for the kind of variable
+        reader_fn = {
+            str: parser.get,
+            bool: parser.getboolean,
+            int: parser.getint,
+            float: parser.getfloat
+        }
+        # Load all variables that we know about
+        for variable in self.Meta.variable_list:
+            # Access the variable in the configuration file
+            try:
+                value = reader_fn[variable.kind](
+                    variable.section, variable.name)
+            except configparser.NoSectionError:
+                continue
+            except configparser.NoOptionError:
+                continue
+            # Try to assign it
+            try:
+                variable.__set__(self, value)
+            except ValidationError as exc:
+                self.problem_list.append(exc)
+        # Load all sections that we know about
+        for section in self.Meta.section_list:
+            try:
+                # Access the section in the configuration file
+                value = dict(parser.items(section.name))
+            except configparser.NoSectionError:
+                continue
+            # Assign it
+            section.__set__(self, value)
+
+    def _get_variable(self, name):
+        """
+        Internal method called by :meth:`Variable.__get__`
+        """
+        return self._var[name]
+
+    def _set_variable(self, name, value):
+        """
+        Internal method called by :meth:`Variable.__set__`
+        """
+        self._var[name] = value
+
+    def _del_variable(self, name):
+        """
+        Internal method called by :meth:`Variable.__delete__`
+        """
+        del self._var[name]
+
+    def _get_section(self, name):
+        """
+        Internal method called by :meth:`Section.__get__`
+        """
+        return self._section[name]
+
+    def _set_section(self, name, value):
+        """
+        Internal method called by :meth:`Section.__set__`
+        """
+        self._section[name] = value
+
+    def _del_section(self, name):
+        """
+        Internal method called by :meth:`Section.__delete__`
+        """
+        del self._section[name]
+
+
+class ValidationError(ValueError):
+    """
+    Exception raised when configuration variables fail to validate
+    """
+
+    def __init__(self, variable, new_value, message):
+        self.variable = variable
+        self.new_value = new_value
+        self.message = message
+
+    def __str__(self):
+        return self.message
+
+
+class IValidator(metaclass=ABCMeta):
+    """
+    An interface for variable vale validators
+    """
+
+    @abstractmethod
+    def __call__(self, variable, new_value):
+        """
+        Check if a value is appropriate for the variable.
+
+        :returns: None if everything is okay
+        :returns: string that describes the problem if the value cannot be used
+        """
+
+
+def KindValidator(variable, new_value):
+    """
+    A validator ensuring that values match the "kind" of the variable.
+    """
+    if not isinstance(new_value, variable.kind):
+        return "expected a {}".format(variable.kind.__name__)
+
+
+class PatternValidator(IValidator):
+    """
+    A validator ensuring that values match a given pattern
+    """
+
+    def __init__(self, pattern_text):
+        self.pattern_text = pattern_text
+        self.pattern = re.compile(pattern_text)
+
+    def __call__(self, variable, new_value):
+        if not self.pattern.match(new_value):
+            return "does not match pattern: {!r}".format(self.pattern_text)

=== added file 'plainbox/plainbox/impl/job.py.OTHER'
--- plainbox/plainbox/impl/job.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/job.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,259 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012, 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.job` -- job definition
+==========================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+import logging
+import os
+import re
+
+from plainbox.abc import IJobDefinition
+from plainbox.impl.config import Unset
+from plainbox.impl.resource import ResourceProgram
+from plainbox.impl.secure.checkbox_trusted_launcher import BaseJob
+
+
+logger = logging.getLogger("plainbox.job")
+
+
+class JobDefinition(BaseJob, IJobDefinition):
+    """
+    Job definition class.
+
+    Thin wrapper around the RFC822 record that defines a checkbox job
+    definition
+    """
+
+    @property
+    def name(self):
+        return self.__getattr__('name')
+
+    @property
+    def requires(self):
+        try:
+            return self.__getattr__('requires')
+        except AttributeError:
+            return None
+
+    @property
+    def description(self):
+        try:
+            return self.__getattr__('description')
+        except AttributeError:
+            return None
+
+    @property
+    def depends(self):
+        try:
+            return self.__getattr__('depends')
+        except AttributeError:
+            return None
+
+    @property
+    def via(self):
+        """
+        The checksum of the "parent" job when the current JobDefinition comes
+        from a job output using the local plugin
+        """
+        return self._via
+
+    @property
+    def origin(self):
+        """
+        The Origin object associated with this JobDefinition
+
+        May be None
+        """
+        return self._origin
+
+    def __init__(self, data, origin=None, checkbox=None, via=None):
+        super(JobDefinition, self).__init__(data)
+        self._resource_program = None
+        self._origin = origin
+        self._checkbox = checkbox
+        self._via = via
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return "<JobDefinition name:{!r} plugin:{!r}>".format(
+            self.name, self.plugin)
+
+    def __getattr__(self, attr):
+        if attr in self._data:
+            return self._data[attr]
+        gettext_attr = "_{}".format(attr)
+        if gettext_attr in self._data:
+            value = self._data[gettext_attr]
+            # TODO: feed through gettext
+            return value
+        raise AttributeError(attr)
+
+    def _get_persistance_subset(self):
+        state = {}
+        state['data'] = {}
+        for key, value in self._data.items():
+            state['data'][key] = value
+        if self.via is not None:
+            state['via'] = self.via
+        return state
+
+    def __eq__(self, other):
+        if not isinstance(other, JobDefinition):
+            return False
+        return self.get_checksum() == other.get_checksum()
+
+    def __ne__(self, other):
+        if not isinstance(other, JobDefinition):
+            return True
+        return self.get_checksum() != other.get_checksum()
+
+    def get_resource_program(self):
+        """
+        Return a ResourceProgram based on the 'requires' expression.
+
+        The program instance is cached in the JobDefinition and is not
+        compiled or validated on subsequent calls.
+
+        Returns ResourceProgram or None
+        Raises ResourceProgramError or SyntaxError
+        """
+        if self.requires is not None and self._resource_program is None:
+            self._resource_program = ResourceProgram(self.requires)
+        return self._resource_program
+
+    def get_direct_dependencies(self):
+        """
+        Compute and return a set of direct dependencies
+
+        To combat a simple mistake where the jobs are space-delimited any
+        mixture of white-space (including newlines) and commas are allowed.
+        """
+        if self.depends:
+            return {name for name in re.split('[\s,]+', self.depends)}
+        else:
+            return set()
+
+    def get_resource_dependencies(self):
+        """
+        Compute and return a set of resource dependencies
+        """
+        program = self.get_resource_program()
+        if program:
+            return program.required_resources
+        else:
+            return set()
+
+    @classmethod
+    def from_rfc822_record(cls, record):
+        """
+        Create a JobDefinition instance from rfc822 record
+
+        The record must be a RFC822Record instance.
+
+        Only the 'name' and 'plugin' keys are required.
+        All other data is stored as is and is entirely optional.
+        """
+        for key in ['plugin', 'name']:
+            if key not in record.data:
+                raise ValueError(
+                    "Required record key {!r} was not found".format(key))
+        return cls(record.data, record.origin)
+
+    def modify_execution_environment(self, env, session_dir, config=None):
+        """
+        Alter execution environment as required to execute this job.
+
+        The environment is modified in place.
+
+        The session_dir argument can be passed to scripts to know where to
+        create temporary data. This data will persist during the lifetime of
+        the session.
+
+        The config argument (which defaults to None) should be a PlainBoxConfig
+        object. It is used to provide values for missing environment variables
+        that are required by the job (as expressed by the environ key in the
+        job definition file).
+
+        Computes and modifies the dictionary of additional values that need to
+        be added to the base environment. Note that all changes to the
+        environment (modifications, not replacements) depend on the current
+        environment.  This may be of importance when attempting to setup the
+        test session as another user.
+
+        This environment has additional PATH, PYTHONPATH entries. It also uses
+        fixed LANG so that scripts behave as expected. Lastly it sets
+        CHECKBOX_SHARE that is required by some scripts.
+        """
+        # XXX: this obviously requires a checkbox object to know where stuff is
+        # but during the transition we may not have one available.
+        assert self._checkbox is not None
+        # Use PATH that can lookup checkbox scripts
+        if self._checkbox.extra_PYTHONPATH:
+            env['PYTHONPATH'] = os.pathsep.join(
+                [self._checkbox.extra_PYTHONPATH]
+                + env.get("PYTHONPATH", "").split(os.pathsep))
+        # Update PATH so that scripts can be found
+        env['PATH'] = os.pathsep.join(
+            [self._checkbox.extra_PATH]
+            + env.get("PATH", "").split(os.pathsep))
+        # Add CHECKBOX_SHARE that is needed by one script
+        env['CHECKBOX_SHARE'] = self._checkbox.CHECKBOX_SHARE
+        # Add CHECKBOX_DATA (temporary checkbox data)
+        env['CHECKBOX_DATA'] = session_dir
+        # Inject additional variables that are requested in the config
+        if config is not None and config.environment is not Unset:
+            for env_var in config.environment:
+                # Don't override anything that is already present in the
+                # current environment. This will allow users to customize
+                # variables without editing any config files.
+                if env_var in env:
+                    continue
+                # If the environment section of the configuration file has a
+                # particular variable then copy it over.
+                env[env_var] = config.environment[env_var]
+
+    def create_child_job_from_record(self, record):
+        """
+        Create a new JobDefinition from RFC822 record.
+
+        This method should only be used to create additional jobs from local
+        jobs (plugin local). The intent is two-fold:
+            1) to encapsulate the sharing of the embedded checkbox reference.
+            2) to set the ``via`` attribute (to aid the trusted launcher)
+        """
+        job = self.from_rfc822_record(record)
+        job._checkbox = self._checkbox
+        job._via = self.get_checksum()
+        return job
+
+    @classmethod
+    def from_json_record(cls, record):
+        """
+        Create a JobDefinition instance from JSON record
+        """
+        return cls(record['data'], via=record.get('via'))

=== added file 'plainbox/plainbox/impl/runner.py.OTHER'
--- plainbox/plainbox/impl/runner.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/runner.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,421 @@
+# This file is part of Checkbox.
+#
+# Copyright 2012 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.runner` -- job runner
+=========================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+import collections
+import datetime
+import json
+import logging
+import os
+import string
+
+from plainbox.vendor import extcmd
+
+from plainbox.abc import IJobRunner
+from plainbox.impl.result import JobResult, IOLogRecord, IoLogEncoder
+
+logger = logging.getLogger("plainbox.runner")
+
+
+def slugify(_string):
+    """
+    Slugify - like Django does for URL - transform a random string to a valid
+    slug that can be later used in filenames
+    """
+    valid_chars = frozenset(
+        "-_.{}{}".format(string.ascii_letters, string.digits))
+    return ''.join(c if c in valid_chars else '_' for c in _string)
+
+
+def io_log_write(log, stream):
+    """
+    JSON call to serialize io_log objects to disk
+    """
+    json.dump(
+        log, stream, ensure_ascii=False, indent=None, cls=IoLogEncoder,
+        separators=(',', ':'))
+
+
+def authenticate_warmup():
+    """
+    Call the checkbox trusted launcher in warmup mode.
+
+    This will use the corresponding PolicyKit action and start the
+    authentication agent (depending on the installed policy file)
+    """
+    warmup_popen = extcmd.ExternalCommand()
+    return warmup_popen.call(
+        ['pkexec', 'checkbox-trusted-launcher', '--warmup'])
+
+
+class CommandIOLogBuilder(extcmd.DelegateBase):
+    """
+    Delegate for extcmd that builds io_log entries.
+
+    IO log entries are records kept by JobResult.io_log and correspond to all
+    of the data that was written by called process. The format is a sequence of
+    tuples (delay, stream_name, data).
+    """
+
+    def on_begin(self, args, kwargs):
+        """
+        Internal method of extcmd.DelegateBase
+
+        Called when a command is being invoked.
+        Begins tracking time (relative time entries) and creates the empty
+        io_log list.
+        """
+        logger.debug("io log starting for command: %r", args)
+        self.io_log = []
+        self.last_msg = datetime.datetime.utcnow()
+
+    def on_line(self, stream_name, line):
+        """
+        Internal method of IOLogBuilder
+
+        Appends each line to the io_log. Maintains a timestamp of the last
+        message so that approximate delay between each piece of output can be
+        recorded as well.
+        """
+        now = datetime.datetime.utcnow()
+        delay = now - self.last_msg
+        self.last_msg = now
+        record = IOLogRecord(delay.total_seconds(), stream_name, line)
+        self.io_log.append(record)
+        logger.debug("io log captured %r", record)
+
+
+class CommandOutputWriter(extcmd.DelegateBase):
+    """
+    Delegate for extcmd that writes output to a file on disk.
+
+    The file itself is only opened once on_begin() gets called by extcmd. This
+    makes it safe to instantiate this without worrying about dangling
+    resources.
+    """
+
+    def __init__(self, stdout_path, stderr_path):
+        """
+        Initialize new writer.
+
+        Just records output paths.
+        """
+        self.stdout_path = stdout_path
+        self.stderr_path = stderr_path
+
+    def on_begin(self, args, kwargs):
+        """
+        Internal method of extcmd.DelegateBase
+
+        Called when a command is being invoked
+        """
+        self.stdout = open(self.stdout_path, "wb")
+        self.stderr = open(self.stderr_path, "wb")
+
+    def on_end(self, returncode):
+        """
+        Internal method of extcmd.DelegateBase
+
+        Called when a command finishes running
+        """
+        self.stdout.close()
+        self.stderr.close()
+
+    def on_line(self, stream_name, line):
+        """
+        Internal method of extcmd.DelegateBase
+
+        Called for each line of output.
+        """
+        if stream_name == 'stdout':
+            self.stdout.write(line)
+        elif stream_name == 'stderr':
+            self.stderr.write(line)
+
+
+class FallbackCommandOutputPrinter(extcmd.DelegateBase):
+    """
+    Delegate for extcmd that prints all output to stdout.
+
+    This delegate is only used as a fallback when no delegate was explicitly
+    provided to a JobRunner instance.
+    """
+
+    def __init__(self, prompt):
+        self._prompt = prompt
+        self._lineno = collections.defaultdict(int)
+        self._abort = False
+
+    def on_line(self, stream_name, line):
+        if self._abort:
+            return
+        self._lineno[stream_name] += 1
+        try:
+            print("(job {}, <{}:{:05}>) {}".format(
+                self._prompt, stream_name, self._lineno[stream_name],
+                line.decode('UTF-8').rstrip()))
+        except UnicodeDecodeError:
+            self._abort = True
+
+
+class JobRunner(IJobRunner):
+    """
+    Runner for jobs - executes jobs and produces results
+
+    The runner is somewhat de-coupled from jobs and session. It still carries
+    all checkbox-specific logic about the various types of plugins.
+
+    The runner consumes jobs and configuration objects and produces job result
+    objects. The runner can operate in dry-run mode, when enabled, most jobs
+    are never started. Only jobs listed in DRY_RUN_PLUGINS are executed.
+    """
+
+    # List of plugins that are still executed
+    _DRY_RUN_PLUGINS = ('local', 'resource', 'attachment')
+
+    def __init__(self, session_dir, jobs_io_log_dir,
+                 command_io_delegate=None, outcome_callback=None,
+                 dry_run=False):
+        """
+        Initialize a new job runner.
+
+        Uses the specified session_dir as CHECKBOX_DATA environment variable.
+        Uses the specified IO delegate for extcmd.ExternalCommandWithDelegate
+        to track IO done by the called commands (optional, a simple console
+        printer is provided if missing).
+        """
+        self._session_dir = session_dir
+        self._jobs_io_log_dir = jobs_io_log_dir
+        self._command_io_delegate = command_io_delegate
+        self._outcome_callback = outcome_callback
+        self._dry_run = dry_run
+
+    def run_job(self, job, config=None):
+        """
+        Run the specified job an return the result
+        """
+        logger.info("Running %r", job)
+        func_name = "_plugin_" + job.plugin.replace('-', '_')
+        try:
+            runner = getattr(self, func_name)
+        except AttributeError:
+            return JobResult({
+                'job': job,
+                'outcome': JobResult.OUTCOME_NOT_IMPLEMENTED,
+                'comment': 'This plugin is not supported'
+            })
+        else:
+            if self._dry_run and job.plugin not in self._DRY_RUN_PLUGINS:
+                return self._dry_run_result(job)
+            else:
+                return runner(job, config)
+
+    def _dry_run_result(self, job):
+        """
+        Produce the result that is used when running in dry-run mode
+        """
+        return JobResult({
+            'job': job,
+            'outcome': JobResult.OUTCOME_SKIP,
+            'comments': "Job skipped in dry-run mode"
+        })
+
+    def _plugin_shell(self, job, config):
+        return self._just_run_command(job, config)
+
+    _plugin_attachment = _plugin_shell
+
+    def _plugin_resource(self, job, config):
+        return self._just_run_command(job, config)
+
+    def _plugin_local(self, job, config):
+        return self._just_run_command(job, config)
+
+    def _plugin_manual(self, job, config):
+        if self._outcome_callback is None:
+            return JobResult({
+                'job': job,
+                'outcome': JobResult.OUTCOME_SKIP,
+                'comment': "non-interactive test run"
+            })
+        else:
+            result = self._just_run_command(job, config)
+            # XXX: make outcome writable
+            result._data['outcome'] = self._outcome_callback()
+            return result
+
+    _plugin_user_interact = _plugin_manual
+    _plugin_user_verify = _plugin_manual
+
+    def _just_run_command(self, job, config):
+        # Run the embedded command
+        return_code, io_log = self._run_command(job, config)
+        # Convert the return of the command to the outcome of the job
+        if return_code == 0:
+            outcome = JobResult.OUTCOME_PASS
+        else:
+            outcome = JobResult.OUTCOME_FAIL
+        # Create a result object and return it
+        return JobResult({
+            'job': job,
+            'outcome': outcome,
+            'return_code': return_code,
+            'io_log': io_log
+        })
+
+    def _get_script_env(self, job, config=None, only_changes=False):
+        """
+        Compute the environment the script will be executed in
+        """
+        # Get a proper environment
+        env = dict(os.environ)
+        # Use non-internationalized environment
+        env['LANG'] = 'C.UTF-8'
+        # Allow the job to customize anything
+        job.modify_execution_environment(env, self._session_dir, config)
+        # If a differential environment is requested return only the subset
+        # that has been altered.
+        #
+        # XXX: This will effectively give the root user our PATH which _may_ be
+        # good bud _might_ be dangerous. This will need some peer review.
+        if only_changes:
+            return {key: value
+                    for key, value in env.items()
+                    if key not in os.environ or os.environ[key] != value
+                    or key in job.get_environ_settings()}
+        else:
+            return env
+
+    def _get_command_trusted(self, job, config=None):
+        # When the job requires to run as root then elevate our permissions
+        # via pkexec(1). Since pkexec resets environment we need to somehow
+        # pass the extra things we require. To do that we pass the list of
+        # changed environment variables in addition to the job hash.
+        cmd = ['checkbox-trusted-launcher', '--hash', job.get_checksum()] + [
+            "{key}={value}".format(key=key, value=value)
+            for key, value in self._get_script_env(
+                job, config, only_changes=True
+            ).items()
+        ]
+        if job.via is not None:
+            cmd += ['--via', job.via]
+        return cmd
+
+    def _get_command_src(self, job, config=None):
+        # Running PlainBox from source doesn't require the trusted launcher
+        # That's why we use the env(1)' command and pass it the list of
+        # changed environment variables.
+        # The whole pkexec and env part gets prepended to the command
+        # we were supposed to run.
+        cmd = ['env']
+        cmd += [
+            "{key}={value}".format(key=key, value=value)
+            for key, value in self._get_script_env(
+                job, only_changes=True
+            ).items()
+        ]
+        cmd += ['bash', '-c', job.command]
+        return cmd
+
+    def _run_command(self, job, config):
+        """
+        Run the shell command associated with the specified job.
+
+        Returns a tuple (return_code, io_log)
+        """
+        # Bail early if there is nothing do do
+        if job.command is None:
+            return None, ()
+        ui_io_delegate = self._command_io_delegate
+        # If there is no UI delegate specified create a simple
+        # delegate that logs all output to the console
+        if ui_io_delegate is None:
+            ui_io_delegate = FallbackCommandOutputPrinter(job.name)
+        # Create a delegate that writes all IO to disk
+        slug = slugify(job.name)
+        output_writer = CommandOutputWriter(
+            stdout_path=os.path.join(self._jobs_io_log_dir,
+                                     "{}.stdout".format(slug)),
+            stderr_path=os.path.join(self._jobs_io_log_dir,
+                                     "{}.stderr".format(slug)))
+        # Create a delegate that builds a log of all IO
+        io_log_builder = CommandIOLogBuilder()
+        # Create the delegate for routing IO
+        #
+        #
+        # Split the stream of data into three parts (each part is expressed as
+        # an element of extcmd.Chain()).
+        #
+        # Send the first copy of the data through bytes->text decoder and
+        # then to the UI delegate. This cold be something provided by the
+        # higher level caller or the default CommandOutputLogger.
+        #
+        # Send the second copy of the data to the _IOLogBuilder() instance that
+        # just concatenates subsequent bytes into neat time-stamped records.
+        #
+        # Send the third copy to the output writer that writes everything to
+        # disk.
+        delegate = extcmd.Chain([
+            ui_io_delegate,
+            io_log_builder,
+            output_writer])
+        logger.debug("job[%s] extcmd delegate: %r", job.name, delegate)
+        # Create a subprocess.Popen() like object that uses the delegate
+        # system to observe all IO as it occurs in real time.
+        logging_popen = extcmd.ExternalCommandWithDelegate(delegate)
+        # Start the process and wait for it to finish getting the
+        # result code. This will actually call a number of callbacks
+        # while the process is running. It will also spawn a few
+        # threads although all callbacks will be fired from a single
+        # thread (which is _not_ the main thread)
+        logger.debug("job[%s] starting command: %s", job.name, job.command)
+        if job.user is not None:
+            if job._checkbox._mode == 'src':
+                cmd = self._get_command_src(job, config)
+            else:
+                cmd = self._get_command_trusted(job, config)
+            cmd = ['pkexec', '--user', job.user] + cmd
+            logging.debug("job[%s] executing %r", job.name, cmd)
+            return_code = logging_popen.call(cmd)
+        else:
+            # XXX: sadly using /bin/sh results in broken output
+            # XXX: maybe run it both ways and raise exceptions on differences?
+            cmd = ['bash', '-c', job.command]
+            logging.debug("job[%s] executing %r", job.name, cmd)
+            return_code = logging_popen.call(
+                cmd, env=self._get_script_env(job, config))
+        logger.debug("job[%s] command return code: %r",
+                     job.name, return_code)
+        # XXX: Perhaps handle process dying from signals here
+        # When the process is killed proc.returncode is not set
+        # and another (cannot remember now) attribute is set
+        fjson = os.path.join(self._jobs_io_log_dir, "{}.json".format(slug))
+        with open(fjson, "wt") as stream:
+            io_log_write(io_log_builder.io_log, stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        return return_code, fjson

=== added directory 'plainbox/plainbox/impl/secure'
=== added file 'plainbox/plainbox/impl/secure/checkbox_trusted_launcher.py.OTHER'
--- plainbox/plainbox/impl/secure/checkbox_trusted_launcher.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/secure/checkbox_trusted_launcher.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,395 @@
+# 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.secure.checkbox_trusted_launcher` -- command launcher
+=========================================================================
+
+.. warning::
+
+    THIS MODULE DOES NOT HAVE STABLE PUBLIC API
+"""
+
+import argparse
+import collections
+import glob
+import hashlib
+import json
+import os
+import re
+import subprocess
+from inspect import cleandoc
+
+
+class BaseJob:
+    """
+    Base Job definition class.
+    """
+
+    @property
+    def plugin(self):
+        return self.__getattr__('plugin')
+
+    @property
+    def command(self):
+        try:
+            return self.__getattr__('command')
+        except AttributeError:
+            return None
+
+    @property
+    def environ(self):
+        try:
+            return self.__getattr__('environ')
+        except AttributeError:
+            return None
+
+    @property
+    def user(self):
+        try:
+            return self.__getattr__('user')
+        except AttributeError:
+            return None
+
+    def __init__(self, data):
+        self._data = data
+
+    def __getattr__(self, attr):
+        if attr in self._data:
+            return self._data[attr]
+        raise AttributeError(attr)
+
+    def get_checksum(self):
+        """
+        Compute a checksum of the job definition.
+
+        This method can be used to compute the checksum of the canonical form
+        of the job definition.  The canonical form is the UTF-8 encoded JSON
+        serialization of the data that makes up the full definition of the job
+        (all keys and values). The JSON serialization uses no indent and
+        minimal separators.
+
+        The checksum is defined as the SHA256 hash of the canonical form.
+        """
+        # Ideally we'd use simplejson.dumps() with sorted keys to get
+        # predictable serialization but that's another dependency. To get
+        # something simple that is equally reliable, just sort all the keys
+        # manually and ask standard json to serialize that..
+        sorted_data = collections.OrderedDict(sorted(self._data.items()))
+        # Compute the canonical form which is arbitrarily defined as sorted
+        # json text with default indent and separator settings.
+        canonical_form = json.dumps(
+            sorted_data, indent=None, separators=(',', ':'))
+        # Compute the sha256 hash of the UTF-8 encoding of the canonical form
+        # and return the hex digest as the checksum that can be displayed.
+        return hashlib.sha256(canonical_form.encode('UTF-8')).hexdigest()
+
+    def get_environ_settings(self):
+        """
+        Return a set of requested environment variables
+        """
+        if self.environ is not None:
+            return {variable for variable in re.split('[\s,]+', self.environ)}
+        else:
+            return set()
+
+    def modify_execution_environment(self, environ, packages):
+        """
+        Compute the environment the script will be executed in
+        """
+        # Get a proper environment
+        env = dict(os.environ)
+        # Use non-internationalized environment
+        env['LANG'] = 'C.UTF-8'
+        # Create CHECKBOX*_SHARE for every checkbox related packages
+        # Add their respective script directory to the PATH variable
+        # giving precedence to those located in /usr/lib/
+        for path in packages:
+            basename = os.path.basename(path)
+            env[basename.upper().replace('-', '_') + '_SHARE'] = path
+            # Update PATH so that scripts can be found
+            env['PATH'] = os.pathsep.join([
+                os.path.join('usr', 'lib', basename, 'bin'),
+                os.path.join(path, 'scripts')]
+                + env.get("PATH", "").split(os.pathsep))
+        if 'CHECKBOX_DATA' in env:
+            env['CHECKBOX_DATA'] = environ['CHECKBOX_DATA']
+        # Add new environment variables only if they are defined in the
+        # job environ property
+        for key in self.get_environ_settings():
+            if key in environ:
+                env[key] = environ[key]
+        return env
+
+
+class BaseRFC822Record:
+    """
+    Base class for tracking RFC822 records
+
+    This is a simple container for the dictionary of data.
+    """
+
+    def __init__(self, data):
+        self._data = data
+
+    @property
+    def data(self):
+        """
+        The data set (dictionary)
+        """
+        return self._data
+
+
+class RFC822SyntaxError(SyntaxError):
+    """
+    SyntaxError subclass for RFC822 parsing functions
+    """
+
+    def __init__(self, filename, lineno, msg):
+        self.filename = filename
+        self.lineno = lineno
+        self.msg = msg
+
+
+def load_rfc822_records(stream, data_cls=dict):
+    """
+    Load a sequence of rfc822-like records from a text stream.
+
+    Each record consists of any number of key-value pairs. Subsequent records
+    are separated by one blank line. A record key may have a multi-line value
+    if the line starts with whitespace character.
+
+    Returns a list of subsequent values as instances BaseRFC822Record class. If
+    the optional data_cls argument is collections.OrderedDict then the values
+    retain their original ordering.
+    """
+    return list(gen_rfc822_records(stream, data_cls))
+
+
+def gen_rfc822_records(stream, data_cls=dict):
+    """
+    Load a sequence of rfc822-like records from a text stream.
+
+    Each record consists of any number of key-value pairs. Subsequent records
+    are separated by one blank line. A record key may have a multi-line value
+    if the line starts with whitespace character.
+
+    Returns a list of subsequent values as instances BaseRFC822Record class. If
+    the optional data_cls argument is collections.OrderedDict then the values
+    retain their original ordering.
+    """
+    record = None
+    data = None
+    key = None
+    value_list = None
+
+    def _syntax_error(msg):
+        """
+        Report a syntax error in the current line
+        """
+        try:
+            filename = stream.name
+        except AttributeError:
+            filename = None
+        return RFC822SyntaxError(filename, lineno, msg)
+
+    def _new_record():
+        """
+        Reset local state to track new record
+        """
+        nonlocal key
+        nonlocal value_list
+        nonlocal record
+        nonlocal data
+        key = None
+        value_list = None
+        data = data_cls()
+        record = BaseRFC822Record(data)
+
+    def _commit_key_value_if_needed():
+        """
+        Finalize the most recently seen key: value pair
+        """
+        nonlocal key
+        if key is not None:
+            data[key] = cleandoc('\n'.join(value_list))
+            key = None
+
+    # Start with an empty record
+    _new_record()
+    # Iterate over subsequent lines of the stream
+    for lineno, line in enumerate(stream, start=1):
+        # Treat empty lines as record separators
+        if line.strip() == "":
+            # Commit the current record so that the multi-line value of the
+            # last key, if any, is saved as a string
+            _commit_key_value_if_needed()
+            # If data is non-empty, yield the record, this allows us to safely
+            # use newlines for formatting
+            if data:
+                yield record
+            # Reset local state so that we can build a new record
+            _new_record()
+        # Treat lines staring with whitespace as multi-line continuation of the
+        # most recently seen key-value
+        elif line.startswith(" "):
+            if key is None:
+                # If we have not seen any keys yet then this is a syntax error
+                raise _syntax_error("Unexpected multi-line value")
+            # Append the current line to the list of values of the most recent
+            # key. This prevents quadratic complexity of string concatenation
+            if line == " .\n":
+                value_list.append(" ")
+            elif line == " ..\n":
+                value_list.append(" .")
+            else:
+                value_list.append(line.rstrip())
+        # Treat lines with a colon as new key-value pairs
+        elif ":" in line:
+            # Since we have a new, key-value pair we need to commit any
+            # previous key that we may have (regardless of multi-line or
+            # single-line values).
+            _commit_key_value_if_needed()
+            # Parse the line by splitting on the colon, get rid of additional
+            # whitespace from both key and the value
+            key, value = line.split(":", 1)
+            key = key.strip()
+            value = value.strip()
+            # Check if the key already exist in this message
+            if key in record.data:
+                raise _syntax_error((
+                    "Job has a duplicate key {!r} "
+                    "with old value {!r} and new value {!r}").format(
+                        key, record.data[key], value))
+            # Construct initial value list out of the (only) value that we have
+            # so far. Additional multi-line values will just append to
+            # value_list
+            value_list = [value]
+        # Treat all other lines as syntax errors
+        else:
+            raise _syntax_error("Unexpected non-empty line")
+    # Make sure to commit the last key from the record
+    _commit_key_value_if_needed()
+    # Once we've seen the whole file return the last record, if any
+    if data:
+        yield record
+
+
+class Runner:
+    """
+    Runner for jobs
+
+    Executes the command process and pipes back stdout/stderr
+    """
+
+    CHECKBOXES = "/usr/share/checkbox*"
+
+    def __init__(self, builtin_jobs=[], packages=[]):
+        # List of all available jobs in system-wide locations
+        self.builtin_jobs = builtin_jobs
+        # List of all checkbox variants, like checkbox-oem(-.*)?
+        self.packages = packages
+
+    def path_expand(self, path):
+        for p in glob.glob(path):
+            self.packages.append(p)
+            for dirpath, dirs, filenames in os.walk(os.path.join(p, 'jobs')):
+                for name in filenames:
+                    if name.endswith(".txt"):
+                        yield os.path.join(dirpath, name)
+
+    def main(self, argv=None):
+        parser = argparse.ArgumentParser(prog="checkbox-trusted-launcher")
+        group = parser.add_mutually_exclusive_group(required=True)
+        group.add_argument('--hash', metavar='HASH', help='job hash to match')
+        group.add_argument(
+            '--warmup',
+            action='store_true',
+            help='Return immediately, only useful when used with pkexec(1)')
+        parser.add_argument(
+            '--via',
+            metavar='LOCAL-JOB-HASH',
+            dest='via_hash',
+            help='Local job hash to use to match the generated job')
+        parser.add_argument(
+            'ENV', metavar='NAME=VALUE', nargs='*',
+            help='Set each NAME to VALUE in the string environment')
+        args = parser.parse_args(argv)
+
+        if args.warmup:
+            return 0
+
+        for filename in self.path_expand(self.CHECKBOXES):
+            stream = open(filename, "r", encoding="utf-8")
+            for message in load_rfc822_records(stream):
+                self.builtin_jobs.append(BaseJob(message.data))
+            stream.close()
+        lookup_list = [j for j in self.builtin_jobs if j.user]
+
+        args.ENV = dict(item.split('=') for item in args.ENV)
+
+        if args.via_hash is not None:
+            local_list = [j for j in self.builtin_jobs if j.plugin == 'local']
+            desired_job_list = [j for j in local_list
+                                if j.get_checksum() == args.via_hash]
+            if desired_job_list:
+                via_job = desired_job_list.pop()
+                via_job_result = subprocess.Popen(
+                    via_job.command,
+                    shell=True,
+                    universal_newlines=True,
+                    stdout=subprocess.PIPE,
+                    env=via_job.modify_execution_environment(
+                        args.ENV,
+                        self.packages)
+                )
+                try:
+                    for message in load_rfc822_records(via_job_result.stdout):
+                        lookup_list.append(BaseJob(message.data))
+                finally:
+                    # Always call Popen.wait() in order to avoid zombies
+                    via_job_result.stdout.close()
+                    via_job_result.wait()
+
+        try:
+            target_job = [j for j in lookup_list
+                          if j.get_checksum() == args.hash][0]
+        except IndexError:
+            return "Job not found"
+        try:
+            os.execve(
+                '/bin/bash',
+                ['bash', '-c', target_job.command],
+                target_job.modify_execution_environment(
+                    args.ENV,
+                    self.packages)
+            )
+        # if execve doesn't fail, it never returns...
+        except OSError:
+            return "Fatal error"
+        finally:
+            return "Fatal error"
+
+
+def main(argv=None):
+    """
+    Entry point for the checkbox trusted launcher
+    """
+    runner = Runner()
+    raise SystemExit(runner.main(argv))

=== added file 'plainbox/plainbox/impl/secure/test_checkbox_trusted_launcher.py.OTHER'
--- plainbox/plainbox/impl/secure/test_checkbox_trusted_launcher.py.OTHER	1970-01-01 00:00:00 +0000
+++ plainbox/plainbox/impl/secure/test_checkbox_trusted_launcher.py.OTHER	2013-08-28 12:37:27 +0000
@@ -0,0 +1,280 @@
+# 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/>.
+
+"""
+plainbox.impl.secure.test_checkbox_trusted_launcher
+===================================================
+
+Test definitions for plainbox.impl.secure.checkbox_trusted_launcher module
+"""
+
+import os
+
+from inspect import cleandoc
+from io import StringIO
+from mock import Mock, patch
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+from unittest import TestCase
+
+from plainbox.impl.secure.checkbox_trusted_launcher import BaseJob
+from plainbox.impl.secure.checkbox_trusted_launcher import load_rfc822_records
+from plainbox.impl.secure.checkbox_trusted_launcher import main
+from plainbox.impl.secure.checkbox_trusted_launcher import Runner
+from plainbox.impl.test_rfc822 import RFC822ParserTestsMixIn
+from plainbox.testing_utils.io import TestIO
+from plainbox.testing_utils.testcases import TestCaseWithParameters
+
+
+class TestJobDefinition(TestCase):
+
+    def setUp(self):
+        self._full_record = {
+            'plugin': 'plugin',
+            'command': 'command',
+            'environ': 'environ',
+            'user': 'user'
+        }
+        self._min_record = {
+            'plugin': 'plugin',
+            'name': 'name',
+        }
+
+    def test_smoke_full_record(self):
+        job = BaseJob(self._full_record)
+        self.assertEqual(job.plugin, "plugin")
+        self.assertEqual(job.command, "command")
+        self.assertEqual(job.environ, "environ")
+        self.assertEqual(job.user, "user")
+
+    def test_smoke_min_record(self):
+        job = BaseJob(self._min_record)
+        self.assertEqual(job.plugin, "plugin")
+        self.assertEqual(job.command, None)
+        self.assertEqual(job.environ, None)
+        self.assertEqual(job.user, None)
+
+    def test_checksum_smoke(self):
+        job1 = BaseJob({'plugin': 'plugin', 'user': 'root'})
+        identical_to_job1 = BaseJob({'plugin': 'plugin', 'user': 'root'})
+        # Two distinct but identical jobs have the same checksum
+        self.assertEqual(job1.get_checksum(), identical_to_job1.get_checksum())
+        job2 = BaseJob({'plugin': 'plugin', 'user': 'anonymous'})
+        # Two jobs with different definitions have different checksum
+        self.assertNotEqual(job1.get_checksum(), job2.get_checksum())
+        # The checksum is stable and does not change over time
+        self.assertEqual(
+            job1.get_checksum(),
+            "c47cc3719061e4df0010d061e6f20d3d046071fd467d02d093a03068d2f33400")
+
+
+class ParsingTests(TestCaseWithParameters):
+
+    parameter_names = ('glue',)
+    parameter_values = (
+        ('commas',),
+        ('spaces',),
+        ('tabs',),
+        ('newlines',),
+        ('spaces_and_commas',),
+        ('multiple_spaces',),
+        ('multiple_commas',)
+    )
+    parameters_keymap = {
+        'commas': ',',
+        'spaces': ' ',
+        'tabs': '\t',
+        'newlines': '\n',
+        'spaces_and_commas': ', ',
+        'multiple_spaces': '   ',
+        'multiple_commas': ',,,,'
+    }
+
+    def test_environ_parsing_with_various_separators(self):
+        job = BaseJob({
+            'name': 'name',
+            'plugin': 'plugin',
+            'environ': self.parameters_keymap[
+                self.parameters.glue].join(['foo', 'bar', 'froz'])})
+        expected = set({'foo', 'bar', 'froz'})
+        observed = job.get_environ_settings()
+        self.assertEqual(expected, observed)
+
+    def test_environ_parsing_empty(self):