Merge lp:~benji/juju-deployer/add-fetching-configs into lp:~gandelman-a/juju-deployer/trunk

[Benji York]

Add the ability to specify a configuration file by URL.

This branch adds the ability to specify a configuration file (in a -c option) by URL and have that configuration file loaded over the network, stored in a temp file locally, and used by the deployer.

Unmerged revisions

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2013-07-15 21:24:33 +0000
@@ -0,0 +1,7 @@
+deployer.sublime-project
+deployer.sublime-workspace
+tmp
+juju_deployer.egg-info
+.emacs.desktop
+.emacs.desktop.lock
+_build

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

=== added file 'MANIFEST.in'
--- MANIFEST.in	1970-01-01 00:00:00 +0000
+++ MANIFEST.in	2013-07-15 21:24:33 +0000
@@ -0,0 +1,2 @@
+include README
+include LICENSE
\ No newline at end of file

=== modified file 'README'
--- README	2013-01-10 18:23:17 +0000
+++ README	2013-07-15 21:24:33 +0000
@@ -1,4 +1,78 @@
-1. Juju deployer
+Juju Deployer
+-------------
+
+A deployment tool for juju that allows stack-like configurations of complex
+deployments.
+
+It supports configuration in yaml or json.
+
+Installation
+------------
+
+  $ virtualenv --system-site-packages deployer
+  $ ./deployer/bin/easy_install juju-deployer
+  $ ./deployer/bin/juju-deployer -h
+
+
+Usage
+-----
+
+
+Stack Definitions
+-----------------
+
+High level view::
+
+  blog:
+     series: precise
+     services:
+        blog:
+          charm: wordpress
+          branch: lp:charms/precise/wordpress
+        db:
+          charm: mysql
+          branch: lp:charms/precise/mysql
+     relations:
+        - [db, blog]
+
+  blog-prod:
+     inherits: blog
+     services:
+        blog:
+          num_units: 3
+          constraints: instance-type=m1.medium
+          options:
+            wp-content: include-file://content-branch.txt
+        db:
+          constraints: instance-type=m1.large
+          options:
+            tuning: include-base64://db-tuning.txt
+        cachelb:
+          charm: varnish
+          branch: lp:charms/precise/varnish
+     relations:
+        - [cachelb, blog]
+
+ 
+ We've got two deployment stacks here, blog, and blog-prod. The blog stack defines
+ a simple wordpress deploy with mysql and two relations. In this case its
+
+
+Development
+-----------
+
+ Obtain source
+
+   $ bzr branch lp:juju-deployer/darwin deployer
+   $ cd deployer
+
+   # Test runner 
+   $ python test_deployment.py -h
+
+  
+
+Background
+----------
 
 This is a wrapper for Juju that allows stack-like configurations of complex
 deployments.  It was created to deploy Openstack but should be able to deploy

=== added directory 'configs'
=== added file 'configs/blog.yaml'
--- configs/blog.yaml	1970-01-01 00:00:00 +0000
+++ configs/blog.yaml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,36 @@
+wordpress-stage:
+    series: precise
+    services:
+        blog:
+            charm: wordpress
+            branch: lp:charms/precise/wordpress
+            constraints: mem=2
+            options:
+                tuning: optimized
+                engine: apache
+        db:
+            charm: mysql
+            branch: lp:charms/precise/mysql
+            options:
+                tuning-level: fast
+        memcached:
+            branch: lp:charms/precise/memcached
+            options:
+                request-limit: 32
+    relations:
+        - [blog, [db, memcached]]
+
+wordpress-prod:
+    series: precise
+    inherits: wordpress-stage
+    services:
+        blog:
+            options:
+                engine: nginx
+                tuning: optimized
+            constraints: cpu-cores=1
+
+        db:
+            constraints: cpu-cores=2
+            options:
+                tuning-level: safest

=== added file 'configs/gui-export.yml'
--- configs/gui-export.yml	1970-01-01 00:00:00 +0000
+++ configs/gui-export.yml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,42 @@
+envExport: 
+  series: precise
+  services: 
+
+    fs:
+      charm: cs:precise/ceph
+      options: 
+        "auth-supported": cephx
+        "ephemeral-unmount": ""
+        fsid: ""
+        key: ""
+        "monitor-count": "3"
+        "monitor-secret": ""
+        "osd-devices": /dev/vdb
+        "osd-format": xfs
+        "osd-journal": ""
+        "osd-reformat": ""
+        source: "cloud:precise-updates/folsom"
+      num_units: 1
+    wordpress:
+      charm: cs:precise/wordpress
+      options: 
+        debug: no
+        engine: nginx
+        tuning: single
+        "wp-content": ""
+      num_units: 1
+    mysql:
+      charm: cs:precise/mysql
+      options: 
+        "binlog-format": MIXED
+        "dataset-size": "80%"
+        flavor: distro
+        "max-connections": "-1"
+        "preferred-storage-engine": InnoDB
+        "query-cache-size": "-1"
+        "query-cache-type": OFF
+        "tuning-level": safest
+      num_units: 1
+  relations: 
+    - - "wordpress:db"
+      - "mysql:db"

=== renamed file 'deployments.cfg' => 'configs/openstack.cfg'
=== renamed file 'deployments.cfg.sample' => 'configs/ostack-testing-sample.cfg'
=== added file 'configs/wiki.yaml'
--- configs/wiki.yaml	1970-01-01 00:00:00 +0000
+++ configs/wiki.yaml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,24 @@
+wiki:
+  series: precise
+  services:
+    wiki:
+      charm: mediawiki
+      branch: lp:charms/precise/mediawiki
+      constraints: mem=2
+      num_units: 2
+     db:
+       charm: mysql
+       branch: lp:charms/precise/mysql
+       options:
+         tuning-level: fast
+     haproxy:
+       branch: lp:charms/precise/haproxy
+       options:
+         request-limit: 32
+     memcached:
+       branch: lp:charms/precise/memcached
+       options:
+         request-limit: 32
+  relations:
+    - ["wiki:db", mysql]
+    - [wiki, [haproxy, memcached]]

