Merge lp:~rogpeppe/pyjuju/go-state-units-under-service into lp:pyjuju/go

[Roger Peppe]

state: store units inside their respective services

Making this change simplifies a lot of code - not need
to keep a separate sequence numbering system for units,
for example.

https://codereview.appspot.com/6247066/

[Roger Peppe (rogpeppe)]

Reviewers: mp+108341_code.launchpad.net,

Message:
Please take a look.

Description:
state: store units inside their respective services

Making this change simplifies a lot of code - not need
to keep a separate sequence numbering system for units,
for example.

https://code.launchpad.net/~rogpeppe/juju/go-state-units-under-service/+merge/108341

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/6247066/

Affected files:
   A [revision details]
   M state/internal_test.go
   M state/machine.go
   M state/service.go
   M state/state.go
   M state/state_test.go
   M state/topology.go
   M state/unit.go

[Roger Peppe (rogpeppe)]

Please take a look.

https://codereview.appspot.com/6247066/

[William Reade (fwereade)]

LGTM modulo below.

https://codereview.appspot.com/6247066/diff/7001/state/service.go
File state/service.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode120
state/service.go:120: return zkRemoveTree(s.st.zk, unit.zkPath())
Not relevant to this CL... but do we actually want to do this? The unit
agent will surely still be running; I'm not sure it'll handle this all
that well...

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode228
state/service.go:228: return s.zkPath() + "/config"
I strongly approve of all the changes like this one :).

https://codereview.appspot.com/6247066/diff/7001/state/topology.go
File state/topology.go (left):

https://codereview.appspot.com/6247066/diff/7001/state/topology.go#oldcode283
state/topology.go:283: // sequence number will be increased
monotonically for each service.
Update comment

https://codereview.appspot.com/6247066/diff/7001/state/unit.go
File state/unit.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode77
state/unit.go:77: func mkUnitKey(serviceKey string, unitId int) string {
What does "mk" signify?

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode86
state/unit.go:86: return "", fmt.Errorf("invalid unit key %q (1) %s",
unitKey, debug.Callers(0, 10))
Is this the proposed implementation or an oversight?

https://codereview.appspot.com/6247066/

[Gustavo Niemeyer (niemeyer)]

Very nice change. LGTM, assuming you're happy with the adaptations
below. Otherwise, please reply accordingly and repropose.

Please note you'll have to propose+submit this to the new juju-core
project, since the old trunk is now gone (sorry!). You can do this by
creating a new branch from the new project as you'd usually do, merging
from this work onto it, and then just proposing as usual.

https://codereview.appspot.com/6247066/diff/7001/state/machine.go
File state/machine.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/machine.go#newcode88
state/machine.go:88: // keyId returns the id corresponding to the given
machine or unit id.
s/keyId/keySequence/ or s/keyId/keySeq/

This is not an identifier. "unit-0000001" is the identifier, and we use
the term "key" there, after much debate, precisely to avoid the
confusion with the idea of an "id" which is public. We can easily avoid
the confusion still by calling the sequence number what it really is (it
comes from the idea of sequence from ZooKeeper).

As a special case, we do call the *machine* sequence number an
identifier, because that's how we handle it across the board
(machine.Id(), etc).

https://codereview.appspot.com/6247066/diff/7001/state/service.go
File state/service.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode13
state/service.go:13: pathPkg "path"
stdpath

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode84
state/service.go:84: kprefix = kprefix[:strings.LastIndex(kprefix,
"-")+1]
There's no reason to go over the trouble here. It's already assuming
knowledge about how makeUnitKey works (who said it could skip 'til the
last dash like that?) so it may as well be a lot more clear and say
"/units/unit-" + s.key + "-".

https://codereview.appspot.com/6247066/diff/7001/state/unit.go
File state/unit.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode77
state/unit.go:77: func mkUnitKey(serviceKey string, unitId int) string {
On 2012/06/04 07:29:19, fwereade wrote:
> What does "mk" signify?

I assume "make", but I'd also prefer the word itself rather than saving
two chars. Even more when we have serviceKeyForUnitKey below. :-)

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode86
state/unit.go:86: return "", fmt.Errorf("invalid unit key %q (1) %s",
unitKey, debug.Callers(0, 10))
On 2012/06/04 07:29:19, fwereade wrote:
> Is this the proposed implementation or an oversight?

Yeah, looks like an oversight. We need something closer to the error
message of makeUnitKey.

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode518
state/unit.go:518: func parseUnitName(name string) (serviceName string,
serviceId int, err error) {
s/serviceId/serviceSeq/

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode523
state/unit.go:523: id, err := strconv.ParseInt(parts[1], 10, 0)
s/id/seq/

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode527
state/unit.go:527: return parts[0], int(id), nil
s/id/seq/

https://codereview.appspot.com/6247066/

[Gustavo Niemeyer (niemeyer)]

I have marked the branch in Launchpad as Rejected, but only because of
the move to juju-core. The above review is still valid and is what
counts.

https://codereview.appspot.com/6247066/

[lp:~rogpeppe/pyjuju/go-state-units-under-service]

201. By Roger Peppe on 2012-06-07

state: fixes for review

202. By Roger Peppe on 2012-06-07

merge trunk

[Roger Peppe (rogpeppe)]

submitted in branch from juju-core

https://codereview.appspot.com/6247066/diff/7001/state/machine.go
File state/machine.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/machine.go#newcode88
state/machine.go:88: // keyId returns the id corresponding to the given
machine or unit id.
On 2012/06/06 20:15:09, niemeyer wrote:
> s/keyId/keySequence/ or s/keyId/keySeq/

> This is not an identifier. "unit-0000001" is the identifier, and we
use the term
> "key" there, after much debate, precisely to avoid the confusion with
the idea
> of an "id" which is public. We can easily avoid the confusion still by
calling
> the sequence number what it really is (it comes from the idea of
sequence from
> ZooKeeper).

> As a special case, we do call the *machine* sequence number an
identifier,
> because that's how we handle it across the board (machine.Id(), etc).

Done.

https://codereview.appspot.com/6247066/diff/7001/state/service.go
File state/service.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode84
state/service.go:84: kprefix = kprefix[:strings.LastIndex(kprefix,
"-")+1]
On 2012/06/06 20:15:09, niemeyer wrote:
> There's no reason to go over the trouble here. It's already assuming
knowledge
> about how makeUnitKey works (who said it could skip 'til the last dash
like
> that?) so it may as well be a lot more clear and say "/units/unit-" +
s.key +
> "-".

it's not *quite* as simple as that (makeUnitKey strips off the initial
"service-" prefix) but done anyway.

https://codereview.appspot.com/6247066/diff/7001/state/service.go#newcode120
state/service.go:120: return zkRemoveTree(s.st.zk, unit.zkPath())
On 2012/06/04 07:29:19, fwereade wrote:
> Not relevant to this CL... but do we actually want to do this? The
unit agent
> will surely still be running; I'm not sure it'll handle this all that
well...

that's an interesting point (although, as you say, not relevant to this
CL). what *should* we do here? wait until the unit agent has gone away?
leave the directory around and GC it later? or perhaps the best approach
*is* to delete the directory and let the unit agent detect that.

https://codereview.appspot.com/6247066/diff/7001/state/unit.go
File state/unit.go (right):

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode77
state/unit.go:77: func mkUnitKey(serviceKey string, unitId int) string {
On 2012/06/06 20:15:09, niemeyer wrote:
> On 2012/06/04 07:29:19, fwereade wrote:
> > What does "mk" signify?

> I assume "make", but I'd also prefer the word itself rather than
saving two
> chars. Even more when we have serviceKeyForUnitKey below. :-)

done. old C proclivities creeping in there... :-)

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode86
state/unit.go:86: return "", fmt.Errorf("invalid unit key %q (1) %s",
unitKey, debug.Callers(0, 10))
On 2012/06/06 20:15:09, niemeyer wrote:
> On 2012/06/04 07:29:19, fwereade wrote:
> > Is this the proposed implementation or an oversight?

> Yeah, looks like an oversight. We need something closer to the error
message of
> makeUnitKey.

oops. done.

https://codereview.appspot.com/6247066/diff/7001/state/unit.go#newcode518
sta...

[William Reade (fwereade)]

On 2012/06/07 12:07:29, rog wrote:
> On 2012/06/04 07:29:19, fwereade wrote:
> > Not relevant to this CL... but do we actually want to do this? The
unit agent
> > will surely still be running; I'm not sure it'll handle this all
that well...

> that's an interesting point (although, as you say, not relevant to
this CL).
> what *should* we do here? wait until the unit agent has gone away?
leave the
> directory around and GC it later? or perhaps the best approach *is* to
delete
> the directory and let the unit agent detect that.

Offhand, I think I'd favour a dying/dead approach... eg this sets
"dying", which is handled by the UA (which cleans itself up, and sets
"dead"); MA can watch for "dead" on assigned units, tidy them up, and
finally delete the state once we're sure it's unused. Not sure though.

https://codereview.appspot.com/6247066/

[Kapil Thangavelu (hazmat)]

taking out dirs from running processes is a bad idea. it needs to be
coordinate if your going to leave the process around.

On Thu, Jun 7, 2012 at 11:22 AM, William Reade
<email address hidden>wrote:

> On 2012/06/07 12:07:29, rog wrote:
> > On 2012/06/04 07:29:19, fwereade wrote:
> > > Not relevant to this CL... but do we actually want to do this? The
> unit agent
> > > will surely still be running; I'm not sure it'll handle this all
> that well...
>
> > that's an interesting point (although, as you say, not relevant to
> this CL).
> > what *should* we do here? wait until the unit agent has gone away?
> leave the
> > directory around and GC it later? or perhaps the best approach *is* to
> delete
> > the directory and let the unit agent detect that.
>
> Offhand, I think I'd favour a dying/dead approach... eg this sets
> "dying", which is handled by the UA (which cleans itself up, and sets
> "dead"); MA can watch for "dead" on assigned units, tidy them up, and
> finally delete the state once we're sure it's unused. Not sure though.
>
> https://codereview.appspot.com/6247066/
>
> --
>
> https://code.launchpad.net/~rogpeppe/juju/go-state-units-under-service/+merge/108341
> Your team juju hackers is requested to review the proposed merge of
> lp:~rogpeppe/juju/go-state-units-under-service into lp:juju/go.
>

Unmerged revisions

202. By Roger Peppe on 2012-06-07

merge trunk

201. By Roger Peppe on 2012-06-07

state: fixes for review

200. By Roger Peppe on 2012-06-01

minor tweaks

199. By Roger Peppe on 2012-06-01

state: use a string for unit key

198. By Roger Peppe on 2012-06-01

state: move function
;

197. By Roger Peppe on 2012-06-01

state: move units under service directory

=== added file '.lbox.OTHER'
--- .lbox.OTHER	1970-01-01 00:00:00 +0000
+++ .lbox.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,1 @@
+propose -cr -for lp:juju-core/juju
 
=== added directory 'charm'
=== added file 'charm/bundle_test.go.OTHER'
--- charm/bundle_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/bundle_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,196 @@
+package charm_test
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/testing"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+type BundleSuite struct {
+	repo       *testing.Repo
+	bundlePath string
+}
+
+var _ = Suite(&BundleSuite{})
+
+func (s *BundleSuite) SetUpSuite(c *C) {
+	s.bundlePath = testing.Charms.BundlePath(c.MkDir(), "dummy")
+}
+
+func (s *BundleSuite) TestReadBundle(c *C) {
+	bundle, err := charm.ReadBundle(s.bundlePath)
+	c.Assert(err, IsNil)
+	checkDummy(c, bundle, s.bundlePath)
+}
+
+func (s *BundleSuite) TestReadBundleWithoutConfig(c *C) {
+	path := testing.Charms.BundlePath(c.MkDir(), "varnish")
+	bundle, err := charm.ReadBundle(path)
+	c.Assert(err, IsNil)
+
+	// A lacking config.yaml file still causes a proper
+	// Config value to be returned.
+	c.Assert(bundle.Config().Options, HasLen, 0)
+}
+
+func (s *BundleSuite) TestReadBundleBytes(c *C) {
+	data, err := ioutil.ReadFile(s.bundlePath)
+	c.Assert(err, IsNil)
+
+	bundle, err := charm.ReadBundleBytes(data)
+	c.Assert(err, IsNil)
+	checkDummy(c, bundle, "")
+}
+
+func (s *BundleSuite) TestExpandTo(c *C) {
+	bundle, err := charm.ReadBundle(s.bundlePath)
+	c.Assert(err, IsNil)
+
+	path := filepath.Join(c.MkDir(), "charm")
+	err = bundle.ExpandTo(path)
+	c.Assert(err, IsNil)
+
+	dir, err := charm.ReadDir(path)
+	c.Assert(err, IsNil)
+	checkDummy(c, dir, path)
+}
+
+func (s *BundleSuite) TestBundleFileModes(c *C) {
+	// Apply subtler mode differences than can be expressed in Bazaar.
+	srcPath := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	modes := []struct {
+		path string
+		mode os.FileMode
+	}{
+		{"hooks/install", 0751},
+		{"empty", 0750},
+		{"src/hello.c", 0614},
+	}
+	for _, m := range modes {
+		err := os.Chmod(filepath.Join(srcPath, m.path), m.mode)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// Bundle and extract the charm to a new directory.
+	dir, err := charm.ReadDir(srcPath)
+	c.Assert(err, IsNil)
+	buf := new(bytes.Buffer)
+	err = dir.BundleTo(buf)
+	c.Assert(err, IsNil)
+	bundle, err := charm.ReadBundleBytes(buf.Bytes())
+	c.Assert(err, IsNil)
+	path := c.MkDir()
+	err = bundle.ExpandTo(path)
+	c.Assert(err, IsNil)
+
+	// Check sensible file modes once round-tripped.
+	info, err := os.Stat(filepath.Join(path, "src", "hello.c"))
+	c.Assert(err, IsNil)
+	c.Assert(info.Mode()&0777, Equals, os.FileMode(0644))
+	c.Assert(info.Mode()&os.ModeType, Equals, os.FileMode(0))
+
+	info, err = os.Stat(filepath.Join(path, "hooks", "install"))
+	c.Assert(err, IsNil)
+	c.Assert(info.Mode()&0777, Equals, os.FileMode(0755))
+	c.Assert(info.Mode()&os.ModeType, Equals, os.FileMode(0))
+
+	info, err = os.Stat(filepath.Join(path, "empty"))
+	c.Assert(err, IsNil)
+	c.Assert(info.Mode()&0777, Equals, os.FileMode(0755))
+
+	target, err := os.Readlink(filepath.Join(path, "hooks", "symlink"))
+	c.Assert(err, IsNil)
+	c.Assert(target, Equals, "../target")
+}
+
+func (s *BundleSuite) TestBundleRevisionFile(c *C) {
+	charmDir := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	revPath := filepath.Join(charmDir, "revision")
+
+	// Missing revision file
+	err := os.Remove(revPath)
+	c.Assert(err, IsNil)
+
+	bundle, err := charm.ReadBundle(extBundleDir(c, charmDir))
+	c.Assert(err, IsNil)
+	c.Assert(bundle.Revision(), Equals, 0)
+
+	// Missing revision file with old revision in metadata
+	file, err := os.OpenFile(filepath.Join(charmDir, "metadata.yaml"), os.O_WRONLY|os.O_APPEND, 0)
+	c.Assert(err, IsNil)
+	_, err = file.Write([]byte("\nrevision: 1234\n"))
+	c.Assert(err, IsNil)
+
+	bundle, err = charm.ReadBundle(extBundleDir(c, charmDir))
+	c.Assert(err, IsNil)
+	c.Assert(bundle.Revision(), Equals, 1234)
+
+	// Revision file with bad content
+	err = ioutil.WriteFile(revPath, []byte("garbage"), 0666)
+	c.Assert(err, IsNil)
+
+	bundle, err = charm.ReadBundle(extBundleDir(c, charmDir))
+	c.Assert(err, ErrorMatches, "invalid revision file")
+	c.Assert(bundle, IsNil)
+}
+
+func (s *BundleSuite) TestBundleSetRevision(c *C) {
+	bundle, err := charm.ReadBundle(s.bundlePath)
+	c.Assert(err, IsNil)
+
+	c.Assert(bundle.Revision(), Equals, 1)
+	bundle.SetRevision(42)
+	c.Assert(bundle.Revision(), Equals, 42)
+
+	path := filepath.Join(c.MkDir(), "charm")
+	err = bundle.ExpandTo(path)
+	c.Assert(err, IsNil)
+
+	dir, err := charm.ReadDir(path)
+	c.Assert(err, IsNil)
+	c.Assert(dir.Revision(), Equals, 42)
+}
+
+func (s *BundleSuite) TestExpandToWithBadLink(c *C) {
+	charmDir := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	badLink := filepath.Join(charmDir, "hooks", "badlink")
+
+	// Symlink targeting a path outside of the charm.
+	err := os.Symlink("../../target", badLink)
+	c.Assert(err, IsNil)
+
+	bundle, err := charm.ReadBundle(extBundleDir(c, charmDir))
+	c.Assert(err, IsNil)
+
+	path := filepath.Join(c.MkDir(), "charm")
+	err = bundle.ExpandTo(path)
+	c.Assert(err, ErrorMatches, `symlink "hooks/badlink" links out of charm: "../../target"`)
+
+	// Symlink targeting an absolute path.
+	os.Remove(badLink)
+	err = os.Symlink("/target", badLink)
+	c.Assert(err, IsNil)
+
+	bundle, err = charm.ReadBundle(extBundleDir(c, charmDir))
+	c.Assert(err, IsNil)
+
+	path = filepath.Join(c.MkDir(), "charm")
+	err = bundle.ExpandTo(path)
+	c.Assert(err, ErrorMatches, `symlink "hooks/badlink" is absolute: "/target"`)
+}
+
+func extBundleDir(c *C, dirpath string) (path string) {
+	path = filepath.Join(c.MkDir(), "bundle.charm")
+	cmd := exec.Command("/bin/sh", "-c", fmt.Sprintf("cd %s; zip --fifo --symlinks -r %s .", dirpath, path))
+	output, err := cmd.CombinedOutput()
+	c.Assert(err, IsNil, Commentf("Command output: %s", output))
+	return path
+}
 
=== added file 'charm/charm_test.go.OTHER'
--- charm/charm_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/charm_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,97 @@
+package charm_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/testing"
+	stdtesting "testing"
+)
+
+func Test(t *stdtesting.T) {
+	TestingT(t)
+}
+
+type CharmSuite struct{}
+
+var _ = Suite(&CharmSuite{})
+
+func (s *CharmSuite) TestRead(c *C) {
+	bPath := testing.Charms.BundlePath(c.MkDir(), "dummy")
+	ch, err := charm.Read(bPath)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Meta().Name, Equals, "dummy")
+	dPath := testing.Charms.DirPath("dummy")
+	ch, err = charm.Read(dPath)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Meta().Name, Equals, "dummy")
+}
+
+var inferRepoTests = []struct {
+	name   string
+	series string
+	path   string
+	curl   string
+}{
+	{"wordpress", "precise", "anything", "cs:precise/wordpress"},
+	{"oneiric/wordpress", "anything", "anything", "cs:oneiric/wordpress"},
+	{"cs:oneiric/wordpress", "anything", "anything", "cs:oneiric/wordpress"},
+	{"local:wordpress", "precise", "/some/path", "local:precise/wordpress"},
+	{"local:oneiric/wordpress", "anything", "/some/path", "local:oneiric/wordpress"},
+}
+
+func (s *CharmSuite) TestInferRepository(c *C) {
+	for _, t := range inferRepoTests {
+		repo, curl, err := charm.InferRepository(t.name, t.series, t.path)
+		c.Assert(err, IsNil)
+		expectCurl := charm.MustParseURL(t.curl)
+		c.Assert(curl, DeepEquals, expectCurl)
+		if localRepo, ok := repo.(*charm.LocalRepository); ok {
+			c.Assert(localRepo.Path, Equals, t.path)
+			c.Assert(curl.Schema, Equals, "local")
+		} else {
+			c.Assert(curl.Schema, Equals, "cs")
+		}
+	}
+	_, _, err := charm.InferRepository("local:whatever", "series", "")
+	c.Assert(err, ErrorMatches, "path to local repository not specified")
+}
+
+func checkDummy(c *C, f charm.Charm, path string) {
+	c.Assert(f.Revision(), Equals, 1)
+	c.Assert(f.Meta().Name, Equals, "dummy")
+	c.Assert(f.Config().Options["title"].Default, Equals, "My Title")
+	switch f := f.(type) {
+	case *charm.Bundle:
+		c.Assert(f.Path, Equals, path)
+
+	case *charm.Dir:
+		c.Assert(f.Path, Equals, path)
+	}
+}
+
+type YamlHacker map[interface{}]interface{}
+
+func ReadYaml(r io.Reader) YamlHacker {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		panic(err)
+	}
+	m := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, m)
+	if err != nil {
+		panic(err)
+	}
+	return YamlHacker(m)
+}
+
+func (yh YamlHacker) Reader() io.Reader {
+	data, err := goyaml.Marshal(yh)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewBuffer(data)
+}
 
