Merge lp:~ubuntuone-control-tower/ubuntu/karmic/desktopcouch/spb into lp:ubuntu/karmic/desktopcouch

[Chad Miller]

[Chad Miller (cmiller)]

New upstream bugfix-only release.

[James Westby (james-w)]

Hi,

The watch file doesn't match the tarball name for this release.
If you are going to name the tarball like this then you should
update the watch file.

Uploading anyway, as this is for the alpha. Please correct for the
next upload.

Thanks,

James

review: Approve

=== added file 'COPYING'
--- COPYING	1970-01-01 00:00:00 +0000
+++ COPYING	2009-07-09 20:17:15 +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>.
+

=== added file 'COPYING.LESSER'
--- COPYING.LESSER	1970-01-01 00:00:00 +0000
+++ COPYING.LESSER	2009-07-13 15:53:45 +0000
@@ -0,0 +1,165 @@
+		   GNU LESSER 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.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser 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
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2009-08-26 21:18:02 +0000
@@ -0,0 +1,13 @@
+include COPYING COPYING.LESSER README
+recursive-include data *.tmpl
+include desktopcouch-pair.desktop.in
+include po/POTFILES.in
+include start-desktop-couchdb.sh
+include stop-desktop-couchdb.sh
+include desktopcouch/records/doc/records.txt
+include bin/*
+include docs/man/*
+include MANIFEST.in MANIFEST
+include org.desktopcouch.CouchDB.service
+recursive-include contrib *.py
+

=== added file 'README'
--- README	1970-01-01 00:00:00 +0000
+++ README	2009-08-07 12:43:11 +0000
@@ -0,0 +1,35 @@
+This is Desktop Couch, an infrastructure to place a CouchDB on every desktop
+and provide APIs and management tools for applications to store data within
+it and share that data between computers and to the cloud.
+
+= Technical notes =
+
+== Creating databases, design documents, and views ==
+
+Desktop Couch will automatically create databases and design documents for you
+on startup by inspecting the filesystem, meaning that you do not need to check
+in your application whether your views exist. It is of course possible to create
+views directly through the Records API, but having them created via the 
+filesystem allows managing of the view definitions more easily (they are
+in separately editable files, which helps with version control) and packaging
+(the files can be separately stored in a distribution package and installed
+into the system-level XDG_DATA_DIR rather than the user-level folder).
+
+=== To create a database ===
+
+Create a file $XDG_DATA_DIR/desktop-couch/databases/YOUR_DB_NAME/database.cfg
+
+This file can currently be empty (in future it may contain database setup and
+configuration information). 
+
+=== To create a design document ===
+
+Create a file 
+$XDG_DATA_DIR/desktop-couch/databases/YOUR_DB_NAME/_design/DESIGN_DOC_NAME/views/VIEW_NAME/map.js
+containing the map function from your view.
+If you also require a reduce function for your view, create a file 
+$XDG_DATA_DIR/desktop-couch/databases/YOUR_DB_NAME/_design/DESIGN_DOC_NAME/views/VIEW_NAME/reduce.js.
+
+This is compatible with the filesystem view structure from CouchApp and 
+CouchDBKit.
+

=== added directory 'bin'
=== added file 'bin/desktopcouch-pair'
--- bin/desktopcouch-pair	1970-01-01 00:00:00 +0000
+++ bin/desktopcouch-pair	2009-08-31 15:27:31 +0000
@@ -0,0 +1,796 @@
+#!/usr/bin/python
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+# vim: filetype=python expandtab smarttab
+
+__doc__ = """\
+A tool to aid two local machines to agree to perform some action, after
+meatspace verification of identity.  The action so far is to make two machines
+replicate their couchdb instances to each other.
+
+Authentication
+--------------
+
+One machine, Alice, sets herself to listen for invitations to pair with another
+machine.  In doing so, Alice is discoverable via Zeroconf on local network.
+
+Another machine, Bob, sees the advertisement and generates a secret message and
+a public seed.  Bob then computes the SHA512 digest of the secret, and sends an
+invitation to Alice, in the form of the hex digest concatenated with the public
+seed.  Bob displays the secret to the user, who walks the secret over to Alice.
+
+Alice then computes the SHA512 digest of Bob's secret and compares it to be
+sure that the other machine is indeed the user's.  Alice then concatenates
+Bob's secret and the public seed, and sends the resulting hex digest back to 
+Bob to prove that she received the secret from the user.  Alice sets herself to
+replicate to Bob.
+
+Bob computes the secret+publicseed digest and compares it with the received hex
+digest from Alice.  When it matches, he sets himself to replicate to Alice.
+"""
+
+
+
+import logging
+import getpass
+import gettext
+# gettext implements "_" function.  pylint: disable-msg=E0602
+import random
+import cgi
+
+from twisted.internet import gtk2reactor
+gtk2reactor.install()
+from twisted.internet.reactor import run as run_program
+from twisted.internet.reactor import stop as stop_program
+
+import pygtk
+pygtk.require('2.0')
+import gtk
+import gobject
+import pango
+
+from desktopcouch.pair.couchdb_pairing import network_io
+from desktopcouch.pair.couchdb_pairing import dbus_io
+from desktopcouch.pair import pairing_record_type
+
+discovery_tool_version = "1"
+
+CLOUD_SERVICES = {}
+
+def generate_secret(length=7):
+    """Create a secret that is easy to write and read.  We hate ambiguity and
+    errors."""
+
+    pool = "abcdefghijklmnopqrstuvwxyz23456789#$%&*+=-"
+    return unmap_easily_mistaken(
+            "".join(random.choice(pool) for n in range(length)))
+
+def unmap_easily_mistaken(user_input):
+    """Returns ASCII-encoded text with visually-ambiguous characters crushed
+    down to some common atom."""
+
+    import string
+    easily_mistaken = string.maketrans("!10@", "lloo")
+    return string.translate(user_input.lower().encode("ascii"), easily_mistaken)
+
+def get_host_info():
+    """Create some text that hopefully identifies this host out of many."""
+
+    import platform
+
+    try:
+        uptime_seconds = int(float(file("/proc/uptime").read().split()[0]))
+        days, uptime_seconds = divmod(uptime_seconds, 60*60*24)
+        hours, uptime_seconds = divmod(uptime_seconds, 60*60)
+        minutes, seconds = divmod(uptime_seconds, 60)
+
+        # Is ISO8601 too nerdy? ...
+        #uptime_descr = ", up PT%(days)dD%(hours)dH%(minutes)dM" % locals()
+        uptime_descr = ", up %(days)dd %(hours)dh%(minutes)dm" % locals()
+    except OSError:
+        uptime_descr = ""
+
+    try:
+        return " ".join(platform.dist()) + uptime_descr
+    except AttributeError:
+        return platform.platform() + uptime_descr
+
+
+class Inviting:
+    """We're part of "Bob" in the module's story.
+
+    We see listeners on the network and send invitations to pair with us.
+    We generate a secret message and a public seed.  We get the SHA512 hex
+    digest of the secret message, append the public seed and send it to 
+    Alice.  We also display the cleartext of the secret message to the 
+    screen, so that the user can take it to the machine he thinks is Alice.
+
+    Eventually, we receive a message back from Alice.  We compute the 
+    secret message we started with concatenated with the public seed, and 
+    if that matches Alice's message, then Alice must know the secret we 
+    displayed to the user.  We then set outselves to replicate to Alice."""
+
+    def delete_event(self, widget, event, data=None):
+        """User requested window be closed.  False to propogate event."""
+        return False
+
+    def destroy(self, widget, data=None):
+        """The window is destroyed."""
+        self.inviter.close()
+
+    def auth_completed(self, remote_host, remote_port, remote_info):
+        """The auth stage is finished.  Now pair with the remote host."""
+        pair_with_host(remote_host, remote_port, remote_info)
+        self.window.destroy()
+
+    def on_close(self):
+        """When a socket is closed, we should stop inviting.  (?)"""
+        self.window.destroy()
+
+    def __init__(self, service, hostname, port):
+        self.logging = logging.getLogger(self.__class__.__name__)
+
+        self.hostname = hostname
+        self.port = port
+
+        self.window = gtk.Window()
+        self.window.set_border_width(6)
+        self.window.connect("delete_event", self.delete_event)
+        self.window.connect("destroy", self.destroy)
+        self.window.set_destroy_with_parent(True)
+        self.window.set_title(
+                _("Inviting %s to pair for CouchDB Pairing") % hostname)
+
+        secret_message = generate_secret()
+        self.secret_message = secret_message
+        self.public_seed = generate_secret()
+
+        self.inviter = network_io.start_send_invitation(hostname, port, 
+                self.auth_completed, self.secret_message, self.public_seed,
+                self.on_close)
+
+        top_vbox = gtk.VBox()
+        self.window.add(top_vbox)
+
+        text = gtk.Label()
+        text.set_markup(_("""We're inviting %s to pair with\n""" +
+                """us, and to prove veracity of the invitation we\n""" +
+                """sent, it is waiting for you to tell it this secret:\n""" +
+                """<span font-size="xx-large" color="blue" weight="bold">""" +
+                """<tt>%s</tt></span> .""") % 
+                        (cgi.escape(service), cgi.escape(self.secret_message)))
+        text.set_justify(gtk.JUSTIFY_CENTER)
+        top_vbox.pack_start(text, False, False, 10)
+        text.show()
+
+        cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
+        cancel_button.set_border_width(3)
+        cancel_button.connect("clicked", lambda widget: self.window.destroy())
+        top_vbox.pack_end(cancel_button, False, False, 10)
+        cancel_button.show()
+
+        self.window.show_all()
+
+
+class AcceptInvitation:
+    """We're part of 'Alice' in this module's story.
+    
+    We've received an invitation.  We now send the other end a secret key.  The
+    secret should make its way back to us via meatspace.  We open a dialog
+    asking for that secret here, which we validate.
+
+    When we validate it, we add this end as replicating to the other end.  The
+    other end should also set itself to replicate to us."""
+
+    def delete_event(self, widget, event, data=None):
+        """User requested window be closed.  False to propogate event."""
+        return False
+
+    def destroy(self, widget, data=None):
+        """Window is destroyed."""
+        pass
+
+    def on_close(self):
+        """Handle communication channel being closed."""
+        # FIXME   this is unimplemented and unused.
+        self.destroy()
+
+    def __init__(self, remote_host, is_secret_valid, send_valid_key):
+        self.logging = logging.getLogger(self.__class__.__name__)
+
+        self.is_secret_valid = is_secret_valid
+        self.send_valid_key = send_valid_key
+
+        self.window = gtk.Window()
+        self.window.set_border_width(6)
+
+        self.logging.info("want to listen for invitations.")
+
+        self.window.connect("delete_event", self.delete_event)
+        self.window.connect("destroy", self.destroy)
+        self.window.set_destroy_with_parent(True)
+        self.window.set_title(_("Accepting Invitation"))
+
+        top_vbox = gtk.VBox()
+        top_vbox.show()
+        self.window.add(top_vbox)
+
+        self.remote_hostname = dbus_io.get_remote_hostname(remote_host)
+
+        description = gtk.Label(
+                _("To verify your pairing with %s, enter its secret.") %
+                        self.remote_hostname)
+        description.show()
+        top_vbox.pack_start(description, False, False, 0)
+
+        self.entry_box = gtk.Entry(18)
+        self.entry_box.connect("activate", lambda widget: self.verify_secret())
+        #self.window.connect("activate", lambda widget: self.verify_secret())
+        self.entry_box.set_activates_default(True)
+        self.entry_box.show()
+        top_vbox.pack_start(self.entry_box, False, False, 0)
+
+        self.result = gtk.Label("")
+        self.result.show()
+        self.entry_box.connect("changed", 
+                lambda widget: self.result.set_text(""))
+        top_vbox.pack_start(self.result, False, False, 0)
+
+        button_bar = gtk.HBox(homogeneous=True)
+        button_bar.show()
+        top_vbox.pack_end(button_bar, False, False, 10)
+
+        cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
+        cancel_button.set_border_width(3)
+        cancel_button.connect("clicked", lambda widget: self.window.destroy())
+        button_bar.pack_end(cancel_button, False, False, 10)
+        cancel_button.show()
+
+        connect_button = gtk.Button(_("Verify and connect"))
+        add_image = gtk.Image()
+        add_image.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON)
+        connect_button.set_image(add_image)
+        connect_button.set_border_width(3)
+        connect_button.connect("clicked", lambda widget: self.verify_secret())
+        button_bar.pack_end(connect_button, False, False, 10)
+        connect_button.show()
+
+        self.window.show_all()
+
+    def verify_secret(self):
+        """We got a sumbission from the user's fingers as to what he thinks
+        the secret is.  We verify it, and if it's what the other end started
+        with, then it's okay to let us pair with it."""
+
+        proposed_secret = unmap_easily_mistaken(self.entry_box.get_text())
+        if self.is_secret_valid(proposed_secret):
+            pair_with_host(self.remote_hostname, "(port)", "(info)")
+            self.send_valid_key(proposed_secret)
+            self.window.destroy()
+        else:
+            self.result.set_text("sorry, that is wrong")
+
+
+class Listening:
+    """We're part of 'Alice' in this module's story.
+    
+    Window that starts listening for other machines to pick *us* to pair
+    with.  There must be at least one of these on the network for pairing to
+    happen.  We listen for a finite amount of time, and then stop."""
+
+    def delete_event(self, widget, event, data=None):
+        """User requested window be closed.  False to propogate event."""
+        return False
+
+    def destroy(self, widget, data=None):
+        """Window is destroyed."""
+        self.timeout_counter = None
+
+        if self.advertisement is not None:
+            self.advertisement.die()
+        self.listener.close()
+
+    def receive_invitation_challenge(self, remote_address, is_secret_valid,
+            send_secret):
+        """When we receive an invitation, check its validity and if
+        it's what we expected, then continue and accept it."""
+
+        self.logging.warn("received invitation from %s", remote_address)
+        self.acceptor = AcceptInvitation(remote_address, is_secret_valid,
+                send_secret)
+        self.acceptor.window.connect("destroy",
+                lambda *args: setattr(self, "acceptor", None) and False)
+
+    def cancel_acceptor(self):
+        """Destroy window when connection canceled."""
+        self.acceptor.window.destroy()
+
+    def make_listener(self, couchdb_instance):
+        """Start listening for connections, and start advertising that
+        we're listening."""
+
+        self.listener = network_io.ListenForInvitations(
+                self.receive_invitation_challenge, 
+                lambda: self.window.destroy())
+
+        listen_port = self.listener.get_local_port()
+
+        hostname, domainname = dbus_io.get_local_hostname()
+        username = getpass.getuser()
+        self.advertisement = dbus_io.PairAdvertisement(port=listen_port,
+                name="%s-%s-%d" % (hostname, username, listen_port),
+                text=dict(version=str(discovery_tool_version),
+                        description=get_host_info()))
+        self.advertisement.publish()
+        return hostname, username, listen_port
+
+    def __init__(self, couchdb_instance):
+        self.logging = logging.getLogger(self.__class__.__name__)
+
+        self.listener = None
+        self.listener_loop = None
+        self.advertisement = None
+        self.acceptor = None
+
+        self.timeout_counter = 180
+
+        self.window = gtk.Window()
+        self.window.set_border_width(6)
+
+        self.logging.info("want to listen for invitations.")
+
+        self.window.connect("delete_event", self.delete_event)
+        self.window.connect("destroy", self.destroy)
+        self.window.set_destroy_with_parent(True)
+        self.window.set_title(_("Waiting for CouchDB Pairing Invitations"))
+
+        top_vbox = gtk.VBox()
+        top_vbox.show()
+        self.window.add(top_vbox)
+
+        self.counter_text = gtk.Label("#")
+        self.counter_text.show()
+
+        top_vbox.pack_end(self.counter_text, False, False, 5)
+
+        button_bar = gtk.HBox(homogeneous=True)
+        button_bar.show()
+        top_vbox.pack_end(button_bar, False, False, 10)
+
+        cancel_button = gtk.Button(stock=gtk.STOCK_CANCEL)
+        cancel_button.set_border_width(3)
+        cancel_button.connect("clicked", lambda *args: self.window.destroy())
+        button_bar.pack_end(cancel_button, False, False, 10)
+        cancel_button.show()
+
+        add_minute_button = gtk.Button(_("Add 60 seconds"))
+        add_image = gtk.Image()
+        add_image.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)
+        add_minute_button.set_image(add_image)
+        add_minute_button.set_border_width(3)
+        add_minute_button.connect("clicked",
+                lambda widget: self.add_to_timeout_counter(60))
+        button_bar.pack_end(add_minute_button, False, False, 10)
+        add_minute_button.show()
+
+        hostid, userid, listen_port = self.make_listener(couchdb_instance)
+
+        text = gtk.Label()
+        text.set_markup(
+                _("""We're listening for invitations!  From another\n""" +
+                    """machine on this local network, run this\n""" + 
+                    """same tool and find the machine called\n""" + 
+                    """<span font-size="xx-large" weight="bold"><tt>""" + 
+                    """%s-%s-%d</tt></span> .""") % 
+                            (cgi.escape(hostid), cgi.escape(userid), 
+                            listen_port))
+        text.set_justify(gtk.JUSTIFY_CENTER)
+        top_vbox.pack_start(text, False, False, 10)
+        text.show()
+    
+        self.update_counter_view()
+        self.window.show_all()
+
+        gobject.timeout_add(1000, self.decrement_counter)
+
+    def add_to_timeout_counter(self, seconds):
+        """The user wants more time.  Add seconds to the clock."""
+        self.timeout_counter += seconds
+        self.update_counter_view()
+
+    def update_counter_view(self):
+        """Update the counter widget with pretty text."""
+        self.counter_text.set_text(
+                _("%d seconds remaining") % self.timeout_counter)
+
+    def decrement_counter(self):
+        """Tick!  Decrement the counter and update the display."""
+        if self.timeout_counter is None:
+            return False
+
+        self.timeout_counter -= 1
+        if self.timeout_counter < 0:
+            self.window.destroy()
+            return False
+
+        self.update_counter_view()
+        return True
+        
+
+class PickOrListen:
+    """Main top-level window that represents the life of the application."""
+
+    def delete_event(self, widget, event, data=None):
+        """User requested window be closed.  False to propogate event."""
+        return False
+
+    def destroy(self, widget, data=None):
+        """The window was destroyed."""
+        stop_program()
+
+    def create_pick_pane(self, container):
+        """Set up the pane that contains what's necessary to choose an
+        already-listening tool instance.  This sets up a "Bob" in the 
+        module's story."""
+
+        # positions:   host id, description, pair host, pair port, is_cloud
+        listening_hosts = gtk.TreeStore(str, str, str, int, bool)
+        
+        # If there is an Ubuntu One key in the keyring, add Ubuntu One
+        # as an item to be paired with
+        import gnomekeyring
+        try:
+            matches = gnomekeyring.find_items_sync(
+                gnomekeyring.ITEM_GENERIC_SECRET,
+                {'ubuntuone-realm': "https://ubuntuone.com",
+                 'oauth-consumer-key': "ubuntuone"})
+        except gnomekeyring.NoMatchError:
+            matches = None
+        if matches:
+            # parse "a=b&c=d" to {"a":"b","c":"d"}
+            oauth_data = dict([x.split("=", 1) for x in 
+               matches[0].secret.split("&")])
+            oauth_data.update({
+                "consumer_key": "ubuntuone",
+                "consumer_secret": "",
+            })
+            listening_hosts.append(None, ["Ubuntu One", "The Ubuntu One cloud service", 
+               "ubuntuone.com", 5984, True])
+            CLOUD_SERVICES["Ubuntu One"] = oauth_data
+
+        self.inviting = None  # pylint: disable-msg=W0201
+
+        hostid_col = gtk.TreeViewColumn(_("service name"))
+        description_col = gtk.TreeViewColumn(_("service name"))
+
+        pick_box = gtk.VBox()
+        container.pack_start(pick_box, False, False, 10)
+
+        l = gtk.Label(_("Pick a listening host to invite it to pair with us."))
+        pick_box.pack_start(l, False, False, 0)
+        l.show()
+
+        tv = gtk.TreeView(listening_hosts)
+        tv.set_headers_visible(False)
+        tv.set_rules_hint(True)
+        tv.show()
+
+        def clicked(selection):
+            """An item in the list of services was clicked, so now we go 
+            about inviting it to pair with us."""
+
+            model, iter = selection.get_selected()
+            if not iter:
+                return
+            service = model.get_value(iter, 0)
+            hostname = model.get_value(iter, 2)
+            port = model.get_value(iter, 3)
+            is_cloud = model.get_value(iter, 4)
+            
+            if is_cloud:
+                # Pairing with a cloud service, which doesn't do key exchange
+                pair_with_cloud_service(service, hostname, port)
+                return
+
+
+            self.logging.error("Local pairing is not yet supported.  Aborting.")
+            fail_note = gtk.MessageDialog(
+                    parent=pick_or_listen.window,
+                    flags=gtk.DIALOG_DESTROY_WITH_PARENT,
+                    buttons=gtk.BUTTONS_OK,
+                    type=gtk.MESSAGE_ERROR,
+                    message_format =_("Sorry, couchdb authentication is not yet enabled, so local pairing is not supported"))
+            fail_note.run()
+            fail_note.destroy()
+            return False
+
+
+            self.logging.info("connecting to %s:%s tcp to invite",
+                    hostname, port)
+            if self.inviting != None:
+                self.inviting.window.destroy()
+            self.inviting = Inviting(service, hostname, port)
+            self.inviting.window.connect("destroy",
+                    lambda *args: setattr(self, "inviting_window", None))
+
+        tv_selection = tv.get_selection()
+        tv_selection.connect("changed", clicked)
+
+        scrolled_window = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
+        scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+        scrolled_window.set_border_width(10)
+        scrolled_window.add_with_viewport(tv)
+        scrolled_window.show()
+
+        pick_box.pack_start(scrolled_window, True, False, 0)
+
+        def add_service_to_list(name, description, host, port, version):
+            """When a zeroconf service appears, this adds it to the
+            listing of choices."""
+
+            listening_hosts.append(None, [name, description, host, port, False, None])
+
+        def remove_service_from_list(name):
+            """When a zeroconf service disappears, this finds it in the 
+            listing and removes it as an option for picking."""
+
+            it = listening_hosts.get_iter_first()
+            while it is not None:
+                if listening_hosts.get_value(it, 0) == name:
+                    listening_hosts.remove(it)
+                    return True
+                it = listening_hosts.iter_next(it)
+
+        dbus_io.discover_services(add_service_to_list, remove_service_from_list)
+
+        cell = gtk.CellRendererText()
+        cell.set_property("weight", pango.WEIGHT_BOLD)
+        cell.set_property("weight-set", True)
+        tv.append_column(hostid_col)
+        hostid_col.pack_start(cell, True)
+        hostid_col.add_attribute(cell, 'text', 0)
+
+        cell = gtk.CellRendererText()
+        cell.set_property("ellipsize", pango.ELLIPSIZE_END)
+        cell.set_property("ellipsize-set", True)
+        tv.append_column(description_col)
+        description_col.pack_start(cell, True)
+        description_col.add_attribute(cell, 'text', 1)
+
+        return pick_box
+
+
+    def create_single_listen_pane(self, container):
+        """This sets up an "Alice" from the module's story.
+        
+        This assumes we're pairing a single, known local CouchDB instance,
+        instead of generic instances that we'd need more information to talk
+        about.  Instead of using this function, one might use another that
+        lists local DBs as a way of picking one to pair.  This function assumes
+        we know the answer to that."""
+
+        def listen(btn, couchdb_instance=None):
+            """When we decide to listen for invitations, this spawns the
+            advertising/information window, and disables the button that
+            causes/-ed us to get here (to prevent multiple instances)."""
+
+            if couchdb_instance is None:
+                # assume local for this user.  FIXME
+                pass
+
+
+            self.logging.error("Local pairing is not yet supported.  Aborting.")
+            fail_note = gtk.MessageDialog(
+                    parent=pick_or_listen.window,
+                    flags=gtk.DIALOG_DESTROY_WITH_PARENT,
+                    buttons=gtk.BUTTONS_OK,
+                    type=gtk.MESSAGE_ERROR,
+                    message_format =_("Sorry, couchdb authentication is not yet enabled, so local pairing is not supported"))
+            fail_note.run()
+            fail_note.destroy()
+            return False
+
+
+            btn.set_sensitive(False)
+            listening = Listening(couchdb_instance)
+            listening.window.connect("destroy",
+                    lambda w: btn.set_sensitive(True))
+
+        padding = 6
+
+        listen_box = gtk.HBox()
+        container.pack_start(listen_box, False, False, 10)
+
+        l = gtk.Label(_("Add this host to the list for others to see?"))
+        listen_box.pack_start(l, True, False, padding)
+        l.show()
+
+        listen_button = gtk.Button(_("Listen for invitations"))
+        listen_button.connect("clicked", listen, None)
+        listen_box.pack_start(listen_button, True, False, padding)
+        listen_button.show()
+
+        return listen_box
+
+    def create_any_listen_pane(self, container):
+        """Unused.  An example of where to start when we don't already have
+        a couchdb instance in mind to advertise.  This should be the generic
+        version."""
+
+        l = gtk.Label(_("I also know of CouchDB sessions here.  Pick one " +
+                "to add it to the invitation list for other computers to see."))
+
+        local_sharables_list = gtk.TreeStore(str, str)
+        # et c, et c
+        #some_row_in_list.connect("clicked", self.listen, target_db_info)
+
+    def __init__(self):
+        self.logging = logging.getLogger(self.__class__.__name__)
+
+        self.window = gtk.Window()
+
+        self.window.connect("delete_event", self.delete_event)
+        self.window.connect("destroy", self.destroy)
+
+        self.window.set_border_width(8)
+        self.window.set_title(_("CouchDB Pairing Tool"))
+
+        top_vbox = gtk.VBox()
+        self.window.add(top_vbox)
+
+        self.pick_pane = self.create_pick_pane(top_vbox)
+        self.listen_pane = self.create_single_listen_pane(top_vbox)
+
+        copyright = gtk.Label(_("Copyright 2009 Canonical"))
+        top_vbox.pack_end(copyright, False, False, 0)
+        copyright.show()
+
+        self.pick_pane.show()
+        self.listen_pane.show()
+
+        top_vbox.show()
+        self.window.show()
+
+
+def pair_with_host(host, port, info):
+    """We've verified all is correct and authorized, so now we pair
+    the databases."""
+    logging.info("verified host %s/%s/%s.  Done!", host, port, info)
+
+    # Some kind of two-phase commit would be nice here, before we say 
+    # successful.
+    #couchdb_io.replicate_to(...)
+
+    success_note = gtk.Dialog(title=_("Paired with %(host)s") % locals(), 
+            parent=pick_or_listen.window,
+            flags=gtk.DIALOG_DESTROY_WITH_PARENT,
+            buttons=(gtk.STOCK_OK, gtk.RESPONSE_OK,))
+    text = gtk.Label(
+            _("Successfully paired with %(host)s %(info)s.") % locals())
+    text.show()
+    content_box = success_note.get_content_area()
+    content_box.pack_start(text, True, True, 20)
+    success_note.connect("close",
+            lambda *args: pick_or_listen.window.destroy())
+    success_note.connect("response",
+            lambda *args: pick_or_listen.window.destroy())
+    success_note.show()
+
+def pair_with_cloud_service(name, hostname, port):
+    """Write a paired server record for the selected cloud service."""
+    from desktopcouch.records.server import CouchDatabase
+    from desktopcouch.records.record import Record
+    import uuid
+    
+    # Create a paired server record
+    service_data = CLOUD_SERVICES[name]
+    data = {
+        "record_type": pairing_record_type,
+        "pairing_identifier": str(uuid.uuid4()),
+        "server": "%s:%s" % (hostname, port),
+        "oauth": {
+            "consumer_key": service_data["consumer_key"],
+            "consumer_secret": service_data["consumer_secret"],
+            "token": service_data["oauth_token"],
+            "token_secret": service_data["oauth_token_secret"],
+        },
+        "pull_from_server": True
+    }
+    try:
+        d = CouchDatabase("management", create=True)
+        r = Record(data)
+        record_id = d.put_record(r)
+    except Exception, e:
+        fail_note = gtk.MessageDialog(
+                parent=pick_or_listen.window,
+                flags=gtk.DIALOG_DESTROY_WITH_PARENT,
+                buttons=gtk.BUTTONS_OK,
+                type=gtk.MESSAGE_ERROR,
+                message_format =_("Couldn't save pairing details for %s") % name)
+        fail_note.run()
+        logging.exception(e)
+        fail_note.destroy()
+        return
+    
+    success_note = gtk.MessageDialog(
+            parent=pick_or_listen.window,
+            flags=gtk.DIALOG_DESTROY_WITH_PARENT,
+            buttons=gtk.BUTTONS_OK,
+            type=gtk.MESSAGE_INFO,
+            message_format =_("Successfully paired with %s") % name)
+    success_note.run()
+    success_note.destroy()
+
+
+def set_couchdb_bind_address():
+    from desktopcouch.records.server import CouchDatabase
+    from desktopcouch import local_files
+    bind_address = local_files.get_bind_address()
+
+    if bind_address not in ("127.0.0.1", "0.0.0.0", "::1", None):
+        logging.info("we're not qualified to change explicit address %s",
+                bind_address)
+        return False
+
+    db = CouchDatabase("management", create=True)
+    results = db.get_records(create_view=True)
+    count = 0
+    for row in results[pairing_record_type]:
+        if "server" in row.value and row.value["server"] != "":
+            # Is the record of something that probably connects back to us?
+            logging.debug("not counting fully-addressed machine %r", row.value["server"])
+            continue
+        count += 1
+    logging.debug("paired machine count is %d", count)
+    if count > 0:
+        if ":" in bind_address:
+            want_bind_address = "::0"
+        else:
+            want_bind_address = "0.0.0.0"
+    else:
+        if ":" in bind_address:
+            want_bind_address = "::0"
+        else:
+            want_bind_address = "127.0.0.1"
+
+    if bind_address != want_bind_address:
+        local_files.set_bind_address(want_bind_address)
+        logging.warning("changing the desktopcouch bind address from %r to %r",
+                bind_address, want_bind_address)
+
+def main(args):
+    """Start execution."""
+    global pick_or_listen  # pylint: disable-msg=W0601
+
+    logging.basicConfig(level=logging.DEBUG, format=
+            "%(asctime)s [%(process)d] %(name)s:%(levelname)s:  %(message)s")
+
+    gettext.install("couchdb_pairing")
+
+    try:
+        logging.debug("starting couchdb pairing tool")
+        pick_or_listen = PickOrListen()
+        return run_program()
+    finally:
+        set_couchdb_bind_address()
+        logging.debug("exiting couchdb pairing tool")
+
+
+if __name__ == "__main__":
+    import sys
+    import desktopcouch
+    desktopcouch_port = desktopcouch.find_port()
+    main(sys.argv)

=== added file 'bin/desktopcouch-paired-replication-manager'
--- bin/desktopcouch-paired-replication-manager	1970-01-01 00:00:00 +0000
+++ bin/desktopcouch-paired-replication-manager	2009-08-30 12:25:52 +0000
@@ -0,0 +1,151 @@
+#!/bin/sh
+""""exec ${PYTHON:-python} -t $0 "$@";" """
+# vim: filetype=python expandtab smarttab
+
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+# desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Chad Miller <[e-mail]>
+
+import os
+import threading
+import logging
+import logging.handlers
+log = logging.getLogger("main")
+
+from twisted.internet import gtk2reactor
+gtk2reactor.install()
+from twisted.internet import reactor, task
+import xdg.BaseDirectory
+
+import desktopcouch
+from desktopcouch import local_files
+from desktopcouch.pair.couchdb_pairing import couchdb_io
+from desktopcouch.pair.couchdb_pairing import dbus_io
+
+already_replicating = False
+
+class ReplicatorThread(threading.Thread):
+    def __init__(self, local_port):
+        log.debug("starting up replication thread")
+        super(ReplicatorThread, self).__init__()
+        self.local_port = local_port
+
+    def run(self):
+        global already_replicating  # Fuzzy, as not really critical,
+        already_replicating = True  #   just trying to be polite.
+        try:
+            for uuid, addr, port in dbus_io.get_seen_paired_hosts():
+                log.debug("host %s is seen; want to replicate to it", uuid)
+                for db_name in couchdb_io.get_database_names_replicatable():
+                    couchdb_io.replicate(db_name, db_name,
+                            target_host=addr, target_port=port, 
+                            source_port=self.local_port)
+
+
+            # TODO: get static addressed paired hosts and replicate to
+            # those too.
+
+        finally:
+            already_replicating = False
+        log.debug("finished replicating")
+        
+        
+def replicate_local_databases_to_paired_hosts(local_port):
+    if already_replicating:
+        log.warn("haven't finished replicating before next time to start.")
+        return False
+
+    r = ReplicatorThread(local_port)
+    r.start()
+
+def main(args):
+    log_directory = os.path.join(xdg.BaseDirectory.xdg_cache_home,
+            "ubuntuone/log")
+    try:
+        os.makedirs(log_directory)
+    except:
+        pass
+    rotating_log = logging.handlers.TimedRotatingFileHandler(
+            os.path.join(log_directory, "desktop-couch-replication.log"),
+            "midnight", 1, 14)
+    rotating_log.setLevel(logging.DEBUG)
+    formatter = logging.Formatter('%(asctime)s %(levelname)-8s %(message)s')
+    rotating_log.setFormatter(formatter)
+    console = logging.StreamHandler()
+    console.setLevel(logging.WARNING)
+    logging.getLogger('').addHandler(rotating_log)
+    logging.getLogger('').addHandler(console)
+    logging.getLogger('').setLevel(logging.DEBUG)
+
+    try:
+        log.info("Starting.")
+
+        bind_addr = local_files.get_bind_address()
+        if bind_addr is not None and bind_addr != '':
+            from socket import inet_ntop, inet_pton
+            from socket import error as socketerror
+            try:
+                # There are more than dotted decimal quad to
+                # contend with.  183468213 == 0xaef80b5 == 
+                # 0xa.0xef.0x80.0xb5 == 012.0357.0200.0265 ==
+                # 10.239.128.181.  Just ask the system instead.
+                addr_standard_form = inet_ntop(inet_pton(bind_addr))
+            except socketerror:
+                log.warn("bind address is illegal, %r", bind_addr)
+                log.warn("(If couchdb does understand it, please open a bug!)")
+                sys.exit(1)
+                
+            if addr_standard_form.startswith("127."):  # entire /8 is local.
+                log.warn("couchdb bound to addr %r; cannot accept connections",
+                        bind_addr)
+            elif addr_standard_form == "::1":  # no addr block on v6.  Just one.
+                log.warn("couchdb bound to addr %r; cannot accept connections",
+                        bind_addr)
+
+        unique_identifiers = couchdb_io.get_my_host_unique_id()
+        if unique_identifiers is None:
+            log.warn("No unique hostaccount id is set, so pairing not enabled.")
+            sys.exit(2)
+
+        port = desktopcouch.find_port()
+        beacons = [dbus_io.LocationAdvertisement(port, "desktopcouch " + i)
+                for i in unique_identifiers]
+        for b in beacons:
+            b.publish()
+
+        dbus_io.discover_services(None, None, True)
+
+        try:
+            dbus_io.maintain_discovered_servers()
+            t = task.LoopingCall(replicate_local_databases_to_paired_hosts, port)
+            t.start(600)
+
+            # TODO:  port may change, so every so often, check it and 
+            # perhaps refresh the beacons.
+
+            reactor.run()
+        finally:
+            for b in beacons:
+                b.unpublish()
+
+    finally:
+        log.info("Quitting.")
+
+if __name__ == "__main__":
+    import sys
+
+    main(sys.argv)

=== added file 'bin/desktopcouch-service'
--- bin/desktopcouch-service	1970-01-01 00:00:00 +0000
+++ bin/desktopcouch-service	2009-08-26 17:49:19 +0000
@@ -0,0 +1,71 @@
+#!/usr/bin/python
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Stuart Langridge <[e-mail]>
+#          Tim Cole <[e-mail]>
+
+"""CouchDB port advertiser.
+
+A command-line utility which exports a
+desktopCouch.getPort method on the bus which returns
+that port, so other apps (specifically, the contacts API) can work out
+where CouchDB is running so it can be talked to.
+
+Calculates the port number by looking in the CouchDB log.
+
+If CouchDB is not running, then run the script to start it and then
+start advertising the port.
+
+This file should be started by D-Bus activation.
+
+"""
+
+import desktopcouch
+from desktopcouch import local_files
+
+import re
+from errno import ENOENT
+from dbus.mainloop.glib import DBusGMainLoop
+import dbus.service, gobject, os, errno, time
+DBusGMainLoop(set_as_default=True)
+
+class PortAdvertiser(dbus.service.Object):
+    "Advertise the discovered port number on the D-Bus Session bus"
+    def __init__(self, death):
+        bus_name = dbus.service.BusName("org.desktopcouch.CouchDB",
+                     bus=dbus.SessionBus())
+        self.death = death
+        dbus.service.Object.__init__(self, object_path="/", bus_name=bus_name)
+
+    @dbus.service.method(dbus_interface='org.desktopcouch.CouchDB',
+                         in_signature='', out_signature='i')
+    def getPort(self):
+        "Exported method to return the port"
+        return int(desktopcouch.find_port())
+
+    @dbus.service.method(dbus_interface='org.desktopcouch.CouchDB',
+                         in_signature='', out_signature='')
+    def quit(self):
+        "Exported method to quit the program"
+        self.death()
+
+if __name__ == "__main__":
+
+    # Advertise the port
+    mainloop = gobject.MainLoop()
+    portAdvertiser = PortAdvertiser(mainloop.quit)
+    mainloop.run()

=== added file 'bin/desktopcouch-stop'
--- bin/desktopcouch-stop	1970-01-01 00:00:00 +0000
+++ bin/desktopcouch-stop	2009-07-24 19:32:52 +0000
@@ -0,0 +1,36 @@
+#!/usr/bin/python
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Stuart Langridge <[e-mail]>
+"""
+Stop local CouchDB server.
+"""
+import subprocess, sys
+from desktopcouch import local_files
+
+local_exec = local_files.COUCH_EXEC_COMMAND + ["-k"]
+try:
+    retcode = subprocess.call(local_exec, shell=False)
+    if retcode < 0:
+        print >> sys.stderr, "Child was terminated by signal", -retcode
+    elif retcode > 0:
+        print >> sys.stderr, "Child returned", retcode
+except OSError, e:
+    print >> sys.stderr, "Execution failed: %s: %s" % (e, local_exec)
+    exit(1)
+
+

=== added directory 'contrib'
=== added file 'contrib/mocker.py'
--- contrib/mocker.py	1970-01-01 00:00:00 +0000
+++ contrib/mocker.py	2009-08-06 13:57:30 +0000
@@ -0,0 +1,2068 @@
+"""
+Copyright (c) 2007  Gustavo Niemeyer <[e-mail]>
+
+Graceful platform for test doubles in Python (mocks, stubs, fakes, and dummies).
+"""
+import __builtin__
+import tempfile
+import unittest
+import inspect
+import shutil
+import types
+import sys
+import os
+import gc
+
+
+if sys.version_info < (2, 4):
+    from sets import Set as set # pragma: nocover
+
+
+__all__ = ["Mocker", "expect", "IS", "CONTAINS", "IN", "MATCH",
+           "ANY", "ARGS", "KWARGS"]
+
+
+__author__ = "Gustavo Niemeyer <[e-mail]>"
+__license__ = "PSF License"
+__version__ = "0.10.1"
+
+
+ERROR_PREFIX = "[Mocker] "
+
+
+# --------------------------------------------------------------------
+# Exceptions
+
+class MatchError(AssertionError):
+    """Raised when an unknown expression is seen in playback mode."""
+
+
+# --------------------------------------------------------------------
+# Helper for chained-style calling.
+
+class expect(object):
+    """This is a simple helper that allows a different call-style.
+
+    With this class one can comfortably do chaining of calls to the
+    mocker object responsible by the object being handled. For instance::
+
+        expect(obj.attr).result(3).count(1, 2)
+
+    Is the same as::
+
+        obj.attr
+        mocker.result(3)
+        mocker.count(1, 2)
+
+    """
+
+    def __init__(self, mock, attr=None):
+        self._mock = mock
+        self._attr = attr
+
+    def __getattr__(self, attr):
+        return self.__class__(self._mock, attr)
+
+    def __call__(self, *args, **kwargs):
+        getattr(self._mock.__mocker__, self._attr)(*args, **kwargs)
+        return self
+
+
+# --------------------------------------------------------------------
+# Extensions to Python's unittest.
+
+class MockerTestCase(unittest.TestCase):
+    """unittest.TestCase subclass with Mocker support.
+
+    @ivar mocker: The mocker instance.
+
+    This is a convenience only.  Mocker may easily be used with the
+    standard C{unittest.TestCase} class if wanted.
+
+    Test methods have a Mocker instance available on C{self.mocker}.
+    At the end of each test method, expectations of the mocker will
+    be verified, and any requested changes made to the environment
+    will be restored.
+
+    In addition to the integration with Mocker, this class provides
+    a few additional helper methods.
+    """
+
+    expect = expect
+
+    def __init__(self, methodName="runTest"):
+        # So here is the trick: we take the real test method, wrap it on
+        # a function that do the job we have to do, and insert it in the
+        # *instance* dictionary, so that getattr() will return our
+        # replacement rather than the class method.
+        test_method = getattr(self, methodName, None)
+        if test_method is not None:
+            def test_method_wrapper():
+                try:
+                    result = test_method()
+                except:
+                    raise
+                else:
+                    if (self.mocker.is_recording() and
+                        self.mocker.get_events()):
+                        raise RuntimeError("Mocker must be put in replay "
+                                           "mode with self.mocker.replay()")
+                    if (hasattr(result, "addCallback") and
+                        hasattr(result, "addErrback")):
+                        def verify(result):
+                            self.mocker.verify()
+                            return result
+                        result.addCallback(verify)
+                    else:
+                        self.mocker.verify()
+                    return result
+            # Copy all attributes from the original method..
+            for attr in dir(test_method):
+                # .. unless they're present in our wrapper already.
+                if not hasattr(test_method_wrapper, attr) or attr == "__doc__":
+                    setattr(test_method_wrapper, attr,
+                            getattr(test_method, attr))
+            setattr(self, methodName, test_method_wrapper)
+
+        # We could overload run() normally, but other well-known testing
+        # frameworks do it as well, and some of them won't call the super,
+        # which might mean that cleanup wouldn't happen.  With that in mind,
+        # we make integration easier by using the following trick.
+        run_method = self.run
+        def run_wrapper(*args, **kwargs):
+            try:
+                return run_method(*args, **kwargs)
+            finally:
+                self.__cleanup()
+        self.run = run_wrapper
+
+        self.mocker = Mocker()
+
+        self.__cleanup_funcs = []
+        self.__cleanup_paths = []
+
+        super(MockerTestCase, self).__init__(methodName)
+
+    def __cleanup(self):
+        for path in self.__cleanup_paths:
+            if os.path.isfile(path):
+                os.unlink(path)
+            elif os.path.isdir(path):
+                shutil.rmtree(path)
+        self.mocker.restore()
+        for func, args, kwargs in self.__cleanup_funcs:
+            func(*args, **kwargs)
+
+    def addCleanup(self, func, *args, **kwargs):
+        self.__cleanup_funcs.append((func, args, kwargs))
+
+    def makeFile(self, content=None, suffix="", prefix="tmp", basename=None,
+                 dirname=None, path=None):
+        """Create a temporary file and return the path to it.
+
+        @param content: Initial content for the file.
+        @param suffix: Suffix to be given to the file's basename.
+        @param prefix: Prefix to be given to the file's basename.
+        @param basename: Full basename for the file.
+        @param dirname: Put file inside this directory.
+
+        The file is removed after the test runs.
+        """
+        if path is not None:
+            self.__cleanup_paths.append(path)
+        elif basename is not None:
+            if dirname is None:
+                dirname = tempfile.mkdtemp()
+                self.__cleanup_paths.append(dirname)
+            path = os.path.join(dirname, basename)
+        else:
+            fd, path = tempfile.mkstemp(suffix, prefix, dirname)
+            self.__cleanup_paths.append(path)
+            os.close(fd)
+            if content is None:
+                os.unlink(path)
+        if content is not None:
+            file = open(path, "w")
+            file.write(content)
+            file.close()
+        return path
+
+    def makeDir(self, suffix="", prefix="tmp", dirname=None, path=None):
+        """Create a temporary directory and return the path to it.
+
+        @param suffix: Suffix to be given to the file's basename.
+        @param prefix: Prefix to be given to the file's basename.
+        @param dirname: Put directory inside this parent directory.
+
+        The directory is removed after the test runs.
+        """
+        if path is not None:
+            os.makedirs(path)
+        else:
+            path = tempfile.mkdtemp(suffix, prefix, dirname)
+        self.__cleanup_paths.append(path)
+        return path
+
+    def failUnlessIs(self, first, second, msg=None):
+        """Assert that C{first} is the same object as C{second}."""
+        if first is not second:
+            raise self.failureException(msg or "%r is not %r" % (first, second))
+
+    def failIfIs(self, first, second, msg=None):
+        """Assert that C{first} is not the same object as C{second}."""
+        if first is second:
+            raise self.failureException(msg or "%r is %r" % (first, second))
+
+    def failUnlessIn(self, first, second, msg=None):
+        """Assert that C{first} is contained in C{second}."""
+        if first not in second:
+            raise self.failureException(msg or "%r not in %r" % (first, second))
+
+    def failUnlessStartsWith(self, first, second, msg=None):
+        """Assert that C{first} starts with C{second}."""
+        if first[:len(second)] != second:
+            raise self.failureException(msg or "%r doesn't start with %r" %
+                                               (first, second))
+
+    def failIfStartsWith(self, first, second, msg=None):
+        """Assert that C{first} doesn't start with C{second}."""
+        if first[:len(second)] == second:
+            raise self.failureException(msg or "%r starts with %r" %
+                                               (first, second))
+
+    def failUnlessEndsWith(self, first, second, msg=None):
+        """Assert that C{first} starts with C{second}."""
+        if first[len(first)-len(second):] != second:
+            raise self.failureException(msg or "%r doesn't end with %r" %
+                                               (first, second))
+
+    def failIfEndsWith(self, first, second, msg=None):
+        """Assert that C{first} doesn't start with C{second}."""
+        if first[len(first)-len(second):] == second:
+            raise self.failureException(msg or "%r ends with %r" %
+                                               (first, second))
+
+    def failIfIn(self, first, second, msg=None):
+        """Assert that C{first} is not contained in C{second}."""
+        if first in second:
+            raise self.failureException(msg or "%r in %r" % (first, second))
+
+    def failUnlessApproximates(self, first, second, tolerance, msg=None):
+        """Assert that C{first} is near C{second} by at most C{tolerance}."""
+        if abs(first - second) > tolerance:
+            raise self.failureException(msg or "abs(%r - %r) > %r" %
+                                        (first, second, tolerance))
+
+    def failIfApproximates(self, first, second, tolerance, msg=None):
+        """Assert that C{first} is far from C{second} by at least C{tolerance}.
+        """
+        if abs(first - second) <= tolerance:
+            raise self.failureException(msg or "abs(%r - %r) <= %r" %
+                                        (first, second, tolerance))
+
+    def failUnlessMethodsMatch(self, first, second):
+        """Assert that public methods in C{first} are present in C{second}.
+
+        This method asserts that all public methods found in C{first} are also
+        present in C{second} and accept the same arguments.  C{first} may
+        have its own private methods, though, and may not have all methods
+        found in C{second}.  Note that if a private method in C{first} matches
+        the name of one in C{second}, their specification is still compared.
+
+        This is useful to verify if a fake or stub class have the same API as
+        the real class being simulated.
+        """
+        first_methods = dict(inspect.getmembers(first, inspect.ismethod))
+        second_methods = dict(inspect.getmembers(second, inspect.ismethod))
+        for name, first_method in first_methods.items():
+            first_argspec = inspect.getargspec(first_method)
+            first_formatted = inspect.formatargspec(*first_argspec)
+
+            second_method = second_methods.get(name)
+            if second_method is None:
+                if name[:1] == "_":
+                    continue # First may have its own private methods.
+                raise self.failureException("%s.%s%s not present in %s" %
+                    (first.__name__, name, first_formatted, second.__name__))
+
+            second_argspec = inspect.getargspec(second_method)
+            if first_argspec != second_argspec:
+                second_formatted = inspect.formatargspec(*second_argspec)
+                raise self.failureException("%s.%s%s != %s.%s%s" %
+                    (first.__name__, name, first_formatted,
+                     second.__name__, name, second_formatted))
+
+
+    assertIs = failUnlessIs
+    assertIsNot = failIfIs
+    assertIn = failUnlessIn
+    assertNotIn = failIfIn
+    assertStartsWith = failUnlessStartsWith
+    assertNotStartsWith = failIfStartsWith
+    assertEndsWith = failUnlessEndsWith
+    assertNotEndsWith = failIfEndsWith
+    assertApproximates = failUnlessApproximates
+    assertNotApproximates = failIfApproximates
+    assertMethodsMatch = failUnlessMethodsMatch
+
+    # The following are missing in Python < 2.4.
+    assertTrue = unittest.TestCase.failUnless
+    assertFalse = unittest.TestCase.failIf
+
+    # The following is provided for compatibility with Twisted's trial.
+    assertIdentical = assertIs
+    assertNotIdentical = assertIsNot
+    failUnlessIdentical = failUnlessIs
+    failIfIdentical = failIfIs
+
+
+# --------------------------------------------------------------------
+# Mocker.
+
+class classinstancemethod(object):
+
+    def __init__(self, method):
+        self.method = method
+
+    def __get__(self, obj, cls=None):
+        def bound_method(*args, **kwargs):
+            return self.method(cls, obj, *args, **kwargs)
+        return bound_method
+
+
+class MockerBase(object):
+    """Controller of mock objects.
+
+    A mocker instance is used to command recording and replay of
+    expectations on any number of mock objects.
+
+    Expectations should be expressed for the mock object while in
+    record mode (the initial one) by using the mock object itself,
+    and using the mocker (and/or C{expect()} as a helper) to define
+    additional behavior for each event.  For instance::
+
+        mock = mocker.mock()
+        mock.hello()
+        mocker.result("Hi!")
+        mocker.replay()
+        assert mock.hello() == "Hi!"
+        mock.restore()
+        mock.verify()
+
+    In this short excerpt a mock object is being created, then an
+    expectation of a call to the C{hello()} method was recorded, and
+    when called the method should return the value C{10}.  Then, the
+    mocker is put in replay mode, and the expectation is satisfied by
+    calling the C{hello()} method, which indeed returns 10.  Finally,
+    a call to the L{restore()} method is performed to undo any needed
+    changes made in the environment, and the L{verify()} method is
+    called to ensure that all defined expectations were met.
+
+    The same logic can be expressed more elegantly using the
+    C{with mocker:} statement, as follows::
+
+        mock = mocker.mock()
+        mock.hello()
+        mocker.result("Hi!")
+        with mocker:
+            assert mock.hello() == "Hi!"
+
+    Also, the MockerTestCase class, which integrates the mocker on
+    a unittest.TestCase subclass, may be used to reduce the overhead
+    of controlling the mocker.  A test could be written as follows::
+
+        class SampleTest(MockerTestCase):
+
+            def test_hello(self):
+                mock = self.mocker.mock()
+                mock.hello()
+                self.mocker.result("Hi!")
+                self.mocker.replay()
+                self.assertEquals(mock.hello(), "Hi!")
+    """
+
+    _recorders = []
+
+    # For convenience only.
+    on = expect
+
+    class __metaclass__(type):
+        def __init__(self, name, bases, dict):
+            # Make independent lists on each subclass, inheriting from parent.
+            self._recorders = list(getattr(self, "_recorders", ()))
+
+    def __init__(self):
+        self._recorders = self._recorders[:]
+        self._events = []
+        self._recording = True
+        self._ordering = False
+        self._last_orderer = None
+
+    def is_recording(self):
+        """Return True if in recording mode, False if in replay mode.
+
+        Recording is the initial state.
+        """
+        return self._recording
+
+    def replay(self):
+        """Change to replay mode, where recorded events are reproduced.
+
+        If already in replay mode, the mocker will be restored, with all
+        expectations reset, and then put again in replay mode.
+
+        An alternative and more comfortable way to replay changes is
+        using the 'with' statement, as follows::
+
+            mocker = Mocker()
+            <record events>
+            with mocker:
+                <reproduce events>
+
+        The 'with' statement will automatically put mocker in replay
+        mode, and will also verify if all events were correctly reproduced
+        at the end (using L{verify()}), and also restore any changes done
+        in the environment (with L{restore()}).
+
+        Also check the MockerTestCase class, which integrates the
+        unittest.TestCase class with mocker.
+        """
+        if not self._recording:
+            for event in self._events:
+                event.restore()
+        else:
+            self._recording = False
+        for event in self._events:
+            event.replay()
+
+    def restore(self):
+        """Restore changes in the environment, and return to recording mode.
+
+        This should always be called after the test is complete (succeeding
+        or not).  There are ways to call this method automatically on
+        completion (e.g. using a C{with mocker:} statement, or using the
+        L{MockerTestCase} class.
+        """
+        if not self._recording:
+            self._recording = True
+            for event in self._events:
+                event.restore()
+
+    def reset(self):
+        """Reset the mocker state.
+
+        This will restore environment changes, if currently in replay
+        mode, and then remove all events previously recorded.
+        """
+        if not self._recording:
+            self.restore()
+        self.unorder()
+        del self._events[:]
+
+    def get_events(self):
+        """Return all recorded events."""
+        return self._events[:]
+
+    def add_event(self, event):
+        """Add an event.
+
+        This method is used internally by the implementation, and
+        shouldn't be needed on normal mocker usage.
+        """
+        self._events.append(event)
+        if self._ordering:
+            orderer = event.add_task(Orderer(event.path))
+            if self._last_orderer:
+                orderer.add_dependency(self._last_orderer)
+            self._last_orderer = orderer
+        return event
+
+    def verify(self):
+        """Check if all expectations were met, and raise AssertionError if not.
+
+        The exception message will include a nice description of which
+        expectations were not met, and why.
+        """
+        errors = []
+        for event in self._events:
+            try:
+                event.verify()
+            except AssertionError, e:
+                error = str(e)
+                if not error:
+                    raise RuntimeError("Empty error message from %r"
+                                       % event)
+                errors.append(error)
+        if errors:
+            message = [ERROR_PREFIX + "Unmet expectations:", ""]
+            for error in errors:
+                lines = error.splitlines()
+                message.append("=> " + lines.pop(0))
+                message.extend([" " + line for line in lines])
+                message.append("")
+            raise AssertionError(os.linesep.join(message))
+
+    def mock(self, spec_and_type=None, spec=None, type=None,
+             name=None, count=True):
+        """Return a new mock object.
+
+        @param spec_and_type: Handy positional argument which sets both
+                     spec and type.
+        @param spec: Method calls will be checked for correctness against
+                     the given class.
+        @param type: If set, the Mock's __class__ attribute will return
+                     the given type.  This will make C{isinstance()} calls
+                     on the object work.
+        @param name: Name for the mock object, used in the representation of
+                     expressions.  The name is rarely needed, as it's usually
+                     guessed correctly from the variable name used.
+        @param count: If set to false, expressions may be executed any number
+                     of times, unless an expectation is explicitly set using
+                     the L{count()} method.  By default, expressions are
+                     expected once.
+        """
+        if spec_and_type is not None:
+            spec = type = spec_and_type
+        return Mock(self, spec=spec, type=type, name=name, count=count)
+
+    def proxy(self, object, spec=True, type=True, name=None, count=True,
+              passthrough=True):
+        """Return a new mock object which proxies to the given object.
+ 
+        Proxies are useful when only part of the behavior of an object
+        is to be mocked.  Unknown expressions may be passed through to
+        the real implementation implicitly (if the C{passthrough} argument
+        is True), or explicitly (using the L{passthrough()} method
+        on the event).
+
+        @param object: Real object to be proxied, and replaced by the mock
+                       on replay mode.  It may also be an "import path",
+                       such as C{"time.time"}, in which case the object
+                       will be the C{time} function from the C{time} module.
+        @param spec: Method calls will be checked for correctness against
+                     the given object, which may be a class or an instance
+                     where attributes will be looked up.  Defaults to the
+                     the C{object} parameter.  May be set to None explicitly,
+                     in which case spec checking is disabled.  Checks may
+                     also be disabled explicitly on a per-event basis with
+                     the L{nospec()} method.
+        @param type: If set, the Mock's __class__ attribute will return
+                     the given type.  This will make C{isinstance()} calls
+                     on the object work.  Defaults to the type of the
+                     C{object} parameter.  May be set to None explicitly.
+        @param name: Name for the mock object, used in the representation of
+                     expressions.  The name is rarely needed, as it's usually
+                     guessed correctly from the variable name used.
+        @param count: If set to false, expressions may be executed any number
+                     of times, unless an expectation is explicitly set using
+                     the L{count()} method.  By default, expressions are
+                     expected once.
+        @param passthrough: If set to False, passthrough of actions on the
+                            proxy to the real object will only happen when
+                            explicitly requested via the L{passthrough()}
+                            method.
+        """
+        if isinstance(object, basestring):
+            if name is None:
+                name = object
+            import_stack = object.split(".")
+            attr_stack = []
+            while import_stack:
+                module_path = ".".join(import_stack)
+                try:
+                    object = __import__(module_path, {}, {}, [""])
+                except ImportError:
+                    attr_stack.insert(0, import_stack.pop())
+                    if not import_stack:
+                        raise
+                    continue
+                else:
+                    for attr in attr_stack:
+                        object = getattr(object, attr)
+                    break
+        if spec is True:
+            spec = object
+        if type is True:
+            type = __builtin__.type(object)
+        return Mock(self, spec=spec, type=type, object=object,
+                    name=name, count=count, passthrough=passthrough)
+
+    def replace(self, object, spec=True, type=True, name=None, count=True,
+                passthrough=True):
+        """Create a proxy, and replace the original object with the mock.
+
+        On replay, the original object will be replaced by the returned
+        proxy in all dictionaries found in the running interpreter via
+        the garbage collecting system.  This should cover module
+        namespaces, class namespaces, instance namespaces, and so on.
+
+        @param object: Real object to be proxied, and replaced by the mock
+                       on replay mode.  It may also be an "import path",
+                       such as C{"time.time"}, in which case the object
+                       will be the C{time} function from the C{time} module.
+        @param spec: Method calls will be checked for correctness against
+                     the given object, which may be a class or an instance
+                     where attributes will be looked up.  Defaults to the
+                     the C{object} parameter.  May be set to None explicitly,
+                     in which case spec checking is disabled.  Checks may
+                     also be disabled explicitly on a per-event basis with
+                     the L{nospec()} method.
+        @param type: If set, the Mock's __class__ attribute will return
+                     the given type.  This will make C{isinstance()} calls
+                     on the object work.  Defaults to the type of the
+                     C{object} parameter.  May be set to None explicitly.
+        @param name: Name for the mock object, used in the representation of
+                     expressions.  The name is rarely needed, as it's usually
+                     guessed correctly from the variable name used.
+        @param passthrough: If set to False, passthrough of actions on the
+                            proxy to the real object will only happen when
+                            explicitly requested via the L{passthrough()}
+                            method.
+        """
+        mock = self.proxy(object, spec, type, name, count, passthrough)
+        event = self._get_replay_restore_event()
+        event.add_task(ProxyReplacer(mock))
+        return mock
+
+    def patch(self, object, spec=True):
+        """Patch an existing object to reproduce recorded events.
+
+        @param object: Class or instance to be patched.
+        @param spec: Method calls will be checked for correctness against
+                     the given object, which may be a class or an instance
+                     where attributes will be looked up.  Defaults to the
+                     the C{object} parameter.  May be set to None explicitly,
+                     in which case spec checking is disabled.  Checks may
+                     also be disabled explicitly on a per-event basis with
+                     the L{nospec()} method.
+
+        The result of this method is still a mock object, which can be
+        used like any other mock object to record events.  The difference
+        is that when the mocker is put on replay mode, the *real* object
+        will be modified to behave according to recorded expectations.
+
+        Patching works in individual instances, and also in classes.
+        When an instance is patched, recorded events will only be
+        considered on this specific instance, and other instances should
+        behave normally.  When a class is patched, the reproduction of
+        events will be considered on any instance of this class once
+        created (collectively).
+
+        Observe that, unlike with proxies which catch only events done
+        through the mock object, *all* accesses to recorded expectations
+        will be considered;  even these coming from the object itself
+        (e.g. C{self.hello()} is considered if this method was patched).
+        While this is a very powerful feature, and many times the reason
+        to use patches in the first place, it's important to keep this
+        behavior in mind.
+
+        Patching of the original object only takes place when the mocker
+        is put on replay mode, and the patched object will be restored
+        to its original state once the L{restore()} method is called
+        (explicitly, or implicitly with alternative conventions, such as
+        a C{with mocker:} block, or a MockerTestCase class).
+        """
+        if spec is True:
+            spec = object
+        patcher = Patcher()
+        event = self._get_replay_restore_event()
+        event.add_task(patcher)
+        mock = Mock(self, object=object, patcher=patcher,
+                    passthrough=True, spec=spec)
+        object.__mocker_mock__ = mock
+        return mock
+
+    def act(self, path):
+        """This is called by mock objects whenever something happens to them.
+
+        This method is part of the implementation between the mocker
+        and mock objects.
+        """
+        if self._recording:
+            event = self.add_event(Event(path))
+            for recorder in self._recorders:
+                recorder(self, event)
+            return Mock(self, path)
+        else:
+            # First run events that may run, then run unsatisfied events, then
+            # ones not previously run. We put the index in the ordering tuple
+            # instead of the actual event because we want a stable sort
+            # (ordering between 2 events is undefined).
+            events = self._events
+            order = [(events[i].satisfied()*2 + events[i].has_run(), i)
+                     for i in range(len(events))]
+            order.sort()
+            postponed = None
+            for weight, i in order:
+                event = events[i]
+                if event.matches(path):
+                    if event.may_run(path):
+                        return event.run(path)
+                    elif postponed is None:
+                        postponed = event
+            if postponed is not None:
+                return postponed.run(path)
+            raise MatchError(ERROR_PREFIX + "Unexpected expression: %s" % path)
+
+    def get_recorders(cls, self):
+        """Return recorders associated with this mocker class or instance.
+
+        This method may be called on mocker instances and also on mocker
+        classes.  See the L{add_recorder()} method for more information.
+        """
+        return (self or cls)._recorders[:]
+    get_recorders = classinstancemethod(get_recorders)
+
+    def add_recorder(cls, self, recorder):
+        """Add a recorder to this mocker class or instance.
+
+        @param recorder: Callable accepting C{(mocker, event)} as parameters.
+
+        This is part of the implementation of mocker.
+
+        All registered recorders are called for translating events that
+        happen during recording into expectations to be met once the state
+        is switched to replay mode.
+
+        This method may be called on mocker instances and also on mocker
+        classes.  When called on a class, the recorder will be used by
+        all instances, and also inherited on subclassing.  When called on
+        instances, the recorder is added only to the given instance.
+        """
+        (self or cls)._recorders.append(recorder)
+        return recorder
+    add_recorder = classinstancemethod(add_recorder)
+
+    def remove_recorder(cls, self, recorder):
+        """Remove the given recorder from this mocker class or instance.
+
+        This method may be called on mocker classes and also on mocker
+        instances.  See the L{add_recorder()} method for more information.
+        """
+        (self or cls)._recorders.remove(recorder)
+    remove_recorder = classinstancemethod(remove_recorder)
+
+    def result(self, value):
+        """Make the last recorded event return the given value on replay.
+        
+        @param value: Object to be returned when the event is replayed.
+        """
+        self.call(lambda *args, **kwargs: value)
+
+    def generate(self, sequence):
+        """Last recorded event will return a generator with the given sequence.
+
+        @param sequence: Sequence of values to be generated.
+        """
+        def generate(*args, **kwargs):
+            for value in sequence:
+                yield value
+        self.call(generate)
+
+    def throw(self, exception):
+        """Make the last recorded event raise the given exception on replay.
+
+        @param exception: Class or instance of exception to be raised.
+        """
+        def raise_exception(*args, **kwargs):
+            raise exception
+        self.call(raise_exception)
+
+    def call(self, func):
+        """Make the last recorded event cause the given function to be called.
+
+        @param func: Function to be called.
+
+        The result of the function will be used as the event result.
+        """
+        self._events[-1].add_task(FunctionRunner(func))
+
+    def count(self, min, max=False):
+        """Last recorded event must be replayed between min and max times.
+
+        @param min: Minimum number of times that the event must happen.
+        @param max: Maximum number of times that the event must happen.  If
+                    not given, it defaults to the same value of the C{min}
+                    parameter.  If set to None, there is no upper limit, and
+                    the expectation is met as long as it happens at least
+                    C{min} times.
+        """
+        event = self._events[-1]
+        for task in event.get_tasks():
+            if isinstance(task, RunCounter):
+                event.remove_task(task)
+        event.add_task(RunCounter(min, max))
+
+    def is_ordering(self):
+        """Return true if all events are being ordered.
+
+        See the L{order()} method.
+        """
+        return self._ordering
+
+    def unorder(self):
+        """Disable the ordered mode.
+        
+        See the L{order()} method for more information.
+        """
+        self._ordering = False
+        self._last_orderer = None
+
+    def order(self, *path_holders):
+        """Create an expectation of order between two or more events.
+
+        @param path_holders: Objects returned as the result of recorded events.
+
+        By default, mocker won't force events to happen precisely in
+        the order they were recorded.  Calling this method will change
+        this behavior so that events will only match if reproduced in
+        the correct order.
+
+        There are two ways in which this method may be used.  Which one
+        is used in a given occasion depends only on convenience.
+
+        If no arguments are passed, the mocker will be put in a mode where
+        all the recorded events following the method call will only be met
+        if they happen in order.  When that's used, the mocker may be put
+        back in unordered mode by calling the L{unorder()} method, or by
+        using a 'with' block, like so::
+
+            with mocker.ordered():
+                <record events>
+
+        In this case, only expressions in <record events> will be ordered,
+        and the mocker will be back in unordered mode after the 'with' block.
+
+        The second way to use it is by specifying precisely which events
+        should be ordered.  As an example::
+
+            mock = mocker.mock()
+            expr1 = mock.hello()
+            expr2 = mock.world
+            expr3 = mock.x.y.z
+            mocker.order(expr1, expr2, expr3)
+
+        This method of ordering only works when the expression returns
+        another object.
+
+        Also check the L{after()} and L{before()} methods, which are
+        alternative ways to perform this.
+        """
+        if not path_holders:
+            self._ordering = True
+            return OrderedContext(self)
+
+        last_orderer = None
+        for path_holder in path_holders:
+            if type(path_holder) is Path:
+                path = path_holder
+            else:
+                path = path_holder.__mocker_path__
+            for event in self._events:
+                if event.path is path:
+                    for task in event.get_tasks():
+                        if isinstance(task, Orderer):
+                            orderer = task
+                            break
+                    else:
+                        orderer = Orderer(path)
+                        event.add_task(orderer)
+                    if last_orderer:
+                        orderer.add_dependency(last_orderer)
+                    last_orderer = orderer
+                    break
+
+    def after(self, *path_holders):
+        """Last recorded event must happen after events referred to.
+
+        @param path_holders: Objects returned as the result of recorded events
+                             which should happen before the last recorded event
+
+        As an example, the idiom::
+
+            expect(mock.x).after(mock.y, mock.z)
+
+        is an alternative way to say::
+
+            expr_x = mock.x
+            expr_y = mock.y
+            expr_z = mock.z
+            mocker.order(expr_y, expr_x)
+            mocker.order(expr_z, expr_x)
+
+        See L{order()} for more information.
+        """
+        last_path = self._events[-1].path
+        for path_holder in path_holders:
+            self.order(path_holder, last_path)
+
+    def before(self, *path_holders):
+        """Last recorded event must happen before events referred to.
+
+        @param path_holders: Objects returned as the result of recorded events
+                             which should happen after the last recorded event
+
+        As an example, the idiom::
+
+            expect(mock.x).before(mock.y, mock.z)
+
+        is an alternative way to say::
+
+            expr_x = mock.x
+            expr_y = mock.y
+            expr_z = mock.z
+            mocker.order(expr_x, expr_y)
+            mocker.order(expr_x, expr_z)
+
+        See L{order()} for more information.
+        """
+        last_path = self._events[-1].path
+        for path_holder in path_holders:
+            self.order(last_path, path_holder)
+
+    def nospec(self):
+        """Don't check method specification of real object on last event.
+
+        By default, when using a mock created as the result of a call to
+        L{proxy()}, L{replace()}, and C{patch()}, or when passing the spec
+        attribute to the L{mock()} method, method calls on the given object
+        are checked for correctness against the specification of the real
+        object (or the explicitly provided spec).
+
+        This method will disable that check specifically for the last
+        recorded event.
+        """
+        event = self._events[-1]
+        for task in event.get_tasks():
+            if isinstance(task, SpecChecker):
+                event.remove_task(task)
+
+    def passthrough(self, result_callback=None):
+        """Make the last recorded event run on the real object once seen.
+
+        @param result_callback: If given, this function will be called with
+            the result of the *real* method call as the only argument.
+
+        This can only be used on proxies, as returned by the L{proxy()}
+        and L{replace()} methods, or on mocks representing patched objects,
+        as returned by the L{patch()} method.
+        """
+        event = self._events[-1]
+        if event.path.root_object is None:
+            raise TypeError("Mock object isn't a proxy")
+        event.add_task(PathExecuter(result_callback))
+
+    def __enter__(self):
+        """Enter in a 'with' context.  This will run replay()."""
+        self.replay()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Exit from a 'with' context.
+
+        This will run restore() at all times, but will only run verify()
+        if the 'with' block itself hasn't raised an exception.  Exceptions
+        in that block are never swallowed.
+        """
+        self.restore()
+        if type is None:
+            self.verify()
+        return False
+
+    def _get_replay_restore_event(self):
+        """Return unique L{ReplayRestoreEvent}, creating if needed.
+
+        Some tasks only want to replay/restore.  When that's the case,
+        they shouldn't act on other events during replay.  Also, they
+        can all be put in a single event when that's the case.  Thus,
+        we add a single L{ReplayRestoreEvent} as the first element of
+        the list.
+        """
+        if not self._events or type(self._events[0]) != ReplayRestoreEvent:
+            self._events.insert(0, ReplayRestoreEvent())
+        return self._events[0]
+
+
+class OrderedContext(object):
+
+    def __init__(self, mocker):
+        self._mocker = mocker
+
+    def __enter__(self):
+        return None
+
+    def __exit__(self, type, value, traceback):
+        self._mocker.unorder()
+
+
+class Mocker(MockerBase):
+    __doc__ = MockerBase.__doc__
+
+# Decorator to add recorders on the standard Mocker class.
+recorder = Mocker.add_recorder
+
+
+# --------------------------------------------------------------------
+# Mock object.
+
+class Mock(object):
+
+    def __init__(self, mocker, path=None, name=None, spec=None, type=None,
+                 object=None, passthrough=False, patcher=None, count=True):
+        self.__mocker__ = mocker
+        self.__mocker_path__ = path or Path(self, object)
+        self.__mocker_name__ = name
+        self.__mocker_spec__ = spec
+        self.__mocker_object__ = object
+        self.__mocker_passthrough__ = passthrough
+        self.__mocker_patcher__ = patcher
+        self.__mocker_replace__ = False
+        self.__mocker_type__ = type
+        self.__mocker_count__ = count
+
+    def __mocker_act__(self, kind, args=(), kwargs={}, object=None):
+        if self.__mocker_name__ is None:
+            self.__mocker_name__ = find_object_name(self, 2)
+        action = Action(kind, args, kwargs, self.__mocker_path__)
+        path = self.__mocker_path__ + action
+        if object is not None:
+            path.root_object = object
+        try:
+            return self.__mocker__.act(path)
+        except MatchError, exception:
+            root_mock = path.root_mock
+            if (path.root_object is not None and
+                root_mock.__mocker_passthrough__):
+                return path.execute(path.root_object)
+            # Reinstantiate to show raise statement on traceback, and
+            # also to make the traceback shown shorter.
+            raise MatchError(str(exception))
+        except AssertionError, e:
+            lines = str(e).splitlines()
+            message = [ERROR_PREFIX + "Unmet expectation:", ""]
+            message.append("=> " + lines.pop(0))
+            message.extend([" " + line for line in lines])
+            message.append("")
+            raise AssertionError(os.linesep.join(message))
+
+    def __getattribute__(self, name):
+        if name.startswith("__mocker_"):
+            return super(Mock, self).__getattribute__(name)
+        if name == "__class__":
+            if self.__mocker__.is_recording() or self.__mocker_type__ is None:
+                return type(self)
+            return self.__mocker_type__
+        return self.__mocker_act__("getattr", (name,))
+
+    def __setattr__(self, name, value):
+        if name.startswith("__mocker_"):
+            return super(Mock, self).__setattr__(name, value)
+        return self.__mocker_act__("setattr", (name, value))
+
+    def __delattr__(self, name):
+        return self.__mocker_act__("delattr", (name,))
+
+    def __call__(self, *args, **kwargs):
+        return self.__mocker_act__("call", args, kwargs)
+
+    def __contains__(self, value):
+        return self.__mocker_act__("contains", (value,))
+
+    def __getitem__(self, key):
+        return self.__mocker_act__("getitem", (key,))
+
+    def __setitem__(self, key, value):
+        return self.__mocker_act__("setitem", (key, value))
+
+    def __delitem__(self, key):
+        return self.__mocker_act__("delitem", (key,))
+
+    def __len__(self):
+        # MatchError is turned on an AttributeError so that list() and
+        # friends act properly when trying to get length hints on
+        # something that doesn't offer them.
+        try:
+            result = self.__mocker_act__("len")
+        except MatchError, e:
+            raise AttributeError(str(e))
+        if type(result) is Mock:
+            return 0
+        return result
+
+    def __nonzero__(self):
+        try:
+            return self.__mocker_act__("nonzero")
+        except MatchError, e:
+            return True
+
+    def __iter__(self):
+        # XXX On py3k, when next() becomes __next__(), we'll be able
+        #     to return the mock itself because it will be considered
+        #     an iterator (we'll be mocking __next__ as well, which we
+        #     can't now).
+        result = self.__mocker_act__("iter")
+        if type(result) is Mock:
+            return iter([])
+        return result
+
+    # When adding a new action kind here, also add support for it on
+    # Action.execute() and Path.__str__().
+
+
+def find_object_name(obj, depth=0):
+    """Try to detect how the object is named on a previous scope."""
+    try:
+        frame = sys._getframe(depth+1)
+    except:
+        return None
+    for name, frame_obj in frame.f_locals.iteritems():
+        if frame_obj is obj:
+            return name
+    self = frame.f_locals.get("self")
+    if self is not None:
+        try:
+            items = list(self.__dict__.iteritems())
+        except:
+            pass
+        else:
+            for name, self_obj in items:
+                if self_obj is obj:
+                    return name
+    return None
+
+
+# --------------------------------------------------------------------
+# Action and path.
+
+class Action(object):
+
+    def __init__(self, kind, args, kwargs, path=None):
+        self.kind = kind
+        self.args = args
+        self.kwargs = kwargs
+        self.path = path
+        self._execute_cache = {}
+
+    def __repr__(self):
+        if self.path is None:
+            return "Action(%r, %r, %r)" % (self.kind, self.args, self.kwargs)
+        return "Action(%r, %r, %r, %r)" % \
+               (self.kind, self.args, self.kwargs, self.path)
+
+    def __eq__(self, other):
+        return (self.kind == other.kind and
+                self.args == other.args and
+                self.kwargs == other.kwargs)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def matches(self, other):
+        return (self.kind == other.kind and
+                match_params(self.args, self.kwargs, other.args, other.kwargs))
+
+    def execute(self, object):
+        # This caching scheme may fail if the object gets deallocated before
+        # the action, as the id might get reused.  It's somewhat easy to fix
+        # that with a weakref callback.  For our uses, though, the object
+        # should never get deallocated before the action itself, so we'll
+        # just keep it simple.
+        if id(object) in self._execute_cache:
+            return self._execute_cache[id(object)]
+        execute = getattr(object, "__mocker_execute__", None)
+        if execute is not None:
+            result = execute(self, object)
+        else:
+            kind = self.kind
+            if kind == "getattr":
+                result = getattr(object, self.args[0])
+            elif kind == "setattr":
+                result = setattr(object, self.args[0], self.args[1])
+            elif kind == "delattr":
+                result = delattr(object, self.args[0])
+            elif kind == "call":
+                result = object(*self.args, **self.kwargs)
+            elif kind == "contains":
+                result = self.args[0] in object
+            elif kind == "getitem":
+                result = object[self.args[0]]
+            elif kind == "setitem":
+                result = object[self.args[0]] = self.args[1]
+            elif kind == "delitem":
+                del object[self.args[0]]
+                result = None
+            elif kind == "len":
+                result = len(object)
+            elif kind == "nonzero":
+                result = bool(object)
+            elif kind == "iter":
+                result = iter(object)
+            else:
+                raise RuntimeError("Don't know how to execute %r kind." % kind)
+        self._execute_cache[id(object)] = result
+        return result
+
+
+class Path(object):
+
+    def __init__(self, root_mock, root_object=None, actions=()):
+        self.root_mock = root_mock
+        self.root_object = root_object
+        self.actions = tuple(actions)
+        self.__mocker_replace__ = False
+
+    def parent_path(self):
+        if not self.actions:
+            return None
+        return self.actions[-1].path
+    parent_path = property(parent_path)
+ 
+    def __add__(self, action):
+        """Return a new path which includes the given action at the end."""
+        return self.__class__(self.root_mock, self.root_object,
+                              self.actions + (action,))
+
+    def __eq__(self, other):
+        """Verify if the two paths are equal.
+        
+        Two paths are equal if they refer to the same mock object, and
+        have the actions with equal kind, args and kwargs.
+        """
+        if (self.root_mock is not other.root_mock or
+            self.root_object is not other.root_object or
+            len(self.actions) != len(other.actions)):
+            return False
+        for action, other_action in zip(self.actions, other.actions):
+            if action != other_action:
+                return False
+        return True
+
+    def matches(self, other):
+        """Verify if the two paths are equivalent.
+        
+        Two paths are equal if they refer to the same mock object, and
+        have the same actions performed on them.
+        """
+        if (self.root_mock is not other.root_mock or
+            len(self.actions) != len(other.actions)):
+            return False
+        for action, other_action in zip(self.actions, other.actions):
+            if not action.matches(other_action):
+                return False
+        return True
+
+    def execute(self, object):
+        """Execute all actions sequentially on object, and return result.
+        """
+        for action in self.actions:
+            object = action.execute(object)
+        return object
+
+    def __str__(self):
+        """Transform the path into a nice string such as obj.x.y('z')."""
+        result = self.root_mock.__mocker_name__ or "<mock>"
+        for action in self.actions:
+            if action.kind == "getattr":
+                result = "%s.%s" % (result, action.args[0])
+            elif action.kind == "setattr":
+                result = "%s.%s = %r" % (result, action.args[0], action.args[1])
+            elif action.kind == "delattr":
+                result = "del %s.%s" % (result, action.args[0])
+            elif action.kind == "call":
+                args = [repr(x) for x in action.args]
+                items = list(action.kwargs.iteritems())
+                items.sort()
+                for pair in items:
+                    args.append("%s=%r" % pair)
+                result = "%s(%s)" % (result, ", ".join(args))
+            elif action.kind == "contains":
+                result = "%r in %s" % (action.args[0], result)
+            elif action.kind == "getitem":
+                result = "%s[%r]" % (result, action.args[0])
+            elif action.kind == "setitem":
+                result = "%s[%r] = %r" % (result, action.args[0],
+                                          action.args[1])
+            elif action.kind == "delitem":
+                result = "del %s[%r]" % (result, action.args[0])
+            elif action.kind == "len":
+                result = "len(%s)" % result
+            elif action.kind == "nonzero":
+                result = "bool(%s)" % result
+            elif action.kind == "iter":
+                result = "iter(%s)" % result
+            else:
+                raise RuntimeError("Don't know how to format kind %r" %
+                                   action.kind)
+        return result
+
+
+class SpecialArgument(object):
+    """Base for special arguments for matching parameters."""
+
+    def __init__(self, object=None):
+        self.object = object
+
+    def __repr__(self):
+        if self.object is None:
+            return self.__class__.__name__
+        else:
+            return "%s(%r)" % (self.__class__.__name__, self.object)
+
+    def matches(self, other):
+        return True
+
+    def __eq__(self, other):
+        return type(other) == type(self) and self.object == other.object
+
+
+class ANY(SpecialArgument):
+    """Matches any single argument."""
+
+ANY = ANY()
+
+
+class ARGS(SpecialArgument):
+    """Matches zero or more positional arguments."""
+
+ARGS = ARGS()
+
+
+class KWARGS(SpecialArgument):
+    """Matches zero or more keyword arguments."""
+
+KWARGS = KWARGS()
+
+
+class IS(SpecialArgument):
+
+    def matches(self, other):
+        return self.object is other
+
+    def __eq__(self, other):
+        return type(other) == type(self) and self.object is other.object
+
+
+class CONTAINS(SpecialArgument):
+
+    def matches(self, other):
+        try:
+            other.__contains__
+        except AttributeError:
+            try:
+                iter(other)
+            except TypeError:
+                # If an object can't be iterated, and has no __contains__
+                # hook, it'd blow up on the test below.  We test this in
+                # advance to prevent catching more errors than we really
+                # want.
+                return False
+        return self.object in other
+
+
+class IN(SpecialArgument):
+
+    def matches(self, other):
+        return other in self.object
+
+
+class MATCH(SpecialArgument):
+
+    def matches(self, other):
+        return bool(self.object(other))
+
+    def __eq__(self, other):
+        return type(other) == type(self) and self.object is other.object
+
+
+def match_params(args1, kwargs1, args2, kwargs2):
+    """Match the two sets of parameters, considering special parameters."""
+
+    has_args = ARGS in args1
+    has_kwargs = KWARGS in args1
+
+    if has_kwargs:
+        args1 = [arg1 for arg1 in args1 if arg1 is not KWARGS]
+    elif len(kwargs1) != len(kwargs2):
+        return False
+
+    if not has_args and len(args1) != len(args2):
+        return False
+
+    # Either we have the same number of kwargs, or unknown keywords are
+    # accepted (KWARGS was used), so check just the ones in kwargs1.
+    for key, arg1 in kwargs1.iteritems():
+        if key not in kwargs2:
+            return False
+        arg2 = kwargs2[key]
+        if isinstance(arg1, SpecialArgument):
+            if not arg1.matches(arg2):
+                return False
+        elif arg1 != arg2:
+            return False
+
+    # Keywords match.  Now either we have the same number of
+    # arguments, or ARGS was used.  If ARGS wasn't used, arguments
+    # must match one-on-one necessarily.
+    if not has_args:
+        for arg1, arg2 in zip(args1, args2):
+            if isinstance(arg1, SpecialArgument):
+                if not arg1.matches(arg2):
+                    return False
+            elif arg1 != arg2:
+                return False
+        return True
+
+    # Easy choice. Keywords are matching, and anything on args is accepted.
+    if (ARGS,) == args1:
+        return True
+
+    # We have something different there. If we don't have positional
+    # arguments on the original call, it can't match.
+    if not args2:
+        # Unless we have just several ARGS (which is bizarre, but..).
+        for arg1 in args1:
+            if arg1 is not ARGS:
+                return False
+        return True
+
+    # Ok, all bets are lost.  We have to actually do the more expensive
+    # matching.  This is an algorithm based on the idea of the Levenshtein
+    # Distance between two strings, but heavily hacked for this purpose.
+    args2l = len(args2)
+    if args1[0] is ARGS:
+        args1 = args1[1:]
+        array = [0]*args2l
+    else:
+        array = [1]*args2l
+    for i in range(len(args1)):
+        last = array[0]
+        if args1[i] is ARGS:
+            for j in range(1, args2l):
+                last, array[j] = array[j], min(array[j-1], array[j], last)
+        else:
+            array[0] = i or int(args1[i] != args2[0])
+            for j in range(1, args2l):
+                last, array[j] = array[j], last or int(args1[i] != args2[j])
+        if 0 not in array:
+            return False
+    if array[-1] != 0:
+        return False
+    return True
+
+
+# --------------------------------------------------------------------
+# Event and task base.
+
+class Event(object):
+    """Aggregation of tasks that keep track of a recorded action.
+
+    An event represents something that may or may not happen while the
+    mocked environment is running, such as an attribute access, or a
+    method call.  The event is composed of several tasks that are
+    orchestrated together to create a composed meaning for the event,
+    including for which actions it should be run, what happens when it
+    runs, and what's the expectations about the actions run.
+    """
+
+    def __init__(self, path=None):
+        self.path = path
+        self._tasks = []
+        self._has_run = False
+
+    def add_task(self, task):
+        """Add a new task to this taks."""
+        self._tasks.append(task)
+        return task
+
+    def remove_task(self, task):
+        self._tasks.remove(task)
+
+    def get_tasks(self):
+        return self._tasks[:]
+
+    def matches(self, path):
+        """Return true if *all* tasks match the given path."""
+        for task in self._tasks:
+            if not task.matches(path):
+                return False
+        return bool(self._tasks)
+
+    def has_run(self):
+        return self._has_run
+
+    def may_run(self, path):
+        """Verify if any task would certainly raise an error if run.
+
+        This will call the C{may_run()} method on each task and return
+        false if any of them returns false.
+        """
+        for task in self._tasks:
+            if not task.may_run(path):
+                return False
+        return True
+
+    def run(self, path):
+        """Run all tasks with the given action.
+
+        @param path: The path of the expression run.
+
+        Running an event means running all of its tasks individually and in
+        order.  An event should only ever be run if all of its tasks claim to
+        match the given action.
+
+        The result of this method will be the last result of a task
+        which isn't None, or None if they're all None.
+        """
+        self._has_run = True
+        result = None
+        errors = []
+        for task in self._tasks:
+            try:
+                task_result = task.run(path)
+            except AssertionError, e:
+                error = str(e)
+                if not error:
+                    raise RuntimeError("Empty error message from %r" % task)
+                errors.append(error)
+            else:
+                if task_result is not None:
+                    result = task_result
+        if errors:
+            message = [str(self.path)]
+            if str(path) != message[0]:
+                message.append("- Run: %s" % path)
+            for error in errors:
+                lines = error.splitlines()
+                message.append("- " + lines.pop(0))
+                message.extend(["  " + line for line in lines])
+            raise AssertionError(os.linesep.join(message))
+        return result
+
+    def satisfied(self):
+        """Return true if all tasks are satisfied.
+
+        Being satisfied means that there are no unmet expectations.
+        """
+        for task in self._tasks:
+            try:
+                task.verify()
+            except AssertionError:
+                return False
+        return True
+
+    def verify(self):
+        """Run verify on all tasks.
+
+        The verify method is supposed to raise an AssertionError if the
+        task has unmet expectations, with a one-line explanation about
+        why this item is unmet.  This method should be safe to be called
+        multiple times without side effects.
+        """
+        errors = []
+        for task in self._tasks:
+            try:
+                task.verify()
+            except AssertionError, e:
+                error = str(e)
+                if not error:
+                    raise RuntimeError("Empty error message from %r" % task)
+                errors.append(error)
+        if errors:
+            message = [str(self.path)]
+            for error in errors:
+                lines = error.splitlines()
+                message.append("- " + lines.pop(0))
+                message.extend(["  " + line for line in lines])
+            raise AssertionError(os.linesep.join(message))
+
+    def replay(self):
+        """Put all tasks in replay mode."""
+        self._has_run = False
+        for task in self._tasks:
+            task.replay()
+
+    def restore(self):
+        """Restore the state of all tasks."""
+        for task in self._tasks:
+            task.restore()
+
+
+class ReplayRestoreEvent(Event):
+    """Helper event for tasks which need replay/restore but shouldn't match."""
+
+    def matches(self, path):
+        return False
+
+
+class Task(object):
+    """Element used to track one specific aspect on an event.
+
+    A task is responsible for adding any kind of logic to an event.
+    Examples of that are counting the number of times the event was
+    made, verifying parameters if any, and so on.
+    """
+
+    def matches(self, path):
+        """Return true if the task is supposed to be run for the given path.
+        """
+        return True
+
+    def may_run(self, path):
+        """Return false if running this task would certainly raise an error."""
+        return True
+
+    def run(self, path):
+        """Perform the task item, considering that the given action happened.
+        """
+
+    def verify(self):
+        """Raise AssertionError if expectations for this item are unmet.
+
+        The verify method is supposed to raise an AssertionError if the
+        task has unmet expectations, with a one-line explanation about
+        why this item is unmet.  This method should be safe to be called
+        multiple times without side effects.
+        """
+
+    def replay(self):
+        """Put the task in replay mode.
+
+        Any expectations of the task should be reset.
+        """
+
+    def restore(self):
+        """Restore any environmental changes made by the task.
+
+        Verify should continue to work after this is called.
+        """
+
+
+# --------------------------------------------------------------------
+# Task implementations.
+
+class OnRestoreCaller(Task):
+    """Call a given callback when restoring."""
+
+    def __init__(self, callback):
+        self._callback = callback
+
+    def restore(self):
+        self._callback()
+
+
+class PathMatcher(Task):
+    """Match the action path against a given path."""
+
+    def __init__(self, path):
+        self.path = path
+
+    def matches(self, path):
+        return self.path.matches(path)
+
+def path_matcher_recorder(mocker, event):
+    event.add_task(PathMatcher(event.path))
+
+Mocker.add_recorder(path_matcher_recorder)
+
+
+class RunCounter(Task):
+    """Task which verifies if the number of runs are within given boundaries.
+    """
+
+    def __init__(self, min, max=False):
+        self.min = min
+        if max is None:
+            self.max = sys.maxint
+        elif max is False:
+            self.max = min
+        else:
+            self.max = max
+        self._runs = 0
+
+    def replay(self):
+        self._runs = 0
+
+    def may_run(self, path):
+        return self._runs < self.max
+
+    def run(self, path):
+        self._runs += 1
+        if self._runs > self.max:
+            self.verify()
+
+    def verify(self):
+        if not self.min <= self._runs <= self.max:
+            if self._runs < self.min:
+                raise AssertionError("Performed fewer times than expected.")
+            raise AssertionError("Performed more times than expected.")
+
+
+class ImplicitRunCounter(RunCounter):
+    """RunCounter inserted by default on any event.
+
+    This is a way to differentiate explicitly added counters and
+    implicit ones.
+    """
+
+def run_counter_recorder(mocker, event):
+    """Any event may be repeated once, unless disabled by default."""
+    if event.path.root_mock.__mocker_count__:
+        event.add_task(ImplicitRunCounter(1))
+
+Mocker.add_recorder(run_counter_recorder)
+
+def run_counter_removal_recorder(mocker, event):
+    """
+    Events created by getattr actions which lead to other events
+    may be repeated any number of times. For that, we remove implicit
+    run counters of any getattr actions leading to the current one.
+    """
+    parent_path = event.path.parent_path
+    for event in mocker.get_events()[::-1]:
+        if (event.path is parent_path and
+            event.path.actions[-1].kind == "getattr"):
+            for task in event.get_tasks():
+                if type(task) is ImplicitRunCounter:
+                    event.remove_task(task)
+
+Mocker.add_recorder(run_counter_removal_recorder)
+
+
+class MockReturner(Task):
+    """Return a mock based on the action path."""
+
+    def __init__(self, mocker):
+        self.mocker = mocker
+
+    def run(self, path):
+        return Mock(self.mocker, path)
+
+def mock_returner_recorder(mocker, event):
+    """Events that lead to other events must return mock objects."""
+    parent_path = event.path.parent_path
+    for event in mocker.get_events():
+        if event.path is parent_path:
+            for task in event.get_tasks():
+                if isinstance(task, MockReturner):
+                    break
+            else:
+                event.add_task(MockReturner(mocker))
+            break
+
+Mocker.add_recorder(mock_returner_recorder)
+
+
+class FunctionRunner(Task):
+    """Task that runs a function everything it's run.
+
+    Arguments of the last action in the path are passed to the function,
+    and the function result is also returned.
+    """
+
+    def __init__(self, func):
+        self._func = func
+
+    def run(self, path):
+        action = path.actions[-1]
+        return self._func(*action.args, **action.kwargs)
+
+
+class PathExecuter(Task):
+    """Task that executes a path in the real object, and returns the result."""
+
+    def __init__(self, result_callback=None):
+        self._result_callback = result_callback
+
+    def get_result_callback(self):
+        return self._result_callback
+
+    def run(self, path):
+        result = path.execute(path.root_object)
+        if self._result_callback is not None:
+            self._result_callback(result)
+        return result
+
+
+class Orderer(Task):
+    """Task to establish an order relation between two events.
+
+    An orderer task will only match once all its dependencies have
+    been run.
+    """
+
+    def __init__(self, path):
+        self.path = path
+        self._run = False 
+        self._dependencies = []
+
+    def replay(self):
+        self._run = False
+
+    def has_run(self):
+        return self._run
+
+    def may_run(self, path):
+        for dependency in self._dependencies:
+            if not dependency.has_run():
+                return False
+        return True
+
+    def run(self, path):
+        for dependency in self._dependencies:
+            if not dependency.has_run():
+                raise AssertionError("Should be after: %s" % dependency.path)
+        self._run = True
+
+    def add_dependency(self, orderer):
+        self._dependencies.append(orderer)
+
+    def get_dependencies(self):
+        return self._dependencies
+
+
+class SpecChecker(Task):
+    """Task to check if arguments of the last action conform to a real method.
+    """
+
+    def __init__(self, method):
+        self._method = method
+        self._unsupported = False
+
+        if method:
+            try:
+                self._args, self._varargs, self._varkwargs, self._defaults = \
+                    inspect.getargspec(method)
+            except TypeError:
+                self._unsupported = True
+            else:
+                if self._defaults is None:
+                    self._defaults = ()
+                if type(method) is type(self.run):
+                    self._args = self._args[1:]
+
+    def get_method(self):
+        return self._method
+
+    def _raise(self, message):
+        spec = inspect.formatargspec(self._args, self._varargs,
+                                     self._varkwargs, self._defaults)
+        raise AssertionError("Specification is %s%s: %s" %
+                             (self._method.__name__, spec, message))
+
+    def verify(self):
+        if not self._method:
+            raise AssertionError("Method not found in real specification")
+
+    def may_run(self, path):
+        try:
+            self.run(path)
+        except AssertionError:
+            return False
+        return True
+
+    def run(self, path):
+        if not self._method:
+            raise AssertionError("Method not found in real specification")
+        if self._unsupported:
+            return # Can't check it. Happens with builtin functions. :-(
+        action = path.actions[-1]
+        obtained_len = len(action.args)
+        obtained_kwargs = action.kwargs.copy()
+        nodefaults_len = len(self._args) - len(self._defaults)
+        for i, name in enumerate(self._args):
+            if i < obtained_len and name in action.kwargs:
+                self._raise("%r provided twice" % name)
+            if (i >= obtained_len and i < nodefaults_len and
+                name not in action.kwargs):
+                self._raise("%r not provided" % name)
+            obtained_kwargs.pop(name, None)
+        if obtained_len > len(self._args) and not self._varargs:
+            self._raise("too many args provided")
+        if obtained_kwargs and not self._varkwargs:
+            self._raise("unknown kwargs: %s" % ", ".join(obtained_kwargs))
+
+def spec_checker_recorder(mocker, event):
+    spec = event.path.root_mock.__mocker_spec__
+    if spec:
+        actions = event.path.actions
+        if len(actions) == 1:
+            if actions[0].kind == "call":
+                method = getattr(spec, "__call__", None)
+                event.add_task(SpecChecker(method))
+        elif len(actions) == 2:
+            if actions[0].kind == "getattr" and actions[1].kind == "call":
+                method = getattr(spec, actions[0].args[0], None)
+                event.add_task(SpecChecker(method))
+
+Mocker.add_recorder(spec_checker_recorder)
+
+
+class ProxyReplacer(Task):
+    """Task which installs and deinstalls proxy mocks.
+
+    This task will replace a real object by a mock in all dictionaries
+    found in the running interpreter via the garbage collecting system.
+    """
+
+    def __init__(self, mock):
+        self.mock = mock
+        self.__mocker_replace__ = False
+
+    def replay(self):
+        global_replace(self.mock.__mocker_object__, self.mock)
+
+    def restore(self):
+        global_replace(self.mock, self.mock.__mocker_object__)
+
+
+def global_replace(remove, install):
+    """Replace object 'remove' with object 'install' on all dictionaries."""
+    for referrer in gc.get_referrers(remove):
+        if (type(referrer) is dict and
+            referrer.get("__mocker_replace__", True)):
+            for key, value in referrer.items():
+                if value is remove:
+                    referrer[key] = install
+
+
+class Undefined(object):
+
+    def __repr__(self):
+        return "Undefined"
+
+Undefined = Undefined()
+
+
+class Patcher(Task):
+
+    def __init__(self):
+        super(Patcher, self).__init__()
+        self._monitored = {} # {kind: {id(object): object}}
+        self._patched = {}
+
+    def is_monitoring(self, obj, kind):
+        monitored = self._monitored.get(kind)
+        if monitored:
+            if id(obj) in monitored:
+                return True
+            cls = type(obj)
+            if issubclass(cls, type):
+                cls = obj
+            bases = set([id(base) for base in cls.__mro__])
+            bases.intersection_update(monitored)
+            return bool(bases)
+        return False
+
+    def monitor(self, obj, kind):
+        if kind not in self._monitored:
+            self._monitored[kind] = {}
+        self._monitored[kind][id(obj)] = obj
+
+    def patch_attr(self, obj, attr, value):
+        original = obj.__dict__.get(attr, Undefined)
+        self._patched[id(obj), attr] = obj, attr, original
+        setattr(obj, attr, value)
+
+    def get_unpatched_attr(self, obj, attr):
+        cls = type(obj)
+        if issubclass(cls, type):
+            cls = obj
+        result = Undefined
+        for mro_cls in cls.__mro__:
+            key = (id(mro_cls), attr)
+            if key in self._patched:
+                result = self._patched[key][2]
+                if result is not Undefined:
+                    break
+            elif attr in mro_cls.__dict__:
+                result = mro_cls.__dict__.get(attr, Undefined)
+                break
+        if isinstance(result, object) and hasattr(type(result), "__get__"):
+            if cls is obj:
+                obj = None
+            return result.__get__(obj, cls)
+        return result
+
+    def _get_kind_attr(self, kind):
+        if kind == "getattr":
+            return "__getattribute__"
+        return "__%s__" % kind
+
+    def replay(self):
+        for kind in self._monitored:
+            attr = self._get_kind_attr(kind)
+            seen = set()
+            for obj in self._monitored[kind].itervalues():
+                cls = type(obj)
+                if issubclass(cls, type):
+                    cls = obj
+                if cls not in seen:
+                    seen.add(cls)
+                    unpatched = getattr(cls, attr, Undefined)
+                    self.patch_attr(cls, attr,
+                                    PatchedMethod(kind, unpatched,
+                                                  self.is_monitoring))
+                    self.patch_attr(cls, "__mocker_execute__",
+                                    self.execute)
+
+    def restore(self):
+        for obj, attr, original in self._patched.itervalues():
+            if original is Undefined:
+                delattr(obj, attr)
+            else:
+                setattr(obj, attr, original)
+        self._patched.clear()
+
+    def execute(self, action, object):
+        attr = self._get_kind_attr(action.kind)
+        unpatched = self.get_unpatched_attr(object, attr)
+        try:
+            return unpatched(*action.args, **action.kwargs)
+        except AttributeError:
+            if action.kind == "getattr":
+                # The normal behavior of Python is to try __getattribute__,
+                # and if it raises AttributeError, try __getattr__.   We've
+                # tried the unpatched __getattribute__ above, and we'll now
+                # try __getattr__.
+                try:
+                    __getattr__ = unpatched("__getattr__")
+                except AttributeError:
+                    pass
+                else:
+                    return __getattr__(*action.args, **action.kwargs)
+            raise
+
+
+class PatchedMethod(object):
+
+    def __init__(self, kind, unpatched, is_monitoring):
+        self._kind = kind
+        self._unpatched = unpatched
+        self._is_monitoring = is_monitoring
+
+    def __get__(self, obj, cls=None):
+        object = obj or cls
+        if not self._is_monitoring(object, self._kind):
+            return self._unpatched.__get__(obj, cls)
+        def method(*args, **kwargs):
+            if self._kind == "getattr" and args[0].startswith("__mocker_"):
+                return self._unpatched.__get__(obj, cls)(args[0])
+            mock = object.__mocker_mock__
+            return mock.__mocker_act__(self._kind, args, kwargs, object)
+        return method
+
+    def __call__(self, obj, *args, **kwargs):
+        # At least with __getattribute__, Python seems to use *both* the
+        # descriptor API and also call the class attribute directly.  It
+        # looks like an interpreter bug, or at least an undocumented
+        # inconsistency.
+        return self.__get__(obj)(*args, **kwargs)
+
+
+def patcher_recorder(mocker, event):
+    mock = event.path.root_mock
+    if mock.__mocker_patcher__ and len(event.path.actions) == 1:
+        patcher = mock.__mocker_patcher__
+        patcher.monitor(mock.__mocker_object__, event.path.actions[0].kind)
+
+Mocker.add_recorder(patcher_recorder)

=== added directory 'data'
=== added file 'data/couchdb.tmpl'
--- data/couchdb.tmpl	1970-01-01 00:00:00 +0000
+++ data/couchdb.tmpl	2009-08-20 12:55:54 +0000
@@ -0,0 +1,38 @@
+<!doctype html>
+<html>
+<head>
+<title>Your Desktop CouchDB</title>
+<script>
+window.onload = function() {
+    if (document.cookie == "yes") {
+        location.href = document.getElementById("there").href;
+    }
+    document.getElementById("there").addEventListener("click", function(e) {
+        document.cookie = "yes; expires=Thu, 31 Dec 2099 21:00:00 UTC";
+    }, false);
+    var count = 30;
+    setInterval(function() {
+        count -= 1;
+        if (count < 0) {
+            location.href = document.getElementById("there").href;
+            return;
+        }
+        document.getElementsByTagName("span")[0].innerHTML = count;
+    }, 1000);
+}
+</script>
+</head>
+<body>
+<h1>Desktop CouchDB</h1>
+<p>Your desktop CouchDB is the data store for many of your applications.
+You can browse around it to see which data your applications are storing.</p>
+<p>You should bookmark this page (by going to <strong>Bookmarks > Bookmark
+This Page</strong> or pressing <strong>Ctrl-D</strong>) so you can easily
+come back to browse your CouchDB again.</p>
+<p>Don't bookmark the CouchDB page itself, because its location may change!</p>
+<p>Taking you to your Desktop CouchDB in <span>30</span> seconds...
+<a id="there" href="http://[[COUCHDB_USERNAME]]:[[COUCHDB_PASSWORD]]@localhost:[[COUCHDB_PORT]]/_utils">take me
+there straight away from now on</a> (remember to bookmark this page first!)</p>
+</body>
+</html>
+

=== added directory 'debian'
=== added file 'debian/changelog'
--- debian/changelog	1970-01-01 00:00:00 +0000
+++ debian/changelog	2009-09-01 21:50:36 +0000
@@ -0,0 +1,81 @@
+desktopcouch (0.3.1-0ubuntu1) karmic; urgency=low
+
+  [Ken VanDine]
+  * debian/control
+    - Added depends on python-desktopcouch-records. (LP: #422179)
+  [Chad Miller]
+  * New upstream release.
+  * Changed Vcs-Bzr links in control file.
+  * Changed version dependency on couchdb.
+  * Converting to a full-blown source-package branch.
+  * Fix getPort failure. (LP: #420911, LP: #422127)
+  * Check couchdb bind-port in replicator. (LP: #419973)
+  * Change couchdb bind-port in pairing tool. (LP: #419969)
+
+ -- Chad Miller <[e-mail]>  Tue, 01 Sep 2009 11:57:25 -0400
+
+desktopcouch (0.3-0ubuntu1) karmic; urgency=low
+
+  [ Ken VanDine ]
+  * New upstream release (LP: #416591)
+    - added unit tests for couchwidget, and then fixed bug #412266
+    - Change to freedesktop URL for record type spec.
+    - First version of the contacts picker, based on CouchWidget
+    - Adding the desktopcouch.contacts module.
+    - Use subprocess.Popen and ourselves to the wait()ing, 
+      since subprocess.call() is buggy.  There's still an EINTR bug 
+      in subprocess, though.
+    - Occasionally stop couchdb in tests, so we exercise the automatic 
+      starting code.  This will lead to spurious errors because of the 
+      aforementioned subprocess bug, but it's the right thing to do.
+    - Abstract away some of the linuxisms and complain if we're run on 
+      an unsupported OS.
+    - Fix a race condition in the process-testing code.
+    - Replace the TestCase module with one that doesn't complain of dirty 
+      twisted reactors.
+    - Add a means of stopping the desktop couchdb daemon.
+    - Add an additional check that a found PID and process named correctly 
+      is indeed a process that this user started, so we don't try to talk 
+      to other local users' desktop couchdbs.
+    - Get the port at function-call time, instead of storing a port at
+      start-time and giving that back. The info can be stale, the old
+      way.
+    - Don't create a view per record-type; instead, call the standard 
+      return-all-records-keyed-by-record-type and use slice notation on 
+      the viewresults to only get back the records with that type, 
+      which does the same thing but more elegantly.
+    - Remove the unused/invalid "utils" import from test_server
+    - Change the name of a function tested to be what actually exists in 
+      the code.
+    - Refactored server.py by renaming server.get_records_and_type to 
+      server.get_records. Also modified the function to take a record 
+      type param if desired to only create records of that type and 
+      optionally create a view name "get_"+ record_type. (LP: #411475)
+  * debian/control
+    - Make python-desktopcouch depend on python-gtk2 and python-gnomekeyring
+    - Make python-desktopcouch-records depend on python-gtk2, 
+      python-gnomekeyring, and python-oauth.
+    - Remove depends for python-distutils-extra
+    - Fixed Vcs-Browser tag
+
+  [Elliot Murphy]
+  * debian/control: added build-dep on python-setuptools
+
+
+  [ Martin Pitt ]
+  * debian/control: Fix Vcs-* links.
+
+ -- Ken VanDine <[e-mail]>  Thu, 27 Aug 2009 15:32:11 +0200
+
+desktopcouch (0.2-0ubuntu1) karmic; urgency=low
+
+  * New upstream release
+    * Handle the case where the pid file is empty or doesn't exist (LP: #408796)
+
+ -- Ken VanDine <[e-mail]>  Wed, 05 Aug 2009 02:17:47 +0100
+
+desktopcouch (0.1-0ubuntu1) karmic; urgency=low
+
+  * Initial release (LP: #397662)
+
+ -- Ken VanDine <[e-mail]>  Fri, 31 Jul 2009 13:44:45 -0400

=== added file 'debian/compat'
--- debian/compat	1970-01-01 00:00:00 +0000
+++ debian/compat	2009-09-01 15:46:56 +0000
@@ -0,0 +1,1 @@
+6

=== added file 'debian/control'
--- debian/control	1970-01-01 00:00:00 +0000
+++ debian/control	2009-09-01 16:00:58 +0000
@@ -0,0 +1,75 @@
+Source: desktopcouch
+Section: python
+Priority: optional
+Build-Depends: cdbs (>= 0.4.43),
+ debhelper (>= 6),
+ python,
+ python-central (>= 0.6.11),
+ python-distutils-extra (>= 2.8),
+ python-setuptools
+Maintainer: Ubuntu Developers <[e-mail]>
+Standards-Version: 3.8.2
+XS-Python-Version: current
+Homepage: http://launchpad.net/desktopcouch
+Vcs-Bzr: https://code.launchpad.net/~ubuntuone-control-tower/ubuntu/karmic/desktopcouch/spb
+Vcs-Browser: http://bazaar.launchpad.net/~ubuntuone-control-tower/ubuntu/karmic/desktopcouch/spb
+
+Package: desktopcouch
+Architecture: all
+XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+ ${python:Depends},
+ couchdb (>= 0.10.0~svn809550),
+ python-dbus,
+ python-couchdb (>= 0.6),
+ python-twisted-core,
+ python-gobject,
+ python-avahi,
+ python-desktopcouch,
+ python-desktopcouch-records,
+ python-gtk2
+Description: A Desktop CouchDB instance
+ Runs an instance of CouchDB with the users session.
+
+Package: desktopcouch-tools
+Architecture: all
+XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+ ${python:Depends},
+ python-dbus,
+ python-twisted-core,
+ python-gobject,
+ python-avahi,
+ python-desktopcouch,
+ python-gtk2
+Description: Desktop CouchDB tools
+ Tools used to work with Desktop CouchDB.
+
+Package: python-desktopcouch
+Architecture: all
+XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+ ${python:Depends},
+ desktopcouch,
+ python-dbus,
+ python-couchdb,
+ python-xdg,
+ python-twisted-core,
+ python-gtk2,
+ python-gnomekeyring
+Description: Python Desktop CouchDB 
+ A Python library for Desktop CouchDB.
+
+Package: python-desktopcouch-records
+Architecture: all
+XB-Python-Version: ${python:Versions}
+Depends: ${misc:Depends},
+ ${python:Depends},
+ python-dbus,
+ python-couchdb,
+ python-desktopcouch,
+ python-gtk2,
+ python-gnomekeyring,
+ python-oauth
+Description: Desktop CouchDB Records API
+ A Python library for the Desktop CouchDB Records API.

=== added file 'debian/copyright'
--- debian/copyright	1970-01-01 00:00:00 +0000
+++ debian/copyright	2009-09-01 15:46:56 +0000
@@ -0,0 +1,11 @@
+Format-Specification: http://wiki.debian.org/Proposals/CopyrightFormat
+Upstream-Name: desktopcouch
+Upstream-Maintainer: Stuart Langridge <[e-mail]>
+Upstream-Source: https://launchpad.net/desktopcouch
+
+Files: *
+Copyright: (C) 2009 Canonical Ltd.
+
+License: LGPL-3
+ The full text of the LGPL is distributed in
+ /usr/share/common-licenses/LGPL-3 on Debian systems.

=== added file 'debian/desktopcouch-tools.install'
--- debian/desktopcouch-tools.install	1970-01-01 00:00:00 +0000
+++ debian/desktopcouch-tools.install	2009-09-01 15:46:56 +0000
@@ -0,0 +1,4 @@
+debian/tmp/usr/share/applications/desktopcouch-pair.desktop
+debian/tmp/usr/bin/desktopcouch-pair
+debian/tmp/usr/share/man/man1/desktopcouch-pair.1
+#debian/tmp/usr/share/locale/*/LC_MESSAGES/desktopcouch.mo