=== added file 'deployer.py'
--- deployer.py	1970-01-01 00:00:00 +0000
+++ deployer.py	2013-07-15 21:24:33 +0000
@@ -0,0 +1,1756 @@
+#!/usr/bin/env python
+"""
+Juju Deployer
+
+Deployment automation for juju.
+
+"""
+import argparse
+from base64 import b64encode
+from bzrlib.workingtree import WorkingTree
+from copy import deepcopy
+from contextlib import contextmanager
+
+import errno
+import json
+import logging
+from logging.config import dictConfig as logConfig
+import os
+
+from os.path import abspath, dirname, isabs
+from os.path import join as path_join
+from os.path import exists as path_exists
+
+import pprint
+import shutil
+import stat
+import socket
+import subprocess
+import sys
+import tempfile
+import time
+import urllib
+import urlparse
+import zipfile
+
+try:
+    from yaml import CSafeLoader, CSafeDumper
+    SafeLoader, SafeDumper = CSafeLoader, CSafeDumper
+except ImportError:
+    from yaml import SafeLoader, SafeDumper
+
+import yaml
+
+
+from jujuclient import (
+    Environment as EnvironmentClient, UnitErrors, EnvError)
+
+
+class ErrorExit(Exception):
+
+    def __init__(self, error=None):
+        self.error = error
+
+# Utility functions
+
+
+def yaml_dump(value):
+    return yaml.dump(value, default_flow_style=False)
+
+
+def yaml_load(value):
+    return yaml.load(value, Loader=SafeLoader)
+
+
+DEFAULT_LOGGING = """
+version: 1
+formatters:
+    standard:
+        format: '%(asctime)s %(message)s'
+        datefmt: "%Y-%m-%d %H:%M:%S"
+    detailed:
+        format: '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
+        datefmt: "%Y-%m-%d %H:%M:%S"
+handlers:
+    console:
+        class: logging.StreamHandler
+        formatter: standard
+        level: DEBUG
+        stream: ext://sys.stderr
+loggers:
+    deployer:
+        level: INFO
+        propogate: true
+    deploy.cli:
+        level: DEBUG
+        propogate: true
+    deploy.charm:
+        level: DEBUG
+        propogate: true
+    deploy.env:
+        level: DEBUG
+        propogate: true
+    deploy.deploy:
+        level: DEBUG
+        propogate: true
+    deploy.importer:
+        level: DEBUG
+        propogate: true
+    "":
+        level: INFO
+        handlers:
+            - console
+"""
+
+STORE_CACHE_DIR = "deployer-cache"
+
+STORE_URL = "https://store.juju.ubuntu.com"
+
+
+def setup_logging(verbose=False, debug=False, stream=None):
+    config = yaml_load(DEFAULT_LOGGING)
+    log_options = {}
+    if verbose:
+        log_options.update({"loggers": {
+            "deployer": {"level": "DEBUG", "propogate": True}}})
+        #log_options.update({"loggers": {""
+    if debug:
+        log_options.update(
+            {"handlers": {"console": {"formatter": "detailed"}}})
+    config = dict_merge(config, log_options)
+    logConfig(config)
+
+    # Allow tests to reuse this func to mass configure log streams.
+    if stream:
+        root = logging.getLogger()
+        previous = root.handlers[0]
+        root.handlers[0] = current = logging.StreamHandler(stream)
+        current.setFormatter(previous.formatter)
+        return stream
+
+
+@contextmanager
+def temp_file():
+    t = tempfile.NamedTemporaryFile()
+    try:
+        yield t
+    finally:
+        t.close()
+
+
+def extract_zip(zip_path, dir_path):
+    zf = zipfile.ZipFile(zip_path, "r")
+    for info in zf.infolist():
+        mode = info.external_attr >> 16
+        if stat.S_ISLNK(mode):
+            source = zf.read(info.filename)
+            target = os.path.join(dir_path, info.filename)
+            if os.path.exists(target):
+                os.remove(target)
+            os.symlink(source, target)
+            continue
+        extract_path = zf.extract(info, dir_path)
+        os.chmod(extract_path, mode)
+
+
+def select_runtime(env_name):
+    # pyjuju does juju --version
+    result = _check_call(["juju", "version"], None, ignoreerr=True)
+    if result is None:
+        return PyEnvironment(env_name)
+    return GoEnvironment(env_name)
+
+
+def _parse_constraints(value):
+    constraints = {}
+    pairs = value.strip().split()
+    for p in pairs:
+        k, v = p.split('=')
+        try:
+            v = int(v)
+        except ValueError:
+            try:
+                v = float(v)
+            except:
+                pass
+        constraints[k] = v
+    return constraints
+
+
+def _get_juju_home():
+    jhome = os.environ.get("JUJU_HOME")
+    if jhome is None:
+        jhome = path_join(os.environ.get('HOME'), '.juju')
+    return jhome
+
+
+def _check_call(params, log, *args, **kw):
+    try:
+        cwd = abspath(".")
+        if 'cwd' in kw:
+            cwd = kw['cwd']
+        stderr = subprocess.STDOUT
+        if 'stderr' in kw:
+            stderr = kw['stderr']
+        output = subprocess.check_output(
+            params, cwd=cwd, stderr=stderr, env=os.environ)
+    except subprocess.CalledProcessError, e:
+        if 'ignoreerr' in kw:
+            return
+        #print "subprocess error"
+        #print " ".join(params), "\ncwd: %s\n" % cwd, "\n ".join(
+        # ["%s=%s" % (k, os.environ[k]) for k in os.environ
+        #     if k.startswith("JUJU")])
+        #print e.output
+        log.error(*args)
+        log.error("Command (%s) Output:\n\n %s", " ".join(params), e.output)
+        raise ErrorExit(e)
+    return output
+
+
+# Utils from deployer 1
+def relations_combine(onto, source):
+    target = deepcopy(onto)
+    # Support list of relations targets
+    if isinstance(onto, list) and isinstance(source, list):
+        target.extend(source)
+        return target
+    for (key, value) in source.items():
+        if key in target:
+            if isinstance(target[key], dict) and isinstance(value, dict):
+                target[key] = relations_combine(target[key], value)
+            elif isinstance(target[key], list) and isinstance(value, list):
+                target[key] = list(set(target[key] + value))
+        else:
+            target[key] = value
+    return target
+
+
+def dict_merge(onto, source):
+    target = deepcopy(onto)
+    for (key, value) in source.items():
+        if key == 'relations' and key in target:
+            target[key] = relations_combine(target[key], value)
+        elif (key in target and isinstance(target[key], dict) and
+                isinstance(value, dict)):
+            target[key] = dict_merge(target[key], value)
+        else:
+            target[key] = value
+    return target
+
+
+def resolve_include(fname, include_dirs):
+    if isabs(fname):
+        return fname
+    for path in include_dirs:
+        full_path = path_join(path, fname)
+        if path_exists(full_path):
+            return full_path
+
+    return None
+
+
+def setup_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '-c', '--config',
+        help=('File containing deployment(s) json config. This '
+              'option can be repeated, with later files overriding '
+              'values in earlier ones.'),
+        dest='configs', action='append')
+    parser.add_argument(
+        '-d', '--debug', help='Enable debugging to stdout',
+        dest="debug",
+        action="store_true", default=False)
+    parser.add_argument(
+        '-L', '--local-mods',
+        help='Disallow deployment of locally-modified charms',
+        dest="no_local_mods", default=True, action='store_false')
+    parser.add_argument(
+        '-u', '--update-charms',
+        help='Update existing charm branches',
+        dest="update_charms", default=False, action="store_true")
+    parser.add_argument(
+        '-l', '--ls', help='List available deployments',
+        dest="list_deploys", action="store_true", default=False)
+    parser.add_argument(
+        '-D', '--destroy-services',
+        help='Destroy all services (do not terminate machines)',
+        dest="destroy_services", action="store_true",
+        default=False)
+    parser.add_argument(
+        '-T', '--terminate-machines',
+        help=('Terminate all machines but the bootstrap node.  '
+              'Destroy any services that exist on each'),
+        dest="terminate_machines", action="store_true",
+        default=False)
+    parser.add_argument(
+        '-t', '--timeout',
+        help='Timeout (sec) for entire deployment (45min default)',
+        dest='timeout', action='store', type=int, default=2700)
+    parser.add_argument(
+        "-f", '--find-service', action="store", type=str,
+        help='Find hostname from first unit of a specific service.',
+        dest="find_service")
+    parser.add_argument(
+        "-b", '--branch-only', action="store_true",
+        help='Update vcs branches and exit.',
+        dest="branch_only")
+    parser.add_argument(
+        '-s', '--deploy-delay', action='store', type=float,
+        help=("Time in seconds to sleep between 'deploy' commands, "
+              "to allow machine provider to process requests. This "
+              "delay is also enforced between calls to "
+              "terminate_machine"),
+        dest="deploy_delay", default=0)
+    parser.add_argument(
+        '-e', '--environment', action='store', dest='juju_env',
+        help='Deploy to a specific Juju environment.',
+        default=os.getenv('JUJU_ENV'))
+    parser.add_argument(
+        '-o', '--override', action='append', type=str,
+        help=('Override *all* config options of the same name '
+              'across all services.  Input as key=value.'),
+        dest='overrides', default=None)
+    parser.add_argument(
+        '-v', '--verbose', action='store_true', default=False,
+        dest="verbose", help='Verbose output')
+    parser.add_argument(
+        '-W', '--watch', help='Watch environment changes on console',
+        dest="watch", action="store_true", default=False)
+    parser.add_argument(
+        '-r', "--retry", default=0, type=int, dest="retry_count",
+        help=("Resolve unit errors via retry."
+              " Either standalone or in a deployment"))
+    parser.add_argument(
+        "--diff", action="store_true", default=False,
+        help=("Resolve unit errors via retry."
+              " Either standalone or in a deployment"))
+    parser.add_argument(
+        '-w', '--relation-wait', action='store', dest='rel_wait',
+        default=60, type=int,
+        help=('Number of seconds to wait before checking for '
+              'relation errors after all relations have been added '
+              'and subordinates started. (default: 60)'))
+    parser.add_argument("deployment", nargs="?")
+    return parser
+
+
+class ConfigStack(object):
+
+    log = logging.getLogger("deployer.config")
+
+    def __init__(self, config_files):
+        self.config_files = config_files
+        self.data = {}
+        self.include_dirs = []
+        self.load()
+
+    def keys(self):
+        return sorted(self.data)
+
+    def get(self, key):
+        if not key in self.data:
+            self.log.warning("Deployment %r not found. Available %s",
+                             key, ", ".join(self.keys()))
+            raise ErrorExit()
+        deploy_data = self.data[key]
+        deploy_data = self._resolve_inherited(deploy_data)
+        return Deployment(key, deploy_data, self.include_dirs)
+
+    def load(self, urlopen=urllib.urlopen):
+        data = {}
+        include_dirs = []
+        for fp in self.config_files:
+            if not path_exists(fp):
+                # If the config file path is a URL, fetch it and use it.
+                if urlparse.urlparse(fp).scheme:
+                    response = urlopen(fp)
+                    if response.getcode() == 200:
+                        temp = tempfile.NamedTemporaryFile(delete=True)
+                        shutil.copyfileobj(response, temp)
+                        temp.flush()
+                        fp = temp.name
+                    else:
+                        self.log.warning("Could not retrieve %s", fp)
+                        raise ErrorExit()
+                else:
+                    self.log.warning("Config file not found %s", fp)
+                    raise ErrorExit()
+            else:
+                include_dirs.append(dirname(abspath(fp)))
+            with open(fp) as fh:
+                try:
+                    d = yaml_load(fh.read())
+                    data = dict_merge(data, d)
+                except Exception, e:
+                    self.log.warning(
+                        "Couldn't load config file @ %r, error: %s:%s",
+                        fp, type(e), e)
+                    raise
+        self.data = data
+        self.include_dirs = include_dirs
+
+    def _inherits(self, d):
+        parents = d.get('inherits', ())
+        if isinstance(parents, basestring):
+            parents = [parents]
+        return parents
+
+    def _resolve_inherited(self, deploy_data):
+        if not 'inherits' in deploy_data:
+            return deploy_data
+        inherits = parents = self._inherits(deploy_data)
+        for parent_name in parents:
+            parent = self.get(parent_name)
+            inherits.extend(self._inherits(parent.data))
+            deploy_data = dict_merge(deploy_data, parent.data)
+        deploy_data['inherits'] = inherits
+        return deploy_data
+
+
+class Endpoint(object):
+
+    def __init__(self, ep):
+        self.ep = ep
+        self.name = None
+        if ":" in self.ep:
+            self.service, self.name = self.ep.split(":")
+        else:
+            self.service = ep
+
+
+class EndpointPair(object):
+    # Really simple endpoint service matching that does not work for multiple
+    # relations between two services (used by diff at the moment)
+
+    def __init__(self, ep_x, ep_y=None):
+        self.ep_x = Endpoint(ep_x)
+        self.ep_y = ep_y and Endpoint(ep_y)
+
+    def __eq__(self, ep_pair):
+        if not isinstance(ep_pair, EndpointPair):
+            return False
+        return (ep_pair.ep_x.service in self
+                and
+                ep_pair.ep_y.service in self)
+
+    def __contains__(self, svc_name):
+        return (svc_name == self.ep_x.service
+                or
+                svc_name == self.ep_y.service)
+
+    def __hash__(self):
+        return hash(tuple(sorted(
+            (self.ep_x.service, self.ep_y.service))))
+
+    def __repr__(self):
+        return "%s <-> %s" % (
+            self.ep_x.ep,
+            self.ep_y.ep)
+
+    @staticmethod
+    def to_yaml(dumper, data):
+        return dumper.represent_list([[data.ep_x.ep, data.ep_y.ep]])
+
+
+yaml.add_representer(EndpointPair, EndpointPair.to_yaml)
+
+
+class Service(object):
+
+    def __init__(self, name, svc_data):
+        self.svc_data = svc_data
+        self.name = name
+
+    @property
+    def config(self):
+        return self.svc_data.get('options', None)
+
+    @property
+    def constraints(self):
+        return self.svc_data.get('constraints', None)
+
+    @property
+    def num_units(self):
+        return int(self.svc_data.get('num_units', 1))
+
+    @property
+    def force_machine(self):
+        return self.svc_data.get('force-machine')
+
+    @property
+    def expose(self):
+        return self.svc_data.get('expose', False)
+
+
+class Vcs(object):
+
+    err_update = (
+        "Could not update branch %(path)s from %(branch_url)s\n\n %(output)s")
+    err_branch = "Could not branch %(branch_url)s to %(path)s\n\n %(output)s"
+    err_is_mod = "Couldn't determine if %(path)s was modified\n\n %(output)s"
+    err_pull = (
+        "Could not pull branch @ %(branch_url)s to %(path)s\n\n %(output)s")
+    err_cur_rev = (
+        "Could not determine current revision %(path)s\n\n %(output)s")
+
+    def __init__(self, path, origin, log):
+        self.path = path
+        self.log = log
+        self.origin = origin
+
+    def _call(self, args, error_msg, cwd=None, stderr=()):
+        try:
+            stderr = stderr is None and stderr or subprocess.STDOUT
+            output = subprocess.check_output(
+                args, cwd=cwd or self.path, stderr=subprocess.STDOUT)
+        except subprocess.CalledProcessError, e:
+            #print "vcs err", " ".join(args), "[dir: %s]" % cwd
+            self.log.error(error_msg % self.get_err_msg_ctx(e))
+            raise ErrorExit()
+        return output.strip()
+
+    def get_err_msg_ctx(self, e):
+        return {
+            'path': self.path,
+            'branch_url': self.origin,
+            'exit_code': e.returncode,
+            'output': e.output,
+            'vcs': self.__class__.__name__.lower()}
+
+    def get_cur_rev(self):
+        raise NotImplementedError()
+
+    def update(self, rev=None):
+        raise NotImplementedError()
+
+    def branch(self):
+        raise NotImplementedError()
+
+    def pull(self):
+        raise NotImplementedError()
+
+    def is_modified(self):
+        raise NotImplementedError()
+
+    # upstream missing revisions?
+
+
+class Bzr(Vcs):
+
+    def get_cur_rev(self):
+        params = ["bzr", "revno", "--tree"]
+        return self._call(params, self.err_cur_rev)
+
+    def update(self, rev=None):
+        params = ["bzr", "up"]
+        if rev:
+            params.extend(["-r", str(rev)])
+        self._call(params, self.err_update)
+
+    def pull(self):
+        params = ["bzr", "pull", "--remember", self.origin]
+        self._call(params, self.err_pull)
+
+    def branch(self):
+        params = ["bzr", "branch", self.origin, self.path]
+        cwd = os.path.dirname(os.path.dirname(self.path))
+        if not cwd:
+            cwd = "."
+        self._call(params, self.err_branch, cwd)
+
+    def is_modified(self):
+        # To replace with bzr cli, we need to be able to detect
+        # changes to a wc @ a rev or @ trunk.
+        tree = WorkingTree.open(self.path)
+        return tree.has_changes()
+
+
+class Git(Vcs):
+
+    def get_cur_rev(self):
+        params = ["git", "rev-parse", "HEAD"]
+        return self._call(params, self.err_cur_rev)
+
+    def update(self,  rev=None):
+        params = ["git", "reset", "--merge"]
+        if rev:
+            params.append(rev)
+        self._call(params, self.err_update)
+
+    def pull(self):
+        params = ["git", "pull", "master"]
+        self._call(params, self.err_pull)
+
+    def branch(self):
+        params = ["git", "clone", self.branch]
+        self._call(params, self.err_branch, os.path.dirname(self.path))
+
+    def is_modified(self):
+        params = ["git", "stat", "-s"]
+        return bool(self._call(params, self.err_is_mod).strip())
+
+    def get_origin(self):
+        params = ["git", "config", "--get", "remote.origin.url"]
+        return self._call(params, "")
+
+
+class Charm(object):
+
+    log = logging.getLogger('deployer.charm')
+
+    def __init__(self, name, path, branch, rev, build, charm_url=""):
+        self.name = name
+        self._path = path
+        self.branch = branch
+        self.rev = rev
+        self._charm_url = charm_url
+        self._build = build
+        self.vcs = self.get_vcs()
+
+    def get_vcs(self):
+        if not self.branch:
+            return None
+        if self.branch.startswith('git') or 'github.com' in self.branch:
+            return Git(self.path, self.branch, self.log)
+        elif self.branch.startswith("bzr") or self.branch.startswith('lp:'):
+            return Bzr(self.path, self.branch, self.log)
+
+    @classmethod
+    def from_service(cls, name, series_path, d):
+        branch, rev = None, None
+        charm_branch = d.get('branch')
+        if charm_branch is not None:
+            branch, sep, rev = charm_branch.partition('@')
+
+        charm_path, store_url, build = None, None, None
+        name = d.get('charm', name)
+        if name.startswith('cs'):
+            store_url = name
+        else:
+            charm_path = path_join(series_path, name)
+            build = d.get('build', '')
+        if not store_url:
+            store_url = d.get('charm_url', None)
+
+        if store_url and branch:
+            cls.log.error(
+                "Service: %s has both charm url: %s and branch: %s specified",
+                name, store_url, branch)
+        return cls(name, charm_path, branch, rev, build, store_url)
+
+    def is_local(self):
+        return not self._charm_url
+
+    def exists(self):
+        return self.is_local() and path_exists(self.path)
+
+    def is_subordinate(self):
+        return self.metadata.get('subordinate', False)
+
+    @property
+    def charm_url(self):
+        if self._charm_url:
+            return self._charm_url
+        series = os.path.basename(os.path.dirname(self.path))
+        return "local:%s/%s" % (series, self.name)
+
+    def build(self):
+        if not self._build:
+            return
+        self.log.debug("Building charm %s with %s", self.path, self._build)
+        _check_call([self._build], self.log,
+                    "Charm build failed %s @ %s", self._build, self.path,
+                    cwd=self.path)
+
+    def fetch(self):
+        if self._charm_url:
+            return self._fetch_store_charm()
+        elif not self.branch:
+            self.log.warning("Invalid charm specification %s", self.name)
+            return
+        self.log.debug(" Branching charm %s @ %s", self.branch, self.path)
+        self.vcs.branch()
+        self.build()
+
+    @property
+    def path(self):
+        if not self.is_local() and not self._path:
+            self._path = self._get_charm_store_cache()
+        return self._path
+
+    def _fetch_store_charm(self, update=False):
+        cache_dir = self._get_charm_store_cache()
+        self.log.debug("Cache dir %s", cache_dir)
+        qualified_url = None
+
+        if os.path.exists(cache_dir) and not update:
+            return
+
+        # If we have a qualified url, check cache and move on.
+        parts = self.charm_url.rsplit('-', 1)
+        if len(parts) > 1 and parts[-1].isdigit():
+            qualified_url = self.charm_url
+
+        if not qualified_url:
+            info_url = "%s/charm-info?charms=%s" % (STORE_URL, self.charm_url)
+            fh = urllib.urlopen(info_url)
+            content = json.loads(fh.read())
+            rev = content[self.charm_url]['revision']
+            qualified_url = "%s-%d" % (self.charm_url, rev)
+
+        self.log.debug("Retrieving store charm %s" % qualified_url)
+
+        if update and os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+
+        with temp_file() as fh:
+            ufh = urllib.urlopen("%s/charm/%s" % (
+                STORE_URL, qualified_url[3:]))
+            shutil.copyfileobj(ufh, fh)
+            fh.flush()
+            extract_zip(fh.name, self.path)
+
+        self.config
+
+    def _get_charm_store_cache(self):
+        assert not self.is_local(), "Attempt to get store charm for local"
+        # Cache
+        jhome = _get_juju_home()
+        cache_dir = os.path.join(jhome, ".deployer-store-cache")
+        if not os.path.exists(cache_dir):
+            os.mkdir(cache_dir)
+        return os.path.join(
+            cache_dir,
+            self.charm_url.replace(':', '_').replace("/", "_"))
+
+    def update(self, build=False):
+        if not self.branch:
+            return
+        assert self.exists()
+        self.log.debug(" Updating charm %s from %s", self.path, self.branch)
+        self.vcs.update(self.rev)
+        if build:
+            self.build()
+
+    def is_modified(self):
+        if not self.branch:
+            return False
+        return self.vcs.is_modified()
+
+    @property
+    def config(self):
+        config_path = path_join(self.path, "config.yaml")
+        if not path_exists(config_path):
+            return {}
+
+        with open(config_path) as fh:
+            return yaml_load(fh.read()).get('options', {})
+
+    @property
+    def metadata(self):
+        md_path = path_join(self.path, "metadata.yaml")
+        if not path_exists(md_path):
+            if not path_exists(self.path):
+                raise RuntimeError("No charm metadata @ %s", md_path)
+        with open(md_path) as fh:
+            return yaml_load(fh.read())
+
+    def get_provides(self):
+        p = {'juju-info': [{'name': 'juju-info'}]}
+        for key, value in self.metadata['provides'].items():
+            value['name'] = key
+            p.setdefault(value['interface'], []).append(value)
+        return p
+
+    def get_requires(self):
+        r = {}
+        for key, value in self.metadata['requires'].items():
+            value['name'] = key
+            r.setdefault(value['interface'], []).append(value)
+        return r
+
+
+class Deployment(object):
+
+    log = logging.getLogger("deployer.deploy")
+
+    def __init__(self, name, data, include_dirs, repo_path=""):
+        self.name = name
+        self.data = data
+        self.include_dirs = include_dirs
+        self.repo_path = repo_path
+
+    @property
+    def series(self):
+        # Series could use a little help, charm series should be inferred
+        # directly from a store url
+        return self.data.get('series', 'precise')
+
+    @property
+    def series_path(self):
+        return path_join(self.repo_path, self.series)
+
+    def pretty_print(self):
+        pprint.pprint(self.data)
+
+    def get_service(self, name):
+        if not name in self.data['services']:
+            return
+        return Service(name, self.data['services'][name])
+
+    def get_services(self):
+        for name, svc_data in self.data.get('services', {}).items():
+            yield Service(name, svc_data)
+
+    def get_relations(self):
+        if 'relations' not in self.data:
+            return
+
+        # Strip duplicate rels
+        seen = set()
+
+        def check(a, b):
+            k = tuple(sorted([a, b]))
+            if k in seen:
+                #self.log.warning(" Skipping duplicate relation %r" % (k,))
+                return
+            seen.add(k)
+            return True
+
+        # Support an ordered list of [endpoints]
+        if isinstance(self.data['relations'], list):
+            for end_a, end_b in self.data['relations']:
+                # Allow shorthand of [end_a, [end_b, end_c]]
+                if isinstance(end_b, list):
+                    for eb in end_b:
+                        if check(end_a, eb):
+                            yield (end_a, eb)
+                else:
+                    if check(end_a, end_b):
+                        yield (end_a, end_b)
+            return
+
+        # Legacy format (dictionary of dictionaries with weights)
+        rels = {}
+        for k, v in self.data['relations'].items():
+            expanded = []
+            for c in v['consumes']:
+                expanded.append((k, c))
+            rels[v.get('weight', 0)] = expanded
+        for k in sorted(rels):
+            for r in rels[k]:
+                if check(*r):
+                    yield r
+        #self.log.debug(
+        #    "Found relations %s\n  %s" % (" ".join(map(str, seen))))
+
+    def get_charms(self):
+        for k, v in self.data.get('services', {}).items():
+            yield Charm.from_service(k, self.series_path, v)
+
+    def get_charm_for(self, svc_name):
+        svc_data = self.data['services'][svc_name]
+        return Charm.from_service(svc_name, self.series_path, svc_data)
+
+    def fetch_charms(self, update=False, no_local_mods=False):
+        if not os.path.exists(self.series_path):
+            os.mkdir(self.series_path)
+        for charm in self.get_charms():
+            if charm.is_local():
+                if charm.exists():
+                    if no_local_mods:
+                        if charm.is_modified():
+                            self.log.warning(
+                                "Charm %r has local modifications",
+                                charm.path)
+                            raise ErrorExit()
+                    if update:
+                        charm.update(build=True)
+                    return
+            charm.fetch()
+
+    def resolve(self, cli_overides=()):
+        # Once we have charms definitions available, we can do verification
+        # of config options.
+        self.load_overrides(cli_overides)
+        self.resolve_config()
+        self.validate_relations()
+
+    def load_overrides(self, cli_overrides=()):
+        """Load overrides."""
+        overrides = {}
+        overrides.update(self.data.get('overrides', {}))
+
+        for o in cli_overrides:
+            key, value = o.split('=', 1)
+            overrides[key] = value
+
+        for k, v in overrides.iteritems():
+            found = False
+            for svc_name, svc_data in self.data['services'].items():
+                charm = self.get_charm_for(svc_name)
+                if k in charm.config:
+                    svc_data['options'][k] = v
+                    found = True
+            if not found:
+                self.log.warning(
+                    "Override %s does not match any charms", k)
+
+    def resolve_config(self):
+        """Load any lazy config values (includes), and verify config options.
+        """
+        self.log.debug("Resolving configuration")
+        # XXX TODO, rename resolve, validate relations
+        # against defined services
+        for svc_name, svc_data in self.data.get('services', {}).items():
+            if not 'options' in svc_data:
+                continue
+            charm = self.get_charm_for(svc_name)
+            config = charm.config
+            options = {}
+
+            for k, v in svc_data['options'].items():
+                if not k in config:
+                    self.log.error(
+                        "Invalid config charm %s %s=%s", charm.name, k, v)
+                    raise ErrorExit()
+                iv = self._resolve_include(svc_name, k, v)
+                if iv is not None:
+                    v = iv
+                options[k] = v
+            svc_data['options'] = options
+
+    def _resolve_include(self, svc_name, k, v):
+        for include_type in ["file", "base64"]:
+            if (not isinstance(v, basestring)
+                or not v.startswith(
+                    "include-%s://" % include_type)):
+                continue
+            include, fname = v.split("://", 1)
+            ip = resolve_include(fname, self.include_dirs)
+            if ip is None:
+                self.log.warning(
+                    "Invalid config %s.%s include not found %s",
+                    svc_name, k, v)
+                continue
+            with open(ip) as fh:
+                v = fh.read()
+                if include_type == "base64":
+                    v = b64encode(v)
+                return v
+
+    def validate_relations(self):
+        # Could extend to do interface matching against charms.
+        services = dict([(s.name, s) for s in self.get_services()])
+        for e_a, e_b in self.get_relations():
+            for ep in [Endpoint(e_a), Endpoint(e_b)]:
+                if not ep.service in services:
+                    self.log.error(
+                        ("Invalid relation in config,"
+                         " service %s not found, rel %s"),
+                        ep.service, "%s <-> %s" % (e_a, e_b))
+                    raise ErrorExit()
+
+    def save(self, path):
+        with open(path, "w") as fh:
+            fh.write(yaml_dump(self.data, defaul_flow_style=False))
+
+
+class BaseEnvironment(object):
+
+    log = logging.getLogger("deployer.env")
+
+    @property
+    def env_config_path(self):
+        jhome = _get_juju_home()
+        env_config_path = path_join(jhome, 'environments.yaml')
+        return env_config_path
+
+    def _named_env(self, params):
+        if self.name:
+            params.extend(["-e", self.name])
+        return params
+
+    def _get_env_config(self):
+        with open(self.env_config_path) as fh:
+            config = yaml_load(fh.read())
+            if self.name:
+                if self.name not in config['environments']:
+                    self.log.error("Environment %r not found", self.name)
+                    raise ErrorExit()
+                return config['environments'][self.name]
+            else:
+                env_name = config.get('default')
+                if env_name is None:
+                    if len(config['environments'].keys()) == 1:
+                        env_name = config['environments'].keys().pop()
+                    else:
+                        self.log.error("Ambigious operation environment")
+                        raise ErrorExit()
+                return config['environments'][env_name]
+
+    def _write_config(self, svc_name, config, fh):
+        fh.write(yaml_dump({svc_name: config}))
+        fh.flush()
+
+#    def _write_config(self, svc_name, config, fh):
+#        fh.write(yaml_dump(config))
+#        fh.flush()
+
+    def _get_units_in_error(self):
+        units = []
+        status = self.status()
+        for s in status.get('services', {}).keys():
+            for uid, u in status['services'][s].get('units', {}).items():
+                if u['agent-state'] == 'error':
+                    units.append(uid)
+                for uid, u in u.get('subordinates', {}).items():
+                    if u['agent-state'] == 'error':
+                        units.append(uid)
+        return units
+
+    def deploy(self, name, charm_url,
+               repo=None, config=None,
+               constraints=None, num_units=1, force_machine=None):
+        params = self._named_env(["juju", "deploy"])
+        with temp_file() as fh:
+            if config:
+                fh.write(yaml_dump({name: config}))
+                fh.flush()
+                params.extend(["--config", fh.name])
+            if constraints:
+                params.extend(['--constraints', constraints])
+            if num_units != 1:
+                params.extend(["--num-units", str(num_units)])
+            if charm_url.startswith('local'):
+                if repo == "":
+                    repo = "."
+                params.extend(["--repository=%s" % repo])
+            if force_machine is not None:
+                params.extend["--force-machine=%d" % force_machine]
+
+            params.extend([charm_url, name])
+            _check_call(params, self.log, "Error deploying service %r", name)
+
+    def terminate_machine(self, mid, wait=False):
+        """Terminate a machine.
+
+        The machine can't have any running units, after removing the units or
+        destroying the service, use wait_for_units to know when its safe to
+        delete the machine (ie units have finished executing stop hooks and are
+        removed)
+        """
+        if int(mid) == 0:
+            raise RuntimeError("Can't terminate machine 0")
+        params = self._named_env(["juju", "terminate-machine"])
+        params.append(mid)
+        _check_call(params, self.log, "Error terminating machine %r" % mid)
+
+    def get_service_address(self, svc_name):
+        status = self.get_cli_status()
+        if svc_name not in status['services']:
+            self.log.warning("Service %s does not exist", svc_name)
+            return None
+        units = status['services'][svc_name].get('units', {})
+        unit_keys = list(sorted(units.keys()))
+        if unit_keys:
+            return units[unit_keys[0]].get('public-address', '')
+        self.log.warning("Service %s has no units")
+
+    def get_cli_status(self):
+        params = self._named_env(["juju", "status"])
+        with open('/dev/null', 'w') as fh:
+            output = _check_call(
+                params, self.log, "Error getting status, is it bootstrapped?",
+                stderr=fh)
+        status = yaml_load(output)
+        return status
+
+
+class PyEnvironment(BaseEnvironment):
+
+    def __init__(self, name):
+        self.name = name
+
+    def add_units(self, service_name, num_units):
+        params = self._named_env(["juju", "add-unit"])
+        if num_units > 1:
+            params.extend(["-n", str(num_units)])
+        params.append(service_name)
+        _check_call(
+            params, self.log, "Error adding units to %s", service_name)
+
+    def add_relation(self, endpoint_a, endpoint_b):
+        params = self._named_env(["juju", "add-relation"])
+        params.extend([endpoint_a, endpoint_b])
+        _check_call(
+            params, self.log, "Error adding relation to %s %s",
+            endpoint_a, endpoint_b)
+
+    def close(self):
+        """ NoOp """
+
+    def connect(self):
+        """ NoOp """
+
+    def _destroy_service(self, service_name):
+        params = self._named_env(["juju", "destroy-service"])
+        params.append(service_name)
+        _check_call(
+            params, self.log, "Error destroying service %s" % service_name)
+
+    def get_config(self, svc_name):
+        params = self._named_env(["juju", "get"])
+        params.append(svc_name)
+        return _check_call(
+            params, self.log, "Error retrieving config for %r", svc_name)
+
+    def get_constraints(self, svc_name):
+        params = self._named_env(["juju", "get-constraints"])
+        params.append(svc_name)
+        return _check_call(
+            params, self.log, "Error retrieving constraints for %r", svc_name)
+
+    def reset(self,
+              terminate_machines=False,
+              terminate_delay=0,
+              timeout=360,
+              watch=False):
+        status = self.status()
+        for s in status.get('services'):
+            self.log.debug(" Destroying service %s", s)
+            self._destroy_service(s)
+        if not terminate_machines:
+            return True
+        for m in status.get('machines'):
+            if int(m) == 0:
+                continue
+            self.log.debug(" Terminating machine %s", m)
+            self.terminate_machine(str(m))
+            if terminate_delay:
+                self.log.debug("  Waiting for terminate delay")
+                time.sleep(terminate_delay)
+
+    def resolve_errors(self, retry_count=0, timeout=600, watch=False, delay=5):
+        pass
+
+    def status(self):
+        return self.get_cli_status()
+
+    def wait_for_units(
+            self, timeout, goal_state="started", watch=False, no_exit=False):
+
+        max_time = time.time() + timeout
+        status = self.status()
+        while max_time > time.time():
+            for s in status.get('services', {}).values():
+                for u in s.get('units', {}).values():
+                    value = u.get('state')
+
+
+class GoEnvironment(BaseEnvironment):
+
+    def __init__(self, name, endpoint=None):
+        self.name = name
+        self.api_endpoint = endpoint
+        self.client = None
+
+    def _get_token(self):
+        config = self._get_env_config()
+        return config['admin-secret']
+
+    def add_units(self, service_name, num_units):
+        return self.client.add_units(service_name, num_units)
+
+    def add_relation(self, endpoint_a, endpoint_b):
+        return self.client.add_relation(endpoint_a, endpoint_b)
+
+    def close(self):
+        if self.client:
+            self.client.close()
+
+    def connect(self):
+        if not self.api_endpoint:
+            # Should really have a cheaper/faster way of getting the endpoint
+            # ala juju status 0 for a get_endpoint method.
+            self.get_cli_status()
+        while True:
+            try:
+                self.client = EnvironmentClient(self.api_endpoint)
+            except socket.error, e:
+                if e.errno != errno.ETIMEDOUT:
+                    raise
+                continue
+            else:
+                break
+        self.client.login(self._get_token())
+        self.log.debug("Connected to environment")
+
+    def get_config(self, svc_name):
+        return self.client.get_config(svc_name)
+
+    def get_constraints(self, svc_name):
+        return self.client.get_constraints(svc_name)
+
+    def get_cli_status(self):
+        status = super(GoEnvironment, self).get_cli_status()
+        # Opportunistic, see connect method comment.
+        if not self.api_endpoint:
+            self.api_endpoint = "wss://%s:17070/" % (
+                status["machines"]["0"]["dns-name"])
+        return status
+
+    def reset(self,
+              terminate_machines=False,
+              terminate_delay=0,
+              timeout=360, watch=False):
+        """Destroy/reset the environment."""
+        status = self.status()
+        destroyed = False
+        for s in status.get('services', {}).keys():
+            self.log.debug(" Destroying service %s", s)
+            self.client.destroy_service(s)
+            destroyed = True
+
+        if destroyed:
+            # Mark any errors as resolved so destruction can proceed.
+            self.resolve_errors()
+
+            # Wait for units
+            self.wait_for_units(timeout, "removed", watch=watch)
+
+        # The only value to not terminating is keeping the data on the
+        # machines around.
+        if not terminate_machines:
+            self.log.info(" *juju-core machines are not reusable for units")
+            return
+
+        # Terminate machines
+        self.log.debug(" Terminating machines")
+        for mid in status['machines'].keys():
+            if mid == "0":
+                continue
+            self.log.debug("  Terminating machine %s", mid)
+            self.terminate_machine(mid)
+            if terminate_delay:
+                self.log.debug("  Waiting for terminate delay")
+                time.sleep(terminate_delay)
+
+    def _check_timeout(self, etime):
+        w_timeout = etime - time.time()
+        if w_timeout < 0:
+            self.log.error("Timeout reached while resolving errors")
+            raise ErrorExit()
+        return w_timeout
+
+    def resolve_errors(self, retry_count=0, timeout=600, watch=False, delay=5):
+        """Resolve any unit errors in the environment.
+
+        If retry_count is given then the hook execution is reattempted. The
+        system will do up to retry_count passes through the system resolving
+        errors.
+
+        If retry count is not given, the error is marked resolved permanently.
+        """
+        etime = time.time() + timeout
+        count = 0
+        while True:
+            error_units = self._get_units_in_error()
+            for e_uid in error_units:
+                try:
+                    self.client.resolved(e_uid, retry=bool(retry_count))
+                    self.log.debug("  Resolving error on %s", e_uid)
+                except EnvError, e:
+                    if 'already resolved' in e:
+                        continue
+
+            if not error_units and count:
+                if not count:
+                    self.log.debug("  No unit errors found.")
+                else:
+                    self.log.debug("  No more unit errors found.")
+                return
+
+            w_timeout = self._check_timeout(etime)
+            if retry_count:
+                time.sleep(delay)
+
+            count += 1
+            try:
+                self.wait_for_units(
+                    timeout=int(w_timeout), watch=True, no_exit=True)
+            except UnitErrors, e:
+                if retry_count == count:
+                    self.log.info(
+                        " Retry count %d exhausted, but units in error (%s)",
+                        retry_count, " ".join(u['Name'] for u in e.errors))
+                    return
+            else:
+                return
+
+    def status(self):
+        return self.client.get_stat()
+
+    def wait_for_units(
+            self, timeout, goal_state="started", watch=False, no_exit=False):
+        """Wait for units to reach a given condition.
+        """
+        callback = watch and self._delta_event_log or None
+        try:
+            self.client.wait_for_units(timeout, goal_state, callback=callback)
+        except UnitErrors, e:
+            error_units = [
+                "unit: %s: machine: %s agent-state: %s details: %s" % (
+                    u['Name'], u['MachineId'], u['Status'], u['StatusInfo']
+                )
+                for u in e.errors]
+            if no_exit:
+                raise
+            self.log.error("The following units had errors:\n   %s" % (
+                "   \n".join(error_units)))
+            raise ErrorExit()
+
+    def _delta_event_log(self, et, ct, d):
+        # event type, change type, data
+        name = d.get('Name', d.get('Id', 'unknown'))
+        state = d.get('Status', d.get('Life', 'unknown'))
+        if et == "relation":
+            name = self._format_endpoints(d['Endpoints'])
+            state = "created"
+            if ct == "remove":
+                state = "removed"
+        self.log.debug(
+            " Delta %s: %s %s:%s", et, name, ct, state)
+
+    def _format_endpoints(self, eps):
+        if len(eps) == 1:
+            ep = eps.pop()
+            return "[%s:%s:%s]" % (
+                ep['ServiceName'],
+                ep['Relation']['Name'],
+                ep['Relation']['Role'])
+
+        return "[%s:%s <-> %s:%s]" % (
+            eps[0]['ServiceName'],
+            eps[0]['Relation']['Name'],
+            eps[1]['ServiceName'],
+            eps[1]['Relation']['Name'])
+
+
+class BaseAction(object):
+    pass
+
+
+class Export(BaseAction):
+
+    log = logging.getLogger("deployer.export")
+
+    def __init__(self, env, deployment, options):
+        self.options = options
+        self.env = env
+        self.deployment = deployment
+        self.env_status = None
+        self.env_state = {'services': {}, 'relations': {}}
+
+    def run(self):
+        pass
+
+
+class Diff(BaseAction):
+
+    log = logging.getLogger("deployer.diff")
+
+    def __init__(self, env, deployment, options):
+        self.options = options
+        self.env = env
+        self.deployment = deployment
+        self.env_status = None
+        self.env_state = {'services': {}, 'relations': []}
+
+    def load_env(self):
+        """
+        """
+        rels = set()
+        for svc_name in self.env_status['services']:
+            if not svc_name in self.env_status['services']:
+                self.env_state['services'][svc_name] = 'missing'
+            self.env_state['services'].setdefault(svc_name, {})[
+                'options'] = self.env.get_config(svc_name)
+            self.env_state['services'][svc_name][
+                'constraints'] = self.env.get_constraints(svc_name)
+            self.env_state['services'][svc_name][
+                'unit_count'] = len(self.env_status[
+                    'services'][svc_name]['units'])
+            rels.update(self._load_rels(svc_name))
+        self.env_state['relations'] = sorted(rels)
+
+    def _load_rels(self, svc_name):
+        rels = set()
+        svc_rels = self.env_status['services'][svc_name].get(
+            'relations', {})
+        # There is ambiguity here for multiple rels between two
+        # services without the relation id, which we need support
+        # from core for.
+        for r_name, r_svcs in svc_rels.items():
+            for r_svc in r_svcs:
+                # Skip peer relations
+                if r_svc == svc_name:
+                    continue
+                rr_name = self._get_rel_name(svc_name, r_svc)
+                rels.add(
+                    tuple(sorted([
+                        "%s:%s" % (svc_name, r_name),
+                        "%s:%s" % (r_svc, rr_name)])))
+        return rels
+
+    def _get_rel_name(self, src, tgt):
+        svc_rels = self.env_status['services'][tgt]['relations']
+        found = None
+        for r, eps in svc_rels.items():
+            if src in eps:
+                if found:
+                    raise ValueError("Ambigious relations for service")
+                found = r
+        return found
+
+    def get_delta(self):
+        delta = {}
+        rels_delta = self._get_relations_delta()
+        if rels_delta:
+            delta['relations'] = rels_delta
+        svc_delta = self._get_services_delta()
+        if svc_delta:
+            delta['services'] = svc_delta
+        return delta
+
+    def _get_relations_delta(self):
+        # Simple endpoint diff, no qualified endpoint checking.
+
+        # Env relations are always qualified (at least in go).
+        delta = {}
+        env_rels = set(
+            EndpointPair(*x) for x in self.env_state.get('relations', ()))
+        dep_rels = set(
+            [EndpointPair(*y) for y in self.deployment.get_relations()])
+
+        for r in dep_rels.difference(env_rels):
+            delta.setdefault('missing', []).append(r)
+
+        for r in env_rels.difference(dep_rels):
+            delta.setdefault('unknown', []).append(r)
+
+        return delta
+
+    def _get_services_delta(self):
+        delta = {}
+        env_svcs = set(self.env_status['services'].keys())
+        dep_svcs = set([s.name for s in self.deployment.get_services()])
+
+        missing = dep_svcs - env_svcs
+        if missing:
+            delta['missing'] = {}
+        for a in missing:
+            delta['missing'][a] = self.deployment.get_service(
+                a).svc_data
+        unknown = env_svcs - dep_svcs
+        if unknown:
+            delta['unknown'] = {}
+        for r in unknown:
+            delta['unknown'][r] = self.env_state.get(r)
+
+        for cs in env_svcs.intersection(dep_svcs):
+            d_s = self.deployment.get_service(cs).svc_data
+            e_s = self.env_state['services'][cs]
+            mod = self._diff_service(e_s, d_s)
+            if not mod:
+                continue
+            if not 'modified' in delta:
+                delta['modified'] = {}
+            delta['modified'][cs] = mod
+        return delta
+
+    def _diff_service(self, e_s, d_s):
+        mod = {}
+        if 'constraints' in d_s:
+            d_sc = _parse_constraints(d_s['constraints'])
+            if d_sc != e_s['constraints']:
+                mod['constraints'] = e_s['constraints']
+        for k, v in d_s.get('options', {}).items():
+            # Deploy options not known to the env may originate
+            # from charm version delta or be an invalid config.
+            if not k in e_s['options']:
+                continue
+            e_v = e_s['options'].get(k, {}).get('value')
+            if e_v != v:
+                mod['config'] = {k: e_v}
+        if e_s['unit_count'] != d_s.get('num_units', 1):
+            mod['num_units'] = e_s['num_units']
+        return mod
+
+    def run(self):
+        self.start_time = time.time()
+        self.env.connect()
+        self.env_status = self.env.status()
+        self.load_env()
+        delta = self.get_delta()
+        if delta:
+            print yaml_dump(delta)
+
+
+class Importer(BaseAction):
+
+    log = logging.getLogger("deployer.import")
+
+    def __init__(self, env, deployment, options):
+        self.options = options
+        self.env = env
+        self.deployment = deployment
+
+    def add_units(self):
+        self.log.debug("Adding units...")
+        # Add units to existing services that don't match count.
+        env_status = self.env.status()
+        added = set()
+        for svc in self.deployment.get_services():
+            delta = (svc.num_units -
+                     len(env_status['services'][svc.name].get('units', ())))
+            if delta > 0:
+                charm = self.deployment.get_charm_for(svc.name)
+                if charm.is_subordinate():
+                    self.log.warning(
+                        "Config specifies num units for subordinate: %s",
+                        svc.name)
+                    continue
+                self.log.info(
+                    "Adding %d more units to %s" % (abs(delta), svc.name))
+                for u in self.env.add_units(svc.name, abs(delta)):
+                    added.add(u)
+            else:
+                self.log.debug(
+                    " Service %r does not need any more units added.",
+                    svc.name)
+
+    def get_charms(self):
+        # Get Charms
+        self.log.debug("Getting charms...")
+        self.deployment.fetch_charms(
+            update=self.options.update_charms,
+            no_local_mods=self.options.no_local_mods)
+
+        # Load config overrides/includes and verify rels after we can
+        # validate them.
+        self.deployment.resolve(self.options.overrides or ())
+
+    def deploy_services(self):
+        self.log.info("Deploying services...")
+        env_status = self.env.status()
+        for svc in self.deployment.get_services():
+            if svc.name in env_status['services']:
+                self.log.debug(
+                    " Service %r already deployed. Skipping" % svc.name)
+                continue
+
+            charm = self.deployment.get_charm_for(svc.name)
+            self.log.info(
+                " Deploying service %s using %s", svc.name, charm.charm_url)
+            self.env.deploy(
+                svc.name,
+                charm.charm_url,
+                self.deployment.repo_path,
+                svc.config,
+                svc.constraints,
+                svc.num_units,
+                svc.force_machine)
+
+            if svc.expose:
+                self.env.expose(svc.name)
+
+            if self.options.deploy_delay:
+                self.log.debug(" Waiting for deploy delay")
+                time.sleep(self.options.deploy_delay)
+
+    def add_relations(self):
+        self.log.info("Adding relations...")
+
+        # Relations
+        status = self.env.status()
+        created = False
+
+        for end_a, end_b in self.deployment.get_relations():
+            if self._rel_exists(status, end_a, end_b):
+                continue
+            self.log.info(" Adding relation %s <-> %s", end_a, end_b)
+            self.env.add_relation(end_a, end_b)
+            created = True
+            # per the original, not sure the use case.
+            self.log.debug(" Waiting 5s before next relation")
+            time.sleep(5)
+        return created
+
+    def _rel_exists(self, status, end_a, end_b):
+        # Checks for a named relation on one side that matches the local
+        # endpoint and remote service.
+        (name_a, name_b, rem_a, rem_b) = (end_a, end_b, None, None)
+
+        if ":" in end_a:
+            name_a, rem_a = end_a.split(":", 1)
+        if ":" in end_b:
+            name_b, rem_b = end_b.split(":", 1)
+
+        rels_svc_a = status['services'][name_a].get('relations', {})
+
+        found = False
+        for r, related in rels_svc_a.items():
+            if name_b in related:
+                if rem_a and not r in rem_a:
+                    continue
+                found = True
+                break
+        if found:
+            return True
+        return False
+
+    def wait_for_units(self, ignore_error=False):
+        timeout = self.options.timeout - (time.time() - self.start_time)
+        if timeout < 0:
+            self.log.error("Reached deployment timeout.. exiting")
+            raise ErrorExit()
+        try:
+            self.env.wait_for_units(
+                int(timeout), watch=self.options.watch, no_exit=ignore_error)
+        except UnitErrors:
+            if not ignore_error:
+                raise
+
+    def run(self):
+        self.start_time = time.time()
+        self.env.connect()
+
+        # Get charms
+        self.get_charms()
+        if self.options.branch_only:
+            return
+
+        self.deploy_services()
+        self.wait_for_units()
+        self.add_units()
+
+        rels_created = self.add_relations()
+
+        # Wait for the units to be up before waiting for rel stability.
+        self.log.debug("Waiting for units to be started")
+        self.wait_for_units(self.options.retry_count)
+        if rels_created:
+            self.log.debug("Waiting for relations %d", self.options.rel_wait)
+            time.sleep(self.options.rel_wait)
+            self.wait_for_units(self.options.retry_count)
+
+        if self.options.retry_count:
+            self.log.info("Looking for errors to auto-retry")
+            self.env.resolve_errors(
+                self.retry_count,
+                self.options.timeout - time.time() - self.start_time)
+
+
+def main():
+    stime = time.time()
+    try:
+        run()
+    except ErrorExit:
+        logging.getLogger('deployer.cli').info(
+            "Deployment stopped. run time: %0.2f", time.time() - stime)
+        sys.exit(1)
+
+
+def run():
+    parser = setup_parser()
+    options = parser.parse_args()
+
+    # Debug implies watching and verbose
+    if options.debug:
+        options.watch = options.verbose = True
+    setup_logging(options.verbose, options.debug)
+
+    log = logging.getLogger("deployer.cli")
+    start_time = time.time()
+
+    env = select_runtime(options.juju_env)
+    log.debug('Using runtime %s', env.__class__.__name__)
+
+    config = ConfigStack(options.configs or [])
+
+    # Destroy services and exit
+    if options.destroy_services or options.terminate_machines:
+        log.info("Resetting environment...")
+        env.connect()
+        env.reset(terminate_machines=options.terminate_machines,
+                  terminate_delay=options.deploy_delay,
+                  watch=options.watch)
+        log.info("Environment reset in %0.2f", time.time() - start_time)
+        sys.exit(0)
+
+    # Display service info and exit
+    if options.find_service:
+        address = env.get_service_address(options.find_service)
+        if address is None:
+            log.error("Service not found %r", options.find_service)
+            sys.exit(1)
+        elif not address:
+            log.warning("Service: %s has no address for first unit",
+                        options.find_service)
+        else:
+            log.info("Service: %s address: %s", options.find_service, address)
+        sys.exit(0)
+
+    # Just resolve/retry hooks in the environment
+    if not options.deployment and options.retry_count:
+        log.info("Retrying hooks for error resolution")
+        env.connect()
+        env.resolve_errors(
+            options.retry_count, watch=options.watch, timeout=options.timeout)
+
+    # Arg check on config files and deployment name.
+    if not options.configs:
+        log.error("Config files must be specified")
+        sys.exit(1)
+
+    config.load()
+
+    # Just list the available deployments
+    if options.list_deploys:
+        print "\n".join(sorted(config.keys()))
+        sys.exit(0)
+
+    # Do something to a deployment
+    if not options.deployment:
+        log.error(
+            "Deployment name must be specified. available: %s", tuple(
+                sorted(config.keys())))
+        sys.exit(1)
+
+    deployment = config.get(options.deployment)
+
+    if options.diff:
+        Diff(env, deployment, options).run()
+        return
+
+    # Import it
+    log.info("Starting deployment of %s", options.deployment)
+    Importer(env, deployment, options).run()
+
+    # Deploy complete
+    log.info("Deployment complete in %0.2f seconds" % (
+        time.time() - start_time))
+
+if __name__ == '__main__':
+
+    try:
+        main()
+    except SystemExit:
+        pass
+    except:
+        import pdb, traceback, sys
+        traceback.print_exc()
+        pdb.post_mortem(sys.exc_info()[-1])

