Merge lp:~matsubara/checkbox/maas-tests into lp:~nskaggs/checkbox/checkbox-app-testing

[Diogo Matsubara]

This branch adds some checkbox manual tests for the MAAS project as well as some juju tests to run against a MAAS cluster.

Tests are categorized like the following:
- tests to be done from the Ubuntu installer;
- tests to be done on the MAAS server web ui;
- tests to be done using juju to deploy to a MAAS cluster;

[lp:~matsubara/checkbox/maas-tests]

1355. By Diogo Matsubara on 2012-03-28

add MAAS from archive test

Unmerged revisions

1355. By Diogo Matsubara on 2012-03-28

add MAAS from archive test

1354. By Diogo Matsubara on 2012-03-28

add tests for MAAS server, juju on MAAS and node enlistment.

1353. By Nicholas Skaggs on 2012-03-28

fix missing scripts and paths

1352. By Nicholas Skaggs on 2012-03-28

add missing scripts
replace ubuntu friendly reference

1351. By Nicholas Skaggs on 2012-03-28

migrate to usr/lib from usr/share

1350. By Nicholas Skaggs on 2012-03-28

remove pycompat, add larger description

1349. By Nicholas Skaggs on 2012-03-27

remove icon installation
remove staging db location

1348. By Nicholas Skaggs on 2012-03-27

fix (another) typo

1347. By Nicholas Skaggs on 2012-03-27

fix typo

1346. By Nicholas Skaggs on 2012-03-27

fix ini file, and installed files to not conflict with checkbox install

=== added directory '.bzr-builddeb'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2012-03-28 20:34:20 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+native = True

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2012-03-28 20:34:20 +0000
@@ -0,0 +1,38 @@
+build
+checkbox.log
+checkbox.xsl
+debian/checkbox
+debian/checkbox-cli
+debian/checkbox-gtk
+debian/checkbox-qt
+debian/checkbox-urwid
+debian/*-cli.postrm
+debian/*.debhelper
+debian/files
+debian/*-gtk.postrm
+debian/*-qt.postrm
+debian/*.log
+debian/stamp-patched
+debian/*.substvars
+debian/tmp
+debian/*-urwid.postrm
+gtk/checkbox-gtk.glade.bak
+gtk/checkbox-gtk.gladep
+gtk/checkbox-gtk.gladep.bak
+qt/frontend/Makefile
+qt/frontend/checkbox-qt-service
+qt/frontend/moc_qtfront.cpp
+qt/frontend/ui_qtfront.h
+qt/frontend/qrc_resources.cpp
+lock
+plugins.bpickle
+plugins.bpickle.old
+python-build-stamp-2.5
+scripts/clocktest
+scripts/threaded_memtest
+store
+submission
+submission.xml
+submission.xml
+subunit.log
+system

=== renamed file '.bzrignore' => '.bzrignore.moved'
=== added file '.checkbox-editor.cfg'
--- .checkbox-editor.cfg	1970-01-01 00:00:00 +0000
+++ .checkbox-editor.cfg	2012-03-28 20:34:20 +0000
@@ -0,0 +1,18 @@
+[environment]
+checkbox_share = .
+
+[version control]
+push_branch = lp:checkbox
+pull_branch = lp:checkbox
+push_on_close = False
+commit_on_save = False
+pull_on_open = False
+exclude = .checkbox-editor.cfg
+
+[general]
+checkbox_data_cleanup = True
+replace_tabs_with_spaces = True
+number_of_spaces = 4
+checkbox_binary = ./bin/checkbox-gtk
+whitelist_resources = True
+

=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2012-03-28 20:34:20 +0000
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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.
+
+    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

=== renamed file 'COPYING' => 'COPYING.moved'
=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2012-03-28 20:34:20 +0000
@@ -0,0 +1,5 @@
+This is Checkbox which provides an extensible interface for system testing.
+
+See the following page for documentation:
+
+https://wiki.ubuntu.com/Testing/Automation/Checkbox

=== added directory 'apport'
=== added file 'apport/checkbox.py'
--- apport/checkbox.py	1970-01-01 00:00:00 +0000
+++ apport/checkbox.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,24 @@
+'''apport general hook for checkbox
+
+(c) 2009 Canonical Ltd.
+Author: David Murphy <[e-mail]>
+'''
+import os
+
+
+def add_info(report):
+    HOME = os.environ.get('HOME', '/')
+    CACHE_HOME = os.environ.get('XDG_CACHE_HOME',
+        os.path.join(HOME, '.cache'))
+    SYSTEM = os.path.join(CACHE_HOME, 'checkbox', 'system')
+    SUBMISSION = os.path.join(CACHE_HOME, 'checkbox', 'submission')
+
+    try:
+        report['CheckboxSystem'] = open(SYSTEM).read()
+    except IOError:
+        pass
+
+    try:
+        report['CheckboxSubmission'] = open(SUBMISSION).read()
+    except IOError:
+        pass

=== added file 'apport/source_checkbox.py'
--- apport/source_checkbox.py	1970-01-01 00:00:00 +0000
+++ apport/source_checkbox.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,20 @@
+'''apport package hook for checkbox
+
+(c) 2009 Canonical Ltd.
+Author: David Murphy <[e-mail]>
+'''
+import os
+
+from apport.hookutils import attach_file_if_exists
+
+
+def add_info(report):
+    HOME = os.environ.get('HOME', '/')
+    CACHE_HOME = os.environ.get('XDG_CACHE_HOME',
+        os.path.join(HOME, '.cache'))
+
+    SUBMISSION = os.path.join(CACHE_HOME, 'checkbox', 'submission.xml')
+    attach_file_if_exists(report, SUBMISSION)
+    
+    CHECKBOX_LOG = os.path.join(CACHE_HOME, 'checkbox', 'checkbox.log')
+    attach_file_if_exists(report, CHECKBOX_LOG)

=== added file 'backend'
--- backend	1970-01-01 00:00:00 +0000
+++ backend	2012-03-28 20:34:20 +0000
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+
+import os
+import sys
+
+from optparse import OptionParser
+from checkbox.lib.fifo import FifoReader, FifoWriter
+
+from checkbox.job import Job, FAIL
+
+
+def main(args):
+    usage = "Usage: %prog INPUT OUTPUT"
+    parser = OptionParser(usage=usage)
+    parser.add_option("-p", "--path",
+        help="PATH variable to replace in the environment")
+    (options, args) = parser.parse_args(args)
+
+    if len(args) < 2:
+        parser.error("Missing INPUT and OUTPUT")
+
+    if options.path:
+        os.environ["PATH"] = options.path
+
+    reader = FifoReader(args[0])
+    writer = FifoWriter(args[1])
+
+    while True:
+        try:
+            message = reader.read_object()
+            if message == "stop":
+                break
+            if message == "ping":
+                writer.write_object("pong")
+                continue
+            if isinstance(message, dict) and "command" in message:
+                job = Job(message["command"], message.get("environ"),
+                    message.get("timeout"))
+                result = job.execute()
+            else:
+                result = (FAIL, "", 0,)
+
+            writer.write_object(result)
+        except IOError, e:
+            break
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

=== added directory 'bin'
=== renamed directory 'bin' => 'bin.moved'
=== added file 'bin/checkbox-app-testing'
--- bin/checkbox-app-testing	1970-01-01 00:00:00 +0000
+++ bin/checkbox-app-testing	2012-03-28 20:34:20 +0000
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -e
+
+export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
+
+#export CHECKBOX_APP_TESTING_LIB=${CHECKBOX_APP_TESTING_LIB:-.}
+export CHECKBOX_APP_TESTING_LIB=${CHECKBOX_APP_TESTING_LIB:-/usr/lib/checkbox-app-testing}
+
+#export CHECKBOX_APP_TESTING_DATA=${CHECKBOX_APP_TESTING_DATA:-.}
+export CHECKBOX_APP_TESTING_DATA=${CHECKBOX_APP_TESTING_DATA:-$HOME/.checkbox-app-testing}
+
+#export CHECKBOX_APP_TESTING_SHARE=${CHECKBOX_APP_TESTING_SHARE:-.}
+export CHECKBOX_APP_TESTING_SHARE=${CHECKBOX_APP_TESTING_SHARE:-/usr/share/checkbox-app-testing}
+
+export CHECKBOX_SHARE=${CHECKBOX_SHARE:-$CHECKBOX_APP_TESTING_SHARE}
+export CHECKBOX_LIB=${CHECKBOX_LIB:-$CHECKBOX_APP_TESTING_LIB}
+export CHECKBOX_DATA=${CHECKBOX_DATA:-$CHECKBOX_APP_TESTING_DATA}
+export CHECKBOX_FRONTEND=${CHECKBOX_FRONTEND:-$CHECKBOX_APP_TESTING_LIB/qt/frontend}
+
+export PYTHONPATH=$PYTHONPATH:$CHECKBOX_APP_TESTING_LIB
+
+#debug
+export CHECKBOX_OPTIONS=${CHECKBOX_OPTIONS:---log-level=debug --log=$CHECKBOX_DATA/checkbox-app-testing.log}
+
+#staging lp
+#export APPORT_LAUNCHPAD_INSTANCE=staging
+
+
+if [ -e $CHECKBOX_FRONTEND ]
+then
+    (cd $CHECKBOX_FRONTEND; qmake; make; ./checkbox-qt-service &)
+fi
+
+python $CHECKBOX_APP_TESTING_LIB/run "$@" $CHECKBOX_APP_TESTING_SHARE/configs/$(basename $0).ini

=== added directory 'checkbox'
=== added file 'checkbox/__init__.py'
=== added file 'checkbox/application.py'
--- checkbox/application.py	1970-01-01 00:00:00 +0000
+++ checkbox/application.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,136 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import sys
+import logging
+import posixpath
+
+from gettext import gettext as _
+
+from optparse import OptionParser
+
+from checkbox.lib.config import Config
+from checkbox.lib.environ import get_variable
+from checkbox.lib.log import set_logging
+from checkbox.lib.safe import safe_make_directory
+from checkbox.lib.text import split
+
+from checkbox.plugin import PluginManager
+from checkbox.reactor import Reactor
+
+
+class Application(object):
+
+    reactor_factory = Reactor
+
+    def __init__(self, config):
+        self._config = config
+        self.reactor = self.reactor_factory()
+
+        # Plugin manager setup
+        self.plugin_manager = PluginManager(self._config,
+            self.reactor)
+
+    def run(self):
+        try:
+            self.reactor.run()
+        except:
+            logging.exception("Error running reactor.")
+            raise
+
+
+class ApplicationManager(object):
+
+    application_factory = Application
+
+    default_log = os.path.join(get_variable("CHECKBOX_DATA", "."), "checkbox.log")
+    default_log_level = "info"
+
+    def parse_options(self, args):
+        usage = _("Usage: checkbox [OPTIONS]")
+        parser = OptionParser(usage=usage)
+        parser.add_option("--version",
+                          action="store_true",
+                          help=_("Print version information and exit."))
+        parser.add_option("-l", "--log",
+                          metavar="FILE",
+                          default=self.default_log,
+                          help=_("The file to write the log to."))
+        parser.add_option("--log-level",
+                          default=self.default_log_level,
+                          help=_("One of debug, info, warning, error or critical."))
+        parser.add_option("-c", "--config",
+                          action="append",
+                          type="string",
+                          default=[],
+                          help=_("Configuration override parameters."))
+        parser.add_option("-b", "--blacklist",
+                          help=_("Shorthand for --config=.*/jobs_info/blacklist."))
+        parser.add_option("-B", "--blacklist-file",
+                          help=_("Shorthand for --config=.*/jobs_info/blacklist_file."))
+        parser.add_option("-w", "--whitelist",
+                          help=_("Shorthand for --config=.*/jobs_info/whitelist."))
+        parser.add_option("-W", "--whitelist-file",
+                          help=_("Shorthand for --config=.*/jobs_info/whitelist_file."))
+        return parser.parse_args(args)
+
+    def create_application(self, args=sys.argv):
+        # Create data directory
+        data_directory = get_variable("CHECKBOX_DATA", ".")
+        safe_make_directory(data_directory)
+
+        # Prepend environment options
+        string_options = get_variable("CHECKBOX_OPTIONS", "")
+        args[:0] = split(string_options)
+        (options, args) = self.parse_options(args)
+
+        # Replace shorthands
+        for shorthand in "blacklist", "blacklist_file", "whitelist", "whitelist_file":
+            key = ".*/jobs_info/%s" % shorthand
+            value = getattr(options, shorthand)
+            if value:
+                options.config.append("=".join([key, value]))
+
+        # Set logging early
+        set_logging(options.log_level, options.log)
+
+        # Config setup
+        if len(args) != 2:
+            sys.stderr.write(_("Missing configuration file as argument.\n"))
+            sys.exit(1)
+
+        config = Config()
+        config_filename = posixpath.expanduser(args[1])
+        config.read_filename(config_filename)
+        config.read_configs(options.config)
+
+        section_name = "checkbox/plugins/client_info"
+        section = config.get_section(section_name)
+        if not section:
+            section = config.add_section(section_name)
+        section.set("name", posixpath.basename(args[1]) \
+            .replace(".ini", ""))
+        section.set("version", config.get_defaults().version)
+
+        # Check options
+        if options.version:
+            print config.get_defaults().version
+            sys.exit(0)
+
+        return self.application_factory(config)

=== added file 'checkbox/arguments.py'
--- checkbox/arguments.py	1970-01-01 00:00:00 +0000
+++ checkbox/arguments.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,95 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+from inspect import getargspec
+
+from checkbox.lib.decorator import merge_function_metadata
+
+
+class ArgumentReplacer(object):
+    """A decorator helper that filters arguments to be passed to a function.
+
+    Create one with the original function and a function to replace
+    the arguments, and then call replace_arguments for each call to
+    the function.
+    """
+    def __init__(self, original_function, argument_replacer):
+        """
+        @param original_function: The function which will be called
+            soon. The function must *not* define any * or ** parameters.
+        @param argument_replacer: A function which will be called for
+            every argument. It will be passed a parameter name and the
+            associated argument. It should return the new value.
+        """
+        self.original_function = original_function
+        self.argument_replacer = argument_replacer
+
+        spec = getargspec(original_function)
+        self.all_arguments = spec[0]
+        if getattr(original_function, 'im_self', None) is not None:
+            # If it's bound, ignore the bound arguments.
+            self.all_arguments = self.all_arguments[1:]
+
+    def replace_arguments(self, args, kwargs):
+        """Filter some arguments destined to be passed to a function.
+
+        @param args: Original positional arguments.
+        @param kwargs: Original keyword arguments.
+
+        @return: new arguments and kwarguments.
+        """
+        args = list(args)
+        kwargs = kwargs.copy()
+
+        for name_index, name in enumerate(self.all_arguments):
+            # Ok, we've got the name of the argument. Let's find the value
+            # of the argument in our original arguments and replace it
+            # whether it's a positional or a keyword argument.
+            if name_index < len(args):
+                # Must be a positional argument
+                value = args[name_index]
+                args[name_index] = self.argument_replacer(name, value)
+            else:
+                # Must be a keyword argument
+                if name not in kwargs:
+                    # Oh, but it wasn't passed in. Ignore it.
+                    continue
+                value = kwargs[name]
+                kwargs[name] = self.argument_replacer(name, value)
+        return args, kwargs
+
+
+def coerce_arguments(**schemas):
+    """
+    A decorator factory which returns a decorator which coerces arguments.
+    """
+    def replacer(name, value):
+        if name in schemas:
+            return schemas[name].coerce(value)
+        return value
+
+    def decorator(original):
+        argument_replacer = ArgumentReplacer(original, replacer)
+        def replacement(*args, **kwargs):
+            new_args, new_kwargs = argument_replacer.replace_arguments(args,
+                                                                       kwargs)
+            return original(*new_args, **new_kwargs)
+        merge_function_metadata(original, replacement)
+        return replacement
+
+    return decorator

