Merge lp:~paul-mcspadden/computer-janitor/bug-726616 into lp:computer-janitor

[Paul McSpadden]

NEWS: fixed a typo. (LP: #726616)

[Barry Warsaw (barry)]

Thanks for following along in the UDD class on irc. It was my fault but your original branch should have been against ubuntu:computer-janitor instead of lp:computer-janitor.

review: Disapprove

Unmerged revisions

21. By Paul McSpadden on 2011-02-28

NEWS: fixed a typo. (LP: #726616)

20. By Colin Watson on 2011-01-20

merge lp:~barry/ubuntu/maverick/computer-janitor/bug-665740

19. By Barry Warsaw on 2010-09-20

Fix icon; given by Pavol Klačanský. (LP: #434431)

18. By Barry Warsaw on 2010-08-24

Remove dependency on python-fstab since the fstab_plugin is disabled
now and no package provides python-fstab any more.

17. By Barry Warsaw on 2010-08-24

* Fixes for translation support.
  - Turn {foo} string substitutions back into %(foo)s strings since
    gettext does not yet support validation of {foo} or $foo
    substitutions. (LP: #621723)
  - Ensure that POTFILES.in has the proper type information for the
    ComputerJanitor.ui file. (LP: #612493)

16. By Anders Kaseorg on 2010-07-27

Drop unused dependency on python-fstab, which was removed from squeeze
and maverick. (The fstab plugin that uses it is no longer installed.)
(LP: #610619)

15. By Michael Vogt on 2010-05-27

no change rebuild to generate proper orig.tar.gz

14. By Barry Warsaw on 2010-05-21

Bumping for Ubuntu.

13. By Michael Vogt on 2010-03-12

[ David Planella ]
* Removed obsolete template
* marked .ui file for string extraction, Thanks to Gabor Kelemen

[ Barry Warsaw ]
* remove recommended column (LP: #536908)

12. By Michael Vogt on 2010-01-21

* computerjanitorapp/ui_gtk.py:
  - fix find_and_bind_widgets (LP: #503727)

=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2011-02-28 18:58:01 +0000
@@ -0,0 +1,676 @@
+
+		    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 'CoverageTestRunner.py'
--- CoverageTestRunner.py	1970-01-01 00:00:00 +0000
+++ CoverageTestRunner.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,203 @@
+# Copyright (C) 2007  Lars Wirzenius <[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.
+#
+# 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, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+
+import coverage
+import unittest
+import optparse
+import os
+import imp
+import sys
+import time
+
+
+class CoverageTestResult(unittest.TestResult):
+
+    def __init__(self, output, total):
+        unittest.TestResult.__init__(self)
+        self.output = output
+        self.total = total
+        self.lastmsg = ""
+        self.coverage_missed = []
+        self.timings = []
+        
+    def addCoverageMissed(self, filename, statements, missed_statements,
+                          missed_description):
+        self.coverage_missed.append((filename, statements, missed_statements,
+                                     missed_description))
+
+    def wasSuccessful(self, ignore_coverage=False):
+        return (unittest.TestResult.wasSuccessful(self) and 
+                (ignore_coverage or not self.coverage_missed))
+        
+    def clearmsg(self):
+        self.output.write("\b \b" * len(self.lastmsg))
+        self.lastmsg = ""
+        
+    def write(self, test):
+        self.clearmsg()
+        self.lastmsg = "Running test %d/%d: %s" % (self.testsRun, 
+                                                   self.total, 
+                                                   str(test)[:50])
+        self.output.write(self.lastmsg)
+        self.output.flush()
+        
+    def startTest(self, test):
+        unittest.TestResult.startTest(self, test)
+        self.write(test)
+        self.start_time = time.time()
+        
+    def stopTest(self, test):
+        end_time = time.time()
+        unittest.TestResult.stopTest(self, test)
+        self.timings.append((end_time - self.start_time, test))
+
+
+class CoverageTestRunner:
+
+    """A test runner class that insists modules' tests cover them fully."""
+    
+    def __init__(self):
+        self._module_pairs = []
+        
+    def add_pair(self, module_pathname, test_module_pathname):
+        """Add a module and its test module to list of tests."""
+        self._module_pairs.append((module_pathname, test_module_pathname))
+
+    def find_pairs(self, dirname):
+        """Find all module/test module pairs in directory tree.
+        
+        This method relies on a naming convention: it scans a directory
+        tree and assumes that for any file foo.py, if there exists a
+        file foo_tests.py or fooTests.py, they form a pair.
+        
+        """
+        
+        suffixes = ["_tests.py", "Tests.py"]
+        
+        
+        for dirname, dirnames, filenames in os.walk(dirname):
+            tests = []
+            for filename in filenames:
+                for suffix in suffixes:
+                    if filename.endswith(suffix):
+                        module = filename[:-len(suffix)] + ".py"
+                        if module in filenames:
+                            module = os.path.join(dirname, module)
+                            filename = os.path.join(dirname, filename)
+                            self.add_pair(module, filename)
+        
+    def _load_module_from_pathname(self, pathname):
+        for tuple in imp.get_suffixes():
+            suffix, mode, type = tuple
+            if pathname.endswith(suffix):
+                name = os.path.basename(pathname[:-len(suffix)])
+                f = file(pathname, mode)
+                return imp.load_module(name, f, pathname, tuple)
+        raise Exception("Unknown module: %s" % pathname)
+
+    def _load_pairs(self):
+        module_pairs = []
+        loader = unittest.defaultTestLoader
+        for pathname, test_pathname in self._module_pairs:
+            module = self._load_module_from_pathname(pathname)
+            test_module = self._load_module_from_pathname(test_pathname)
+            suite = loader.loadTestsFromModule(test_module)
+            module_pairs.append((module, test_module, suite))
+        return module_pairs
+
+    def printErrorList(self, flavor, errors):
+        for test, error in errors:
+            print "%s: %s" % (flavor, str(test))
+            print str(error)
+
+    def run(self):
+        start_time = time.time()
+        
+        module_pairs = self._load_pairs()
+        total_tests = sum(suite.countTestCases() 
+                          for x, y, suite in module_pairs)
+        result = CoverageTestResult(sys.stdout, total_tests)
+
+        for module, test_module, suite in module_pairs:
+            coverage.erase()
+            coverage.exclude("#\s*pragma: no cover")
+            coverage.start()
+            sys.path.insert(0, os.path.dirname(module.__file__))
+            reload(module)
+            del sys.path[0]
+            suite.run(result)
+            coverage.stop()
+            filename, stmts, missed, missed_desc = coverage.analysis(module)
+            if missed:
+                result.addCoverageMissed(filename, stmts, missed, missed_desc)
+
+        end_time = time.time()
+
+        sys.stdout.write("\n\n")
+        
+        if result.wasSuccessful():
+            print "OK"
+        else:
+            print "FAILED"
+            print
+            if result.errors:
+                self.printErrorList("ERROR", result.errors)
+            if result.failures:
+                self.printErrorList("FAILURE", result.failures)
+            if result.coverage_missed:
+                print
+                print "Statements missed by per-module tests:"
+                width = max(len(x[0]) for x in result.coverage_missed)
+                fmt = "  %-*s   %s"
+                print fmt % (width, "Module", "Missed statements")
+                for filename, _, _, desc in sorted(result.coverage_missed):
+                    print fmt % (width, filename, desc)
+                print
+
+            print "%d failures, %d errors" % (len(result.failures),
+                                              len(result.errors))
+
+        if end_time - start_time > 10:
+            print
+            print "Slowest tests:"
+            for secs, test in sorted(result.timings)[-10:]:
+                print "  %5.1f s %s" % (secs, str(test)[:70])
+            
+        print "Time: %.1f s" % (end_time - start_time)
+
+        return result
+
+
+def run(dirname="."):
+    """Use CoverageTestRunner on the desired directory."""
+
+    parser = optparse.OptionParser()
+    parser.add_option("--ignore-coverage", action="store_true",
+                      help="Don't fail tests even if coverage is "
+                           "incomplete.")
+
+    opts, args = parser.parse_args()
+
+    runner = CoverageTestRunner()
+    runner.find_pairs(dirname)
+    result = runner.run()
+    if not result.wasSuccessful(ignore_coverage=opts.ignore_coverage):
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run()

=== renamed file 'CoverageTestRunner.py' => 'CoverageTestRunner.py.moved'
=== added file 'Makefile'
--- Makefile	1970-01-01 00:00:00 +0000
+++ Makefile	2011-02-28 18:58:01 +0000
@@ -0,0 +1,51 @@
+# Makefile for Computer Janitor
+# Copyright (C) 2008, 2009  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+all: data/computer-janitor-gtk.desktop
+
+DESKTOP=data/computer-janitor-gtk.desktop
+$(DESKTOP): $(DESKTOP).in
+	intltool-merge -d po $(DESKTOP).in $(DESKTOP)
+
+check: check-unittests check-has-unit-tests check-licenses
+
+check-unittests:
+	env COMPUTER_JANITOR_UNITTEST=yes LC_ALL=C python -m CoverageTestRunner
+	rm -f .coverage
+
+check-has-unit-tests:
+	find computerjanitorapp -name '*.py' ! -name '*_tests.py' | \
+	grep -Exv '^computerjanitorapp/(__init__|ui_gtk).py' | \
+	sed 's/\.py$$//' | \
+	while read file; do \
+	    [ -e $${file}_tests.py ] || \
+	    (echo "Missing unit test: $$file.py"; exit 1); done
+
+check-licenses:
+	./license-check
+
+clean:
+	rm -f computerjanitorapp/*.py[co] .coverage
+	rm -f po/computerjanitor.pot
+	rm -rf build $(DESKTOP)
+
+update-po:
+	echo '[encoding: UTF-8]' > po/POTFILES.in; \
+	find computerjanitorapp -name \*.py >> po/POTFILES.in; \
+	for f in data/*.ui; do \
+		echo '[type: gettext/glade]'$$f >> po/POTFILES.in; \
+	done; \
+	ls data/*.in plugins/*.py >> po/POTFILES.in; \
+	python setup.py build_i18n --merge-po --po-dir po

=== renamed file 'Makefile' => 'Makefile.moved'
=== added file 'NEWS'
--- NEWS	1970-01-01 00:00:00 +0000
+++ NEWS	2011-02-28 18:58:01 +0000
@@ -0,0 +1,237 @@
+NEWS for Computer Janitor
+=========================
+
+This file summarizes mainly user-visible changes. For detailed
+changes, please see the bzr commit log messages.
+
+Version 2.0.4, released 2010-09-20
+
+    * Update translation strings (LP: #621723) (LP: #612493)
+    * computer-janitor-gtk --help and --version switches added
+    * Fixed SystemError crash in open() (LP: #545306)
+    * Do not depend on python-fstab any more.
+    * Fixed icon (LP: #434431) - Pavol Klačanský
+
+Version 2.0, released 2010-03-15
+
+    * Refactored the system modifying parts of Computer Janitor into a
+      separate dbus daemon.  This allows you to run the cli or gtk versions
+      without being root.  You will be prompted for the administrative
+      password when necessary.
+
+    * The user interface has been cleaned up to remove previously unused gui
+      elements.
+
+Version 1.13.3, released 2009-09-09
+
+    * Fixed URL in About dialog.
+    
+    * The "Do cleanups" button is now set to sensitive when there is
+      something to clean.
+      
+    * The user is now told if nothing was found to clean up, so they
+      don't wonder why the window is empty.
+
+    * The 'unsupported package' plugin is re-enabled.
+
+Version 1.13.2, released 2009-08-21
+
+    * Versions 1.13.0 and 1.13.1 were not released publically. This
+      section documents all changes since 1.12.1.
+      
+    * The GTK user interface has been completely rewritten from scratch.
+      Thanks to Martin Albisetti for the general design. All bugs are belong
+      to Lars Wirzenius anyway.
+      
+    * Adapted to new python-apt API. This means the code only works on
+      Ubuntu karmic, not earlier releases.
+      
+    * The 'unsupported package' plugin is now not installed by default.
+      This should make it less likely people remove third-party packages
+      by default.
+      
+    * The fstab plugin is not installed by default. It is no longer needed
+      in karmic, since the Linux kernel now uses relatime by default.
+      
+    BUG FIXES:
+      
+    * I18n changes to account for the fact that Computer Janitor's code
+      is in two places (itself, and Update Manager), and thus two po
+      files.
+      
+    * I18n change to include plugin code as well. Thanks to Gabor Kelemen.
+    
+    * Other i18n changes, in both the GTK and command line user interfaces.
+    
+    * All instances of the word 'cruft' have been removed from the user
+      interface. It is not a proper English word.
+      
+    * Typo fix in manual page. Thanks to Charlie_Smotherman.
+    
+Version 1.12.1, released 2009-03-04
+
+    * Change the description text at the top of the main window to be
+      clearer.
+      
+    * Sort cruft in the GTK user interface in groups. This should
+      some day get user-visible headings, so it's clearer to the user.
+
+    BUG FIXES:
+    
+    * In the GTK user interface, the button "Cleanup" now uses "u" as the
+      accelerator key, rather than "c", which confliced with the
+      accelerator key for the "Close" button. Fixes LP: #311557, reported
+      by hackel.
+      
+    * Changed the label for the yes/no column in the GTK UI to be
+      "Remove/fix?" rather than just "Remove?", since not all things
+      are removals. Fixes LP: #300354, reported by Hernando Torque.
+
+Version 1.12, released 2009-02-19
+
+    * New plugin: remove files left on the filesystem by the dpkg
+      conffile handling (*.dpkg-old and *.dpkg-new).
+      
+    * Code base has been split so that the core parts (plugin management,
+      some of the plugins) now reside in the update-manager source tree.
+      This was done so that update-manager can use the computer-janitor
+      plugins, since there was no point in both programs having code to do
+      the same thing.
+      
+    * When handling exceptions within the computer-janitor code, the
+      actual exception is now logged (at DEBUG level), to aid in
+      debugging the cause.
+      
+    * Plugins can now declare that they should only be used under specific
+      conditions, rather than always. This is useful for plugins that are
+      used by update-manager.
+
+Version 1.11, released 2009-02-03
+
+    * Renamed to Computer Janitor. The old name, Cruft Remover, was using
+      computer jargon (cruft) and gave the wrong impression (the program
+      does not just remove stuff).
+      
+    * New plugin to compact the dpkg status file, from Michael Vogt.
+
+Version 1.10.5, released 2009-01-16
+
+    * Upon startup, we now verify that the package lists look sane by
+      checking for the dash and gzip packages. If they're not available,
+      we assume something is badly wrong and we won't continue. This
+      makes is very unlikely that people will accidentally remove all
+      their packages because apt didn't have any package lists available.
+
+    * A further safeguard: the running kernel and related packages
+      won't ever be considered cruft anymore.
+      
+    * It is now no longer enough to click on the "Cleanup" button to
+      initiate changes (pacxkage removals etc). Instead, a dialog window
+      will pop up and the user has to click on "OK" to continue.
+
+    * A .deb package's short description is now shown in the cruft
+      description. This will help users have an idea what it's all
+      about. (It's insufficient, but was all that there was time for
+      for the Ubuntu intrepid release schedule.)
+      
+    * Columns in the cruft list now have titles, to make it easier
+      to understand what ticks mean (remove cruft? don't remove
+      cruft?).
+      
+    * The program now reads whitelists in /etc/cruft-remover.d. Cruft
+      named in files in that directory will _not_ be removed.
+      
+    * The plugin to remove packages apt considers autoremovable is now
+      enabled. It has been written ages ago, but not been enabled by
+      default until now.
+
+    * The application now uses the icon it has.
+
+    * Added Polish translation from Piotr Makowski.
+
+    * Added Finnish translation from Lars Wirzenius and Timo Jyrinki.
+
+Version 1.10.4, released 2008-10-27
+
+    * Quick bug fixes for the Ubuntu 8.10 release. A proper release
+      of Cruft Remover will be made later.
+
+Version 1.10.3, released 2008-10-14
+
+    * Bug fixes to how messages are logged, primarily to how character
+      sets are encoded. Found by James Westby.
+
+Version 1.10.2, released 2008-10-14
+
+    IMPORTANT CHANGES:
+    
+    * If setting up logging to syslog fails, don't crash. Thanks,
+      Ricardo Wurmus. (LP:#274970)
+
+    * The program now supports translations via gettext. A Finnish
+      translation was added. (LP:#279580)
+
+    * Handles errors by giving nice(r) error messages also in the
+      command line version. The GTK+ version already did that.
+      Thanks, Marco Rodrigues. (LP:#281657)
+
+    MINOR CHANGES:
+    
+    * Wording in manual page fixed. Thanks, James Westby.
+
+    * Non-functional help button hidden. Thanks, Loïc Minier. (LP:#279577)
+    
+    * Cruft description in the GTK+ user interface is cleared after cruft has 
+      been cleaned up.
+
+Version 1.10.1, released 2008-10-06
+
+    * Bugfix: Cruft in /etc/fstab now goes away from the GTK user interface
+      after a cleanup. Found by James Westby, thanks.
+
+    * cruft-remover-gtk now has a manual page.
+
+    * Bugfix: The GTK user interface now no longer imports the gtk and
+      gobject Python modules globally, but only when the code actually
+      runs, to prevent them from being loaded when running unit tests,
+      etc. (The GTK UI code is not unit tested.)
+
+Version 1.10, released 2008-09-30
+
+    * Important fixes to how GTK+ and threads are used: now all GTK+
+      stuff happens only in the main thread. This turns out to be
+      easier to get right than using gtk.gdk.threads_enter and _leave
+      correctly in all situations, and also allows things like
+      gtk.Dialog.run to be used.
+      
+    * Missing test module for the deb_plugin module written.
+    
+    * SystemError exceptions (which are raised by python-apt when
+      there is a dpkg error) are now handled, and an error displayed
+      to the user. This fixes LP: #275034.
+      
+    * The GTK user interface now displays the version number at startup.
+      The command line interface shows it with the new --version option.
+
+Version 1.9, released 2008-09-26
+
+    * Bug fix: cruft-remover-gtk now correctly refreshes the list of
+      cruft after a bug has been fixed. (LP:274715)
+      
+    * Bug fix: cruft-remover-gtk disables the "Cleanup" button if there
+      is nothing to clean up. (LP:274717)
+
+Version 1.8, released 2008-09-23
+
+    * The GTK user interface now lets you select a row without toggling
+      the status of the cruft. This is useful, because the description
+      of each cruft is shown for the selected row only.
+      
+    * Both the GTK and command line user interfaces now attempt to 
+      be more helpful in describing what each piece of cruft is.
+
+Version 1.7, released 2008-09-12
+
+    * First real public release, despite the version number. (If you have
+      seen any earlier versions, they were not real. Not real, I tell
+      you! Not real! They didn't exist! Really!)

=== renamed file 'NEWS' => 'NEWS.moved'
=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2011-02-28 18:58:01 +0000
@@ -0,0 +1,31 @@
+README for Computer Janitor
+===========================
+
+
+Computer Janitor is a tool to clean up a system so that it is more like
+a freshly installed one. It was written for Ubuntu, but should be
+possible to port to other Unix-like operating systems.
+
+
+Copyright license
+-----------------
+
+Computer Janitor - clean up a computer system
+Copyright (C) 2008, 2009  Canonical, Ltd.
+
+The icon (in data/cruftremover-256x256.png and data/cruftremover-24x25.png):
+Copyright (C) Marco Rodrigues
+
+The following license applies to all files (including the icons):
+
+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, version 3 of the License.
+
+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/>.

=== renamed file 'README' => 'README.moved'
=== added file 'TODO'
--- TODO	1970-01-01 00:00:00 +0000
+++ TODO	2011-02-28 18:58:01 +0000
@@ -0,0 +1,30 @@
+Computer Janitor ideas
+
+    - policykit
+     - aptdaemon backend
+    - nx is disabled?
+    - cronjob to run daily to report cruft
+    - vrms plugin
+    - plugin to suggest removing -generic kernel if more specific one
+      is installed and running (-server, e.g.)
+    - configuration mechanism for plugins
+    - plugin to check for sources.list inconsistencies: $released-updates
+      enabled for foo, if $released is enabled for foo (where foo is
+      main, universe, etc)
+    - UI improvement: group items so that previously ignored stuff is in a
+      separate section of the list, and new stuff is at the top.
+    - UI improvement: more information about a .deb: size, full
+      description, when was it installed, which release did it come
+      from
+    - UI improvement: show sections based on type of cruft. e.g., .deb, fstab
+    - add policykit support
+    - cj: setup.py shouldn't hardcode version string, but should not
+      import computerjanitorapp either, since that requires access
+      to the computerjanitor package.
+          - import computerjanitor.version?
+    - write plugin: unpurged packages
+    - kde UI
+    - write plugin (early karmic): apt-get autoclean
+    - relatime unnecessary in karmic? at least obey noatime, strictatime
+      http://mjg59.livejournal.com/109286.html
+

=== renamed file 'TODO' => 'TODO.moved'
=== added file 'computer-janitor'
--- computer-janitor	1970-01-01 00:00:00 +0000
+++ computer-janitor	2011-02-28 18:58:01 +0000
@@ -0,0 +1,41 @@
+#!/usr/bin/python
+#
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Start the command-line computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    ]
+
+
+import sys
+
+from computerjanitorapp import setup_gettext
+from computerjanitorapp.cli.main import main
+from dbus.exceptions import DBusException
+_ = setup_gettext()
+
+
+try:
+    main()
+except KeyboardInterrupt:
+    pass
+except DBusException as error:
+    print >> sys.stderr, _(
+        'Cannot contact Computer Janitor dbus service; try again.')
+    sys.exit(1)

=== added file 'computer-janitor-gtk'
--- computer-janitor-gtk	1970-01-01 00:00:00 +0000
+++ computer-janitor-gtk	2011-02-28 18:58:01 +0000
@@ -0,0 +1,67 @@
+#!/usr/bin/python
+#
+# computer-janitor-gtk - clean up a Unix-like operating system (GTK version)
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Start the gtk computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    ]
+
+
+import os
+import sys
+import logging
+import argparse
+import traceback
+import computerjanitor
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitorapp.gtk.main import main
+from dbus.exceptions import DBusException
+
+_ = setup_gettext()
+
+
+# Parse some simple command line arguments.
+parser = argparse.ArgumentParser(
+    description=_("""\
+    Find and remove cruft from your system.
+
+    Cruft is anything that shouldn't be on your system, but is.
+    Stretching the definition, cruft is also things that should be on
+    your system but aren't."""))
+parser.add_argument(
+    '--version', action='version',
+    version=_('Computer Janitor {version}').format(
+        version=__version__))
+parser.parse_args()
+# If --version or --help is given, .parse_args() will not return.
+
+try:
+    logging.basicConfig()
+    log = logging.getLogger('computerjanitor')
+    main()
+except KeyboardInterrupt:
+    pass
+except DBusException as error:
+    log.exception('Cannot contact Computer Janitor dbus service; try again.')
+    sys.exit(1)
+except:
+    log.exception('computer-janitor-gtk uncaught exception')
+    sys.exit(1)

=== added file 'computer-janitor-gtk.8'
--- computer-janitor-gtk.8	1970-01-01 00:00:00 +0000
+++ computer-janitor-gtk.8	2011-02-28 18:58:01 +0000
@@ -0,0 +1,36 @@
+.\" Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+.\"
+.\" 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, version 3 of the License.
+.\"
+.\" 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/>.
+.TH COMPUTER-JANITOR-GTK 8 2010-03-17 Ubuntu "Ubuntu system administration"
+.SH NAME
+computer-janitor-gtk \- remove cruft from system (GUI version)
+.SH SYNOPSIS
+.B computer-janitor-gtk
+.SH DESCRIPTION
+.B computer-janitor-gtk
+is a version of
+.BR computer-janitor (8)
+with a graphical user interface.
+See the latter's manual page for more information.
+.SH ENVIRONMENT
+In addition to the environment variables understood by
+.BR computer-janitor (8),
+the following one is understood by
+.B computer-janitor-gtk
+as well.
+.TP
+.B COMPUTER_JANITOR_GLADE
+The location of the Glade data file to specify the user interface.
+You should not need to set this, unless you really know what you are doing.
+.SH "SEE ALSO"
+.BR computer-janitor (8).

=== renamed file 'computer-janitor-gtk.8' => 'computer-janitor-gtk.8.moved'
=== renamed file 'computer-janitor-gtk' => 'computer-janitor-gtk.moved'
=== added file 'computer-janitor.8'
--- computer-janitor.8	1970-01-01 00:00:00 +0000
+++ computer-janitor.8	2011-02-28 18:58:01 +0000
@@ -0,0 +1,222 @@
+.\" Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+.\"
+.\" 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, version 3 of the License.
+.\"
+.\" 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/>.
+.TH COMPUTER-JANITOR 8 2010-03-17 Ubuntu "Ubuntu system administration"
+.SH NAME
+computer-janitor \- clean up a system installation
+.SH SYNOPSIS
+.B "computer-janitor"
+.RB [ --version|-h ]
+.br
+.B "computer-janitor find"
+.RB [ -i|-r|-s|-v|-h ]
+.RI
+.br
+.B "computer-janitor clean"
+.RB [ -a|-v|-h ]
+.RI [ CRUFT ]...
+.br
+.B "computer-janitor ignore"
+.RB [ -h ]
+.RI CRUFT
+.br
+.B "computer-janitor unignore"
+.RB [ -h ]
+.RI CRUFT
+.br
+.B computer-janitor-gtk
+.SH DESCRIPTION
+.B computer-janitor
+and
+.B computer-janitor-gtk
+find and remove
+.I cruft
+from your system.
+The former is a command line program, 
+the latter has a graphical user interface.
+.PP
+Cruft is anything that shouldn't be on the system, but is.
+Stretching the definition, it is also things that should be on the system,
+but aren't.
+Examples:
+.IP \(bu
+Packages that were originally installed because something else depended on
+them, but the depending package has since been removed.  
+Typically this includes large numbers of libraries.
+.IP \(bu
+Packages that are no longer supported by the current release of the
+operating system.
+For example, this can be applications whose development have stopped
+and that no longer have support, including for security issues.
+Keeping such applications installed can be dangerous.
+.IP \(bu
+Configuration tweaks that are missing from the system,
+but which would be there if the system was installed from scratch.
+For example, mount options for filesystems such as
+the
+.B relatime
+option.
+.PP
+.B computer-janitor
+has four modes of operation, invoked by the first non-option
+word in the argument list.
+.IP \(bu
+.B find
+searches for cruft and prints out a list of them.
+Each piece of cruft is also tagged with its state:
+.I ignored
+or
+.IR removable .
+.IP \(bu
+.B clean
+actually removes the cruft.
+It will remove those pieces of cruft you name on the command line.
+If you want to remove everything identified by
+.B find
+that is marked
+.IR removable ,
+use the
+.B --all
+option.
+.IP \(bu
+.B ignore
+and
+.B unignore
+mark cruft as
+.I ignored
+or 
+.IR removable ,
+respectively.
+.SH OPTIONS
+Each subcommand listed above has its own set of options.  If
+.B computer-janitor
+is invoked with no subcommand, the following options are available:
+.TP
+.B --version
+Print the version number and exit.
+.TP
+.BR --help | -h
+Print some global help and exit.
+.PP
+The
+.B find
+subcommand supports the following options:
+.TP
+.BR --ignored | -i
+Find and display only the system's ignored cruft.
+.TP
+.BR --removable | -r
+Find and display only the system's removable cruft.
+.TP
+.BR --short | -s
+Display only the cruft names; do not use with
+.BR --verbose .
+.TP
+.BR --verbose | -v
+Display a detailed explanation for each piece of cruft found.
+.TP
+.BR --help | -h
+Print detailed help for the
+.B find
+subcommand and exit.
+.PP
+The
+.B clean
+subcommand requires either a cruft name or the
+.B --all
+option to specify which cruft to remove.  It supports the following options:
+.TP
+.B --all | -a
+Remove all system cruft that are not ignored.
+.TP
+.BR --verbose | -v
+Provide more details about the cruft being cleaned up.
+.TP
+.BR --help | -h
+Print detailed help for the
+.B clean
+subcommand and exit.
+.PP
+The
+.B ignore
+and
+.B unignore
+commands both take the name of a cruft to mark ignored or removable,
+respectively.  They both also accept these options:
+.TP
+.BR --help | -h
+Print detailed help for the
+.B ignore
+or
+.B unignore
+subcommands and exit.
+.SH "EXIT STATUS"
+.B computer-janitor
+will return an exit code of 0 for successful operation (no errors).
+It will return a non-zero exit code if there are any errors.
+It is not an error to find cruft, or to not find cruft.
+.SH FILES
+.TP
+.B /var/lib/computer-janitor/state.dat
+This file stores the
+.I ignored
+or
+.I removable
+state of system cruft.  Any cruft not listed in this file is by default
+.IR removable .
+.TP
+.B /etc/computer-janitor.d
+This directory contains whitelist files, which specify
+things that are never considered cruft.
+A whitelist file has a name that ends with
+.BR .whitelist ,
+and contains one (potential) cruft name per line.
+(Empty lines and lines beginning with # are ignored.)
+.SH EXAMPLE
+To find all cruft on the system:
+.sp 1
+.RS
+computer-janitor find
+.RE
+.PP
+To remove a specific piece of cruft:
+.sp 1
+.RS
+computer-janitor clean hello
+.RE
+.PP
+To mark a piece of cruft as 
+.IR ignored ,
+so that it isn't removed by
+.B clean
+.BR --all :
+.sp 1
+.RS
+computer-janitor ignore hello
+.RE
+.PP
+To mark a piece of cruft as
+.I removable
+again:
+.sp 1
+.RS
+computer-janitor unignore hello
+.RE
+.PP
+To remove all cruft that isn't ignored:
+.sp 1
+.RS
+computer-janitor clean --all
+.RE
+.SH "SEE ALSO"
+.BR computer-janitor-gtk (8).

=== renamed file 'computer-janitor.8' => 'computer-janitor.8.moved'
=== renamed file 'computer-janitor' => 'computer-janitor.moved'
=== added directory 'computerjanitorapp'
=== renamed directory 'computerjanitorapp' => 'computerjanitorapp.moved'
=== added file 'computerjanitorapp/__init__.py'
--- computerjanitorapp/__init__.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/__init__.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,44 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""computerjanitorapp module."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    '__version__',
+    'setup_gettext',
+    ]
+
+
+__version__ = '2.0.4'
+
+
+# Set up gettext.
+def setup_gettext():
+    """Set up gettext for a module.
+
+    Return a method to be used for looking up translations.  Usage:
+
+    >>> import computerjanitorapp
+    >>> _ = computerjanitorapp.setup_gettext()
+    """
+    import gettext
+    import os
+
+    domain = 'computerjanitor'
+    localedir = os.environ.get('LOCPATH', None)
+    t = gettext.translation(domain, localedir=localedir, fallback=True)
+    return t.ugettext

=== added directory 'computerjanitorapp/cli'
=== added file 'computerjanitorapp/cli/__init__.py'
=== added file 'computerjanitorapp/cli/main.py'
--- computerjanitorapp/cli/main.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/cli/main.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,312 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Command line user interface."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
+import sys
+import dbus
+import gobject
+import argparse
+import textwrap
+
+from dbus.mainloop.glib import DBusGMainLoop
+from operator import mod
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitorapp.terminalsize import get_terminal_size
+from computerjanitorapp.utilities import format_size
+from computerjanitord.service import DBUS_INTERFACE_NAME
+_ = setup_gettext()
+
+
+class Options:
+    """Command line option parser."""
+    def __init__(self, runner):
+        """Parse the command line options.
+
+        :param runner: The class implementing the sub-commands.
+        :type runner: `Runner`
+        """
+        self.runner = runner
+        # Parse the arguments.
+        self.parser = argparse.ArgumentParser(
+            description=_("""\
+            Find and remove cruft from your system.
+
+            Cruft is anything that shouldn't be on your system, but is.
+            Stretching the definition, cruft is also things that should be on
+            your system but aren't."""))
+        self.parser.add_argument(
+            '--version', action='version',
+            # XXX barry 2010-08-23: LP: #622720
+            version=mod(_('Computer Janitor %(version)s'),
+                        dict(version=__version__)))
+        subparser = self.parser.add_subparsers(title='Commands')
+        # The 'find' subcommand.
+        command = subparser.add_parser(
+            'find', help=_('Find and display all cruft found on your system.'))
+        command.add_argument(
+            '-v', '--verbose', action='store_true',
+            help=_("""\
+            Display a detailed explanation for each piece of cruft found."""))
+        command.add_argument(
+            '-i', '--ignored', action='store_true',
+            help=_('Find and display only the ignored cruft.'))
+        command.add_argument(
+            '-r', '--removable', action='store_true',
+            help=_('Find and display only the removable cruft.'))
+        command.add_argument(
+            '-s', '--short', action='store_true',
+            help=_('Display only the package names.  Do not use with -v.'))
+        command.set_defaults(func=self.runner.find)
+        # The 'ignore' subcommand.
+        command = subparser.add_parser(
+            'ignore', help=_("""\
+            Ignore a piece of cruft so that it is not cleaned up."""))
+        command.add_argument(
+            'cruft', nargs=1,
+            help=_('The name of the cruft to ignore.'))
+        command.set_defaults(func=self.runner.ignore)
+        # The 'unignore' subcommand.
+        command = subparser.add_parser(
+            'unignore', help=_("""\
+            Unignore a piece of cruft so that it will be cleaned up."""))
+        command.add_argument(
+            'cruft', nargs=1,
+            help=_('The name of the cruft to unignore.'))
+        command.set_defaults(func=self.runner.unignore)
+        # The 'clean' subcommand.
+        command = subparser.add_parser(
+            'clean',
+            help=_('Remove the selected cruft from the system.'))
+        command.add_argument(
+            '-a', '--all', action='store_true',
+            help=_('Clean up all unignored cruft.'))
+        command.add_argument(
+            '-v', '--verbose', action='store_true',
+            help=_("Provide more details on what's being cleaned."))
+        command.add_argument(
+            'cruft', nargs='?',
+            help=_("""\
+            The name of the cruft to clean up.  Do not use if specifying
+            --all."""))
+        command.set_defaults(func=self.runner.clean)
+        # Parse the arguments and execute the subcommand.
+        self.arguments = self.parser.parse_args()
+
+
+class Runner:
+    """Implementations of subcommands."""
+
+    def __init__(self):
+        # Connect to the dbus service.
+        system_bus = dbus.SystemBus()
+        proxy = system_bus.get_object(DBUS_INTERFACE_NAME, '/')
+        self.janitord = dbus.Interface(
+            proxy, dbus_interface=DBUS_INTERFACE_NAME)
+        # Connect to the signal the server will emit when cleaning up.
+        self.janitord.connect_to_signal('cleanup_status', self._clean_working)
+        # This will get backpatched by __main__.  We need it to produce error
+        # messages from the argparser.
+        self.options = None
+        # The main loop for asynchronous calls and signal reception.
+        self.loop = gobject.MainLoop()
+
+    def _error(self, message):
+        """Generate a parser error and exit.
+
+        :param message: The error message.
+        :type message: string
+        """
+        self.options.parser.error(message)
+        # No return.
+
+    def find(self, arguments):
+        """Find and display all cruft.
+
+        :param arguments: Command line options.
+        """
+        # Cruft will be prefixed by 'removable' if it is not being ignored.
+        ignored = set(self.janitord.ignored())
+        cruft_names = set(self.janitord.find())
+        # Filter names based on option flags.
+        if arguments.ignored:
+            cruft = sorted(cruft_names & ignored)
+        elif arguments.removable:
+            cruft = sorted(cruft_names - ignored)
+        else:
+            cruft = sorted(cruft_names)
+        # The prefix will either be 'ignored' or 'removable' however this
+        # string will be translated, so calculate the prefix size in the
+        # native language, then add two columns of separator, followed by the
+        # cruft name.
+        prefixi = _('ignored')
+        prefixr = _('removable')
+        prefix_width = max(len(prefixi), len(prefixr))
+        # Long, short, shorter display.
+        if arguments.verbose and arguments.short:
+            self._error('Use either -s or -v but not both.')
+        if arguments.short:
+            # This is the shorter output.
+            for name in cruft:
+                print name
+        elif not arguments.verbose:
+            # This is the short output.
+            for name in cruft:
+                prefix = (prefixi if name in ignored else prefixr)
+                # 10 spaces for the prefix
+                print '{0:{1}}  {2}'.format(prefix, prefix_width, name)
+        else:
+            # This is the verbose output.  Start by getting the terminal's
+            # size, though all we care about is the width.
+            rows, columns = get_terminal_size()
+            width = ((80 if columns in (None, 0) else columns)
+                     - prefix_width # space for prefix
+                     - 2            # separator
+                     - 1            # avoid last column, some terminals wrap
+                     )
+            margin = ' ' * (prefix_width + 2)
+            for name in cruft:
+                prefix = (prefixi if name in ignored else prefixr)
+                # 10 spaces for the prefix
+                print '{0:{1}}  {2}'.format(prefix, prefix_width, name)
+                # Print some details about the cruft.
+                cruft_type, disk_usage = self.janitord.get_details(name)
+                print '{0}{1} of type {2}'.format(
+                    margin, format_size(disk_usage), cruft_type)
+                # Get the description, wrap it to the available columns, and
+                # display it line-by-line with the proper amount of leading
+                # spaces (prefix_width + 2).
+                description = self.janitord.get_description(name)
+                if len(description) == 0:
+                    print
+                    continue
+                paragraphs = description.split('\n\n')
+                for paragraph in paragraphs:
+                    for line in textwrap.wrap(paragraph, width):
+                        # 2010-02-09 barry: The original code forced the
+                        # output to utf-8, claiming that was necessary to
+                        # "write out stuff even when it's going to somewhere
+                        # like a pipe [...] ignor[ing] the user's desired
+                        # charset, which is bad, bad, bad...".  This makes me
+                        # pretty uncomfortable, so I'd like to see a bug
+                        # report before I copy that from the previous
+                        # implementation.
+                        print '{0}{1}'.format(margin, line)
+                    # Paragraph separator.
+                    print
+
+    def ignore(self, arguments):
+        """Ignore some cruft.
+
+        :param arguments: Command line options.
+        """
+        assert len(arguments.cruft) == 1, 'Unexpected arguments'
+        self.janitord.ignore(arguments.cruft[0])
+        self.janitord.save()
+
+    def unignore(self, arguments):
+        """Unignore some cruft.
+
+        :param arguments: Command line options.
+        """
+        assert len(arguments.cruft) == 1, 'Unexpected arguments'
+        self.janitord.unignore(arguments.cruft[0])
+        self.janitord.save()
+
+    def _clean_reply(self):
+        """The 'clean' operation has completed successfully."""
+        self.loop.quit()
+        print 'done.'
+
+    def _clean_error(self, exception):
+        """The 'clean' operation has failed."""
+        self.loop.quit()
+        print 'dbus service error:', exception
+
+    def _clean_working(self, cruft):
+        """The 'clean' operation is in progress.
+
+        :param cruft: The cruft that is being cleaned up.
+        :type cruft: string
+        """
+        verbose = self.options.arguments.verbose
+        if cruft == '':
+            # We're done.
+            if not verbose:
+                sys.stdout.write(' ')
+                sys.stdout.flush()
+        else:
+            if verbose:
+                print 'Working on', cruft
+            else:
+                sys.stdout.write('.')
+                sys.stdout.flush()
+
+    def clean(self, arguments):
+        """Clean up the cruft.
+
+        :param arguments: Command line options.
+        """
+        if arguments.all:
+            # You can't specify both --all and a cruft name.
+            if arguments.cruft is not None:
+                self._error('Specify a cruft name or --all, but not both')
+                # No return.
+            all_cruft = set(self.janitord.find())
+            ignored = set(self.janitord.ignored())
+            cleanable_cruft = all_cruft - ignored
+        else:
+            if arguments.cruft is None:
+                self._error('You must specify a cruft name, or use --all')
+                # No return.
+            cleanable_cruft = (arguments.cruft,)
+        # Make the asynchronous call because this can take a long time.  We'll
+        # get status updates periodically.  Note however that even though this
+        # is asynchronous, dbus still expects a response within a certain
+        # amount of time.  We have no idea how long it will take to clean up
+        # the cruft though, so just crank the timeout up to some insanely huge
+        # number (of seconds).
+        self.janitord.clean(cleanable_cruft,
+                            reply_handler=self._clean_reply,
+                            error_handler=self._clean_error,
+                            # If it takes longer than an hour, we're screwed.
+                            timeout=3600)
+        # Start the main loop.  This will exit when the remote operation is
+        # complete.
+        if not arguments.verbose:
+            sys.stdout.write('processing')
+            sys.stdout.flush()
+        self.loop.run()
+
+
+def main():
+    # We'll need a main loop to receive status signals from the dbus service.
+    # Don't start the main loop yet though, since we only need it for 'clean'
+    # commands.
+    DBusGMainLoop(set_as_default=True)
+    runner = Runner()
+    options = Options(runner)
+    # Backpatch runner because of circular references.
+    runner.options = options
+    # Execute the subcommand.
+    options.arguments.func(options.arguments)

=== added directory 'computerjanitorapp/gtk'
=== added file 'computerjanitorapp/gtk/__init__.py'
=== added file 'computerjanitorapp/gtk/dialogs.py'
--- computerjanitorapp/gtk/dialogs.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/gtk/dialogs.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,113 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Confirm some actions."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'AreYouSure',
+    'CleanupProblem',
+    ]
+
+
+import gtk
+
+from operator import mod
+
+from computerjanitorapp import setup_gettext
+from computerjanitorapp.gtk.store import ListStoreColumns
+
+_ = setup_gettext()
+NL = '\n'
+
+
+class DialogBase:
+    """Base class for dialogs."""
+
+    def __init__(self, ui):
+        self._ui = ui
+
+
+class AreYouSure(DialogBase):
+    """Confirmation of destructive actions."""
+
+    def verify(self):
+        """Confirm package removal."""
+        # Start by getting all the active, non-ignored cruft.  These are the
+        # candidates for removal.
+        cleanable_cruft = self._ui.get_cleanable_cruft()
+        # It would be nice if we could produce better messages than these, but
+        # that would require a richer interface to the dbus service, and
+        # probably to the cruft plugin architecture underneath that.
+        #
+        message = _('Are you sure you want to clean your system?')
+        dialog = gtk.MessageDialog(
+            parent=self._ui.widgets['window'],
+            type=gtk.MESSAGE_WARNING,
+            buttons=gtk.BUTTONS_NONE,
+            message_format=message)
+        dialog.set_title(_('Clean up'))
+        package_cruft_count = sum(1 for cruft_name, is_pkg in cleanable_cruft
+                                  if is_pkg)
+        other_cruft_count = len(cleanable_cruft) - package_cruft_count
+        messages = []
+        ok_button = None
+        # XXX vv barry 2010-08-23: LP: #622720
+        if package_cruft_count > 0:
+            messages = [
+                _('<b>Software packages to remove: %(packages)s</b>.'),
+                _('\nRemoving packages that are still in use can '
+                  'cause errors.'),
+                ]
+            ok_button = _('Remove packages')
+        if other_cruft_count > 0:
+            messages.insert(1, _('Non-package items to remove: %(others)s.'))
+            ok_button = _('Clean up')
+        message = mod(NL.join(messages),
+                      dict(packages=package_cruft_count,
+                           others=other_cruft_count))
+        # XXX ^^ barry 2010-08-23: LP: #622720
+        dialog.format_secondary_markup(message)
+        dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CLOSE)
+        dialog.add_button(ok_button, gtk.RESPONSE_YES)
+        # Show the dialog and get the user's response.
+        dialog.show_all()
+        response = dialog.run()
+        dialog.hide()
+        return response == gtk.RESPONSE_YES
+
+
+class CleanupProblem(DialogBase):
+    """Some problem occurred during cleanup.
+
+    This is almost definitely caused by another package manager running at the
+    same time.
+    """
+
+    def run(self):
+        """Show the dialog and wait for confirmation."""
+        message = _('System clean up could not complete. '
+                    'Be sure no other package manager such as Synaptic or '
+                    'Update Manager is running.')
+        dialog = gtk.MessageDialog(
+            parent=self._ui.widgets['window'],
+            type=gtk.MESSAGE_ERROR,
+            buttons=gtk.BUTTONS_OK,
+            message_format=message)
+        dialog.set_title(_('System clean up failure'))
+        dialog.show_all()
+        dialog.run()
+        dialog.hide()

=== added file 'computerjanitorapp/gtk/main.py'
--- computerjanitorapp/gtk/main.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/gtk/main.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,32 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Command line user interface."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
+from computerjanitorapp.gtk.ui import UserInterface
+from dbus.mainloop.glib import DBusGMainLoop
+
+
+def main():
+    DBusGMainLoop(set_as_default=True)
+    ui = UserInterface()
+    ui.run()

=== added file 'computerjanitorapp/gtk/store.py'
--- computerjanitorapp/gtk/store.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/gtk/store.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,161 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Gtk ListStore model for backing the TreeViews of cruft."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Store',
+    'optimize',
+    'unused',
+    ]
+
+
+import gtk
+import gobject
+
+
+# XXX 2010-03-04 barry: Use a munepy enum.
+class ListStoreColumns:
+    # The cruft name as known by the dbus service.
+    name = 0
+    # The short name of the cruft.
+    short_name = 1
+    # The text displayed in the cell.
+    text = 2
+    # Should the cruft be shown?
+    show = 3
+    # Is the cruft active locally (i.e. toggle button is set)?
+    active = 4
+    # Is the cruft being ignored in the dbus service?
+    server_ignored = 5
+    # Is the cruft's description expanded?
+    expanded = 6
+    # Is this cruft package cruft or some other kind of cruft?
+    is_package_cruft = 7
+
+
+class Store:
+    """The higher level wrapper around the gtk.ListStore."""
+
+    def __init__(self, janitord):
+        """Create the Store.
+
+        :param janitord: The `dbus.Interface` for talking to the Computer
+            Janitor dbus service.
+        """
+        self.janitord = janitord
+        # This ListStore is the backing data structure for the TreeViews in
+        # the main window.  It holds information about the individual pieces
+        # of cruft.  See ListStoreColumns for details.
+        #
+        # XXX 2010-03-04 barry: pygtk does not like 'unicode'.
+        self.store = gtk.ListStore(str, str, str, bool, bool, bool, bool, bool)
+
+    def find_cruft(self):
+        """Find cruft and populate the backing store.
+
+        This actually just asks the backend dbus service to find all the cruft
+        asynchronously.  When the dbus service completes the task, it sends a
+        `find_finished` signal with the new list of cruft.  Upon receipt of
+        that signal, the ListStore is updated.
+        """
+        self.janitord.connect_to_signal('find_finished', self.on_find_finished)
+        self.janitord.find_async()
+
+    def on_find_finished(self, all_cruft_names):
+        """dbus signal handler.
+
+        This actually updates the store with the new cruft results.
+        """
+        ignored_cruft = set(self.janitord.ignored())
+        all_cruft_names = set(all_cruft_names);
+        pkg_cruft_names = set(
+            cruft_name for cruft_name in all_cruft_names
+            if self.janitord.get_details(cruft_name)[0].lower()
+            == 'packagecruft')
+        self.store.clear()
+        # Cruft always starts out in the active, not-expanded state.  Package
+        # cruft goes in the 'unused' column while non-package cruft goes in
+        # the 'optimize' column.
+        for cruft_name in all_cruft_names:
+            cruft_shortname = self.janitord.get_shortname(cruft_name)
+            self.store.append((
+                cruft_name, cruft_shortname,
+                # What is being displayed in the cell.
+                gobject.markup_escape_text(cruft_shortname),
+                # Show the cruft be shown?
+                cruft_name not in ignored_cruft,
+                # Is the cruft active locally?
+                cruft_name not in ignored_cruft,
+                # Is the cruft ignored in the dbus service?
+                cruft_name in ignored_cruft,
+                # Is the cruft's description expanded?
+                False,
+                # Is this package cruft?
+                cruft_name in pkg_cruft_names,
+                ))
+
+    # Forwards to the underlying store, for convenience.  Really, these should
+    # use generic delegates, or clients should just use self.store.store.
+
+    def get_value(self, *args, **kws):
+        return self.store.get_value(*args, **kws)
+
+    def set_value(self, *args, **kws):
+        return self.store.set_value(*args, **kws)
+
+    def filter_new(self, *args, **kws):
+        return self.store.filter_new(*args, **kws)
+
+    def foreach(self, *args, **kws):
+        return self.store.foreach(*args, **kws)
+
+    def reorder(self, *args, **kws):
+        return self.store.reorder(*args, **kws)
+
+    def get_iter_first(self, *args, **kws):
+        return self.store.get_iter_first(*args, **kws)
+
+    def iter_next(self, *args, **kws):
+        return self.store.iter_next(*args, **kws)
+
+    def clear(self, *args, **kws):
+        return self.store.clear(*args, **kws)
+
+
+# Filter functions for use with TreeView column display.
+
+def unused(store, iter):
+    """True if the cruft is not being ignored and is package cruft.
+
+    :param store: The ListStore instance.
+    :param iter: The TreeIter instance.
+    """
+    show = store.get_value(iter, ListStoreColumns.show)
+    is_package_cruft = store.get_value(iter, ListStoreColumns.is_package_cruft)
+    return show and is_package_cruft
+
+
+def optimize(store, iter):
+    """True if the cruft is not package cruft.
+
+    :param store: The ListStore instance.
+    :param iter: The TreeIter instance.
+    """
+    show = store.get_value(iter, ListStoreColumns.show)
+    is_package_cruft = store.get_value(iter, ListStoreColumns.is_package_cruft)
+    return show and not is_package_cruft

=== added file 'computerjanitorapp/gtk/ui.py'
--- computerjanitorapp/gtk/ui.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/gtk/ui.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,537 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Gtk user interface for computer janitor."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'UserInterface',
+    ]
+
+
+import os
+import gtk
+import sys
+import dbus
+import glib
+import pango
+import gobject
+
+from operator import mod
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitorapp.gtk.dialogs import AreYouSure, CleanupProblem
+from computerjanitorapp.gtk.store import (
+    ListStoreColumns, Store, optimize, unused)
+from computerjanitorapp.utilities import format_size
+from computerjanitord.service import DBUS_INTERFACE_NAME
+
+_ = setup_gettext()
+
+GLADE = '/usr/share/computer-janitor/ComputerJanitor.ui'
+ROOT_WIDTH = 900
+ROOT_HEIGHT = 500
+NL = '\n'
+
+# Keys are lower-cased cruft types, i.e. class name of cruft instances.
+ACTIONS = dict(
+    packagecruft=_('Package will be <b>removed</b>.'),
+    filecruft=_('Package will be <b>installed</b>.'),
+    missingpackagecruft=_('File will be <b>removed</b>.'),
+    )
+
+SENSITIVE_WIDGETS = (
+    'do_button',
+    'optimize_treeview',
+    'quit_menuitem',
+    'show_previously_ignored',
+    'sort_by_name',
+    'sort_by_size',
+    'unused_treeview',
+    )
+
+
+class UserInterface:
+    """Implementation of the Gtk user interface."""
+
+    def __init__(self):
+        # Connect to the dbus service.
+        system_bus = dbus.SystemBus()
+        proxy = system_bus.get_object(DBUS_INTERFACE_NAME, '/')
+        self.janitord = dbus.Interface(
+            proxy, dbus_interface=DBUS_INTERFACE_NAME)
+        # Create the model on which the TreeViews will be based.
+        self.store = Store(self.janitord)
+        self.popup_menus = {}
+        self.cruft_name_columns = set()
+        # Sort by name by default.
+        self._sort_key = self._by_name
+        # Work is happening asynchronously on the dbus service.
+        self.working = False
+        # Connect to the signal the server will emit when cleaning up.
+        self.janitord.connect_to_signal('cleanup_status', self._clean_working)
+
+    def run(self):
+        """Set up the widgets and run the main loop."""
+        builder = gtk.Builder()
+        builder.set_translation_domain('computerjanitor')
+        # Load the glade ui file, which can be overridden from the environment
+        # for testing purposes.
+        glade_file = os.environ.get('COMPUTER_JANITOR_GLADE', GLADE)
+        builder.add_from_file(glade_file)
+        # Bind widgets to callbacks.  Initialize the Do... button to
+        # insensitive, but possibly toggle it back to sensitive if we find
+        # cruft.
+        self.find_and_bind_widgets(builder)
+        self.widgets['do_button'].set_sensitive(False)
+        self.janitord.connect_to_signal('find_finished', self._find_finished)
+        # Do the initial search for cruft and set up the TreeView model.
+        self.store.find_cruft()
+        self.sort_cruft()
+        # Now hook the TreeViews up to there view of the model.
+        self.create_column('unused_treeview', unused)
+        self.create_column('optimize_treeview', optimize)
+        # Set the dimensions of the root window.
+        root = self.widgets['window']
+        root.set_default_size(ROOT_WIDTH, ROOT_HEIGHT)
+        # Map the root window and go!
+        root.show()
+        gtk.main()
+
+    def find_and_bind_widgets(self, builder):
+        """Bind widgets and callbacks."""
+        # Start by extracting all the bindable widgets from the ui builder,
+        # keeping track of them as mapped to their name.
+        self.widgets = {}
+        for ui_object in builder.get_objects():
+            if issubclass(type(ui_object), gtk.Buildable):
+                widget_name = gtk.Buildable.get_name(ui_object)
+                self.widgets[widget_name] = ui_object
+                # Search through the attributes of this instance looking for
+                # callbacks for this widget.  We use the naming convention
+                # 'on_<widget>_<signal>' for such methods.  Both the widget
+                # name and signal (or event) can contain underscores.  Connect
+                # the widget to the callback.
+                prefix = 'on_{0}_'.format(widget_name)
+                for method_name in dir(self):
+                    if method_name.startswith(prefix):
+                        signal_name = method_name[len(prefix):]
+                        ui_object.connect(
+                            signal_name, getattr(self, method_name))
+
+    def create_column(self, widget_name, filter_func):
+        """Set up a column in the named TreeView."""
+        treeview = self.widgets[widget_name]
+        # XXX 2010-03-04 barry: This is a bit of an abuse because it's
+        # supposed to specify whether users are to read across the rows.  As a
+        # side effect it renders the columns with alternating row colors, but
+        # that's not it's primary function.
+        treeview.set_rules_hint(True)
+        # Each TreeView contains two columns.  The leftmost one is a toggle
+        # that when select tells c-j to act on that cruft.  Deselecting the
+        # toggle ignores the package for next time.
+        toggle_cr = gtk.CellRendererToggle()
+        toggle_cr.connect('toggled', self._toggled, treeview)
+        toggle_cr.set_property('yalign', 0)
+        toggle_col = gtk.TreeViewColumn()
+        toggle_col.pack_start(toggle_cr)
+        toggle_col.add_attribute(toggle_cr, 'active', ListStoreColumns.active)
+        treeview.append_column(toggle_col)
+        # The rightmost column contains the details of the cruft.  It will
+        # always contain the cruft name and can be expanded to display cruft
+        # details.  Tell the column to get its toggle's active state from the
+        # model.
+        name_cr = gtk.CellRendererText()
+        name_cr.set_property('yalign', 0)
+        name_cr.set_property('wrap-mode', pango.WRAP_WORD)
+        name_col = gtk.TreeViewColumn()
+        name_col.pack_start(name_cr)
+        name_col.add_attribute(name_cr, 'markup', ListStoreColumns.text)
+        treeview.append_column(name_col)
+        self.cruft_name_columns.add(name_col)
+        # The individual crufts may or may not be visible in this TreeView.
+        # It's the filter function that controls this, so set that now.
+        filter_store = self.store.filter_new()
+        filter_store.set_visible_func(filter_func)
+        treeview.set_model(filter_store)
+        # Each TreeView has a popup menu for select or deselecting all visible
+        # cruft.
+        self.create_popup_menu_for_treeview(treeview)
+
+    def create_popup_menu_for_treeview(self, treeview):
+        """The tree views have a popup menu to select/deselect everything.
+
+        :param treeview: The `TreeView` to attach the menu to.
+        """
+        select_all = gtk.MenuItem(label='Select all')
+        select_all.connect('activate', self.popup_menu_select_all, treeview)
+        unselect_all = gtk.MenuItem(label='Unselect all')
+        unselect_all.connect('activate',
+                             self.popup_menu_unselect_all, treeview)
+        menu = gtk.Menu()
+        menu.append(select_all)
+        menu.append(unselect_all)
+        menu.show_all()
+        self.popup_menus[treeview] = menu
+
+    def _by_name(self, cruft_name):
+        """Sort by cruft name."""
+        return cruft_name
+
+    def _by_size(self, cruft_name):
+        """Sort by cruft size, from largest to smallest."""
+        # Return negative size to sort from largest to smallest.
+        return -self.janitord.get_details(cruft_name)[1]
+
+    def sort_cruft(self):
+        """Sort the cruft displays, either by name or size."""
+        # The way reordering (not technically 'sorting') works in gtk is that
+        # you give a list of integer indexes to the the ListStore.  These
+        # indexes are in sorted order, and refer to the pre-sort indexes of
+        # the items in the store.  IOW, the ListStore knows that if the first
+        # integer in the list is 7, it will move the 7th item to the top.
+        #
+        # Start by getting the indexes and names of the currenly sorted cruft.
+        # We'll fill this list with 2-tuples of the format:
+        # (sort-key, current-index).
+        cruft_data = []
+        def get(model, path, iter, crufts):
+            cruft_name = model.get_value(iter, ListStoreColumns.name)
+            crufts.append((self._sort_key(cruft_name), len(crufts)))
+            # Continue iterating.
+            return False
+        self.store.foreach(get, cruft_data)
+        cruft_data.sort()
+        cruft_indexes = [index for key, index in cruft_data]
+        # No need to do anything if there is no cruft.
+        if len(cruft_indexes) > 0:
+            self.store.reorder(cruft_indexes)
+
+    def get_cleanable_cruft(self):
+        """Return the list of cleanable cruft candidates.
+
+        :return: List of cleanable cruft.
+        :rtype: list of 2-tuples of (cruft_name, is_package_cruft)
+        """
+        cleanable_cruft = []
+        def collect(model, path, iter, crufts):
+            # Only clean up active cruft, i.e. those that are specifically
+            # checked as ready for cleaning.
+            cruft_active = model.get_value(iter, ListStoreColumns.active)
+            if cruft_active:
+                cruft_name = model.get_value(iter, ListStoreColumns.name)
+                cruft_is_package_cruft = model.get_value(
+                    iter, ListStoreColumns.is_package_cruft)
+                crufts.append((cruft_name, cruft_is_package_cruft))
+            # Continue iterating.
+            return False
+        self.store.foreach(collect, cleanable_cruft)
+        return cleanable_cruft
+
+    def toggle_long_description(self, treeview):
+        """Toggle the currently selected cruft's long description.
+
+        :param treeview: The TreeView
+        """
+        selection = treeview.get_selection()
+        filter_model, selected = selection.get_selected()
+        if not selected:
+            return
+        model = filter_model.get_model()
+        iter = filter_model.convert_iter_to_child_iter(selected)
+        cruft_name = model.get_value(iter, ListStoreColumns.name)
+        expanded = model.get_value(iter, ListStoreColumns.expanded)
+        shortname = model.get_value(iter, ListStoreColumns.short_name)
+        if expanded:
+            # Collapse it.
+            value = gobject.markup_escape_text(shortname)
+        else:
+            cruft_type, size = self.janitord.get_details(cruft_name)
+            lines = [gobject.markup_escape_text(shortname)]
+            action = ACTIONS.get(cruft_type.lower())
+            if action is not None:
+                lines.append(action)
+            # XXX barry 2010-08-23: LP: #622720
+            lines.append(mod(_('Size: %(bytes)s'),
+                             dict(bytes=format_size(size))))
+            lines.append('')
+            description = self.janitord.get_description(cruft_name)
+            lines.append(gobject.markup_escape_text(description))
+            value = NL.join(lines)
+        model.set_value(iter, ListStoreColumns.text, value)
+        model.set_value(iter, ListStoreColumns.expanded, not expanded)
+
+    def desensitize(self):
+        """Make certain ui elements insensitive during work."""
+        for widget in SENSITIVE_WIDGETS:
+            self.widgets[widget].set_sensitive(False)
+
+    def sensitize(self):
+        """Make certain ui elements sensitive after work."""
+        for widget in SENSITIVE_WIDGETS:
+            self.widgets[widget].set_sensitive(True)
+
+    def _find_finished(self, all_cruft_names):
+        """dbus signal handler."""
+        self.widgets['do_button'].set_sensitive(len(all_cruft_names) > 0)
+
+    # Popup menu support.
+
+    def popup_menu_foreach_set_state(self, treeview, enabled):
+        """Set the state of the cruft 'active' flag for all cruft.
+
+        :param treeview: The `TreeView` to set cruft state on.
+        :param enabled: The new state flag for all cruft.  True means enabled.
+        :type enabled: bool
+        """
+        def set_state(model, path, iter, user_data):
+            # Set the state on an individual piece of cruft.  Start by
+            # changing the state of the cruft on the dbus service.
+            child_iter = model.convert_iter_to_child_iter(iter)
+            cruft_name = self.store.get_value(
+                child_iter, ListStoreColumns.name)
+            if enabled:
+                self.janitord.unignore(cruft_name)
+            else:
+                self.janitord.ignore(cruft_name)
+            # Now set the active state in the model.
+            self.store.set_value(child_iter, ListStoreColumns.active, enabled)
+        treeview.get_model().foreach(set_state, None)
+        # Save the updated state on the dbus service.
+        self.janitord.save()
+
+    def popup_menu_select_all(self, menuitem, treeview):
+        self.popup_menu_foreach_set_state(treeview, True)
+
+    def popup_menu_unselect_all(self, menuitem, treeview):
+        self.popup_menu_foreach_set_state(treeview, False)
+
+    # Progress bar
+
+    def pulse(self):
+        """Progress bar callback, showing that something is happening."""
+        progress = self.widgets['progressbar_status']
+        if self.working:
+            progress.show()
+            progress.pulse()
+            return True
+        else:
+            # All done.  Hide the progress bar, make the ui elements sensitive
+            # again, update the store, and kill the timer.
+            progress.hide()
+            self.store.clear()
+            self.store.find_cruft()
+            self.sensitize()
+            return False
+
+    def _clean_working(self, cruft):
+        """dbus signal handler; the 'clean' operation is in progress.
+
+        :param done: The cruft that is being cleaned up.
+        :type done: string
+        """
+        # Just mark the status here.  The progress bar pulsar will handle
+        # doing the actual work.
+        self.working = (cruft != '')
+        if self.working:
+            self.widgets['progressbar_status'].set_text(
+                # XXX barry 2010-08-23: LP: #622720
+                mod(_('Processing %(cruft)s'), dict(cruft=cruft)))
+
+    # Callbacks
+
+    def _toggled(self, widget, path, treeview):
+        """Handle the toggle button in a TreeView cell.
+
+        :param widget: The CellRendererToggle
+        :param path: The cell's path.
+        :param treeview: The TreeView
+        """
+        # Find out which cruft's toggle was clicked.
+        model = treeview.get_model()
+        filter_iter = model.get_iter(path)
+        child_iter = model.convert_iter_to_child_iter(filter_iter)
+        cruft_name = self.store.get_value(child_iter, ListStoreColumns.name)
+        state = self.store.get_value(child_iter, ListStoreColumns.active)
+        # Toggle the current state.
+        new_state = not state
+        if new_state:
+            self.janitord.unignore(cruft_name)
+        else:
+            self.janitord.ignore(cruft_name)
+        self.store.set_value(child_iter, ListStoreColumns.active, new_state)
+        self.store.set_value(
+            child_iter, ListStoreColumns.server_ignored, not new_state)
+        # Save the new ignored state on the dbus service.
+        self.janitord.save()
+
+    # Signal and event handlers.
+
+    def on_quit_menuitem_activate(self, *args):
+        """Signal and event handlers for quitting.
+
+        Since we just want things to go away, we don't really care about the
+        arguments.  Just tell the main loop to exit.
+        """
+        # Don't quit while we're working.
+        if self.working:
+            return True
+        gtk.main_quit()
+
+    on_window_delete_event = on_quit_menuitem_activate
+
+    def treeview_button_press_event(self, treeview, event):
+        """Handle mouse button press events on the TreeView ourselves.
+
+        We handle mouse button presses ourselves so that we can either
+        toggle the long description (button 1, typically left) or
+        pop up a menu (button 3, typically right).
+        """
+        # Original comment: This is slightly tricky and probably a source of
+        # bugs.  Oh well.
+        if event.button == 1:
+            # Left button event.  Select the row being clicked on.  If the
+            # click is on the cruft name, show or hide its long description.
+            # If the click the click is elsewhere do not handle it.  This
+            # allows the toggle button event to be handled separately.
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pathinfo = treeview.get_path_at_pos(x, y)
+            if pathinfo is None:
+                # The click was not in a cell, but we've handled it anyway.
+                return True
+            path, column, cell_x, cell_y = pathinfo
+            if column in self.cruft_name_columns:
+                treeview.set_cursor(path, column, False)
+                self.toggle_long_description(treeview)
+                return True
+            else:
+                # We are not handling this event so that the toggle button
+                # handling can occur.
+                return False
+        elif event.button == 3:
+            # Right button event.  Pop up the select/deselect all menu.
+            treeview.grab_focus()
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pathinfo = treeview.get_path_at_pos(x, y)
+            if pathinfo is not None:
+                path, column, cell_x, cell_y = pathinfo
+                treeview.set_cursor(path, column, False)
+            menu = self.popup_menus[treeview]
+            menu.popup(None, None, None, event.button, time)
+            return True
+        else:
+            # No other events are handled by us.
+            return False
+
+    # The actual event handler is totally generic.  Alias it to names
+    # recognized by the automatic event binding scheme.
+    on_unused_treeview_button_press_event = treeview_button_press_event
+    on_optimize_treeview_button_press_event = treeview_button_press_event
+
+    def treeview_size_allocate(self, treeview, *args):
+        """Allocate space for the tree view and set wrap width.
+
+        :param treeview: The TreeView
+        :param args: Additional ignored positional arguments
+        """
+        # Get the rightmost of the two columns in the TreeView, i.e. the one
+        # containing the text.
+        column = treeview.get_column(1)
+        name_cr = column.get_cell_renderers()[0]
+        # Wrap to the entire width of the column.
+        width = column.get_width()
+        name_cr.set_property('wrap-width', width)
+
+    on_unused_treeview_size_allocate = treeview_size_allocate
+    on_optimize_treeview_size_allocate = treeview_size_allocate
+
+    def on_sort_by_name_toggled(self, menuitem):
+        """Reorder the crufts to be sorted by name or size."""
+        if menuitem.get_active():
+            self._sort_key = self._by_name
+        else:
+            self._sort_key = self._by_size
+        self.sort_cruft()
+
+    def on_about_menuitem_activate(self, *args):
+        dialog = self.widgets['about_dialog']
+        dialog.set_name(_('Computer Janitor'))
+        dialog.set_version(__version__)
+        dialog.show()
+        dialog.run()
+        dialog.hide()
+
+    def on_show_previously_ignored_toggled(self, menuitem):
+        """Show all cruft, even those being ignored.
+
+        Normally, we only show cruft that wasn't explicitly ignored.  By
+        toggling this menu item, the janitor can also display cruft that is
+        marked as ignored on the dbus service.
+        """
+        show_ignored_cruft = menuitem.get_active()
+        iter = self.store.get_iter_first()
+        while iter:
+            cruft_name = self.store.get_value(iter, ListStoreColumns.name)
+            server_ignored = self.store.get_value(
+                iter, ListStoreColumns.server_ignored)
+            show = (show_ignored_cruft or not server_ignored)
+            self.store.set_value(iter, ListStoreColumns.show, show)
+            iter = self.store.iter_next(iter)
+
+    def on_do_button_clicked(self, *args):
+        """JFDI, well almost."""
+        self.count = 0
+        response = AreYouSure(self).verify()
+        if not response:
+            return
+        # This can take a long time.  Make an asynchronous call to the dbus
+        # service and arrange for it to occasionally provide us with status.
+        # This isn't great ui, but OTOH, the package cruft cleaners themselves
+        # don't provide much granularity, so there's little we can do anyway
+        # without a major rewrite of the plugin architecture.
+        self.working = True
+        glib.timeout_add(150, self.pulse)
+        # Make various ui elements insensitive.
+        self.desensitize()
+        cleanable = [cruft for cruft, ispkg in self.get_cleanable_cruft()]
+        def error(exception):
+            # XXX 2010-05-19 barry: This will (almost?) always be caused by
+            # some other package manager already running, so if we get that
+            # exception, display a (hopefully) useful dialog.  I'm not sure
+            # it's very helpful to display the low-level apt exception in a
+            # dialog.  `exception` will always be a DBusException; we won't
+            # get the more useful PackageCleanupError.
+            print >> sys.stderr, exception
+            CleanupProblem(self).run()
+            self.working = False
+        def reply():
+            pass
+        # Make the asynchronous call because this can take a long time.  We'll
+        # get status updates periodically.  Note however that even though this
+        # is asynchronous, dbus still expects a response within a certain
+        # amount of time.  We have no idea how long it will take to clean up
+        # the cruft though, so just crank the timeout up to some insanely huge
+        # number (of seconds).
+        self.widgets['progressbar_status'].set_text('Authenticating...')
+        self.janitord.clean(cleanable,
+                            reply_handler=reply,
+                            error_handler=error,
+                            # If it takes longer than an hour, we're screwed.
+                            timeout=3600)

=== added file 'computerjanitorapp/terminalsize.py'
--- computerjanitorapp/terminalsize.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/terminalsize.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,64 @@
+# terminalsize.py - find size of terminal
+# Copyright (C) 2008  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+# Inspired by code by Chuck Blake, at
+# http://pdos.csail.mit.edu/~cblake/cls/cls.py, but rewritten in an
+# attempt to clarify things. This code is slightly tricky, so I thought
+# the extra clarity would be worth it.
+
+import fcntl
+import os
+import struct
+import termios
+
+
+def get_terminal_size(fd=1):
+    """Return size of terminal attached to the standard output.
+
+    Use ioctl(2) to query a terminal for its size, given a file descriptor
+    attached to the terminal.
+
+    :param fd: Use the given file descriptor.
+    :type fd: int
+    :return: The columns and rows representing the size of the terminal.  If
+        this cannot be determined, None is returned for both values.
+    :rtype: 2-tuple
+    """
+
+    try:
+        # Do the ioctl call. termios.TIOCGWINSZ is the code to query terminal
+        # size (see tty_ioctl(4), at least on Linux).  We need to give it a
+        # string of suitable size to use as the input buffer for ioctl.
+        # ioctl() modifies the buffer and returns the modified buffer as its
+        # return value.
+        #
+        # The manual page specifies a struct winsize to be used, which
+        # consists of four unsigned shorts.  We use struct.calcsize() to
+        # compute the size of that.
+        #
+        # Note that Blake's original code assumes only the first two shorts in
+        # the struct are used, and that two shorts fit into four bytes, which
+        # is probably true for all the relevant platforms, but is cramped
+        # enough that it makes me feel icky.  Thus, I assume less.  This will
+        # still break if the contents of the struct change, but since that
+        # would change the system call API, that's unlikely.
+        buflen = struct.calcsize('hhhh')
+        buf = fcntl.ioctl(fd, termios.TIOCGWINSZ, '\0' * buflen)
+        # ioctl returns a binary buffer that represents the struct
+        # at the C level. We unpack it with struct.unpack.
+        return tuple(struct.unpack('hhhh', buf)[:2])
+    except Exception:
+        # If anything went wrong, we give up and claim we don't know.
+        return None, None

=== added directory 'computerjanitorapp/tests'
=== added file 'computerjanitorapp/tests/__init__.py'
=== added file 'computerjanitorapp/tests/test_all.py'
--- computerjanitorapp/tests/test_all.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/tests/test_all.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,29 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test suite for Computer Janitor."""
+
+import unittest
+
+from computerjanitorapp.tests import test_terminalsize
+from computerjanitorapp.tests import test_utilities
+from computerjanitord.tests.test_all import test_suite as cjd_suite
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(test_terminalsize.test_suite())
+    suite.addTests(test_utilities.test_suite())
+    suite.addTests(cjd_suite())
+    return suite

=== added file 'computerjanitorapp/tests/test_terminalsize.py'
--- computerjanitorapp/tests/test_terminalsize.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/tests/test_terminalsize.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,54 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test calculation of terminal sizes."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import unittest
+
+from computerjanitorapp import terminalsize
+
+
+class TestTerminalSize(unittest.TestCase):
+    """Test calculation of terminal sizes."""
+
+    def test_returns_unknown_when_querying_dev_null(self):
+        fd = os.open("/dev/null", os.O_RDONLY)
+        rows, cols = terminalsize.get_terminal_size(fd)
+        os.close(fd)
+        self.assertEqual(rows, None)
+        self.assertEqual(cols, None)
+
+    def test_returns_two_integers_when_stdout_is_a_terminal(self):
+        # We only run this check if stdout is a terminal.
+        # Unfortunately, there is no sensible way of checking the values.
+        # But that's OK, they're lumberjacks.
+        if os.isatty(1):
+            rows, cols = terminalsize.get_terminal_size(1)
+            self.assertEqual(type(rows), int)
+            self.assertEqual(type(cols), int)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestTerminalSize))
+    return suite

=== added file 'computerjanitorapp/tests/test_utilities.py'
--- computerjanitorapp/tests/test_utilities.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/tests/test_utilities.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,71 @@
+# Copyright (C) 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test common utilities."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import unittest
+
+from computerjanitorapp.utilities import format_size
+
+
+class TestUtilities(unittest.TestCase):
+    """Test common utilities."""
+
+    def test_format_negative(self):
+        self.assertRaises(AssertionError, format_size, -1)
+
+    def test_format_zero(self):
+        self.assertEqual(format_size(0), '0B')
+
+    def test_format_small(self):
+        self.assertEqual(format_size(500), '500B')
+
+    def test_format_1k(self):
+        self.assertEqual(format_size(1000), '1kB')
+
+    def test_format_smallish(self):
+        self.assertEqual(format_size(500000), '500kB')
+
+    def test_format_1M(self):
+        self.assertEqual(format_size(1000000), '1MB')
+
+    def test_format_mediumish(self):
+        self.assertEqual(format_size(500000000), '500MB')
+
+    def test_format_1G(self):
+        self.assertEqual(format_size(1000000000), '1GB')
+
+    def test_format_bigish(self):
+        self.assertEqual(format_size(500000000000), '500GB')
+
+    def test_format_1T(self):
+        self.assertEqual(format_size(1000000000000), '1TB')
+
+    def test_format_hugish(self):
+        self.assertEqual(format_size(500000000000000), '>1TB')
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestUtilities))
+    return suite

=== added file 'computerjanitorapp/utilities.py'
--- computerjanitorapp/utilities.py	1970-01-01 00:00:00 +0000
+++ computerjanitorapp/utilities.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,51 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Common utilities."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'format_size',
+    ]
+
+
+from math import log10
+
+
+TABLE = (
+    'B',
+    'kB',
+    'MB',
+    'GB',
+    'TB',
+    )
+
+
+def format_size(bytes):
+    """Format size in bytes.
+
+    :param bytes: Integer size in bytes.
+    :type bytes: integer
+    :return: Formatted size
+    :rtype: string
+    """
+    assert bytes >= 0, 'Cannot have negative sizes'
+    if bytes == 0:
+        return '0B'
+    if bytes > 10**12:
+        return '>1TB'
+    key = divmod(int(log10(bytes)), 3)[0]
+    return '{0}{1}'.format(bytes // 10**(key * 3), TABLE[key])

=== added directory 'computerjanitord'
=== renamed directory 'computerjanitord' => 'computerjanitord.moved'
=== added file 'computerjanitord/__init__.py'
=== added file 'computerjanitord/application.py'
--- computerjanitord/application.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/application.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,92 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Application interface for use by plugins.
+
+This primarily makes certain apt functionality available to the plugin.
+"""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Application',
+    'SourcesListError',
+    ]
+
+
+import apt
+
+import computerjanitor
+import computerjanitorapp
+
+from computerjanitord.errors import (
+    MissingLandmarkError, NonDownloadableError)
+
+
+_ = computerjanitorapp.setup_gettext()
+
+SYNTAPTIC_PREFERENCES_FILE = '/var/lib/synaptic/preferences'
+# There really isn't anything special about these packages.  These really just
+# represent landmarks in the package namespace that we look for to try to
+# judge the sanity of the apt cache.  If these are missing, things are really
+# messed up and we can't actually figure out how to continue.
+LANDMARK_PACKAGES = [
+    'dash',
+    'gzip',
+    ]
+
+
+class Application:
+    """Interface for plugins requesting apt actions."""
+
+    def __init__(self, apt_cache=None):
+        """Create the application interface.
+
+        :param apt_cache: Alternative apt cache for testing purposes.  When
+            `None` use the default apt cache.
+        """
+        if apt_cache is None:
+            # Use the real apt cache.
+            self.apt_cache = apt.Cache()
+        else:
+            self.apt_cache = apt_cache
+        self.refresh_apt_cache()
+
+    def refresh_apt_cache(self):
+        """Refresh the apt cache.
+
+        This API is used by plugins.
+        """
+        self.apt_cache.open()
+        # For historical purposes, Synaptic has a different way of pinning
+        # packages than apt, so we have to load its preferences file in order
+        # to know what it's pinning.
+        self.apt_cache._depcache.ReadPinFile(SYNTAPTIC_PREFERENCES_FILE)
+
+    def verify_apt_cache(self):
+        """Verify that essential packages are available in the apt cache.
+
+        This API is used by plugins.
+
+        :raises MissingLandmarkError: When an essential package is not
+            available.
+        :raises NonDownloadableError: When an essential package cannot be
+            downloaded.
+        """
+        for name in LANDMARK_PACKAGES:
+            if name not in self.apt_cache:
+                raise MissingLandmarkError(name)
+            if not any(v.downloadable for v in self.apt_cache[name].versions):
+                raise NonDownloadableError(name)

=== added file 'computerjanitord/authenticator.py'
--- computerjanitord/authenticator.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/authenticator.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,85 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Authentication for Computer Janitor backend services."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Authenticator',
+    ]
+
+
+import dbus
+
+
+PK_AUTHORITY_BUS_NAME = 'org.freedesktop.PolicyKit1'
+PK_AUTHORITY_OBJECT_PATH = '/org/freedesktop/PolicyKit1/Authority'
+PK_AUTHORITY_INTERFACE = 'org.freedesktop.PolicyKit1.Authority'
+# From the PolicyKit API.
+# http://hal.freedesktop.org/docs/polkit/
+# eggdbus-interface-org.freedesktop.PolicyKit1.Authority.html
+AllowUserInteraction = 0x00000001
+
+
+class Authenticator:
+    """PolicyKit authenticator."""
+
+    def authenticate(self, sender, connection, privilege):
+        """Authenticate with PolicyKit.
+
+        :param sender: The initiator of the action.
+        :param connection: The dbus connection that initiated the action.
+        :param privilege: The privilege being requested.
+        :return: Whether the subject is authorized or not.
+        :rtype: bool
+        """
+        policykit = self._get_policykit_proxy()
+        sender_pid = self._get_sender_pid(connection, sender)
+        # This is the CheckAuthorization() 'subject' structure.
+        subject = (
+            'unix-process', {
+                'pid': sender_pid,
+                'start-time': 0,
+                })
+        # No details or cancellation_id needed.
+        details = {'': ''}
+        cancellation_id = ''
+        flags = AllowUserInteraction
+        # CheckAuthorization returns an AuthorizationResult structure, modeled
+        # as a 3-tuple.  The only thing we care about though is the boolean
+        # describing whether we got authorized or not.
+        is_authorized, is_challenge, details = policykit.CheckAuthorization(
+            subject, privilege, details, flags, cancellation_id)
+        return is_authorized
+
+    def _get_policykit_proxy(self):
+        """Contact the system bus to get a PolicyKit proxy."""
+        system_bus = dbus.SystemBus()
+        pk_proxy = system_bus.get_object(
+            PK_AUTHORITY_BUS_NAME, PK_AUTHORITY_OBJECT_PATH)
+        return dbus.Interface(pk_proxy, PK_AUTHORITY_INTERFACE)
+
+    def _get_sender_pid(self, connection, sender):
+        """Contact the system bus to get the sender connection PID."""
+        # Since we're going to authorize a Unix process, we need to get the
+        # sender's process id.  This is available on the dbus.  The
+        # CheckAuthorization() method also requires us to have a start-time,
+        # but it's not clear what the semantics are for that, so we'll just
+        # put a zero there.
+        db_proxy = connection.get_object(
+            dbus.BUS_DAEMON_NAME, dbus.BUS_DAEMON_PATH, introspect=False)
+        info = dbus.Interface(db_proxy, dbus.BUS_DAEMON_IFACE)
+        return info.GetConnectionUnixProcessID(sender)

=== added file 'computerjanitord/collector.py'
--- computerjanitord/collector.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/collector.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,167 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""A cruft collector."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Collector',
+    ]
+
+
+import os
+import time
+import logging
+
+from computerjanitor import PluginManager
+from computerjanitord.errors import DuplicateCruftError, PackageCleanupError
+from computerjanitord.whitelist import Whitelist
+
+
+log = logging.getLogger('computerjanitor')
+MISSING = object()
+DEFAULT_PLUGINS_DIRS = "/usr/share/computerjanitor/plugins"
+
+# For testing purposes.
+SLEEPY_TIME = float(os.environ.get('COMPUTER_JANITOR_SLEEPY_TIME', '1.0'))
+
+
+class Collector:
+    """A cruft collector."""
+
+    def __init__(self, application, plugin_manager_class=None,
+                 whitelist_dirs=None, service=None):
+        """Create a cruft collector.
+
+        :param application: The `Application` class.
+        :type application: This object is used by plugins to access the apt
+            database.  It must have an attribute named `apt_cache` and a
+            method named `refresh_apt_cache()`.
+        :param plugin_manager_class: The plugin manager class.  If None (the
+            default), then `computerjanitor.PluginManager` is used.
+        :type plugin_manager_class: callable accepting a single argument,
+            which is a sequence of plugin directories.
+        :param whitelist_dirs: Sequence of directories to search for
+            '.whitelist' files.  Passed directly to
+            `computerjanitord.whitelist.Whitelist`.
+        :param service: The dbus service; when doing plugin post-cleanup, this
+            will be used to emit a progress signal.
+        """
+        self.application = application
+        self.service = service
+        self.whitelist = Whitelist(whitelist_dirs)
+        # Keep track of cruft and map between the cruft's name and its Cruft
+        # instance.  We'll use the latter when cruft cleanup is requested
+        # through the dbus API.
+        self.cruft = None
+        self.cruft_by_name = None
+        # Set up the plugin manager.
+        plugin_path = os.environ.get('COMPUTER_JANITOR_PLUGINS',
+                                     DEFAULT_PLUGINS_DIRS)
+        plugin_dirs = plugin_path.split(':')
+        if plugin_manager_class is None:
+            plugin_manager_class = PluginManager
+        self.plugin_manager = plugin_manager_class(application, plugin_dirs)
+        self.load()
+
+    def load(self):
+        """Reload all cruft."""
+        self.cruft = []
+        self.cruft_by_name = {}
+        # Ask all the plugins to find their cruft, filtering out whitelisted
+        # cruft.
+        for plugin in self.plugin_manager.get_plugins():
+            for cruft in plugin.get_cruft():
+                if not self.whitelist.is_whitelisted(cruft):
+                    # Different plugins can give us duplicate cruft names,
+                    # however the Cruft class better be the same, otherwise we
+                    # won't actually know how to map the name back to a cruft
+                    # instance for proper cleanup.
+                    if cruft.get_name() in self.cruft_by_name:
+                        my_cruft = self.cruft_by_name[cruft.get_name()]
+                        if cruft.__class__ is my_cruft.__class__:
+                            # We only need one instance of this cruft.
+                            continue
+                        else:
+                            raise DuplicateCruftError(cruft.get_name())
+                    #print '    ', cruft.get_name()
+                    self.cruft.append(cruft)
+                    self.cruft_by_name[cruft.get_name()] = cruft
+
+    def clean(self, names, dry_run=False):
+        """Clean up the named cruft.
+
+        :param names: The names of the cruft to clean up.
+        :type names: list of strings
+        :param dry_run: Flag indicating whether to do permanent changes.
+        :type dry_run: bool
+        """
+        for name in names:
+            # Ensure that all named cruft is known.
+            cruft = self.cruft_by_name.get(name, MISSING)
+            if cruft is MISSING:
+                log.error('No such cruft: {0}'.format(name))
+                raise NoSuchCruftError(name)
+            # Ensure that the cruft is not being ignored.
+            if cruft in self.service.state.ignore:
+                log.error('Skipping ignored cruft: {0}'.format(name))
+                continue
+            log.info('cleaning cruft{1}: {0}'.format(
+                cruft.get_name(), ('[X]' if dry_run else '[Y]')))
+            if not dry_run:
+                try:
+                    cruft.cleanup()
+                except:
+                    log.exception('cruft.cleanup(): {0}'.format(name))
+                    raise
+        # Do plugin-specific post-cleanup.
+        for plugin in self.plugin_manager.get_plugins():
+            log.info('post-cleanup: {0}'.format(plugin))
+            if self.service is not None:
+                # Notify the client that we're not done yet.
+                #
+                # 2010-02-09 barry: this actually kind of sucks because the
+                # granularity is too coarse.  Some plugins will post_cleanup()
+                # very quickly, others will take a long time.  Unfortunately,
+                # the computerjanitor.Plugin API doesn't support a more
+                # granular feedback.  Plugin.get_plugin(..., callback=foo)
+                # doesn't really cut it because that only gets called during
+                # get_plugins().
+                self.service.cleanup_status(plugin.__class__.__name__)
+            if dry_run:
+                # For testing purposes.
+                time.sleep(SLEEPY_TIME)
+            else:
+                try:
+                    plugin.post_cleanup()
+                except SystemError as error:
+                    # apt will raise a SystemError if some other package
+                    # manager is already running.  Turn this into a dbus
+                    # derived exception so the client will be properly
+                    # informed.
+                    log.exception(
+                        'plugin.post_cleanup(): {0}'.format(plugin))
+                    raise PackageCleanupError(str(error))
+                except:
+                    log.exception(
+                        'plugin.post_cleanup(): {0}'.format(plugin))
+                    raise
+        # Now we're done.
+        if self.service is not None:
+            self.service.cleanup_status('')
+        # Reload list of crufts.
+        self.application.refresh_apt_cache()
+        self.load()

=== added directory 'computerjanitord/data'
=== added file 'computerjanitord/data/com.ubuntu.ComputerJanitor.conf'
--- computerjanitord/data/com.ubuntu.ComputerJanitor.conf	1970-01-01 00:00:00 +0000
+++ computerjanitord/data/com.ubuntu.ComputerJanitor.conf	2011-02-28 18:58:01 +0000
@@ -0,0 +1,15 @@
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+        <policy user="root">
+                <allow own="com.ubuntu.ComputerJanitor"/>
+        </policy>
+
+        <policy context="default">
+                <allow send_interface="com.ubuntu.ComputerJanitor"/>
+                <allow receive_interface="com.ubuntu.ComputerJanitor"
+                       receive_sender="com.ubuntu.ComputerJanitor"/>
+        </policy>
+
+</busconfig>

=== added file 'computerjanitord/data/com.ubuntu.ComputerJanitor.service'
--- computerjanitord/data/com.ubuntu.ComputerJanitor.service	1970-01-01 00:00:00 +0000
+++ computerjanitord/data/com.ubuntu.ComputerJanitor.service	2011-02-28 18:58:01 +0000
@@ -0,0 +1,4 @@
+[D-BUS Service]
+Name=com.ubuntu.ComputerJanitor
+Exec=/usr/share/computerjanitor/janitord
+User=root

=== added file 'computerjanitord/data/com.ubuntu.computerjanitor.policy'
--- computerjanitord/data/com.ubuntu.computerjanitor.policy	1970-01-01 00:00:00 +0000
+++ computerjanitord/data/com.ubuntu.computerjanitor.policy	2011-02-28 18:58:01 +0000
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+<policyconfig>
+
+  <vendor>ComputerJanitor</vendor>
+  <vendor_url>https://launchpad.net/computer-janitor</vendor_url>
+
+  <action id="com.ubuntu.computerjanitor.updatesystem">
+    <description>Clean up packages that are no longer necessary</description>
+    <message>Removing unused packages requires authentication</message>
+    <defaults>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin_keep</allow_active>
+    </defaults>
+  </action>
+
+</policyconfig>

=== added file 'computerjanitord/errors.py'
--- computerjanitord/errors.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/errors.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,95 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Exceptions for the Computer Janitor daemon."""
+
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'DuplicateCruftError',
+    'LandmarkPackageError',
+    'MissingLandmarkError',
+    'NoSuchCruftError',
+    'NonDownloadableError',
+    'PermissionDeniedError',
+    ]
+
+
+import dbus
+import computerjanitor
+
+
+class DBusServiceBaseException(computerjanitor.Exception, dbus.DBusException):
+    """Base class exception for the Computer Janitor DBus service."""
+
+
+class PermissionDeniedError(DBusServiceBaseException):
+    """Permission denied by policy."""
+
+
+class CruftError(DBusServiceBaseException):
+    """Cruft exceptions passed back to dbus client."""
+
+    _errmsg = None
+
+    def __init__(self, cruft_name):
+        self.cruft_name = cruft_name
+
+    def __str__(self):
+        return self._errmsg.format(self)
+
+
+class DuplicateCruftError(CruftError):
+    """Duplicate cruft name with different cleanup."""
+
+    _errmsg = 'Duplicate cruft with different cleanup: {0.cruft_name}'
+
+
+class NoSuchCruftError(CruftError):
+    """There is no cruft by the given name."""
+
+    _errmsg = 'No such cruft: {0.cruft_name}'
+
+
+class LandmarkPackageError(DBusServiceBaseException):
+    """Base class for problems with the landmark packages."""
+
+    _errmsg = None
+
+    def __init__(self, package):
+        self.package = package
+
+    def __str__(self):
+        # gettext translation needs to be called at run time.
+        return self._errmsg.format(self)
+
+
+class MissingLandmarkError(LandmarkPackageError):
+    """A landmark package could not be found."""
+
+    _errmsg = 'Landmark package {0.package} is missing'
+
+
+class NonDownloadableError(LandmarkPackageError):
+    """A landmark package is not downloadable."""
+
+    _errmsg = 'Landmark package {0.package} is not downloadable'
+
+
+class PackageCleanupError(DBusServiceBaseException):
+    """Could not complete plugin post-cleanup."""
+
+    _errmsg = 'Post-cleanup exception'

=== added file 'computerjanitord/main.py'
--- computerjanitord/main.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/main.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,118 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Main entry point for Computer Janitor dbus daemon."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'main',
+    ]
+
+
+import os
+import gobject
+import logging
+import argparse
+import warnings
+import dbus.mainloop.glib
+import logging.handlers
+
+from computerjanitorapp import __version__, setup_gettext
+from computerjanitord.service import Service
+
+_ = setup_gettext()
+
+
+# 2010-02-09 barry: computerjanitor.package_cruft has a DeprecationWarning,
+# but that really needs to be fixed in that package, which in turn needs to be
+# ripped out of update-manager.
+warnings.filterwarnings('ignore', category=DeprecationWarning,
+                        module='computerjanitor.package_cruft')
+
+
+# As per aptdaemon, when run as a dbus service, we must add the necessary
+# paths to $PATH.
+REQUIRED_PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin'
+
+
+class Options:
+    """Command line options."""
+
+    def __init__(self):
+        self.parser = argparse.ArgumentParser(
+            description=_("""\
+            Computer janitor dbus daemon.  You must run this daemon as root.
+            """))
+        self.parser.add_argument(
+            '--version', action='version',
+            version=_('Computer Janitor dbus daemon {version}'.format(
+                version=__version__)))
+        self.parser.add_argument(
+            '-n', '--dry-run', action='store_true',
+            help=_("""\
+            Only pretend to do anything permanent.  This is useful for testing
+            and debugging."""))
+        self.parser.add_argument(
+            '-f', '--state-file', metavar='FILE',
+            help=_('Store ignored state in FILE instead of the default.'))
+        self.arguments = self.parser.parse_args()
+
+
+class ASCIIFormatter(logging.Formatter):
+    """Force the log messages to ASCII."""
+    def format(self, record):
+        message = logging.Formatter.format(self, record)
+        return message.encode('ascii', 'replace')
+
+
+def main():
+    """Main entry point."""
+    # Set up logging.
+    if os.environ.get('COMPUTER_JANITOR_DEBUG') is not None:
+        level = logging.DEBUG
+    else:
+        level = logging.INFO
+    # When running under dbus, $PATH will not be set.  However it must be in
+    # order to find dpkg(1) and friends.  Hard code it in the same way that
+    # aptdaemon does.
+    if os.environ.get('PATH') is None:
+        os.putenv('PATH', REQUIRED_PATH)
+    logging.basicConfig(level=level)
+    log = logging.getLogger('computerjanitor')
+    # SysLogHandler does not recognize unicode arguments.
+    syslog = logging.handlers.SysLogHandler(b'/dev/log')
+    # syslog will provide a timestamp.
+    formatter = ASCIIFormatter('computerjanitord:%(levelname)s: %(message)s')
+    syslog.setFormatter(formatter)
+    syslog.setLevel(level)
+    log.addHandler(syslog)
+    options = Options()
+    # Ensure that we're running as root.  Do this here instead of ../janitord
+    # so that we can still run 'janitord --version' and 'janitord --help' as
+    # non-root.
+    if os.getuid() != 0:
+        options.parser.error('You must run this as root')
+        # No return.
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    server = Service(options)
+    try:
+        gobject.MainLoop().run()
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == '__main__':
+    main()

=== added file 'computerjanitord/service.py'
--- computerjanitord/service.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/service.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,289 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""dbus service for cleaning up crufty packages that are no longer needed."""
+
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'Service',
+    ]
+
+
+import atexit
+import logging
+
+import dbus.service
+
+from computerjanitor import PackageCruft
+from computerjanitord.application import Application
+from computerjanitord.authenticator import Authenticator
+from computerjanitord.collector import Collector
+from computerjanitord.errors import NoSuchCruftError, PermissionDeniedError
+from computerjanitord.state import State, DEFAULT_STATE_FILE
+
+import glib
+
+log = logging.getLogger('computerjanitor')
+MISSING = object()
+
+DBUS_INTERFACE_NAME = 'com.ubuntu.ComputerJanitor'
+PRIVILEGE = 'com.ubuntu.computerjanitor.updatesystem'
+
+
+class Service(dbus.service.Object):
+    """Backend dbus service that handles removing crufty packages."""
+
+    def __init__(self, options):
+        """Create the dbus service.
+
+        :param options: The command line options class.
+        :type options: `Options`
+        """
+        self.dry_run = options.arguments.dry_run
+        self.state_file = (DEFAULT_STATE_FILE
+                           if options.arguments.state_file is None
+                           else options.arguments.state_file)
+        self.application = Application()
+        self.state = State()
+        self.state.load(self.state_file)
+        self.collector = Collector(self.application, service=self)
+        self.authenticator = Authenticator()
+        bus_name = dbus.service.BusName(
+            DBUS_INTERFACE_NAME, bus=dbus.SystemBus())
+        dbus.service.Object.__init__(self, bus_name, '/')
+        # We can't use the decorator because that doesn't work with methods;
+        # self doesn't get passed to the handler.
+        atexit.register(self._exit_handler)
+
+    def _exit_handler(self):
+        """Ensure that the state file is saved at exit."""
+        if not self.dry_run:
+            self.state.save(self.state_file)
+
+    def _authenticate(self, sender, connection):
+        """Authenticate via PolicyKit.
+
+        :param sender: The dbus client sender.
+        :param connection: The dbus client connection.
+        :raises PermissionDeniedError: when the authentication fails.
+        """
+        if not self.authenticator.authenticate(sender, connection, PRIVILEGE):
+            log.error('Permission denied: {0} for {1} on {2}'.format(
+                PRIVILEGE, sender, connection))
+            raise PermissionDeniedError(PRIVILEGE)
+        log.debug('Permission granted: {0} for {1} on {2}'.format(
+            PRIVILEGE, sender, connection))
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as')
+    def find(self):
+        """Find all the non-whitelisted cruft on the system.
+
+        Because this is a read-only interface it does not need authorization
+        to be called.
+
+        :return: A list of matching cruft names.
+        """
+        return list(cruft.get_name() for cruft in self.collector.cruft)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='b')
+    def find_async(self):
+        """Find all the non-whitelisted cruft on the system, asynchronously.
+
+        Because this is a read-only interface it does not need authorization
+        to be called.  Use this method when you can't wait for the cruft
+        searching process to complete, since it might take some time.  To
+        respond when the cruft has been found, set up a `find_finished` signal
+        handler.
+
+        :return: True
+        """
+        glib.timeout_add_seconds(1, self._find_async)
+        return True
+
+    def _find_async(self):
+        """Find all cruft asynchronously and call the signal handler."""
+        cruft = list(cruft.get_name() for cruft in self.collector.cruft)
+        self.find_finished(cruft)
+        # Only call the callback once.
+        return False
+
+    @dbus.service.signal(DBUS_INTERFACE_NAME, signature='as')
+    def find_finished(self, cruft):
+        """dbus signal called when `_find_async()` completes."""
+        log.debug('find_finished: {0}'.format(cruft))
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def load(self, sender=None, connection=None):
+        """Load the state file."""
+        self._authenticate(sender, connection)
+        self.state.load(self.state_file)
+        return list(self.state.ignore)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def save(self, sender=None, connection=None):
+        """Save the state file."""
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            self.state.save(self.state_file)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def ignore(self, name, sender=None, connection=None):
+        """Ignore the named cruft.
+
+        :param name: The name of the cruft to ignore.
+        :type filename: string
+        """
+        # Make sure this is known cruft first.
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('ignore(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            self.state.ignore.add(name)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def unignore(self, name, sender=None, connection=None):
+        """Unignore the named cruft.
+
+        :param name: The name of the cruft to unignore.
+        :type filename: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('ignore(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        self._authenticate(sender, connection)
+        if not self.dry_run:
+            # Don't worry if we're already not ignoring the cruft (i.e. don't
+            # raise a KeyError here if 'name' is not in the set).
+            self.state.ignore.discard(name)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         out_signature='as')
+    def ignored(self):
+        """Return the list of ignored cruft.
+
+        :return: The names of the ignored cruft.
+        :rtype: list of strings
+        """
+        return list(self.state.ignore)
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='s')
+    def get_description(self, name):
+        """Return the description of the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: The description of the cruft.
+        :rtype: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_description(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.get_description()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='s')
+    def get_shortname(self, name):
+        """Return the short name of the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: The short nameof the cruft.
+        :rtype: string
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_shortname(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.get_shortname()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='s',
+                         out_signature='st')
+    def get_details(self, name):
+        """Return some extra details about the named cruft.
+
+        :param name: The cruft name.
+        :type name: string
+        :return: Some extra details about the named cruft, specifically its
+            'type' and the amount of disk space it consumes.  The type is
+            simply the name of the cruft instance's class.
+        :rtype: string, uint64
+        """
+        cruft = self.collector.cruft_by_name.get(name, MISSING)
+        if cruft is MISSING:
+            log.error('get_shortname(): No such cruft: {0}'.format(name))
+            raise NoSuchCruftError(name)
+        return cruft.__class__.__name__, cruft.get_disk_usage()
+
+    @dbus.service.method(DBUS_INTERFACE_NAME,
+                         in_signature='as', # array of strings
+                         # Must wrap these in str() because Python < 2.6.5
+                         # does not like unicode keyword arguments.
+                         sender_keyword=str('sender'),
+                         connection_keyword=str('connection'))
+    def clean(self, names, sender=None, connection=None):
+        """Clean the named crufts.
+
+        :param names: The names of the cruft to clean.
+        :type names: list of strings
+        """
+        self._authenticate(sender, connection)
+        self.collector.clean(names, self.dry_run)
+
+    @dbus.service.signal(DBUS_INTERFACE_NAME,
+                         signature='s')
+    def cleanup_status(self, cruft):
+        """Signal cleanup status.
+
+        This signal is used to incrementally inform clients that some cleanup
+        work is being done.  It is called at the beginning of the cleanup
+        process and after each plugin has completed its `post_cleanup()`
+        method.
+
+        :param done: The name of the next piece of cruft to be cleaned up, or
+            the empty string when there's nothing left to do.
+        :type done: string
+        """
+        log.debug('cleanup_status: {0}'.format(cruft))

=== added file 'computerjanitord/state.py'
--- computerjanitord/state.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/state.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,92 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Maintaining package ignored state."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'DEFAULT_STATE_FILE',
+    'State',
+    ]
+
+
+import ConfigParser
+import textwrap
+
+
+DEFAULT_STATE_FILE = '/var/lib/computer-janitor/state.dat'
+
+
+class State:
+    """Maintain the state of cruft which should be ignored.
+
+    The file's format is a `ConfigParser` style .ini file.  Each section is a
+    cruft's `.get_name()` value and contains a single boolean setting
+    `ignore`.  If true, then the cruft is ignored.
+
+    For backward compatibility purposes, the setting `enabled` is also
+    recognized (on read only).  If `enabled` is false then the cruft is
+    ignored.
+    """
+
+    def __init__(self):
+        self.ignore = set()
+
+    def load(self, filename):
+        """Load ignored state from a file.
+
+        This reset any previously determined state and re-initializes it with
+        the state stored in the file.
+
+        :param filename: The file to load.
+        :type filename: string
+        """
+        parser = ConfigParser.ConfigParser()
+        parser.read(filename)
+        # Reset the set of ignored packages.
+        self.ignore = set()
+        for cruft_name in parser.sections():
+            # For backwards compatibility, recognize both the 'ignore' setting
+            # and the 'enabled' setting.  We only write the former.
+            try:
+                ignore = parser.getboolean(cruft_name, 'ignore')
+            except ConfigParser.NoOptionError:
+                try:
+                    ignore = not parser.getboolean(cruft_name, 'enabled')
+                except ConfigParser.NoOptionError:
+                    # No other settings are recognized.
+                    ignore = False
+            if ignore:
+                self.ignore.add(cruft_name)
+
+    def save(self, filename):
+        """Save the ignored state to a file.
+
+        Only the packages being ignored are stored to the file, and writing
+        overwrites the previous contents of the file.
+        
+        :param filename: The file to load.
+        :type filename: string
+        """
+        # It's easier just to write the .ini file directly instead of using
+        # the ConfigParser interface.  This way we can guarantee sort order
+        # and can automatically cull unignored packages from the file.
+        with open(filename, 'w') as fp:
+            for cruft_name in self.ignore:
+                print >> fp, textwrap.dedent("""\
+                [{0}]
+                ignore: true
+                """.format(cruft_name))

=== added directory 'computerjanitord/tests'
=== added file 'computerjanitord/tests/__init__.py'
=== added directory 'computerjanitord/tests/data'
=== added file 'computerjanitord/tests/data/empty'
=== added directory 'computerjanitord/tests/data/etc'
=== added directory 'computerjanitord/tests/data/etc/apt'
=== added file 'computerjanitord/tests/data/etc/apt/sources.list'
--- computerjanitord/tests/data/etc/apt/sources.list	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/etc/apt/sources.list	2011-02-28 18:58:01 +0000
@@ -0,0 +1,1 @@
+deb http://archive.ubuntu.com/ubuntu intrepid main restricted

=== added directory 'computerjanitord/tests/data/var'
=== added directory 'computerjanitord/tests/data/var/cache'
=== added directory 'computerjanitord/tests/data/var/cache/apt'
=== added directory 'computerjanitord/tests/data/var/cache/apt/archives'
=== added directory 'computerjanitord/tests/data/var/cache/apt/archives/partial'
=== added directory 'computerjanitord/tests/data/var/lib'
=== added directory 'computerjanitord/tests/data/var/lib/apt'
=== added directory 'computerjanitord/tests/data/var/lib/apt/lists'
=== added file 'computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages'
--- computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/var/lib/apt/lists/archive.ubuntu.com_ubuntu_dists_intrepid_restricted_binary-i386_Packages	2011-02-28 18:58:01 +0000
@@ -0,0 +1,54 @@
+Package: dash
+Priority: required
+Section: shells
+Installed-Size: 236
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Gerrit Pape <[e-mail]>
+Architecture: all
+Version: 0.5.5.1-3ubuntu1
+Depends: debianutils (>= 2.15), dpkg (>= 1.15.0)
+Pre-Depends: libc6 (>= 2.11~20100104-0ubuntu2)
+Filename: pool/main/d/dash/dash_0.5.5.1-3ubuntu1_all.deb
+Size: 104190
+MD5sum: a7f08fe3ee941d06c0d98e5e99c02190
+SHA1: d2dda78f9a6f82c58c01d34f18b94aebfcb33f19
+SHA256: 69709747f854ac1bd671dff37b47c18e589b095ecb8f3116beaed7fc0eeb657e
+Description: POSIX-compliant shell
+ The Debian Almquist Shell (dash) is a POSIX-compliant shell derived
+ from ash.
+ .
+ Since it executes scripts faster than bash, and has fewer library
+ dependencies (making it more robust against software or hardware
+ failures), it is used as the default system shell on Debian systems.
+Homepage: http://gondor.apana.org.au/~herbert/dash/
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+
+Package: gzip
+Essential: yes
+Priority: required
+Section: utils
+Installed-Size: 284
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Bdale Garbee <[e-mail]>
+Architecture: all
+Version: 1.3.12-9ubuntu1
+Pre-Depends: libc6 (>= 2.4)
+Suggests: less
+Filename: pool/main/g/gzip/gzip_1.3.12-9ubuntu1_all.deb
+Size: 107030
+MD5sum: f64beb93d2d1a3348cfc47f1fd176ee1
+SHA1: 3dd3e56f551fb85ba2ad385df463adeff1fff2d9
+SHA256: 2545f0a28514535006adf9ee8576ca3be2aa6da3d890047f92eeda18c0e3aa57
+Description: GNU compression utilities
+ This package provides the standard GNU file compression utilities, which
+ are also the default compression tools for Debian.  They typically operate
+ on files with names ending in '.gz', but can also decompress files ending
+ in '.Z' created with 'compress'.
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+

=== added directory 'computerjanitord/tests/data/var/lib/apt/lists/partial'
=== added directory 'computerjanitord/tests/data/var/lib/dpkg'
=== added file 'computerjanitord/tests/data/var/lib/dpkg/status'
--- computerjanitord/tests/data/var/lib/dpkg/status	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/data/var/lib/dpkg/status	2011-02-28 18:58:01 +0000
@@ -0,0 +1,28 @@
+Package: dash-nodownload
+Priority: required
+Section: shells
+Installed-Size: 236
+Maintainer: Ubuntu Core Developers <[e-mail]>
+Original-Maintainer: Gerrit Pape <[e-mail]>
+Architecture: all
+Version: 0.5.5.1-3ubuntu1
+Depends: debianutils (>= 2.15), dpkg (>= 1.15.0)
+Pre-Depends: libc6 (>= 2.11~20100104-0ubuntu2)
+Filename: pool/main/d/dash/dash_0.5.5.1-3ubuntu1_all.deb
+Size: 104190
+MD5sum: a7f08fe3ee941d06c0d98e5e99c02190
+SHA1: d2dda78f9a6f82c58c01d34f18b94aebfcb33f19
+SHA256: 69709747f854ac1bd671dff37b47c18e589b095ecb8f3116beaed7fc0eeb657e
+Description: POSIX-compliant shell
+ The Debian Almquist Shell (dash) is a POSIX-compliant shell derived
+ from ash.
+ .
+ Since it executes scripts faster than bash, and has fewer library
+ dependencies (making it more robust against software or hardware
+ failures), it is used as the default system shell on Debian systems.
+Homepage: http://gondor.apana.org.au/~herbert/dash/
+Bugs: https://bugs.launchpad.net/ubuntu/+filebug
+Origin: Ubuntu
+Supported: 5y
+Task: minimal
+

=== added file 'computerjanitord/tests/test_all.py'
--- computerjanitord/tests/test_all.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_all.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,41 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test suite for Computer Janitor daemon (dbus backend)."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import unittest
+
+from computerjanitord.tests import test_application
+from computerjanitord.tests import test_authenticator
+from computerjanitord.tests import test_collector
+from computerjanitord.tests import test_state
+from computerjanitord.tests import test_whitelist
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(test_application.test_suite())
+    suite.addTests(test_authenticator.test_suite())
+    suite.addTests(test_collector.test_suite())
+    suite.addTests(test_state.test_suite())
+    suite.addTests(test_whitelist.test_suite())
+    return suite

=== added file 'computerjanitord/tests/test_application.py'
--- computerjanitord/tests/test_application.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_application.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,106 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test the plugin application interfaces."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'ApplicationTestSetupMixin',
+    'test_suite',
+    ]
+
+
+import os
+import apt
+import apt_pkg
+import unittest
+import warnings
+import pkg_resources
+
+from contextlib import contextmanager
+
+import computerjanitor
+import computerjanitord.application
+
+from computerjanitord.application import (
+    Application, MissingLandmarkError, NonDownloadableError)
+
+
+@contextmanager
+def landmarks(*packages):
+    # Hack the module global list of known landmark packages.
+    old_landmarks = computerjanitord.application.LANDMARK_PACKAGES[:]
+    computerjanitord.application.LANDMARK_PACKAGES[:] = packages
+    yield
+    computerjanitord.application.LANDMARK_PACKAGES[:] = old_landmarks
+
+
+class MockCruft:
+    def __init__(self, name):
+        self.name = name
+
+    def get_name(self):
+        warnings.warn('.get_name() is deprecated; use .name',
+                      DeprecationWarning)
+        return self.name
+
+
+class ApplicationTestSetupMixin:
+    """Set up an `Application` instance with test data in its apt_cache."""
+
+    def setUp(self):
+        self.data_dir = os.path.abspath(
+            pkg_resources.resource_filename('computerjanitord.tests', 'data'))
+        # Make the test insensitive to the platform's architecture.
+        apt_pkg.Config.Set('APT::Architecture', 'i386')
+        self.cache = apt.Cache(rootdir=self.data_dir)
+        self.app = Application(self.cache)
+
+    def tearDown(self):
+        # Clear the cache.
+        cache_dir = os.path.join(self.data_dir, 'var', 'cache', 'apt')
+        for filename in os.listdir(cache_dir):
+            if filename.endswith('.bin'):
+                os.remove(os.path.join(cache_dir, filename))
+
+
+class TestApplication(unittest.TestCase, ApplicationTestSetupMixin):
+    """Test the `Application` interface."""
+
+    def setUp(self):
+        ApplicationTestSetupMixin.setUp(self)
+
+    def tearDown(self):
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_verify_apt_cache_good_path(self):
+        # All essential packages are in the cache by default.
+        self.assertEqual(self.app.verify_apt_cache(), None)
+
+    def test_verify_apt_cache_with_nondownloadable_landmark(self):
+        # Test that a missing landmark file causes an exception.
+        with landmarks('gzip', 'dash-nodownload'):
+            self.assertRaises(NonDownloadableError, self.app.verify_apt_cache)
+
+    def test_verify_apt_cache_with_missing_landmark(self):
+        with landmarks('gzip', 'dash', 'i-am-not-here'):
+            self.assertRaises(MissingLandmarkError, self.app.verify_apt_cache)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestApplication))
+    return suite

=== added file 'computerjanitord/tests/test_authenticator.py'
--- computerjanitord/tests/test_authenticator.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_authenticator.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,97 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test the authenticator."""
+
+import unittest
+
+from computerjanitord.authenticator import Authenticator
+
+SUCCESS_PID = 801
+FAILURE_PID = 999
+
+AUTHENTICATED_USER = 'desktop-user'
+IMPOSTER_USER = 'imposter'
+EXPECTED_PRIVILEGE = 'com.ubuntu.computerjanitor.cleanpackages'
+BOGUS_PRIVILEGE = 'com.example.evil-corp.killsystem'
+
+
+class MockPolicyKit(object):
+    """Mock the PolicyKit's CheckAuthorization() method."""
+
+    def CheckAuthorization(self, subject, privilege, details, flags,
+                           cancellation_id):
+        """See `policykit.CheckAuthorization()`.
+
+        :return: (is_authorized, is_challenge, details)
+        """
+        if privilege == BOGUS_PRIVILEGE:
+            return False, False, ''
+        assert isinstance(subject, tuple) and len(subject) == 2, (
+            'subject is not a 2-tuple')
+        assert subject[0] == 'unix-process', 'Badly formed subject'
+        assert isinstance(subject[1], dict), 'Badly formed subject details'
+        assert subject[1]['start-time'] == 0, 'subject missing start-time'
+        if subject[1]['pid'] == SUCCESS_PID:
+            return True, False, ''
+        else:
+            return False, False, ''
+
+
+class TestableAuthenticator(Authenticator):
+    """See `Authenticator`."""
+
+    def _get_policykit_proxy(self):
+        """See `Authenticator`."""
+        return MockPolicyKit()
+
+    def _get_sender_pid(self, connection, sender):
+        """See `Authenticator`."""
+        if sender == AUTHENTICATED_USER:
+            return SUCCESS_PID
+        else:
+            return FAILURE_PID
+
+
+class TestAuthenticator(unittest.TestCase):
+    """Tests of the PolicyKit authenticator."""
+
+    def setUp(self):
+        """See `unittest.TestCase`."""
+        self.authenticator = TestableAuthenticator()
+        self.connection = object()
+
+    def tearDown(self):
+        """See `unittest.TestCase`."""
+
+    def test_good_path(self):
+        # Test for successful authentication.
+        self.assertTrue(self.authenticator.authenticate(
+            AUTHENTICATED_USER, self.connection, EXPECTED_PRIVILEGE))
+
+    def test_bogus_privilege(self):
+        # Test for bogus privilege fails.
+        self.assertFalse(self.authenticator.authenticate(
+            AUTHENTICATED_USER, self.connection, BOGUS_PRIVILEGE))
+
+    def test_unauthorized(self):
+        # Test for some imposter not being able to authenticate.
+        self.assertFalse(self.authenticator.authenticate(
+            IMPOSTER_USER, self.connection, EXPECTED_PRIVILEGE))
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestAuthenticator))
+    return suite

=== added file 'computerjanitord/tests/test_collector.py'
--- computerjanitord/tests/test_collector.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_collector.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,225 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test the cruft collector."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import shutil
+import apt_pkg
+import tempfile
+import unittest
+import pkg_resources
+import multiprocessing
+
+from computerjanitor.plugin import Plugin
+from computerjanitord.collector import Collector
+from computerjanitord.errors import DuplicateCruftError, PackageCleanupError
+from computerjanitord.tests.test_application import ApplicationTestSetupMixin
+
+
+LOCK_FILE = pkg_resources.resource_filename(
+    'computerjanitord.tests',
+    os.path.join('data', 'var', 'lib', 'dpkg', 'status'))
+
+
+class MockCruft:
+    """Mock cruft that supports the required `get_name()` interface."""
+
+    def __init__(self, name):
+        self.name = name
+
+    def get_name(self):
+        return self.name
+
+
+class MockPlugin(Plugin):
+    cruft_class = MockCruft
+
+    def __init__(self, prefix, shortnames):
+        super(MockPlugin, self).__init__()
+        self.prefix = prefix
+        self.shortnames = shortnames
+
+    def get_cruft(self):
+        for shortname in self.shortnames:
+            yield self.cruft_class('{0}:{1}'.format(self.prefix, shortname))
+
+
+class SawAppPlugin(Plugin):
+    """All this plugin does is set a marker attribute on the `Application`.
+
+    This proves that access to the application through the plugin works.
+    """
+    def get_cruft(self):
+        self.app.saw_app_plugin = True
+        return []
+
+
+class LockingPlugin(Plugin):
+    """All this plugin does is acquire a fake apt lock after cleanup."""
+
+    def get_cruft(self):
+        return []
+
+    def post_cleanup(self):
+        # If the lock cannot be acquired, an exception is raised.
+        with apt_pkg.FileLock(LOCK_FILE):
+            # Do something.
+            pass
+
+
+class MockPluginManager:
+    def __init__(self, app, plugin_dirs):
+        # Ignore plugin_dirs
+        self.app = app
+
+    def get_plugins(self):
+        shortnames = ('one', 'two', 'three')
+        for prefix in ('foo', 'bar', 'baz'):
+            plugin = MockPlugin(prefix, shortnames)
+            plugin.set_application(self.app)
+            yield plugin
+        for plugin_class in (SawAppPlugin, LockingPlugin):
+            plugin = plugin_class()
+            plugin.set_application(self.app)
+            yield plugin
+
+
+class MockCruftExtra(MockCruft):
+    """Cruft with a different class."""
+
+
+class MockPluginExtra(MockPlugin):
+    """A mock plugin that returns cruft with a different class."""
+
+    cruft_class = MockCruftExtra
+
+
+class IgnoredDuplicateCruftPluginManager(MockPluginManager):
+    """Add an additional piece of ignorable duplication cruft."""
+    
+    def __init__(self, app, plugin_dirs):
+        self.app = app
+        # Ignore plugin_dirs
+
+    def get_plugins(self):
+        yield MockPlugin('one', ('foo', 'bar'))
+        yield MockPlugin('one', ('baz', 'foo'))
+
+
+class BadDuplicateCruftPluginManager(MockPluginManager):
+    """Add an additional piece of bad duplicate cruft."""
+    def __init__(self, app, plugin_dirs):
+        self.app = app
+        # Ignore plugin_dirs
+
+    def get_plugins(self):
+        yield MockPlugin('one', ('foo', 'bar'))
+        yield MockPluginExtra('one', ('baz', 'foo'))
+
+
+class TestCollector(unittest.TestCase, ApplicationTestSetupMixin):
+    """Test the cruft collector."""
+
+    def setUp(self):
+        # Set up the test data Application.
+        ApplicationTestSetupMixin.setUp(self)
+        self.tempdir = tempfile.mkdtemp()
+        whitelist_dirs = (self.tempdir,)
+        with open(os.path.join(self.tempdir, 'one.whitelist'), 'w') as fp:
+            print >> fp, 'foo:two'
+            print >> fp, 'bar:one'
+            print >> fp, 'baz:three'
+        self.collector = Collector(self.app, MockPluginManager, whitelist_dirs)
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_cruft_collector(self):
+        cruft_names = set(cruft.get_name() for cruft in self.collector.cruft)
+        self.assertEqual(cruft_names, set(('foo:one', 'foo:three',
+                                           'bar:two', 'bar:three',
+                                           'baz:one', 'baz:two')))
+
+    def test_plugin_needs_application(self):
+        # SawAppPlugin returned by the MockPluginManager sets this attribute
+        # on the Application.
+        self.assertTrue(self.app.saw_app_plugin)
+
+    def test_collector_name_mapping(self):
+        cruft_keys = set(self.collector.cruft_by_name)
+        cruft_names = set(cruft.get_name() for cruft in self.collector.cruft)
+        self.assertEqual(cruft_keys, cruft_names)
+
+    def test_cleanup_lock(self):
+        # Pretend we're running synaptic at the same time.  We have to acquire
+        # this fake-synaptic lock in a subprocess.
+        lock_event = multiprocessing.Event()
+        continue_event = multiprocessing.Event()
+        class AptLockThread(multiprocessing.Process):
+            def run(self):
+                with apt_pkg.FileLock(LOCK_FILE):
+                    lock_event.set()
+                    continue_event.wait(1.0)
+        apt_locker = AptLockThread()
+        apt_locker.start()
+        lock_event.wait(1.0)
+        self.assertRaises(PackageCleanupError, self.collector.clean, [])
+        continue_event.set()
+
+
+class TestDuplicateCruftCollector(
+    unittest.TestCase, ApplicationTestSetupMixin):
+
+    def setUp(self):
+        # Set up the test data Application.
+        ApplicationTestSetupMixin.setUp(self)
+
+    def tearDown(self):
+        ApplicationTestSetupMixin.tearDown(self)
+
+    def test_duplicate_cruft_error(self):
+        self.assertRaises(DuplicateCruftError, Collector,
+                          self.app, BadDuplicateCruftPluginManager, [])
+
+    def test_duplicate_cruft_error_message(self):
+        try:
+            Collector(self.app, BadDuplicateCruftPluginManager, [])
+        except DuplicateCruftError as error:
+            self.assertEqual(
+                str(error),
+                'Duplicate cruft with different cleanup: one:foo')
+        else:
+            raise AssertionError('DuplicateCruftError expected')
+
+    def test_ignored_duplicate_cruft(self):
+        collector = Collector(self.app, IgnoredDuplicateCruftPluginManager, [])
+        self.assertEqual(list(cruft.get_name() for cruft in collector.cruft),
+                         ['one:foo', 'one:bar', 'one:baz'])
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestCollector))
+    suite.addTests(unittest.makeSuite(TestDuplicateCruftCollector))
+    return suite

=== added file 'computerjanitord/tests/test_state.py'
--- computerjanitord/tests/test_state.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_state.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,141 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test the package state."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import difflib
+import tempfile
+import textwrap
+import unittest
+
+from computerjanitord.state import State
+
+NL = '\n'
+
+
+class TestState(unittest.TestCase):
+    """Test the `State` class."""
+
+    def setUp(self):
+        self.state = State()
+        # Create a temporary file with some enabled and disabled packages.
+        fd, self._state_file = tempfile.mkstemp()
+        os.close(fd)
+        with open(self._state_file, 'w') as fp:
+            print >> fp, textwrap.dedent("""\
+            [deb:foo]
+            ignore: false
+            [deb:bar]
+            ignore: true
+            [deb:baz]
+            ignore: true
+            """)
+        fd, self._state_file_old = tempfile.mkstemp()
+        os.close(fd)
+        with open(self._state_file_old, 'w') as fp:
+            print >> fp, textwrap.dedent("""\
+            [deb:qux]
+            enabled: false
+            [deb:fno]
+            enabled: true
+            [deb:bla]
+            enabled: true
+            """)
+        fd, self._write_file = tempfile.mkstemp()
+        os.close(fd)
+
+    def tearDown(self):
+        os.remove(self._state_file)
+        os.remove(self._state_file_old)
+        os.remove(self._write_file)
+
+    def assertEqualNdiff(self, expected, got):
+        expected_lines = expected.splitlines()
+        got_lines = got.splitlines()
+        self.assertEqual(
+            expected, got,
+            '\n' + NL.join(difflib.ndiff(expected_lines, got_lines)))
+
+    def test_initially_no_previously_ignored(self):
+        self.assertEqual(self.state.ignore, set())
+
+    def test_load_state(self):
+        self.state.load(self._state_file)
+        self.assertEqual(self.state.ignore, set(('deb:bar', 'deb:baz')))
+
+    def test_backward_compatibility_file_format(self):
+        # Here, enabled:false means to ignore the package.
+        self.state.load(self._state_file_old)
+        self.assertEqual(self.state.ignore, set(('deb:qux',)))
+
+    def test_ignore(self):
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.add('deb:baz')
+        self.assertEqual(self.state.ignore, set(('deb:buz', 'deb:baz')))
+
+    def test_more_ignores(self):
+        self.state.load(self._state_file)
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.add('deb:baz')
+        self.assertEqual(self.state.ignore,
+                         set(('deb:bar', 'deb:buz', 'deb:baz')))
+
+    def test_unignore(self):
+        self.state.load(self._state_file)
+        self.state.ignore.remove('deb:bar')
+        self.assertEqual(self.state.ignore, set(('deb:baz',)))
+
+    def test_write(self):
+        self.state.load(self._state_file)
+        self.state.ignore.add('deb:buz')
+        self.state.ignore.remove('deb:baz')
+        self.state.save(self._write_file)
+        with open(self._write_file) as fp:
+            got = fp.read()
+        expected = textwrap.dedent("""\
+        [deb:bar]
+        ignore: true
+
+        [deb:buz]
+        ignore: true
+
+        """)
+        self.assertEqualNdiff(expected, got)
+
+    def test_write_new_format(self):
+        self.state.load(self._state_file_old)
+        self.state.save(self._write_file)
+        with open(self._write_file) as fp:
+            got = fp.read()
+        expected = textwrap.dedent("""\
+        [deb:qux]
+        ignore: true
+
+        """)
+        self.assertEqualNdiff(expected, got)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+    suite.addTests(unittest.makeSuite(TestState))
+    return suite

=== added file 'computerjanitord/tests/test_whitelist.py'
--- computerjanitord/tests/test_whitelist.py	1970-01-01 00:00:00 +0000
+++ computerjanitord/tests/test_whitelist.py	2011-02-28 18:58:01 +0000
@@ -0,0 +1,119 @@
+# Copyright (C) 2008, 2009, 2010  Canonical, Ltd.
+#
+# 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, version 3 of the License.
+#
+# 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/>.
+
+"""Test the whitelister."""
+
+from __future__ import absolute_import, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'test_suite',
+    ]
+
+
+import os
+import shutil
+import tempfile
+import unittest
+
+from computerjanitord.whitelist import Whitelist
+
+