=== added file 'debian/desktopcouch.install'
--- debian/desktopcouch.install	1970-01-01 00:00:00 +0000
+++ debian/desktopcouch.install	2009-09-01 15:46:56 +0000
@@ -0,0 +1,3 @@
+debian/tmp/usr/share/desktopcouch
+debian/tmp/usr/lib/desktopcouch/desktopcouch-{stop,service}
+debian/tmp/usr/share/dbus-1/services/org.desktopcouch.CouchDB.service

=== added file 'debian/pycompat'
--- debian/pycompat	1970-01-01 00:00:00 +0000
+++ debian/pycompat	2009-09-01 15:46:56 +0000
@@ -0,0 +1,1 @@
+2

=== added file 'debian/python-desktopcouch-records.install'
--- debian/python-desktopcouch-records.install	1970-01-01 00:00:00 +0000
+++ debian/python-desktopcouch-records.install	2009-09-01 15:46:56 +0000
@@ -0,0 +1,2 @@
+debian/tmp/usr/share/doc/python-desktopcouch-records/api
+debian/tmp/usr/lib/*/*/desktopcouch/records/*

=== added file 'debian/python-desktopcouch.install'
--- debian/python-desktopcouch.install	1970-01-01 00:00:00 +0000
+++ debian/python-desktopcouch.install	2009-09-01 15:46:56 +0000
@@ -0,0 +1,2 @@
+debian/tmp/usr/lib/*/*/desktopcouch/*.py
+debian/tmp/usr/lib/*/*/desktopcouch/pair/{couchdb_pairing,__init__.py}