=== added file 'charm/config.go.OTHER'
--- charm/config.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/config.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,141 @@
+package charm
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju-core/juju/schema"
+	"reflect"
+	"strconv"
+)
+
+// Option represents a single configuration option that is declared
+// as supported by a charm in its config.yaml file.
+type Option struct {
+	Title       string
+	Description string
+	Type        string
+	Default     interface{}
+}
+
+// Config represents the supported configuration options for a charm,
+// as declared in its config.yaml file.
+type Config struct {
+	Options map[string]Option
+}
+
+// NewConfig returns a new Config without any options.
+func NewConfig() *Config {
+	return &Config{make(map[string]Option)}
+}
+
+// ReadConfig reads a config.yaml file and returns its representation.
+func ReadConfig(r io.Reader) (config *Config, err error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return
+	}
+	raw := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, raw)
+	if err != nil {
+		return
+	}
+	v, err := configSchema.Coerce(raw, nil)
+	if err != nil {
+		return nil, errors.New("config: " + err.Error())
+	}
+	config = NewConfig()
+	m := v.(schema.MapType)
+	for name, infov := range m["options"].(schema.MapType) {
+		opt := infov.(schema.MapType)
+		optTitle, _ := opt["title"].(string)
+		optType, _ := opt["type"].(string)
+		optDescr, _ := opt["description"].(string)
+		optDefault := opt["default"]
+		if optDefault != nil {
+			if reflect.TypeOf(optDefault).Kind() != validTypes[optType] {
+				msg := "Bad default for %q: %v is not of type %s"
+				return nil, fmt.Errorf(msg, name, optDefault, optType)
+			}
+		}
+		config.Options[name.(string)] = Option{
+			Title:       optTitle,
+			Type:        optType,
+			Description: optDescr,
+			Default:     optDefault,
+		}
+	}
+	return
+}
+
+// Validate processes the values in the input map according to the
+// configuration in config, doing the following operations:
+//
+// - Values are converted from strings to the types defined
+// - Options with default values are introduced for missing keys
+// - Unknown keys and badly typed values are reported as errors
+// 
+func (c *Config) Validate(values map[string]string) (processed map[string]interface{}, err error) {
+	out := make(map[string]interface{})
+	for k, v := range values {
+		opt, ok := c.Options[k]
+		if !ok {
+			return nil, fmt.Errorf("Unknown configuration option: %q", k)
+		}
+		switch opt.Type {
+		case "string":
+			out[k] = v
+		case "int":
+			i, err := strconv.ParseInt(v, 10, 64)
+			if err != nil {
+				return nil, fmt.Errorf("Value for %q is not an int: %q", k, v)
+			}
+			out[k] = i
+		case "float":
+			f, err := strconv.ParseFloat(v, 64)
+			if err != nil {
+				return nil, fmt.Errorf("Value for %q is not a float: %q", k, v)
+			}
+			out[k] = f
+		case "boolean":
+			b, err := strconv.ParseBool(v)
+			if err != nil {
+				return nil, fmt.Errorf("Value for %q is not a boolean: %q", k, v)
+			}
+			out[k] = b
+		default:
+			panic(fmt.Errorf("Internal error: option type %q is unknown to Validate", opt.Type))
+		}
+	}
+	for k, opt := range c.Options {
+		if _, ok := out[k]; !ok && opt.Default != nil {
+			out[k] = opt.Default
+		}
+	}
+	return out, nil
+}
+
+var validTypes = map[string]reflect.Kind{
+	"string":  reflect.String,
+	"int":     reflect.Int64,
+	"boolean": reflect.Bool,
+	"float":   reflect.Float64,
+}
+
+var optionSchema = schema.FieldMap(
+	schema.Fields{
+		"type":        schema.OneOf(schema.Const("string"), schema.Const("int"), schema.Const("float"), schema.Const("boolean")),
+		"default":     schema.OneOf(schema.String(), schema.Int(), schema.Float(), schema.Bool()),
+		"description": schema.String(),
+	},
+	schema.Optional{"default", "description"},
+)
+
+var configSchema = schema.FieldMap(
+	schema.Fields{
+		"options": schema.Map(schema.String(), optionSchema),
+	},
+	nil,
+)
 
=== added file 'charm/config_test.go.OTHER'
--- charm/config_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/config_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,191 @@
+package charm_test
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/testing"
+	"os"
+	"path/filepath"
+)
+
+var sampleConfig = `
+options:
+  title:
+    default: My Title
+    description: A descriptive title used for the service.
+    type: string
+  outlook:
+    description: No default outlook.
+    type: string
+  username:
+    default: admin001
+    description: The name of the initial account (given admin permissions).
+    type: string
+  skill-level:
+    description: A number indicating skill.
+    type: int
+  agility-ratio:
+    description: A number from 0 to 1 indicating agility.
+    type: float
+  reticulate-splines:
+    description: Whether to reticulate splines on launch, or not.
+    type: boolean
+`
+
+func repoConfig(name string) io.Reader {
+	charmDir := testing.Charms.DirPath(name)
+	file, err := os.Open(filepath.Join(charmDir, "config.yaml"))
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewBuffer(data)
+}
+
+type ConfigSuite struct{}
+
+var _ = Suite(&ConfigSuite{})
+
+func (s *ConfigSuite) TestReadConfig(c *C) {
+	config, err := charm.ReadConfig(repoConfig("dummy"))
+	c.Assert(err, IsNil)
+	c.Assert(config.Options["title"], DeepEquals,
+		charm.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+}
+
+func (s *ConfigSuite) TestConfigError(c *C) {
+	_, err := charm.ReadConfig(bytes.NewBuffer([]byte(`options: {t: {type: foo}}`)))
+	c.Assert(err, ErrorMatches, `config: options.t.type: unsupported value`)
+}
+
+func (s *ConfigSuite) TestDefaultType(c *C) {
+	assertDefault := func(type_ string, value string, expected interface{}) {
+		config := fmt.Sprintf(`options: {t: {type: %s, default: %s}}`, type_, value)
+		result, err := charm.ReadConfig(bytes.NewBuffer([]byte(config)))
+		c.Assert(err, IsNil)
+		c.Assert(result.Options["t"].Default, Equals, expected)
+	}
+
+	assertDefault("boolean", "true", true)
+	assertDefault("string", "golden grahams", "golden grahams")
+	assertDefault("float", "2.2e11", 2.2e11)
+	assertDefault("int", "99", int64(99))
+
+	assertTypeError := func(type_ string, value string) {
+		config := fmt.Sprintf(`options: {t: {type: %s, default: %s}}`, type_, value)
+		_, err := charm.ReadConfig(bytes.NewBuffer([]byte(config)))
+		expected := fmt.Sprintf(`Bad default for "t": %s is not of type %s`, value, type_)
+		c.Assert(err, ErrorMatches, expected)
+	}
+
+	assertTypeError("boolean", "henry")
+	assertTypeError("string", "2.5")
+	assertTypeError("float", "blob")
+	assertTypeError("int", "33.2")
+}
+
+func (s *ConfigSuite) TestParseSample(c *C) {
+	config, err := charm.ReadConfig(bytes.NewBuffer([]byte(sampleConfig)))
+	c.Assert(err, IsNil)
+
+	opt := config.Options
+	c.Assert(opt["title"], DeepEquals,
+		charm.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["outlook"], DeepEquals,
+		charm.Option{
+			Description: "No default outlook.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["username"], DeepEquals,
+		charm.Option{
+			Default:     "admin001",
+			Description: "The name of the initial account (given admin permissions).",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["skill-level"], DeepEquals,
+		charm.Option{
+			Description: "A number indicating skill.",
+			Type:        "int",
+		},
+	)
+	c.Assert(opt["reticulate-splines"], DeepEquals,
+		charm.Option{
+			Description: "Whether to reticulate splines on launch, or not.",
+			Type:        "boolean",
+		},
+	)
+}
+
+func (s *ConfigSuite) TestValidate(c *C) {
+	config, err := charm.ReadConfig(bytes.NewBuffer([]byte(sampleConfig)))
+	c.Assert(err, IsNil)
+
+	input := map[string]string{
+		"title":   "Helpful Title",
+		"outlook": "Peachy",
+	}
+
+	// This should include an overridden value, a default and a new value.
+	expected := map[string]interface{}{
+		"title":    "Helpful Title",
+		"outlook":  "Peachy",
+		"username": "admin001",
+	}
+
+	output, err := config.Validate(input)
+	c.Assert(err, IsNil)
+	c.Assert(output, DeepEquals, expected)
+
+	// Check whether float conversion is working.
+	input["agility-ratio"] = "0.5"
+	input["skill-level"] = "7"
+	expected["agility-ratio"] = 0.5
+	expected["skill-level"] = int64(7)
+	output, err = config.Validate(input)
+	c.Assert(err, IsNil)
+	c.Assert(output, DeepEquals, expected)
+
+	// Check whether float errors are caught.
+	input["agility-ratio"] = "foo"
+	output, err = config.Validate(input)
+	c.Assert(err, ErrorMatches, `Value for "agility-ratio" is not a float: "foo"`)
+	input["agility-ratio"] = "0.5"
+
+	// Check whether int errors are caught.
+	input["skill-level"] = "foo"
+	output, err = config.Validate(input)
+	c.Assert(err, ErrorMatches, `Value for "skill-level" is not an int: "foo"`)
+	input["skill-level"] = "7"
+
+	// Check whether boolean errors are caught.
+	input["reticulate-splines"] = "maybe"
+	output, err = config.Validate(input)
+	c.Assert(err, ErrorMatches, `Value for "reticulate-splines" is not a boolean: "maybe"`)
+	input["reticulate-splines"] = "false"
+
+	// Now try to set a value outside the expected.
+	input["bad"] = "value"
+	output, err = config.Validate(input)
+	c.Assert(output, IsNil)
+	c.Assert(err, ErrorMatches, `Unknown configuration option: "bad"`)
+}
 
=== added file 'charm/dir_test.go.OTHER'
--- charm/dir_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/dir_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,199 @@
+package charm_test
+
+import (
+	"archive/zip"
+	"bytes"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/testing"
+	"os"
+	"path/filepath"
+	"syscall"
+)
+
+type DirSuite struct{}
+
+var _ = Suite(&DirSuite{})
+
+func (s *DirSuite) TestReadDir(c *C) {
+	path := testing.Charms.DirPath("dummy")
+	dir, err := charm.ReadDir(path)
+	c.Assert(err, IsNil)
+	checkDummy(c, dir, path)
+}
+
+func (s *DirSuite) TestReadDirWithoutConfig(c *C) {
+	path := testing.Charms.DirPath("varnish")
+	dir, err := charm.ReadDir(path)
+	c.Assert(err, IsNil)
+
+	// A lacking config.yaml file still causes a proper
+	// Config value to be returned.
+	c.Assert(dir.Config().Options, HasLen, 0)
+}
+
+func (s *DirSuite) TestBundleTo(c *C) {
+	dir := testing.Charms.Dir("dummy")
+	path := filepath.Join(c.MkDir(), "bundle.charm")
+	file, err := os.Create(path)
+	c.Assert(err, IsNil)
+	err = dir.BundleTo(file)
+	file.Close()
+	c.Assert(err, IsNil)
+
+	zipr, err := zip.OpenReader(path)
+	c.Assert(err, IsNil)
+	defer zipr.Close()
+
+	var metaf, instf, emptyf, revf, symf *zip.File
+	for _, f := range zipr.File {
+		c.Logf("Bundled file: %s", f.Name)
+		switch f.Name {
+		case "revision":
+			revf = f
+		case "metadata.yaml":
+			metaf = f
+		case "hooks/install":
+			instf = f
+		case "hooks/symlink":
+			symf = f
+		case "empty/":
+			emptyf = f
+		case "build/ignored":
+			c.Errorf("bundle includes build/*: %s", f.Name)
+		case ".ignored", ".dir/ignored":
+			c.Errorf("bundle includes .* entries: %s", f.Name)
+		}
+	}
+
+	c.Assert(revf, NotNil)
+	reader, err := revf.Open()
+	c.Assert(err, IsNil)
+	data, err := ioutil.ReadAll(reader)
+	reader.Close()
+	c.Assert(err, IsNil)
+	c.Assert(string(data), Equals, "1")
+
+	c.Assert(metaf, NotNil)
+	reader, err = metaf.Open()
+	c.Assert(err, IsNil)
+	meta, err := charm.ReadMeta(reader)
+	reader.Close()
+	c.Assert(err, IsNil)
+	c.Assert(meta.Name, Equals, "dummy")
+
+	c.Assert(instf, NotNil)
+	// Despite it being 0751, we pack and unpack it as 0755.
+	c.Assert(instf.Mode()&0777, Equals, os.FileMode(0755))
+
+	c.Assert(symf, NotNil)
+	c.Assert(symf.Mode()&0777, Equals, os.FileMode(0777))
+	reader, err = symf.Open()
+	c.Assert(err, IsNil)
+	data, err = ioutil.ReadAll(reader)
+	reader.Close()
+	c.Assert(err, IsNil)
+	c.Assert(string(data), Equals, "../target")
+
+	c.Assert(emptyf, NotNil)
+	c.Assert(emptyf.Mode()&os.ModeType, Equals, os.ModeDir)
+	// Despite it being 0750, we pack and unpack it as 0755.
+	c.Assert(emptyf.Mode()&0777, Equals, os.FileMode(0755))
+}
+
+func (s *DirSuite) TestBundleToWithBadType(c *C) {
+	charmDir := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	badFile := filepath.Join(charmDir, "hooks", "badfile")
+
+	// Symlink targeting a path outside of the charm.
+	err := os.Symlink("../../target", badFile)
+	c.Assert(err, IsNil)
+
+	dir, err := charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+
+	err = dir.BundleTo(&bytes.Buffer{})
+	c.Assert(err, ErrorMatches, `symlink "hooks/badfile" links out of charm: "../../target"`)
+
+	// Symlink targeting an absolute path.
+	os.Remove(badFile)
+	err = os.Symlink("/target", badFile)
+	c.Assert(err, IsNil)
+
+	dir, err = charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+
+	err = dir.BundleTo(&bytes.Buffer{})
+	c.Assert(err, ErrorMatches, `symlink "hooks/badfile" is absolute: "/target"`)
+
+	// Can't bundle special files either.
+	os.Remove(badFile)
+	err = syscall.Mkfifo(badFile, 0644)
+	c.Assert(err, IsNil)
+
+	dir, err = charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+
+	err = dir.BundleTo(&bytes.Buffer{})
+	c.Assert(err, ErrorMatches, `file is a named pipe: "hooks/badfile"`)
+}
+
+func (s *DirSuite) TestDirRevisionFile(c *C) {
+	charmDir := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	revPath := filepath.Join(charmDir, "revision")
+
+	// Missing revision file
+	err := os.Remove(revPath)
+	c.Assert(err, IsNil)
+
+	dir, err := charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+	c.Assert(dir.Revision(), Equals, 0)
+
+	// Missing revision file with old revision in metadata
+	file, err := os.OpenFile(filepath.Join(charmDir, "metadata.yaml"), os.O_WRONLY|os.O_APPEND, 0)
+	c.Assert(err, IsNil)
+	_, err = file.Write([]byte("\nrevision: 1234\n"))
+	c.Assert(err, IsNil)
+
+	dir, err = charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+	c.Assert(dir.Revision(), Equals, 1234)
+
+	// Revision file with bad content
+	err = ioutil.WriteFile(revPath, []byte("garbage"), 0666)
+	c.Assert(err, IsNil)
+
+	dir, err = charm.ReadDir(charmDir)
+	c.Assert(err, ErrorMatches, "invalid revision file")
+	c.Assert(dir, IsNil)
+}
+
+func (s *DirSuite) TestDirSetRevision(c *C) {
+	dir := testing.Charms.ClonedDir(c.MkDir(), "dummy")
+	c.Assert(dir.Revision(), Equals, 1)
+	dir.SetRevision(42)
+	c.Assert(dir.Revision(), Equals, 42)
+
+	var b bytes.Buffer
+	err := dir.BundleTo(&b)
+	c.Assert(err, IsNil)
+
+	bundle, err := charm.ReadBundleBytes(b.Bytes())
+	c.Assert(bundle.Revision(), Equals, 42)
+}
+
+func (s *DirSuite) TestDirSetDiskRevision(c *C) {
+	charmDir := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
+	dir, err := charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+
+	c.Assert(dir.Revision(), Equals, 1)
+	dir.SetDiskRevision(42)
+	c.Assert(dir.Revision(), Equals, 42)
+
+	dir, err = charm.ReadDir(charmDir)
+	c.Assert(err, IsNil)
+	c.Assert(dir.Revision(), Equals, 42)
+}
 
=== added file 'charm/export_test.go.OTHER'
--- charm/export_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/export_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,15 @@
+package charm
+
+import (
+	"launchpad.net/juju-core/juju/schema"
+)
+
+// Export meaningful bits for tests only.
+
+func IfaceExpander(limit interface{}) schema.Checker {
+	return ifaceExpander(limit)
+}
+
+func NewStore(url, path string) Repository {
+	return &store{url, path}
+}
 
=== added file 'charm/meta.go.OTHER'
--- charm/meta.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/meta.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,201 @@
+package charm
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju-core/juju/schema"
+)
+
+const (
+	ScopeGlobal    = "global"
+	ScopeContainer = "container"
+)
+
+// Relation represents a single relation defined in the charm
+// metadata.yaml file.
+type Relation struct {
+	Interface string
+	Optional  bool
+	Limit     int
+	Scope     string
+}
+
+// Meta represents all the known content that may be defined
+// within a charm's metadata.yaml file.
+type Meta struct {
+	Name        string
+	Summary     string
+	Description string
+	Provides    map[string]Relation
+	Requires    map[string]Relation
+	Peers       map[string]Relation
+	OldRevision int // Obsolete
+	Subordinate bool
+}
+
+// ReadMeta reads the content of a metadata.yaml file and returns
+// its representation.
+func ReadMeta(r io.Reader) (meta *Meta, err error) {
+	data, err := ioutil.ReadAll(r)
+	if err != nil {
+		return
+	}
+	raw := make(map[interface{}]interface{})
+	err = goyaml.Unmarshal(data, raw)
+	if err != nil {
+		return
+	}
+	v, err := charmSchema.Coerce(raw, nil)
+	if err != nil {
+		return nil, errors.New("metadata: " + err.Error())
+	}
+	m := v.(schema.MapType)
+	meta = &Meta{}
+	meta.Name = m["name"].(string)
+	// Schema decodes as int64, but the int range should be good
+	// enough for revisions.
+	meta.Summary = m["summary"].(string)
+	meta.Description = m["description"].(string)
+	meta.Provides = parseRelations(m["provides"])
+	meta.Requires = parseRelations(m["requires"])
+	meta.Peers = parseRelations(m["peers"])
+	if rev := m["revision"]; rev != nil {
+		// Obsolete
+		meta.OldRevision = int(m["revision"].(int64))
+	}
+	// Subordinate charms must have at least one relation that
+	// has container scope, otherwise they can't relate to the
+	// principal.
+	if subordinate := m["subordinate"]; subordinate != nil {
+		valid := false
+		if meta.Requires != nil {
+			for _, relationData := range meta.Requires {
+				if relationData.Scope == ScopeContainer {
+					valid = true
+					break
+				}
+			}
+		}
+		if !valid {
+			return nil, fmt.Errorf("subordinate charm %q lacks requires relation with container scope", meta.Name)
+		}
+		meta.Subordinate = m["subordinate"].(bool)
+	}
+	return
+}
+
+func parseRelations(relations interface{}) map[string]Relation {
+	if relations == nil {
+		return nil
+	}
+	result := make(map[string]Relation)
+	for name, rel := range relations.(schema.MapType) {
+		relMap := rel.(schema.MapType)
+		relation := Relation{}
+		relation.Interface = relMap["interface"].(string)
+		relation.Optional = relMap["optional"].(bool)
+		if scope := relMap["scope"]; scope != nil {
+			relation.Scope = scope.(string)
+		}
+		if relMap["limit"] != nil {
+			// Schema defaults to int64, but we know
+			// the int range should be more than enough.
+			relation.Limit = int(relMap["limit"].(int64))
+		}
+		result[name.(string)] = relation
+	}
+	return result
+}
+
+// Schema coercer that expands the interface shorthand notation.
+// A consistent format is easier to work with than considering the
+// potential difference everywhere.
+//
+// Supports the following variants::
+//
+//   provides:
+//     server: riak
+//     admin: http
+//     foobar:
+//       interface: blah
+//
+//   provides:
+//     server:
+//       interface: mysql
+//       limit:
+//       optional: false
+//
+// In all input cases, the output is the fully specified interface
+// representation as seen in the mysql interface description above.
+func ifaceExpander(limit interface{}) schema.Checker {
+	return ifaceExpC{limit}
+}
+
+type ifaceExpC struct {
+	limit interface{}
+}
+
+var (
+	stringC = schema.String()
+	mapC    = schema.Map(schema.String(), schema.Any())
+)
+
+func (c ifaceExpC) Coerce(v interface{}, path []string) (newv interface{}, err error) {
+	s, err := stringC.Coerce(v, path)
+	if err == nil {
+		newv = schema.MapType{
+			"interface": s,
+			"limit":     c.limit,
+			"optional":  false,
+			"scope":     ScopeGlobal,
+		}
+		return
+	}
+
+	// Optional values are context-sensitive and/or have
+	// defaults, which is different than what KeyDict can
+	// readily support. So just do it here first, then
+	// coerce to the real schema.
+	v, err = mapC.Coerce(v, path)
+	if err != nil {
+		return
+	}
+	m := v.(schema.MapType)
+	if _, ok := m["limit"]; !ok {
+		m["limit"] = c.limit
+	}
+	if _, ok := m["optional"]; !ok {
+		m["optional"] = false
+	}
+	if _, ok := m["scope"]; !ok {
+		m["scope"] = ScopeGlobal
+	}
+	return ifaceSchema.Coerce(m, path)
+}
+
+var ifaceSchema = schema.FieldMap(
+	schema.Fields{
+		"interface": schema.String(),
+		"limit":     schema.OneOf(schema.Const(nil), schema.Int()),
+		"scope":     schema.OneOf(schema.Const(ScopeGlobal), schema.Const(ScopeContainer)),
+		"optional":  schema.Bool(),
+	},
+	schema.Optional{"scope"},
+)
+
+var charmSchema = schema.FieldMap(
+	schema.Fields{
+		"name":        schema.String(),
+		"summary":     schema.String(),
+		"description": schema.String(),
+		"peers":       schema.Map(schema.String(), ifaceExpander(1)),
+		"provides":    schema.Map(schema.String(), ifaceExpander(nil)),
+		"requires":    schema.Map(schema.String(), ifaceExpander(1)),
+		"revision":    schema.Int(), // Obsolete
+		"subordinate": schema.Bool(),
+	},
+	schema.Optional{"provides", "requires", "peers", "revision", "subordinate"},
+)
 
=== added file 'charm/meta_test.go.OTHER'
--- charm/meta_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/meta_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,137 @@
+package charm_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/schema"
+	"launchpad.net/juju-core/juju/testing"
+	"os"
+	"path/filepath"
+)
+
+func repoMeta(name string) io.Reader {
+	charmDir := testing.Charms.DirPath(name)
+	file, err := os.Open(filepath.Join(charmDir, "metadata.yaml"))
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewBuffer(data)
+}
+
+type MetaSuite struct{}
+
+var _ = Suite(&MetaSuite{})
+
+func (s *MetaSuite) TestReadMeta(c *C) {
+	meta, err := charm.ReadMeta(repoMeta("dummy"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Name, Equals, "dummy")
+	c.Assert(meta.Summary, Equals, "That's a dummy charm.")
+	c.Assert(meta.Description, Equals,
+		"This is a longer description which\npotentially contains multiple lines.\n")
+	c.Assert(meta.OldRevision, Equals, 0)
+	c.Assert(meta.Subordinate, Equals, false)
+}
+
+func (s *MetaSuite) TestSubordinate(c *C) {
+	meta, err := charm.ReadMeta(repoMeta("logging"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Subordinate, Equals, true)
+}
+
+func (s *MetaSuite) TestSubordinateWithoutContainerRelation(c *C) {
+	r := repoMeta("dummy")
+	hackYaml := ReadYaml(r)
+	hackYaml["subordinate"] = true
+	_, err := charm.ReadMeta(hackYaml.Reader())
+	c.Assert(err, ErrorMatches, "subordinate charm \"dummy\" lacks requires relation with container scope")
+}
+
+func (s *MetaSuite) TestScopeConstraint(c *C) {
+	meta, err := charm.ReadMeta(repoMeta("logging"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["logging-client"].Scope, Equals, charm.ScopeGlobal)
+	c.Assert(meta.Requires["logging-directory"].Scope, Equals, charm.ScopeContainer)
+	c.Assert(meta.Subordinate, Equals, true)
+}
+
+func (s *MetaSuite) TestParseMetaRelations(c *C) {
+	meta, err := charm.ReadMeta(repoMeta("mysql"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["server"], Equals, charm.Relation{Interface: "mysql", Scope: charm.ScopeGlobal})
+	c.Assert(meta.Requires, IsNil)
+	c.Assert(meta.Peers, IsNil)
+
+	meta, err = charm.ReadMeta(repoMeta("riak"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["endpoint"], Equals, charm.Relation{Interface: "http", Scope: charm.ScopeGlobal})
+	c.Assert(meta.Provides["admin"], Equals, charm.Relation{Interface: "http", Scope: charm.ScopeGlobal})
+	c.Assert(meta.Peers["ring"], Equals, charm.Relation{Interface: "riak", Limit: 1, Scope: charm.ScopeGlobal})
+	c.Assert(meta.Requires, IsNil)
+
+	meta, err = charm.ReadMeta(repoMeta("wordpress"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["url"], Equals, charm.Relation{Interface: "http", Scope: charm.ScopeGlobal})
+	c.Assert(meta.Requires["db"], Equals, charm.Relation{Interface: "mysql", Limit: 1, Scope: charm.ScopeGlobal})
+	c.Assert(meta.Requires["cache"], Equals, charm.Relation{Interface: "varnish", Limit: 2, Optional: true, Scope: charm.ScopeGlobal})
+	c.Assert(meta.Peers, IsNil)
+
+}
+
+// Test rewriting of a given interface specification into long form.
+//
+// InterfaceExpander uses `coerce` to do one of two things:
+//
+//   - Rewrite shorthand to the long form used for actual storage
+//   - Fills in defaults, including a configurable `limit`
+//
+// This test ensures test coverage on each of these branches, along
+// with ensuring the conversion object properly raises SchemaError
+// exceptions on invalid data.
+func (s *MetaSuite) TestIfaceExpander(c *C) {
+	e := charm.IfaceExpander(nil)
+
+	path := []string{"<pa", "th>"}
+
+	// Shorthand is properly rewritten
+	v, err := e.Coerce("http", path)
+	c.Assert(err, IsNil)
+	c.Assert(v, DeepEquals, schema.MapType{"interface": "http", "limit": nil, "optional": false, "scope": charm.ScopeGlobal})
+
+	// Defaults are properly applied
+	v, err = e.Coerce(schema.MapType{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, DeepEquals, schema.MapType{"interface": "http", "limit": nil, "optional": false, "scope": charm.ScopeGlobal})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "limit": 2}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, DeepEquals, schema.MapType{"interface": "http", "limit": int64(2), "optional": false, "scope": charm.ScopeGlobal})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "optional": true}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, DeepEquals, schema.MapType{"interface": "http", "limit": nil, "optional": true, "scope": charm.ScopeGlobal})
+
+	// Invalid data raises an error.
+	v, err = e.Coerce(42, path)
+	c.Assert(err, ErrorMatches, "<path>: expected map, got 42")
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "optional": nil}, path)
+	c.Assert(err, ErrorMatches, "<path>.optional: expected bool, got nothing")
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "limit": "none, really"}, path)
+	c.Assert(err, ErrorMatches, "<path>.limit: unsupported value")
+
+	// Can change default limit
+	e = charm.IfaceExpander(1)
+	v, err = e.Coerce(schema.MapType{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, DeepEquals, schema.MapType{"interface": "http", "limit": int64(1), "optional": false, "scope": charm.ScopeGlobal})
+}
 
=== added file 'charm/repo.go.OTHER'
--- charm/repo.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/repo.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,226 @@
+package charm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"launchpad.net/juju-core/juju/log"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// InfoResponse is sent by the charm store in response to charm-info requests.
+type InfoResponse struct {
+	Revision int      `json:"revision"` // Zero is valid. Can't omitempty.
+	Sha256   string   `json:"sha256,omitempty"`
+	Errors   []string `json:"errors,omitempty"`
+	Warnings []string `json:"warnings,omitempty"`
+}
+
+// Repository respresents a collection of charms.
+type Repository interface {
+	Get(curl *URL) (Charm, error)
+	Latest(curl *URL) (int, error)
+}
+
+// store is a Repository that talks to the juju charm server (in ../store).
+type store struct {
+	baseURL   string
+	cachePath string
+}
+
+const (
+	storeURL  = "https://store.juju.ubuntu.com"
+	cachePath = "$HOME/.juju/cache"
+)
+
+// Store returns a Repository that provides access to the juju charm store.
+func Store() Repository {
+	return &store{storeURL, os.ExpandEnv(cachePath)}
+}
+
+// info returns the revision and SHA256 digest of the charm referenced by curl.
+func (s *store) info(curl *URL) (rev int, digest string, err error) {
+	key := curl.String()
+	resp, err := http.Get(s.baseURL + "/charm-info?charms=" + url.QueryEscape(key))
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return
+	}
+	infos := make(map[string]*InfoResponse)
+	if err = json.Unmarshal(body, &infos); err != nil {
+		return
+	}
+	info, found := infos[key]
+	if !found {
+		err = fmt.Errorf("charm: charm store returned response without charm %q", key)
+		return
+	}
+	for _, w := range info.Warnings {
+		log.Printf("WARNING: charm store reports for %q: %s", key, w)
+	}
+	if info.Errors != nil {
+		err = fmt.Errorf(
+			"charm info errors for %q: %s", key, strings.Join(info.Errors, "; "),
+		)
+		return
+	}
+	return info.Revision, info.Sha256, nil
+}
+
+// Latest returns the latest revision of the charm referenced by curl, regardless
+// of the revision set on curl itself.
+func (s *store) Latest(curl *URL) (int, error) {
+	rev, _, err := s.info(curl.WithRevision(-1))
+	return rev, err
+}
+
+// verify returns an error unless a file exists at path with a hex-encoded
+// SHA256 matching digest.
+func verify(path, digest string) error {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	h := sha256.New()
+	h.Write(b)
+	if hex.EncodeToString(h.Sum(nil)) != digest {
+		return fmt.Errorf("bad SHA256 of %q", path)
+	}
+	return nil
+}
+
+// Get returns the charm referenced by curl.
+func (s *store) Get(curl *URL) (Charm, error) {
+	if err := os.MkdirAll(s.cachePath, 0755); err != nil {
+		return nil, err
+	}
+	rev, digest, err := s.info(curl)
+	if err != nil {
+		return nil, err
+	}
+	if curl.Revision == -1 {
+		curl = curl.WithRevision(rev)
+	} else if curl.Revision != rev {
+		return nil, fmt.Errorf("charm: store returned charm with wrong revision for %q", curl.String())
+	}
+	path := filepath.Join(s.cachePath, Quote(curl.String())+".charm")
+	if verify(path, digest) != nil {
+		resp, err := http.Get(s.baseURL + "/charm/" + url.QueryEscape(curl.Path()))
+		if err != nil {
+			return nil, err
+		}
+		defer resp.Body.Close()
+		f, err := ioutil.TempFile(s.cachePath, "charm-download")
+		if err != nil {
+			return nil, err
+		}
+		dlPath := f.Name()
+		_, err = io.Copy(f, resp.Body)
+		if cerr := f.Close(); err == nil {
+			err = cerr
+		}
+		if err != nil {
+			os.Remove(dlPath)
+			return nil, err
+		}
+		if err := os.Rename(dlPath, path); err != nil {
+			return nil, err
+		}
+	}
+	if err := verify(path, digest); err != nil {
+		return nil, err
+	}
+	return ReadBundle(path)
+}
+
+// LocalRepository represents a local directory containing subdirectories
+// named after an Ubuntu series, each of which contains charms targeted for
+// that series. For example:
+//
+//   /path/to/repository/oneiric/mongodb/
+//   /path/to/repository/precise/mongodb.charm
+//   /path/to/repository/precise/wordpress/
+type LocalRepository struct {
+	Path string
+}
+
+// Latest returns the latest revision of the charm referenced by curl, regardless
+// of the revision set on curl itself.
+func (r *LocalRepository) Latest(curl *URL) (int, error) {
+	ch, err := r.Get(curl.WithRevision(-1))
+	if err != nil {
+		return 0, err
+	}
+	return ch.Revision(), nil
+}
+
+func repoNotFound(path string) error {
+	return fmt.Errorf("no repository found at %q", path)
+}
+
+func charmNotFound(curl *URL) error {
+	return fmt.Errorf("no charms found matching %q", curl)
+}
+
+func mightBeCharm(info os.FileInfo) bool {
+	if info.IsDir() {
+		return !strings.HasPrefix(info.Name(), ".")
+	}
+	return strings.HasSuffix(info.Name(), ".charm")
+}
+
+// Get returns a charm matching curl, if one exists. If curl has a revision of
+// -1, it returns the latest charm that matches curl. If multiple candidates
+// satisfy the foregoing, the first one encountered will be returned.
+func (r *LocalRepository) Get(curl *URL) (Charm, error) {
+	if curl.Schema != "local" {
+		return nil, fmt.Errorf("local repository got URL with non-local schema: %q", curl)
+	}
+	info, err := os.Stat(r.Path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			err = repoNotFound(r.Path)
+		}
+		return nil, err
+	}
+	if !info.IsDir() {
+		return nil, repoNotFound(r.Path)
+	}
+	path := filepath.Join(r.Path, curl.Series)
+	infos, err := ioutil.ReadDir(path)
+	if err != nil {
+		return nil, charmNotFound(curl)
+	}
+	var latest Charm
+	for _, info := range infos {
+		if !mightBeCharm(info) {
+			continue
+		}
+		chPath := filepath.Join(path, info.Name())
+		if ch, err := Read(chPath); err != nil {
+			log.Printf("WARNING: failed to load charm at %q: %s", chPath, err)
+		} else if ch.Meta().Name == curl.Name {
+			if ch.Revision() == curl.Revision {
+				return ch, nil
+			}
+			if latest == nil || ch.Revision() > latest.Revision() {
+				latest = ch
+			}
+		}
+	}
+	if curl.Revision == -1 && latest != nil {
+		return latest, nil
+	}
+	return nil, charmNotFound(curl)
+}
 
