Merge lp:~udienz/ubuntu/natty/checkbox/checkbox.fix.514401 into lp:checkbox

[Michael Terry]

Solved
 * LP: #514401
   Translations are not loaded for the test descriptions in Checkbox
 * LP: #525454
   translation line 338: "Screen" should be "The screen"

Unmerged revisions

21. By Mahyuddin Susanto on 2010-12-16

* Fixed several strings appear in English although translated (LP: #514401)
  + jobs/fingerprint.txt.in
  + jobs/media.txt.in
  + jobs/monitor.txt.in
  + jobs/sleep.txt.in
  + po/checkbox.pot
* Fixed grammar (LP: #525454)
  + jobs/fingerprint.txt.in
* Removing directory produced from building
  - build

20. By Matthias Klose on 2010-12-15

Hack to work around internals of ConfigParser in python2.7. LP: #689140.

19. By Marc Tardif on 2010-09-14

New upstream release (LP: #638333):
* Fixed verification of SSL validity (LP: #625076)
* Improved audio test questions.

18. By Marc Tardif on 2010-08-13

New upstream release (LP: #617583):
* Fixed sleep_test to check the connection if using network-manager.
* Fixed reporting bugs against alsa-base and xorg (LP: #607214)
* Fixed apport dialog no longer appearing (LP: #607217)
* Reduced data file size for the desktop image.
* Updated report to be more pretty.

17. By Marc Tardif on 2010-06-22

New upstream release (LP: #597295):
* Added support for urwid interface.
* Added sound check test.
* Added document viewer test.
* Added update-manager and nautilus tests.
* Added resolution tests.
* Added sleep tests.

16. By Marc Tardif on 2010-04-06

New upstream release (LP: #585132):
* Added media tests (LP: #397944)
* Added support for comments in templates.
* Added referer when sending submissions to Launchpad (LP: #550973)
* Added suggests to checkbox package in debian/control file (LP: #352740)
* Fixed udev_resource script to be more resilient (LP: #556824)
* Fixed cdimage_resource script to read casper.log (LP: #558728)
* Fixed reporting all resources found for a job (LP: #560948)
* Fixed stalling when using kdesudo to start backend (LP: #557443)
* Fixed starting the appropriate default browser on UNR (LP: #563050)
* Fixed ansi_parser script when outputting to stdout (LP: #560952)
* Fixed opening the report with the gconf preferred browser (LP: #562580)
* Fixed suspend_test to use relative time for wakealarm (LP: #349768)
* Fixed backend not getting terminated upon closing (LP: #553328)

15. By Marc Tardif on 2010-03-07

New upstream release (LP: #548800):
* Added cpu_scaling_test script.
* Fixed hard drive detection (LP: #549714)
* Fixed backend to handle empty messages (LP: #536645)
* Fixed parsing of package resource (LP: #539691)
* Fixed malformed xml report (LP: #485445)
* Fixed running root manual tests as normal user (LP: #383559)
* Fixed writing apport files only after submitting (LP: #530380)
* Fixed audio test instructions (LP: #529205)
* Fixed gathering chassis information (LP: #537435)
* Fixed detection of disks in kvm (LP: #552998)
* Fixed udev_resource script to be more resilient (LP: #552999)
* Fixed filter_packages script to use new resources.

14. By Mathias Gug on 2010-03-09

[ Marc Tardif ]
New upstream release (LP: #532882):
* Introduced job_prompt plugin to treat all jobs (suites, tests, etc.) as composites.
* Replaced the registry and resource scripts and centralized job iteration.
* Replaced dependency on dbus by using sudo/gksu/kdesudo instead.
* Replaced mktemp with mkdtemp for security purposes.
* Fixed strings in fingerprint and modem tests (LP: #457759)
* Fixed client side validation of Launchpad form (LP: #438671)
* Added device information to tags when reporting bugs with apport.
* Added shorthands for blacklist-file and whitelist-file.
* Added support for apport default configuration (LP: #465447)
* Added support for scrolled options list (LP: #411526)
* Added support for tests generated by suites to run as root.
* Added support for requirements in attachments.
* Added support for armv7l processor
* Added Autotest integration
* Added LTP integration
* Added Phoronix integration
* Added qa-regression-testing integration

13. By Marc Tardif on 2009-11-04

Added support for apport default configuration (LP: #465447)

12. By Marc Tardif on 2009-10-26

* Fixed translation of suites and tests files (LP: #456115)
* Fixed checking the status of command registries (LP: #457502)
* Fixed selecting suites in the command line (LP: #457559)
* Fixed reporting of bugs to contain test description (LP: #427932)
* Fixed execute permissions on scripts (LP: #459606)
* Renamed processors_info plugin to singular because processor
  information is reported as a single structure with a count attribute
* Updated translation files.

=== added directory '.bzr-builddeb'
=== renamed directory '.bzr-builddeb' => '.bzr-builddeb.moved'
=== added file '.bzr-builddeb/default.conf'
--- .bzr-builddeb/default.conf	1970-01-01 00:00:00 +0000
+++ .bzr-builddeb/default.conf	2010-12-22 15:36:34 +0000
@@ -0,0 +1,2 @@
+[BUILDDEB]
+native = True

=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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

=== renamed file 'README' => 'README.moved'
=== added directory 'apport'
=== renamed directory 'apport' => 'apport.moved'
=== added file 'apport/checkbox.py'
--- apport/checkbox.py	1970-01-01 00:00:00 +0000
+++ apport/checkbox.py	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,17 @@
+'''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)

=== added file 'backend'
--- backend	1970-01-01 00:00:00 +0000
+++ backend	2010-12-22 15:36:34 +0000
@@ -0,0 +1,46 @@
+#!/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 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:]))

=== renamed file 'backend' => 'backend.moved'
=== added directory 'bin'
=== renamed directory 'bin' => 'bin.moved'
=== added file 'bin/checkbox-cli'
--- bin/checkbox-cli	1970-01-01 00:00:00 +0000
+++ bin/checkbox-cli	2010-12-22 15:36:34 +0000
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
+export CHECKBOX_DATA=${CHECKBOX_DATA:-.}
+export CHECKBOX_SHARE=${CHECKBOX_SHARE:-.}
+export CHECKBOX_OPTIONS="--log-level=debug --log=$CHECKBOX_DATA/checkbox.log"
+export PYTHONPATH=$PYTHONPATH:$CHECKBOX_SHARE
+
+if [ $CHECKBOX_DATA != '.' ]
+then
+    old_data=$HOME/.checkbox
+    if [ -d $old_data ] && [ ! -d $CHECKBOX_DATA ]
+    then
+        mv -f $old_data $CHECKBOX_DATA
+    fi
+fi
+
+python $CHECKBOX_SHARE/run "$@" $CHECKBOX_SHARE/configs/$(basename $0).ini

=== added file 'bin/checkbox-gtk'
--- bin/checkbox-gtk	1970-01-01 00:00:00 +0000
+++ bin/checkbox-gtk	2010-12-22 15:36:34 +0000
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
+export CHECKBOX_DATA=${CHECKBOX_DATA:-.}
+export CHECKBOX_SHARE=${CHECKBOX_SHARE:-.}
+export CHECKBOX_OPTIONS="--log-level=debug --log=$CHECKBOX_DATA/checkbox.log"
+export PYTHONPATH=$PYTHONPATH:$CHECKBOX_SHARE
+
+if [ $CHECKBOX_DATA != '.' ]
+then
+    old_data=$HOME/.checkbox
+    if [ -d $old_data ] && [ ! -d $CHECKBOX_DATA ]
+    then
+        mv -f $old_data $CHECKBOX_DATA
+    fi
+fi
+
+python $CHECKBOX_SHARE/run "$@" $CHECKBOX_SHARE/configs/$(basename $0).ini

=== added file 'bin/checkbox-urwid'
--- bin/checkbox-urwid	1970-01-01 00:00:00 +0000
+++ bin/checkbox-urwid	2010-12-22 15:36:34 +0000
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
+export CHECKBOX_DATA=${CHECKBOX_DATA:-.}
+export CHECKBOX_SHARE=${CHECKBOX_SHARE:-.}
+export CHECKBOX_OPTIONS="--log-level=debug --log=$CHECKBOX_DATA/checkbox.log"
+export PYTHONPATH=$PYTHONPATH:$CHECKBOX_SHARE
+
+if [ $CHECKBOX_DATA != '.' ]
+then
+    old_data=$HOME/.checkbox
+    if [ -d $old_data ] && [ ! -d $CHECKBOX_DATA ]
+    then
+        mv -f $old_data $CHECKBOX_DATA
+    fi
+fi
+
+python $CHECKBOX_SHARE/run "$@" $CHECKBOX_SHARE/configs/$(basename $0).ini

=== added directory 'checkbox'
=== renamed directory 'checkbox' => 'checkbox.moved'
=== added file 'checkbox/__init__.py'
=== added file 'checkbox/application.py'
--- checkbox/application.py	1970-01-01 00:00:00 +0000
+++ checkbox/application.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,133 @@
+#
+# 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 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_level = "critical"
+
+    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",
+                          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=checkbox/plugins/jobs_info/blacklist."))
+        parser.add_option("-B", "--blacklist-file",
+                          help=_("Shorthand for --config=checkbox/plugins/jobs_info/blacklist_file."))
+        parser.add_option("-w", "--whitelist",
+                          help=_("Shorthand for --config=checkbox/plugins/jobs_info/whitelist."))
+        parser.add_option("-W", "--whitelist-file",
+                          help=_("Shorthand for --config=checkbox/plugins/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 = "checkbox/plugins/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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,542 @@
+# 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
+
+
+__all__ = ["Persist", "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:
+                raise PersistError("Need a filename!")
+            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):
+        raise NotImplementedError
+
+    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 PickleBackend(Backend):
+
+    def __init__(self):
+        import cPickle
+        self._pickle = cPickle
+
+    def new(self):
+        return {}
+
+    def load(self, filepath):
+        file = open(filepath)
+        try:
+            return self._pickle.load(file)
+        finally:
+            file.close()
+
+    def save(self, filepath, map):
+        file = open(filepath, "w")
+        try:
+            self._pickle.dump(map, file, 2)
+        finally:
+            file.close()
+
+
+class BPickleBackend(Backend):
+
+    def __init__(self):
+        from checkbox.contrib import bpickle
+        self._bpickle = bpickle
+
+    def new(self):
+        return {}
+
+    def load(self, filepath):
+        file = open(filepath)
+        try:
+            return self._bpickle.loads(file.read())
+        finally:
+            file.close()
+
+    def save(self, filepath, map):
+        file = open(filepath, "w")
+        try:
+            file.write(self._bpickle.dumps(map))
+        finally:
+            file.close()

=== added file 'checkbox/job.py'
--- checkbox/job.py	1970-01-01 00:00:00 +0000
+++ checkbox/job.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,131 @@
+#
+# 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]
+
+
+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
+
+    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(suite=job.get("suite")):
+                    message = self._read_message(filename)
+                    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)
+            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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,42 @@
+#
+# 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 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_per_long = 8 * 8
+    offset = bit % bits_per_long
+    long = int(bit / bits_per_long)
+    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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,156 @@
+#
+# 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
+import types
+
+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():
+            super(IncludeDict, self).__setitem__(key.lower(), value)
+
+    def __setitem__(self, key, value):
+        if key == "includes":
+            if type(value) == types.ListType:
+                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 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 = attributes
+
+    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):
+        return os.environ.get(name.upper()) \
+            or os.environ.get(name.lower()) \
+            or super(ConfigDefaults, self).get(name)
+
+
+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()
+            if not self._parser.has_section(name):
+                self._parser.add_section(name)
+
+            self._parser.set(name, 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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,80 @@
+#
+# 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
+
+
+def string_to_type(value):
+    conversion_table = (
+        ("(yes|true)", lambda v: True),
+        ("(no|false)", lambda v: False),
+        ("\d+", lambda v: int(v.group(0))),
+        ("\d+\.\d+", lambda v: float(v.group(0))),
+        ("(\d+) ?([kmgt]?b?)", lambda v: int(v.group(1))),
+        ("(\d+\.\d+) ?([kmgt]?b?)", lambda v: float(v.group(1))),
+        ("(\d+) ?([kmgt]?hz?)", lambda v: int(v.group(1))),
+        ("(\d+\.\d+) ?([kmgt]?hz?)", lambda v: float(v.group(1))))
+
+    multiplier_table = (
+        ("b", 1),
+        ("kb?", 1024),
+        ("mb?", 1024 * 1024),
+        ("gb?", 1024 * 1024 * 1024),
+        ("tb?", 1024 * 1024 * 1024 * 1024),
+        ("hz", 1),
+        ("khz?", 1024),
+        ("mhz?", 1024 * 1024),
+        ("ghz?", 1024 * 1024 * 1024),
+        ("thz?", 1024 * 1024 * 1024 * 1024))
+
+    if isinstance(value, basestring):
+        for regex, conversion in conversion_table:
+            match = re.match("^%s$" % regex, value, re.IGNORECASE)
+            if match:
+                value = conversion(match)
+                if len(match.groups()) < 2:
+                    return value
+
+                unit = match.group(2)
+                for regex, multiplier in multiplier_table:
+                    match = re.match("^%s$" % regex, unit, re.IGNORECASE)
+                    if match:
+                        value *= multiplier
+                        return value
+                else:
+                    raise Exception, "Unknown multiplier: %s" % unit
+
+    return value
+
+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

=== added file 'checkbox/lib/decorator.py'
--- checkbox/lib/decorator.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/decorator.py	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,74 @@
+#
+# 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 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 = [c[0] for c in chassis]
+    chassis_types = [c[1] for c in chassis]
+    chassis_name_to_type = dict(chassis)
+
+
+class DmiNotAvailable(object):
+    def __init__(self, function):
+        self._function = function
+
+    def __get__(self, instance, cls=None):
+        self._instance = instance
+        return self
+
+    def __call__(self, *args, **kwargs):
+        name = self._function(self._instance, *args, **kwargs)
+        if name == "Not Available":
+            name = None
+
+        return name

=== added file 'checkbox/lib/environ.py'
--- checkbox/lib/environ.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/environ.py	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,80 @@
+#
+# 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
+
+
+class FifoBase(object):
+
+    mode = None
+
+    def __init__(self, path):
+        self.path = path
+        self.file = open(path, self.mode)
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        self.file.close()
+
+
+class FifoReader(FifoBase):
+
+    mode = "r"
+
+    def read_string(self):
+        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):
+
+    mode = "w"
+
+    def write_string(self, string):
+        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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,68 @@
+#
+# 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):
+    """
+    Returns a fully-qualified name for the specified object, such as
+    'checkbox.log.format_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()" % (object.__module__, name)
+    elif inspect.isfunction(object):
+        name = repr(object).split(" ")[1]
+        return "%s.%s()" % (object.__module__, name)
+    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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +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	2010-12-22 15:36:34 +0000
@@ -0,0 +1,137 @@
+#
+# 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 time
+import fcntl
+import select
+
+
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
+
+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):
+        # Note sh below doesn't setup a seperate group (job control)
+        # for non interactive shells (hmm maybe -m option does?)
+        os.setpgrp() #seperate group so we can kill it
+        # Force FD_CLOEXEC on all inherited descriptors
+        try:
+            open_max = os.sysconf('SC_OPEN_MAX')
+        except (AttributeError, ValueError):
+            open_max = 1024
+        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/sh", "-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, 15) # SIGTERM whole group
+
+    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	2010-12-22 15:36:34 +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
+
+def redirect_to_string(func, *args):
+    # apply func(*args) with stdout redirected to return string.
+    file = tempfile.TemporaryFile()
+    apply(redirect_to_file, (file, func) + args)
+    file.seek(0)
+    return file.read()
+
+def redirect_to_lines(func, *args):
+    # apply func(*args), returning a list of redirected stdout lines.
+    file = tempfile.TemporaryFile()
+    apply(redirect_to_file, (file, func) + args)
+    file.seek(0)
+    return file.readlines()
+
+
+class RedirectTee(object):
+
+    def __init__(self, *optargs):
+        self._files = []
+        for arg in optargs:
+            self.addfile(arg)
+
+    def addfile(self, file):
+        self._files.append(_file_write(file))
+
+    def remfile(self, file):
+        file.flush()
+        self._files.remove(file)
+
+    def files(self):
+        return self._files
+
+    def write(self, what):
+        for eachfile in self._files:
+            eachfile.write(what)
+
+    def writelines(self, lines):
+        for eachline in lines: self.write(eachline)
+
+    def flush(self):
+        for eachfile in self._files:
+            eachfile.flush()
+
+    def close(self):
+        for eachfile in self._files:
+            self.remfile(eachfile)  # Don't CLOSE the real files.
+
+    def CLOSE(self):
+        for eachfile in self._files:
+            self.remfile(eachfile)
+            self.eachfile.close()
+
+    def isatty(self):
+        return 0
+
+
+class RedirectEcho(object):
+
+    def __init__(self, input, *output):
+        self._infile = _file_read(input)
+        if output:
+            self._output = _file_write(output[0])
+        else:
+            self._output = None
+
+    def read(self, *howmuch):
+        stuff = apply(self._infile.read, howmuch)
+        if self._output:
+            self._output.write(stuff)
+        return stuff
+
+    def readline(self):
+        line = self._infile.readline()
+        self._output.write(line)
+        return line
+
+    def readlines(self):
+        out = []
+        while True:
+            out.append(self.readline())
+            if not out[-1]:
+                return out[:-1]
+
+    def flush(self):
+        self._output.flush()
+
+    def seek(self, where, how):
+        self._infile.seek(where, how)
+
+    def tell(self):
+        return self._infile.tell()
+
+    def isatty(self):
+        return self._infile.isatty()
+
+    def close(self):
+        self._infile.close()
+        self._output.close()

=== added file 'checkbox/lib/resolver.py'
--- checkbox/lib/resolver.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/resolver.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,126 @@
+#
+# 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 Resolver:
+    """
+    Main class. Instantiate with the root directory of your items.
+    """
+
+    def __init__(self, compare=None, key=None):
+        if compare is None:
+            compare = lambda a, b: cmp(a, b)
+        if key is None:
+            key = lambda k: k
+
+        self.compare = compare
+        self.key = key
+
+        # detect repeated resolution attempts - these indicate some circular dependency
+        self.reentrant_resolution = set()
+
+        # collect all items
+        self.items = {}
+
+        # for each item, keep a set of dependents and dependencies
+        self.dependents = {}
+        self.dependencies = {}
+
+    def add(self, item, *dependencies):
+        key = self.key(item)
+        if key in self.items:
+            raise Exception, "%s: key already exists" % key
+        self.items[key] = item
+
+        dependency_keys = [self.key(d) for d in dependencies]
+        self.dependencies[key] = set(dependency_keys)
+
+    def remove(self, item):
+        key = self.key(item)
+        del self.items[key]
+        del self.dependencies[key]
+
+    def resolve(self, item, found=None):
+        """
+        the center piece.
+        recursively resolve dependencies of scripts
+        return them as a flat list, sorted according to ancestral relationships
+        """
+        key = self.key(item)
+        resolved = self.dependents.get(key, None)
+        if resolved is not None:
+            return resolved
+
+        if key not in self.items:
+            msg = "no dependencies found for %s" % key
+            if found:
+                msg += " while resolving %s" % found
+            raise Exception, msg
+
+        dependencies = self.dependencies.get(key, set())
+        resolved = set()
+
+        for dependency in dependencies:
+            resolution_step = (key, dependency)
+            if resolution_step in self.reentrant_resolution:
+                if found:
+                    scapegoat = found
+                else:
+                    scapegoat = dependency
+                raise Exception, "circular dependency involving %s and %s" % (key, scapegoat)
+            # add resolution
+            self.reentrant_resolution.add(resolution_step)
+            # and its dependencies, if any
+            resolved.update(self.resolve(self.items[dependency], found=key))
+
+        # now it's time for sorting hierarchically... Since circular dependencies are excluded,
+        # ancestors will always have fewer dependencies than descendants, so sorting by the
+        # number of dependencies will give the desired order.
+        resolved = sorted(resolved, key=lambda x : len(self.dependents[x]))
+        resolved.append(key)
+        self.dependents[key] = resolved
+
+        return resolved
+
+    def get_dependencies(self, item):
+        return [self.items[r] for r in self.resolve(item)]
+
+    def get_dependents(self, item=None):
+        dependents = []
+        if item:
+            # Immediate dependents
+            key = self.key(item)
+            all_dependents = filter(
+                lambda x: key in self.resolve(x)[:-1],
+                self.items.itervalues())
+            dependents = filter(
+                lambda x: self.key(self.get_dependencies(x)[-2]) == key,
+                all_dependents)
+        else:
+            # First level of dependents
+            dependents = filter(lambda x: len(self.resolve(x)) == 1, self.items.itervalues())
+
+        index = 0
+        dependents = sorted(dependents, self.compare)
+        while index < len(dependents):
+            sub_dependents = self.get_dependents(dependents[index])
+            if sub_dependents:
+                dependents[index+1:index+1] = sub_dependents
+                index += len(sub_dependents)
+            index += 1
+
+        return dependents

=== added file 'checkbox/lib/safe.py'
--- checkbox/lib/safe.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/safe.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,96 @@
+#
+# 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
+import shutil
+
+from stat import ST_MODE, S_IMODE, S_ISFIFO
+
+
+def safe_change_mode(path, mode):
+    if not posixpath.exists(path):
+        raise Exception, "Path does not exist: %s" % path
+
+    old_mode = os.stat(path)[ST_MODE]
+    if mode != S_IMODE(old_mode):
+        os.chmod(path, mode)
+
+def safe_make_directory(path, mode=0755):
+    if posixpath.exists(path):
+        if not posixpath.isdir(path):
+            raise Exception, "Path is not a directory: %s" % path
+    else:
+        os.makedirs(path, mode)
+
+def safe_make_fifo(path, mode=0666):
+    if posixpath.exists(path):
+        mode = os.stat(path)[ST_MODE]
+        if not S_ISFIFO(mode):
+            raise Exception, "Path is not a FIFO: %s" % path
+    else:
+        os.mkfifo(path, mode)
+
+def safe_remove_directory(path):
+    if posixpath.exists(path):
+        if not posixpath.isdir(path):
+            raise Exception, "Path is not a directory: %s" % path
+
+        shutil.rmtree(path)
+
+def safe_remove_file(path):
+    if posixpath.exists(path):
+        if not posixpath.isfile(path):
+            raise Exception, "Path is not a file: %s" % path
+
+        os.remove(path)
+
+def safe_rename(old, new):
+    if old != new:
+        if not posixpath.exists(old):
+            raise Exception, "Old path does not exist: %s" % old
+        if posixpath.exists(new):
+            raise Exception, "New path exists already: %s" % new
+
+        os.rename(old, new)
+
+def safe_md5sum():
+    try:
+        import hashlib
+        digest = hashlib.md5()
+    except ImportError:
+        # for Python << 2.5
+        import md5
+        digest = md5.new()
+
+    return digest
+
+def safe_md5sum_file(name):
+    md5sum = None
+    if posixpath.exists(name):
+        file = open(name)
+        digest = safe_md5sum()
+        while 1:
+            buf = file.read(4096)
+            if buf == "":
+                break
+            digest.update(buf)
+        file.close()
+        md5sum = digest.hexdigest()
+
+    return md5sum

=== added file 'checkbox/lib/script.py'
--- checkbox/lib/script.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/script.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,33 @@
+#
+# 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 checkbox.lib.environ import get_path
+
+
+def get_globals(script):
+    path = posixpath.expanduser(script)
+    if not posixpath.exists(path):
+        path = get_path(script)
+        if not path:
+            raise Exception, "Script not found in PATH: %s" % script
+
+    globals = {}
+    execfile(path, globals)
+    return globals

=== added file 'checkbox/lib/signal.py'
--- checkbox/lib/signal.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/signal.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,89 @@
+#
+# 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 gettext import gettext as _
+
+
+signal_description_table = {
+    "SIGHUP":  _("Hangup detected on controlling terminal or death of controlling process"),
+    "SIGINT":  _("Interrupt from keyboard"),
+    "SIGQUIT": _("Quit from keyboard"),
+    "SIGILL":  _("Illegal Instruction"),
+    "SIGABRT": _("Abort signal from abort(3)"),
+    "SIGFPE":  _("Floating point exception"),
+    "SIGKILL": _("Kill signal"),
+    "SIGSEGV": _("Invalid memory reference"),
+    "SIGPIPE": _("Broken pipe: write to pipe with no readers"),
+    "SIGALRM": _("Timer signal from alarm(2)"),
+    "SIGTERM": _("Termination signal"),
+    "SIGUSR1": _("User-defined signal 1"),
+    "SIGUSR2": _("User-defined signal 2"),
+    "SIGCHLD": _("Child stopped or terminated"),
+    "SIGCONT": _("Continue if stopped"),
+    "SIGSTOP": _("Stop process"),
+    "SIGTSTP": _("Stop typed at tty"),
+    "SIGTTIN": _("tty input for background process"),
+    "SIGTTOU": _("tty output for background process")}
+
+signal_name_table = {
+    1: "SIGHUP",
+    2: "SIGINT",
+    3: "SIGQUIT",
+    4: "SIGILL",
+    6: "SIGABRT",
+    8: "SIGFPE",
+    9: "SIGKILL",
+    10: "SIGUSR1",
+    11: "SIGSEGV",
+    12: "SIGUSR2",
+    13: "SIGPIPE",
+    14: "SIGALRM",
+    15: "SIGTERM",
+    16: "SIGUSR1",
+    21: "SIGTTIN",
+    22: "SIGTTOU",
+    23: "SIGSTOP",
+    24: "SIGTSTP",
+    25: "SIGCONT",
+    26: "SIGTTIN",
+    27: "SIGTTOU",
+    30: "SIGUSR1",
+    31: "SIGUSR2"}
+
+def signal_to_name(signal):
+    """Convert a signal number to its string representation.
+
+    Keyword arguments:
+    signal -- number of the signal as returned by wait
+    """
+
+    if signal_name_table.has_key(signal):
+        return signal_name_table[signal]
+    return _("UNKNOWN")
+
+def signal_to_description(signal):
+    """Convert a signal number to its corresponding description.
+
+    Keyword arguments:
+    signal -- number of the signal as returned by wait
+    """
+
+    name = signal_to_name(signal)
+    if signal_description_table.has_key(name):
+        return signal_description_table[name]
+    return _("Unknown signal")

=== added file 'checkbox/lib/template.py'
--- checkbox/lib/template.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/template.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,144 @@
+#
+# 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
+import logging
+
+
+EXTENDED_STRING = "_extended"
+
+
+class Template(object):
+
+    def _reader(self, file, size=4096, delimiter=r"\n{2,}"):
+        buffer_old = ""
+        while True:
+            buffer_new = file.read(size)
+            if not buffer_new:
+                break
+
+            lines = re.split(delimiter, buffer_old + buffer_new)
+            buffer_old = lines.pop(-1)
+
+            for line in lines:
+                yield line
+
+        yield buffer_old
+
+    def dump_file(self, elements, file, filename="<stream>"):
+        for element in elements:
+            for long_key in element.keys():
+                if long_key.endswith(EXTENDED_STRING):
+                    short_key = long_key.replace(EXTENDED_STRING, "")
+                    del element[short_key]
+
+            for key, value in element.items():
+                if key.endswith(EXTENDED_STRING):
+                    key = key.replace(EXTENDED_STRING, "")
+                    file.write("%s:\n" % key)
+                    for line in value.split("\n"):
+                        file.write(" %s\n" % line)
+                elif isinstance(value, (list, tuple)):
+                    file.write("%s:\n" % key)
+                    for v in value:
+                        file.write(" %s\n" % v)
+                else:
+                    file.write("%s: %s\n" % (key, value))
+
+            file.write("\n")
+
+    def dump_filename(self, elements, filename):
+        logging.info("Dumping elements to filename: %s", filename)
+
+        file = open(filename, "w")
+        return self.dump_file(elements, file, filename)
+
+    def load_file(self, file, filename="<stream>"):
+        elements = []
+        for string in self._reader(file):
+            if not string:
+                break
+
+            element = {}
+
+            def _save(field, value, extended):
+                extended = extended.rstrip("\n")
+                if field:
+                    if element.has_key(field):
+                        raise Exception, \
+                            "Template %s has a duplicate field '%s'" \
+                            " with a new value '%s'." \
+                                % (filename, field, value)
+                    element[field] = value
+                    if extended:
+                        element["%s%s" % (field, EXTENDED_STRING)] = extended
+
+            string = string.strip("\n")
+            field = value = extended = ""
+            for line in string.split("\n"):
+                line.strip()
+                if line.startswith("#"):
+                    continue
+
+                match = re.search(r"^([-_.A-Za-z0-9]*):\s?(.*)", line)
+                if match:
+                    _save(field, value, extended)
+                    field = match.groups()[0].lower()
+                    value = match.groups()[1].rstrip()
+                    extended = ""
+                    continue
+
+                if re.search(r"^\s\.$", line):
+                    extended += "\n\n"
+                    continue
+
+                match = re.search(r"^\s(\s+.*)", line)
+                if match:
+                    bit = match.groups()[0].rstrip()
+                    if len(extended) and not re.search(r"[\n ]$", extended):
+                        extended += "\n"
+
+                    extended += bit + "\n"
+                    continue
+
+                match = re.search(r"^\s(.*)", line)
+                if match:
+                    bit = match.groups()[0].rstrip()
+                    if len(extended) and not re.search(r"[\n ]$", extended):
+                        if extended.endswith("\\"):
+                            extended = extended[:-1].rstrip() + " "
+                        else:
+                            extended += "\n"
+
+                    extended += bit
+                    continue
+
+                raise Exception, "Template %s parse error at: %s" \
+                    % (filename, line)
+
+            _save(field, value, extended)
+
+            elements.append(element)
+
+        return elements
+
+    def load_filename(self, filename):
+        logging.info("Loading elements from filename: %s", filename)
+
+        file = open(filename, "r")
+        return self.load_file(file, filename)

=== added file 'checkbox/lib/template_i18n.py'
--- checkbox/lib/template_i18n.py	1970-01-01 00:00:00 +0000
+++ checkbox/lib/template_i18n.py	2010-12-22 15:36:34 +0000
@@ -0,0 +1,133 @@
+#
+# 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
+import locale
+
+from os import environ
+from gettext import gettext as _
+
+from checkbox.lib.template import Template
+
+