=== added file 'debian/rules'
--- debian/rules	1970-01-01 00:00:00 +0000
+++ debian/rules	2009-09-01 15:46:56 +0000
@@ -0,0 +1,7 @@
+#!/usr/bin/make -f
+
+DEB_PYTHON_SYSTEM := pycentral
+
+include /usr/share/cdbs/1/rules/debhelper.mk
+include /usr/share/cdbs/1/class/python-distutils.mk
+include /usr/share/cdbs/1/rules/langpack.mk

=== added file 'debian/watch'
--- debian/watch	1970-01-01 00:00:00 +0000
+++ debian/watch	2009-09-01 15:46:56 +0000
@@ -0,0 +1,2 @@
+version=3
+http://launchpad.net/desktopcouch/+download .*/desktopcouch-([0-9.]+)\.tar\.gz

=== added directory 'desktopcouch'
=== added file 'desktopcouch-pair.desktop.in'
--- desktopcouch-pair.desktop.in	1970-01-01 00:00:00 +0000
+++ desktopcouch-pair.desktop.in	2009-07-27 19:18:55 +0000
@@ -0,0 +1,8 @@
+[Desktop Entry]
+_Name=CouchDB Pairing Tool
+Type=Application
+_Comment=Utility for pairing Desktop CouchDB
+Exec=desktopcouch-pair
+Icon=
+Categories=Network;
+_GenericName=CouchDB Pairing Tool