=== added file 'checkbox/attribute.py'
--- checkbox/attribute.py	1970-01-01 00:00:00 +0000
+++ checkbox/attribute.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,41 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+from checkbox.variables import Variable
+
+
+class Attribute(object):
+
+    def __init__(self, name, cls, variable_factory=None):
+        self.name = name
+        self.cls = cls
+        self.variable_factory = variable_factory or Variable
+
+
+def get_attributes(cls):
+    if "__checkbox_attributes__" in cls.__dict__:
+        return cls.__dict__["__checkbox_attributes__"]
+    else:
+        attributes = {}
+        for name in dir(cls):
+            attribute = getattr(cls, name, None)
+            if isinstance(attribute, Attribute):
+                attributes[name] = attribute
+
+        cls.__checkbox_attributes__ = attributes
+        return cls.__checkbox_attributes__

=== added file 'checkbox/component.py'
--- checkbox/component.py	1970-01-01 00:00:00 +0000
+++ checkbox/component.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,184 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import re
+import itertools
+import logging
+import posixpath
+
+from checkbox.lib.cache import cache
+from checkbox.lib.path import path_expand_recursive
+
+from checkbox.properties import List, String
+from checkbox.variables import get_variables
+
+
+class ComponentSection(object):
+    """
+    Component section which is essentially a container of modules. These
+    map to the modules referenced in the configuration passed as argument
+    to the constructor.
+    """
+
+    modules = List(type=String())
+    whitelist = List(type=String(), default_factory=lambda:"")
+    blacklist = List(type=String(), default_factory=lambda:"")
+
+    def __init__(self, config, name):
+        """
+        Constructor which takes a configuration instance and name as
+        argument. The former is expected to contain modules.
+        """
+        self._config = config
+        self.name = name
+
+        self.modules = config.modules
+        self.whitelist = config.get("whitelist")
+        self.blacklist = config.get("blacklist")
+
+    @cache
+    def get_names(self):
+        """
+        Get all the module names contained in the filenames or directories
+        for this section.
+        """
+        whitelist_patterns = [re.compile(r"^%s$" % r) for r in self.whitelist]
+        blacklist_patterns = [re.compile(r"^%s$" % r) for r in self.blacklist]
+
+        # Determine names
+        names = set()
+        filenames = itertools.chain(*[path_expand_recursive(m)
+            for m in self.modules])
+        for filename in filenames:
+            name = posixpath.basename(filename)
+            if not name.endswith(".py") or name == "__init__.py":
+                # Ignore silently
+                continue
+
+            name = name.replace(".py", "")
+            if whitelist_patterns:
+                if not [name for p in whitelist_patterns if p.match(name)]:
+                    logging.info("Not whitelisted module: %s", name)
+                    continue
+            elif blacklist_patterns:
+                if [name for p in blacklist_patterns if p.match(name)]:
+                    logging.info("Blacklisted module: %s", name)
+                    continue
+
+            names.add(name)
+
+        return list(names)
+
+    def has_module(self, name):
+        """
+        Check if the given name is in this section.
+        """
+        return name in self.get_names()
+
+    def load_module(self, name):
+        """
+        Load a single module by name from this section.
+        """
+        logging.info("Loading module %s from section %s",
+            name, self.name)
+
+        if not self.has_module(name):
+            raise Exception, "No such such module: %s" % name
+
+        filenames = itertools.chain(*[path_expand_recursive(m)
+            for m in self.modules])
+        for filename in filenames:
+            if filename.endswith(".py") and posixpath.exists(filename):
+                basename = posixpath.basename(filename)
+                basename = basename.replace(".py", "")
+                if basename == name:
+                    globals = {}
+                    exec open(filename) in globals
+                    if "factory" not in globals:
+                        raise Exception, "Variable 'factory' not found in: %s" \
+                            % filename
+
+                    module = globals["factory"]()
+                    module.__module__ = name
+
+                    config_name = "/".join([self.name, name])
+                    config = self._config.parent.get_section(config_name)
+
+                    # Set configuration values
+                    variables = get_variables(module)
+                    environ = dict([(k.lower(), v) for k, v in os.environ.iteritems()])
+                    for attribute, variable in variables.iteritems():
+                        if config and attribute.name in config:
+                            value = config.get(attribute.name)
+                            variable.set(value)
+                        else:
+                            value = variable.get()
+                            if isinstance(value, basestring):
+                                value = value % environ
+                                variable.set(value)
+                            elif isinstance(value, list):
+                                value = [v % environ for v in value]
+                                variable.set(value)
+
+                    # Check required attributes
+                    for attribute, variable in variables.iteritems():
+                        value = variable.get()
+                        if value is None and variable._required:
+                            raise Exception, "Configuration '%s' missing " \
+                                "required attribute: %s" \
+                                % (config_name, attribute.name)
+
+                    return module
+
+        raise Exception, "Failed to find module '%s' in: %s" % (name, filenames)
+
+    def load_modules(self):
+        """
+        Load all modules contained in this section.
+        """
+        modules = []
+        for name in self.get_names():
+            module = self.load_module(name)
+            modules.append(module)
+
+        return modules
+
+
+class ComponentManager(object):
+    """
+    Component manager which is essentially a container of sections.
+    """
+
+    _section_factory = ComponentSection
+
+    def __init__(self, config):
+        """
+        Constructor which takes a configuration instance as argument. This
+        will be used to load sections by name.
+        """
+        self._config = config
+
+    def load_section(self, name):
+        """
+        Load a section by name which must correspond to a module in the
+        configuration instance pased as argument to the constructor.
+        """
+        logging.info("Loading component section %s", name)
+        config = self._config.get_section(name)
+        return self._section_factory(config, name)

=== added directory 'checkbox/contrib'
=== added file 'checkbox/contrib/REThread.py'
--- checkbox/contrib/REThread.py	1970-01-01 00:00:00 +0000
+++ checkbox/contrib/REThread.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,139 @@
+'''Enhanced threading.Thread which can deliver a return value and propagate
+exceptions from the called thread to the calling thread.
+
+Copyright (C) 2007 Canonical Ltd.
+Author: Martin Pitt <[e-mail]>
+
+This program 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 2 of the License, or (at your
+option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
+the full text of the license.
+'''
+
+import threading, sys
+
+class REThread(threading.Thread):
+    '''Enhanced threading.Thread which can deliver a return value and propagate
+    exceptions from the called thread to the calling thread.'''
+
+    def __init__(self, group=None, target=None, name=None, args=(), kwargs={},
+            verbose=None):
+        '''Initialize Thread, identical to threading.Thread.__init__().'''
+
+        threading.Thread.__init__(self, group, target, name, args, kwargs,
+            verbose)
+        self.__target = target
+        self.__args = args
+        self.__kwargs = kwargs
+        self._retval = None
+        self._exception = None
+
+    def run(self):
+        '''Run target function, identical to threading.Thread.run().'''
+
+        if self.__target:
+            try:
+                self._retval = self.__target(*self.__args, **self.__kwargs)
+            except:
+                self._exception = sys.exc_info()
+
+    def return_value(self):
+        '''Return value from target function.
+
+        This can only be called after the thread has finished, i. e. when
+        isAlive() is False and did not terminate with an exception.'''
+
+        assert not self.isAlive()
+        assert not self._exception
+        return self._retval
+
+    def exc_info(self):
+        '''Return a tuple (type, value, traceback) of the exception caught in
+        run().'''
+
+        return self._exception
+
+    def exc_raise(self):
+        '''Raises the exception caught in the thread.
+
+        Does nothing if no exception was caught.'''
+
+        if self._exception:
+            raise self._exception[0], self._exception[1], self._exception[2]
+
+#
+# Unit test
+#
+
+if __name__ == '__main__':
+    import unittest, time, traceback, exceptions
+
+    def idle(seconds):
+        '''Test thread to just wait a bit.'''
+
+        time.sleep(seconds)
+
+    def div(x, y):
+        '''Test thread to divide two numbers.'''
+
+        return x / y
+
+    class _REThreadTest(unittest.TestCase):
+        def test_return_value(self):
+            '''Test that return value works properly.'''
+
+            t = REThread(target=div, args=(42, 2))
+            t.start()
+            t.join()
+            # exc_raise() should be a no-op on successful functions
+            t.exc_raise()
+            self.assertEqual(t.return_value(), 21)
+            self.assertEqual(t.exc_info(), None)
+
+        def test_no_return_value(self):
+            '''Test that REThread works if run() does not return anything.'''
+
+            t = REThread(target=idle, args=(0.5,))
+            t.start()
+            # thread must be joined first
+            self.assertRaises(AssertionError, t.return_value)
+            t.join()
+            self.assertEqual(t.return_value(), None)
+            self.assertEqual(t.exc_info(), None)
+
+        def test_exception(self):
+            '''Test that exception in thread is caught and passed.'''
+
+            t = REThread(target=div, args=(1, 0))
+            t.start()
+            t.join()
+            # thread did not terminate normally, no return value
+            self.assertRaises(AssertionError, t.return_value)
+            self.assert_(t.exc_info()[0] == exceptions.ZeroDivisionError)
+            exc = traceback.format_exception(t.exc_info()[0], t.exc_info()[1],
+                t.exc_info()[2])
+            self.assert_(exc[-1].startswith('ZeroDivisionError'))
+            self.assert_(exc[-2].endswith('return x / y\n'))
+
+        def test_exc_raise(self):
+            '''Test that exc_raise() raises caught thread exception.'''
+
+            t = REThread(target=div, args=(1, 0))
+            t.start()
+            t.join()
+            # thread did not terminate normally, no return value
+            self.assertRaises(AssertionError, t.return_value)
+            raised = False
+            try:
+                t.exc_raise()
+            except:
+                raised = True
+                e = sys.exc_info()
+                exc = traceback.format_exception(e[0], e[1], e[2])
+                self.assert_(exc[-1].startswith('ZeroDivisionError'))
+                self.assert_(exc[-2].endswith('return x / y\n'))
+            self.assert_(raised)
+
+    unittest.main()
+