=== added directory 'doc'
=== added file 'doc/Makefile'
--- doc/Makefile	1970-01-01 00:00:00 +0000
+++ doc/Makefile	2013-07-15 21:24:33 +0000
@@ -0,0 +1,130 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         =
+BUILDDIR      = _build
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest
+
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  html       to make standalone HTML files"
+	@echo "  dirhtml    to make HTML files named index.html in directories"
+	@echo "  singlehtml to make a single large HTML file"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+
+clean:
+	-rm -rf $(BUILDDIR)/*
+
+html:
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
+
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+pickle:
+	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/JujuDeployer.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/JujuDeployer.qhc"
+
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/JujuDeployer"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/JujuDeployer"
+	@echo "# devhelp"
+
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+latexpdf:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	make -C $(BUILDDIR)/latex all-pdf
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."

=== added directory 'doc/_static'
=== added directory 'doc/_templates'
=== added file 'doc/announcement.txt'
--- doc/announcement.txt	1970-01-01 00:00:00 +0000
+++ doc/announcement.txt	2013-07-15 21:24:33 +0000
@@ -0,0 +1,53 @@
+
+Juju deployer for juju-core.
+
+Hi Folks
+
+Juju deployer is an automation tool for deploying complex applications
+with juju. It encompasses most of the properties of a juju environment
+(relations, config, constraints) along with charm vcs management into
+a simple definition format. It allows for inheritance between
+configurations which makes it straightforward to take customize/share
+a base environment configuration across multiple environments.
+
+Deployer was written by Adam Gandleman, and originated from some of
+Canonical's openstack charm development and deployment, and has seen fairly
+widespread adoption within canonical for application deployment.
+
+There's a new implementation of juju-deployer that supports juju-core
+and pyjuju. I took the opportunity to add some new features, tests,
+and docs. When used with juju-core it now uses the environment's
+websocket api instead of the cli where possible, and also for allow
+for reporting live changes as the deployment proceeds. Change listing
+at the bottom of the email.
+
+
+Installation
+------------
+
+ $ pip install juju-deployer
+
+Source
+------
+
+ bzr branch lp:juju-deployer/darwin
+
+Docs
+----
+
+ http://pythonhosted.org/juju-deployer/
+
+Changes
+-------
+
+ - Relations only added if they don't exist.
+ - Support for multiple services using the same charm.
+ - Support for automatic retrying of failed relations.
+ - Support for simpler relation definition syntax, either a list of
+   endpoint pairs - [blog, db] or list of endpoint, [targets] can be used. ie. [blog, [db, cache]] can be used.
+ - Uses watches for live feedback of change progress in an environment.
+ - Additional sanity/error checking prior to modifying an environment.
+ - yaml support config file support
+ - multiple inheritance
+ - No support atm for resetting the environment's charm cache.
+ - Unit tests.

=== added file 'doc/conf.py'
--- doc/conf.py	1970-01-01 00:00:00 +0000
+++ doc/conf.py	2013-07-15 21:24:33 +0000
@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+# Juju Deployer documentation build configuration file, created by
+# sphinx-quickstart on Sat May 11 14:34:00 2013.
+#
+# This file is execfile()d with the current directory set to its containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+import sys, os
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#sys.path.insert(0, os.path.abspath('.'))
+
+# -- General configuration -----------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be extensions
+# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
+extensions = []
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix of source filenames.
+source_suffix = '.rst'
+
+# The encoding of source files.
+#source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+project = u'Juju Deployer'
+copyright = u'2013, Kapil Thangavelu'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = '0.0.4'
+# The full version, including alpha/beta/rc tags.
+release = '0.0.4'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#today = ''
+# Else, today_fmt is used as the format for a strftime call.
+#today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+exclude_patterns = ['_build']
+
+# The reST default role (used for this markup: `text`) to use for all documents.
+#default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+#modindex_common_prefix = []
+
+
+# -- Options for HTML output ---------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = 'default'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#html_theme_options = {}
+
+# Add any paths that contain custom themes here, relative to this directory.
+#html_theme_path = []
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+#html_title = None
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#html_logo = None
+
+# The name of an image file (within the static path) to use as favicon of the
+# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
+# using the given strftime format.
+#html_last_updated_fmt = '%b %d, %Y'
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#html_use_smartypants = True
+
+# Custom sidebar templates, maps document names to template names.
+#html_sidebars = {}
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#html_additional_pages = {}
+
+# If false, no module index is generated.
+#html_domain_indices = True
+
+# If false, no index is generated.
+#html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#html_split_index = False
+
+# If true, links to the reST sources are added to the pages.
+#html_show_sourcelink = True
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#html_show_sphinx = True
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#html_show_copyright = True
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#html_file_suffix = None
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'JujuDeployerdoc'
+
+
+# -- Options for LaTeX output --------------------------------------------------
+
+# The paper size ('letter' or 'a4').
+#latex_paper_size = 'letter'
+
+# The font size ('10pt', '11pt' or '12pt').
+#latex_font_size = '10pt'
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title, author, documentclass [howto/manual]).
+latex_documents = [
+  ('index', 'JujuDeployer.tex', u'Juju Deployer Documentation',
+   u'Kapil Thangavelu', 'manual'),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#latex_logo = None
+
+# For "manual" documents, if this is true, then toplevel headings are parts,
+# not chapters.
+#latex_use_parts = False
+
+# If true, show page references after internal links.
+#latex_show_pagerefs = False
+
+# If true, show URL addresses after external links.
+#latex_show_urls = False
+
+# Additional stuff for the LaTeX preamble.
+#latex_preamble = ''
+
+# Documents to append as an appendix to all manuals.
+#latex_appendices = []
+
+# If false, no module index is generated.
+#latex_domain_indices = True
+
+
+# -- Options for manual page output --------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    ('index', 'jujudeployer', u'Juju Deployer Documentation',
+     [u'Kapil Thangavelu'], 1)
+]

=== added file 'doc/config.rst'
--- doc/config.rst	1970-01-01 00:00:00 +0000
+++ doc/config.rst	2013-07-15 21:24:33 +0000
@@ -0,0 +1,96 @@
+
+Configuration
+=============
+
+
+The deployer configuration file can be in either yaml or json
+formats. The contents of the top level are a dictionary/hash mapping
+of stack names to configuration.
+
+Environment/Stack
+==================
+
+The stack can take several options for specifying, series::
+
+    wordpress-stage:
+        series: precise
+
+Services
+========
+
+
+Snippet::
+
+  wordpress-stage:
+    series: precise
+    services:
+        blog:
+            charm: wordpress
+            branch: lp:charms/precise/wordpress
+            constraints: mem=2
+            options:
+                tuning: optimized
+                engine: apache
+                icon: include-base64://file.ico
+ 
+
+ The service's charm name will be infered from the vcs branch name if
+ possible, else it will assume the service name, is the name of the
+ charm, or can be specified manually via the charm key.
+
+ The service constraints are specified as a single string value
+ corresponding to what would be specified on the command line. Valid
+ generic constraints for juju-core are mem, cpu-cores, cpu-power.
+
+ Service configuration is specified a dictionary of key/value
+ mapping. There is support for including data from external
+ files with either the include-file://path-to-file or
+ include-base64://path-to-file. Relative paths are resolved
+ relative to the config file.
+
+
+Relations
+=========
+
+
+Relations can be specified in a few different formats.
+
+legacy::
+    relations:
+        - [blog, [db, memcached]]
+
+endpoint pairs::
+    relations:
+        - [blog, db]
+        - [blog, memcached]
+
+nested endpoint pairs::
+    relations:
+        - [blog, [db, memcached]]
+
+
+Inheritance
+===========
+
+An environment configuration::
+
+  wordpress-stage:
+    series: precise
+    services:
+        blog:
+            charm: wordpress
+            branch: lp:charms/precise/wordpress
+            constraints: mem=2
+            options:
+                tuning: optimized
+                engine: apache
+                icon: include-base64://file.ico
+
+
+  wordpress-prod:
+    inherits: [wordpress-stage, monitoring]
+    services:
+        blog:
+            constraints: mem=16
+            options:
+                tuning: optimized

=== added file 'doc/index.rst'
--- doc/index.rst	1970-01-01 00:00:00 +0000
+++ doc/index.rst	2013-07-15 21:24:33 +0000
@@ -0,0 +1,24 @@
+.. Juju Deployer documentation master file, created by
+   sphinx-quickstart on Sat May 11 14:34:00 2013.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to Juju Deployer's documentation!
+=========================================
+
+Contents:
+
+
+.. toctree::
+   :maxdepth: 2
+
+   config.rst
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+

=== added file 'doc/notes.txt'
--- doc/notes.txt	1970-01-01 00:00:00 +0000
+++ doc/notes.txt	2013-07-15 21:24:33 +0000
@@ -0,0 +1,39 @@
+
+Feaures
+
+ - dryrun
+ - export
+ - sync
+ - diff
+
+
+
+services:
+  blog:
+    charm: local:precise/wordpress-93
+    exposed: false
+    relations:
+      cache:
+      - memcached
+      db:
+      - db
+      loadbalancer:
+      - blog
+    units:
+      blog/0:
+        agent-state: started
+        agent-version: 1.11.0
+        machine: "4"
+        public-address: ec2-50-112-56-62.us-west-2.compute.amazonaws.com
+  memcached:
+    charm: local:precise/memcached-28
+    exposed: false
+    life: dying
+    relations:
+      cache:
+      - blog
+
+
+$ juju remove-relation blog memcached
+
+No Op on status

=== renamed file 'deployer.py' => 'old_deployer.py'
=== renamed file 'utils.py' => 'old_utils.py'
=== added file 'setup.cfg'
--- setup.cfg	1970-01-01 00:00:00 +0000
+++ setup.cfg	2013-07-15 21:24:33 +0000
@@ -0,0 +1,7 @@
+[build_sphinx]
+source-dir = doc/
+build-dir  = doc/_build
+all_files  = 1
+
+[upload_sphinx]
+upload-dir = doc/_build/html
\ No newline at end of file

=== added file 'setup.py'
--- setup.py	1970-01-01 00:00:00 +0000
+++ setup.py	2013-07-15 21:24:33 +0000
@@ -0,0 +1,26 @@
+from setuptools import setup
+
+long_description = """
+Python client for juju-core websocket api.
+"""
+
+setup(
+    name="juju-deployer",
+    version="0.1.0",
+    description="A tool for deploying complex stacks with juju.",
+    long_description=open("README").read(),
+    author="Kapil Thangavelu",
+    author_email="[e-mail]",
+    url="http://juju.ubuntu.com",
+    install_requires=["jujuclient >= 0.0.5"],
+    classifiers=[
+        "Development Status :: 2 - Pre-Alpha",
+        "Programming Language :: Python",
+        "Topic :: Internet",
+        "Topic :: Software Development :: Libraries :: Python Modules",
+        "Intended Audience :: Developers"],
+#    test_suite="test_deployment",
+    entry_points={
+        "console_scripts": [
+            'juju-deployer = deployer:main']},
+    py_modules=["deployer"])

=== added directory 'test_data'
=== added file 'test_data/blog.snippet'
--- test_data/blog.snippet	1970-01-01 00:00:00 +0000
+++ test_data/blog.snippet	2013-07-15 21:24:33 +0000
@@ -0,0 +1,1 @@
+HelloWorld
\ No newline at end of file

=== added file 'test_data/blog.yaml'
--- test_data/blog.yaml	1970-01-01 00:00:00 +0000
+++ test_data/blog.yaml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,63 @@
+
+metrics-base:
+    services:
+        newrelic:
+            branch: lp:charms/precise/newrelic
+            options: 
+                key: measureallthethings
+
+wordpress-base:
+    series: precise
+    services:
+        blog:
+            charm: wordpress
+            branch: lp:charms/precise/wordpress
+
+wordpress-stage:
+    series: precise
+    inherits:
+        - wordpress-base
+        - metrics-base
+    services:
+        blog:
+            charm: wordpress
+            constraints: instance-type=m1.small
+            num_units: 3
+            options:
+                tuning: optimized
+                engine: apache
+                wp-content: include-base64://blog.snippet
+        db:
+            charm: mysql
+            branch: lp:charms/precise/mysql
+            options:
+                tuning-level: fast
+        memcached:
+            branch: lp:charms/precise/memcached
+            options:
+                size: 100
+        haproxy:
+            charm_url: cs:precise/haproxy
+            options:
+                services: include-file://blog-include.yaml
+    relations:
+        - [blog, db]
+        - - blog
+          - cache
+        - - blog
+          - haproxy
+
+wordpress-prod:
+    series: precise
+    inherits: wordpress-stage
+    services:
+        blog:
+            options:
+                engine: nginx
+                tuning: optimized
+            constraints: instance-type=m1.large
+
+        db:
+            constraints: instance-type=m1.large
+            options:
+                tuning-level: safest
\ No newline at end of file

=== added directory 'test_data/precise'
=== added directory 'test_data/precise/appsrv'
=== added file 'test_data/precise/appsrv/metadata.yaml'
--- test_data/precise/appsrv/metadata.yaml	1970-01-01 00:00:00 +0000
+++ test_data/precise/appsrv/metadata.yaml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,2 @@
+charm: true
+

=== added file 'test_data/stack-default.cfg'
--- test_data/stack-default.cfg	1970-01-01 00:00:00 +0000
+++ test_data/stack-default.cfg	2013-07-15 21:24:33 +0000
@@ -0,0 +1,58 @@
+{
+  "wordpress": {
+        "series": "precise",
+        "services": {
+            "wordpress": {
+                "constraints": "instance-type=m1.small",
+                "options": {
+                    "engine": "",
+                    "enable_modules": "proxy rewrite proxy_http proxy_balancer ssl headers",
+                    "vhost_https_template": "include-base64://stack-include.template"
+                }
+            },
+            "db": {
+                "constraints": "instance-type=m1.small",
+                "charm": "mysql",
+                "options": {
+                    "tuning-level": "safest"}
+            },
+            "memcached": {
+                 "constraints": "instance-type=m1.small",
+                 "charm_url": ""
+            },
+            "haproxy": {
+
+            },
+            "my-app-cache": {
+                "constraints": "instance-type=m1.small",
+                "options": {
+                    "x_balancer_name_allowed": "true"
+                }
+            },
+            "my-nrpe-app-cache": {
+            },
+            "my-app-cache-lb": {
+                "constraints": "instance-type=m1.small",
+                "options": {
+                    "enable_monitoring": "true"
+                }
+            },
+            "my-nrpe-app-cache-lb": {
+            }
+        },
+        "relations": {
+            "my-app-fe:balancer": {
+                "weight": 100,
+                "consumes": ["my-app-lb:website"]
+            },
+            "my-app-lb:reverseproxy": {
+                "weight": 90,
+                "consumes": ["my-app-cache:cached-website"]
+            },
+            "my-app-cache:website": {
+                "weight": 80,
+                "consumes": ["my-app-cache-lb:website"]
+            }
+        }
+    }
+}

=== added file 'test_data/stack-include.template'
--- test_data/stack-include.template	1970-01-01 00:00:00 +0000
+++ test_data/stack-include.template	2013-07-15 21:24:33 +0000
@@ -0,0 +1,18 @@
+<VirtualHost _default_:80>
+    ServerAdmin [e-mail]
+
+    ErrorLog ${APACHE_LOG_DIR}/error.log
+    CustomLog ${APACHE_LOG_DIR}/access.log combined
+    LogLevel warn
+
+    DocumentRoot /srv/myapp.com/www/root
+
+    ProxyRequests off
+    <Proxy *>
+        Order deny,allow
+        Allow from all
+    </Proxy>
+
+    ProxyPreserveHost off
+
+</VirtulaHost
\ No newline at end of file

=== added file 'test_data/stack-include.yaml'
--- test_data/stack-include.yaml	1970-01-01 00:00:00 +0000
+++ test_data/stack-include.yaml	2013-07-15 21:24:33 +0000
@@ -0,0 +1,19 @@
+- service_name: thumbnail-private
+  service_host: 0.0.0.0
+  service_port: 1001
+  service_options: ['timeout client 65000', 'timeout server 65000', 'option httpchk', 'balance leastconn']
+  server_options: ['check inter 2000', 'rise 2', 'fall 5', 'maxconn 4']
+
+
+- service_name: updown-download-private
+  service_host: 0.0.0.0
+  service_port: 1011
+  service_options: ['timeout client 65000', 'timeout server 300000', 'option httpchk', 'balance leastconn']
+  server_options: ['check inter 2000', 'rise 2', 'fall 5', 'maxconn 16']
+
+
+- service_name: updown-upload
+  service_host: 0.0.0.0
+  service_port: 1021
+  service_options: ['balance leastconn', 'timeout server 600000']
+  server_options: ['check inter 2000', 'rise 2', 'fall 5', 'maxconn 8']

=== added file 'test_data/stack-inherits.cfg'
--- test_data/stack-inherits.cfg	1970-01-01 00:00:00 +0000
+++ test_data/stack-inherits.cfg	2013-07-15 21:24:33 +0000
@@ -0,0 +1,41 @@
+{
+    "my-files-frontend-dev": {
+        "inherits": "default-myapp-frontend",
+        "services": {
+            "my-files-fe": {
+                "constraints": "instance-type=m1.small"
+            },
+            "my-files-lb": {
+                "constraints": "instance-type=m1.small",
+                "options": {
+                    "services": "include-file://stack-include.yaml"
+                }
+            },
+            "my-nagios": {
+                "constraints": "instance-type=m1.small"
+            }
+        },
+       "relations": {
+            "my-nrpe-files-fe:monitors": {
+                "weight": 99,
+                "consumes": ["my-nagios:monitors"]
+            },
+            "my-files-fe:juju-info": {
+                "weight": 98,
+                "consumes": ["my-nagios:nagios"]
+            },
+            "my-nrpe-files-lb:monitors": {
+                "weight": 89,
+                "consumes": ["my-nagios:monitors"]
+            },
+            "my-files-lb:juju-info": {
+                "weight": 88,
+                "consumes": ["my-nagios:nagios"]
+            },
+            "my-files-lb:local-monitors": {
+                "weight": 88,
+                "consumes": ["my-nrpe-files-lb:local-monitors"]
+            }
+        }
+    }
+}
\ No newline at end of file

=== added file 'test_deployment.py'
--- test_deployment.py	1970-01-01 00:00:00 +0000
+++ test_deployment.py	2013-07-15 21:24:33 +0000
@@ -0,0 +1,447 @@
+"""
+
+For live connected tests you must setup a test environment and give
+the deployer the following.
+
+  - JUJU_API = API Endpoint for an environment (machine 0 port 17070). Example
+        JUJU_API=wss://instance-address.com:17070
+
+  - JUJU_HOME = If your using a non standard juju home location
+
+  - Provider api credentials in their default environment locations. For some
+    commands we need to execute the cli at the moment (terminate-machine,
+    deploy local charm).
+
+  - JUJU_BIN = If you want to use a non-PATH juju binary
+
+
+For devs, there is an isolated environment test example below that
+will self generate an environment.
+"""
+import base64
+import logging
+import os
+import shutil
+import StringIO
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+
+from deployer import (
+    ConfigStack,
+    Service,
+    Charm,
+    Deployment,
+    EnvironmentClient,
+    Importer,
+    ErrorExit)
+
+from deployer import (
+    path_join, yaml_dump, yaml_load, setup_logging, dict_merge)
+
+
+class Base(unittest.TestCase):
+
+    def capture_logging(self, name="", level=logging.INFO,
+                        log_file=None, formatter=None):
+        if log_file is None:
+            log_file = StringIO.StringIO()
+        log_handler = logging.StreamHandler(log_file)
+        if formatter:
+            log_handler.setFormatter(formatter)
+        logger = logging.getLogger(name)
+        logger.addHandler(log_handler)
+        old_logger_level = logger.level
+        logger.setLevel(level)
+
+        @self.addCleanup
+        def reset_logging():
+            logger.removeHandler(log_handler)
+            logger.setLevel(old_logger_level)
+        return log_file
+
+    def mkdir(self):
+        d = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, d)
+        return d
+
+    def change_environment(self, **kw):
+        """
+        """
+        original_environ = dict(os.environ)
+
+        @self.addCleanup
+        def cleanup_env():
+            os.environ.clear()
+            os.environ.update(original_environ)
+
+        os.environ.update(kw)
+
+
+class UtilTests(Base):
+
+    def test_relation_list_merge(self):
+        self.assertEqual(
+            dict_merge(
+                {'relations': [['m1', 'x1']]},
+                {'relations': [['m2', 'x2']]}),
+            {'relations': [['m1', 'x1'], ['m2', 'x2']]})
+
+    def test_no_rels_in_target(self):
+        self.assertEqual(
+            dict_merge(
+                {'a': 1},
+                {'relations': [['m1', 'x1'], ['m2', 'x2']]}),
+            {'a': 1, 'relations': [['m1', 'x1'], ['m2', 'x2']]})
+
+
+class CharmTest(Base):
+
+    def setUp(self):
+        d = self.mkdir()
+        self.series_path = os.path.join(d, "precise")
+        os.mkdir(self.series_path)
+
+        self.charm_data = {
+            "charm": "couchdb",
+            "build": None,
+            "branch": "lp:charms/precise/couchdb",
+            "rev": None,
+            "charm_url": None,
+        }
+        self.output = self.capture_logging(
+            "deployer.charm", level=logging.DEBUG)
+
+    def test_charm(self):
+        params = dict(self.charm_data)
+        charm = Charm.from_service("scratch", self.series_path, params)
+
+        charm.fetch()
+        self.assertEqual(charm.metadata['name'],  'couchdb')
+
+        charm.rev = 7
+        charm.update()
+        output = subprocess.check_output(
+            ["bzr", "revno", "--tree"], cwd=charm.path)
+        self.assertEqual(output.strip(), str(7))
+
+        self.assertFalse(charm.is_modified())
+        with open(os.path.join(charm.path, 'revision'), 'w') as fh:
+            fh.write('0')
+        self.assertTrue(charm.is_modified())
+
+    def test_charm_error(self):
+        params = dict(self.charm_data)
+        params['branch'] = "lp:charms/precise/zebramoon"
+        charm = Charm.from_service("scratch", self.series_path, params)
+        self.assertRaises(ErrorExit, charm.fetch)
+        self.assertIn('bzr: ERROR: Not a branch: ', self.output.getvalue())
+
+
+class ConfigTest(Base):
+
+    def setUp(self):
+        self.output = self.capture_logging(
+            "deployer.config", level=logging.DEBUG)
+
+    def test_config_basic(self):
+        config = ConfigStack(['configs/ostack-testing-sample.cfg'])
+        config.load()
+        self.assertEqual(
+            config.keys(),
+            [u'openstack-precise-ec2',
+             u'openstack-precise-ec2-trunk',
+             u'openstack-ubuntu-testing'])
+        self.assertRaises(ErrorExit, config.get, 'zeeland')
+        result = config.get("openstack-precise-ec2")
+        self.assertTrue(isinstance(result, Deployment))
+
+    def test_config(self):
+        config = ConfigStack([
+            "test_data/stack-default.cfg", "test_data/stack-inherits.cfg"])
+        config.load()
+        self.assertEqual(
+            config.keys(),
+            [u'my-files-frontend-dev', u'wordpress'])
+        deployment = config.get("wordpress")
+        self.assertTrue(deployment)
+
+
+class NetworkConfigFetchingTests(Base):
+    """Configuration files can be specified via URL that is then fetched."""
+
+    def setUp(self):
+        self.output = self.capture_logging(
+            "deployer.config", level=logging.DEBUG)
+
+    def test_urls_are_fetched(self):
+        # If a config file is specified as a URL, that URL is fetched and
+        # placed at a temporary location where it is read and treated as a
+        # regular config file.
+        CONFIG_URL = 'http://site.invalid/config-1'
+        config = ConfigStack([])
+        config.config_files = [CONFIG_URL]
+
+        class FauxResponse(file):
+            def getcode(self):
+                return 200
+
+        def faux_urlopen(url):
+            self.assertEqual(url, CONFIG_URL)
+            return FauxResponse('configs/ostack-testing-sample.cfg')
+
+        config.load(urlopen=faux_urlopen)
+        self.assertEqual(
+            config.keys(),
+            [u'openstack-precise-ec2',
+             u'openstack-precise-ec2-trunk',
+             u'openstack-ubuntu-testing'])
+        self.assertRaises(ErrorExit, config.get, 'zeeland')
+        result = config.get("openstack-precise-ec2")
+        self.assertTrue(isinstance(result, Deployment))
+
+    def test_unfetchable_urls_generate_an_error(self):
+        # If a config file is specified as a URL, that URL is fetched and
+        # placed at a temporary location where it is read and treated as a
+        # regular config file.
+        CONFIG_URL = 'http://site.invalid/config-1'
+        config = ConfigStack([])
+        config.config_files = [CONFIG_URL]
+
+        class FauxResponse(file):
+            def getcode(self):
+                return 400
+
+        def faux_urlopen(url):
+            self.assertEqual(url, CONFIG_URL)
+            return FauxResponse('configs/ostack-testing-sample.cfg')
+
+        self.assertRaises(ErrorExit, config.load, urlopen=faux_urlopen)
+
+
+class ServiceTest(Base):
+
+    def test_service(self):
+        data = {
+            'branch': 'lp:precise/mysql'}
+
+        s = Service('db', data)
+        self.assertEqual(s.name, "db")
+        self.assertEqual(s.num_units, 1)
+        self.assertEqual(s.constraints, None)
+        self.assertEqual(s.config, None)
+
+        data = {
+            'branch': 'lp:precise/mysql',
+            'constraints': "instance-type=m1.small",
+            'options': {"services": "include-file://stack-include.yaml"},
+            'num_units': 10}
+        s = Service('db', data)
+        self.assertEquals(s.num_units, 10)
+        self.assertEquals(s.constraints, "instance-type=m1.small")
+        self.assertEquals(s.config, {"services": "include-file://stack-include.yaml"})
+
+
+class DeploymentTest(Base):
+    def setUp(self):
+        self.output = setup_logging(
+            debug=True, verbose=True, stream=StringIO.StringIO())
+
+    def test_deployer(self):
+        d = ConfigStack(["test_data/blog.yaml"]).get('wordpress-prod')
+        services = d.get_services()
+        self.assertTrue([s for s in services if s.name == "newrelic"])
+
+        # Ensure inheritance order reflects reality, instead of merge value.
+        self.assertEqual(
+            d.data['inherits'],  ['wordpress-stage', 'wordpress-base', 'metrics-base'])
+
+        # Fetch charms to verify late binding config values & validation.
+        t = self.mkdir()
+        os.mkdir(os.path.join(t, "precise"))
+        d.repo_path = t
+        d.fetch_charms()
+
+        # Load up overrides and resolves
+        d.load_overrides(["key=abc"])
+        d.resolve_config()
+
+        # Verify include-base64
+        self.assertEqual(d.get_service('newrelic').config, {'key': 'abc'})
+        self.assertEqual(
+            base64.b64decode(d.get_service('blog').config['wp-content']),
+            "HelloWorld")
+
+        # TODO verify include-file
+
+        # Verify relations
+        self.assertEqual(
+            list(d.get_relations()),
+            [('blog', 'db'), ('blog', 'cache'), ('blog', 'haproxy')])
+
+
[e-mail](
+    (not bool(os.environ.get("JUJU_ENDPOINT"))
+     or not bool(os.environ.get("JUJU_AUTH"))),
+    "Test env must be defined: JUJU_ENDPOINT/JUJU_AUTH")
+class LiveEnvironmentTest(Base):
+
+    def setUp(self):
+        self.endpoint = os.environ.get("JUJU_ENDPOINT")
+        self.output = self.capture_logging(
+            "deployer.env", log_file=sys.stderr, level=logging.DEBUG)
+        self.env = Environment("", self.endpoint)
+        self.env.connect()
+
+    def tearDown(self):
+        self.env.reset(timeout=240)
+        self.env.close()
+
+    def test_env(self):
+        # Destroy everything.. consistent baseline
+        self.env.reset(timeout=240)
+
+        status = self.env.status()
+        self.assertFalse('services' in status)
+        self.env.deploy("test-blog", "cs:precise/wordpress")
+        self.env.deploy("test-db", "cs:precise/mysql")
+        self.env.add_relation("test-db", "test-blog")
+        self.env.add_units('test-blog', 1)
+        self.env.wait_for_units(timeout=600)
+
+        status = self.env.status()
+        services = ["test-blog", "test-db"]
+        self.assertEqual(
+            sorted(status['services'].keys()),
+            services)
+        for s in services:
+            for u in status['services'][s]['units']:
+                self.assertEqual(u['agent-state'], "started")
+
+
[e-mail](
+    not bool(os.environ.get("JUJU_NEW_ENV")),
+    "Skipping new env tests unless new env specified (JUJU_NEW_ENV)")
+class DISABLEDIsolatedEnvironmentTest(Base):
+    """
+    Environments tests that *create* & destroy isolated environments for testing.
+    """
+
+    @classmethod
+    def _exec(cls, params, ign_err=False, **env_vars):
+        env = dict(os.environ)
+        env.update(env_vars)
+        env["JUJU_HOME"] = cls.cls_juju_home
+
+        print "cmd:", " ".join(params), "env:", " ".join(
+            ["%s=%s" % (k, env[k]) for k in env if k.startswith("JUJU")])
+
+        try:
+            return subprocess.check_output(
+                params, stderr=subprocess.STDOUT, env=env)
+        except subprocess.CalledProcessError, e:
+            print "Error on exec"
+            print " ".join(params), env["JUJU_HOME"]
+            print e.output
+
+    @classmethod
+    def setUpClass(cls):
+        # Bootstraps a new juju test environment
+        cls.cls_juju_home = tempfile.mkdtemp()
+        cls.juju_bin = os.environ.get("JUJU_BIN", "juju")
+
+        # Create a new environment
+        conf = yaml_load(cls._exec([cls.juju_bin, 'init']))
+        envs = conf['environments']
+        env_type = os.environ.get("JUJU_ENV", "amazon")
+
+        assert env_type in envs, "Invalid env type specified %s" % (envs.keys())
+        conf["default"] = env_type
+
+        # Find a public key to use for the environment
+        found = False
+        key_set = ["~/.ssh/id_dsa.pub", "~/.ssh/id_rsa.pub"]
+        for key in key_set:
+            key = os.path.expanduser(key)
+            if os.path.exists(key):
+                found = True
+                break
+        if not found:
+            raise RuntimeError("No ssh public key found: tried (%s" % (
+                " ".join(key_set)))
+        envs[env_type]['authorized-keys-path'] = key
+
+        # Bootstrap
+        with open(path_join(
+                cls.cls_juju_home, "environments.yaml"), "w") as fh:
+            fh.write(yaml_dump(conf))
+        cls._exec([cls.juju_bin, "bootstrap"])
+
+    @classmethod
+    def tearDownClass(cls):
+        cls._exec([cls.juju_bin, "destroy-environment"])
+
+    def setUp(self):
+        self.st = time.time()
+        self.change_environment(JUJU_HOME=self.__class__.cls_juju_home)
+        self.capture_logging("deployer.env", log_file=sys.stderr, level=logging.DEBUG)
+
+    def test_environment(self):
+        env = Environment("")
+        st = time.time()
+        env.connect()
+        print "Bootstrap took", st - time.time()
+        status = env.status()
+        self.assertFalse(status['services'].keys())
+
+
+_marker = object()
+
+
+class Options(dict):
+
+    def __getattr__(self, key):
+        v = self.get(key, _marker)
+        if v is _marker:
+            raise AttributeError(key)
+        return v
+
+
[e-mail](
+    not bool(os.environ.get("JUJU_API")),
+    "Test environment endpoint must be defined JUJU_API")
+class ImporterTest(Base):
+
+    def setUp(self):
+        self.env = Environment("", os.environ["JUJU_API"])
+        self.output = StringIO()
+        setup_logging(verbose=True, debug=True, stream=self.output)
+
+        self.importer = Importer()
+        self.options = Options({
+            'verbose': True, 'watch': True})
+
+        self.importer = Importer(self.env, self.deployment, self.options)
+
+    def get_importer(self, data, dirs=(), **kw):
+        pass
+
+    def test_importer(self):
+        pass
+
+
+def collector():
+    # import __main__ triggers code re-execution
+    from unittest.loader import defaultTestLoader
+    __main__ = sys.modules['__main__']
+    setupDir = os.path.abspath(os.path.dirname(__main__.__file__))
+    return defaultTestLoader.discover(setupDir)
+
+
+def main():
+    unittest.main()
+
+if __name__ == '__main__':
+    main()

=== added file 'todo.txt'
--- todo.txt	1970-01-01 00:00:00 +0000
+++ todo.txt	2013-07-15 21:24:33 +0000
@@ -0,0 +1,47 @@
+Todo Items
+----------
+
+Long term
+=========
+
+- Freeze to generate an updated
+- support for revision of charms as of date
+- include-env for shell env var inclusion
+
+- generate an archive with charms
+- gpg sign an archive
+
+    # Workaround / say if using cached Charm present
+    # Write out resolved deployment file with includes & overrides
+    # Ensure bootstrap
+    # 
+
+Medium Term
+===========
+- support for github charms
+- Get core support for resetting charms.
+
+
+Short Term
+==========
+- Switch to argparse/Use subcommands for new commands
+- Better deployment validation
+- Diff an environment to config
+- Save a charm
+- Update/Run against an existing environment
+- Write out resolved deployment file
+- Version file.
+
+
+----------------------------------------
+
+- allow for specifying list of lists for a single rel entry.
+- include variable for env uuid and name
+- charm branch parse for info
+
+----------------------------------------
+
+Bugs encountered
+  - http://pad.lv/1174616 [wedged unit]
+  - http://pad.lv/1174613 [relation-list -r]
+  - http://pad.lv/1174610 [unit-id recycling]