=== added file 'desktopcouch/__init__.py'
--- desktopcouch/__init__.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/__init__.py	2009-09-01 00:38:53 +0000
@@ -0,0 +1,98 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+"Desktop Couch helper files"
+
+from __future__ import with_statement
+import os, re, time
+from desktopcouch.start_local_couchdb import process_is_couchdb, read_pidfile
+
+def find_pid(start_if_not_running=True):
+    # Work out whether CouchDB is running by looking at its pid file
+    pid = read_pidfile()
+    if not process_is_couchdb(pid) and start_if_not_running:
+        # start CouchDB by running the startup script
+        print "Desktop CouchDB is not running; starting it.",
+        from desktopcouch import start_local_couchdb
+        pid = start_local_couchdb.start_couchdb()
+        # now load the design documents, because it's started
+        start_local_couchdb.update_design_documents()
+
+        if not process_is_couchdb(pid):
+            raise RuntimeError("desktop-couch not started")
+
+    return pid
+
+def find_port__linux(pid=None):
+    if pid is None:
+        pid = find_pid()
+
+    proc_dir = "/proc/%s" % (pid,)
+
+    # enumerate the process' file descriptors
+    fd_dir = os.path.join(proc_dir, 'fd')
+    try:
+        fd_paths = [os.readlink(os.path.join(fd_dir, fd))
+                    for fd in os.listdir(fd_dir)]
+    except OSError:
+        raise RuntimeError("Unable to find file descriptors in /proc")
+
+    # identify socket fds
+    socket_matches = [re.match('socket:\\[([0-9]+)\\]', p) for p in fd_paths]
+    # extract their inode numbers
+    socket_inodes = [m.group(1) for m in socket_matches if m is not None]
+
+    # construct a subexpression which matches any one of these inodes
+    inode_subexp = "|".join(map(re.escape, socket_inodes))
+    # construct regexp to match /proc/net/tcp entries which are listening
+    # sockets having one of the given inode numbers
+    listening_regexp = re.compile(r'''
+        \s*\d+:\s*                # sl
+        [0-9A-F]{8}:              # local_address part 1
+        ([0-9A-F]{4})\s+          # local_address part 2
+        00000000:0000\s+          # rem_address
+        0A\s+                     # st (0A = listening)
+        [0-9A-F]{8}:              # tx_queue
+        [0-9A-F]{8}\s+            # rx_queue
+        [0-9A-F]{2}:              # tr
+        [0-9A-F]{8}\s+            # tm->when
+        [0-9A-F]{8}\s*            # retrnsmt
+        \d+\s+\d+\s+              # uid, timeout
+        (?:%s)\s+                 # inode
+        ''' % (inode_subexp,), re.VERBOSE)
+
+    # extract the TCP port from the first matching line in /proc/$pid/net/tcp
+    port = None
+    with open(os.path.join(proc_dir, 'net', 'tcp')) as tcp_file:
+        for line in tcp_file:
+            match = listening_regexp.match(line)
+            if match is not None:
+                port = str(int(match.group(1), 16))
+                break
+    if port is None:
+        raise RuntimeError("Unable to find listening port")
+
+    return port
+
+
+
+import platform
+os_name = platform.system()
+try:
+    find_port = {
+        "Linux": find_port__linux
+        } [os_name]
+except KeyError:
+    raise NotImplementedError("os %r is not yet supported" % (os_name,))