=== added file 'checkbox/contrib/__init__.py'
=== added file 'checkbox/contrib/bpickle.py'
--- checkbox/contrib/bpickle.py	1970-01-01 00:00:00 +0000
+++ checkbox/contrib/bpickle.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,167 @@
+"""
+Copyright (c) 2006, Gustavo Niemeyer <[e-mail]>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the names of its
+      contributors may be used to endorse or promote products derived from
+      this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+
+dumps_table = {}
+loads_table = {}
+
+
+def dumps(obj, _dt=None):
+    if not _dt:
+        _dt = dumps_table
+
+    type_names = [type(obj)]
+    for type_name in type_names:
+        if _dt.has_key(type_name):
+            return _dt[type_name](obj)
+
+        type_names.extend(type_name.__bases__)
+
+    raise ValueError, "Unsupported type: %s" % type(obj)
+
+
+def loads(str, _lt=loads_table):
+    if not str:
+        raise ValueError, "Can't load empty string"
+    try:
+        return _lt[str[0]](str, 0)[0]
+    except KeyError, e:
+        raise ValueError, "Unknown type character: %s" % e
+    except IndexError:
+        raise ValueError, "Corrupted data"
+
+def dumps_bool(obj):
+    return "b%d" % int(obj)
+
+def dumps_int(obj):
+    return "i%s;" % obj
+
+def dumps_float(obj):
+    return "f%r;" % obj
+
+def dumps_str(obj):
+    return "s%s:%s" % (len(obj), obj)
+
+def dumps_unicode(obj):
+    obj = obj.encode("utf-8")
+    return "u%s:%s" % (len(obj), obj)
+
+def dumps_list(obj, _dt=None):
+    return "l%s;" % "".join([dumps(val, _dt) for val in obj])
+
+def dumps_tuple(obj, _dt=None):
+    return "t%s;" % "".join([dumps(val, _dt) for val in obj])
+
+def dumps_dict(obj, _dt=None):
+    res = []
+    keys = sorted(obj.iterkeys())
+    append = res.append
+    for key in keys:
+        val = obj[key]
+        append(dumps(key, _dt))
+        append(dumps(val, _dt))
+    return "d%s;" % "".join(res)
+
+def dumps_none(obj):
+    return "n"
+
+def loads_bool(str, pos):
+    return bool(int(str[pos+1])), pos+2
+
+def loads_int(str, pos):
+    endpos = str.index(";", pos)
+    return int(str[pos+1:endpos]), endpos+1
+
+def loads_float(str, pos):
+    endpos = str.index(";", pos)
+    return float(str[pos+1:endpos]), endpos+1
+
+def loads_str(str, pos):
+    startpos = str.index(":", pos)+1
+    endpos = startpos+int(str[pos+1:startpos-1])
+    return str[startpos:endpos], endpos
+
+def loads_unicode(str, pos):
+    startpos = str.index(":", pos)+1
+    endpos = startpos+int(str[pos+1:startpos-1])
+    return str[startpos:endpos].decode("utf-8"), endpos
+
+def loads_list(str, pos, _lt=loads_table):
+    pos += 1
+    res = []
+    append = res.append
+    while str[pos] != ";":
+        obj, pos = _lt[str[pos]](str, pos)
+        append(obj)
+    return res, pos+1
+
+def loads_tuple(str, pos, _lt=loads_table):
+    pos += 1
+    res = []
+    append = res.append
+    while str[pos] != ";":
+        obj, pos = _lt[str[pos]](str, pos)
+        append(obj)
+    return tuple(res), pos+1
+
+def loads_dict(str, pos, _lt=loads_table):
+    pos += 1
+    res = {}
+    while str[pos] != ";":
+        key, pos = _lt[str[pos]](str, pos)
+        val, pos = _lt[str[pos]](str, pos)
+        res[key] = val
+    return res, pos+1
+
+def loads_none(str, pos):
+    return None, pos+1
+
+
+dumps_table.update({       bool: dumps_bool,
+                            int: dumps_int,
+                           long: dumps_int,
+                          float: dumps_float,
+                            str: dumps_str,
+                        unicode: dumps_unicode,
+                           list: dumps_list,
+                          tuple: dumps_tuple,
+                           dict: dumps_dict,
+                     type(None): dumps_none     })
+
+loads_table.update({ "b": loads_bool,
+                     "i": loads_int,
+                     "f": loads_float,
+                     "s": loads_str,
+                     "u": loads_unicode,
+                     "l": loads_list,
+                     "t": loads_tuple,
+                     "d": loads_dict,
+                     "n": loads_none     })
+

=== added file 'checkbox/contrib/glock.py'
--- checkbox/contrib/glock.py	1970-01-01 00:00:00 +0000
+++ checkbox/contrib/glock.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,316 @@
+#!/usr/bin/env python
+# -*- coding: latin1 -*-
+#----------------------------------------------------------------------------
+# glock.py:                 Global mutex
+#
+# See __doc__ string below.
+#
+# Requires:
+#    - Python 1.5.2 or newer (www.python.org)
+#    - On windows: win32 extensions installed
+#           (http://www.python.org/windows/win32all/win32all.exe)
+#    - OS: Unix, Windows.
+#
+# $Id: //depot/rgutils/rgutils/glock.py#5 $
+#----------------------------------------------------------------------------
+'''
+This module defines the class GlobalLock that implements a global
+(inter-process) mutex on Windows and Unix, using file-locking on
+Unix.
+
+@see: class L{GlobalLock} for more details.
+'''
+__version__ = '0.2.' + '$Revision: #5 $'[12:-2]
+__author__ = 'Richard Gruet', '[e-mail]'
+__date__    = '$Date: 2005/06/19 $'[7:-2], '$Author: rgruet $'[9:-2]
+__since__ = '2000-01-22'
+__doc__ += '\n@author: %s (U{%s})\n@version: %s' % (__author__[0],
+                                            __author__[1], __version__)
+__all__ = ['GlobalLock', 'GlobalLockError', 'LockAlreadyAcquired', 'NotOwner']
+
+# Imports:
+import sys, string, os, errno, re, posixpath
+
+# System-dependent imports for locking implementation:
+_windows = (sys.platform == 'win32')
+
+if _windows:
+    try:
+        import win32event, win32api, pywintypes
+    except ImportError:
+        sys.stderr.write('The win32 extensions need to be installed!')
+    try:
+        import ctypes
+    except ImportError:
+        ctypes = None
+else:   # assume Unix
+    try:
+        import fcntl
+    except ImportError:
+        sys.stderr.write("On what kind of OS am I ? (Mac?) I should be on "
+                         "Unix but can't import fcntl.\n")
+        raise
+    import threading
+
+# Exceptions :
+# ----------
+class GlobalLockError(Exception):
+    ''' Error raised by the glock module.
+    '''
+    pass
+
+class NotOwner(GlobalLockError):
+    ''' Attempt to release somebody else's lock.
+    '''
+    pass
+
+class LockAlreadyAcquired(GlobalLockError):
+    ''' Non-blocking acquire but lock already seized.
+    '''
+    pass
+
+
+# Constants
+# ---------:
+if sys.version[:3] < '2.2':
+    True, False = 1, 0  # built-in in Python 2.2+
+
+#----------------------------------------------------------------------------
+class GlobalLock:
+#----------------------------------------------------------------------------
+    ''' A global mutex.
+
+        B{Specification}
+
+         - The lock must act as a global mutex, ie block between different
+           candidate processus, but ALSO between different candidate
+           threads of the same process.
+
+         - It must NOT block in case of reentrant lock request issued by
+           the SAME thread.
+         - Extraneous unlocks should be ideally harmless.
+
+        B{Implementation}
+
+        In Python there is no portable global lock AFAIK. There is only a
+        LOCAL/ in-process Lock mechanism (threading.RLock), so we have to
+        implement our own solution:
+
+         - Unix: use fcntl.flock(). Recursive calls OK. Different process OK.
+           But <> threads, same process don't block so we have to use an extra
+           threading.RLock to fix that point.
+         - Windows: We use WIN32 mutex from Python Win32 extensions. Can't use
+           std module msvcrt.locking(), because global lock is OK, but
+           blocks also for 2 calls from the same thread!
+    '''
+    RE_ERROR_MSG = re.compile ("^\[Errno ([0-9]+)\]")
+
+    def __init__(self, fpath, lockInitially=False, logger=None):
+        ''' Creates (or opens) a global lock.
+
+            @param fpath: Path of the file used as lock target. This is also
+                          the global id of the lock. The file will be created
+                          if non existent.
+            @param lockInitially: if True locks initially.
+            @param logger: an optional logger object.
+        '''
+        self.logger = logger
+        self.fpath = fpath
+        if posixpath.exists(fpath):
+            self.previous_lockfile_present = True
+        else:
+            self.previous_lockfile_present = False
+        if _windows:
+            self.name = string.replace(fpath, '\\', '_')
+            self.mutex = win32event.CreateMutex(None, lockInitially, self.name)
+        else: # Unix
+            self.name = fpath
+            self.flock = open(fpath, 'w')
+            self.fdlock = self.flock.fileno()
+            self.threadLock = threading.RLock()
+        if lockInitially:
+            self.acquire()
+
+    def __del__(self):
+        #print '__del__ called' ##
+        try: self.release()
+        except: pass
+        if _windows:
+            win32api.CloseHandle(self.mutex)
+        else:
+            try: self.flock.close()
+            except: pass
+
+    def __repr__(self):
+        return '<Global lock @ %s>' % self.name
+
+    def acquire(self, blocking=False):
+        """ Locks. Attemps to acquire a lock.
+
+            @param blocking: If True, suspends caller until done. Otherwise,
+            LockAlreadyAcquired is raised if the lock cannot be acquired immediately.
+
+            On windows an IOError is always raised after ~10 sec if the lock
+            can't be acquired.
+            @exception GlobalLockError: if lock can't be acquired (timeout)
+            @exception LockAlreadyAcquired: someone already has the lock and
+                       the caller decided not to block.
+        """
+        if self.logger:
+            self.logger.info('creating lockfile')
+        if _windows:
+            if blocking:
+                timeout = win32event.INFINITE
+            else:
+                timeout = 0
+            r = win32event.WaitForSingleObject(self.mutex, timeout)
+            if r == win32event.WAIT_FAILED:
+                raise GlobalLockError("Can't acquire mutex: error")
+            if not blocking and r == win32event.WAIT_TIMEOUT:
+                raise LockAlreadyAcquired('Lock %s already acquired by '
+                                          'someone else' % self.name)
+        else:
+            # First, acquire the global (inter-process) lock:
+            if blocking:
+                options = fcntl.LOCK_EX
+            else:
+                options = fcntl.LOCK_EX|fcntl.LOCK_NB
+            try:
+                fcntl.flock(self.fdlock, options)
+            except IOError, message: #(errno 13: perm. denied,
+                            #       36: Resource deadlock avoided)
+                if not blocking and self._errnoOf (message) == errno.EWOULDBLOCK:
+                    raise LockAlreadyAcquired('Lock %s already acquired by '
+                                              'someone else' % self.name)
+                else:
+                    raise GlobalLockError('Cannot acquire lock on "file" '
+                                          '%s: %s\n' % (self.name, message))
+            #print 'got file lock.' ##
+
+            # Then acquire the local (inter-thread) lock:
+            if not self.threadLock.acquire(blocking):
+                fcntl.flock(self.fdlock, fcntl.LOCK_UN) # release global lock
+                raise LockAlreadyAcquired('Lock %s already acquired by '
+                                          'someone else' % self.name)
+            if self.previous_lockfile_present and self.logger:
+                self.logger.warn("Stale lockfile detected and claimed.")
+            #print 'got thread lock.' ##
+
+        self.is_locked = True
+
+    def release(self, skip_delete=False):
+        ''' Unlocks. (caller must own the lock!)
+
+            @param skip_delete: don't try to delete the file. This can
+                be used when the original filename has changed; for
+                instance, if the lockfile is erased out-of-band, or if
+                the directory it contains has been renamed.
+
+            @return: The lock count.
+            @exception IOError: if file lock can't be released
+            @exception NotOwner: Attempt to release somebody else's lock.
+        '''
+        if not self.is_locked:
+            return
+        if not skip_delete:
+            if self.logger:
+                self.logger.debug('Removing lock file: %s', self.fpath)
+            os.unlink(self.fpath)
+        elif self.logger:
+            # At certain times the lockfile will have been removed or
+            # moved away before we call release(); log a message because
+            # this is unusual and could be an error.
+            self.logger.debug('Oops, my lock file disappeared: %s', self.fpath)
+        if _windows:
+            if ctypes:
+                result = ctypes.windll.kernel32.ReleaseMutex(self.mutex.handle)
+                if not result:
+                   raise NotOwner("Attempt to release somebody else's lock")
+            else:
+                try:
+                    win32event.ReleaseMutex(self.mutex)
+                    #print "released mutex"
+                except pywintypes.error, e:
+                    errCode, fctName, errMsg =  e.args
+                    if errCode == 288:
+                        raise NotOwner("Attempt to release somebody else's lock")
+                    else:
+                        raise GlobalLockError('%s: err#%d: %s' % (fctName, errCode,
+                                                                  errMsg))
+        else:
+            # First release the local (inter-thread) lock:
+            try:
+                self.threadLock.release()
+            except AssertionError:
+                raise NotOwner("Attempt to release somebody else's lock")
+
+            # Then release the global (inter-process) lock:
+            try:
+                fcntl.flock(self.fdlock, fcntl.LOCK_UN)
+            except IOError: # (errno 13: permission denied)
+                raise GlobalLockError('Unlock of file "%s" failed\n' %
+                                                            self.name)
+        self.is_locked = False
+
+    def _errnoOf (self, message):
+        match = self.RE_ERROR_MSG.search(str(message))
+        if match:
+            return int(match.group(1))
+        else:
+            raise Exception ('Malformed error message "%s"' % message)
+
+#----------------------------------------------------------------------------
+def test():
+#----------------------------------------------------------------------------
+    ##TODO: a more serious test with distinct processes !
+
+    print 'Testing glock.py...'
+
+    # unfortunately can't test inter-process lock here!
+    lockName = 'myFirstLock'
+    l = GlobalLock(lockName)
+    if not _windows:
+        assert posixpath.exists(lockName)
+    l.acquire()
+    l.acquire() # reentrant lock, must not block
+    l.release()
+    l.release()
+
+    try: l.release()
+    except NotOwner: pass
+    else: raise Exception('should have raised a NotOwner exception')
+
+    # Check that <> threads of same process do block:
+    import threading, time
+    thread = threading.Thread(target=threadMain, args=(l,))
+    print 'main: locking...',
+    l.acquire()
+    print ' done.'
+    thread.start()
+    time.sleep(3)
+    print '\nmain: unlocking...',
+    l.release()
+    print ' done.'
+    time.sleep(0.1)
+
+    print '=> Test of glock.py passed.'
+    return l
+
+def threadMain(lock):
+    print 'thread started(%s).' % lock
+    try: lock.acquire(blocking=False)
+    except LockAlreadyAcquired: pass
+    else: raise Exception('should have raised LockAlreadyAcquired')
+    print 'thread: locking (should stay blocked for ~ 3 sec)...',
+    lock.acquire()
+    print 'thread: locking done.'
+    print 'thread: unlocking...',
+    lock.release()
+    print ' done.'
+    print 'thread ended.'
+
+#----------------------------------------------------------------------------
+#       M A I N
+#----------------------------------------------------------------------------
+if __name__ == "__main__":
+    l = test()

=== added file 'checkbox/contrib/persist.py'
--- checkbox/contrib/persist.py	1970-01-01 00:00:00 +0000
+++ checkbox/contrib/persist.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,552 @@
+# Copyright (c) 2006 Canonical
+# Copyright (c) 2004 Conectiva, Inc.
+#
+# Written by Gustavo Niemeyer <[e-mail]>
+#
+# This Python module 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 2 of the License, or (at
+# your option) any later version.
+#
+# This Python module 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 this Python module; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+import os
+import sys
+import copy
+import re
+import posixpath
+
+from checkbox.lib.safe import safe_close
+
+__all__ = ["Persist", "MemoryBackend", "PickleBackend", "BPickleBackend",
+    "path_string_to_tuple", "path_tuple_to_string", "RootedPersist",
+    "PersistError", "PersistReadOnlyError"]
+
+
+NOTHING = object()
+
+
+class PersistError(Exception):
+    pass
+
+
+class PersistReadOnlyError(PersistError):
+    pass
+
+
+class Persist(object):
+    """Persistence handler.
+
+    There are three different kinds of opition maps, regarding the
+    persistence and priority that maps are queried.
+
+    hard - Options are persistent.
+    soft - Options are not persistent, and have a higher priority
+           than persistent options.
+    weak - Options are not persistent, and have a lower priority
+           than persistent options.
+
+    @ivar filename: The name of the file where persist data is saved
+        or None if not filename is available.
+    """
+
+
+    def __init__(self, filename=None, backend=None):
+        """
+        @param backend: The backend to use. If none is specified,
+            L{BPickleBackend} will be used.
+        @param filename: The default filename to save to and load from. If
+            specified, and the file exists, it will be immediately
+            loaded. Specifying this will also allow L{save} to be called
+            without any arguments to save the persist.
+        """
+        if backend is None:
+            backend = BPickleBackend()
+        self._backend = backend
+        self._hardmap = backend.new()
+        self._softmap = {}
+        self._weakmap = {}
+        self._readonly = False
+        self._modified = False
+        self.filename = filename
+        if filename is not None and posixpath.exists(filename):
+            self.load(filename)
+
+    def _get_readonly(self):
+        return self._readonly
+
+    def _set_readonly(self, flag):
+        self._readonly = bool(flag)
+
+    def _get_modified(self):
+        return self._modified
+
+    readonly = property(_get_readonly, _set_readonly)
+    modified = property(_get_modified)
+
+    def reset_modified(self):
+        self._modified = False
+
+    def assert_writable(self):
+        if self._readonly:
+            raise PersistReadOnlyError("Configuration is in readonly mode.")
+
+    def load(self, filepath):
+        filepath = posixpath.expanduser(filepath)
+        if not posixpath.isfile(filepath):
+            raise PersistError("File not found: %s" % filepath)
+        if posixpath.getsize(filepath) == 0:
+            return
+        try:
+            self._hardmap = self._backend.load(filepath)
+        except:
+            filepathold = filepath+".old"
+            if (posixpath.isfile(filepathold) and
+                posixpath.getsize(filepathold) > 0):
+                # warning("Broken configuration file at %s" % filepath)
+                # warning("Trying backup at %s" % filepathold)
+                try:
+                    self._hardmap = self._backend.load(filepathold)
+                except:
+                    raise PersistError("Broken configuration file at %s" %
+                                       filepathold)
+            else:
+                raise PersistError("Broken configuration file at %s" %
+                                   filepath)
+
+    def save(self, filepath=None):
+        """Save the persist to the given C{filepath}.
+
+        If None is specified, then the filename passed during construction will
+        be used.
+        """
+        if filepath is None:
+            if self.filename is None:
+                return
+            filepath = self.filename
+        filepath = posixpath.expanduser(filepath)
+        if posixpath.isfile(filepath):
+            os.rename(filepath, filepath+".old")
+        dirname = posixpath.dirname(filepath)
+        if dirname and not posixpath.isdir(dirname):
+            os.makedirs(dirname)
+        self._backend.save(filepath, self._hardmap)
+
+    def _traverse(self, obj, path, default=NOTHING, setvalue=NOTHING):
+        if setvalue is not NOTHING:
+            setvalue = self._backend.copy(setvalue)
+        queue = list(path)
+        marker = NOTHING
+        newobj = obj
+        while queue:
+            obj = newobj
+            elem = queue.pop(0)
+            newobj = self._backend.get(obj, elem)
+            if newobj is NotImplemented:
+                if queue:
+                    path = path[:-len(queue)]
+                raise PersistError("Can't traverse %r (%r): %r" %
+                                   (type(obj), path_tuple_to_string(path),
+                                    str(obj)))
+            if newobj is marker:
+                break
+        if newobj is not marker:
+            if setvalue is not marker:
+                newobj = self._backend.set(obj, elem, setvalue)
+        else:
+            if setvalue is marker:
+                newobj = default
+            else:
+                while True:
+                    if len(queue) > 0:
+                        if type(queue[0]) is int:
+                            newvalue = []
+                        else:
+                            newvalue = {}
+                    else:
+                        newvalue = setvalue
+                    newobj = self._backend.set(obj, elem, newvalue)
+                    if newobj is NotImplemented:
+                        raise PersistError("Can't traverse %r with %r" %
+                                           (type(obj), type(elem)))
+                    if not queue:
+                        break
+                    obj = newobj
+                    elem = queue.pop(0)
+        return newobj
+
+    def _getvalue(self, path, soft=False, hard=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        marker = NOTHING
+        if soft:
+            value = self._traverse(self._softmap, path, marker)
+        elif hard:
+            value = self._traverse(self._hardmap, path, marker)
+        elif weak:
+            value = self._traverse(self._weakmap, path, marker)
+        else:
+            value = self._traverse(self._softmap, path, marker)
+            if value is marker:
+                value = self._traverse(self._hardmap, path, marker)
+                if value is marker:
+                    value = self._traverse(self._weakmap, path, marker)
+        return value
+
+    def has(self, path, value=NOTHING, soft=False, hard=False, weak=False):
+        obj = self._getvalue(path, soft, hard, weak)
+        marker = NOTHING
+        if obj is marker:
+            return False
+        elif value is marker:
+            return True
+        result = self._backend.has(obj, value)
+        if result is NotImplemented:
+            raise PersistError("Can't check %r for containment" % type(obj))
+        return result
+
+    def keys(self, path, soft=False, hard=False, weak=False):
+        obj = self._getvalue(path, soft, hard, weak)
+        if obj is NOTHING:
+            return []
+        result = self._backend.keys(obj)
+        if result is NotImplemented:
+            raise PersistError("Can't return keys for %s" % type(obj))
+        return result
+
+    def get(self, path, default=None, soft=False, hard=False, weak=False):
+        value = self._getvalue(path, soft, hard, weak)
+        if value is NOTHING:
+            return default
+        return self._backend.copy(value)
+
+    def set(self, path, value, soft=False, weak=False):
+        assert path
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        if soft:
+            map = self._softmap
+        elif weak:
+            map = self._weakmap
+        else:
+            self.assert_writable()
+            self._modified = True
+            map = self._hardmap
+        self._traverse(map, path, setvalue=value)
+
+    def add(self, path, value, unique=False, soft=False, weak=False):
+        assert path
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        if soft:
+            map = self._softmap
+        elif weak:
+            map = self._weakmap
+        else:
+            self.assert_writable()
+            self._modified = True
+            map = self._hardmap
+        if unique:
+            current = self._traverse(map, path)
+            if type(current) is list and value in current:
+                return
+        path = path+(sys.maxint,)
+        self._traverse(map, path, setvalue=value)
+
+    def remove(self, path, value=NOTHING, soft=False, weak=False):
+        assert path
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        if soft:
+            map = self._softmap
+        elif weak:
+            map = self._weakmap
+        else:
+            self.assert_writable()
+            self._modified = True
+            map = self._hardmap
+        marker = NOTHING
+        while path:
+            if value is marker:
+                obj = self._traverse(map, path[:-1])
+                elem = path[-1]
+                isvalue = False
+            else:
+                obj = self._traverse(map, path)
+                elem = value
+                isvalue = True
+            result = False
+            if obj is not marker:
+                result = self._backend.remove(obj, elem, isvalue)
+                if result is NotImplemented:
+                    raise PersistError("Can't remove %r from %r" %
+                                       (elem, type(obj)))
+            if self._backend.empty(obj):
+                if value is not marker:
+                    value = marker
+                else:
+                    path = path[:-1]
+            else:
+                break
+        return result
+
+    def move(self, oldpath, newpath, soft=False, weak=False):
+        if not (soft or weak):
+            self.assert_writable()
+        if type(oldpath) is str:
+            oldpath = path_string_to_tuple(oldpath)
+        if type(newpath) is str:
+            newpath = path_string_to_tuple(newpath)
+        result = False
+        marker = NOTHING
+        value = self._getvalue(oldpath, soft, not (soft or weak), weak)
+        if value is not marker:
+            self.remove(oldpath, soft=soft, weak=weak)
+            self.set(newpath, value, weak, soft)
+            result = True
+        return result
+
+    def root_at(self, path):
+        return RootedPersist(self, path)
+
+
+class RootedPersist(object):
+
+    def __init__(self, parent, root):
+        self.parent = parent
+        if type(root) is str:
+            self.root = path_string_to_tuple(root)
+        else:
+            self.root = root
+
+    readonly = property(lambda self: self.parent.readonly)
+    modified = property(lambda self: self.parent.modified)
+
+    def assert_writable(self):
+        self.parent.assert_writable()
+
+    def save(self):
+        self.parent.save()
+
+    def has(self, path, value=NOTHING, soft=False, hard=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.has(self.root+path, value, soft, hard, weak)
+
+    def keys(self, path, soft=False, hard=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.keys(self.root+path, soft, hard, weak)
+
+    def get(self, path, default=None, soft=False, hard=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.get(self.root+path, default, soft, hard, weak)
+
+    def set(self, path, value, soft=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.set(self.root+path, value, soft, weak)
+
+    def add(self, path, value, unique=False, soft=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.add(self.root+path, value, unique, soft, weak)
+
+    def remove(self, path, value=NOTHING, soft=False, weak=False):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.remove(self.root+path, value, soft, weak)
+
+    def move(self, oldpath, newpath, soft=False, weak=False):
+        if type(oldpath) is str:
+            oldpath = path_string_to_tuple(oldpath)
+        if type(newpath) is str:
+            newpath = path_string_to_tuple(newpath)
+        return self.parent.move(self.root+oldpath, self.root+newpath,
+                                soft, weak)
+
+    def root_at(self, path):
+        if type(path) is str:
+            path = path_string_to_tuple(path)
+        return self.parent.root_at(self.root+path)
+
+
+_splitpath = re.compile(r"(\[-?\d+\])|(?<!\\)\.").split
+
+def path_string_to_tuple(path):
+    if "." not in path and "[" not in path:
+        return (path,)
+    result = []
+    tokens = _splitpath(path)
+    for token in tokens:
+        if token:
+            if token[0] == "[" and token[-1] == "]":
+                try:
+                    result.append(int(token[1:-1]))
+                except ValueError:
+                    raise PersistError("Invalid path index: %r" % token)
+            else:
+                result.append(token.replace(r"\.", "."))
+    return tuple(result)
+
+
+def path_tuple_to_string(path):
+    result = []
+    for elem in path:
+        if type(elem) is int:
+            result[-1] += "[%d]" % elem
+        else:
+            result.append(str(elem).replace(".", "\."))
+    return ".".join(result)
+
+
+class Backend(object):
+
+    def new(self):
+        return {}
+
+    def load(self, filepath):
+        raise NotImplementedError
+
+    def save(self, filepath, map):
+        raise NotImplementedError
+
+    def get(self, obj, elem, _marker=NOTHING):
+        if type(obj) is dict:
+            newobj = obj.get(elem, _marker)
+        elif type(obj) in (tuple, list):
+            if type(elem) is int:
+                try:
+                    newobj = obj[elem]
+                except IndexError:
+                    newobj = _marker
+            elif elem in obj:
+                newobj = elem
+            else:
+                newobj = _marker
+        else:
+            newobj = NotImplemented
+        return newobj
+
+    def set(self, obj, elem, value):
+        if type(obj) is dict:
+            newobj = obj[elem] = value
+        elif type(obj) is list and type(elem) is int:
+            lenobj = len(obj)
+            if lenobj <= elem:
+                obj.append(None)
+                elem = lenobj
+            elif elem < 0 and abs(elem) > lenobj:
+                obj.insert(0, None)
+                elem = 0
+            newobj = obj[elem] = value
+        else:
+            newobj = NotImplemented
+        return newobj
+
+    def remove(self, obj, elem, isvalue):
+        result = False
+        if type(obj) is dict:
+            if elem in obj:
+                del obj[elem]
+                result = True
+        elif type(obj) is list:
+            if not isvalue and type(elem) is int:
+                try:
+                    del obj[elem]
+                    result = True
+                except IndexError:
+                    pass
+            elif elem in obj:
+                obj[:] = [x for x in obj if x != elem]
+                result = True
+        else:
+            result = NotImplemented
+        return result
+
+    def copy(self, value):
+        if type(value) in (dict, list):
+            return copy.deepcopy(value)
+        return value
+
+    def empty(self, obj):
+        return (not obj)
+
+    def has(self, obj, elem):
+        contains = getattr(obj, "__contains__", None)
+        if contains:
+            return contains(elem)
+        return NotImplemented
+
+    def keys(self, obj):
+        keys = getattr(obj, "keys", None)
+        if keys:
+            return keys()
+        elif type(obj) is list:
+            return range(len(obj))
+        return NotImplemented
+
+
+class MemoryBackend(Backend):
+
+    def __init__(self):
+        self._store = {}
+
+    def load(self, filepath):
+        return self._store.get(filepath)
+
+    def save(self, filepath, map):
+        self._store[filepath] = map
+
+class DiskBackend(Backend):
+
+    safe_file_closing = True
+
+class PickleBackend(DiskBackend):
+
+    def __init__(self):
+        import cPickle
+        self._pickle = cPickle
+
+    def load(self, filepath):
+        file = open(filepath)
+        try:
+            return self._pickle.load(file)
+        finally:
+            safe_close(file, self.safe_file_closing)
+
+    def save(self, filepath, map):
+        file = open(filepath, "w")
+        try:
+            self._pickle.dump(map, file, 2)
+        finally:
+            safe_close(file, self.safe_file_closing)
+
+
+class BPickleBackend(DiskBackend):
+
+    def __init__(self):
+        from checkbox.contrib import bpickle
+        self._bpickle = bpickle
+
+    def load(self, filepath):
+        file = open(filepath)
+        try:
+            return self._bpickle.loads(file.read())
+        finally:
+            safe_close(file, self.safe_file_closing)
+
+    def save(self, filepath, map):
+        file = open(filepath, "w")
+        try:
+            file.write(self._bpickle.dumps(map))
+        finally:
+            safe_close(file, self.safe_file_closing)

=== added file 'checkbox/dispatcher.py'
--- checkbox/dispatcher.py	1970-01-01 00:00:00 +0000
+++ checkbox/dispatcher.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,201 @@
+# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+__all__ = [
+    "Dispatcher",
+    "DispatcherList",
+    "DispatcherQueue",
+    ]
+
+import logging
+
+from itertools import product
+
+
+class Event:
+    """Event payload containing the positional and keywoard arguments
+    passed to the handler in the event listener."""
+
+    def __init__(self, type, *args, **kwargs):
+        self.type = type
+        self.args = args
+        self.kwargs = kwargs
+
+
+class Listener:
+    """Event listener notified when events are published by the dispatcher."""
+
+    def __init__(self, event_type, handler, count):
+        self.event_type = event_type
+        self.handler = handler
+        self.count = count
+
+    def notify(self, event):
+        """Notify the handler with the payload of the event.
+
+        :param event: The event containint the payload for the handler.
+        """
+        if self.count is None or self.count:
+            self.handler(*event.args, **event.kwargs)
+            if self.count:
+                self.count -= 1
+
+
+class ListenerList(Listener):
+    """Event listener notified for lists of events."""
+
+    def __init__(self, *args, **kwargs):
+        super(ListenerList, self).__init__(*args, **kwargs)
+        self.event_types = set(self.event_type)
+        self.kwargs = {}
+
+    def notify(self, event):
+        """Only notify the handler when all the events for this listener
+        have been published by the dispatcher. When duplicate events
+        occur, the latest event is preserved and the previous one are
+        overwritten until all events have been published.
+        """
+        if self.count is None or self.count:
+            self.kwargs[event.type] = event.args[0]
+            if self.event_types.issubset(self.kwargs):
+                self.handler(**self.kwargs)
+                if self.count:
+                    self.count -= 1
+
+
+class ListenerQueue(ListenerList):
+
+    def notify(self, event):
+        """Only notify the handler when all the events for this listener
+        have been published by the dispatcher. Duplicate events are enqueued
+        and dequeued only when all events have been published.
+        """
+        arg = event.args[0]
+        queue = self.kwargs.setdefault(event.type, [])
+
+        # Strip duplicates from the queue.
+        if arg not in queue:
+            queue.append(arg)
+
+        # Once the queue has handler has been called, the queue
+        # then behaves like a list using the latest events.
+        if self.event_types.issubset(self.kwargs):
+            self.notify = notify = super(ListenerQueue, self).notify
+            keys = self.kwargs.keys()
+            for values in product(*self.kwargs.values()):
+                self.kwargs = dict(zip(keys, values))
+                notify(event)
+
+
+class Dispatcher:
+    """Register handlers and publish events for them identified by strings."""
+
+    listener_factory = Listener
+
+    def __init__(self, listener_factory=None):
+        self._event_listeners = {}
+
+        if listener_factory is not None:
+            self.listener_factory = listener_factory
+
+    def registerHandler(self, event_type, handler, count=None):
+        """Register an event handler and return its listener.
+
+        :param event_type: The name of the event type to handle.
+        :param handler: The function handling the given event type.
+        :param count: Optionally, the number times to call the handler.
+        """
+        listener = self.listener_factory(event_type, handler, count)
+
+        listeners = self._event_listeners.setdefault(event_type, [])
+        listeners.append(listener)
+
+        return listener
+
+    def unregisterHandler(self, handler):
+        """Unregister a handler.
+
+        :param handler: The handler to unregister.
+        """
+        for event_type, listeners in self._event_listeners.items():
+            listeners = [
+                listener for listener in listeners
+                if listener.handler == handler]
+            if listeners:
+                self._event_listeners[event_type] = listeners
+            else:
+                del self._event_listeners[event_type]
+
+    def unregisterListener(self, listener, event_type=None):
+        """Unregister a listener.
+
+        :param listener: The listener of the handler to unregister.
+        :param event_type: Optionally, the event_type to unregister.
+        """
+        if event_type is None:
+            event_type = listener.event_type
+
+        self._event_listeners[event_type].remove(listener)
+        if not self._event_listeners[event_type]:
+            del self._event_listeners[event_type]
+
+    def publishEvent(self, event_type, *args, **kwargs):
+        """Publish an event of a given type and notify all listeners.
+
+        :param event_type: The name of the event type to publish.
+        :param args: Positional arguments to pass to the registered handlers.
+        :param kwargs: Keyword arguments to pass to the registered handlers.
+        """
+        if event_type in self._event_listeners:
+            event = Event(event_type, *args, **kwargs)
+            for listener in list(self._event_listeners[event_type]):
+                try:
+                    listener.notify(event)
+                    if listener.count is not None and not listener.count:
+                        self.unregisterListener(listener)
+                except:
+                    logging.exception(
+                        "Error running event handler for %r with args %r %r",
+                        event_type, args, kwargs)
+
+
+class DispatcherList(Dispatcher):
+    """
+    Register handlers and publish events for them identified by lists
+    of strings.
+    """
+
+    listener_factory = ListenerList
+
+    def registerHandler(self, event_types, handler, count=None):
+        """See Dispatcher."""
+        if not isinstance(event_types, (list, tuple,)):
+            event_types = (event_types,)
+
+        listener = self.listener_factory(event_types, handler, count)
+        for event_type in event_types:
+            listeners = self._event_listeners.setdefault(event_type, [])
+            listeners.append(listener)
+
+        return listener
+
+    def unregisterListener(self, listener):
+        """See Dispatcher."""
+        for event_type in listener.event_types:
+            super(DispatcherList, self).unregisterListener(
+                listener, event_type)
+
+    def publishEvent(self, event_type, arg):
+        """See Dispatcher."""
+        super(DispatcherList, self).publishEvent(event_type, arg)
+
+
+class DispatcherQueue(DispatcherList):
+    """
+    Register handlers and publish events for them identified by lists
+    of strings in queue order.
+    """
+
+    listener_factory = ListenerQueue

=== added file 'checkbox/job.py'
--- checkbox/job.py	1970-01-01 00:00:00 +0000
+++ checkbox/job.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,140 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import logging
+
+from gettext import gettext as _
+from string import Template
+
+from checkbox.lib.process import Process
+from checkbox.lib.signal import signal_to_name, signal_to_description
+
+from checkbox.message import MessageStore
+
+
+FAIL = "fail"
+PASS = "pass"
+UNINITIATED = "uninitiated"
+UNRESOLVED = "unresolved"
+UNSUPPORTED = "unsupported"
+UNTESTED = "untested"
+
+ALL_STATUS = [FAIL, PASS, UNINITIATED, UNRESOLVED, UNSUPPORTED, UNTESTED]
+
+DEFAULT_JOB_TIMEOUT = 30 # used in case a job specifies invalid timeout
+
+class Job(object):
+
+    def __init__(self, command, environ=None, timeout=None):
+        if environ is None:
+            environ = []
+
+        self.command = command
+        self.environ = environ
+        self.timeout = timeout
+        if self.timeout is not None:
+            try:
+                self.timeout = float(self.timeout)
+            except:
+                self.timeout = DEFAULT_JOB_TIMEOUT
+            finally:
+                if self.timeout < 0:
+                    self.timeout = DEFAULT_JOB_TIMEOUT
+
+    def execute(self):
+        # Sanitize environment
+        process_environ = dict(os.environ)
+        for environ in self.environ:
+            key, value = environ.split("=", 1)
+            value = Template(value).safe_substitute(process_environ)
+            process_environ[key] = value
+
+        logging.info("Running command: %s", self.command)
+        process = Process(self.command, process_environ)
+        if not process.read(self.timeout):
+            logging.info("Command timed out, killing process.")
+            process.kill()
+
+        process_status = process.cleanup()
+        if os.WIFEXITED(process_status):
+            exit_status = os.WEXITSTATUS(process_status)
+            if exit_status == 0:
+                status = PASS
+                data = process.outdata
+                if not data:
+                    data = process.errdata
+            elif exit_status == 127:
+                status = UNRESOLVED
+                data = _("Command not found.")
+            else:
+                status = FAIL
+                data = (process.errdata
+                             or process.outdata)
+        elif os.WIFSIGNALED(process_status):
+            status = UNRESOLVED
+            term_signal = os.WTERMSIG(process_status)
+            data = _("Command received signal %s: %s") % \
+                (signal_to_name(term_signal),
+                 signal_to_description(term_signal))
+        else:
+            raise Exception, "Command not terminated: %s" \
+                % self.command
+
+        duration = process.endtime - process.starttime
+
+        return (status, data, duration,)
+
+
+class JobStore(MessageStore):
+    """A job store which stores its jobs in a file system hierarchy."""
+
+    def add(self, job):
+        # TODO: Order alphabetically within suite or non-suite
+
+        # Remove the same job if it already exists without a suite
+        if "suite" in job:
+            for filename in self._find_matching_messages(name=job["name"], suite=None):
+                os.unlink(filename)
+
+        # Return if the same job is already in the store
+        if list(self._find_matching_messages(name=job["name"])):
+            return
+
+        message_id = super(JobStore, self).add(job)
+
+        # TODO: Apply dependencies
+        if "depends" in job:
+            for depends in job["depends"]:
+                for filename in self._find_matching_messages():
+                    message = self._read_message(filename, cache=True)
+                    if job["name"] in message.get("depends", []):
+                        new_filename = self._get_next_message_filename()
+                        os.rename(filename, new_filename)
+
+        return message_id
+
+    # TODO: Optimize by only searching backwards until a given condition
+    def _find_matching_messages(self, **kwargs):
+        for filename in self._walk_messages():
+            message = self._read_message(filename,cache=True)
+            for key, value in kwargs.iteritems():
+                if message.get(key) != value:
+                    break
+            else:
+                yield filename

=== added directory 'checkbox/lib'
=== added file 'checkbox/lib/__init__.py'
=== added file 'checkbox/lib/bit.py'
--- checkbox/lib/bit.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/bit.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,46 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+from struct import calcsize
+
+
+def get_bitmask(key):
+    bitmask = []
+    for value in reversed(key.split()):
+        value = int(value, 16)
+        bitmask.append(value)
+
+    return bitmask
+
+def get_bitcount(bitmask):
+    bitcount = 0
+    for value in bitmask:
+        while value:
+            bitcount += 1
+            value &= (value - 1)
+
+    return bitcount
+
+def test_bit(bit, bitmask, bits=None):
+    if bits is None:
+        bits = calcsize("l") * 8
+    offset = bit % bits
+    long = int(bit / bits)
+    if long >= len(bitmask):
+        return 0
+    return (bitmask[long] >> offset) & 1

=== added file 'checkbox/lib/cache.py'
--- checkbox/lib/cache.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/cache.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,37 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+class Cache(object):
+
+    def __init__(self, function):
+        self._cache = {}
+        self._function = function
+
+    def __get__(self, instance, cls=None):
+        self._instance = instance
+        return self
+
+    def __call__(self, *args):
+        if not self._cache.has_key((self._instance,) + args):
+            self._cache[(self._instance,) + args] = self._function(self._instance, *args)
+
+        return self._cache[(self._instance,) + args]
+
+
+def cache(function):
+    return Cache(function)

=== added file 'checkbox/lib/config.py'
--- checkbox/lib/config.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/config.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,173 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import re
+import logging
+import posixpath
+
+from ConfigParser import ConfigParser
+
+from checkbox.lib.text import split
+
+
+class IncludeDict(dict):
+
+    def __init__(self, parser):
+        super(IncludeDict, self).__init__()
+        self._parser = parser
+
+        for (key, value) in os.environ.iteritems():
+            if key.startswith("CHECKBOX"):
+                super(IncludeDict, self).__setitem__(key.lower(), value)
+
+    def __setitem__(self, key, value):
+        if key == "includes":
+            if isinstance(value, list):
+                value = value[0]
+            for path in split(value):
+                path = self._parser._interpolate("DEFAULT", None, path, self)
+                path = posixpath.expanduser(path)
+                if not posixpath.exists(path):
+                    raise Exception, "No such configuration file: %s" % path
+                if posixpath.isdir(path):
+                    logging.info("Parsing config filenames from directory: %s",
+                        path)
+                    def walk_func(arg, directory, names):
+                        for name in names:
+                            path = posixpath.join(directory, name)
+                            if not posixpath.isdir(path):
+                                arg._parser.read(path)
+
+                    posixpath.walk(path, walk_func, self)
+                else:
+                    logging.info("Parsing config filename: %s", path)
+                    self._parser.read(path)
+
+        # Environment has precedence over configuration
+        elif not key.startswith("CHECKBOX") or key.upper() not in os.environ:
+            super(IncludeDict, self).__setitem__(key, value)
+
+
+class ConfigSection(object):
+
+    def __init__(self, parent, name, attributes={}):
+        self.parent = parent
+        self.name = name
+        self.attributes = {}
+        for key, value in attributes.iteritems():
+            self.attributes[key] = re.sub("\n\.\n", "\n\n", value)
+
+    def __getattr__(self, name):
+        if name in self.attributes:
+            return self.get(name)
+
+        raise AttributeError, name
+
+    def __contains__(self, name):
+        return name in self.attributes
+
+    def get(self, name):
+        return self.attributes.get(name, "")
+
+    def set(self, name, value):
+        self.parent._parser.set(self.name, name, value)
+        self.attributes[name] = value
+
+
+class ConfigDefaults(ConfigSection):
+
+    def __getattr__(self, name):
+        if name in self.attributes:
+            return self.get(name)
+
+        raise AttributeError, name
+
+    def get(self, name):
+        name_upper = name.upper()
+        if not name_upper.startswith("CHECKBOX") or name_upper not in os.environ:
+            return super(ConfigDefaults, self).get(name)
+        else:
+            return os.environ[name_upper]
+
+
+class Config(object):
+
+    def __init__(self):
+        self._parser = ConfigParser()
+        self._parser._defaults = IncludeDict(self._parser)
+
+        # Copy attributes from the parser to avoid one additional
+        # function call on each access.
+        for attr in ["has_section", "remove_section"]:
+            setattr(self, attr, getattr(self._parser, attr))
+
+    def read_configs(self, configs):
+        for config in configs:
+            match = re.match("(.*)/([^/]+)=(.*)", config)
+            if not match:
+                raise Exception, "Invalid config string: %s" % config
+
+            (name, option, value) = match.groups()
+
+            # Match section names
+            name_regex = re.compile(name)
+            sections = [section for section in self._parser.sections()
+                        if name_regex.match(section)]
+
+            if not sections:
+                self._parser.add_section(name)
+                sections.append(name)
+
+            for section in sections:
+                logging.debug('Setting configuration parameter: '
+                              '%(section)s/%(option)s = %(value)s'
+                              % {'section': section,
+                                 'option': option,
+                                 'value': value})
+                self._parser.set(section, option, value)
+
+    def read_file(self, file, filename="<stream>"):
+        logging.info("Reading configurations from: %s", filename)
+
+        self._parser.readfp(file, filename)
+
+    def read_filename(self, filename):
+        if not posixpath.exists(filename):
+            raise Exception, "No such configuration file: %s" % filename
+
+        file = open(filename, "r")
+        return self.read_file(file, filename)
+
+    def get_defaults(self):
+        attributes = self._parser.defaults()
+        return ConfigDefaults(self, 'DEFAULT', attributes)
+
+    def get_section(self, name):
+        if self._parser.has_section(name):
+            attributes = dict(self._parser.items(name))
+            return ConfigSection(self, name, attributes)
+
+        return None
+
+    def get_section_names(self):
+        return self._parser.sections()
+
+    def add_section(self, name):
+        self._parser.add_section(name)
+        return self.get_section(name)

=== added file 'checkbox/lib/conversion.py'
--- checkbox/lib/conversion.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/conversion.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,169 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import re
+
+from dateutil import tz
+from datetime import (
+    datetime,
+    timedelta,
+    )
+
+
+DATETIME_RE = re.compile(r"""
+    ^(?P<year>\d\d\d\d)-?(?P<month>\d\d)-?(?P<day>\d\d)
+    T(?P<hour>\d\d):?(?P<minute>\d\d):?(?P<second>\d\d)
+    (?:\.(?P<second_fraction>\d{0,6}))?
+    (?P<tz>
+        (?:(?P<tz_sign>[-+])(?P<tz_hour>\d\d):(?P<tz_minute>\d\d))
+        | Z)?$
+    """, re.VERBOSE)
+
+TYPE_FORMATS = (
+    (r"(yes|true)", lambda v: True),
+    (r"(no|false)", lambda v: False),
+    (r"-?\d+", lambda v: int(v.group(0))),
+    (r"-?\d+\.\d+", lambda v: float(v.group(0))),
+    (r"(-?\d+) ?([kmgt]?b?)", lambda v: int(v.group(1))),
+    (r"(-?\d+\.\d+) ?([kmgt]?b?)", lambda v: float(v.group(1))),
+    (r"(-?\d+) ?([kmgt]?hz)", lambda v: int(v.group(1))),
+    (r"(-?\d+\.\d+) ?([kmgt]?hz)", lambda v: float(v.group(1))))
+TYPE_FORMATS = tuple(
+    (re.compile(r"^%s$" % pattern, re.IGNORECASE), format)
+    for pattern, format in TYPE_FORMATS)
+
+TYPE_MULTIPLIERS = (
+    (r"b", 1),
+    (r"kb?", 1024),
+    (r"mb?", 1024 * 1024),
+    (r"gb?", 1024 * 1024 * 1024),
+    (r"tb?", 1024 * 1024 * 1024 * 1024),
+    (r"hz", 1),
+    (r"khz?", 1024),
+    (r"mhz?", 1024 * 1024),
+    (r"ghz?", 1024 * 1024 * 1024),
+    (r"thz?", 1024 * 1024 * 1024 * 1024))
+TYPE_MULTIPLIERS = tuple(
+    (re.compile(r"^%s$" % pattern, re.IGNORECASE), multiplier)
+    for pattern, multiplier in TYPE_MULTIPLIERS)
+
+
+def datetime_to_string(dt):
+    """Return a consistent string representation for a given datetime.
+
+    :param dt: The datetime object.
+    """
+    return dt.isoformat()
+
+def string_to_datetime(string):
+    """Return a datetime object from a consistent string representation.
+
+    :param string: The string representation.
+    """
+    # we cannot use time.strptime: this function accepts neither fractions
+    # of a second nor a time zone given e.g. as '+02:30'.
+    match = DATETIME_RE.match(string)
+
+    # The Relax NG schema allows a leading minus sign and year numbers
+    # with more than four digits, which are not "covered" by _time_regex.
+    if not match:
+        raise ValueError("Datetime with unreasonable value: %s" % string)
+
+    time_parts = match.groupdict()
+
+    year = int(time_parts['year'])
+    month = int(time_parts['month'])
+    day = int(time_parts['day'])
+    hour = int(time_parts['hour'])
+    minute = int(time_parts['minute'])
+    second = int(time_parts['second'])
+    second_fraction = time_parts['second_fraction']
+    if second_fraction is not None:
+        milliseconds = second_fraction + '0' * (6 - len(second_fraction))
+        milliseconds = int(milliseconds)
+    else:
+        milliseconds = 0
+
+    # The Relax NG validator accepts leap seconds, but the datetime
+    # constructor rejects them. The time values submitted by the HWDB
+    # client are not necessarily very precise, hence we can round down
+    # to 59.999999 seconds without losing any real precision.
+    if second > 59:
+        second = 59
+        milliseconds = 999999
+
+    dt = datetime(
+        year, month, day, hour, minute, second, milliseconds,
+        tzinfo=tz.tzutc())
+
+    tz_sign = time_parts['tz_sign']
+    tz_hour = time_parts['tz_hour']
+    tz_minute = time_parts['tz_minute']
+    if tz_sign in ('-', '+'):
+        delta = timedelta(hours=int(tz_hour), minutes=int(tz_minute))
+        if tz_sign == '-':
+            dt = dt + delta
+        else:
+            dt = dt - delta
+
+    return dt
+
+def sizeof_bytes(bytes):
+    for x in ["bytes", "KB", "MB", "GB", "TB"]:
+        string = "%3.1f%s" % (bytes, x)
+        if bytes < 1024.0:
+            break
+        bytes /= 1024.0
+
+    return string
+
+def sizeof_hertz(hertz):
+    for x in ["Hz", "KHz", "MHz", "GHz"]:
+        string = "%3.1f%s" % (hertz, x)
+        if hertz < 1000.0:
+            break
+        hertz /= 1000.0
+
+    return string
+
+def string_to_type(string):
+    """Return a typed representation for the given string.
+
+    The result might be a bool, int or float. The string might also be
+    supplemented by a multiplier like KB which would return an int or
+    float multiplied by 1024 for example.
+
+    :param string: The string representation.
+    """
+    if isinstance(string, basestring):
+        for regex, formatter in TYPE_FORMATS:
+            match = regex.match(string)
+            if match:
+                string = formatter(match)
+                if len(match.groups()) > 1:
+                    unit = match.group(2)
+                    for regex, multiplier in TYPE_MULTIPLIERS:
+                        match = regex.match(unit)
+                        if match:
+                            string *= multiplier
+                            break
+                    else:
+                        raise ValueError("Unknown multiplier: %s" % unit)
+                break
+
+    return string

=== added file 'checkbox/lib/decorator.py'
--- checkbox/lib/decorator.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/decorator.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,28 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+def merge_function_metadata(original, new):
+    """Overwrite C{new}'s docstring and instance dictionary from C{original}.
+
+    This also sets an C{original_function} attribute on the new
+    function to C{original}. This is to allow code
+    introspect various things about the original function.
+    """
+    new.__doc__ = original.__doc__
+    new.__dict__.update(original.__dict__)
+    new.original_function = original

=== added file 'checkbox/lib/dmi.py'
--- checkbox/lib/dmi.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/dmi.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,225 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+
+
+# See also 3.3.4.1 of the "System Management BIOS Reference Specification,
+# Version 2.6.1" (Preliminary Standard) document, available from
+# http://www.dmtf.org/standards/smbios.
+class Dmi:
+    chassis = (
+        ("Undefined",             "unknown"),  # 0x00
+        ("Other",                 "unknown"),
+        ("Unknown",               "unknown"),
+        ("Desktop",               "desktop"),
+        ("Low Profile Desktop",   "desktop"),
+        ("Pizza Box",             "server"),
+        ("Mini Tower",            "desktop"),
+        ("Tower",                 "desktop"),
+        ("Portable",              "laptop"),
+        ("Laptop",                "laptop"),
+        ("Notebook",              "laptop"),
+        ("Hand Held",             "handheld"),
+        ("Docking Station",       "laptop"),
+        ("All In One",            "unknown"),
+        ("Sub Notebook",          "laptop"),
+        ("Space-saving",          "desktop"),
+        ("Lunch Box",             "unknown"),
+        ("Main Server Chassis",   "server"),
+        ("Expansion Chassis",     "unknown"),
+        ("Sub Chassis",           "unknown"),
+        ("Bus Expansion Chassis", "unknown"),
+        ("Peripheral Chassis",    "unknown"),
+        ("RAID Chassis",          "unknown"),
+        ("Rack Mount Chassis",    "unknown"),
+        ("Sealed-case PC",        "unknown"),
+        ("Multi-system",          "unknown"),
+        ("CompactPCI",            "unknonw"),
+        ("AdvancedTCA",           "unknown"),
+        ("Blade",                 "server"),
+        ("Blade Enclosure",       "unknown"))
+
+    chassis_names = tuple(c[0] for c in chassis)
+    chassis_types = tuple(c[1] for c in chassis)
+    chassis_name_to_type = dict(chassis)
+
+    type_names = (
+        "BIOS",  # 0x00
+        "System",
+        "Base Board",
+        "Chassis",
+        "Processor",
+        "Memory Controller",
+        "Memory Module",
+        "Cache",
+        "Port Connector",
+        "System Slots",
+        "On Board Devices",
+        "OEM Strings",
+        "System Configuration Options",
+        "BIOS Language",
+        "Group Associations",
+        "System Event Log",
+        "Physical Memory Array",
+        "Memory Device",
+        "32-bit Memory Error",
+        "Memory Array Mapped Address",
+        "Memory Device Mapped Address",
+        "Built-in Pointing Device",
+        "Portable Battery",
+        "System Reset",
+        "Hardware Security",
+        "System Power Controls",
+        "Voltage Probe",
+        "Cooling Device",
+        "Temperature Probe",
+        "Electrical Current Probe",
+        "Out-of-band Remote Access",
+        "Boot Integrity Services",
+        "System Boot",
+        "64-bit Memory Error",
+        "Management Device",
+        "Management Device Component",
+        "Management Device Threshold Data",
+        "Memory Channel",
+        "IPMI Device",
+        "Power Supply",
+        )
+
+
+class DmiDevice:
+
+    bus = "dmi"
+    driver = None
+    product_id = None
+    vendor_id = None
+
+    _product_blacklist = (
+        "<BAD INDEX>",
+        "N/A",
+        "Not Available",
+        "INVALID",
+        "OEM",
+        "Product Name",
+        "System Product Name",
+        "To be filled by O.E.M.",
+        "To Be Filled By O.E.M.",
+        "To Be Filled By O.E.M. by More String",
+        "Unknown",
+        "Uknown",
+        "Unknow",
+        "xxxxxxxxxxxxxx",
+        )
+    _vendor_blacklist = (
+        "<BAD INDEX>",
+        "Not Available",
+        "OEM",
+        "OEM Manufacturer",
+        "System manufacturer",
+        "System Manufacturer",
+        "System Name",
+        "To be filled by O.E.M.",
+        "To Be Filled By O.E.M.",
+        "To Be Filled By O.E.M. by More String",
+        "Unknow",  # XXX This is correct mispelling
+        "Unknown",
+        )
+    _serial_blacklist = (
+       "0",
+       "00000000",
+       "00 00 00 00 00 00 00 00",
+       "0123456789",
+       "Base Board Serial Number",
+       "Chassis Serial Number",
+       "N/A",
+       "None",
+       "Not Applicable",
+       "Not Available",
+       "Not Specified",
+       "OEM",
+       "System Serial Number",
+       )
+    _version_blacklist = (
+        "-1",
+        "<BAD INDEX>",
+        "N/A",
+        "None",
+        "Not Applicable",
+        "Not Available",
+        "Not Specified",
+        "OEM",
+        "System Version",
+        "Unknown",
+        "x.x",
+        )
+
+    def __init__(self, attributes, category):
+        self._attributes = attributes
+        self.category = category
+
+    @property
+    def path(self):
+        path = "/devices/virtual/dmi/id"
+        return os.path.join(path, self.category.lower())
+
+    @property
+    def product(self):
+        if self.category == "CHASSIS":
+            type_string = self._attributes.get("chassis_type", "0")
+            try:
+                type_index = int(type_string)
+                return Dmi.chassis_names[type_index]
+            except ValueError:
+                return type_string
+
+        for name in "name", "version":
+            attribute = "%s_%s" % (self.category.lower(), name)
+            product = self._attributes.get(attribute)
+            if product and product not in self._product_blacklist:
+                return product
+
+        return None
+
+    @property
+    def vendor(self):
+        for name in "manufacturer", "vendor":
+            attribute = "%s_%s" % (self.category.lower(), name)
+            vendor = self._attributes.get(attribute)
+            if vendor and vendor not in self._vendor_blacklist:
+                return vendor
+
+        return None
+
+    @property
+    def serial(self):
+        attribute = "%s_serial" % self.category.lower()
+        serial = self._attributes.get(attribute)
+        if serial and serial not in self._serial_blacklist:
+            return serial
+
+        return None
+
+    @property
+    def version(self):
+        attribute = "%s_version" % self.category.lower()
+        version = self._attributes.get(attribute)
+        if version and version not in self._version_blacklist:
+            return version
+
+        return None

=== added file 'checkbox/lib/enum.py'
--- checkbox/lib/enum.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/enum.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,72 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2011 Canonical Ltd.
+#
+# 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/>.
+#
+__all__ = [
+    "EnumException", "Enum", "enum_name_to_value", "enum_value_to_name"]
+
+
+class EnumException(Exception):
+
+    pass
+
+
+class Enum(object):
+
+    def __init__(self, *names):
+        value = 0
+        unique_names = set()
+        for name in names:
+            if isinstance(name, (list, tuple)):
+                name, value = name
+
+            if not isinstance(name, str):
+                raise EnumException(
+                    "enum name is not a string: %s" % name)
+
+            if isinstance(value, str):
+                if value not in unique_names:
+                    raise EnumException(
+                        "enum value does not define: %s" % value)
+                value = getattr(self, value)
+
+            if not isinstance(value, (int, long)):
+                raise EnumException(
+                    "enum value is not an integer: %s" % value)
+
+            if name in unique_names:
+                raise EnumException(
+                    "enum name is not unique: %s" % name)
+
+            unique_names.add(name)
+            setattr(self, name, value)
+            value += 1
+
+
+def enum_name_to_value(enum, name):
+    if not hasattr(enum, name):
+        raise EnumException("enum name unknown: %s" % name)
+
+    return getattr(enum, name)
+
+
+def enum_value_to_name(enum, value):
+    for k, v in enum.__dict__.items():
+        if v == value:
+            return k
+
+    raise EnumException("enum value unknown: %s" % value)

=== added file 'checkbox/lib/environ.py'
--- checkbox/lib/environ.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/environ.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,113 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import posixpath
+
+from os import environ
+from stat import ST_MODE, S_IEXEC
+
+
+def get_variables():
+    return dict(environ)
+
+def get_variable(name, default=None):
+    """Get the value of an environment variable name.
+
+    Keyword arguments:
+    name -- name of the environment variable
+    """
+
+    return environ.get(name, default)
+
+def add_variable(name, value):
+    """Add or change the value of an environment variable name.
+
+    Keyword arguments:
+    name -- name of the environment variable
+    value -- value given to the environment variable
+    """
+
+    if value is not None:
+        environ[name] = value
+
+def remove_variable(name):
+    """Remove an environment variable name.
+
+    Keyword arguments:
+    name -- name of the environment variable
+    """
+
+    if name in environ:
+        del environ[name]
+
+def get_paths():
+    paths = []
+    if "PATH" in environ:
+        paths = environ["PATH"].split(":")
+
+    return paths
+
+def get_path(command):
+    for path in get_paths():
+        absolute = posixpath.join(path, command)
+        if posixpath.exists(absolute):
+            mode = os.stat(absolute)[ST_MODE]
+            if mode & S_IEXEC:
+                return absolute
+
+    return None
+
+def append_path(path):
+    """Prepend a path to the PATH environment variable if it doesn't
+    exist already.
+
+    Keyword arguments:
+    path -- path to add
+    """
+
+    environ_path = get_paths()
+    if path not in environ_path:
+        environ_path.append(path)
+        environ["PATH"] = ":".join(environ_path)
+
+def prepend_path(path):
+    """Prepend a path to the PATH environment variable if it doesn't
+    exist already.
+
+    Keyword arguments:
+    path -- path to add
+    """
+
+    environ_path = get_paths()
+    if path not in environ_path:
+        environ_path.insert(0, path)
+        environ["PATH"] = ":".join(environ_path)
+
+def remove_path(path):
+    """Remove a path from the PATH environment variable if it exists
+    already.
+
+    Keyword arguments:
+    path -- path to remove
+    """
+
+    environ_path = get_paths()
+    if path in environ_path:
+        environ_path.remove(path)
+        environ["PATH"] = ":".join(environ_path)

=== added file 'checkbox/lib/fifo.py'
--- checkbox/lib/fifo.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/fifo.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,105 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2010 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import struct
+
+from checkbox.contrib.bpickle import dumps, loads
+from checkbox.lib.selector import Selector, SelectorIO
+
+class FifoBase(object):
+
+    mode = None
+
+    def __init__(self, path, timeout=None):
+        self.path = path
+        self.file = open(path, self.mode)
+        self._timeout = timeout
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        self.file.close()
+
+    def wait_for(self, operation):
+        if self._timeout is not None:
+            selector = Selector()
+            selector.set_timeout(self._timeout)
+            selector.add_fd(self.file.fileno(), operation)
+
+            selector.execute()
+
+            if not selector.has_ready():
+                return False
+        return True
+
+class FifoReader(FifoBase):
+
+    #on Linux, opening a FIFO in read-write mode is non-blocking and
+    #succeeds even if other end is not open as per FIFO(7)
+    mode = "w+"
+
+    def read_string(self):
+        # Check if a connection arrived within the timeout
+        if not self.wait_for(SelectorIO.READ):
+            return None
+
+        size = struct.calcsize("i")
+        length_string = self.file.read(size)
+        if not length_string:
+            return ""
+
+        length = struct.unpack(">i", length_string)[0]
+        return self.file.read(length)
+
+    def read_object(self):
+        string = self.read_string()
+        if not string:
+            return None
+
+        return loads(string)
+
+
+class FifoWriter(FifoBase):
+
+    #on Linux, opening a FIFO in read-write mode is non-blocking and
+    #succeeds even if other end is not open as per FIFO(7)
+    mode = "w+"
+
+    def write_string(self, string):
+
+        # Wait until I can write 
+        if not self.wait_for(SelectorIO.WRITE):
+            return None 
+
+        length = len(string)
+        length_string = struct.pack(">i", length)
+        self.file.write(length_string)
+        self.file.write(string)
+        self.file.flush()
+        return length
+
+    def write_object(self, object):
+        string = dumps(object)
+        return self.write_string(string)
+
+
+def create_fifo(path, mode=0666):
+    os.mkfifo(path, mode)
+    return path

=== added file 'checkbox/lib/input.py'
--- checkbox/lib/input.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/input.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,585 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+
+# See linux/input.h
+class Input:
+    KEY_RESERVED            = 0
+    KEY_ESC                 = 1
+    KEY_1                   = 2
+    KEY_2                   = 3
+    KEY_3                   = 4
+    KEY_4                   = 5
+    KEY_5                   = 6
+    KEY_6                   = 7
+    KEY_7                   = 8
+    KEY_8                   = 9
+    KEY_9                   = 10
+    KEY_0                   = 11
+    KEY_MINUS               = 12
+    KEY_EQUAL               = 13
+    KEY_BACKSPACE           = 14
+    KEY_TAB                 = 15
+    KEY_Q                   = 16
+    KEY_W                   = 17
+    KEY_E                   = 18
+    KEY_R                   = 19
+    KEY_T                   = 20
+    KEY_Y                   = 21
+    KEY_U                   = 22
+    KEY_I                   = 23
+    KEY_O                   = 24
+    KEY_P                   = 25
+    KEY_LEFTBRACE           = 26
+    KEY_RIGHTBRACE          = 27
+    KEY_ENTER               = 28
+    KEY_LEFTCTRL            = 29
+    KEY_A                   = 30
+    KEY_S                   = 31
+    KEY_D                   = 32
+    KEY_F                   = 33
+    KEY_G                   = 34
+    KEY_H                   = 35
+    KEY_J                   = 36
+    KEY_K                   = 37
+    KEY_L                   = 38
+    KEY_SEMICOLON           = 39
+    KEY_APOSTROPHE          = 40
+    KEY_GRAVE               = 41
+    KEY_LEFTSHIFT           = 42
+    KEY_BACKSLASH           = 43
+    KEY_Z                   = 44
+    KEY_X                   = 45
+    KEY_C                   = 46
+    KEY_V                   = 47
+    KEY_B                   = 48
+    KEY_N                   = 49
+    KEY_M                   = 50
+    KEY_COMMA               = 51
+    KEY_DOT                 = 52
+    KEY_SLASH               = 53
+    KEY_RIGHTSHIFT          = 54
+    KEY_KPASTERISK          = 55
+    KEY_LEFTALT             = 56
+    KEY_SPACE               = 57
+    KEY_CAPSLOCK            = 58
+    KEY_F1                  = 59
+    KEY_F2                  = 60
+    KEY_F3                  = 61
+    KEY_F4                  = 62
+    KEY_F5                  = 63
+    KEY_F6                  = 64
+    KEY_F7                  = 65
+    KEY_F8                  = 66
+    KEY_F9                  = 67
+    KEY_F10                 = 68
+    KEY_NUMLOCK             = 69
+    KEY_SCROLLLOCK          = 70
+    KEY_KP7                 = 71
+    KEY_KP8                 = 72
+    KEY_KP9                 = 73
+    KEY_KPMINUS             = 74
+    KEY_KP4                 = 75
+    KEY_KP5                 = 76
+    KEY_KP6                 = 77
+    KEY_KPPLUS              = 78
+    KEY_KP1                 = 79
+    KEY_KP2                 = 80
+    KEY_KP3                 = 81
+    KEY_KP0                 = 82
+    KEY_KPDOT               = 83
+
+    KEY_ZENKAKUHANKAKU      = 85
+    KEY_102ND               = 86
+    KEY_F11                 = 87
+    KEY_F12                 = 88
+    KEY_RO                  = 89
+    KEY_KATAKANA            = 90
+    KEY_HIRAGANA            = 91
+    KEY_HENKAN              = 92
+    KEY_KATAKANAHIRAGANA    = 93
+    KEY_MUHENKAN            = 94
+    KEY_KPJPCOMMA           = 95
+    KEY_KPENTER             = 96
+    KEY_RIGHTCTRL           = 97
+    KEY_KPSLASH             = 98
+    KEY_SYSRQ               = 99
+    KEY_RIGHTALT            = 100
+    KEY_LINEFEED            = 101
+    KEY_HOME                = 102
+    KEY_UP                  = 103
+    KEY_PAGEUP              = 104
+    KEY_LEFT                = 105
+    KEY_RIGHT               = 106
+    KEY_END                 = 107
+    KEY_DOWN                = 108
+    KEY_PAGEDOWN            = 109
+    KEY_INSERT              = 110
+    KEY_DELETE              = 111
+    KEY_MACRO               = 112
+    KEY_MUTE                = 113
+    KEY_VOLUMEDOWN          = 114
+    KEY_VOLUMEUP            = 115
+    KEY_POWER               = 116     # SC System Power Down
+    KEY_KPEQUAL             = 117
+    KEY_KPPLUSMINUS         = 118
+    KEY_PAUSE               = 119
+    KEY_SCALE               = 120     # AL Compiz Scale (Expose)
+
+    KEY_KPCOMMA             = 121
+    KEY_HANGEUL             = 122
+    KEY_HANGUEL             = KEY_HANGEUL
+    KEY_HANJA               = 123
+    KEY_YEN                 = 124
+    KEY_LEFTMETA            = 125
+    KEY_RIGHTMETA           = 126
+    KEY_COMPOSE             = 127
+
+    KEY_STOP                = 128     # AC Stop
+    KEY_AGAIN               = 129
+    KEY_PROPS               = 130     # AC Properties
+    KEY_UNDO                = 131     # AC Undo
+    KEY_FRONT               = 132
+    KEY_COPY                = 133     # AC Copy
+    KEY_OPEN                = 134     # AC Open
+    KEY_PASTE               = 135     # AC Paste
+    KEY_FIND                = 136     # AC Search
+    KEY_CUT                 = 137     # AC Cut
+    KEY_HELP                = 138     # AL Integrated Help Center
+    KEY_MENU                = 139     # Menu (show menu)
+    KEY_CALC                = 140     # AL Calculator
+    KEY_SETUP               = 141
+    KEY_SLEEP               = 142     # SC System Sleep
+    KEY_WAKEUP              = 143     # System Wake Up
+    KEY_FILE                = 144     # AL Local Machine Browser
+    KEY_SENDFILE            = 145
+    KEY_DELETEFILE          = 146
+    KEY_XFER                = 147
+    KEY_PROG1               = 148
+    KEY_PROG2               = 149
+    KEY_WWW                 = 150     # AL Internet Browser
+    KEY_MSDOS               = 151
+    KEY_COFFEE              = 152     # AL Terminal Lock/Screensaver
+    KEY_SCREENLOCK          = KEY_COFFEE
+    KEY_DIRECTION           = 153
+    KEY_CYCLEWINDOWS        = 154
+    KEY_MAIL                = 155
+    KEY_BOOKMARKS           = 156     # AC Bookmarks
+    KEY_COMPUTER            = 157
+    KEY_BACK                = 158     # AC Back
+    KEY_FORWARD             = 159     # AC Forward
+    KEY_CLOSECD             = 160
+    KEY_EJECTCD             = 161
+    KEY_EJECTCLOSECD        = 162
+    KEY_NEXTSONG            = 163
+    KEY_PLAYPAUSE           = 164
+    KEY_PREVIOUSSONG        = 165
+    KEY_STOPCD              = 166
+    KEY_RECORD              = 167
+    KEY_REWIND              = 168
+    KEY_PHONE               = 169     # Media Select Telephone
+    KEY_ISO                 = 170
+    KEY_CONFIG              = 171     # AL Consumer Control Configuration
+    KEY_HOMEPAGE            = 172     # AC Home
+    KEY_REFRESH             = 173     # AC Refresh
+    KEY_EXIT                = 174     # AC Exit
+    KEY_MOVE                = 175
+    KEY_EDIT                = 176
+    KEY_SCROLLUP            = 177
+    KEY_SCROLLDOWN          = 178
+    KEY_KPLEFTPAREN         = 179
+    KEY_KPRIGHTPAREN        = 180
+    KEY_NEW                 = 181     # AC New
+    KEY_REDO                = 182     # AC Redo/Repeat
+
+    KEY_F13                 = 183
+    KEY_F14                 = 184
+    KEY_F15                 = 185
+    KEY_F16                 = 186
+    KEY_F17                 = 187
+    KEY_F18                 = 188
+    KEY_F19                 = 189
+    KEY_F20                 = 190
+    KEY_F21                 = 191
+    KEY_F22                 = 192
+    KEY_F23                 = 193
+    KEY_F24                 = 194
+
+    KEY_PLAYCD              = 200
+    KEY_PAUSECD             = 201
+    KEY_PROG3               = 202
+    KEY_PROG4               = 203
+    KEY_DASHBOARD           = 204     # AL Dashboard
+    KEY_SUSPEND             = 205
+    KEY_CLOSE               = 206     # AC Close
+    KEY_PLAY                = 207
+    KEY_FASTFORWARD         = 208
+    KEY_BASSBOOST           = 209
+    KEY_PRINT               = 210     # AC Print
+    KEY_HP                  = 211
+    KEY_CAMERA              = 212
+    KEY_SOUND               = 213
+    KEY_QUESTION            = 214
+    KEY_EMAIL               = 215
+    KEY_CHAT                = 216
+    KEY_SEARCH              = 217
+    KEY_CONNECT             = 218
+    KEY_FINANCE             = 219     # AL Checkbook/Finance
+    KEY_SPORT               = 220
+    KEY_SHOP                = 221
+    KEY_ALTERASE            = 222
+    KEY_CANCEL              = 223     # AC Cancel
+    KEY_BRIGHTNESSDOWN      = 224
+    KEY_BRIGHTNESSUP        = 225
+    KEY_MEDIA               = 226
+
+    KEY_SWITCHVIDEOMODE     = 227     # Cycle between available video
+                                      # outputs (Monitor/LCD/TV-out/etc)
+    KEY_KBDILLUMTOGGLE      = 228
+    KEY_KBDILLUMDOWN        = 229
+    KEY_KBDILLUMUP          = 230
+
+    KEY_SEND                = 231     # AC Send
+    KEY_REPLY               = 232     # AC Reply
+    KEY_FORWARDMAIL         = 233     # AC Forward Msg
+    KEY_SAVE                = 234     # AC Save
+    KEY_DOCUMENTS           = 235
+
+    KEY_BATTERY             = 236
+
+    KEY_BLUETOOTH           = 237
+    KEY_WLAN                = 238
+    KEY_UWB                 = 239
+
+    KEY_UNKNOWN             = 240
+
+    KEY_VIDEO_NEXT          = 241     # drive next video source
+    KEY_VIDEO_PREV          = 242     # drive previous video source
+    KEY_BRIGHTNESS_CYCLE    = 243     # brightness up, after max is min
+    KEY_BRIGHTNESS_ZERO     = 244     # brightness off, use ambient
+    KEY_DISPLAY_OFF         = 245     # display device to off state
+
+    KEY_WIMAX               = 246
+
+    # Range = 248 - 255 is reserved for special needs of AT keyboard driver
+
+    BTN_MISC                = 0x100
+    BTN_0                   = 0x100
+    BTN_1                   = 0x101
+    BTN_2                   = 0x102
+    BTN_3                   = 0x103
+    BTN_4                   = 0x104
+    BTN_5                   = 0x105
+    BTN_6                   = 0x106
+    BTN_7                   = 0x107
+    BTN_8                   = 0x108
+    BTN_9                   = 0x109
+
+    BTN_MOUSE               = 0x110
+    BTN_LEFT                = 0x110
+    BTN_RIGHT               = 0x111
+    BTN_MIDDLE              = 0x112
+    BTN_SIDE                = 0x113
+    BTN_EXTRA               = 0x114
+    BTN_FORWARD             = 0x115
+    BTN_BACK                = 0x116
+    BTN_TASK                = 0x117
+
+    BTN_JOYSTICK            = 0x120
+    BTN_TRIGGER             = 0x120
+    BTN_THUMB               = 0x121
+    BTN_THUMB2              = 0x122
+    BTN_TOP                 = 0x123
+    BTN_TOP2                = 0x124
+    BTN_PINKIE              = 0x125
+    BTN_BASE                = 0x126
+    BTN_BASE2               = 0x127
+    BTN_BASE3               = 0x128
+    BTN_BASE4               = 0x129
+    BTN_BASE5               = 0x12a
+    BTN_BASE6               = 0x12b
+    BTN_DEAD                = 0x12f
+
+    BTN_GAMEPAD             = 0x130
+    BTN_A                   = 0x130
+    BTN_B                   = 0x131
+    BTN_C                   = 0x132
+    BTN_X                   = 0x133
+    BTN_Y                   = 0x134
+    BTN_Z                   = 0x135
+    BTN_TL                  = 0x136
+    BTN_TR                  = 0x137
+    BTN_TL2                 = 0x138
+    BTN_TR2                 = 0x139
+    BTN_SELECT              = 0x13a
+    BTN_START               = 0x13b
+    BTN_MODE                = 0x13c
+    BTN_THUMBL              = 0x13d
+    BTN_THUMBR              = 0x13e
+
+    BTN_DIGI                = 0x140
+    BTN_TOOL_PEN            = 0x140
+    BTN_TOOL_RUBBER         = 0x141
+    BTN_TOOL_BRUSH          = 0x142
+    BTN_TOOL_PENCIL         = 0x143
+    BTN_TOOL_AIRBRUSH       = 0x144
+    BTN_TOOL_FINGER         = 0x145
+    BTN_TOOL_MOUSE          = 0x146
+    BTN_TOOL_LENS           = 0x147
+    BTN_TOUCH               = 0x14a
+    BTN_STYLUS              = 0x14b
+    BTN_STYLUS2             = 0x14c
+    BTN_TOOL_DOUBLETAP      = 0x14d
+    BTN_TOOL_TRIPLETAP      = 0x14e
+
+    BTN_WHEEL               = 0x150
+    BTN_GEAR_DOWN           = 0x150
+    BTN_GEAR_UP             = 0x151
+
+    KEY_OK                  = 0x160
+    KEY_SELECT              = 0x161
+    KEY_GOTO                = 0x162
+    KEY_CLEAR               = 0x163
+    KEY_POWER2              = 0x164
+    KEY_OPTION              = 0x165
+    KEY_INFO                = 0x166   # AL OEM Features/Tips/Tutorial
+    KEY_TIME                = 0x167
+    KEY_VENDOR              = 0x168
+    KEY_ARCHIVE             = 0x169
+    KEY_PROGRAM             = 0x16a   # Media Select Program Guide
+    KEY_CHANNEL             = 0x16b
+    KEY_FAVORITES           = 0x16c
+    KEY_EPG                 = 0x16d
+    KEY_PVR                 = 0x16e   # Media Select Home
+    KEY_MHP                 = 0x16f
+    KEY_LANGUAGE            = 0x170
+    KEY_TITLE               = 0x171
+    KEY_SUBTITLE            = 0x172
+    KEY_ANGLE               = 0x173
+    KEY_ZOOM                = 0x174
+    KEY_MODE                = 0x175
+    KEY_KEYBOARD            = 0x176
+    KEY_SCREEN              = 0x177
+    KEY_PC                  = 0x178   # Media Select Computer
+    KEY_TV                  = 0x179   # Media Select TV
+    KEY_TV2                 = 0x17a   # Media Select Cable
+    KEY_VCR                 = 0x17b   # Media Select VCR
+    KEY_VCR2                = 0x17c   # VCR Plus
+    KEY_SAT                 = 0x17d   # Media Select Satellite
+    KEY_SAT2                = 0x17e
+    KEY_CD                  = 0x17f   # Media Select CD
+    KEY_TAPE                = 0x180   # Media Select Tape
+    KEY_RADIO               = 0x181
+    KEY_TUNER               = 0x182   # Media Select Tuner
+    KEY_PLAYER              = 0x183
+    KEY_TEXT                = 0x184
+    KEY_DVD                 = 0x185   # Media Select DVD
+    KEY_AUX                 = 0x186
+    KEY_MP3                 = 0x187
+    KEY_AUDIO               = 0x188
+    KEY_VIDEO               = 0x189
+    KEY_DIRECTORY           = 0x18a
+    KEY_LIST                = 0x18b
+    KEY_MEMO                = 0x18c   # Media Select Messages
+    KEY_CALENDAR            = 0x18d
+    KEY_RED                 = 0x18e
+    KEY_GREEN               = 0x18f
+    KEY_YELLOW              = 0x190
+    KEY_BLUE                = 0x191
+    KEY_CHANNELUP           = 0x192   # Channel Increment
+    KEY_CHANNELDOWN         = 0x193   # Channel Decrement
+    KEY_FIRST               = 0x194
+    KEY_LAST                = 0x195   # Recall Last
+    KEY_AB                  = 0x196
+    KEY_NEXT                = 0x197
+    KEY_RESTART             = 0x198
+    KEY_SLOW                = 0x199
+    KEY_SHUFFLE             = 0x19a
+    KEY_BREAK               = 0x19b
+    KEY_PREVIOUS            = 0x19c
+    KEY_DIGITS              = 0x19d
+    KEY_TEEN                = 0x19e
+    KEY_TWEN                = 0x19f
+    KEY_VIDEOPHONE          = 0x1a0   # Media Select Video Phone
+    KEY_GAMES               = 0x1a1   # Media Select Games
+    KEY_ZOOMIN              = 0x1a2   # AC Zoom In
+    KEY_ZOOMOUT             = 0x1a3   # AC Zoom Out
+    KEY_ZOOMRESET           = 0x1a4   # AC Zoom
+    KEY_WORDPROCESSOR       = 0x1a5   # AL Word Processor
+    KEY_EDITOR              = 0x1a6   # AL Text Editor
+    KEY_SPREADSHEET         = 0x1a7   # AL Spreadsheet
+    KEY_GRAPHICSEDITOR      = 0x1a8   # AL Graphics Editor
+    KEY_PRESENTATION        = 0x1a9   # AL Presentation App
+    KEY_DATABASE            = 0x1aa   # AL Database App
+    KEY_NEWS                = 0x1ab   # AL Newsreader
+    KEY_VOICEMAIL           = 0x1ac   # AL Voicemail
+    KEY_ADDRESSBOOK         = 0x1ad   # AL Contacts/Address Book
+    KEY_MESSENGER           = 0x1ae   # AL Instant Messaging
+    KEY_DISPLAYTOGGLE       = 0x1af   # Turn display (LCD) on and off
+    KEY_SPELLCHECK          = 0x1b0   # AL Spell Check
+    KEY_LOGOFF              = 0x1b1   # AL Logoff
+
+    KEY_DOLLAR              = 0x1b2
+    KEY_EURO                = 0x1b3
+
+    KEY_FRAMEBACK           = 0x1b4   # Consumer - transport controls
+    KEY_FRAMEFORWARD        = 0x1b5
+    KEY_CONTEXT_MENU        = 0x1b6   # GenDesc - system context menu
+    KEY_MEDIA_REPEAT        = 0x1b7   # Consumer - transport control
+
+    KEY_DEL_EOL             = 0x1c0
+    KEY_DEL_EOS             = 0x1c1
+    KEY_INS_LINE            = 0x1c2
+    KEY_DEL_LINE            = 0x1c3
+
+    KEY_FN                  = 0x1d0
+    KEY_FN_ESC              = 0x1d1
+    KEY_FN_F1               = 0x1d2
+    KEY_FN_F2               = 0x1d3
+    KEY_FN_F3               = 0x1d4
+    KEY_FN_F4               = 0x1d5
+    KEY_FN_F5               = 0x1d6
+    KEY_FN_F6               = 0x1d7
+    KEY_FN_F7               = 0x1d8
+    KEY_FN_F8               = 0x1d9
+    KEY_FN_F9               = 0x1da
+    KEY_FN_F10              = 0x1db
+    KEY_FN_F11              = 0x1dc
+    KEY_FN_F12              = 0x1dd
+    KEY_FN_1                = 0x1de
+    KEY_FN_2                = 0x1df
+    KEY_FN_D                = 0x1e0
+    KEY_FN_E                = 0x1e1
+    KEY_FN_F                = 0x1e2
+    KEY_FN_S                = 0x1e3
+    KEY_FN_B                = 0x1e4
+
+    KEY_BRL_DOT1            = 0x1f1
+    KEY_BRL_DOT2            = 0x1f2
+    KEY_BRL_DOT3            = 0x1f3
+    KEY_BRL_DOT4            = 0x1f4
+    KEY_BRL_DOT5            = 0x1f5
+    KEY_BRL_DOT6            = 0x1f6
+    KEY_BRL_DOT7            = 0x1f7
+    KEY_BRL_DOT8            = 0x1f8
+    KEY_BRL_DOT9            = 0x1f9
+    KEY_BRL_DOT10           = 0x1fa
+
+    KEY_NUMERIC_0           = 0x200   # used by phones, remote controls,
+    KEY_NUMERIC_1           = 0x201   # and other keypads
+    KEY_NUMERIC_2           = 0x202
+    KEY_NUMERIC_3           = 0x203
+    KEY_NUMERIC_4           = 0x204
+    KEY_NUMERIC_5           = 0x205
+    KEY_NUMERIC_6           = 0x206
+    KEY_NUMERIC_7           = 0x207
+    KEY_NUMERIC_8           = 0x208
+    KEY_NUMERIC_9           = 0x209
+    KEY_NUMERIC_STAR        = 0x20a
+    KEY_NUMERIC_POUND       = 0x20b
+
+    # Relative axes
+
+    REL_X                   = 0x00
+    REL_Y                   = 0x01
+    REL_Z                   = 0x02
+    REL_RX                  = 0x03
+    REL_RY                  = 0x04
+    REL_RZ                  = 0x05
+    REL_HWHEEL              = 0x06
+    REL_DIAL                = 0x07
+    REL_WHEEL               = 0x08
+    REL_MISC                = 0x09
+    REL_MAX                 = 0x0f
+    REL_CNT                 = REL_MAX+1
+
+    # Absolute axes
+
+    ABS_X                   = 0x00
+    ABS_Y                   = 0x01
+    ABS_Z                   = 0x02
+    ABS_RX                  = 0x03
+    ABS_RY                  = 0x04
+    ABS_RZ                  = 0x05
+    ABS_THROTTLE            = 0x06
+    ABS_RUDDER              = 0x07
+    ABS_WHEEL               = 0x08
+    ABS_GAS                 = 0x09
+    ABS_BRAKE               = 0x0a
+    ABS_HAT0X               = 0x10
+    ABS_HAT0Y               = 0x11
+    ABS_HAT1X               = 0x12
+    ABS_HAT1Y               = 0x13
+    ABS_HAT2X               = 0x14
+    ABS_HAT2Y               = 0x15
+    ABS_HAT3X               = 0x16
+    ABS_HAT3Y               = 0x17
+    ABS_PRESSURE            = 0x18
+    ABS_DISTANCE            = 0x19
+    ABS_TILT_X              = 0x1a
+    ABS_TILT_Y              = 0x1b
+    ABS_TOOL_WIDTH          = 0x1c
+    ABS_VOLUME              = 0x20
+    ABS_MISC                = 0x28
+    ABS_MAX                 = 0x3f
+    ABS_CNT                 = ABS_MAX+1
+
+    # Switch events
+
+    SW_LID                  = 0x00  # set = lid shut
+    SW_TABLET_MODE          = 0x01  # set = tablet mode
+    SW_HEADPHONE_INSERT     = 0x02  # set = inserted
+    SW_RFKILL_ALL           = 0x03  # rfkill master switch, type "any"
+                                    # set = radio enabled
+    SW_RADIO                = SW_RFKILL_ALL   # deprecated
+    SW_MICROPHONE_INSERT    = 0x04  # set = inserted
+    SW_DOCK                 = 0x05  # set = plugged into dock
+    SW_MAX                  = 0x0f
+    SW_CNT                  = SW_MAX+1
+
+    # Misc events
+
+    MSC_SERIAL              = 0x00
+    MSC_PULSELED            = 0x01
+    MSC_GESTURE             = 0x02
+    MSC_RAW                 = 0x03
+    MSC_SCAN                = 0x04
+    MSC_MAX                 = 0x07
+    MSC_CNT                 = MSC_MAX+1
+
+    # LEDs
+
+    LED_NUML                = 0x00
+    LED_CAPSL               = 0x01
+    LED_SCROLLL             = 0x02
+    LED_COMPOSE             = 0x03
+    LED_KANA                = 0x04
+    LED_SLEEP               = 0x05
+    LED_SUSPEND             = 0x06
+    LED_MUTE                = 0x07
+    LED_MISC                = 0x08
+    LED_MAIL                = 0x09
+    LED_CHARGING            = 0x0a
+    LED_MAX                 = 0x0f
+    LED_CNT                 = LED_MAX+1
+
+    # Autorepeat values
+
+    REP_DELAY               = 0x00
+    REP_PERIOD              = 0x01
+    REP_MAX                 = 0x01

=== added file 'checkbox/lib/log.py'
--- checkbox/lib/log.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/log.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,77 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import inspect
+import logging
+
+from logging import StreamHandler, FileHandler, Formatter
+
+
+def format_class(cls):
+    return "%s.%s" % (cls.__module__, cls.__name__)
+
+def format_object(object, *args, **kwargs):
+    """
+    Returns a fully-qualified name for the specified object, such as
+    'checkbox.log.format_object()'.
+    """
+    args_string = ""
+    if args:
+        args_string += ", ".join(str(a) for a in args)
+        if kwargs:
+            args_string += ", "
+    if kwargs:
+        args_string += ", ".join(["%s=%s" % (k, v) for k, v in kwargs.iteritems()])
+
+    module = object.__module__ if object.__module__ else inspect.getfile(object)
+    if inspect.ismethod(object):
+        # FIXME If the method is implemented on a base class of
+        # object's class, the module name and function name will be
+        # from the base class and the method's class name will be from
+        # object's class.
+        name = repr(object).split(" ")[2]
+        return "%s %s(%s)" % (module, name, args_string)
+    elif inspect.isfunction(object):
+        name = repr(object).split(" ")[1]
+        return "%s %s(%s)" % (module, name, args_string)
+    return format_class(object.__class__)
+
+def format_delta(seconds):
+    if not seconds:
+        seconds = 0.0
+    return "%.02fs" % float(seconds)
+
+def set_logging(level, log=None):
+    log_level = logging.getLevelName(level.upper())
+    log_handlers = []
+    if log:
+        log_filename = log
+        log_handlers.append(FileHandler(log_filename))
+    else:
+        log_handlers.append(StreamHandler())
+
+    # Log setup
+    format = ("%(asctime)s %(levelname)-8s %(message)s")
+    if log_handlers:
+        for handler in log_handlers:
+            handler.setFormatter(Formatter(format))
+            logging.getLogger().addHandler(handler)
+        if log_level:
+            logging.getLogger().setLevel(log_level)
+    elif not logging.getLogger().handlers:
+        logging.disable(logging.CRITICAL)

=== added file 'checkbox/lib/path.py'
--- checkbox/lib/path.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/path.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,66 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import posixpath
+
+from glob import glob
+
+
+def path_split(path):
+    return path.split(posixpath.sep)
+
+def path_common(l1, l2, common=[]):
+    if len(l1) < 1:
+        return (common, l1, l2)
+
+    if len(l2) < 1:
+        return (common, l1, l2)
+
+    if l1[0] != l2[0]:
+        return (common, l1, l2)
+
+    return path_common(l1[1:], l2[1:], common + [l1[0]])
+
+def path_relative(p1, p2):
+    (common, l1, l2) = path_common(path_split(p1), path_split(p2))
+    p = []
+    if len(l1) > 0:
+        p = ["..%s" % posixpath.sep * len(l1)]
+
+    p = p + l2
+    return posixpath.join( *p )
+
+def path_expand(path):
+    path = posixpath.expanduser(path)
+    return glob(path)
+
+def path_expand_recursive(path):
+    paths = []
+    for path in path_expand(path):
+        if posixpath.isdir(path):
+            def walk_func(arg, directory, names):
+                for name in names:
+                    path = posixpath.join(directory, name)
+                    if not posixpath.isdir(path):
+                        arg.append(path)
+
+            posixpath.walk(path, walk_func, paths)
+        else:
+            paths.append(path)
+
+    return paths

=== added file 'checkbox/lib/pci.py'
--- checkbox/lib/pci.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/pci.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,86 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+
+# See http://pciids.sourceforge.net/pci.ids.bz2
+class Pci:
+
+    BASE_CLASS_STORAGE              = 1
+    CLASS_STORAGE_SCSI              = 0
+    CLASS_STORAGE_IDE               = 1
+    CLASS_STORAGE_FLOPPY            = 2
+    CLASS_STORAGE_IPI               = 3
+    CLASS_STORAGE_RAID              = 4
+    CLASS_STORAGE_OTHER             = 80
+
+    BASE_CLASS_NETWORK              = 2
+    CLASS_NETWORK_ETHERNET          = 0
+    CLASS_NETWORK_TOKEN_RING        = 1
+    CLASS_NETWORK_FDDI              = 2
+    CLASS_NETWORK_ATM               = 3
+    CLASS_NETWORK_OTHER             = 80
+    CLASS_NETWORK_WIRELESS          = 128
+
+    BASE_CLASS_DISPLAY              = 3
+    CLASS_DISPLAY_VGA               = 0
+    CLASS_DISPLAY_XGA               = 1
+    CLASS_DISPLAY_3D                = 2
+    CLASS_DISPLAY_OTHER             = 80
+
+    BASE_CLASS_MULTIMEDIA           = 4
+    CLASS_MULTIMEDIA_VIDEO          = 0
+    CLASS_MULTIMEDIA_AUDIO          = 1
+    CLASS_MULTIMEDIA_PHONE          = 2
+    CLASS_MULTIMEDIA_AUDIO_DEVICE   = 3
+    CLASS_MULTIMEDIA_OTHER          = 80
+
+    BASE_CLASS_BRIDGE               = 6
+    CLASS_BRIDGE_HOST               = 0
+    CLASS_BRIDGE_ISA                = 1
+    CLASS_BRIDGE_EISA               = 2
+    CLASS_BRIDGE_MC                 = 3
+    CLASS_BRIDGE_PCI                = 4
+    CLASS_BRIDGE_PCMCIA             = 5
+    CLASS_BRIDGE_NUBUS              = 6
+    CLASS_BRIDGE_CARDBUS            = 7
+    CLASS_BRIDGE_RACEWAY            = 8
+    CLASS_BRIDGE_OTHER              = 80
+
+    BASE_CLASS_COMMUNICATION        = 7
+    CLASS_COMMUNICATION_SERIAL      = 0
+    CLASS_COMMUNICATION_PARALLEL    = 1
+    CLASS_COMMUNICATION_MULTISERIAL = 2
+    CLASS_COMMUNICATION_MODEM       = 3
+    CLASS_COMMUNICATION_OTHER       = 80
+
+    BASE_CLASS_INPUT                = 9
+    CLASS_INPUT_KEYBOARD            = 0
+    CLASS_INPUT_PEN                 = 1
+    CLASS_INPUT_MOUSE               = 2
+    CLASS_INPUT_SCANNER             = 3
+    CLASS_INPUT_GAMEPORT            = 4
+    CLASS_INPUT_OTHER               = 80
+
+    BASE_CLASS_SERIAL               = 12
+    CLASS_SERIAL_FIREWIRE           = 0
+    CLASS_SERIAL_ACCESS             = 1
+
+    CLASS_SERIAL_SSA                = 2
+    CLASS_SERIAL_USB                = 3
+    CLASS_SERIAL_FIBER              = 4
+    CLASS_SERIAL_SMBUS              = 5

=== added file 'checkbox/lib/process.py'
--- checkbox/lib/process.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/process.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,139 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+from __future__ import absolute_import
+
+import os
+import time
+import fcntl
+import select
+import signal
+
+
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
+DEFAULT_OPEN_MAX = 1024
+
+
+class Process:
+    """Class representing a child process which is non blocking. This makes
+       it possible to return within a specified timeout."""
+
+    def __init__(self, cmd, env={}, bufsize=8192):
+        """The parameter 'cmd' is the shell command to execute in a
+        sub-process. If the 'bufsize' parameter is specified, it
+        specifies the size of the I/O buffers from the child process."""
+        self.cleaned=False
+        self.BUFSIZ=bufsize
+        self.outr, self.outw = os.pipe()
+        self.errr, self.errw = os.pipe()
+        self.pid = os.fork()
+        if self.pid == 0:
+            self._child(cmd, env)
+        os.close(self.outw) #parent doesn't write so close
+        os.close(self.errw)
+        # Note we could use self.stdout=fdopen(self.outr) here
+        # to get a higher level file object like popen2.Popen3 uses.
+        # This would have the advantages of auto handling the BUFSIZ
+        # and closing the files when deleted. However it would mean
+        # that it would block waiting for a full BUFSIZ unless we explicitly
+        # set the files non blocking, and there would be extra uneeded
+        # overhead like EOL conversion. So I think it's handier to use os.read()
+        self.outdata = self.errdata = ""
+        self.starttime = self.endtime = None
+        self._outeof = self._erreof = False
+
+    def _child(self, cmd, env):
+        # Force FD_CLOEXEC on all inherited descriptors
+        try:
+            open_max = os.sysconf('SC_OPEN_MAX')
+        except (AttributeError, ValueError):
+            open_max = DEFAULT_OPEN_MAX
+        for fileno in range(STDERR_FILENO+1, open_max):
+            try:
+                flags = fcntl.fcntl(fileno, fcntl.F_GETFD)
+            except IOError:
+                continue
+            flags |= fcntl.FD_CLOEXEC
+            fcntl.fcntl(fileno, fcntl.F_SETFD, flags)
+        # stdout and stderr to write side of pipe
+        os.dup2(self.outw, STDOUT_FILENO)
+        os.dup2(self.errw, STDERR_FILENO)
+        # stdout and stderr connected to pipe, so close all other files
+        map(os.close, [self.outr, self.outw, self.errr, self.errw])
+        try:
+            cmd = ["/bin/bash", "-c", cmd]
+            os.execve(cmd[0], cmd, env)
+        finally: #exit child on error
+            os._exit(1)
+
+    def read(self, timeout=None):
+        """return False when finished
+           else return True every timeout seconds
+           data will be in outdata and errdata"""
+        has_finished = True
+        self.starttime = time.time()
+        while True:
+            tocheck=[]
+            if not self._outeof:
+                tocheck.append(self.outr)
+            if not self._erreof:
+                tocheck.append(self.errr)
+            ready = select.select(tocheck, [], [], timeout)
+            if not len(ready[0]): # no data timeout
+                has_finished = False
+                break
+            else:
+                if self.outr in ready[0]:
+                    outchunk = os.read(self.outr, self.BUFSIZ)
+                    if outchunk == "":
+                        self._outeof = True
+                    self.outdata += outchunk
+                if self.errr in ready[0]:
+                    errchunk = os.read(self.errr, self.BUFSIZ)
+                    if errchunk == "":
+                        self._erreof = True
+                    self.errdata += errchunk
+                if self._outeof and self._erreof:
+                    break
+                elif timeout:
+                    if (time.time() - self.starttime) > timeout:
+                        has_finished = False
+                        break # may be more data but time to go
+
+        self.endtime = time.time()
+        return has_finished
+
+    def kill(self):
+        os.kill(self.pid, signal.SIGTERM)
+
+    def cleanup(self):
+        """Wait for and return the exit status of the child process."""
+        self.cleaned = True
+        os.close(self.outr)
+        os.close(self.errr)
+        pid, status = os.waitpid(self.pid, 0)
+        if pid == self.pid:
+            self.status = status
+        return self.status
+
+    def __del__(self):
+        if not self.cleaned:
+            self.cleanup()

=== added file 'checkbox/lib/redirect.py'
--- checkbox/lib/redirect.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/redirect.py	2012-03-28 20:34:20 +0000
@@ -0,0 +1,158 @@
+#
+# This file is part of Checkbox.
+#
+# Copyright 2008 Canonical Ltd.
+#
+# 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/>.
+#
+import os
+import sys
+import tempfile
+
+
+def _file_write(file):
+    # file is a filename, a pipe-command, a fileno(), or a file
+    # returns file.
+    if not hasattr(file, "write"):
+        if file[0] == "|":
+            file = os.popen(file[1:], "w")
+        else:
+            file = open(file, "w")
+
+    return file
+
+def _file_read(file):
+    # file is a filename, a pipe-command, or a file
+    # returns file.
+    if not hasattr(file, "read"):
+        if file[-1] == "|":
+            file = os.popen(file[1:], "r")
+        else:
+            file = open(file, "r")
+
+    return file
+
+def redirect_to_file(file, func, *args):
+    # apply func(args), temporarily redirecting stdout to file.
+    # file can be a file or any writable object, or a filename string.
+    # a "|cmd" string will pipe output to cmd.
+    # Returns value of apply(func, *args)
+    ret = None
+    file = _file_write(file)
+    sys.stdout, file = file, sys.stdout
+    try:
+        ret = apply(func, args)
+    finally:
+        print ret
+        sys.stdout, file = file, sys.stdout
+    return ret
+