=== added file 'charm/repo_test.go.OTHER'
--- charm/repo_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/repo_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,339 @@
+package charm_test
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/log"
+	"launchpad.net/juju-core/juju/testing"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+type MockStore struct {
+	mux          *http.ServeMux
+	lis          net.Listener
+	bundleBytes  []byte
+	bundleSha256 string
+	downloads    []*charm.URL
+}
+
+func NewMockStore(c *C) *MockStore {
+	s := &MockStore{}
+	bytes, err := ioutil.ReadFile(testing.Charms.BundlePath(c.MkDir(), "dummy"))
+	c.Assert(err, IsNil)
+	s.bundleBytes = bytes
+	h := sha256.New()
+	h.Write(bytes)
+	s.bundleSha256 = hex.EncodeToString(h.Sum(nil))
+	s.mux = http.NewServeMux()
+	s.mux.HandleFunc("/charm-info", func(w http.ResponseWriter, r *http.Request) {
+		s.ServeInfo(w, r)
+	})
+	s.mux.HandleFunc("/charm/", func(w http.ResponseWriter, r *http.Request) {
+		s.ServeCharm(w, r)
+	})
+	lis, err := net.Listen("tcp", "127.0.0.1:4444")
+	c.Assert(err, IsNil)
+	s.lis = lis
+	go http.Serve(s.lis, s)
+	return s
+}
+
+func (s *MockStore) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.mux.ServeHTTP(w, r)
+}
+
+func (s *MockStore) ServeInfo(w http.ResponseWriter, r *http.Request) {
+	r.ParseForm()
+	response := map[string]*charm.InfoResponse{}
+	for _, url := range r.Form["charms"] {
+		cr := &charm.InfoResponse{}
+		response[url] = cr
+		curl := charm.MustParseURL(url)
+		switch curl.Name {
+		case "borken":
+			cr.Errors = append(cr.Errors, "badness")
+			continue
+		case "unwise":
+			cr.Warnings = append(cr.Warnings, "foolishness")
+			fallthrough
+		default:
+			if curl.Revision == -1 {
+				cr.Revision = 23
+			} else {
+				cr.Revision = curl.Revision
+			}
+			cr.Sha256 = s.bundleSha256
+		}
+	}
+	data, err := json.Marshal(response)
+	if err != nil {
+		panic(err)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	_, err = w.Write(data)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (s *MockStore) ServeCharm(w http.ResponseWriter, r *http.Request) {
+	curl := charm.MustParseURL("cs:" + r.URL.Path[len("/charm/"):])
+	s.downloads = append(s.downloads, curl)
+	w.Header().Set("Connection", "close")
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Header().Set("Content-Length", strconv.Itoa(len(s.bundleBytes)))
+	_, err := w.Write(s.bundleBytes)
+	if err != nil {
+		panic(err)
+	}
+}
+
+type StoreSuite struct {
+	server *MockStore
+	store  charm.Repository
+	cache  string
+}
+
+var _ = Suite(&StoreSuite{})
+
+func (s *StoreSuite) SetUpSuite(c *C) {
+	s.server = NewMockStore(c)
+}
+
+func (s *StoreSuite) SetUpTest(c *C) {
+	s.cache = c.MkDir()
+	s.store = charm.NewStore("http://127.0.0.1:4444", s.cache)
+	s.server.downloads = nil
+}
+
+func (s *StoreSuite) TearDownSuite(c *C) {
+	s.server.lis.Close()
+}
+
+func (s *StoreSuite) TestError(c *C) {
+	curl := charm.MustParseURL("cs:series/borken")
+	expect := `charm info errors for "cs:series/borken": badness`
+	_, err := s.store.Latest(curl)
+	c.Assert(err, ErrorMatches, expect)
+	_, err = s.store.Get(curl)
+	c.Assert(err, ErrorMatches, expect)
+}
+
+func (s *StoreSuite) TestWarning(c *C) {
+	orig := log.Target
+	log.Target = c
+	defer func() { log.Target = orig }()
+	curl := charm.MustParseURL("cs:series/unwise")
+	expect := `.* JUJU WARNING: charm store reports for "cs:series/unwise": foolishness` + "\n"
+	r, err := s.store.Latest(curl)
+	c.Assert(r, Equals, 23)
+	c.Assert(err, IsNil)
+	c.Assert(c.GetTestLog(), Matches, expect)
+	ch, err := s.store.Get(curl)
+	c.Assert(ch, NotNil)
+	c.Assert(err, IsNil)
+	c.Assert(c.GetTestLog(), Matches, expect+expect)
+}
+
+func (s *StoreSuite) TestLatest(c *C) {
+	for _, str := range []string{
+		"cs:series/blah",
+		"cs:series/blah-2",
+		"cs:series/blah-99",
+	} {
+		r, err := s.store.Latest(charm.MustParseURL(str))
+		c.Assert(r, Equals, 23)
+		c.Assert(err, IsNil)
+	}
+}
+
+func (s *StoreSuite) assertCached(c *C, curl *charm.URL) {
+	s.server.downloads = nil
+	ch, err := s.store.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch, NotNil)
+	c.Assert(s.server.downloads, IsNil)
+}
+
+func (s *StoreSuite) TestGetCacheImplicitRevision(c *C) {
+	os.RemoveAll(s.cache)
+	base := "cs:series/blah"
+	curl := charm.MustParseURL(base)
+	revCurl := charm.MustParseURL(base + "-23")
+	ch, err := s.store.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch, NotNil)
+	c.Assert(s.server.downloads, DeepEquals, []*charm.URL{revCurl})
+	s.assertCached(c, curl)
+	s.assertCached(c, revCurl)
+}
+
+func (s *StoreSuite) TestGetCacheExplicitRevision(c *C) {
+	os.RemoveAll(s.cache)
+	base := "cs:series/blah-12"
+	curl := charm.MustParseURL(base)
+	ch, err := s.store.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch, NotNil)
+	c.Assert(s.server.downloads, DeepEquals, []*charm.URL{curl})
+	s.assertCached(c, curl)
+}
+
+func (s *StoreSuite) TestGetBadCache(c *C) {
+	base := "cs:series/blah"
+	curl := charm.MustParseURL(base)
+	revCurl := charm.MustParseURL(base + "-23")
+	name := charm.Quote(revCurl.String()) + ".charm"
+	err := ioutil.WriteFile(filepath.Join(s.cache, name), nil, 0666)
+	c.Assert(err, IsNil)
+	ch, err := s.store.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch, NotNil)
+	c.Assert(s.server.downloads, DeepEquals, []*charm.URL{revCurl})
+	s.assertCached(c, curl)
+	s.assertCached(c, revCurl)
+}
+
+type LocalRepoSuite struct {
+	testing.LoggingSuite
+	repo       *charm.LocalRepository
+	seriesPath string
+}
+
+var _ = Suite(&LocalRepoSuite{})
+
+func (s *LocalRepoSuite) SetUpTest(c *C) {
+	s.LoggingSuite.SetUpTest(c)
+	root := c.MkDir()
+	s.repo = &charm.LocalRepository{root}
+	s.seriesPath = filepath.Join(root, "series")
+	c.Assert(os.Mkdir(s.seriesPath, 0777), IsNil)
+}
+
+func (s *LocalRepoSuite) addBundle(name string) string {
+	return testing.Charms.BundlePath(s.seriesPath, name)
+}
+
+func (s *LocalRepoSuite) addDir(name string) string {
+	return testing.Charms.ClonedDirPath(s.seriesPath, name)
+}
+
+func (s *LocalRepoSuite) TestMissingCharm(c *C) {
+	_, err := s.repo.Latest(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no charms found matching "local:series/zebra"`)
+	_, err = s.repo.Get(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no charms found matching "local:series/zebra"`)
+	_, err = s.repo.Latest(charm.MustParseURL("local:badseries/zebra"))
+	c.Assert(err, ErrorMatches, `no charms found matching "local:badseries/zebra"`)
+	_, err = s.repo.Get(charm.MustParseURL("local:badseries/zebra"))
+	c.Assert(err, ErrorMatches, `no charms found matching "local:badseries/zebra"`)
+}
+
+func (s *LocalRepoSuite) TestMissingRepo(c *C) {
+	c.Assert(os.RemoveAll(s.repo.Path), IsNil)
+	_, err := s.repo.Latest(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no repository found at ".*"`)
+	_, err = s.repo.Get(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no repository found at ".*"`)
+	c.Assert(ioutil.WriteFile(s.repo.Path, nil, 0666), IsNil)
+	_, err = s.repo.Latest(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no repository found at ".*"`)
+	_, err = s.repo.Get(charm.MustParseURL("local:series/zebra"))
+	c.Assert(err, ErrorMatches, `no repository found at ".*"`)
+}
+
+func (s *LocalRepoSuite) TestMultipleVersions(c *C) {
+	curl := charm.MustParseURL("local:series/sample")
+	s.addDir("old")
+	rev, err := s.repo.Latest(curl)
+	c.Assert(err, IsNil)
+	c.Assert(rev, Equals, 1)
+	ch, err := s.repo.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Revision(), Equals, 1)
+
+	s.addDir("new")
+	rev, err = s.repo.Latest(curl)
+	c.Assert(err, IsNil)
+	c.Assert(rev, Equals, 2)
+	ch, err = s.repo.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Revision(), Equals, 2)
+
+	revCurl := curl.WithRevision(1)
+	rev, err = s.repo.Latest(revCurl)
+	c.Assert(err, IsNil)
+	c.Assert(rev, Equals, 2)
+	ch, err = s.repo.Get(revCurl)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Revision(), Equals, 1)
+
+	badRevCurl := curl.WithRevision(33)
+	rev, err = s.repo.Latest(badRevCurl)
+	c.Assert(err, IsNil)
+	c.Assert(rev, Equals, 2)
+	ch, err = s.repo.Get(badRevCurl)
+	c.Assert(err, ErrorMatches, `no charms found matching "local:series/sample-33"`)
+}
+
+func (s *LocalRepoSuite) TestBundle(c *C) {
+	curl := charm.MustParseURL("local:series/dummy")
+	s.addBundle("dummy")
+
+	rev, err := s.repo.Latest(curl)
+	c.Assert(err, IsNil)
+	c.Assert(rev, Equals, 1)
+	ch, err := s.repo.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Revision(), Equals, 1)
+}
+
+func (s *LocalRepoSuite) TestLogsErrors(c *C) {
+	err := ioutil.WriteFile(filepath.Join(s.seriesPath, "blah.charm"), nil, 0666)
+	c.Assert(err, IsNil)
+	err = os.Mkdir(filepath.Join(s.seriesPath, "blah"), 0666)
+	c.Assert(err, IsNil)
+	samplePath := s.addDir("new")
+	gibberish := []byte("don't parse me by")
+	err = ioutil.WriteFile(filepath.Join(samplePath, "metadata.yaml"), gibberish, 0666)
+	c.Assert(err, IsNil)
+
+	curl := charm.MustParseURL("local:series/dummy")
+	s.addDir("dummy")
+	ch, err := s.repo.Get(curl)
+	c.Assert(err, IsNil)
+	c.Assert(ch.Revision(), Equals, 1)
+	c.Assert(c.GetTestLog(), Matches, `
+.* JUJU WARNING: failed to load charm at ".*/series/blah": .*
+.* JUJU WARNING: failed to load charm at ".*/series/blah.charm": .*
+.* JUJU WARNING: failed to load charm at ".*/series/new": .*
+`[1:])
+}
+
+func renameSibling(c *C, path, name string) {
+	c.Assert(os.Rename(path, filepath.Join(filepath.Dir(path), name)), IsNil)
+}
+
+func (s *LocalRepoSuite) TestIgnoresUnpromisingNames(c *C) {
+	err := ioutil.WriteFile(filepath.Join(s.seriesPath, "blah.notacharm"), nil, 0666)
+	c.Assert(err, IsNil)
+	err = os.Mkdir(filepath.Join(s.seriesPath, ".blah"), 0666)
+	c.Assert(err, IsNil)
+	renameSibling(c, s.addDir("dummy"), ".dummy")
+	renameSibling(c, s.addBundle("dummy"), "dummy.notacharm")
+	curl := charm.MustParseURL("local:series/dummy")
+
+	_, err = s.repo.Get(curl)
+	c.Assert(err, ErrorMatches, `no charms found matching "local:series/dummy"`)
+	_, err = s.repo.Latest(curl)
+	c.Assert(err, ErrorMatches, `no charms found matching "local:series/dummy"`)
+	c.Assert(c.GetTestLog(), Equals, "")
+}
 
=== added file 'charm/url_test.go.OTHER'
--- charm/url_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ charm/url_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,126 @@
+package charm_test
+
+import (
+	"fmt"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/charm"
+)
+
+type URLSuite struct{}
+
+var _ = Suite(&URLSuite{})
+
+var urlTests = []struct {
+	s, err string
+	url    *charm.URL
+}{
+	{"cs:~user/series/name", "", &charm.URL{"cs", "user", "series", "name", -1}},
+	{"cs:~user/series/name-0", "", &charm.URL{"cs", "user", "series", "name", 0}},
+	{"cs:series/name", "", &charm.URL{"cs", "", "series", "name", -1}},
+	{"cs:series/name-42", "", &charm.URL{"cs", "", "series", "name", 42}},
+	{"local:series/name-1", "", &charm.URL{"local", "", "series", "name", 1}},
+	{"local:series/name", "", &charm.URL{"local", "", "series", "name", -1}},
+	{"local:series/n0-0n-n0", "", &charm.URL{"local", "", "series", "n0-0n-n0", -1}},
+
+	{"bs:~user/series/name-1", "charm URL has invalid schema: .*", nil},
+	{"cs:~1/series/name-1", "charm URL has invalid user name: .*", nil},
+	{"cs:~user/1/name-1", "charm URL has invalid series: .*", nil},
+	{"cs:~user/series/name-1-2", "charm URL has invalid charm name: .*", nil},
+	{"cs:~user/series/name-1-name-2", "charm URL has invalid charm name: .*", nil},
+	{"cs:~user/series/name--name-2", "charm URL has invalid charm name: .*", nil},
+	{"cs:~user/series/huh/name-1", "charm URL has invalid form: .*", nil},
+	{"cs:~user/name", "charm URL without series: .*", nil},
+	{"cs:name", "charm URL without series: .*", nil},
+	{"local:~user/series/name", "local charm URL with user name: .*", nil},
+	{"local:~user/name", "local charm URL with user name: .*", nil},
+	{"local:name", "charm URL without series: .*", nil},
+}
+
+func (s *URLSuite) TestParseURL(c *C) {
+	for _, t := range urlTests {
+		url, err := charm.ParseURL(t.s)
+		comment := Commentf("ParseURL(%q)", t.s)
+		if t.err != "" {
+			c.Check(err.Error(), Matches, t.err, comment)
+		} else {
+			c.Check(url, DeepEquals, t.url, comment)
+			c.Check(t.url.String(), Equals, t.s)
+		}
+	}
+}
+
+var inferTests = []struct {
+	vague, exact string
+}{
+	{"foo", "cs:defseries/foo"},
+	{"foo-1", "cs:defseries/foo-1"},
+	{"n0-n0-n0", "cs:defseries/n0-n0-n0"},
+	{"cs:foo", "cs:defseries/foo"},
+	{"local:foo", "local:defseries/foo"},
+	{"series/foo", "cs:series/foo"},
+	{"cs:series/foo", "cs:series/foo"},
+	{"local:series/foo", "local:series/foo"},
+	{"cs:~user/foo", "cs:~user/defseries/foo"},
+	{"cs:~user/series/foo", "cs:~user/series/foo"},
+	{"local:~user/series/foo", "local:~user/series/foo"},
+	{"bs:foo", "bs:defseries/foo"},
+	{"cs:~1/foo", "cs:~1/defseries/foo"},
+	{"cs:foo-1-2", "cs:defseries/foo-1-2"},
+}
+
+func (s *URLSuite) TestInferURL(c *C) {
+	for _, t := range inferTests {
+		comment := Commentf("InferURL(%q, %q)", t.vague, "defseries")
+		inferred, ierr := charm.InferURL(t.vague, "defseries")
+		parsed, perr := charm.ParseURL(t.exact)
+		if parsed != nil {
+			c.Check(inferred, DeepEquals, parsed, comment)
+		} else {
+			expect := perr.Error()
+			if t.vague != t.exact {
+				expect = fmt.Sprintf("%s (URL inferred from %q)", expect, t.vague)
+			}
+			c.Check(ierr.Error(), Equals, expect, comment)
+		}
+	}
+	u, err := charm.InferURL("~blah", "defseries")
+	c.Assert(u, IsNil)
+	c.Assert(err, ErrorMatches, "cannot infer charm URL with user but no schema: .*")
+}
+
+func (s *URLSuite) TestMustParseURL(c *C) {
+	url := charm.MustParseURL("cs:series/name")
+	c.Assert(url, DeepEquals, &charm.URL{"cs", "", "series", "name", -1})
+	f := func() { charm.MustParseURL("local:name") }
+	c.Assert(f, PanicMatches, "charm URL without series: .*")
+}
+
+func (s *URLSuite) TestWithRevision(c *C) {
+	url := charm.MustParseURL("cs:series/name")
+	other := url.WithRevision(1)
+	c.Assert(url, DeepEquals, &charm.URL{"cs", "", "series", "name", -1})
+	c.Assert(other, DeepEquals, &charm.URL{"cs", "", "series", "name", 1})
+
+	// Should always copy. The opposite behavior is error prone.
+	c.Assert(other.WithRevision(1), Not(Equals), other)
+	c.Assert(other.WithRevision(1), DeepEquals, other)
+}
+
+type QuoteSuite struct{}
+
+var _ = Suite(&QuoteSuite{})
+
+func (s *QuoteSuite) TestUnmodified(c *C) {
+	// Check that a string containing only valid
+	// chars stays unmodified.
+	in := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-"
+	out := charm.Quote(in)
+	c.Assert(out, Equals, in)
+}
+
+func (s *QuoteSuite) TestQuote(c *C) {
+	// Check that invalid chars are translated correctly.
+	in := "hello_there/how'are~you-today.sir"
+	out := charm.Quote(in)
+	c.Assert(out, Equals, "hello_5f_there_2f_how_27_are_7e_you-today.sir")
+}
 
=== added directory 'cloudinit'
=== added file 'cloudinit/cloudinit_test.go.OTHER'
--- cloudinit/cloudinit_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cloudinit/cloudinit_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,228 @@
+package cloudinit_test
+
+import (
+	"fmt"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cloudinit"
+	"testing"
+)
+
+// TODO integration tests, but how?
+
+type S struct{}
+
+var _ = Suite(S{})
+
+func Test1(t *testing.T) {
+	TestingT(t)
+}
+
+var ctests = []struct {
+	name      string
+	expect    string
+	setOption func(cfg *cloudinit.Config)
+}{
+	{
+		"User",
+		"user: me\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetUser("me")
+		},
+	},
+	{
+		"AptUpgrade",
+		"apt_upgrade: true\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetAptUpgrade(true)
+		},
+	},
+	{
+		"AptUpdate",
+		"apt_update: true\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetAptUpdate(true)
+		},
+	},
+	{
+		"AptMirror",
+		"apt_mirror: http://foo.com\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetAptMirror("http://foo.com")
+		},
+	},
+	{
+		"AptPreserveSourcesList",
+		"apt_mirror: true\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetAptPreserveSourcesList(true)
+		},
+	},
+	{
+		"DebconfSelections",
+		"debconf_selections: '# Force debconf priority to critical.\n\n  debconf debconf/priority select critical\n\n'\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetDebconfSelections("# Force debconf priority to critical.\ndebconf debconf/priority select critical\n")
+		},
+	},
+	{
+		"DisableEC2Metadata",
+		"disable_ec2_metadata: true\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetDisableEC2Metadata(true)
+		},
+	},
+	{
+		"FinalMessage",
+		"final_message: goodbye\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetFinalMessage("goodbye")
+		},
+	},
+	{
+		"Locale",
+		"locale: en_us\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetLocale("en_us")
+		},
+	},
+	{
+		"DisableRoot",
+		"disable_root: false\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetDisableRoot(false)
+		},
+	},
+	{
+		"SSHAuthorizedKeys",
+		"ssh_authorized_keys:\n- key1\n- key2\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHAuthorizedKeys("key1")
+			cfg.AddSSHAuthorizedKeys("key2")
+		},
+	},
+	{
+		"SSHAuthorizedKeys",
+		"ssh_authorized_keys:\n- key1\n- key2\n- key3\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHAuthorizedKeys("#command\nkey1")
+			cfg.AddSSHAuthorizedKeys("key2\n# comment\n\nkey3\n")
+			cfg.AddSSHAuthorizedKeys("")
+		},
+	},
+	{
+		"SSHKeys RSAPrivate",
+		"ssh_keys:\n  rsa_private: key1data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.RSAPrivate, "key1data")
+		},
+	},
+	{
+		"SSHKeys RSAPublic",
+		"ssh_keys:\n  rsa_public: key2data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.RSAPublic, "key2data")
+		},
+	},
+	{
+		"SSHKeys DSAPublic",
+		"ssh_keys:\n  dsa_public: key1data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.DSAPublic, "key1data")
+		},
+	},
+	{
+		"SSHKeys DSAPrivate",
+		"ssh_keys:\n  dsa_private: key2data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.DSAPrivate, "key2data")
+		},
+	},
+	{
+		"Output",
+		"output:\n  all:\n  - '>foo'\n  - '|bar'\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetOutput("all", ">foo", "|bar")
+		},
+	},
+	{
+		"Output",
+		"output:\n  all: '>foo'\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetOutput(cloudinit.OutAll, ">foo", "")
+		},
+	},
+	{
+		"AptSources",
+		"apt_sources:\n- source: keyName\n  key: someKey\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddAptSource("keyName", "someKey")
+		},
+	},
+	{
+		"AptSources",
+		"apt_sources:\n- source: keyName\n  keyid: someKey\n  keyserver: foo.com\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddAptSourceWithKeyId("keyName", "someKey", "foo.com")
+		},
+	},
+	{
+		"Packages",
+		"packages:\n- juju\n- ubuntu\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddPackage("juju")
+			cfg.AddPackage("ubuntu")
+		},
+	},
+	{
+		"BootCmd",
+		"bootcmd:\n- ls > /dev\n- - ls\n  - '>with space'\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddBootCmd("ls > /dev")
+			cfg.AddBootCmdArgs("ls", ">with space")
+		},
+	},
+	{
+		"Mounts",
+		"mounts:\n- - x\n  - \"y\"\n- - z\n  - w\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddMount("x", "y")
+			cfg.AddMount("z", "w")
+		},
+	},
+	{
+		"Attr",
+		"arbitraryAttr: someValue\n",
+		func(cfg *cloudinit.Config) {
+			cfg.SetAttr("arbitraryAttr", "someValue")
+		},
+	},
+}
+
+const header = "#cloud-config\n"
+
+func (S) TestOutput(c *C) {
+	for _, t := range ctests {
+		cfg := cloudinit.New()
+		t.setOption(cfg)
+		data, err := cfg.Render()
+		c.Assert(err, IsNil)
+		c.Assert(data, NotNil)
+		c.Assert(string(data), Equals, header+t.expect, Commentf("test %q output differs", t.name))
+	}
+}
+
+//#cloud-config
+//packages:
+//- juju
+//- ubuntu
+func ExampleConfig() {
+	cfg := cloudinit.New()
+	cfg.AddPackage("juju")
+	cfg.AddPackage("ubuntu")
+	data, err := cfg.Render()
+	if err != nil {
+		fmt.Printf("render error: %v", err)
+		return
+	}
+	fmt.Printf("%s", data)
+}
 
=== added directory 'cmd'
=== added file 'cmd/cmd.go.OTHER'
--- cmd/cmd.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/cmd.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,139 @@
+package cmd
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/log"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// ErrSilent can be returned from Run to signal that Main should exit with
+// code 1 without producing error output.
+var ErrSilent = errors.New("cmd: error out silently")
+
+// Command is implemented by types that interpret command-line arguments.
+type Command interface {
+	// Info returns information about the Command.
+	Info() *Info
+
+	// Init initializes the Command before running. The command may add options
+	// to f before processing args.
+	Init(f *gnuflag.FlagSet, args []string) error
+
+	// Run will execute the Command as directed by the options and positional
+	// arguments passed to Init.
+	Run(ctx *Context) error
+}
+
+// Context represents the run context of a Command. Command implementations
+// should interpret file names relative to Dir (see AbsPath below), and print
+// output and errors to Stdout and Stderr respectively.
+type Context struct {
+	Dir    string
+	Stdout io.Writer
+	Stderr io.Writer
+}
+
+// AbsPath returns an absolute representation of path, with relative paths
+// interpreted as relative to ctx.Dir.
+func (ctx *Context) AbsPath(path string) string {
+	if filepath.IsAbs(path) {
+		return path
+	}
+	return filepath.Join(ctx.Dir, path)
+}
+
+// Info holds some of the usage documentation of a Command.
+type Info struct {
+	// Name is the Command's name.
+	Name string
+
+	// Args describes the command's expected positional arguments.
+	Args string
+
+	// Purpose is a short explanation of the Command's purpose.
+	Purpose string
+
+	// Doc is the long documentation for the Command.
+	Doc string
+}
+
+// Help renders i's content, along with documentation for any
+// flags defined in f. It calls f.SetOutput(ioutil.Discard).
+func (i *Info) Help(f *gnuflag.FlagSet) []byte {
+	buf := &bytes.Buffer{}
+	fmt.Fprintf(buf, "usage: %s", i.Name)
+	hasOptions := false
+	f.VisitAll(func(f *gnuflag.Flag) { hasOptions = true })
+	if hasOptions {
+		fmt.Fprintf(buf, " [options]")
+	}
+	if i.Args != "" {
+		fmt.Fprintf(buf, " %s", i.Args)
+	}
+	fmt.Fprintf(buf, "\n")
+	if i.Purpose != "" {
+		fmt.Fprintf(buf, "purpose: %s\n", i.Purpose)
+	}
+	if hasOptions {
+		fmt.Fprintf(buf, "\noptions:\n")
+		f.SetOutput(buf)
+		f.PrintDefaults()
+	}
+	f.SetOutput(ioutil.Discard)
+	if i.Doc != "" {
+		fmt.Fprintf(buf, "\n%s\n", strings.TrimSpace(i.Doc))
+	}
+	return buf.Bytes()
+}
+
+// Main runs the given Command in the supplied Context with the given
+// arguments, which should not include the command name. It returns a code
+// suitable for passing to os.Exit.
+func Main(c Command, ctx *Context, args []string) int {
+	f := gnuflag.NewFlagSet(c.Info().Name, gnuflag.ContinueOnError)
+	f.SetOutput(ioutil.Discard)
+	if err := c.Init(f, args); err != nil {
+		ctx.Stderr.Write(c.Info().Help(f))
+		if err == gnuflag.ErrHelp {
+			return 0
+		}
+		fmt.Fprintf(ctx.Stderr, "error: %v\n", err)
+		return 2
+	}
+	if err := c.Run(ctx); err != nil {
+		if err != ErrSilent {
+			log.Debugf("%s command failed: %s\n", c.Info().Name, err)
+			fmt.Fprintf(ctx.Stderr, "error: %v\n", err)
+		}
+		return 1
+	}
+	return 0
+}
+
+// DefaultContext returns a Context suitable for use in non-hosted situations.
+func DefaultContext() *Context {
+	dir, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		panic(err)
+	}
+	return &Context{abs, os.Stdout, os.Stderr}
+}
+
+// CheckEmpty is a utility function that returns an error if args is not empty.
+func CheckEmpty(args []string) error {
+	if len(args) != 0 {
+		return fmt.Errorf("unrecognized args: %q", args)
+	}
+	return nil
+}
 
=== added file 'cmd/cmd_test.go.OTHER'
--- cmd/cmd_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/cmd_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,96 @@
+package cmd_test
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"path/filepath"
+	"testing"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type CmdSuite struct{}
+
+var _ = Suite(&CmdSuite{})
+
+func (s *CmdSuite) TestContext(c *C) {
+	ctx := dummyContext(c)
+	c.Assert(ctx.AbsPath("/foo/bar"), Equals, "/foo/bar")
+	c.Assert(ctx.AbsPath("foo/bar"), Equals, filepath.Join(ctx.Dir, "foo/bar"))
+}
+
+func (s *CmdSuite) TestInfo(c *C) {
+	minimal := &TestCommand{Name: "verb", Minimal: true}
+	help := minimal.Info().Help(dummyFlagSet())
+	c.Assert(string(help), Equals, minimalHelp)
+
+	full := &TestCommand{Name: "verb"}
+	f := dummyFlagSet()
+	var ignored string
+	f.StringVar(&ignored, "option", "", "option-doc")
+	help = full.Info().Help(f)
+	c.Assert(string(help), Equals, fullHelp)
+
+	optionInfo := full.Info()
+	optionInfo.Doc = ""
+	help = optionInfo.Help(f)
+	c.Assert(string(help), Equals, optionHelp)
+}
+
+var initErrorTests = []struct {
+	c    *TestCommand
+	help string
+}{
+	{&TestCommand{Name: "verb"}, fullHelp},
+	{&TestCommand{Name: "verb", Minimal: true}, minimalHelp},
+}
+
+func (s *CmdSuite) TestMainInitError(c *C) {
+	for _, t := range initErrorTests {
+		ctx := dummyContext(c)
+		result := cmd.Main(t.c, ctx, []string{"--unknown"})
+		c.Assert(result, Equals, 2)
+		c.Assert(bufferString(ctx.Stdout), Equals, "")
+		expected := t.help + "error: flag provided but not defined: --unknown\n"
+		c.Assert(bufferString(ctx.Stderr), Equals, expected)
+	}
+}
+
+func (s *CmdSuite) TestMainRunError(c *C) {
+	ctx := dummyContext(c)
+	result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "error"})
+	c.Assert(result, Equals, 1)
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	c.Assert(bufferString(ctx.Stderr), Equals, "error: BAM!\n")
+}
+
+func (s *CmdSuite) TestMainRunSilentError(c *C) {
+	ctx := dummyContext(c)
+	result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "silent-error"})
+	c.Assert(result, Equals, 1)
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	c.Assert(bufferString(ctx.Stderr), Equals, "")
+}
+
+func (s *CmdSuite) TestMainSuccess(c *C) {
+	ctx := dummyContext(c)
+	result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "success!"})
+	c.Assert(result, Equals, 0)
+	c.Assert(bufferString(ctx.Stdout), Equals, "success!\n")
+	c.Assert(bufferString(ctx.Stderr), Equals, "")
+}
+
+func (s *CmdSuite) TestMainHelp(c *C) {
+	for _, arg := range []string{"-h", "--help"} {
+		ctx := dummyContext(c)
+		result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{arg})
+		c.Assert(result, Equals, 0)
+		c.Assert(bufferString(ctx.Stdout), Equals, "")
+		c.Assert(bufferString(ctx.Stderr), Equals, fullHelp)
+	}
+}
+
+func (s *CmdSuite) TestCheckEmpty(c *C) {
+	c.Assert(cmd.CheckEmpty(nil), IsNil)
+	c.Assert(cmd.CheckEmpty([]string{"boo!"}), ErrorMatches, `unrecognized args: \["boo!"\]`)
+}
 
=== added directory 'cmd/juju'
=== added file 'cmd/juju/bootstrap.go.OTHER'
--- cmd/juju/bootstrap.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/juju/bootstrap.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/juju"
+)
+
+// BootstrapCommand is responsible for launching the first machine in a juju
+// environment, and setting up everything necessary to continue working.
+type BootstrapCommand struct {
+	EnvName     string
+	UploadTools bool
+}
+
+func (c *BootstrapCommand) Info() *cmd.Info {
+	return &cmd.Info{"bootstrap", "", "start up an environment from scratch", ""}
+}
+
+func (c *BootstrapCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	addEnvironFlags(&c.EnvName, f)
+	f.BoolVar(&c.UploadTools, "upload-tools", false, "upload local version of tools before bootstrapping")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	return cmd.CheckEmpty(f.Args())
+}
+
+// Run connects to the environment specified on the command line and bootstraps
+// a juju in that environment if none already exists.
+func (c *BootstrapCommand) Run(_ *cmd.Context) error {
+	conn, err := juju.NewConn(c.EnvName)
+	if err != nil {
+		return err
+	}
+	return conn.Bootstrap(c.UploadTools)
+}
 
=== added file 'cmd/juju/cmd_test.go.OTHER'
--- cmd/juju/cmd_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/juju/cmd_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,255 @@
+package main
+
+import (
+	"io/ioutil"
+	"launchpad.net/gnuflag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/environs"
+	"launchpad.net/juju-core/juju/environs/dummy"
+	"launchpad.net/juju-core/juju/testing"
+	"os"
+	"path/filepath"
+	"reflect"
+)
+
+type cmdSuite struct {
+	testing.LoggingSuite
+	home string
+}
+
+var _ = Suite(&cmdSuite{})
+
+// N.B. Barking is broken.
+var config = `
+default:
+    peckham
+environments:
+    peckham:
+        type: dummy
+        zookeeper: false
+    walthamstow:
+        type: dummy
+        zookeeper: false
+    barking:
+        type: dummy
+        broken: true
+        zookeeper: false
+`
+
+func (s *cmdSuite) SetUpTest(c *C) {
+	s.LoggingSuite.SetUpTest(c)
+	// Arrange so that the "home" directory points
+	// to a temporary directory containing the config file.
+	s.home = os.Getenv("HOME")
+	dir := c.MkDir()
+	os.Setenv("HOME", dir)
+	err := os.Mkdir(filepath.Join(dir, ".juju"), 0777)
+	c.Assert(err, IsNil)
+	err = ioutil.WriteFile(filepath.Join(dir, ".juju", "environments.yaml"), []byte(config), 0666)
+	c.Assert(err, IsNil)
+}
+
+func (s *cmdSuite) TearDownTest(c *C) {
+	os.Setenv("HOME", s.home)
+
+	dummy.Reset()
+	s.LoggingSuite.TearDownTest(c)
+}
+
+func newFlagSet() *gnuflag.FlagSet {
+	return gnuflag.NewFlagSet("", gnuflag.ContinueOnError)
+}
+
+// testInit checks that a command initialises correctly
+// with the given set of arguments.
+func testInit(c *C, com cmd.Command, args []string, errPat string) {
+	err := com.Init(newFlagSet(), args)
+	if errPat != "" {
+		c.Assert(err, ErrorMatches, errPat)
+	} else {
+		c.Assert(err, IsNil)
+	}
+}
+
+// assertConnName asserts that the Command is using
+// the given environment name.
+// Since every command has a different type,
+// we use reflection to look at the value of the
+// Conn field in the value.
+func assertConnName(c *C, com cmd.Command, name string) {
+	v := reflect.ValueOf(com).Elem().FieldByName("EnvName")
+	c.Assert(v.IsValid(), Equals, true)
+	c.Assert(v.Interface(), Equals, name)
+}
+
+// All members of EnvironmentInitTests are tested for the -environment and -e
+// flags, and that extra arguments will cause parsing to fail.
+var EnvironmentInitTests = []func() (cmd.Command, []string){
+	func() (cmd.Command, []string) { return new(BootstrapCommand), nil },
+	func() (cmd.Command, []string) { return new(DestroyCommand), nil },
+	func() (cmd.Command, []string) {
+		return new(DeployCommand), []string{"charm-name", "service-name"}
+	},
+}
+
+// TestEnvironmentInit tests that all commands which accept
+// the --environment variable initialise their
+// environment name correctly.
+func (*cmdSuite) TestEnvironmentInit(c *C) {
+	for i, cmdFunc := range EnvironmentInitTests {
+		c.Logf("test %d", i)
+		com, args := cmdFunc()
+		testInit(c, com, args, "")
+		assertConnName(c, com, "")
+
+		com, args = cmdFunc()
+		testInit(c, com, append(args, "-e", "walthamstow"), "")
+		assertConnName(c, com, "walthamstow")
+
+		com, args = cmdFunc()
+		testInit(c, com, append(args, "--environment", "walthamstow"), "")
+		assertConnName(c, com, "walthamstow")
+
+		com, args = cmdFunc()
+		testInit(c, com, append(args, "hotdog"), "unrecognized args.*")
+	}
+}
+
+func runCommand(com cmd.Command, args ...string) (opc chan dummy.Operation, errc chan error) {
+	errc = make(chan error, 1)
+	opc = make(chan dummy.Operation)
+	dummy.Reset()
+	dummy.Listen(opc)
+	go func() {
+		// signal that we're done with this ops channel.
+		defer dummy.Listen(nil)
+
+		err := com.Init(newFlagSet(), args)
+		if err != nil {
+			errc <- err
+			return
+		}
+
+		err = com.Run(cmd.DefaultContext())
+		errc <- err
+	}()
+	return
+}
+
+func op(kind dummy.OperationKind, name string) dummy.Operation {
+	return dummy.Operation{
+		Env:  name,
+		Kind: kind,
+	}
+}
+
+func (*cmdSuite) TestBootstrapCommand(c *C) {
+	// normal bootstrap
+	opc, errc := runCommand(new(BootstrapCommand))
+	c.Check(<-opc, Equals, op(dummy.OpBootstrap, "peckham"))
+	c.Check(<-errc, IsNil)
+
+	// bootstrap with tool uploading - checking that a file
+	// is uploaded should be sufficient, as the detailed semantics
+	// of UploadTools are tested in environs.
+	opc, errc = runCommand(new(BootstrapCommand), "--upload-tools")
+	c.Check(<-opc, Equals, op(dummy.OpPutFile, "peckham"))
+	c.Check(<-opc, Equals, op(dummy.OpBootstrap, "peckham"))
+	c.Check(<-errc, IsNil)
+
+	envs, err := environs.ReadEnvirons("")
+	c.Assert(err, IsNil)
+	env, err := envs.Open("peckham")
+	c.Assert(err, IsNil)
+	dir := c.MkDir()
+	err = environs.GetTools(env, dir)
+	c.Assert(err, IsNil)
+
+	// bootstrap with broken environment
+	opc, errc = runCommand(new(BootstrapCommand), "-e", "barking")
+	c.Check((<-opc).Kind, Equals, dummy.OpNone)
+	c.Check(<-errc, ErrorMatches, `broken environment`)
+}
+
+func (*cmdSuite) TestDestroyCommand(c *C) {
+	// normal destroy
+	opc, errc := runCommand(new(DestroyCommand))
+	c.Check(<-opc, Equals, op(dummy.OpDestroy, "peckham"))
+	c.Check(<-errc, IsNil)
+
+	// destroy with broken environment
+	opc, errc = runCommand(new(DestroyCommand), "-e", "barking")
+	c.Check((<-opc).Kind, Equals, dummy.OpNone)
+	c.Check(<-errc, ErrorMatches, `broken environment`)
+}
+
+var deployTests = []struct {
+	args []string
+	com  *DeployCommand
+}{
+	{
+		[]string{"charm-name"},
+		&DeployCommand{},
+	}, {
+		[]string{"charm-name", "service-name"},
+		&DeployCommand{ServiceName: "service-name"},
+	}, {
+		[]string{"--config", "/path/to/config.yaml", "charm-name"},
+		&DeployCommand{ConfPath: "/path/to/config.yaml"},
+	}, {
+		[]string{"--repository", "/path/to/another-repo", "charm-name"},
+		&DeployCommand{RepoPath: "/path/to/another-repo"},
+	}, {
+		[]string{"--upgrade", "charm-name"},
+		&DeployCommand{Upgrade: true},
+	}, {
+		[]string{"-u", "charm-name"},
+		&DeployCommand{Upgrade: true},
+	}, {
+		[]string{"--num-units", "33", "charm-name"},
+		&DeployCommand{NumUnits: 33},
+	}, {
+		[]string{"-n", "104", "charm-name"},
+		&DeployCommand{NumUnits: 104},
+	},
+}
+
+func initExpectations(com *DeployCommand) {
+	if com.CharmName == "" {
+		com.CharmName = "charm-name"
+	}
+	if com.NumUnits == 0 {
+		com.NumUnits = 1
+	}
+	if com.RepoPath == "" {
+		com.RepoPath = "/path/to/repo"
+	}
+}
+
+func initDeployCommand(args ...string) (*DeployCommand, error) {
+	com := &DeployCommand{}
+	return com, com.Init(newFlagSet(), args)
+}
+
+func (*cmdSuite) TestDeployCommandInit(c *C) {
+	defer os.Setenv("JUJU_REPOSITORY", os.Getenv("JUJU_REPOSITORY"))
+	os.Setenv("JUJU_REPOSITORY", "/path/to/repo")
+
+	for _, t := range deployTests {
+		initExpectations(t.com)
+		com, err := initDeployCommand(t.args...)
+		c.Assert(err, IsNil)
+		c.Assert(com, DeepEquals, t.com)
+	}
+
+	// missing args
+	_, err := initDeployCommand()
+	c.Assert(err, ErrorMatches, "no charm specified")
+
+	// bad unit count
+	_, err = initDeployCommand("charm-name", "--num-units", "0")
+	c.Assert(err, ErrorMatches, "must deploy at least one unit")
+
+	// environment tested elsewhere
+}
 
=== added file 'cmd/juju/deploy.go.OTHER'
--- cmd/juju/deploy.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/juju/deploy.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,79 @@
+package main
+
+import (
+	"errors"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"os"
+)
+
+type DeployCommand struct {
+	EnvName     string
+	CharmName   string
+	ServiceName string
+	ConfPath    string
+	NumUnits    int
+	Upgrade     bool
+	RepoPath    string // defaults to JUJU_REPOSITORY
+}
+
+const deployDoc = `
+<charm name> can be a charm URL, or an unambiguously condensed form of it;
+assuming a current default series of "precise", the following forms will be
+accepted.
+
+For cs:precise/mysql
+  mysql
+  precise/mysql
+
+For cs:~user/precise/mysql
+  cs:~user/mysql
+
+For local:precise/mysql
+  local:mysql
+
+In all cases, a versioned charm URL will be expanded as expected (for example,
+mysql-33 becomes cs:precise/mysql-33).
+
+<service name>, if omitted, will be derived from <charm name>.
+`
+
+func (c *DeployCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		"deploy", "<charm name> [<service name>]", "deploy a new service", deployDoc,
+	}
+}
+
+func (c *DeployCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	addEnvironFlags(&c.EnvName, f)
+	f.IntVar(&c.NumUnits, "n", 1, "number of service units to deploy")
+	f.IntVar(&c.NumUnits, "num-units", 1, "")
+	f.BoolVar(&c.Upgrade, "u", false, "increment local charm revision")
+	f.BoolVar(&c.Upgrade, "upgrade", false, "")
+	f.StringVar(&c.ConfPath, "config", "", "path to yaml-formatted service config")
+	f.StringVar(&c.RepoPath, "repository", os.Getenv("JUJU_REPOSITORY"), "local charm repository")
+	// TODO --constraints
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	args = f.Args()
+	switch len(args) {
+	case 2:
+		c.ServiceName = args[1]
+		fallthrough
+	case 1:
+		c.CharmName = args[0]
+	case 0:
+		return errors.New("no charm specified")
+	default:
+		return cmd.CheckEmpty(args[2:])
+	}
+	if c.NumUnits < 1 {
+		return errors.New("must deploy at least one unit")
+	}
+	return nil
+}
+
+func (c *DeployCommand) Run(ctx *cmd.Context) error {
+	panic("not implemented")
+}
 
=== added file 'cmd/juju/destroy.go.OTHER'
--- cmd/juju/destroy.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/juju/destroy.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/juju"
+)
+
+// DestroyCommand destroys an environment.
+type DestroyCommand struct {
+	EnvName string
+}
+
+func (c *DestroyCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		"destroy-environment", "[options]",
+		"terminate all machines and other associated resources for an environment",
+		"",
+	}
+}
+
+func (c *DestroyCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	addEnvironFlags(&c.EnvName, f)
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	return cmd.CheckEmpty(f.Args())
+}
+
+func (c *DestroyCommand) Run(_ *cmd.Context) error {
+	conn, err := juju.NewConn(c.EnvName)
+	if err != nil {
+		return err
+	}
+	return conn.Destroy()
+}
 
=== added file 'cmd/juju/main.go.OTHER'
--- cmd/juju/main.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/juju/main.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"os"
+)
+
+// When we import an environment provider implementation
+// here, it will register itself with environs, and hence
+// be available to the juju command.
+import (
+	_ "launchpad.net/juju-core/juju/environs/ec2"
+)
+
+var jujuDoc = `
+juju provides easy, intelligent service orchestration on top of environments
+such as OpenStack, Amazon AWS, or bare metal.
+
+https://juju.ubuntu.com/
+`
+
+// Main registers subcommands for the juju executable, and hands over control
+// to the cmd package. This function is not redundant with main, because it
+// provides an entry point for testing with arbitrary command line arguments.
+func Main(args []string) {
+	juju := &cmd.SuperCommand{Name: "juju", Doc: jujuDoc, Log: &cmd.Log{}}
+	juju.Register(&BootstrapCommand{})
+	juju.Register(&DestroyCommand{})
+	os.Exit(cmd.Main(juju, cmd.DefaultContext(), args[1:]))
+}
+
+func main() {
+	Main(os.Args)
+}
+
+func addEnvironFlags(name *string, f *gnuflag.FlagSet) {
+	f.StringVar(name, "e", "", "juju environment to operate in")
+	f.StringVar(name, "environment", "", "")
+}
 
=== added directory 'cmd/jujuc'
=== added file 'cmd/jujuc/main.go.OTHER'
--- cmd/jujuc/main.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/main.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,89 @@
+package main
+
+import (
+	"fmt"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"net/rpc"
+	"os"
+	"path/filepath"
+)
+
+var Help = `
+The jujuc command forwards invocations over RPC for execution by the juju
+unit agent. It expects to be called via a symlink named for the desired
+remote command, and expects JUJU_AGENT_SOCKET and JUJU_CONTEXT_ID be set
+in its environment.
+`[1:]
+
+func getenv(name string) (string, error) {
+	value := os.Getenv(name)
+	if value == "" {
+		return "", fmt.Errorf("%s not set", name)
+	}
+	return value, nil
+}
+
+func getwd() (string, error) {
+	dir, err := os.Getwd()
+	if err != nil {
+		return "", err
+	}
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return "", err
+	}
+	return abs, nil
+}
+
+// Main uses JUJU_CONTEXT_ID and JUJU_AGENT_SOCKET to ask a running unit agent
+// to execute a Command on our behalf. Individual commands should be exposed
+// by symlinking the command name to this executable.
+// This function is not redundant with main, because it is exported, and can
+// thus be called by testing code.
+func Main(args []string) (code int, err error) {
+	commandName := filepath.Base(args[0])
+	if commandName == "jujuc" {
+		fmt.Fprint(os.Stderr, Help)
+		return 2, fmt.Errorf("jujuc should not be called directly")
+	}
+	code = 1
+	contextId, err := getenv("JUJU_CONTEXT_ID")
+	if err != nil {
+		return
+	}
+	dir, err := getwd()
+	if err != nil {
+		return
+	}
+	req := server.Request{
+		ContextId:   contextId,
+		Dir:         dir,
+		CommandName: commandName,
+		Args:        args[1:],
+	}
+	socketPath, err := getenv("JUJU_AGENT_SOCKET")
+	if err != nil {
+		return
+	}
+	client, err := rpc.Dial("unix", socketPath)
+	if err != nil {
+		return
+	}
+	defer client.Close()
+	var resp server.Response
+	err = client.Call("Jujuc.Main", req, &resp)
+	if err != nil {
+		return
+	}
+	os.Stdout.Write(resp.Stdout)
+	os.Stderr.Write(resp.Stderr)
+	return resp.Code, nil
+}
+
+func main() {
+	code, err := Main(os.Args)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+	}
+	os.Exit(code)
+}
 
=== added file 'cmd/jujuc/main_test.go.OTHER'
--- cmd/jujuc/main_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/main_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,159 @@
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"launchpad.net/gnuflag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+var flagRunMain = flag.Bool("run-main", false, "Run the application's main function for recursive testing")
+
+// Reentrancy point for testing (something as close as possible to) the jujuc
+// tool itself.
+func TestRunMain(t *testing.T) {
+	if *flagRunMain {
+		code, err := Main(flag.Args())
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		}
+		os.Exit(code)
+	}
+}
+
+type RemoteCommand struct {
+	msg string
+}
+
+var expectUsage = `usage: remote [options]
+purpose: test jujuc
+
+options:
+--error (= "")
+    if set, fail
+
+here is some documentation
+`
+
+func (c *RemoteCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		"remote", "", "test jujuc", "here is some documentation"}
+}
+
+func (c *RemoteCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	f.StringVar(&c.msg, "error", "", "if set, fail")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	return cmd.CheckEmpty(f.Args())
+}
+
+func (c *RemoteCommand) Run(ctx *cmd.Context) error {
+	if c.msg != "" {
+		return errors.New(c.msg)
+	}
+	fmt.Fprintf(ctx.Stdout, "success!\n")
+	return nil
+}
+
+func run(c *C, sockPath string, contextId string, exit int, cmd ...string) string {
+	args := append([]string{"-test.run", "TestRunMain", "-run-main", "--"}, cmd...)
+	ps := exec.Command(os.Args[0], args...)
+	ps.Dir = c.MkDir()
+	ps.Env = []string{
+		fmt.Sprintf("JUJU_AGENT_SOCKET=%s", sockPath),
+		fmt.Sprintf("JUJU_CONTEXT_ID=%s", contextId),
+	}
+	output, err := ps.CombinedOutput()
+	if exit == 0 {
+		c.Assert(err, IsNil)
+	} else {
+		c.Assert(err, ErrorMatches, fmt.Sprintf("exit status %d", exit))
+	}
+	return string(output)
+}
+
+type MainSuite struct {
+	sockPath string
+	server   *server.Server
+}
+
+var _ = Suite(&MainSuite{})
+
+func (s *MainSuite) SetUpSuite(c *C) {
+	factory := func(contextId, cmdName string) (cmd.Command, error) {
+		if contextId != "bill" {
+			return nil, fmt.Errorf("bad context: %s", contextId)
+		}
+		if cmdName != "remote" {
+			return nil, fmt.Errorf("bad command: %s", cmdName)
+		}
+		return &RemoteCommand{}, nil
+	}
+	s.sockPath = filepath.Join(c.MkDir(), "test.sock")
+	srv, err := server.NewServer(factory, s.sockPath)
+	c.Assert(err, IsNil)
+	s.server = srv
+	go func() {
+		if err := s.server.Run(); err != nil {
+			c.Fatalf("server died: %s", err)
+		}
+	}()
+}
+
+func (s *MainSuite) TearDownSuite(c *C) {
+	s.server.Close()
+}
+
+var argsTests = []struct {
+	args   []string
+	code   int
+	output string
+}{
+	{[]string{"jujuc", "whatever"}, 2, Help + "error: jujuc should not be called directly\n"},
+	{[]string{"remote"}, 0, "success!\n"},
+	{[]string{"/path/to/remote"}, 0, "success!\n"},
+	{[]string{"unknown"}, 1, "error: bad request: bad command: unknown\n"},
+	{[]string{"remote", "--error", "borken"}, 1, "error: borken\n"},
+	{[]string{"remote", "--unknown"}, 2, expectUsage + "error: flag provided but not defined: --unknown\n"},
+	{[]string{"remote", "unwanted"}, 2, expectUsage + `error: unrecognized args: ["unwanted"]` + "\n"},
+}
+
+func (s *MainSuite) TestArgs(c *C) {
+	for _, t := range argsTests {
+		fmt.Println(t.args)
+		output := run(c, s.sockPath, "bill", t.code, t.args...)
+		c.Assert(output, Equals, t.output)
+	}
+}
+
+func (s *MainSuite) TestNoClientId(c *C) {
+	output := run(c, s.sockPath, "", 1, "remote")
+	c.Assert(output, Equals, "error: JUJU_CONTEXT_ID not set\n")
+}
+
+func (s *MainSuite) TestBadClientId(c *C) {
+	output := run(c, s.sockPath, "ben", 1, "remote")
+	c.Assert(output, Equals, "error: bad request: bad context: ben\n")
+}
+
+func (s *MainSuite) TestNoSockPath(c *C) {
+	output := run(c, "", "bill", 1, "remote")
+	c.Assert(output, Equals, "error: JUJU_AGENT_SOCKET not set\n")
+}
+
+func (s *MainSuite) TestBadSockPath(c *C) {
+	badSock := filepath.Join(c.MkDir(), "bad.sock")
+	output := run(c, badSock, "bill", 1, "remote")
+	err := fmt.Sprintf("error: dial unix %s: .*\n", badSock)
+	c.Assert(output, Matches, err)
+}
 
=== added directory 'cmd/jujuc/server'
=== added file 'cmd/jujuc/server/config-get.go.OTHER'
--- cmd/jujuc/server/config-get.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/config-get.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,66 @@
+package server
+
+import (
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+)
+
+// ConfigGetCommand implements the config-get command.
+type ConfigGetCommand struct {
+	*ClientContext
+	Key string // The key to show. If empty, show all.
+	out output
+}
+
+func NewConfigGetCommand(ctx *ClientContext) (cmd.Command, error) {
+	if err := ctx.check(); err != nil {
+		return nil, err
+	}
+	return &ConfigGetCommand{ClientContext: ctx}, nil
+}
+
+func (c *ConfigGetCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		"config-get", "[<key>]",
+		"print service configuration",
+		"If a key is given, only the value for that key will be printed.",
+	}
+}
+
+func (c *ConfigGetCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	c.out.addFlags(f, "yaml", defaultFormatters)
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	args = f.Args()
+	if args == nil {
+		return nil
+	}
+	c.Key = args[0]
+	return cmd.CheckEmpty(args[1:])
+}
+
+func (c *ConfigGetCommand) Run(ctx *cmd.Context) error {
+	unit, err := c.State.Unit(c.LocalUnitName)
+	if err != nil {
+		return err
+	}
+	service, err := c.State.Service(unit.ServiceName())
+	if err != nil {
+		return err
+	}
+	conf, err := service.Config()
+	if err != nil {
+		return err
+	}
+	var value interface{}
+	if c.Key == "" {
+		value = conf.Map()
+	} else {
+		value, _ = conf.Get(c.Key)
+	}
+	if c.out.testMode {
+		return truthError(value)
+	}
+	return c.out.write(ctx, value)
+}
 
=== added file 'cmd/jujuc/server/config-get_test.go.OTHER'
--- cmd/jujuc/server/config-get_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/config-get_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,125 @@
+package server_test
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"path/filepath"
+)
+
+type ConfigGetSuite struct {
+	UnitFixture
+}
+
+var _ = Suite(&ConfigGetSuite{})
+
+func (s *ConfigGetSuite) SetUpTest(c *C) {
+	s.UnitFixture.SetUpTest(c)
+	conf, err := s.service.Config()
+	c.Assert(err, IsNil)
+	conf.Update(map[string]interface{}{
+		"monsters":            false,
+		"spline-reticulation": 45.0,
+	})
+	_, err = conf.Write()
+	c.Assert(err, IsNil)
+}
+
+var configGetYamlMap = "(spline-reticulation: 45\nmonsters: false\n|monsters: false\nspline-reticulation: 45\n)\n"
+var configGetTests = []struct {
+	args []string
+	out  string
+}{
+	{[]string{"monsters"}, "false\n\n"},
+	{[]string{"--format", "yaml", "monsters"}, "false\n\n"},
+	{[]string{"--format", "json", "monsters"}, "false\n"},
+	{[]string{"spline-reticulation"}, "45\n\n"},
+	{[]string{"--format", "yaml", "spline-reticulation"}, "45\n\n"},
+	{[]string{"--format", "json", "spline-reticulation"}, "45\n"},
+	{[]string{"missing"}, ""},
+	{[]string{"--format", "yaml", "missing"}, ""},
+	{[]string{"--format", "json", "missing"}, "null\n"},
+	{nil, configGetYamlMap},
+	{[]string{"--format", "yaml"}, configGetYamlMap},
+	{[]string{"--format", "json"}, `{"monsters":false,"spline-reticulation":45}` + "\n"},
+}
+
+func (s *ConfigGetSuite) TestOutputFormat(c *C) {
+	for _, t := range configGetTests {
+		com, err := s.ctx.NewCommand("config-get")
+		c.Assert(err, IsNil)
+		ctx := dummyContext(c)
+		code := cmd.Main(com, ctx, t.args)
+		c.Assert(code, Equals, 0)
+		c.Assert(bufferString(ctx.Stderr), Equals, "")
+		c.Assert(bufferString(ctx.Stdout), Matches, t.out)
+	}
+}
+
+var configGetTestModeTests = []struct {
+	args []string
+	code int
+}{
+	{[]string{"monsters", "--test"}, 1},
+	{[]string{"spline-reticulation", "--test"}, 0},
+	{[]string{"missing", "--test"}, 1},
+	{[]string{"--test"}, 0},
+}
+
+func (s *ConfigGetSuite) TestTestMode(c *C) {
+	for _, t := range configGetTestModeTests {
+		com, err := s.ctx.NewCommand("config-get")
+		c.Assert(err, IsNil)
+		ctx := dummyContext(c)
+		code := cmd.Main(com, ctx, t.args)
+		c.Assert(code, Equals, t.code)
+		c.Assert(bufferString(ctx.Stderr), Equals, "")
+		c.Assert(bufferString(ctx.Stdout), Equals, "")
+	}
+}
+
+func (s *ConfigGetSuite) TestHelp(c *C) {
+	com, err := s.ctx.NewCommand("config-get")
+	c.Assert(err, IsNil)
+	ctx := dummyContext(c)
+	code := cmd.Main(com, ctx, []string{"--help"})
+	c.Assert(code, Equals, 0)
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	c.Assert(bufferString(ctx.Stderr), Equals, `usage: config-get [options] [<key>]
+purpose: print service configuration
+
+options:
+--format  (= yaml)
+    specify output format (json|yaml)
+-o, --output (= "")
+    specify an output file
+--test  (= false)
+    returns non-zero exit code if value is false/zero/empty
+
+If a key is given, only the value for that key will be printed.
+`)
+}
+
+func (s *ConfigGetSuite) TestOutputPath(c *C) {
+	com, err := s.ctx.NewCommand("config-get")
+	c.Assert(err, IsNil)
+	ctx := dummyContext(c)
+	code := cmd.Main(com, ctx, []string{"--output", "some-file", "monsters"})
+	c.Assert(code, Equals, 0)
+	c.Assert(bufferString(ctx.Stderr), Equals, "")
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "some-file"))
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "false\n\n")
+}
+
+func (s *ConfigGetSuite) TestUnknownArg(c *C) {
+	com, err := s.ctx.NewCommand("config-get")
+	c.Assert(err, IsNil)
+	err = com.Init(dummyFlagSet(), []string{"multiple", "keys"})
+	c.Assert(err, ErrorMatches, `unrecognized args: \["keys"\]`)
+}
+
+func (s *ConfigGetSuite) TestUnitCommand(c *C) {
+	s.AssertUnitCommand(c, "config-get")
+}
 
=== added file 'cmd/jujuc/server/context.go.OTHER'
--- cmd/jujuc/server/context.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/context.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,96 @@
+// The cmd/jujuc/server package implements the server side of the jujuc proxy
+// tool, which forwards command invocations to the unit agent process so that
+// they can be executed against specific state.
+package server
+
+import (
+	"fmt"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+// ClientContext is responsible for the state against which a jujuc-forwarded
+// command will execute; it implements the core of the various jujuc tools, and
+// is involved in constructing a suitable environment in which to execute a hook
+// (which is likely to call jujuc tools that need this specific ClientContext).
+type ClientContext struct {
+	Id             string
+	State          *state.State
+	LocalUnitName  string
+	RemoteUnitName string
+	RelationName   string
+}
+
+// checkUnitState returns an error if ctx has nil State or LocalUnitName fields.
+func (ctx *ClientContext) check() error {
+	if ctx.State == nil {
+		return fmt.Errorf("context %s cannot access state", ctx.Id)
+	}
+	if ctx.LocalUnitName == "" {
+		return fmt.Errorf("context %s is not attached to a unit", ctx.Id)
+	}
+	return nil
+}
+
+// newCommands maps Command names to initializers.
+var newCommands = map[string]func(*ClientContext) (cmd.Command, error){
+	"close-port": NewClosePortCommand,
+	"config-get": NewConfigGetCommand,
+	"juju-log":   NewJujuLogCommand,
+	"open-port":  NewOpenPortCommand,
+	"unit-get":   NewUnitGetCommand,
+}
+
+// NewCommand returns an instance of the named Command, initialized to execute
+// against this ClientContext.
+func (ctx *ClientContext) NewCommand(name string) (cmd.Command, error) {
+	f := newCommands[name]
+	if f == nil {
+		return nil, fmt.Errorf("unknown command: %s", name)
+	}
+	return f(ctx)
+}
+
+// hookVars returns an os.Environ-style list of strings necessary to run a hook
+// such that it can know what environment it's operating in, and can call back
+// into ctx.
+func (ctx *ClientContext) hookVars(charmDir, socketPath string) []string {
+	vars := []string{
+		"APT_LISTCHANGES_FRONTEND=none",
+		"DEBIAN_FRONTEND=noninteractive",
+		"PATH=" + os.Getenv("PATH"),
+		"CHARM_DIR=" + charmDir,
+		"JUJU_CONTEXT_ID=" + ctx.Id,
+		"JUJU_AGENT_SOCKET=" + socketPath,
+	}
+	if ctx.LocalUnitName != "" {
+		vars = append(vars, "JUJU_UNIT_NAME="+ctx.LocalUnitName)
+	}
+	if ctx.RemoteUnitName != "" {
+		vars = append(vars, "JUJU_REMOTE_UNIT="+ctx.RemoteUnitName)
+	}
+	if ctx.RelationName != "" {
+		vars = append(vars, "JUJU_RELATION="+ctx.RelationName)
+	}
+	return vars
+}
+
+// RunHook executes a hook in an environment which allows it to to call back
+// into ctx to execute jujuc tools.
+func (ctx *ClientContext) RunHook(hookName, charmDir, socketPath string) error {
+	ps := exec.Command(filepath.Join(charmDir, "hooks", hookName))
+	ps.Env = ctx.hookVars(charmDir, socketPath)
+	ps.Dir = charmDir
+	if err := ps.Run(); err != nil {
+		if ee, ok := err.(*exec.Error); ok {
+			if os.IsNotExist(ee.Err) {
+				return nil
+			}
+		}
+		return err
+	}
+	return nil
+}
 
=== added file 'cmd/jujuc/server/context_test.go.OTHER'
--- cmd/jujuc/server/context_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/context_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,145 @@
+package server_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"launchpad.net/juju-core/juju/state"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type GetCommandSuite struct{}
+
+var _ = Suite(&GetCommandSuite{})
+
+var getCommandTests = []struct {
+	name string
+	err  string
+}{
+	{"close-port", ""},
+	{"config-get", ""},
+	{"juju-log", ""},
+	{"open-port", ""},
+	{"unit-get", ""},
+	{"random", "unknown command: random"},
+}
+
+func (s *GetCommandSuite) TestGetCommand(c *C) {
+	ctx := &server.ClientContext{
+		Id:            "ctxid",
+		State:         &state.State{},
+		LocalUnitName: "minecraft/0",
+	}
+	for _, t := range getCommandTests {
+		com, err := ctx.NewCommand(t.name)
+		if t.err == "" {
+			// At this level, just check basic sanity; commands are tested in
+			// more detail elsewhere.
+			c.Assert(err, IsNil)
+			c.Assert(com.Info().Name, Equals, t.name)
+		} else {
+			c.Assert(com, IsNil)
+			c.Assert(err, ErrorMatches, t.err)
+		}
+	}
+}
+
+type RunHookSuite struct {
+	outPath string
+}
+
+var _ = Suite(&RunHookSuite{})
+
+// makeCharm constructs a fake charm dir containing a single named hook with
+// permissions perm and exit code code. It returns the charm directory and the
+// path to which the hook script will write environment variables.
+func makeCharm(c *C, hookName string, perm os.FileMode, code int) (charmDir, outPath string) {
+	charmDir = c.MkDir()
+	hooksDir := filepath.Join(charmDir, "hooks")
+	err := os.Mkdir(hooksDir, 0755)
+	c.Assert(err, IsNil)
+	hook, err := os.OpenFile(filepath.Join(hooksDir, hookName), os.O_CREATE|os.O_WRONLY, perm)
+	c.Assert(err, IsNil)
+	defer hook.Close()
+	outPath = filepath.Join(c.MkDir(), "hook.out")
+	_, err = fmt.Fprintf(hook, "#!/bin/bash\nenv > %s\nexit %d", outPath, code)
+	c.Assert(err, IsNil)
+	return charmDir, outPath
+}
+
+func AssertEnvContains(c *C, lines []string, env map[string]string) {
+	for k, v := range env {
+		sought := k + "=" + v
+		found := false
+		for _, line := range lines {
+			if line == sought {
+				found = true
+				continue
+			}
+		}
+		comment := Commentf("expected to find %v among %v", sought, lines)
+		c.Assert(found, Equals, true, comment)
+	}
+}
+
+func AssertEnv(c *C, outPath string, env map[string]string) {
+	out, err := ioutil.ReadFile(outPath)
+	c.Assert(err, IsNil)
+	lines := strings.Split(string(out), "\n")
+	AssertEnvContains(c, lines, env)
+	AssertEnvContains(c, lines, map[string]string{
+		"PATH":                     os.Getenv("PATH"),
+		"DEBIAN_FRONTEND":          "noninteractive",
+		"APT_LISTCHANGES_FRONTEND": "none",
+	})
+}
+
+func (s *RunHookSuite) TestNoHook(c *C) {
+	ctx := &server.ClientContext{}
+	err := ctx.RunHook("tree-fell-in-forest", c.MkDir(), "")
+	c.Assert(err, IsNil)
+}
+
+func (s *RunHookSuite) TestNonExecutableHook(c *C) {
+	ctx := &server.ClientContext{}
+	charmDir, _ := makeCharm(c, "something-happened", 0600, 0)
+	err := ctx.RunHook("something-happened", charmDir, "")
+	c.Assert(err, ErrorMatches, `exec: ".*/something-happened": permission denied`)
+}
+
+func (s *RunHookSuite) TestBadHook(c *C) {
+	ctx := &server.ClientContext{Id: "ctx-id"}
+	charmDir, outPath := makeCharm(c, "occurrence-occurred", 0700, 99)
+	socketPath := "/path/to/socket"
+	err := ctx.RunHook("occurrence-occurred", charmDir, socketPath)
+	c.Assert(err, ErrorMatches, "exit status 99")
+	AssertEnv(c, outPath, map[string]string{
+		"CHARM_DIR":         charmDir,
+		"JUJU_AGENT_SOCKET": socketPath,
+		"JUJU_CONTEXT_ID":   "ctx-id",
+	})
+}
+
+func (s *RunHookSuite) TestGoodHookWithVars(c *C) {
+	ctx := &server.ClientContext{
+		Id:             "some-id",
+		LocalUnitName:  "local/99",
+		RemoteUnitName: "remote/123",
+		RelationName:   "rel",
+	}
+	charmDir, outPath := makeCharm(c, "something-happened", 0700, 0)
+	socketPath := "/path/to/socket"
+	err := ctx.RunHook("something-happened", charmDir, socketPath)
+	c.Assert(err, IsNil)
+	AssertEnv(c, outPath, map[string]string{
+		"CHARM_DIR":         charmDir,
+		"JUJU_AGENT_SOCKET": socketPath,
+		"JUJU_CONTEXT_ID":   "some-id",
+		"JUJU_UNIT_NAME":    "local/99",
+		"JUJU_REMOTE_UNIT":  "remote/123",
+		"JUJU_RELATION":     "rel",
+	})
+}
 
=== added file 'cmd/jujuc/server/juju-log.go.OTHER'
--- cmd/jujuc/server/juju-log.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/juju-log.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,57 @@
+package server
+
+import (
+	"errors"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/log"
+	"strings"
+)
+
+// JujuLogCommand implements the juju-log command.
+type JujuLogCommand struct {
+	*ClientContext
+	Message string
+	Debug   bool
+}
+
+func NewJujuLogCommand(ctx *ClientContext) (cmd.Command, error) {
+	return &JujuLogCommand{ClientContext: ctx}, nil
+}
+
+func (c *JujuLogCommand) Info() *cmd.Info {
+	return &cmd.Info{"juju-log", "<message>", "write a message to the juju log", ""}
+}
+
+func (c *JujuLogCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	f.BoolVar(&c.Debug, "debug", false, "log at debug level")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	args = f.Args()
+	if args == nil {
+		return errors.New("no message specified")
+	}
+	c.Message = strings.Join(args, " ")
+	return nil
+}
+
+func (c *JujuLogCommand) Run(_ *cmd.Context) error {
+	s := []string{}
+	if c.LocalUnitName != "" {
+		s = append(s, c.LocalUnitName)
+	}
+	if c.RelationName != "" {
+		s = append(s, c.RelationName)
+	}
+	msg := c.Message
+	if len(s) > 0 {
+		msg = strings.Join(s, " ") + ": " + msg
+	}
+	if c.Debug {
+		log.Debugf("%s", msg)
+	} else {
+		log.Printf("%s", msg)
+	}
+	return nil
+}
 
=== added file 'cmd/jujuc/server/juju-log_test.go.OTHER'
--- cmd/jujuc/server/juju-log_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/juju-log_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,82 @@
+package server_test
+
+import (
+	"bytes"
+	"fmt"
+	"launchpad.net/gnuflag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"launchpad.net/juju-core/juju/log"
+	stdlog "log"
+)
+
+type JujuLogSuite struct{}
+
+var _ = Suite(&JujuLogSuite{})
+
+func pushLog(debug bool) (buf *bytes.Buffer, pop func()) {
+	oldTarget, oldDebug := log.Target, log.Debug
+	buf = new(bytes.Buffer)
+	log.Target, log.Debug = stdlog.New(buf, "", 0), debug
+	return buf, func() {
+		log.Target, log.Debug = oldTarget, oldDebug
+	}
+}
+
+func dummyFlagSet() *gnuflag.FlagSet {
+	return gnuflag.NewFlagSet("", gnuflag.ContinueOnError)
+}
+
+var commonLogTests = []struct {
+	debugEnabled bool
+	debugFlag    bool
+	target       string
+}{
+	{false, false, "JUJU"},
+	{false, true, ""},
+	{true, false, "JUJU"},
+	{true, true, "JUJU:DEBUG"},
+}
+
+func assertLogs(c *C, ctx *server.ClientContext, badge string) {
+	msg1 := "the chickens"
+	msg2 := "are 110% AWESOME"
+	com, err := ctx.NewCommand("juju-log")
+	c.Assert(err, IsNil)
+	for _, t := range commonLogTests {
+		buf, pop := pushLog(t.debugEnabled)
+		defer pop()
+
+		var args []string
+		if t.debugFlag {
+			args = []string{"--debug", msg1, msg2}
+		} else {
+			args = []string{msg1, msg2}
+		}
+		code := cmd.Main(com, &cmd.Context{}, args)
+		c.Assert(code, Equals, 0)
+
+		if t.target == "" {
+			c.Assert(buf.String(), Equals, "")
+		} else {
+			expect := fmt.Sprintf("%s %s: %s %s\n", t.target, badge, msg1, msg2)
+			c.Assert(buf.String(), Equals, expect)
+		}
+	}
+}
+
+func (s *JujuLogSuite) TestBadges(c *C) {
+	local := &server.ClientContext{LocalUnitName: "minecraft/0"}
+	assertLogs(c, local, "minecraft/0")
+	relation := &server.ClientContext{LocalUnitName: "minecraft/0", RelationName: "bot"}
+	assertLogs(c, relation, "minecraft/0 bot")
+}
+
+func (s *JujuLogSuite) TestRequiresMessage(c *C) {
+	ctx := &server.ClientContext{}
+	com, err := ctx.NewCommand("juju-log")
+	c.Assert(err, IsNil)
+	err = com.Init(dummyFlagSet(), nil)
+	c.Assert(err, ErrorMatches, "no message specified")
+}
 
=== added file 'cmd/jujuc/server/output.go.OTHER'
--- cmd/jujuc/server/output.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/output.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,149 @@
+package server
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"launchpad.net/gnuflag"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju-core/juju/cmd"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+// formatter converts an arbitrary object into a []byte.
+type formatter func(value interface{}) ([]byte, error)
+
+// formatYaml marshals value to a yaml-formatted []byte, unless value is nil.
+func formatYaml(value interface{}) ([]byte, error) {
+	if value == nil {
+		return nil, nil
+	}
+	return goyaml.Marshal(value)
+}
+
+// defaultFormatters are used by many jujuc Commands.
+var defaultFormatters = map[string]formatter{
+	"yaml": formatYaml,
+	"json": json.Marshal,
+}
+
+// formatterValue implements gnuflag.Value for the --format flag.
+type formatterValue struct {
+	name       string
+	formatters map[string]formatter
+}
+
+// newFormatterValue returns a new formatterValue. The initial formatter name
+// must be present in formatters.
+func newFormatterValue(initial string, formatters map[string]formatter) *formatterValue {
+	v := &formatterValue{formatters: formatters}
+	if err := v.Set(initial); err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Set stores the chosen formatter name in v.name.
+func (v *formatterValue) Set(value string) error {
+	if v.formatters[value] == nil {
+		return fmt.Errorf("unknown format: %s", value)
+	}
+	v.name = value
+	return nil
+}
+
+// String returns the chosen formatter name.
+func (v *formatterValue) String() string {
+	return v.name
+}
+
+// doc returns documentation for the --format flag.
+func (v *formatterValue) doc() string {
+	choices := make([]string, len(v.formatters))
+	i := 0
+	for name := range v.formatters {
+		choices[i] = name
+		i++
+	}
+	sort.Strings(choices)
+	return "specify output format (" + strings.Join(choices, "|") + ")"
+}
+
+// format runs the chosen formatter on value.
+func (v *formatterValue) format(value interface{}) ([]byte, error) {
+	return v.formatters[v.name](value)
+}
+
+// output is responsible for interpreting output-related command line flags
+// and writing a value to a file or to stdout as directed. The testMode field,
+// controlled by the --test flag, is used to indicate that output should be
+// suppressed and communicated entirely in the process exit code.
+type output struct {
+	formatter *formatterValue
+	outPath   string
+	testMode  bool
+}
+
+// addFlags injects appropriate command line flags into f.
+func (c *output) addFlags(f *gnuflag.FlagSet, name string, formatters map[string]formatter) {
+	c.formatter = newFormatterValue(name, formatters)
+	f.Var(c.formatter, "format", c.formatter.doc())
+	f.StringVar(&c.outPath, "o", "", "specify an output file")
+	f.StringVar(&c.outPath, "output", "", "")
+	f.BoolVar(&c.testMode, "test", false, "returns non-zero exit code if value is false/zero/empty")
+}
+
+// write formats and outputs value as directed by the --format and --output
+// command line flags.
+func (c *output) write(ctx *cmd.Context, value interface{}) (err error) {
+	var target io.Writer
+	if c.outPath == "" {
+		target = ctx.Stdout
+	} else {
+		path := ctx.AbsPath(c.outPath)
+		if target, err = os.Create(path); err != nil {
+			return
+		}
+	}
+	bytes, err := c.formatter.format(value)
+	if err != nil {
+		return
+	}
+	if bytes != nil {
+		_, err = target.Write(bytes)
+		if err == nil {
+			_, err = target.Write([]byte{'\n'})
+		}
+	}
+	return
+}
+
+// truthError returns cmd.ErrSilent if value is nil, false, or 0, or an empty
+// array, map, slice, or string.
+func truthError(value interface{}) error {
+	b := true
+	v := reflect.ValueOf(value)
+	switch v.Kind() {
+	case reflect.Invalid:
+		b = false
+	case reflect.Bool:
+		b = v.Bool()
+	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
+		b = v.Len() != 0
+	case reflect.Float32, reflect.Float64:
+		b = v.Float() != 0
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		b = v.Int() != 0
+	case reflect.Uint, reflect.Uintptr, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		b = v.Uint() != 0
+	case reflect.Interface, reflect.Ptr:
+		b = !v.IsNil()
+	}
+	if b {
+		return nil
+	}
+	return cmd.ErrSilent
+}
 
=== added file 'cmd/jujuc/server/ports.go.OTHER'
--- cmd/jujuc/server/ports.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/ports.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,100 @@
+package server
+
+import (
+	"errors"
+	"fmt"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+	"strconv"
+	"strings"
+)
+
+const portFormat = "<port>[/<protocol>]"
+
+// portCommand implements the open-port and close-port commands.
+type portCommand struct {
+	*ClientContext
+	info     *cmd.Info
+	action   func(*state.Unit, string, int) error
+	Protocol string
+	Port     int
+}
+
+func (c *portCommand) Info() *cmd.Info {
+	return c.info
+}
+
+func badPort(value interface{}) error {
+	return fmt.Errorf(`port must be in the range [1, 65535]; got "%v"`, value)
+}
+
+func (c *portCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	args = f.Args()
+	if args == nil {
+		return errors.New("no port specified")
+	}
+	parts := strings.Split(args[0], "/")
+	if len(parts) > 2 {
+		return fmt.Errorf("expected %s; got %q", portFormat, args[0])
+	}
+	port, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return badPort(parts[0])
+	}
+	if port < 1 || port > 65535 {
+		return badPort(port)
+	}
+	protocol := "tcp"
+	if len(parts) == 2 {
+		protocol = strings.ToLower(parts[1])
+		if protocol != "tcp" && protocol != "udp" {
+			return fmt.Errorf(`protocol must be "tcp" or "udp"; got %q`, protocol)
+		}
+	}
+	c.Port = port
+	c.Protocol = protocol
+	return cmd.CheckEmpty(args[1:])
+}
+
+func (c *portCommand) Run(_ *cmd.Context) error {
+	unit, err := c.State.Unit(c.LocalUnitName)
+	if err != nil {
+		return err
+	}
+	return c.action(unit, c.Protocol, c.Port)
+}
+
+var openPortInfo = &cmd.Info{
+	"open-port", portFormat, "register a port to open",
+	"The port will only be open while the service is exposed.",
+}
+
+func NewOpenPortCommand(ctx *ClientContext) (cmd.Command, error) {
+	if err := ctx.check(); err != nil {
+		return nil, err
+	}
+	return &portCommand{
+		ClientContext: ctx,
+		info:          openPortInfo,
+		action:        (*state.Unit).OpenPort,
+	}, nil
+}
+
+var closePortInfo = &cmd.Info{
+	"close-port", portFormat, "ensure a port is always closed", "",
+}
+
+func NewClosePortCommand(ctx *ClientContext) (cmd.Command, error) {
+	if err := ctx.check(); err != nil {
+		return nil, err
+	}
+	return &portCommand{
+		ClientContext: ctx,
+		info:          closePortInfo,
+		action:        (*state.Unit).ClosePort,
+	}, nil
+}
 
=== added file 'cmd/jujuc/server/ports_test.go.OTHER'
--- cmd/jujuc/server/ports_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/ports_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,86 @@
+package server_test
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+)
+
+type PortsSuite struct {
+	UnitFixture
+}
+
+var _ = Suite(&PortsSuite{})
+
+var portsTests = []struct {
+	cmd  []string
+	open []state.Port
+}{
+	{[]string{"open-port", "80"}, []state.Port{{"tcp", 80}}},
+	{[]string{"open-port", "99/tcp"}, []state.Port{{"tcp", 80}, {"tcp", 99}}},
+	{[]string{"close-port", "80/TCP"}, []state.Port{{"tcp", 99}}},
+	{[]string{"open-port", "123/udp"}, []state.Port{{"tcp", 99}, {"udp", 123}}},
+	{[]string{"close-port", "9999/UDP"}, []state.Port{{"tcp", 99}, {"udp", 123}}},
+}
+
+func (s *PortsSuite) TestOpenClose(c *C) {
+	for _, t := range portsTests {
+		com, err := s.ctx.NewCommand(t.cmd[0])
+		c.Assert(err, IsNil)
+		ctx := dummyContext(c)
+		code := cmd.Main(com, ctx, t.cmd[1:])
+		c.Assert(code, Equals, 0)
+		c.Assert(bufferString(ctx.Stdout), Equals, "")
+		c.Assert(bufferString(ctx.Stderr), Equals, "")
+		open, err := s.unit.OpenPorts()
+		c.Assert(err, IsNil)
+		c.Assert(open, DeepEquals, t.open)
+	}
+}
+
+var badPortsTests = []struct {
+	args []string
+	err  string
+}{
+	{nil, "no port specified"},
+	{[]string{"0"}, `port must be in the range \[1, 65535\]; got "0"`},
+	{[]string{"65536"}, `port must be in the range \[1, 65535\]; got "65536"`},
+	{[]string{"two"}, `port must be in the range \[1, 65535\]; got "two"`},
+	{[]string{"80/http"}, `protocol must be "tcp" or "udp"; got "http"`},
+	{[]string{"blah/blah/blah"}, `expected <port>\[/<protocol>\]; got "blah/blah/blah"`},
+	{[]string{"123", "haha"}, `unrecognized args: \["haha"\]`},
+}
+
+func (s *PortsSuite) TestBadArgs(c *C) {
+	for _, name := range []string{"open-port", "close-port"} {
+		for _, t := range badPortsTests {
+			com, err := s.ctx.NewCommand(name)
+			c.Assert(err, IsNil)
+			err = com.Init(dummyFlagSet(), t.args)
+			c.Assert(err, ErrorMatches, t.err)
+		}
+	}
+}
+
+func (s *PortsSuite) TestHelp(c *C) {
+	open, err := s.ctx.NewCommand("open-port")
+	c.Assert(err, IsNil)
+	c.Assert(string(open.Info().Help(dummyFlagSet())), Equals, `
+usage: open-port <port>[/<protocol>]
+purpose: register a port to open
+
+The port will only be open while the service is exposed.
+`[1:])
+
+	close, err := s.ctx.NewCommand("close-port")
+	c.Assert(err, IsNil)
+	c.Assert(string(close.Info().Help(dummyFlagSet())), Equals, `
+usage: close-port <port>[/<protocol>]
+purpose: ensure a port is always closed
+`[1:])
+}
+
+func (s *PortsSuite) TestUnitCommands(c *C) {
+	s.AssertUnitCommand(c, "open-port")
+	s.AssertUnitCommand(c, "close-port")
+}
 
=== added file 'cmd/jujuc/server/server.go.OTHER'
--- cmd/jujuc/server/server.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/server.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,133 @@
+// The cmd/jujuc/server package allows a process to expose an RPC interface that
+// allows client processes to delegate execution of cmd.Commands to a server
+// process (with the exposed commands amenable to specialisation by context id).
+package server
+
+import (
+	"bytes"
+	"fmt"
+	"launchpad.net/juju-core/juju/cmd"
+	"net"
+	"net/rpc"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+// Request contains the information necessary to run a Command remotely.
+type Request struct {
+	ContextId   string
+	Dir         string
+	CommandName string
+	Args        []string
+}
+
+// Response contains the return code and output generated by a Request.
+type Response struct {
+	Code   int
+	Stdout []byte
+	Stderr []byte
+}
+
+// CmdGetter looks up a Command implementation connected to a particular Context.
+type CmdGetter func(contextId, cmdName string) (cmd.Command, error)
+
+// Jujuc implements the jujuc command in the form required by net/rpc.
+type Jujuc struct {
+	getCmd CmdGetter
+}
+
+// badReqErr returns an error indicating a bad Request.
+func badReqErr(format string, v ...interface{}) error {
+	return fmt.Errorf("bad request: "+format, v...)
+}
+
+// Main runs the Command specified by req, and fills in resp.
+func (j *Jujuc) Main(req Request, resp *Response) error {
+	if req.CommandName == "" {
+		return badReqErr("command not specified")
+	}
+	if !filepath.IsAbs(req.Dir) {
+		return badReqErr("Dir is not absolute")
+	}
+	c, err := j.getCmd(req.ContextId, req.CommandName)
+	if err != nil {
+		return badReqErr("%s", err)
+	}
+	var stdout, stderr bytes.Buffer
+	ctx := &cmd.Context{req.Dir, &stdout, &stderr}
+	resp.Code = cmd.Main(c, ctx, req.Args)
+	resp.Stdout = stdout.Bytes()
+	resp.Stderr = stderr.Bytes()
+	return nil
+}
+
+// Server implements a server that serves command invocations via
+// a unix domain socket.
+type Server struct {
+	socketPath string
+	listener   net.Listener
+	server     *rpc.Server
+	closed     chan bool
+	closing    chan bool
+	wg         sync.WaitGroup
+}
+
+// NewServer creates an RPC server bound to socketPath, which can execute
+// remote command invocations against an appropriate Context. It will not
+// actually do so until Run is called.
+func NewServer(getCmd CmdGetter, socketPath string) (*Server, error) {
+	server := rpc.NewServer()
+	if err := server.Register(&Jujuc{getCmd}); err != nil {
+		return nil, err
+	}
+	listener, err := net.Listen("unix", socketPath)
+	if err != nil {
+		return nil, err
+	}
+	s := &Server{
+		socketPath: socketPath,
+		listener:   listener,
+		server:     server,
+		closed:     make(chan bool),
+		closing:    make(chan bool),
+	}
+	return s, nil
+}
+
+// Run accepts new connections until it encounters an error, or until Close is
+// called, and then blocks until all existing connections have been closed.
+func (s *Server) Run() (err error) {
+	var conn net.Conn
+	for {
+		conn, err = s.listener.Accept()
+		if err != nil {
+			break
+		}
+		s.wg.Add(1)
+		go func(conn net.Conn) {
+			s.server.ServeConn(conn)
+			s.wg.Done()
+		}(conn)
+	}
+	select {
+	case <-s.closing:
+		// Someone has called Close(), so it is overwhelmingly likely that
+		// the error from Accept is a direct result of the Listener being
+		// closed, and can therefore be safely ignored.
+		err = nil
+	default:
+	}
+	s.wg.Wait()
+	close(s.closed)
+	return
+}
+
+// Close immediately stops accepting connections, and blocks until all existing
+// connections have been closed.
+func (s *Server) Close() {
+	close(s.closing)
+	s.listener.Close()
+	os.Remove(s.socketPath)
+	<-s.closed
+}
 
=== added file 'cmd/jujuc/server/server_test.go.OTHER'
--- cmd/jujuc/server/server_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/server_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,146 @@
+package server_test
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/gnuflag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"net/rpc"
+	"os"
+	"path/filepath"
+)
+
+type RpcCommand struct {
+	Value string
+}
+
+func (c *RpcCommand) Info() *cmd.Info {
+	return &cmd.Info{"remote", "", "act at a distance", "blah doc"}
+}
+
+func (c *RpcCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	f.StringVar(&c.Value, "value", "", "doc")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	return cmd.CheckEmpty(f.Args())
+}
+
+func (c *RpcCommand) Run(ctx *cmd.Context) error {
+	if c.Value == "error" {
+		return errors.New("blam")
+	}
+	ctx.Stdout.Write([]byte("eye of newt\n"))
+	ctx.Stderr.Write([]byte("toe of frog\n"))
+	return ioutil.WriteFile(ctx.AbsPath("local"), []byte(c.Value), 0644)
+}
+
+func factory(contextId, cmdName string) (cmd.Command, error) {
+	if contextId != "validCtx" {
+		return nil, fmt.Errorf("unknown context %q", contextId)
+	}
+	if cmdName != "remote" {
+		return nil, fmt.Errorf("unknown command %q", cmdName)
+	}
+	return &RpcCommand{}, nil
+}
+
+type ServerSuite struct {
+	server   *server.Server
+	sockPath string
+	err      chan error
+}
+
+var _ = Suite(&ServerSuite{})
+
+func (s *ServerSuite) SetUpTest(c *C) {
+	s.sockPath = filepath.Join(c.MkDir(), "test.sock")
+	srv, err := server.NewServer(factory, s.sockPath)
+	c.Assert(err, IsNil)
+	c.Assert(srv, NotNil)
+	s.server = srv
+	s.err = make(chan error)
+	go func() { s.err <- s.server.Run() }()
+}
+
+func (s *ServerSuite) TearDownTest(c *C) {
+	s.server.Close()
+	c.Assert(<-s.err, IsNil)
+	_, err := os.Open(s.sockPath)
+	c.Assert(os.IsNotExist(err), Equals, true)
+}
+
+func (s *ServerSuite) Call(c *C, req server.Request) (resp server.Response, err error) {
+	client, err := rpc.Dial("unix", s.sockPath)
+	c.Assert(err, IsNil)
+	defer client.Close()
+	err = client.Call("Jujuc.Main", req, &resp)
+	return resp, err
+}
+
+func (s *ServerSuite) TestHappyPath(c *C) {
+	dir := c.MkDir()
+	resp, err := s.Call(c, server.Request{
+		"validCtx", dir, "remote", []string{"--value", "something"}})
+	c.Assert(err, IsNil)
+	c.Assert(resp.Code, Equals, 0)
+	c.Assert(string(resp.Stdout), Equals, "eye of newt\n")
+	c.Assert(string(resp.Stderr), Equals, "toe of frog\n")
+	content, err := ioutil.ReadFile(filepath.Join(dir, "local"))
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "something")
+}
+
+func (s *ServerSuite) TestBadCommandName(c *C) {
+	dir := c.MkDir()
+	_, err := s.Call(c, server.Request{"validCtx", dir, "", nil})
+	c.Assert(err, ErrorMatches, "bad request: command not specified")
+	_, err = s.Call(c, server.Request{"validCtx", dir, "witchcraft", nil})
+	c.Assert(err, ErrorMatches, `bad request: unknown command "witchcraft"`)
+}
+
+func (s *ServerSuite) TestBadDir(c *C) {
+	for _, req := range []server.Request{
+		{"validCtx", "", "anything", nil},
+		{"validCtx", "foo/bar", "anything", nil},
+	} {
+		_, err := s.Call(c, req)
+		c.Assert(err, ErrorMatches, "bad request: Dir is not absolute")
+	}
+}
+
+func (s *ServerSuite) TestBadContextId(c *C) {
+	_, err := s.Call(c, server.Request{"whatever", c.MkDir(), "remote", nil})
+	c.Assert(err, ErrorMatches, `bad request: unknown context "whatever"`)
+}
+
+func (s *ServerSuite) AssertBadCommand(c *C, args []string, code int) server.Response {
+	resp, err := s.Call(c, server.Request{"validCtx", c.MkDir(), args[0], args[1:]})
+	c.Assert(err, IsNil)
+	c.Assert(resp.Code, Equals, code)
+	return resp
+}
+
+func (s *ServerSuite) TestParseError(c *C) {
+	resp := s.AssertBadCommand(c, []string{"remote", "--cheese"}, 2)
+	c.Assert(string(resp.Stdout), Equals, "")
+	c.Assert(string(resp.Stderr), Equals, `usage: remote [options]
+purpose: act at a distance
+
+options:
+--value (= "")
+    doc
+
+blah doc
+error: flag provided but not defined: --cheese
+`)
+}
+
+func (s *ServerSuite) TestBrokenCommand(c *C) {
+	resp := s.AssertBadCommand(c, []string{"remote", "--value", "error"}, 1)
+	c.Assert(string(resp.Stdout), Equals, "")
+	c.Assert(string(resp.Stderr), Equals, "error: blam\n")
+}
 
=== added file 'cmd/jujuc/server/unit-get.go.OTHER'
--- cmd/jujuc/server/unit-get.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/unit-get.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,66 @@
+package server
+
+import (
+	"errors"
+	"fmt"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+)
+
+// UnitGetCommand implements the unit-get command.
+type UnitGetCommand struct {
+	*ClientContext
+	Key string
+	out output
+}
+
+func NewUnitGetCommand(ctx *ClientContext) (cmd.Command, error) {
+	if err := ctx.check(); err != nil {
+		return nil, err
+	}
+	return &UnitGetCommand{ClientContext: ctx}, nil
+}
+
+func (c *UnitGetCommand) Info() *cmd.Info {
+	return &cmd.Info{
+		"unit-get", "<setting>", "print public-address or private-address", "",
+	}
+}
+
+func (c *UnitGetCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	c.out.addFlags(f, "yaml", defaultFormatters)
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	args = f.Args()
+	if args == nil {
+		return errors.New("no setting specified")
+	}
+	if args[0] != "private-address" && args[0] != "public-address" {
+		return fmt.Errorf("unknown setting %q", args[0])
+	}
+	c.Key = args[0]
+	return cmd.CheckEmpty(args[1:])
+}
+
+func (c *UnitGetCommand) Run(ctx *cmd.Context) (err error) {
+	var unit *state.Unit
+	unit, err = c.State.Unit(c.LocalUnitName)
+	if err != nil {
+		return
+	}
+	var value string
+	if c.Key == "private-address" {
+		value, err = unit.PrivateAddress()
+	} else {
+		value, err = unit.PublicAddress()
+	}
+	if err != nil {
+		return
+	}
+	if c.out.testMode {
+		return truthError(value)
+	}
+	return c.out.write(ctx, value)
+}
 
=== added file 'cmd/jujuc/server/unit-get_test.go.OTHER'
--- cmd/jujuc/server/unit-get_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/unit-get_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,109 @@
+package server_test
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+	"path/filepath"
+)
+
+type UnitGetSuite struct {
+	UnitFixture
+}
+
+var _ = Suite(&UnitGetSuite{})
+
+func (s *UnitGetSuite) SetUpTest(c *C) {
+	s.UnitFixture.SetUpTest(c)
+	err := s.unit.SetPublicAddress("gimli.minecraft.example.com")
+	c.Assert(err, IsNil)
+	err = s.unit.SetPrivateAddress("192.168.0.99")
+	c.Assert(err, IsNil)
+}
+
+var unitGetTests = []struct {
+	args []string
+	out  string
+}{
+	{[]string{"private-address"}, "192.168.0.99\n\n"},
+	{[]string{"private-address", "--format", "yaml"}, "192.168.0.99\n\n"},
+	{[]string{"private-address", "--format", "json"}, `"192.168.0.99"` + "\n"},
+	{[]string{"public-address"}, "gimli.minecraft.example.com\n\n"},
+	{[]string{"public-address", "--format", "yaml"}, "gimli.minecraft.example.com\n\n"},
+	{[]string{"public-address", "--format", "json"}, `"gimli.minecraft.example.com"` + "\n"},
+}
+
+func (s *UnitGetSuite) TestOutputFormat(c *C) {
+	for _, t := range unitGetTests {
+		com, err := s.ctx.NewCommand("unit-get")
+		c.Assert(err, IsNil)
+		ctx := dummyContext(c)
+		code := cmd.Main(com, ctx, t.args)
+		c.Assert(code, Equals, 0)
+		c.Assert(bufferString(ctx.Stderr), Equals, "")
+		c.Assert(bufferString(ctx.Stdout), Matches, t.out)
+	}
+}
+
+func (s *UnitGetSuite) TestTestMode(c *C) {
+	for _, key := range []string{"public-address", "private-address"} {
+		com, err := s.ctx.NewCommand("unit-get")
+		c.Assert(err, IsNil)
+		ctx := dummyContext(c)
+		code := cmd.Main(com, ctx, []string{"--test", key})
+		c.Assert(code, Equals, 0)
+		c.Assert(bufferString(ctx.Stderr), Equals, "")
+		c.Assert(bufferString(ctx.Stdout), Equals, "")
+	}
+}
+
+func (s *UnitGetSuite) TestHelp(c *C) {
+	com, err := s.ctx.NewCommand("unit-get")
+	c.Assert(err, IsNil)
+	ctx := dummyContext(c)
+	code := cmd.Main(com, ctx, []string{"--help"})
+	c.Assert(code, Equals, 0)
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	c.Assert(bufferString(ctx.Stderr), Equals, `usage: unit-get [options] <setting>
+purpose: print public-address or private-address
+
+options:
+--format  (= yaml)
+    specify output format (json|yaml)
+-o, --output (= "")
+    specify an output file
+--test  (= false)
+    returns non-zero exit code if value is false/zero/empty
+`)
+}
+
+func (s *UnitGetSuite) TestOutputPath(c *C) {
+	com, err := s.ctx.NewCommand("unit-get")
+	c.Assert(err, IsNil)
+	ctx := dummyContext(c)
+	code := cmd.Main(com, ctx, []string{"--output", "some-file", "private-address"})
+	c.Assert(code, Equals, 0)
+	c.Assert(bufferString(ctx.Stderr), Equals, "")
+	c.Assert(bufferString(ctx.Stdout), Equals, "")
+	content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "some-file"))
+	c.Assert(err, IsNil)
+	c.Assert(string(content), Equals, "192.168.0.99\n\n")
+}
+
+func (s *UnitGetSuite) TestUnknownSetting(c *C) {
+	com, err := s.ctx.NewCommand("unit-get")
+	c.Assert(err, IsNil)
+	err = com.Init(dummyFlagSet(), []string{"protected-address"})
+	c.Assert(err, ErrorMatches, `unknown setting "protected-address"`)
+}
+
+func (s *UnitGetSuite) TestUnknownArg(c *C) {
+	com, err := s.ctx.NewCommand("unit-get")
+	c.Assert(err, IsNil)
+	err = com.Init(dummyFlagSet(), []string{"private-address", "blah"})
+	c.Assert(err, ErrorMatches, `unrecognized args: \["blah"\]`)
+}
+
+func (s *UnitGetSuite) TestUnitCommand(c *C) {
+	s.AssertUnitCommand(c, "unit-get")
+}
 
=== added file 'cmd/jujuc/server/util_test.go.OTHER'
--- cmd/jujuc/server/util_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujuc/server/util_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,149 @@
+package server_test
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	. "launchpad.net/gocheck"
+	"launchpad.net/gozk/zookeeper"
+	"launchpad.net/juju-core/juju/charm"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/cmd/jujuc/server"
+	"launchpad.net/juju-core/juju/state"
+	"launchpad.net/juju-core/juju/testing"
+	"net/url"
+	stdtesting "testing"
+)
+
+var zkAddr string
+
+func TestPackage(t *stdtesting.T) {
+	srv := testing.StartZkServer()
+	defer srv.Destroy()
+	var err error
+	zkAddr, err = srv.Addr()
+	if err != nil {
+		t.Fatalf("could not get ZooKeeper server address")
+	}
+	TestingT(t)
+}
+
+func addDummyCharm(c *C, st *state.State) *state.Charm {
+	ch := testing.Charms.Dir("dummy")
+	u := fmt.Sprintf("local:series/%s-%d", ch.Meta().Name, ch.Revision())
+	curl := charm.MustParseURL(u)
+	burl, err := url.Parse("http://bundle.url")
+	c.Assert(err, IsNil)
+	dummy, err := st.AddCharm(ch, curl, burl, "dummy-sha256")
+	c.Assert(err, IsNil)
+	return dummy
+}
+
+func dummyContext(c *C) *cmd.Context {
+	return &cmd.Context{c.MkDir(), &bytes.Buffer{}, &bytes.Buffer{}}
+}
+
+func bufferString(w io.Writer) string {
+	return w.(*bytes.Buffer).String()
+}
+
+type UnitFixture struct {
+	ctx     *server.ClientContext
+	service *state.Service
+	unit    *state.Unit
+}
+
+func (f *UnitFixture) SetUpTest(c *C) {
+	st, err := state.Initialize(&state.Info{
+		Addrs: []string{zkAddr},
+	})
+	c.Assert(err, IsNil)
+	f.ctx = &server.ClientContext{
+		Id:            "TestCtx",
+		State:         st,
+		LocalUnitName: "minecraft/0",
+	}
+	dummy := addDummyCharm(c, st)
+	f.service, err = st.AddService("minecraft", dummy)
+	c.Assert(err, IsNil)
+	f.unit, err = f.service.AddUnit()
+	c.Assert(err, IsNil)
+}
+
+func (f *UnitFixture) TearDownTest(c *C) {
+	zk, session, err := zookeeper.Dial(zkAddr, 15e9)
+	c.Assert(err, IsNil)
+	event := <-session
+	c.Assert(event.Ok(), Equals, true)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
+	testing.ZkRemoveTree(zk, "/")
+}
+
+func (f *UnitFixture) AssertUnitCommand(c *C, name string) {
+	ctx := &server.ClientContext{Id: "TestCtx", State: f.ctx.State}
+	com, err := ctx.NewCommand(name)
+	c.Assert(com, IsNil)
+	c.Assert(err, ErrorMatches, "context TestCtx is not attached to a unit")
+
+	ctx = &server.ClientContext{Id: "TestCtx", LocalUnitName: f.ctx.LocalUnitName}
+	com, err = ctx.NewCommand(name)
+	c.Assert(com, IsNil)
+	c.Assert(err, ErrorMatches, "context TestCtx cannot access state")
+}
+
+type TruthErrorSuite struct{}
+
+var _ = Suite(&TruthErrorSuite{})
+
+var truthErrorTests = []struct {
+	value interface{}
+	err   error
+}{
+	{0, cmd.ErrSilent},
+	{int8(0), cmd.ErrSilent},
+	{int16(0), cmd.ErrSilent},
+	{int32(0), cmd.ErrSilent},
+	{int64(0), cmd.ErrSilent},
+	{uint(0), cmd.ErrSilent},
+	{uint8(0), cmd.ErrSilent},
+	{uint16(0), cmd.ErrSilent},
+	{uint32(0), cmd.ErrSilent},
+	{uint64(0), cmd.ErrSilent},
+	{uintptr(0), cmd.ErrSilent},
+	{123, nil},
+	{int8(123), nil},
+	{int16(123), nil},
+	{int32(123), nil},
+	{int64(123), nil},
+	{uint(123), nil},
+	{uint8(123), nil},
+	{uint16(123), nil},
+	{uint32(123), nil},
+	{uint64(123), nil},
+	{uintptr(123), nil},
+	{0.0, cmd.ErrSilent},
+	{float32(0.0), cmd.ErrSilent},
+	{123.45, nil},
+	{float32(123.45), nil},
+	{nil, cmd.ErrSilent},
+	{"", cmd.ErrSilent},
+	{"blah", nil},
+	{true, nil},
+	{false, cmd.ErrSilent},
+	{[]string{}, cmd.ErrSilent},
+	{[]string{""}, nil},
+	{[]bool{}, cmd.ErrSilent},
+	{[]bool{false}, nil},
+	{map[string]string{}, cmd.ErrSilent},
+	{map[string]string{"": ""}, nil},
+	{map[bool]bool{}, cmd.ErrSilent},
+	{map[bool]bool{false: false}, nil},
+	{struct{ x bool }{false}, nil},
+}
+
+func (s *TruthErrorSuite) TestTruthError(c *C) {
+	for _, t := range truthErrorTests {
+		c.Assert(server.TruthError(t.value), Equals, t.err)
+	}
+}
 
=== added directory 'cmd/jujud'
=== added file 'cmd/jujud/agent.go.OTHER'
--- cmd/jujud/agent.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujud/agent.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"fmt"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+	"regexp"
+	"strings"
+)
+
+// requiredError is useful when complaining about missing command-line options.
+func requiredError(name string) error {
+	return fmt.Errorf("--%s option must be set", name)
+}
+
+// stateInfoValue implements gnuflag.Value on a state.Info.
+type stateInfoValue state.Info
+
+var validAddr = regexp.MustCompile("^.+:[0-9]+$")
+
+// Set splits the comma-separated list of ZooKeeper addresses and stores
+// onto v's Addrs. Addresses must include port numbers.
+func (v *stateInfoValue) Set(value string) error {
+	addrs := strings.Split(value, ",")
+	for _, addr := range addrs {
+		if !validAddr.MatchString(addr) {
+			return fmt.Errorf("%q is not a valid zookeeper address", addr)
+		}
+	}
+	v.Addrs = addrs
+	return nil
+}
+
+// String returns the list of ZooKeeper addresses joined by commas.
+func (v *stateInfoValue) String() string {
+	if v.Addrs != nil {
+		return strings.Join(v.Addrs, ",")
+	}
+	return ""
+}
+
+// stateInfoVar sets up a gnuflag flag analagously to FlagSet.*Var methods.
+func stateInfoVar(fs *gnuflag.FlagSet, target *state.Info, name string, value []string, usage string) {
+	target.Addrs = value
+	fs.Var((*stateInfoValue)(target), name, usage)
+}
+
+// AgentConf handles command-line flags shared by all agents.
+type AgentConf struct {
+	JujuDir   string // Defaults to "/var/lib/juju".
+	StateInfo state.Info
+}
+
+// addFlags injects common agent flags into f.
+func (c *AgentConf) addFlags(f *gnuflag.FlagSet) {
+	f.StringVar(&c.JujuDir, "juju-directory", "/var/lib/juju", "juju working directory")
+	stateInfoVar(f, &c.StateInfo, "zookeeper-servers", nil, "zookeeper servers to connect to")
+}
+
+// checkArgs checks that required flags have been set and that args is empty.
+func (c *AgentConf) checkArgs(args []string) error {
+	if c.JujuDir == "" {
+		return requiredError("juju-directory")
+	}
+	if c.StateInfo.Addrs == nil {
+		return requiredError("zookeeper-servers")
+	}
+	return cmd.CheckEmpty(args)
+}
 
=== added file 'cmd/jujud/initzk.go.OTHER'
--- cmd/jujud/initzk.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujud/initzk.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+	"launchpad.net/juju-core/juju/state"
+)
+
+type InitzkCommand struct {
+	StateInfo  state.Info
+	InstanceId string
+	EnvType    string
+}
+
+// Info returns a decription of the command.
+func (c *InitzkCommand) Info() *cmd.Info {
+	return &cmd.Info{"initzk", "", "initialize juju state in a local zookeeper", ""}
+}
+
+// Init initializes the command for running.
+func (c *InitzkCommand) Init(f *gnuflag.FlagSet, args []string) error {
+	stateInfoVar(f, &c.StateInfo, "zookeeper-servers", []string{"127.0.0.1:2181"}, "address of zookeeper to initialize")
+	f.StringVar(&c.InstanceId, "instance-id", "", "instance id of this machine")
+	f.StringVar(&c.EnvType, "env-type", "", "environment type")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	if c.StateInfo.Addrs == nil {
+		return requiredError("zookeeper-servers")
+	}
+	if c.InstanceId == "" {
+		return requiredError("instance-id")
+	}
+	if c.EnvType == "" {
+		return requiredError("env-type")
+	}
+	return cmd.CheckEmpty(f.Args())
+}
+
+// Run initializes zookeeper state for an environment.
+func (c *InitzkCommand) Run(_ *cmd.Context) error {
+	_, err := state.Initialize(&c.StateInfo)
+	return err
+}
 
=== added file 'cmd/jujud/initzk_test.go.OTHER'
--- cmd/jujud/initzk_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujud/initzk_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,78 @@
+package main
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/gozk/zookeeper"
+	"launchpad.net/juju-core/juju/testing"
+	stdtesting "testing"
+)
+
+var zkAddr string
+
+func TestPackage(t *stdtesting.T) {
+	srv := testing.StartZkServer()
+	defer srv.Destroy()
+	var err error
+	zkAddr, err = srv.Addr()
+	if err != nil {
+		t.Fatalf("could not get ZooKeeper server address")
+	}
+	TestingT(t)
+}
+
+type InitzkSuite struct {
+	zkConn *zookeeper.Conn
+	path   string
+}
+
+var _ = Suite(&InitzkSuite{})
+
+func (s *InitzkSuite) SetUpTest(c *C) {
+	zk, session, err := zookeeper.Dial(zkAddr, 15e9)
+	c.Assert(err, IsNil)
+	event := <-session
+	c.Assert(event.Ok(), Equals, true)
+	c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
+	c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
+
+	s.zkConn = zk
+	s.path = "/watcher"
+
+	c.Assert(err, IsNil)
+}
+
+func (s *InitzkSuite) TearDownTest(c *C) {
+	testing.ZkRemoveTree(s.zkConn, s.path)
+	s.zkConn.Close()
+}
+
+func initInitzkCommand(args []string) (*InitzkCommand, error) {
+	c := &InitzkCommand{}
+	return c, initCmd(c, args)
+}
+
+func (s *InitzkSuite) TestParse(c *C) {
+	args := []string{}
+	_, err := initInitzkCommand(args)
+	c.Assert(err, ErrorMatches, "--instance-id option must be set")
+
+	args = append(args, "--instance-id", "iWhatever")
+	_, err = initInitzkCommand(args)
+	c.Assert(err, ErrorMatches, "--env-type option must be set")
+
+	args = append(args, "--env-type", "dummy")
+	izk, err := initInitzkCommand(args)
+	c.Assert(err, IsNil)
+	c.Assert(izk.StateInfo.Addrs, DeepEquals, []string{"127.0.0.1:2181"})
+	c.Assert(izk.InstanceId, Equals, "iWhatever")
+	c.Assert(izk.EnvType, Equals, "dummy")
+
+	args = append(args, "--zookeeper-servers", "zk1:2181,zk2:2181")
+	izk, err = initInitzkCommand(args)
+	c.Assert(err, IsNil)
+	c.Assert(izk.StateInfo.Addrs, DeepEquals, []string{"zk1:2181", "zk2:2181"})
+
+	args = append(args, "haha disregard that")
+	_, err = initInitzkCommand(args)
+	c.Assert(err, ErrorMatches, `unrecognized args: \["haha disregard that"\]`)
+}
 
=== added file 'cmd/jujud/machine.go.OTHER'
--- cmd/jujud/machine.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujud/machine.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+	"launchpad.net/gnuflag"
+	"launchpad.net/juju-core/juju/cmd"
+)
+
+// MachineAgent is a cmd.Command responsible for running a machine agent.
+type MachineAgent struct {
+	Conf      AgentConf
+	MachineId int
+}
+
+// Info returns usage information for the command.
+func (a *MachineAgent) Info() *cmd.Info {
+	return &cmd.Info{"machine", "", "run a juju machine agent", ""}
+}
+
+// Init initializes the command for running.
+func (a *MachineAgent) Init(f *gnuflag.FlagSet, args []string) error {
+	a.Conf.addFlags(f)
+	f.IntVar(&a.MachineId, "machine-id", -1, "id of the machine to run")
+	if err := f.Parse(true, args); err != nil {
+		return err
+	}
+	if a.MachineId < 0 {
+		return fmt.Errorf("--machine-id option must be set, and expects a non-negative integer")
+	}
+	return a.Conf.checkArgs(f.Args())
+}
+
+// Run runs a machine agent.
+func (a *MachineAgent) Run(_ *cmd.Context) error {
+	return fmt.Errorf("MachineAgent.Run not implemented")
+}
 
=== added file 'cmd/jujud/machine_test.go.OTHER'
--- cmd/jujud/machine_test.go.OTHER	1970-01-01 00:00:00 +0000
+++ cmd/jujud/machine_test.go.OTHER	2012-06-07 11:57:18 +0000
@@ -0,0 +1,35 @@
+package main
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju-core/juju/cmd"
+)
+
+type MachineSuite struct{}
+
+var _ = Suite(&MachineSuite{})
+
+func (s *MachineSuite) TestParseSuccess(c *C) {
+	create := func() (cmd.Command, *AgentConf) {
+		a := &MachineAgent{}
+		return a, &a.Conf
+	}
+	a := CheckAgentCommand(c, create, []string{"--machine-id", "42"})
+	c.Assert(a.(*MachineAgent).MachineId, Equals, 42)
+}
+
+func (s *MachineSuite) TestParseNonsense(c *C) {
+	for _, args := range [][]string{
+		[]string{},
+		[]string{"--machine-id", "-4004"},
+	} {