=== added directory 'desktopcouch/contacts'
=== added file 'desktopcouch/contacts/__init__.py'
--- desktopcouch/contacts/__init__.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/__init__.py	2009-08-17 21:39:48 +0000
@@ -0,0 +1,20 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Eric Casteleijn <[e-mail]>
+#          Nicola Larosa <[e-mail]>
+
+"""UbuntuOne Contacts API"""

=== added file 'desktopcouch/contacts/contactspicker.py'
--- desktopcouch/contacts/contactspicker.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/contactspicker.py	2009-08-24 20:35:25 +0000
@@ -0,0 +1,81 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+# desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Rodrigo Moya <[e-mail]
+
+"""A widget to allow users to pick contacts"""
+
+import gtk
+from desktopcouch.contacts.record import CONTACT_RECORD_TYPE
+from desktopcouch.records.couchgrid import CouchGrid
+
+
+class ContactsPicker(gtk.VBox):
+    """A contacts picker"""
+
+    def __init__(self, uri=None):
+        """Create a new ContactsPicker widget."""
+
+        gtk.VBox.__init__(self)
+
+        # Create search entry and button
+        hbox = gtk.HBox()
+        self.pack_start(hbox, False, False, 3)
+
+        self.search_entry = gtk.Entry()
+        hbox.pack_start(self.search_entry, True, True, 3)
+
+        self.search_button = gtk.Button(
+            stock=gtk.STOCK_FIND, use_underline=True)
+        hbox.pack_start(self.search_button, False, False, 3)
+
+        # Create CouchGrid to contain list of contacts
+        self.contacts_list = CouchGrid('contacts', uri=uri)
+        self.contacts_list.editable = False
+        self.contacts_list.keys = [ "first_name", "last_name" ]
+        self.contacts_list.record_type = CONTACT_RECORD_TYPE
+
+        #Pimp out the columns with some nicer titles
+        #TODO: this should be set up for translatability
+        columns = self.contacts_list.get_columns()
+        columns[0].set_title("First Name")
+        columns[1].set_title("Last Name")
+
+        self.contacts_list.show()
+        self.pack_start(self.contacts_list, True, True, 3)
+
+    def get_contacts_list(self):
+        """get_contacts_list - gtk.Widget value
+        Gets the CouchGrid inside the ContactsPicker widget
+        """
+        return self.contacts_list
+
+if __name__ == "__main__":
+    """creates a test ContactsPicker if called directly"""
+
+    # Create and show a test window
+    win = gtk.Dialog("ContactsPicker widget test", None, 0,
+                     (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
+    win.connect("response", gtk.main_quit)
+    win.resize(300, 450)
+
+    # Create the contacts picker widget
+    picker = ContactsPicker()
+    win.get_content_area().pack_start(picker, True, True, 3)
+
+    # Run the test application
+    win.show_all()
+    gtk.main()

=== added file 'desktopcouch/contacts/record.py'
--- desktopcouch/contacts/record.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/record.py	2009-08-19 10:07:54 +0000
@@ -0,0 +1,34 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Eric Casteleijn <[e-mail]>
+#          Nicola Larosa <[e-mail]>
+#          Mark G. Saye <[e-mail]>
+
+
+"""A dictionary based contact record representation."""
+
+from desktopcouch.records.record import Record
+
+CONTACT_RECORD_TYPE = 'http://www.freedesktop.org/wiki/Specifications/desktopcouch/contact'
+
+
+class Contact(Record):
+    """An Ubuntuone Contact Record."""
+
+    def __init__(self, data=None, record_id=None):
+        super(Contact, self).__init__(
+            record_id=record_id, data=data, record_type=CONTACT_RECORD_TYPE)

=== added file 'desktopcouch/contacts/schema.txt'
--- desktopcouch/contacts/schema.txt	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/schema.txt	2009-08-19 10:07:54 +0000
@@ -0,0 +1,50 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+
+Schema
+
+The proposed CouchDB contact schema is as follows:
+
+Core fields
+
+    * record_type 'http://www.freedesktop.org/wiki/Specifications/desktopcouch/contact'
+    * first_name (string)
+    * last_name (string)
+    * birth_date (string, "YYYY-MM-DD")
+    * addresses (MergeableList of "address" dictionaries)
+          o city (string)
+          o address1 (string)
+          o address2 (string)
+          o pobox (string)
+          o state (string)
+          o country (string)
+          o postalcode (string)
+          o description (string, e.g., "Home")
+    * email_addresses (MergeableList of "emailaddress" dictionaries)
+          o address (string),
+          o description (string)
+    * phone_numbers (MergeableList of "phone number" dictionaries)
+          o number (string)
+          o description (string)
+    * application_annotations Everything else, organized per application.
+
+Note: None of the core fields are mandatory, but applications should
+not add any other fields at the top level of the record. Any fields
+needed not defined here should be put under application_annotations in
+the namespace of the application there. So for Ubuntu One:
+
+    "application_annotations": {
+        "Ubuntu One": {<Ubuntu One specific fields here>}}

=== added directory 'desktopcouch/contacts/testing'
=== added file 'desktopcouch/contacts/testing/__init__.py'
--- desktopcouch/contacts/testing/__init__.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/testing/__init__.py	2009-08-17 21:39:48 +0000
@@ -0,0 +1,20 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Stuart Langridge <[e-mail]>
+#          Nicola Larosa <[e-mail]>
+
+"""Support code for tests"""

=== added file 'desktopcouch/contacts/testing/create.py'
--- desktopcouch/contacts/testing/create.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/testing/create.py	2009-08-19 10:07:54 +0000
@@ -0,0 +1,113 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Stuart Langridge <[e-mail]>
+#          Nicola Larosa <[e-mail]>
+
+"""Creating CouchDb-stored contacts for testing"""
+
+import random, string, uuid
+
+from couchdb import Server
+
+CONTACT_DOCTYPE = 'http://www.freedesktop.org/wiki/Specifications/desktopcouch/contact'
+COUCHDB_SYS_PORT = 5984
+
+FIRST_NAMES = ('Jack', 'Thomas', 'Oliver', 'Joshua', 'Harry', 'Charlie',
+    'Daniel', 'William', 'James', 'Alfie', 'Grace', 'Ruby', 'Olivia',
+    'Emily', 'Jessica', 'Sophie', 'Chloe', 'Lily', 'Ella', 'Amelia')
+LAST_NAMES = ('Dalglish', 'Grobbelaar', 'Lawrenson', 'Beglin', 'Nicol',
+    'Whelan', 'Hansen', 'Johnston', 'Rush', 'Molby', 'MacDonald', 'McMahon')
+CITIES = ('Scunthorpe', 'Birmingham', 'Cambridge', 'Durham', 'Bedford')
+COUNTRIES = ('England', 'Ireland', 'Scotland', 'Wales')
+
+def random_string(length=10):
+    """Return a string of random lowercase letters and of specified length"""
+    return ''.join(random.sample(string.lowercase, length))
+
+def random_postal_address():
+    """Return something that looks like a postal address"""
+    return '%s Street' % random.choice(LAST_NAMES)
+
+def random_email_address(first_name, last_name):
+    """Return something that looks like an email address"""
+    return '%s.%s@%s.com' % (first_name, last_name, random_string(3))
+
+def random_postal_code():
+    """Return something that looks like a postal code"""
+    return '%s12 3%s' % (random_string(2), random_string(2))
+
+def random_phone_number():
+    """Return something that looks like a phone number"""
+    return '+%s %s %s %s' % (random.randint(10, 99), random.randint(10, 99),
+      random.randint(1000, 9999), random.randint(1000, 9999))
+
+def random_birth_date():
+    """Return something that looks like a birth date"""
+    return '%04d-%02d-%02d' % (random.randint(1900, 2006),
+        random.randint(1, 12), random.randint(1, 28))
+
+def make_one_contact(maincount, doctype, app_annots):
+    """Make up one contact randomly"""
+    # Record schema
+    fielddict = {'record_type': doctype, 'record_type_version': '1.0'}
+    # Names
+    first_name = random.choice(FIRST_NAMES) + str(maincount)
+    last_name = random.choice(LAST_NAMES)
+    # Addresses
+    addresses = {}
+    for address_type in ('home', 'work', 'other'):
+        addresses[str(uuid.uuid4())] = {
+            'address1': random_postal_address(), 'address2': '',
+            'pobox': '', 'city': random.choice(CITIES),
+            'state': '', 'postalcode': random_postal_code(),
+            'country': random.choice(COUNTRIES), 'description': address_type}
+    # Email addresses
+    email_addresses = {}
+    for email_address_type in ('home', 'work', 'other'):
+        email_addresses[str(uuid.uuid4())] = {
+            'address': random_email_address(first_name, last_name),
+            'description': email_address_type}
+    # Phone numbers
+    phone_numbers = {}
+    for phone_number_type in ('home', 'work', 'other'):
+        phone_numbers[str(uuid.uuid4())] = {
+            'priority': 0, 'number': random_phone_number(),
+            'description': phone_number_type}
+    # Store data in fielddict
+    fielddict.update({'first_name': first_name, 'last_name': last_name,
+        'addresses': addresses, 'email_addresses': email_addresses,
+        'phone_numbers': phone_numbers, 'birth_date': random_birth_date()})
+    # Possibly add example application annotations
+    if app_annots:
+        fielddict['application_annotations'] = app_annots
+    return fielddict
+
+def create_many_contacts(
+        num_contacts=10, host='localhost', port=COUCHDB_SYS_PORT,
+        db_name='contacts', doctype=CONTACT_DOCTYPE, app_annots=None):
+    """Make many contacts and create their records"""
+    server_url = 'http://%s:%s/' % (host, port)
+    server = Server(server_url)
+    db = server[db_name] if db_name in server else server.create(db_name)
+    record_ids = []
+    for maincount in range(1, num_contacts + 1):
+        # Make the contact
+        fielddict = make_one_contact(maincount, doctype, app_annots)
+        # Store data in CouchDB
+        record_id = db.create(fielddict)
+        record_ids.append(record_id)
+    return record_ids

=== added directory 'desktopcouch/contacts/tests'
=== added file 'desktopcouch/contacts/tests/__init__.py'
--- desktopcouch/contacts/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/tests/__init__.py	2009-08-17 21:39:48 +0000
@@ -0,0 +1,17 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+
+"Tests for Contacts API"

=== added file 'desktopcouch/contacts/tests/test_contactspicker.py'
--- desktopcouch/contacts/tests/test_contactspicker.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/tests/test_contactspicker.py	2009-08-24 20:35:25 +0000
@@ -0,0 +1,55 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Rick Spencer <[e-mail]>
+
+"""Tests for the ContactsPicker class"""
+
+import testtools
+import gtk
+from desktopcouch.contacts.contactspicker import ContactsPicker
+from desktopcouch.records.server import CouchDatabase
+from desktopcouch.records.tests import get_uri
+
+URI = get_uri()
+
+class TestContactsPicker(testtools.TestCase):
+    """Test the Contact Picker Window."""
+
+    def setUp(self):
+        """setup each test"""
+        # Connect to CouchDB server
+        self.dbname = 'contacts'
+        self.database = CouchDatabase(self.dbname, create=True, uri=URI)
+
+    def tearDown(self):
+        """tear down each test"""
+        del self.database._server[self.dbname]
+
+    def test_can_contruct_contactspicker(self):
+        """Test that we can build the window"""
+        # Create and show a test window
+        win = gtk.Dialog("ContactsPicker widget test", None, 0,
+                        (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
+        win.connect("response", gtk.main_quit)
+        win.resize(300, 450)
+
+        # Create the contacts picker widget
+        picker = ContactsPicker(uri=URI)
+        win.get_content_area().pack_start(picker, True, True, 3)
+        self.assert_(picker.get_contacts_list())
+
+

=== added file 'desktopcouch/contacts/tests/test_record.py'
--- desktopcouch/contacts/tests/test_record.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/contacts/tests/test_record.py	2009-08-17 21:39:48 +0000
@@ -0,0 +1,31 @@
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch-contacts.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Authors: Nicola Larosa <[e-mail]>
+
+"""Tests for the ContactDocument class"""
+
+import testtools
+from desktopcouch.contacts.record import Contact, CONTACT_RECORD_TYPE
+
+class TestContactRecord(testtools.TestCase):
+    """Test the Contact Record object."""
+
+    def test_contact_record(self):
+        """Test that we get the correct record type."""
+        contact = Contact()
+        self.assertEqual(CONTACT_RECORD_TYPE, contact.record_type)
+

=== added file 'desktopcouch/local_files.py'
--- desktopcouch/local_files.py	1970-01-01 00:00:00 +0000
+++ desktopcouch/local_files.py	2009-08-31 15:27:31 +0000
@@ -0,0 +1,137 @@
+#!/usr/bin/python
+# Copyright 2009 Canonical Ltd.
+#
+# This file is part of desktopcouch.
+#
+#  desktopcouch is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License version 3
+# as published by the Free Software Foundation.
+#
+# desktopcouch 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with desktopcouch.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author: Stuart Langridge <[e-mail]>
+#         Eric Casteleijn <[e-mail]>
+
+"""Specify location of files relevant to desktop CouchDB.
+
+Checks to see whether we're running out of the source tree or not.
+"""
+
+import os
+import xdg.BaseDirectory
+import subprocess
+import logging
+try:
+    import ConfigParser as configparser
+except ImportError:
+    import configparser
+
+def mkpath(rootdir, path):
+    "Remove .. from paths"
+    return os.path.realpath(os.path.join(rootdir, path))
+
+rootdir = os.path.join(xdg.BaseDirectory.xdg_cache_home, "desktop-couch")
+if not os.path.isdir(rootdir):
+    os.mkdir(rootdir)
+config_dir = xdg.BaseDirectory.save_config_path("desktop-couch")
+FILE_INI = os.path.join(config_dir, "desktop-couchdb.ini")
+DIR_DB = xdg.BaseDirectory.save_data_path("desktop-couch")
+
+FILE_PID = mkpath(rootdir, "desktop-couchdb.pid")
+FILE_LOG = mkpath(rootdir, "desktop-couchdb.log")
+FILE_STDOUT = mkpath(rootdir, "desktop-couchdb.stdout")
+FILE_STDERR = mkpath(rootdir, "desktop-couchdb.stderr")
+
+COUCH_EXE = os.environ.get('COUCHDB')
+if not COUCH_EXE:
+    for x in os.environ['PATH'].split(':'):
+        if os.path.exists(os.path.join(x, 'couchdb')):
+            COUCH_EXE = os.path.join(x, 'couchdb')
+if not COUCH_EXE:
+    raise ImportError("Could not find couchdb")
+
+def couch_chain_flag():
+    process = subprocess.Popen([COUCH_EXE, '-V'], shell=False,
+        stdout=subprocess.PIPE)
+    line = process.stdout.read().split('\n')[0]
+    couchversion = line.split()[-1]