Merge lp:~fwereade/pyjuju/go-add-control-package into lp:pyjuju

[William Reade]

First flailing attempts at using go

Profoundly incomplete control package for juju, with a few tests. Usage
output is definitely broken; I'm not aware of anything else that is actively
*wrong*. Not using gnu-style flags package yet.

[lp:~fwereade/pyjuju/go-add-control-package]

38. By William Reade on 2012-01-18

merge go-add-control-package

Unmerged revisions

38. By William Reade on 2012-01-18

merge go-add-control-package

37. By Gustavo Niemeyer on 2012-01-17

build: remove all.bash and fix .lbox

R=rog
CC=
https://codereview.appspot.com/5539069

36. By Roger Peppe on 2012-01-17

environs/ec2: launch instances in named security groups

R=niemeyer
CC=
https://codereview.appspot.com/5532058

35. By Gustavo Niemeyer on 2012-01-13

store: base support for storing charms

R=
CC=
https://codereview.appspot.com/5504047

34. By Gustavo Niemeyer on 2012-01-13

store: save charm config and meta

This turns CharmInfo into a charm.Charm!

R=rog
CC=
https://codereview.appspot.com/5532049

33. By Frank Mueller on 2012-01-12

Initial adding of the state model to the Go port of juju

As a first step in adding the Go port the state can be opened and first
operations ond Service and Unit can be done. Also needed first topology
functionality is part of this branch.

R=
CC=
https://codereview.appspot.com/5502043

32. By Roger Peppe on 2011-12-19

environs/ec2test: add new test suite for live tests

R=niemeyer
CC=
https://codereview.appspot.com/5490073

31. By Gustavo Niemeyer on 2011-12-19

charm: must handle new revision schema

Revision handling was moved out of the metadata.yaml file.
The Go port most be updated to handle it.

This branch implements the new schema for charm revision handling
in an independent file, including backwards compatibility with
the previous schema, and also SetVersion methods that enable
bundling and expanding charms with custom revisions
(necessary for store).

R=rog
CC=
https://codereview.appspot.com/5489087

30. By Roger Peppe on 2011-12-16

juju: rename to "environs"

R=niemeyer
CC=
https://codereview.appspot.com/5495052

29. By Roger Peppe on 2011-12-16

merge go-juju-ec2-operations

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+*.6
+_obj
+_test
+6.out
+_testmain.go
 
=== renamed file '.bzrignore' => '.bzrignore.moved'
=== added file '.lbox'
--- .lbox	1970-01-01 00:00:00 +0000
+++ .lbox	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+propose -cr -for lp:juju/go
 
=== added directory 'charm'
=== added file 'charm/Makefile'
--- charm/Makefile	1970-01-01 00:00:00 +0000
+++ charm/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,28 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/charm
+
+GOFILES=\
+	bundle.go\
+	config.go\
+	dir.go\
+	charm.go\
+	meta.go\
+	url.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'charm/bundle.go'
--- charm/bundle.go	1970-01-01 00:00:00 +0000
+++ charm/bundle.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,222 @@
+package charm
+
+import (
+	"archive/zip"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// The Bundle type encapsulates access to data and operations
+// on a charm bundle.
+type Bundle struct {
+	Path     string // May be empty if Bundle wasn't read from a file
+	meta     *Meta
+	config   *Config
+	revision int
+	r        io.ReaderAt
+	size     int64
+}
+
+// Trick to ensure *Bundle implements the Charm interface.
+var _ Charm = (*Bundle)(nil)
+
+// ReadBundle returns a Bundle for the charm in path.
+func ReadBundle(path string) (bundle *Bundle, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	fi, err := f.Stat()
+	if err != nil {
+		return
+	}
+	b, err := readBundle(f, fi.Size())
+	if err != nil {
+		return
+	}
+	b.Path = path
+	return b, nil
+}
+
+// ReadBundleBytes returns a Bundle read from the given data.
+// Make sure the bundle fits in memory before using this.
+func ReadBundleBytes(data []byte) (bundle *Bundle, err error) {
+	return readBundle(readAtBytes(data), int64(len(data)))
+}
+
+func readBundle(r io.ReaderAt, size int64) (bundle *Bundle, err error) {
+	b := &Bundle{r: r, size: size}
+	zipr, err := zip.NewReader(r, size)
+	if err != nil {
+		return
+	}
+
+	reader, err := zipOpen(zipr, "metadata.yaml")
+	if err != nil {
+		return
+	}
+	b.meta, err = ReadMeta(reader)
+	reader.Close()
+	if err != nil {
+		return
+	}
+
+	reader, err = zipOpen(zipr, "config.yaml")
+	if err != nil {
+		return
+	}
+	b.config, err = ReadConfig(reader)
+	reader.Close()
+	if err != nil {
+		return
+	}
+
+	reader, err = zipOpen(zipr, "revision")
+	if err != nil {
+		if _, ok := err.(noBundleFile); !ok {
+			return
+		}
+		b.revision = b.meta.OldRevision
+	} else {
+		_, err = fmt.Fscan(reader, &b.revision)
+		if err != nil {
+			return nil, errors.New("invalid revision file")
+		}
+	}
+	return b, nil
+}
+
+func zipOpen(zipr *zip.Reader, path string) (rc io.ReadCloser, err error) {
+	for _, fh := range zipr.File {
+		if fh.Name == path {
+			return fh.Open()
+		}
+	}
+	return nil, noBundleFile{path}
+}
+
+type noBundleFile struct {
+	path string
+}
+
+func (err noBundleFile) Error() string {
+	return fmt.Sprintf("bundle file not found: %s", err.path)
+}
+
+// Revision returns the revision number for the charm
+// expanded in dir.
+func (b *Bundle) Revision() int {
+	return b.revision
+}
+
+// SetRevision changes the charm revision number. This affects the
+// revision reported by Revision and the revision of the charm
+// directory created by ExpandTo.
+func (b *Bundle) SetRevision(revision int) {
+	b.revision = revision
+}
+
+// Meta returns the Meta representing the metadata.yaml file from bundle.
+func (b *Bundle) Meta() *Meta {
+	return b.meta
+}
+
+// Config returns the Config representing the config.yaml file
+// for the charm bundle.
+func (b *Bundle) Config() *Config {
+	return b.config
+}
+
+// ExpandTo expands the charm bundle into dir, creating it if necessary.
+// If any errors occur during the expansion procedure, the process will
+// continue. Only the last error found is returned.
+func (b *Bundle) ExpandTo(dir string) (err error) {
+	// If we have a Path, reopen the file. Otherwise, try to use
+	// the original ReaderAt.
+	r := b.r
+	size := b.size
+	if b.Path != "" {
+		f, err := os.Open(b.Path)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+		fi, err := f.Stat()
+		if err != nil {
+			return err
+		}
+		r = f
+		size = fi.Size()
+	}
+
+	zipr, err := zip.NewReader(r, size)
+	if err != nil {
+		return err
+	}
+
+	var lasterr error
+	for _, zfile := range zipr.File {
+		if err := b.expand(dir, zfile); err != nil {
+			lasterr = err
+		}
+	}
+
+	revFile, err := os.Create(filepath.Join(dir, "revision"))
+	if err != nil {
+		return err
+	}
+	_, err = revFile.Write([]byte(strconv.Itoa(b.revision)))
+	revFile.Close()
+	if err != nil {
+		return err
+	}
+	return lasterr
+}
+
+func (b *Bundle) expand(dir string, zfile *zip.File) error {
+	cleanName := filepath.Clean(zfile.Name)
+	if cleanName == "revision" {
+		return nil
+	}
+
+	r, err := zfile.Open()
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+
+	path := filepath.Join(dir, cleanName)
+	if strings.HasSuffix(zfile.Name, "/") {
+		err = os.MkdirAll(path, 0755)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
+	base, _ := filepath.Split(path)
+	err = os.MkdirAll(base, 0755)
+	if err != nil {
+		return err
+	}
+	f, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(f, r)
+	f.Close()
+	return err
+}
+
+// FWIW, being able to do this is awesome.
+type readAtBytes []byte
+
+func (b readAtBytes) ReadAt(out []byte, off int64) (n int, err error) {
+	return copy(out, b[off:]), nil
+}
 
=== added file 'charm/bundle_test.go'
--- charm/bundle_test.go	1970-01-01 00:00:00 +0000
+++ charm/bundle_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,122 @@
+package charm_test
+
+import (
+	"fmt"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/charm"
+	"os"
+	"os/exec"
+	"path/filepath"
+)
+
+type BundleSuite struct {
+	bundlePath string
+}
+
+var _ = Suite(&BundleSuite{})
+
+func (s *BundleSuite) SetUpSuite(c *C) {
+	s.bundlePath = bundleDir(c, repoDir("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) 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) TestBundleRevisionFile(c *C) {
+	charmDir := c.MkDir()
+	copyCharmDir(charmDir, repoDir("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 bundleDir(c *C, dirpath string) (path string) {
+	dir, err := charm.ReadDir(dirpath)
+	c.Assert(err, IsNil)
+
+	path = filepath.Join(c.MkDir(), "bundle.charm")
+
+	file, err := os.Create(path)
+	c.Assert(err, IsNil)
+
+	err = dir.BundleTo(file)
+	c.Assert(err, IsNil)
+	file.Close()
+
+	return path
+}
+
+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 -r %s .", dirpath, path))
+	output, err := cmd.CombinedOutput()
+	c.Assert(err, IsNil, Bug("Command output: %s", output))
+	return path
+}
 
=== added file 'charm/charm.go'
--- charm/charm.go	1970-01-01 00:00:00 +0000
+++ charm/charm.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,9 @@
+package charm
+
+// The Charm interface is implemented by any type that
+// may be handled as a charm.
+type Charm interface {
+	Meta() *Meta
+	Config() *Config
+	Revision() int
+}
 
=== added file 'charm/charm_test.go'
--- charm/charm_test.go	1970-01-01 00:00:00 +0000
+++ charm/charm_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,58 @@
+package charm_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju/go/charm"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	TestingT(t)
+}
+
+type S struct{}
+
+var _ = Suite(&S{})
+
+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)
+		_, err := os.Stat(filepath.Join(path, "src", "hello.c"))
+		c.Assert(err, IsNil)
+	}
+}
+
+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'
--- charm/config.go	1970-01-01 00:00:00 +0000
+++ charm/config.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,117 @@
+package charm
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju/go/schema"
+	"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
+}
+
+// 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 = &Config{}
+	config.Options = make(map[string]Option)
+	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"]
+		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
+		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 optionSchema = schema.FieldMap(
+	schema.Fields{
+		"type":        schema.OneOf(schema.Const("string"), schema.Const("int"), schema.Const("float")),
+		"default":     schema.OneOf(schema.String(), schema.Int(), schema.Float()),
+		"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'
--- charm/config_test.go	1970-01-01 00:00:00 +0000
+++ charm/config_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,143 @@
+package charm_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/charm"
+	"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
+`
+
+func repoConfig(name string) io.Reader {
+	file, err := os.Open(filepath.Join("testrepo", "series", name, "config.yaml"))
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewBuffer(data)
+}
+
+func (s *S) TestReadConfig(c *C) {
+	config, err := charm.ReadConfig(repoConfig("dummy"))
+	c.Assert(err, IsNil)
+	c.Assert(config.Options["title"], Equals,
+		charm.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+}
+
+func (s *S) 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 *S) TestParseSample(c *C) {
+	config, err := charm.ReadConfig(bytes.NewBuffer([]byte(sampleConfig)))
+	c.Assert(err, IsNil)
+
+	opt := config.Options
+	c.Assert(opt["title"], Equals,
+		charm.Option{
+			Default:     "My Title",
+			Description: "A descriptive title used for the service.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["outlook"], Equals,
+		charm.Option{
+			Description: "No default outlook.",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["username"], Equals,
+		charm.Option{
+			Default:     "admin001",
+			Description: "The name of the initial account (given admin permissions).",
+			Type:        "string",
+		},
+	)
+	c.Assert(opt["skill-level"], Equals,
+		charm.Option{
+			Description: "A number indicating skill.",
+			Type:        "int",
+		},
+	)
+}
+
+func (s *S) 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, Equals, 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, Equals, 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"
+
+	// 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.go'
--- charm/dir.go	1970-01-01 00:00:00 +0000
+++ charm/dir.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,174 @@
+package charm
+
+import (
+	"archive/zip"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strconv"
+	"syscall"
+)
+
+// The Dir type encapsulates access to data and operations
+// on a charm directory.
+type Dir struct {
+	Path     string
+	meta     *Meta
+	config   *Config
+	revision int
+}
+
+// Trick to ensure *Dir implements the Charm interface.
+var _ Charm = (*Dir)(nil)
+
+// ReadDir returns a Dir representing an expanded charm directory.
+func ReadDir(path string) (dir *Dir, err error) {
+	dir = &Dir{Path: path}
+	file, err := os.Open(dir.join("metadata.yaml"))
+	if err != nil {
+		return nil, err
+	}
+	dir.meta, err = ReadMeta(file)
+	file.Close()
+	if err != nil {
+		return nil, err
+	}
+	file, err = os.Open(dir.join("config.yaml"))
+	if err != nil {
+		return nil, err
+	}
+	dir.config, err = ReadConfig(file)
+	file.Close()
+	if err != nil {
+		return nil, err
+	}
+	if file, err = os.Open(dir.join("revision")); err == nil {
+		_, err = fmt.Fscan(file, &dir.revision)
+		file.Close()
+		if err != nil {
+			return nil, errors.New("invalid revision file")
+		}
+	} else {
+		dir.revision = dir.meta.OldRevision
+	}
+	return dir, nil
+}
+
+// join builds a path rooted at the charm's expanded directory
+// path and the extra path components provided.
+func (dir *Dir) join(parts ...string) string {
+	parts = append([]string{dir.Path}, parts...)
+	return filepath.Join(parts...)
+}
+
+// Revision returns the revision number for the charm
+// expanded in dir.
+func (dir *Dir) Revision() int {
+	return dir.revision
+}
+
+// Meta returns the Meta representing the metadata.yaml file
+// for the charm expanded in dir.
+func (dir *Dir) Meta() *Meta {
+	return dir.meta
+}
+
+// Config returns the Config representing the config.yaml file
+// for the charm expanded in dir.
+func (dir *Dir) Config() *Config {
+	return dir.config
+}
+
+// SetRevision changes the charm revision number. This affects
+// the revision reported by Revision and the revision of the
+// charm bundled by BundleTo.
+// The revision file in the charm directory is not modified.
+func (dir *Dir) SetRevision(revision int) {
+	dir.revision = revision
+}
+
+// SetDiskRevision does the same as SetRevision but also changes
+// the revision file in the charm directory.
+func (dir *Dir) SetDiskRevision(revision int) error {
+	dir.SetRevision(revision)
+	file, err := os.OpenFile(dir.join("revision"), os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return err
+	}
+	_, err = file.Write([]byte(strconv.Itoa(revision)))
+	file.Close()
+	return err
+}
+
+// BundleTo creates a charm file from the charm expanded in dir.
+func (dir *Dir) BundleTo(w io.Writer) (err error) {
+	zipw := zip.NewWriter(w)
+	defer zipw.Close()
+	zp := zipPacker{zipw, dir.Path}
+	zp.AddRevision(dir.revision)
+	return filepath.Walk(dir.Path, zp.WalkFunc())
+}
+
+type zipPacker struct {
+	*zip.Writer
+	root string
+}
+
+func (zp *zipPacker) WalkFunc() filepath.WalkFunc {
+	return func(path string, fi os.FileInfo, err error) error {
+		return zp.visit(path, fi, err)
+	}
+}
+
+func (zp *zipPacker) AddRevision(revision int) error {
+	h := &zip.FileHeader{Name: "revision"}
+	h.SetMode(syscall.S_IFREG | 0644)
+	w, err := zp.CreateHeader(h)
+	if err == nil {
+		_, err = w.Write([]byte(strconv.Itoa(revision)))
+	}
+	return err
+}
+
+func (zp *zipPacker) visit(path string, fi os.FileInfo, err error) error {
+	if err != nil {
+		return err
+	}
+	relpath, err := filepath.Rel(zp.root, path)
+	if err != nil {
+		return err
+	}
+	method := zip.Deflate
+	hidden := len(relpath) > 1 && relpath[0] == '.'
+	if fi.IsDir() {
+		if relpath == "build" {
+			return filepath.SkipDir
+		}
+		if hidden {
+			return filepath.SkipDir
+		}
+		relpath += "/"
+		method = zip.Store
+	}
+	if hidden || relpath == "revision" {
+		return nil
+	}
+	h := &zip.FileHeader{
+		Name:   relpath,
+		Method: method,
+	}
+	h.SetMode(fi.Mode())
+	w, err := zp.CreateHeader(h)
+	if err != nil || fi.IsDir() {
+		return err
+	}
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		return err
+	}
+	_, err = w.Write(data)
+	return err
+}
 
=== added file 'charm/dir_test.go'
--- charm/dir_test.go	1970-01-01 00:00:00 +0000
+++ charm/dir_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,167 @@
+package charm_test
+
+import (
+	"archive/zip"
+	"bytes"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/charm"
+	"os"
+	"path/filepath"
+)
+
+func repoDir(name string) (path string) {
+	return filepath.Join("testrepo", "series", name)
+}
+
+func (s *S) TestReadDir(c *C) {
+	path := repoDir("dummy")
+	dir, err := charm.ReadDir(path)
+	c.Assert(err, IsNil)
+	checkDummy(c, dir, path)
+}
+
+func (s *S) TestBundleTo(c *C) {
+	dir, err := charm.ReadDir(repoDir("dummy"))
+	c.Assert(err, IsNil)
+
+	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 *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 "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)
+	mode, err := instf.Mode()
+	c.Assert(err, IsNil)
+	c.Assert(mode&0700, Equals, os.FileMode(0700))
+
+	c.Assert(emptyf, NotNil)
+	mode, err = emptyf.Mode()
+	c.Assert(err, IsNil)
+	c.Assert(mode&os.ModeType, Equals, os.ModeDir)
+}
+
+func copyCharmDir(dst, src string) {
+	dir, err := charm.ReadDir(src)
+	if err != nil {
+		panic(err)
+	}
+	var b bytes.Buffer
+	err = dir.BundleTo(&b)
+	if err != nil {
+		panic(err)
+	}
+	bundle, err := charm.ReadBundleBytes(b.Bytes())
+	if err != nil {
+		panic(err)
+	}
+	err = bundle.ExpandTo(dst)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (s *S) TestDirRevisionFile(c *C) {
+	charmDir := c.MkDir()
+	copyCharmDir(charmDir, repoDir("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 *S) TestDirSetRevision(c *C) {
+	dir, err := charm.ReadDir(repoDir("dummy"))
+	c.Assert(err, IsNil)
+
+	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 *S) TestDirSetDiskRevision(c *C) {
+	charmDir := c.MkDir()
+	copyCharmDir(charmDir, repoDir("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'
--- charm/export_test.go	1970-01-01 00:00:00 +0000
+++ charm/export_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,11 @@
+package charm
+
+import (
+	"launchpad.net/juju/go/schema"
+)
+
+// Export meaningful bits for tests only.
+
+func IfaceExpander(limit interface{}) schema.Checker {
+	return ifaceExpander(limit)
+}
 
=== added file 'charm/meta.go'
--- charm/meta.go	1970-01-01 00:00:00 +0000
+++ charm/meta.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,163 @@
+package charm
+
+import (
+	"errors"
+	"io"
+	"io/ioutil"
+	"launchpad.net/goyaml"
+	"launchpad.net/juju/go/schema"
+)
+
+// Relation represents a single relation defined in the charm
+// metadata.yaml file.
+type Relation struct {
+	Interface string
+	Optional  bool
+	Limit     int
+}
+
+// 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
+}
+
+// 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))
+	}
+	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 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,
+		}
+		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
+	}
+	return ifaceSchema.Coerce(m, path)
+}
+
+var ifaceSchema = schema.FieldMap(schema.Fields{
+	"interface": schema.String(),
+	"limit":     schema.OneOf(schema.Const(nil), schema.Int()),
+	"optional":  schema.Bool(),
+}, nil)
+
+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
+	},
+	schema.Optional{"provides", "requires", "peers", "revision"},
+)
 
=== added file 'charm/meta_test.go'
--- charm/meta_test.go	1970-01-01 00:00:00 +0000
+++ charm/meta_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,108 @@
+package charm_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/charm"
+	"launchpad.net/juju/go/schema"
+	"os"
+	"path/filepath"
+)
+
+func repoMeta(name string) io.Reader {
+	file, err := os.Open(filepath.Join("testrepo", "series", name, "metadata.yaml"))
+	if err != nil {
+		panic(err)
+	}
+	defer file.Close()
+	data, err := ioutil.ReadAll(file)
+	if err != nil {
+		panic(err)
+	}
+	return bytes.NewBuffer(data)
+}
+
+func (s *S) 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)
+}
+
+func (s *S) TestParseMetaRelations(c *C) {
+	meta, err := charm.ReadMeta(repoMeta("mysql"))
+	c.Assert(err, IsNil)
+	c.Assert(meta.Provides["server"], Equals, charm.Relation{Interface: "mysql"})
+	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"})
+	c.Assert(meta.Provides["admin"], Equals, charm.Relation{Interface: "http"})
+	c.Assert(meta.Peers["ring"], Equals, charm.Relation{Interface: "riak", Limit: 1})
+	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"})
+	c.Assert(meta.Requires["db"], Equals, charm.Relation{Interface: "mysql", Limit: 1})
+	c.Assert(meta.Requires["cache"], Equals, charm.Relation{Interface: "varnish", Limit: 2, Optional: true})
+	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 *S) 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, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": false})
+
+	// Defaults are properly applied
+	v, err = e.Coerce(schema.MapType{"interface": "http"}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": false})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "limit": 2}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": int64(2), "optional": false})
+
+	v, err = e.Coerce(schema.MapType{"interface": "http", "optional": true}, path)
+	c.Assert(err, IsNil)
+	c.Assert(v, Equals, schema.MapType{"interface": "http", "limit": nil, "optional": true})
+
+	// 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, Equals, schema.MapType{"interface": "http", "limit": int64(1), "optional": false})
+}
 
=== added directory 'charm/testrepo'
=== added directory 'charm/testrepo/series'
=== added directory 'charm/testrepo/series/dummy'
=== added directory 'charm/testrepo/series/dummy/.dir'
=== added file 'charm/testrepo/series/dummy/.dir/ignored'
=== added file 'charm/testrepo/series/dummy/.ignored'
--- charm/testrepo/series/dummy/.ignored	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/.ignored	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+#
 \ No newline at end of file
 
=== added directory 'charm/testrepo/series/dummy/build'
=== added file 'charm/testrepo/series/dummy/build/ignored'
=== added file 'charm/testrepo/series/dummy/config.yaml'
--- charm/testrepo/series/dummy/config.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/config.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+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}
 
=== added directory 'charm/testrepo/series/dummy/empty'
=== added directory 'charm/testrepo/series/dummy/hooks'
=== added file 'charm/testrepo/series/dummy/hooks/install'
--- charm/testrepo/series/dummy/hooks/install	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/hooks/install	2012-01-18 17:30:30 +0000
@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Done!"
 
=== added file 'charm/testrepo/series/dummy/metadata.yaml'
--- charm/testrepo/series/dummy/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: dummy
+summary: "That's a dummy charm."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.
 
=== added file 'charm/testrepo/series/dummy/revision'
--- charm/testrepo/series/dummy/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 \ No newline at end of file
 
=== added directory 'charm/testrepo/series/dummy/src'
=== added file 'charm/testrepo/series/dummy/src/hello.c'
--- charm/testrepo/series/dummy/src/hello.c	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/dummy/src/hello.c	2012-01-18 17:30:30 +0000
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+main()
+{
+    printf ("Hello World!\n");
+    return 0;
+}
 
=== added directory 'charm/testrepo/series/mysql'
=== added directory 'charm/testrepo/series/mysql-alternative'
=== added file 'charm/testrepo/series/mysql-alternative/metadata.yaml'
--- charm/testrepo/series/mysql-alternative/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/mysql-alternative/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,9 @@
+name: mysql-alternative
+summary: "Database engine"
+description: "A pretty popular database"
+provides:
+  prod:
+    interface: mysql
+  dev:
+    interface: mysql
+    limit: 2
 
=== added file 'charm/testrepo/series/mysql-alternative/revision'
--- charm/testrepo/series/mysql-alternative/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/mysql-alternative/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 \ No newline at end of file
 
=== added file 'charm/testrepo/series/mysql/metadata.yaml'
--- charm/testrepo/series/mysql/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/mysql/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: mysql
+summary: "Database engine"
+description: "A pretty popular database"
+provides:
+  server: mysql
 
=== added file 'charm/testrepo/series/mysql/revision'
--- charm/testrepo/series/mysql/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/mysql/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 \ No newline at end of file
 
=== added directory 'charm/testrepo/series/new'
=== added file 'charm/testrepo/series/new/metadata.yaml'
--- charm/testrepo/series/new/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/new/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: sample
+summary: "That's a sample charm."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.
 
=== added file 'charm/testrepo/series/new/revision'
--- charm/testrepo/series/new/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/new/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+2
 
=== added directory 'charm/testrepo/series/old'
=== added file 'charm/testrepo/series/old/metadata.yaml'
--- charm/testrepo/series/old/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/old/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: sample
+summary: "That's a sample charm."
+description: |
+    This is a longer description which
+    potentially contains multiple lines.
 
=== added file 'charm/testrepo/series/old/revision'
--- charm/testrepo/series/old/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/old/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 
=== added directory 'charm/testrepo/series/riak'
=== added file 'charm/testrepo/series/riak/metadata.yaml'
--- charm/testrepo/series/riak/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/riak/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,11 @@
+name: riak
+summary: "K/V storage engine"
+description: "Scalable K/V Store in Erlang with Clocks :-)"
+provides:
+  endpoint:
+    interface: http
+  admin:
+    interface: http
+peers:
+  ring:
+    interface: riak
 
=== added file 'charm/testrepo/series/riak/revision'
--- charm/testrepo/series/riak/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/riak/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+7
 \ No newline at end of file
 
=== added directory 'charm/testrepo/series/varnish'
=== added directory 'charm/testrepo/series/varnish-alternative'
=== added directory 'charm/testrepo/series/varnish-alternative/hooks'
=== added file 'charm/testrepo/series/varnish-alternative/hooks/install'
--- charm/testrepo/series/varnish-alternative/hooks/install	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/varnish-alternative/hooks/install	2012-01-18 17:30:30 +0000
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo hello world
 \ No newline at end of file
 
=== added file 'charm/testrepo/series/varnish-alternative/metadata.yaml'
--- charm/testrepo/series/varnish-alternative/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/varnish-alternative/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: varnish-alternative
+summary: "Database engine"
+description: "Another popular database"
+provides:
+  webcache: varnish
 
=== added file 'charm/testrepo/series/varnish-alternative/revision'
--- charm/testrepo/series/varnish-alternative/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/varnish-alternative/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 \ No newline at end of file
 
=== added file 'charm/testrepo/series/varnish/metadata.yaml'
--- charm/testrepo/series/varnish/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/varnish/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,5 @@
+name: varnish
+summary: "Database engine"
+description: "Another popular database"
+provides:
+  webcache: varnish
 
=== added file 'charm/testrepo/series/varnish/revision'
--- charm/testrepo/series/varnish/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/varnish/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+1
 \ No newline at end of file
 
=== added directory 'charm/testrepo/series/wordpress'
=== added file 'charm/testrepo/series/wordpress/config.yaml'
--- charm/testrepo/series/wordpress/config.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/wordpress/config.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,3 @@
+options:
+  blog-title: {default: My Title, description: A descriptive title used for the blog., type: string}
+
 
=== added file 'charm/testrepo/series/wordpress/metadata.yaml'
--- charm/testrepo/series/wordpress/metadata.yaml	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/wordpress/metadata.yaml	2012-01-18 17:30:30 +0000
@@ -0,0 +1,19 @@
+name: wordpress
+summary: "Blog engine"
+description: "A pretty popular blog engine"
+provides:
+  url:
+    interface: http
+    limit:
+    optional: false
+requires:
+  db:
+    interface: mysql
+    limit: 1
+    optional: false
+  cache:
+    interface: varnish
+    limit: 2
+    optional: true
+
+
 
=== added file 'charm/testrepo/series/wordpress/revision'
--- charm/testrepo/series/wordpress/revision	1970-01-01 00:00:00 +0000
+++ charm/testrepo/series/wordpress/revision	2012-01-18 17:30:30 +0000
@@ -0,0 +1,1 @@
+3
 \ No newline at end of file
 
=== added file 'charm/url.go'
--- charm/url.go	1970-01-01 00:00:00 +0000
+++ charm/url.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,132 @@
+package charm
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// A charm URL represents charm locations such as:
+//
+//     cs:~joe/oneiric/wordpress
+//     cs:oneiric/wordpress-42
+//     local:oneiric/wordpress
+//
+type URL struct {
+	Name     string
+	Revision int // -1 if unset, 0 is valid
+	Collection
+}
+
+// A charm Collection represents a namespace of charms. The
+// collection precedes the charm name in a charm URL.
+type Collection struct {
+	Schema string
+	User   string
+	Series string
+}
+
+// WithRevision returns a *URL with the same Name and Collection of url,
+// but with Revision set to the revision parameter. If url already has
+// the requested revision, url itself is returned.
+func (url *URL) WithRevision(revision int) *URL {
+	if url.Revision == revision {
+		return url
+	}
+	urlCopy := *url
+	urlCopy.Revision = revision
+	return &urlCopy
+}
+
+var validUser = regexp.MustCompile("^[a-z0-9][a-zA-Z0-9+.-]+$")
+var validSeries = regexp.MustCompile("^[a-z]+([a-z-]+[a-z])?$")
+var validName = regexp.MustCompile("^[a-z][a-z0-9]*(-[a-z0-9]*[a-z][a-z0-9]*)*$")
+
+// MustParseURL works like ParseURL, but panics in case of errors.
+func MustParseURL(url string) *URL {
+	u, err := ParseURL(url)
+	if err != nil {
+		panic(err)
+	}
+	return u
+}
+
+// ParseURL parses the provided charm URL string into its respective
+// structure.
+func ParseURL(url string) (*URL, error) {
+	u := &URL{}
+	i := strings.Index(url, ":")
+	if i > 0 {
+		u.Schema = url[:i]
+		i++
+	}
+	// cs: or local:
+	if u.Schema != "cs" && u.Schema != "local" {
+		return nil, fmt.Errorf("charm URL has invalid schema: %q", url)
+	}
+	parts := strings.Split(url[i:], "/")
+	if len(parts) < 1 || len(parts) > 3 {
+		return nil, fmt.Errorf("charm URL has invalid form: %q", url)
+	}
+
+	// ~<username>
+	if strings.HasPrefix(parts[0], "~") {
+		if u.Schema == "local" {
+			return nil, fmt.Errorf("local charm URL with user name: %q", url)
+		}
+		u.User = parts[0][1:]
+		if !validUser.MatchString(u.User) {
+			return nil, fmt.Errorf("charm URL has invalid user name: %q", url)
+		}
+		parts = parts[1:]
+	}
+
+	// <series>
+	if len(parts) < 2 {
+		return nil, fmt.Errorf("charm URL without series: %q", url)
+	}
+	if len(parts) == 2 {
+		u.Series = parts[0]
+		if !validSeries.MatchString(u.Series) {
+			return nil, fmt.Errorf("charm URL has invalid series: %q", url)
+		}
+		parts = parts[1:]
+	}
+
+	// <name>[-<revision>]
+	u.Name = parts[0]
+	u.Revision = -1
+	for i := len(u.Name) - 1; i > 0; i-- {
+		c := u.Name[i]
+		if c >= '0' && c <= '9' {
+			continue
+		}
+		if c == '-' && i != len(u.Name)-1 {
+			var err error
+			u.Revision, err = strconv.Atoi(u.Name[i+1:])
+			if err != nil {
+				panic(err) // We just checked it was right.
+			}
+			u.Name = u.Name[:i]
+		}
+		break
+	}
+	if !validName.MatchString(u.Name) {
+		return nil, fmt.Errorf("charm URL has invalid charm name: %q", url)
+	}
+	return u, nil
+}
+
+func (u *URL) String() string {
+	if u.User != "" {
+		if u.Revision >= 0 {
+			return fmt.Sprintf("%s:~%s/%s/%s-%d", u.Schema, u.User, u.Series, u.Name, u.Revision)
+		}
+		return fmt.Sprintf("%s:~%s/%s/%s", u.Schema, u.User, u.Series, u.Name)
+	}
+	if u.Revision >= 0 {
+		return fmt.Sprintf("%s:%s/%s-%d", u.Schema, u.Series, u.Name, u.Revision)
+	}
+	return fmt.Sprintf("%s:%s/%s", u.Schema, u.Series, u.Name)
+}
 
=== added file 'charm/url_test.go'
--- charm/url_test.go	1970-01-01 00:00:00 +0000
+++ charm/url_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,61 @@
+package charm_test
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/charm"
+)
+
+var urlTests = []struct {
+	s, err string
+	url    *charm.URL
+}{
+	{"cs:~user/series/name", "", &charm.URL{"name", -1, charm.Collection{"cs", "user", "series"}}},
+	{"cs:~user/series/name-0", "", &charm.URL{"name", 0, charm.Collection{"cs", "user", "series"}}},
+	{"cs:series/name", "", &charm.URL{"name", -1, charm.Collection{"cs", "", "series"}}},
+	{"cs:series/name-42", "", &charm.URL{"name", 42, charm.Collection{"cs", "", "series"}}},
+	{"local:series/name-1", "", &charm.URL{"name", 1, charm.Collection{"local", "", "series"}}},
+	{"local:series/name", "", &charm.URL{"name", -1, charm.Collection{"local", "", "series"}}},
+	{"local:series/n0-0n-n0", "", &charm.URL{"n0-0n-n0", -1, charm.Collection{"local", "", "series"}}},
+
+	{"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 *S) TestParseURL(c *C) {
+	for _, t := range urlTests {
+		url, err := charm.ParseURL(t.s)
+		bug := Bug("ParseURL(%q)", t.s)
+		if t.err != "" {
+			c.Check(err.Error(), Matches, t.err, bug)
+		} else {
+			c.Check(url, Equals, t.url, bug)
+			c.Check(t.url.String(), Equals, t.s)
+		}
+	}
+}
+
+func (s *S) TestMustParseURL(c *C) {
+	url := charm.MustParseURL("cs:series/name")
+	c.Assert(url, Equals, &charm.URL{"name", -1, charm.Collection{"cs", "", "series"}})
+	f := func() { charm.MustParseURL("local:name") }
+	c.Assert(f, PanicMatches, "charm URL without series: .*")
+}
+
+func (s *S) TestWithRevision(c *C) {
+	url := charm.MustParseURL("cs:series/name")
+	other := url.WithRevision(1)
+	c.Assert(url, Equals, &charm.URL{"name", -1, charm.Collection{"cs", "", "series"}})
+	c.Assert(other, Equals, &charm.URL{"name", 1, charm.Collection{"cs", "", "series"}})
+
+	c.Assert(other.WithRevision(1) == other, Equals, true)
+}
 
=== added directory 'cloudinit'
=== added file 'cloudinit/Makefile'
--- cloudinit/Makefile	1970-01-01 00:00:00 +0000
+++ cloudinit/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,24 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/cloudinit
+
+GOFILES=\
+	cloudinit.go\
+	options.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'cloudinit/cloudinit.go'
--- cloudinit/cloudinit.go	1970-01-01 00:00:00 +0000
+++ cloudinit/cloudinit.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,66 @@
+// The cloudinit package implements a way of creating
+// a cloud-init configuration file.
+// See https://help.ubuntu.com/community/CloudInit.
+package cloudinit
+
+import (
+	yaml "launchpad.net/goyaml"
+)
+
+// Config represents a set of cloud-init configuration options.
+type Config struct {
+	attrs map[string]interface{}
+}
+
+// New returns a new Config with no options set.
+func New() *Config {
+	return &Config{make(map[string]interface{})}
+}
+
+// Render returns the cloud-init configuration as a YAML file.
+func (cfg *Config) Render() ([]byte, error) {
+	data, err := yaml.Marshal(cfg.attrs)
+	if err != nil {
+		return nil, err
+	}
+	return append([]byte("#cloud-config\n"), data...), nil
+}
+
+func (cfg *Config) set(opt string, yes bool, value interface{}) {
+	if yes {
+		cfg.attrs[opt] = value
+	} else {
+		delete(cfg.attrs, opt)
+	}
+}
+
+// source is Key, or KeyId and KeyServer
+type source struct {
+	Source    string `yaml:"source"`
+	Key       string `yaml:"key,omitempty"`
+	KeyId     string `yaml:"keyid,omitempty"`
+	KeyServer string `yaml:"keyserver,omitempty"`
+}
+
+// command represents a shell command.
+type command struct {
+	literal string
+	args    []string
+}
+
+// GetYAML implements yaml.Getter
+func (t *command) GetYAML() (tag string, value interface{}) {
+	if t.args != nil {
+		return "", t.args
+	}
+	return "", t.literal
+}
+
+type SSHKeyType string
+
+const (
+	RSAPrivate SSHKeyType = "rsa_private"
+	RSAPublic  SSHKeyType = "rsa_public"
+	DSAPrivate SSHKeyType = "dsa_private"
+	DSAPublic  SSHKeyType = "dsa_public"
+)
 
=== added file 'cloudinit/cloudinit_test.go'
--- cloudinit/cloudinit_test.go	1970-01-01 00:00:00 +0000
+++ cloudinit/cloudinit_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,200 @@
+package cloudinit_test
+
+import (
+	"fmt"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/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.AddSSHAuthorizedKey("key1")
+			cfg.AddSSHAuthorizedKey("key2")
+		},
+	},
+	{
+		"SSHKeys RSA",
+		"ssh_keys:\n  rsa_private: key1data\n  rsa_public: key2data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.RSAPrivate, "key1data")
+			cfg.AddSSHKey(cloudinit.RSAPublic, "key2data")
+		},
+	},
+	{
+		"SSHKeys DSA",
+		"ssh_keys:\n  dsa_public: key1data\n  dsa_private: key2data\n",
+		func(cfg *cloudinit.Config) {
+			cfg.AddSSHKey(cloudinit.DSAPublic, "key1data")
+			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")
+		},
+	},
+}
+
+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, Bug("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 file 'cloudinit/options.go'
--- cloudinit/options.go	1970-01-01 00:00:00 +0000
+++ cloudinit/options.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,214 @@
+package cloudinit
+
+// SetUser sets the user name that will be used for some other options.
+// The user will be assumed to already exist in the machine image.
+// The default user is "ubuntu".
+func (cfg *Config) SetUser(user string) {
+	cfg.set("user", user != "", user)
+}
+
+// SetAptUpgrade sets whether cloud-init runs "apt-get upgrade"
+// on first boot.
+func (cfg *Config) SetAptUpgrade(yes bool) {
+	cfg.set("apt_upgrade", yes, yes)
+}
+
+// SetUpdate sets whether cloud-init runs "apt-get update"
+// on first boot.
+func (cfg *Config) SetAptUpdate(yes bool) {
+	cfg.set("apt_update", yes, yes)
+}
+
+// SetAptMirror sets the URL to be used as the apt
+// mirror site. If not set, the URL is selected based
+// on cloud metadata in EC2 - <region>.archive.ubuntu.com
+func (cfg *Config) SetAptMirror(url string) {
+	cfg.set("apt_mirror", url != "", url)
+}
+
+// SetAptPreserveSourcesList sets whether /etc/apt/sources.list
+// is overwritten by the mirror. If true, SetAptMirror above
+// will have no effect.
+func (cfg *Config) SetAptPreserveSourcesList(yes bool) {
+	cfg.set("apt_mirror", yes, yes)
+}
+
+// AddAptSource adds an apt source. The key holds the
+// public key of the source, in the form expected by apt-key(8).
+func (cfg *Config) AddAptSource(name, key string) {
+	src, _ := cfg.attrs["apt_sources"].([]*source)
+	cfg.attrs["apt_sources"] = append(src,
+		&source{
+			Source: name,
+			Key:    key,
+		})
+}
+
+// AddAptSource adds an apt source. The public key for the
+// source is retrieved by fetching the given keyId from the
+// GPG key server at the given address.
+func (cfg *Config) AddAptSourceWithKeyId(name, keyId, keyServer string) {
+	src, _ := cfg.attrs["apt_sources"].([]*source)
+	cfg.attrs["apt_sources"] = append(src,
+		&source{
+			Source:    name,
+			KeyId:     keyId,
+			KeyServer: keyServer,
+		})
+}
+
+// SetDebconfSelections provides preseeded debconf answers
+// for the boot process. The given answers will be used as input
+// to debconf-set-selections(1).
+func (cfg *Config) SetDebconfSelections(answers string) {
+	cfg.set("debconf_selections", answers != "", answers)
+}
+
+// AddPackage adds a package to be installed on first boot.
+// If any packages are specified, "apt-get update"
+// will be called.
+func (cfg *Config) AddPackage(name string) {
+	pkgs, _ := cfg.attrs["packages"].([]string)
+	cfg.attrs["packages"] = append(pkgs, name)
+}
+
+func (cfg *Config) addCmd(kind string, c *command) {
+	cmds, _ := cfg.attrs[kind].([]*command)
+	cfg.attrs[kind] = append(cmds, c)
+}
+
+// AddRunCmd adds a command to be executed
+// at first boot. The command will be run
+// by the shell with any metacharacters retaining
+// their special meaning (that is, no quoting takes place).
+func (cfg *Config) AddRunCmd(cmd string) {
+	cfg.addCmd("runcmd", &command{literal: cmd})
+}
+
+// AddRunCmdArgs is like AddRunCmd except that the command
+// will be executed with the given arguments properly quoted.
+func (cfg *Config) AddRunCmdArgs(args ...string) {
+	cfg.addCmd("runcmd", &command{args: args})
+}
+
+// AddBootCmd is like AddRunCmd except that the
+// command will run very early in the boot process,
+// and it will run on every boot, not just the first time.
+func (cfg *Config) AddBootCmd(cmd string) {
+	cfg.addCmd("bootcmd", &command{literal: cmd})
+}
+
+// AddBootCmdArgs is like AddBootCmd except that the command
+// will be executed with the given arguments properly quoted.
+func (cfg *Config) AddBootCmdArgs(args ...string) {
+	cfg.addCmd("bootcmd", &command{args: args})
+}
+
+// SetDisableEC2Metadata sets whether access to the
+// EC2 metadata service is disabled early in boot
+// via a null route ( route del -host 169.254.169.254 reject).
+func (cfg *Config) SetDisableEC2Metadata(yes bool) {
+	cfg.set("disable_ec2_metadata", yes, yes)
+}
+
+// SetFinalMessage sets to message that will be written
+// when the system has finished booting for the first time.
+// By default, the message is:
+// "cloud-init boot finished at $TIMESTAMP. Up $UPTIME seconds".
+func (cfg *Config) SetFinalMessage(msg string) {
+	cfg.set("final_message", msg != "", msg)
+}
+
+// SetLocale sets the locale; it defaults to en_US.UTF-8.
+func (cfg *Config) SetLocale(locale string) {
+	cfg.set("locale", locale != "", locale)
+}
+
+// AddMount adds a mount point. The given
+// arguments will be used as a line in /etc/fstab.
+func (cfg *Config) AddMount(args ...string) {
+	mounts, _ := cfg.attrs["mounts"].([][]string)
+	cfg.attrs["mounts"] = append(mounts, args)
+}
+
+// OutputKind represents a destination for command output.
+type OutputKind string
+
+const (
+	OutInit   OutputKind = "init"
+	OutConfig OutputKind = "config"
+	OutFinal  OutputKind = "final"
+	OutAll    OutputKind = "all"
+)
+
+// SetOutput specifies destination for command output.
+// Valid values for the kind "init", "config", "final" and "all".
+// Each of stdout and stderr can take one of the following forms:
+//   >>file
+//       appends to file
+//   >file
+//       overwrites file
+//   |command
+//       pipes to the given command.
+func (cfg *Config) SetOutput(kind OutputKind, stdout, stderr string) {
+	out, _ := cfg.attrs["output"].(map[string]interface{})
+	if out == nil {
+		out = make(map[string]interface{})
+	}
+	if stderr == "" {
+		out[string(kind)] = stdout
+	} else {
+		out[string(kind)] = []string{stdout, stderr}
+	}
+	cfg.attrs["output"] = out
+}
+
+// AddSSHKey adds a pre-generated ssh key to the
+// server keyring. Keys that are added like this will be
+// written to /etc/ssh and new random keys will not
+// be generated.
+func (cfg *Config) AddSSHKey(keyType SSHKeyType, keyData string) {
+	keys, _ := cfg.attrs["ssh_keys"].(map[SSHKeyType]string)
+	if keys == nil {
+		keys = make(map[SSHKeyType]string)
+		cfg.attrs["ssh_keys"] = keys
+	}
+	keys[keyType] = keyData
+}
+
+// SetDisableRoot sets whether ssh login is disabled to the root account
+// via the ssh authorized key associated with the instance metadata.
+// It is true by default.
+func (cfg *Config) SetDisableRoot(disable bool) {
+	// note that disable_root defaults to true, so we include
+	// the option only if disable is false.
+	cfg.set("disable_root", !disable, disable)
+}
+
+// AddSSHAuthorizedKey adds a key that will be
+// an entry in ~/.ssh/authorized_keys for the
+// configured user (see SetUser).
+func (cfg *Config) AddSSHAuthorizedKey(yes string) {
+	keys, _ := cfg.attrs["ssh_authorized_keys"].([]string)
+	cfg.attrs["ssh_authorized_keys"] = append(keys, yes)
+}
+
+// TODO
+// byobu
+// grub_dpkg
+// mcollective
+// phone_home
+// puppet
+// resizefs
+// rightscale_userdata
+// rsyslog
+// scripts_per_boot
+// scripts_per_instance
+// scripts_per_once
+// scripts_user
+// set_hostname
+// set_passwords
+// ssh_import_id
+// timezone
+// update_etc_hosts
+// update_hostname
 
=== added directory 'control'
=== added file 'control/bootstrap.go'
--- control/bootstrap.go	1970-01-01 00:00:00 +0000
+++ control/bootstrap.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,28 @@
+package control
+
+import "flag"
+import "fmt"
+
+type BootstrapCommand struct {
+	environment string
+}
+
+var _ Command = (*BootstrapCommand)(nil)
+
+func (c *BootstrapCommand) Parse(args []string) error {
+	fs := flag.NewFlagSet("bootstrap", flag.ExitOnError)
+	fs.StringVar(&c.environment, "e", "", "juju environment to operate in")
+	fs.StringVar(&c.environment, "environment", "", "juju environment to operate in")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	if len(fs.Args()) != 0 {
+		return fmt.Errorf("Unknown args: %s", fs.Args())
+	}
+	return nil
+}
+
+func (c *BootstrapCommand) Run() error {
+	fmt.Println("Running bootstrap in environment ", c.environment)
+	return nil
+}
 
=== added file 'control/command.go'
--- control/command.go	1970-01-01 00:00:00 +0000
+++ control/command.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,69 @@
+package control
+
+import "fmt"
+import "flag"
+
+type Command interface {
+	Parse(args []string) error
+	Run() error
+}
+
+type JujuCommand struct {
+	logfile string
+	verbose bool
+	subcmds map[string]Command
+	subcmd  Command
+}
+
+func (c *JujuCommand) Logfile() string {
+	return c.logfile
+}
+
+func (c *JujuCommand) Verbose() bool {
+	return c.verbose
+}
+
+func (c *JujuCommand) Register(name string, subcmd Command) error {
+	if c.subcmds == nil {
+		c.subcmds = make(map[string]Command)
+	}
+	_, alreadythere := c.subcmds[name]
+	if alreadythere {
+		return fmt.Errorf("subcommand %s already registered", name)
+	}
+	c.subcmds[name] = subcmd
+	return nil
+}
+
+func (c *JujuCommand) Parse(args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("no args to parse")
+	}
+	fs := flag.NewFlagSet(args[0], flag.ExitOnError)
+	fs.StringVar(&c.logfile, "l", "", "where to log to")
+	fs.StringVar(&c.logfile, "log-file", "", "where to log to")
+	fs.BoolVar(&c.verbose, "v", false, "whether to be noisy")
+	fs.BoolVar(&c.verbose, "verbose", false, "whether to be noisy")
+	if err := fs.Parse(args[1:]); err != nil {
+		return err
+	}
+	return c.parseSubcmd(fs.Args())
+}
+
+func (c *JujuCommand) parseSubcmd(args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("no subcommand specified")
+	}
+	if c.subcmds == nil {
+		return fmt.Errorf("no subcommands registered")
+	}
+	exists := false
+	if c.subcmd, exists = c.subcmds[args[0]]; !exists {
+		return fmt.Errorf("no %s subcommand registered", args[0])
+	}
+	return c.subcmd.Parse(args[1:])
+}
+
+func (c *JujuCommand) Run() error {
+	return c.subcmd.Run()
+}
 
=== added file 'control/command_test.go'
--- control/command_test.go	1970-01-01 00:00:00 +0000
+++ control/command_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,100 @@
+package control_test
+
+import (
+	"flag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/control"
+	"testing"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type CommandSuite struct{}
+
+var _ = Suite(&CommandSuite{})
+
+type testCommand struct {
+	value string
+}
+
+func (c *testCommand) Parse(args []string) error {
+	fs := flag.NewFlagSet("defenestrate", flag.ContinueOnError)
+	fs.StringVar(&c.value, "value", "", "doc")
+	return fs.Parse(args)
+}
+
+func (c *testCommand) Run() error {
+	return nil
+}
+
+func parseEmpty(args []string) (*control.JujuCommand, error) {
+	jc := new(control.JujuCommand)
+	err := jc.Parse(args)
+	return jc, err
+}
+
+func parseDefenestrate(args []string) (*control.JujuCommand, *testCommand, error) {
+	jc := new(control.JujuCommand)
+	tc := new(testCommand)
+	jc.Register("defenestrate", tc)
+	err := jc.Parse(args)
+	return jc, tc, err
+}
+
+func (s *CommandSuite) TestSubcommandDispatch(c *C) {
+	_, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, `no subcommand specified`)
+
+	_, err = parseEmpty([]string{"juju", "defenstrate"})
+	c.Assert(err, ErrorMatches, `no subcommands registered`)
+
+	_, _, err = parseDefenestrate([]string{"juju", "discombobulate"})
+	c.Assert(err, ErrorMatches, `no discombobulate subcommand registered`)
+
+	_, tc, err := parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(tc.value, Equals, "")
+
+	_, tc, err = parseDefenestrate([]string{"juju", "defenestrate", "--value", "firmly"})
+	c.Assert(err, IsNil)
+	c.Assert(tc.value, Equals, "firmly")
+
+	_, tc, err = parseDefenestrate([]string{"juju", "defenestrate", "--gibberish", "burble"})
+	c.Assert(err, ErrorMatches, "flag provided but not defined: -gibberish")
+}
+
+func (s *CommandSuite) TestVerbose(c *C) {
+	jc, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Verbose(), Equals, false)
+
+	jc, _, err = parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Verbose(), Equals, false)
+
+	jc, err = parseEmpty([]string{"juju", "--verbose"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Verbose(), Equals, true)
+
+	jc, _, err = parseDefenestrate([]string{"juju", "-v", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Verbose(), Equals, true)
+}
+
+func (s *CommandSuite) TestLogfile(c *C) {
+	jc, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Logfile(), Equals, "")
+
+	jc, _, err = parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Logfile(), Equals, "")
+
+	jc, err = parseEmpty([]string{"juju", "-l", "foo"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Logfile(), Equals, "foo")
+
+	jc, _, err = parseDefenestrate([]string{"juju", "--log-file", "bar", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Logfile(), Equals, "bar")
+}
 
=== added directory 'environs'
=== added file 'environs/Makefile'
--- environs/Makefile	1970-01-01 00:00:00 +0000
+++ environs/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/environs
+
+GOFILES=\
+	open.go\
+	config.go\
+	interface.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'environs/config.go'
--- environs/config.go	1970-01-01 00:00:00 +0000
+++ environs/config.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,134 @@
+package environs
+
+import (
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"launchpad.net/goyaml"
+	"os"
+	"path/filepath"
+)
+
+// environ holds information about one environment.
+type environ struct {
+	kind   string      // the type of environment (e.g. ec2).
+	config interface{} // the configuration data for passing to NewEnviron.
+	err    error       // an error if the config data could not be parsed.
+}
+
+// Environs holds information about each named environment
+// in an environments.yaml file.
+type Environs struct {
+	Default  string // The name of the default environment.
+	environs map[string]environ
+}
+
+// Names returns the list of environment names.
+func (e *Environs) Names() (names []string) {
+	for name := range e.environs {
+		names = append(names, name)
+	}
+	return
+}
+
+// providers maps from provider type to EnvironProvider for
+// each registered provider type.
+var providers = make(map[string]EnvironProvider)
+
+// RegisterProvider registers a new environment provider. Name gives the name
+// of the provider, and p the interface to that provider.
+//
+// RegisterProvider will panic if the same provider name is registered more than
+// once.
+func RegisterProvider(name string, p EnvironProvider) {
+	if providers[name] != nil {
+		panic(fmt.Errorf("juju: duplicate provider name %q", name))
+	}
+	providers[name] = p
+}
+
+// ReadEnvironsBytes parses the contents of an environments.yaml file
+// and returns its representation. An environment with an unknown type
+// will only generate an error when New is called for that environment.
+// Attributes for environments with known types are checked.
+func ReadEnvironsBytes(data []byte) (*Environs, error) {
+	var raw struct {
+		Default      string                 "default"
+		Environments map[string]interface{} "environments"
+	}
+	raw.Environments = make(map[string]interface{}) // TODO fix bug in goyaml - it should make this automatically.
+	err := goyaml.Unmarshal(data, &raw)
+	if err != nil {
+		return nil, err
+	}
+
+	if raw.Default != "" && raw.Environments[raw.Default] == nil {
+		return nil, fmt.Errorf("default environment %q does not exist", raw.Default)
+	}
+	if raw.Default == "" {
+		// If there's a single environment, then we get the default
+		// automatically.
+		if len(raw.Environments) == 1 {
+			for name := range raw.Environments {
+				raw.Default = name
+				break
+			}
+		}
+	}
+
+	environs := make(map[string]environ)
+	for name, x := range raw.Environments {
+		attrs, ok := x.(map[interface{}]interface{})
+		if !ok {
+			return nil, fmt.Errorf("environment %q does not have attributes", name)
+		}
+		kind, _ := attrs["type"].(string)
+		if kind == "" {
+			return nil, fmt.Errorf("environment %q has no type", name)
+		}
+
+		p := providers[kind]
+		if p == nil {
+			// unknown provider type - skip entry but leave error message
+			// in case the environment is used later.
+			environs[name] = environ{
+				kind: kind,
+				err:  fmt.Errorf("environment %q has an unknown provider type: %q", name, kind),
+			}
+			continue
+		}
+		cfg, err := p.ConfigChecker().Coerce(attrs, nil)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing environment %q: %v", name, err)
+		}
+		environs[name] = environ{
+			kind:   kind,
+			config: cfg,
+		}
+	}
+	return &Environs{raw.Default, environs}, nil
+}
+
+// ReadEnvirons reads the juju environments.yaml file
+// and returns the result of running ParseEnvironments
+// on the file's contents.
+// If environsFile is empty, $HOME/.juju/environments.yaml
+// is used.
+func ReadEnvirons(environsFile string) (*Environs, error) {
+	if environsFile == "" {
+		home := os.Getenv("HOME")
+		if home == "" {
+			return nil, errors.New("$HOME not set")
+		}
+		environsFile = filepath.Join(home, ".juju/environments.yaml")
+	}
+	data, err := ioutil.ReadFile(environsFile)
+	if err != nil {
+		return nil, err
+	}
+	e, err := ReadEnvironsBytes(data)
+	if err != nil {
+		return nil, fmt.Errorf("cannot parse %q: %v", environsFile, err)
+	}
+	return e, nil
+}
 
=== added file 'environs/config_test.go'
--- environs/config_test.go	1970-01-01 00:00:00 +0000
+++ environs/config_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,179 @@
+package environs_test
+
+import (
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+	"os"
+	"path/filepath"
+)
+
+type configTest struct {
+	env   string
+	check func(c *C, es *environs.Environs)
+}
+
+var configTests = []struct {
+	env   string
+	check func(c *C, es *environs.Environs)
+}{
+	{`
+environments:
+    only:
+        type: unknown
+        other: anything
+`, func(c *C, es *environs.Environs) {
+		e, err := es.Open("")
+		c.Assert(e, IsNil)
+		c.Assert(err, NotNil)
+		c.Assert(err.Error(), Equals, `environment "only" has an unknown provider type: "unknown"`)
+	},
+	},
+	// one known environment, no defaults, bad attribute -> parse error
+	{`
+environments:
+    only:
+        type: dummy
+        badattr: anything
+`, nil,
+	},
+	// one known environment, no defaults -> parse ok, instantiate ok
+	{`
+environments:
+    only:
+        type: dummy
+        basename: foo
+`, func(c *C, es *environs.Environs) {
+		e, err := es.Open("")
+		c.Assert(err, IsNil)
+		checkDummyEnviron(c, e, "foo")
+	},
+	},
+	// several environments, no defaults -> parse ok, instantiate maybe error
+	{`
+environments:
+    one:
+        type: dummy
+        basename: foo
+    two:
+        type: dummy
+        basename: bar
+`, func(c *C, es *environs.Environs) {
+		e, err := es.Open("")
+		c.Assert(err, NotNil)
+		e, err = es.Open("one")
+		c.Assert(err, IsNil)
+		checkDummyEnviron(c, e, "foo")
+	},
+	},
+	// several environments, default -> parse ok, instantiate ok
+	{`
+default:
+    two
+environments:
+    one:
+        type: dummy
+        basename: foo
+    two:
+        type: dummy
+        basename: bar
+`, func(c *C, es *environs.Environs) {
+		e, err := es.Open("")
+		c.Assert(err, IsNil)
+		checkDummyEnviron(c, e, "bar")
+	},
+	},
+}
+
+func checkDummyEnviron(c *C, e environs.Environ, basename string) {
+	i0, err := e.StartInstance(0)
+	c.Assert(err, IsNil)
+	c.Assert(i0, NotNil)
+	c.Assert(i0.DNSName(), Equals, basename+"-0")
+
+	is, err := e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(is), Equals, 1)
+	c.Assert(is[0], Equals, i0)
+
+	i1, err := e.StartInstance(1)
+	c.Assert(err, IsNil)
+	c.Assert(i1, NotNil)
+	c.Assert(i1.DNSName(), Equals, basename+"-1")
+
+	is, err = e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(is), Equals, 2)
+	if is[0] == i1 {
+		is[0], is[1] = is[1], is[0]
+	}
+	c.Assert(is[0], Equals, i0)
+	c.Assert(is[1], Equals, i1)
+
+	err = e.StopInstances([]environs.Instance{i0})
+	c.Assert(err, IsNil)
+
+	is, err = e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(is), Equals, 1)
+	c.Assert(is[0], Equals, i1)
+
+	err = e.Destroy()
+	c.Assert(err, IsNil)
+}
+
+func (suite) TestConfig(c *C) {
+	for i, t := range configTests {
+		c.Logf("running test %v", i)
+		es, err := environs.ReadEnvironsBytes([]byte(t.env))
+		if es == nil {
+			c.Logf("parse failed\n")
+			if t.check != nil {
+				c.Errorf("test %d failed: %v", i, err)
+			}
+		} else {
+			if t.check == nil {
+				c.Errorf("test %d parsed ok but should have failed", i)
+				continue
+			}
+			c.Logf("checking...")
+			t.check(c, es)
+		}
+	}
+}
+
+func (suite) TestConfigFile(c *C) {
+	d := c.MkDir()
+	err := os.Mkdir(filepath.Join(d, ".juju"), 0777)
+	c.Assert(err, IsNil)
+
+	path := filepath.Join(d, ".juju", "environments.yaml")
+	env := `
+environments:
+    only:
+        type: dummy
+        basename: foo
+`
+	err = ioutil.WriteFile(path, []byte(env), 0666)
+	c.Assert(err, IsNil)
+
+	// test reading from a named file
+	es, err := environs.ReadEnvirons(path)
+	c.Assert(err, IsNil)
+	e, err := es.Open("")
+	c.Assert(err, IsNil)
+	checkDummyEnviron(c, e, "foo")
+
+	// test reading from the default environments.yaml file.
+	h := os.Getenv("HOME")
+	os.Setenv("HOME", d)
+
+	es, err = environs.ReadEnvirons("")
+	c.Assert(err, IsNil)
+	e, err = es.Open("")
+	c.Assert(err, IsNil)
+	checkDummyEnviron(c, e, "foo")
+
+	// reset $HOME just in case something else relies on it.
+	os.Setenv("HOME", h)
+}
 
=== added file 'environs/dummyprovider_test.go'
--- environs/dummyprovider_test.go	1970-01-01 00:00:00 +0000
+++ environs/dummyprovider_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,93 @@
+// Dummy is a bare minimum provider that doesn't actually do anything.
+// The configuration requires a single value, "basename", which
+// is used as the base name of any machines that are "created".
+// It has no persistent state.
+//
+// Note that this file contains no tests as such - it is
+// just used by the testing code.
+package environs_test
+
+import (
+	"fmt"
+	"launchpad.net/juju/go/environs"
+	"launchpad.net/juju/go/schema"
+	"sync"
+)
+
+func init() {
+	environs.RegisterProvider("dummy", dummyProvider{})
+}
+
+type dummyInstance struct {
+	name string
+}
+
+func (m *dummyInstance) Id() string {
+	return fmt.Sprintf("dummy-%s", m.name)
+}
+
+func (m *dummyInstance) DNSName() string {
+	return m.name
+}
+
+type dummyProvider struct{}
+
+func (dummyProvider) ConfigChecker() schema.Checker {
+	return schema.FieldMap(
+		schema.Fields{
+			"type":     schema.Const("dummy"),
+			"basename": schema.String(),
+		},
+		nil,
+	)
+}
+
+type dummyEnviron struct {
+	mu       sync.Mutex
+	baseName string
+	n        int // instance count
+
+	instances map[string]*dummyInstance
+}
+
+func (dummyProvider) Open(name string, attributes interface{}) (e environs.Environ, err error) {
+	cfg := attributes.(schema.MapType)
+	return &dummyEnviron{
+		baseName:  cfg["basename"].(string),
+		instances: make(map[string]*dummyInstance),
+	}, nil
+}
+
+func (*dummyEnviron) Destroy() error {
+	return nil
+}
+
+func (e *dummyEnviron) StartInstance(id int) (environs.Instance, error) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	i := &dummyInstance{
+		name: fmt.Sprintf("%s-%d", e.baseName, e.n),
+	}
+	e.instances[i.name] = i
+	e.n++
+	return i, nil
+}
+
+func (e *dummyEnviron) StopInstances(is []environs.Instance) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	for _, i := range is {
+		delete(e.instances, i.(*dummyInstance).name)
+	}
+	return nil
+}
+
+func (e *dummyEnviron) Instances() ([]environs.Instance, error) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	var is []environs.Instance
+	for _, i := range e.instances {
+		is = append(is, i)
+	}
+	return is, nil
+}
 
=== added directory 'environs/ec2'
=== added file 'environs/ec2/Makefile'
--- environs/ec2/Makefile	1970-01-01 00:00:00 +0000
+++ environs/ec2/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,31 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/environs/ec2
+
+GOFILES=\
+	config.go\
+	ec2.go\
+	image.go\
+	util.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
+# regenerate doesn't remove images that have disappeared
+# but that's probably not a problem.
+regenerate:
+	gotest -regenerate-images
+	bzr add images
 
=== added file 'environs/ec2/config.go'
--- environs/ec2/config.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/config.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,79 @@
+package ec2
+
+import (
+	"fmt"
+	"launchpad.net/goamz/aws"
+	"launchpad.net/juju/go/schema"
+)
+
+// providerConfig is a placeholder for any config information
+// that we will have in a configuration file.
+type providerConfig struct {
+	region string
+	auth   aws.Auth
+}
+
+type checker struct{}
+
+func (checker) Coerce(v interface{}, path []string) (interface{}, error) {
+	return &providerConfig{}, nil
+}
+
+// TODO move these known strings into goamz/aws
+var Regions = map[string]aws.Region{
+	"ap-northeast-1": aws.APNortheast,
+	"ap-southeast-1": aws.APSoutheast,
+	"eu-west-1":      aws.EUWest,
+	"us-east-1":      aws.USEast,
+	"us-west-1":      aws.USWest,
+}
+
+func (environProvider) ConfigChecker() schema.Checker {
+	return combineCheckers(
+		schema.FieldMap(
+			schema.Fields{
+				"access-key": schema.String(),
+				"secret-key": schema.String(),
+				"region":     schema.String(),
+			}, []string{
+				"access-key",
+				"secret-key",
+				"region",
+			},
+		),
+		checkerFunc(func(v interface{}, path []string) (newv interface{}, err error) {
+			m := v.(schema.MapType)
+			var c providerConfig
+
+			c.auth.AccessKey = maybeString(m["access-key"], "")
+			c.auth.SecretKey = maybeString(m["secret-key"], "")
+			if c.auth.AccessKey == "" || c.auth.SecretKey == "" {
+				if c.auth.AccessKey != "" {
+					return nil, fmt.Errorf("environment has access-key but no secret-key")
+				}
+				if c.auth.SecretKey != "" {
+					return nil, fmt.Errorf("environment has secret-key but no access-key")
+				}
+				var err error
+				c.auth, err = aws.EnvAuth()
+				if err != nil {
+					return nil, err
+				}
+			}
+
+			regionName := maybeString(m["region"], "us-east-1")
+			if _, ok := Regions[regionName]; !ok {
+				return nil, fmt.Errorf("invalid region name %q", regionName)
+			}
+			c.region = regionName
+			return &c, nil
+		}),
+	)
+}
+
+func maybeString(x interface{}, dflt string) string {
+	if x == nil {
+		return dflt
+	}
+	return x.(string)
+}
 
=== added file 'environs/ec2/config_test.go'
--- environs/ec2/config_test.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/config_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,104 @@
+package ec2
+
+import (
+	"launchpad.net/goamz/aws"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+	"os"
+	"strings"
+)
+
+// Use local suite since this file lives in the ec2 package
+// for testing internals.
+type configSuite struct{}
+
+var _ = Suite(configSuite{})
+
+var configTestRegion = aws.Region{
+	EC2Endpoint: "testregion.nowhere:1234",
+}
+
+var testAuth = aws.Auth{"gopher", "long teeth"}
+
+type configTest struct {
+	env    string
+	config *providerConfig
+	err    string
+}
+
+var configTests = []configTest{
+	{"", &providerConfig{region: "us-east-1", auth: testAuth}, ""},
+	{"region: eu-west-1\n", &providerConfig{region: "eu-west-1", auth: testAuth}, ""},
+	{"region: unknown\n", nil, ".*invalid region name.*"},
+	{"region: configtest\n", &providerConfig{region: "configtest", auth: testAuth}, ""},
+	{"region: 666\n", nil, ".*expected string, got 666"},
+	{"access-key: 666\n", nil, ".*expected string, got 666"},
+	{"secret-key: 666\n", nil, ".*expected string, got 666"},
+	{"access-key: jujuer\nsecret-key: open sesame\n",
+		&providerConfig{
+			region: "us-east-1",
+			auth: aws.Auth{
+				AccessKey: "jujuer",
+				SecretKey: "open sesame",
+			},
+		},
+		"",
+	},
+	{"access-key: jujuer\n", nil, ".*environment has access-key but no secret-key"},
+	{"secret-key: badness\n", nil, ".*environment has secret-key but no access-key"},
+	// unknown fields are discarded
+	{"unknown-something: 666\n", &providerConfig{region: "us-east-1", auth: testAuth}, ""},
+}
+
+func indent(s string, with string) string {
+	var r string
+	lines := strings.Split(s, "\n")
+	for _, l := range lines {
+		r += with + l + "\n"
+	}
+	return r
+}
+
+func makeEnv(s string) []byte {
+	return []byte("environments:\n  testenv:\n    type: ec2\n" + indent(s, "    "))
+}
+
+func (configSuite) TestConfig(c *C) {
+	Regions["configtest"] = configTestRegion
+	defer delete(Regions, "configtest")
+
+	defer os.Setenv("AWS_ACCESS_KEY_ID", os.Getenv("AWS_ACCESS_KEY_ID"))
+	defer os.Setenv("AWS_SECRET_ACCESS_KEY", os.Getenv("AWS_SECRET_ACCESS_KEY"))
+
+	os.Setenv("AWS_ACCESS_KEY_ID", "")
+	os.Setenv("AWS_SECRET_ACCESS_KEY", "")
+
+	// first try with no auth environment vars set
+	test := configTest{"", &providerConfig{region: "us-east-1", auth: testAuth}, ".*not found in environment"}
+	test.run(c)
+
+	// then set testAuthults
+	os.Setenv("AWS_ACCESS_KEY_ID", testAuth.AccessKey)
+	os.Setenv("AWS_SECRET_ACCESS_KEY", testAuth.SecretKey)
+
+	for _, t := range configTests {
+		t.run(c)
+	}
+}
+
+func (t configTest) run(c *C) {
+	envs, err := environs.ReadEnvironsBytes(makeEnv(t.env))
+	if err != nil {
+		if t.err != "" {
+			c.Check(err, ErrorMatches, t.err, Bug("environ %q", t.env))
+		} else {
+			c.Check(err, IsNil, Bug("environ %q", t.env))
+		}
+		return
+	}
+	e, err := envs.Open("testenv")
+	c.Assert(err, IsNil)
+	c.Assert(e, NotNil)
+	c.Assert(e, FitsTypeOf, (*environ)(nil), Bug("environ %q", t.env))
+	c.Check(e.(*environ).config, Equals, t.config, Bug("environ %q", t.env))
+}
 
=== added file 'environs/ec2/ec2.go'
--- environs/ec2/ec2.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/ec2.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,171 @@
+package ec2
+
+import (
+	"fmt"
+	"launchpad.net/goamz/ec2"
+	"launchpad.net/juju/go/environs"
+)
+
+func init() {
+	environs.RegisterProvider("ec2", environProvider{})
+}
+
+type environProvider struct{}
+
+var _ environs.EnvironProvider = environProvider{}
+
+type environ struct {
+	name   string
+	config *providerConfig
+	ec2    *ec2.EC2
+}
+
+var _ environs.Environ = (*environ)(nil)
+
+type instance struct {
+	*ec2.Instance
+}
+
+var _ environs.Instance = (*instance)(nil)
+
+func (inst *instance) Id() string {
+	return inst.InstanceId
+}
+
+func (inst *instance) DNSName() string {
+	return inst.Instance.DNSName
+}
+
+func (environProvider) Open(name string, config interface{}) (e environs.Environ, err error) {
+	cfg := config.(*providerConfig)
+	if Regions[cfg.region].EC2Endpoint == "" {
+		return nil, fmt.Errorf("no ec2 endpoint found for region %q, opening %q", cfg.region, name)
+	}
+	return &environ{
+		name:   name,
+		config: cfg,
+		ec2:    ec2.New(cfg.auth, Regions[cfg.region]),
+	}, nil
+}
+
+func (e *environ) StartInstance(machineId int) (environs.Instance, error) {
+	image, err := FindImageSpec(DefaultImageConstraint)
+	if err != nil {
+		return nil, fmt.Errorf("cannot find image: %v", err)
+	}
+	groups, err := e.setUpGroups(machineId)
+	if err != nil {
+		return nil, fmt.Errorf("cannot set up groups: %v", err)
+	}
+	instances, err := e.ec2.RunInstances(&ec2.RunInstances{
+		ImageId:        image.ImageId,
+		MinCount:       1,
+		MaxCount:       1,
+		UserData:       nil,
+		InstanceType:   "m1.small",
+		SecurityGroups: groups,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("cannot run instances: %v", err)
+	}
+	if len(instances.Instances) != 1 {
+		return nil, fmt.Errorf("expected 1 started instance, got %d", len(instances.Instances))
+	}
+	return &instance{&instances.Instances[0]}, nil
+}
+
+func (e *environ) StopInstances(insts []environs.Instance) error {
+	if len(insts) == 0 {
+		return nil
+	}
+	names := make([]string, len(insts))
+	for i, inst := range insts {
+		names[i] = inst.(*instance).InstanceId
+	}
+	_, err := e.ec2.TerminateInstances(names)
+	return err
+}
+
+func (e *environ) Instances() ([]environs.Instance, error) {
+	filter := ec2.NewFilter()
+	filter.Add("instance-state-name", "pending", "running")
+
+	resp, err := e.ec2.Instances(nil, filter)
+	if err != nil {
+		return nil, err
+	}
+	var insts []environs.Instance
+	for i := range resp.Reservations {
+		r := &resp.Reservations[i]
+		for j := range r.Instances {
+			insts = append(insts, &instance{&r.Instances[j]})
+		}
+	}
+	return insts, nil
+}
+
+func (e *environ) Destroy() error {
+	insts, err := e.Instances()
+	if err != nil {
+		return err
+	}
+	return e.StopInstances(insts)
+}
+
+func (e *environ) machineGroupName(machineId int) string {
+	return fmt.Sprintf("%s-%d", e.groupName(), machineId)
+}
+
+func (e *environ) groupName() string {
+	return "juju-" + e.name
+}
+
+// setUpGroups creates the security groups for the new machine, and
+// returns them.
+// 
+// Instances are tagged with a group so they can be distinguished from
+// other instances that might be running on the same EC2 account.  In
+// addition, a specific machine security group is created for each
+// machine, so that its firewall rules can be configured per machine.
+func (e *environ) setUpGroups(machineId int) ([]ec2.SecurityGroup, error) {
+	jujuGroup := ec2.SecurityGroup{Name: e.groupName()}
+	jujuMachineGroup := ec2.SecurityGroup{Name: e.machineGroupName(machineId)}
+	groups, err := e.ec2.SecurityGroups([]ec2.SecurityGroup{jujuGroup, jujuMachineGroup}, nil)
+	if err != nil {
+		return nil, fmt.Errorf("cannot get security groups: %v", err)
+	}
+
+	for _, g := range groups.Groups {
+		switch g.Name {
+		case jujuGroup.Name:
+			jujuGroup = g.SecurityGroup
+		case jujuMachineGroup.Name:
+			jujuMachineGroup = g.SecurityGroup
+		}
+	}
+
+	// Create the provider group if doesn't exist.
+	if jujuGroup.Id == "" {
+		r, err := e.ec2.CreateSecurityGroup(jujuGroup.Name, "juju group for "+e.name)
+		if err != nil {
+			return nil, fmt.Errorf("cannot create juju security group: %v", err)
+		}
+		jujuGroup = r.SecurityGroup
+	}
+
+	// Create the machine-specific group, but first see if there's
+	// one already existing from a previous machine launch;
+	// if so, delete it, since it can have the wrong firewall setup
+	if jujuMachineGroup.Id != "" {
+		_, err := e.ec2.DeleteSecurityGroup(jujuMachineGroup)
+		if err != nil {
+			return nil, fmt.Errorf("cannot delete old security group %q: %v", jujuMachineGroup.Name, err)
+		}
+	}
+	descr := fmt.Sprintf("juju group for %s machine %d", e.name, machineId)
+	r, err := e.ec2.CreateSecurityGroup(jujuMachineGroup.Name, descr)
+	if err != nil {
+		return nil, fmt.Errorf("cannot create machine group %q: %v", jujuMachineGroup.Name, err)
+	}
+	return []ec2.SecurityGroup{jujuGroup, r.SecurityGroup}, nil
+}
 
=== added file 'environs/ec2/image.go'
--- environs/ec2/image.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/image.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,80 @@
+package ec2
+
+import (
+	"bufio"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// ImageConstraint specifies a range of possible machine images.
+// TODO allow specification of softer constraints?
+type ImageConstraint struct {
+	UbuntuRelease     string
+	Architecture      string
+	PersistentStorage bool
+	Region            string
+	Daily             bool
+	Desktop           bool
+}
+
+var DefaultImageConstraint = &ImageConstraint{
+	UbuntuRelease:     "oneiric",
+	Architecture:      "i386",
+	PersistentStorage: true,
+	Region:            "us-east-1",
+	Daily:             false,
+	Desktop:           false,
+}
+
+type ImageSpec struct {
+	ImageId string
+}
+
+func FindImageSpec(spec *ImageConstraint) (*ImageSpec, error) {
+	// note: original get_image_id added three optional args:
+	// DefaultImageId		if found, returns that immediately
+	// Region				overrides spec.Region
+	// DefaultSeries		used if spec.UbuntuRelease is ""
+
+	hclient := new(http.Client)
+	uri := fmt.Sprintf("http://uec-images.ubuntu.com/query/%s/%s/%s.current.txt",
+		spec.UbuntuRelease,
+		either(spec.Desktop, "desktop", "server"), // variant.
+		either(spec.Daily, "daily", "released"),   // version.
+	)
+	resp, err := hclient.Get(uri)
+	if err == nil && resp.StatusCode != 200 {
+		err = fmt.Errorf("%s", resp.Status)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("error getting instance types: %v", err)
+	}
+	defer resp.Body.Close()
+	ebsMatch := either(spec.PersistentStorage, "ebs", "instance-store")
+	r := bufio.NewReader(resp.Body)
+	for {
+		line, _, err := r.ReadLine()
+		if err != nil {
+			return nil, fmt.Errorf("cannot find matching image: %v", err)
+		}
+		f := strings.Split(string(line), "\t")
+		if len(f) < 8 {
+			continue
+		}
+		if f[4] != ebsMatch {
+			continue
+		}
+		if f[5] == spec.Architecture && f[6] == spec.Region {
+			return &ImageSpec{f[7]}, nil
+		}
+	}
+	panic("not reached")
+}
+
+func either(yes bool, a, b string) string {
+	if yes {
+		return a
+	}
+	return b
+}
 
=== added file 'environs/ec2/image_test.go'
--- environs/ec2/image_test.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/image_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,138 @@
+package ec2_test
+
+import (
+	"fmt"
+	"io"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs/ec2"
+	"net/http"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// N.B. the image IDs in this test will need updating
+// if the image directory is regenerated.
+var imageTests = []struct {
+	constraint ec2.ImageConstraint
+	imageId    string
+	err        string
+}{
+	{*ec2.DefaultImageConstraint, "ami-a7f539ce", ""},
+	{ec2.ImageConstraint{
+		UbuntuRelease:     "natty",
+		Architecture:      "amd64",
+		PersistentStorage: false,
+		Region:            "eu-west-1",
+		Daily:             true,
+		Desktop:           true,
+	}, "ami-19fdc16d", ""},
+	{ec2.ImageConstraint{
+		UbuntuRelease:     "natty",
+		Architecture:      "i386",
+		PersistentStorage: true,
+		Region:            "ap-northeast-1",
+		Daily:             true,
+		Desktop:           true,
+	}, "ami-cc9621cd", ""},
+	{ec2.ImageConstraint{
+		UbuntuRelease:     "natty",
+		Architecture:      "i386",
+		PersistentStorage: false,
+		Region:            "ap-northeast-1",
+		Daily:             true,
+		Desktop:           true,
+	}, "ami-62962163", ""},
+	{ec2.ImageConstraint{
+		UbuntuRelease:     "natty",
+		Architecture:      "amd64",
+		PersistentStorage: false,
+		Region:            "ap-northeast-1",
+		Daily:             true,
+		Desktop:           true,
+	}, "ami-a69621a7", ""},
+	{ec2.ImageConstraint{
+		UbuntuRelease:     "zingy",
+		Architecture:      "amd64",
+		PersistentStorage: false,
+		Region:            "eu-west-1",
+		Daily:             true,
+		Desktop:           true,
+	}, "", "error getting instance types:.*"},
+}
+
+func (suite) TestFindImageSpec(c *C) {
+	// set up http so that all requests will be satisfied from the images directory.
+	defer setTransport(setTransport(http.NewFileTransport(http.Dir("images"))))
+
+	for i, t := range imageTests {
+		id, err := ec2.FindImageSpec(&t.constraint)
+		if t.err != "" {
+			c.Check(err, ErrorMatches, t.err, Bug("test %d", i))
+			c.Check(id, IsNil, Bug("test %d", i))
+			continue
+		}
+		if !c.Check(err, IsNil, Bug("test %d", i)) {
+			continue
+		}
+		if !c.Check(id, NotNil, Bug("test %d", i)) {
+			continue
+		}
+		c.Check(id.ImageId, Equals, t.imageId)
+	}
+}
+
+func setTransport(t http.RoundTripper) (old http.RoundTripper) {
+	old = http.DefaultTransport
+	http.DefaultTransport = t
+	return
+}
+
+// regenerate all data inside the images directory.
+// N.B. this second-guesses the logic inside images.go
+func regenerateImages(t *testing.T) {
+	if err := os.RemoveAll(imagesRoot); err != nil {
+		t.Errorf("cannot remove old images: %v", err)
+		return
+	}
+	for _, variant := range []string{"desktop", "server"} {
+		for _, version := range []string{"daily", "released"} {
+			for _, release := range []string{"natty", "oneiric"} {
+				s := fmt.Sprintf("query/%s/%s/%s.current.txt", release, variant, version)
+				t.Logf("regenerating images from %q", s)
+				err := copylocal(s)
+				if err != nil {
+					t.Logf("regenerate: %v", err)
+				}
+			}
+		}
+	}
+}
+
+var imagesRoot = "images"
+
+func copylocal(s string) error {
+	r, err := http.Get("http://uec-images.ubuntu.com/" + s)
+	if err != nil {
+		return fmt.Errorf("get %q: %v", s, err)
+	}
+	defer r.Body.Close()
+	if r.StatusCode != 200 {
+		return fmt.Errorf("status on %q: %s", s, r.Status)
+	}
+	path := filepath.Join(filepath.FromSlash(imagesRoot), filepath.FromSlash(s))
+	d, _ := filepath.Split(path)
+	if err := os.MkdirAll(d, 0777); err != nil {
+		return err
+	}
+	file, err := os.Create(path)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	_, err = io.Copy(file, r.Body)
+	if err != nil {
+		return fmt.Errorf("error copying image file: %v", err)
+	}
+	return nil
+}
 
=== added directory 'environs/ec2/images'
=== added directory 'environs/ec2/images/query'
=== added directory 'environs/ec2/images/query/natty'
=== added directory 'environs/ec2/images/query/natty/desktop'
=== added file 'environs/ec2/images/query/natty/desktop/daily.current.txt'
--- environs/ec2/images/query/natty/desktop/daily.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/natty/desktop/daily.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+natty	desktop	daily	20111205	ebs	amd64	ap-northeast-1	ami-d89621d9	aki-d409a2d5		paravirtual
+natty	desktop	daily	20111205	ebs	i386	ap-northeast-1	ami-cc9621cd	aki-d209a2d3		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	ap-northeast-1	ami-a69621a7	aki-d409a2d5		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	ap-northeast-1	ami-62962163	aki-d209a2d3		paravirtual
+natty	desktop	daily	20111205	ebs	amd64	ap-southeast-1	ami-ac3471fe	aki-11d5aa43		paravirtual
+natty	desktop	daily	20111205	ebs	i386	ap-southeast-1	ami-a63471f4	aki-13d5aa41		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	ap-southeast-1	ami-8a3471d8	aki-11d5aa43		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	ap-southeast-1	ami-ea3471b8	aki-13d5aa41		paravirtual
+natty	desktop	daily	20111205	ebs	amd64	eu-west-1	ami-abfdc1df	aki-4feec43b		paravirtual
+natty	desktop	daily	20111205	ebs	i386	eu-west-1	ami-c7fdc1b3	aki-4deec439		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	eu-west-1	ami-19fdc16d	aki-4feec43b		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	eu-west-1	ami-79fdc10d	aki-4deec439		paravirtual
+natty	desktop	daily	20111205	ebs	amd64	us-east-1	ami-e7408b8e			hvm
+natty	desktop	daily	20111205	ebs	amd64	us-east-1	ami-37408b5e	aki-427d952b		paravirtual
+natty	desktop	daily	20111205	ebs	i386	us-east-1	ami-5d408b34	aki-407d9529		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	us-east-1	ami-e1418a88	aki-427d952b		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	us-east-1	ami-914289f8	aki-407d9529		paravirtual
+natty	desktop	daily	20111205	ebs	amd64	us-west-1	ami-23a9f666	aki-9ba0f1de		paravirtual
+natty	desktop	daily	20111205	ebs	i386	us-west-1	ami-1ba9f65e	aki-99a0f1dc		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	us-west-1	ami-03a9f646	aki-9ba0f1de		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	us-west-1	ami-77a9f632	aki-99a0f1dc		paravirtual
+natty	desktop	daily	20111205	ebs	amd64	us-west-2	ami-aa98159a	aki-ace26f9c		paravirtual
+natty	desktop	daily	20111205	ebs	i386	us-west-2	ami-a2981592	aki-dce26fec		paravirtual
+natty	desktop	daily	20111205	instance-store	amd64	us-west-2	ami-bc98158c	aki-ace26f9c		paravirtual
+natty	desktop	daily	20111205	instance-store	i386	us-west-2	ami-b0981580	aki-dce26fec		paravirtual
 
=== added directory 'environs/ec2/images/query/natty/server'
=== added file 'environs/ec2/images/query/natty/server/daily.current.txt'
--- environs/ec2/images/query/natty/server/daily.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/natty/server/daily.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+natty	server	daily	20111201	ebs	amd64	ap-northeast-1	ami-a6b80fa7	aki-d409a2d5		paravirtual
+natty	server	daily	20111201	ebs	i386	ap-northeast-1	ami-9cb80f9d	aki-d209a2d3		paravirtual
+natty	server	daily	20111201	instance-store	amd64	ap-northeast-1	ami-7cb80f7d	aki-d409a2d5		paravirtual
+natty	server	daily	20111201	instance-store	i386	ap-northeast-1	ami-68b80f69	aki-d209a2d3		paravirtual
+natty	server	daily	20111201	ebs	amd64	ap-southeast-1	ami-62246130	aki-11d5aa43		paravirtual
+natty	server	daily	20111201	ebs	i386	ap-southeast-1	ami-7e24612c	aki-13d5aa41		paravirtual
+natty	server	daily	20111201	instance-store	amd64	ap-southeast-1	ami-74246126	aki-11d5aa43		paravirtual
+natty	server	daily	20111201	instance-store	i386	ap-southeast-1	ami-5e24610c	aki-13d5aa41		paravirtual
+natty	server	daily	20111201	ebs	amd64	eu-west-1	ami-431d2137	aki-4feec43b		paravirtual
+natty	server	daily	20111201	ebs	i386	eu-west-1	ami-691d211d	aki-4deec439		paravirtual
+natty	server	daily	20111201	instance-store	amd64	eu-west-1	ami-891c20fd	aki-4feec43b		paravirtual
+natty	server	daily	20111201	instance-store	i386	eu-west-1	ami-9b1c20ef	aki-4deec439		paravirtual
+natty	server	daily	20111201	ebs	amd64	us-east-1	ami-0fec2766			hvm
+natty	server	daily	20111201	ebs	amd64	us-east-1	ami-59ec2730	aki-427d952b		paravirtual
+natty	server	daily	20111201	ebs	i386	us-east-1	ami-95ed26fc	aki-407d9529		paravirtual
+natty	server	daily	20111201	instance-store	amd64	us-east-1	ami-1fed2676	aki-427d952b		paravirtual
+natty	server	daily	20111201	instance-store	i386	us-east-1	ami-3fed2656	aki-407d9529		paravirtual
+natty	server	daily	20111201	ebs	amd64	us-west-1	ami-c983dc8c	aki-9ba0f1de		paravirtual
+natty	server	daily	20111201	ebs	i386	us-west-1	ami-3583dc70	aki-99a0f1dc		paravirtual
+natty	server	daily	20111201	instance-store	amd64	us-west-1	ami-2f83dc6a	aki-9ba0f1de		paravirtual
+natty	server	daily	20111201	instance-store	i386	us-west-1	ami-2183dc64	aki-99a0f1dc		paravirtual
+natty	server	daily	20111201	ebs	amd64	us-west-2	ami-689d1058	aki-ace26f9c		paravirtual
+natty	server	daily	20111201	ebs	i386	us-west-2	ami-649d1054	aki-dce26fec		paravirtual
+natty	server	daily	20111201	instance-store	amd64	us-west-2	ami-7e9d104e	aki-ace26f9c		paravirtual
+natty	server	daily	20111201	instance-store	i386	us-west-2	ami-789d1048	aki-dce26fec		paravirtual
 
=== added file 'environs/ec2/images/query/natty/server/released.current.txt'
--- environs/ec2/images/query/natty/server/released.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/natty/server/released.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+natty	server	release	20111003	ebs	amd64	ap-northeast-1	ami-02b10503	aki-d409a2d5		paravirtual
+natty	server	release	20111003	ebs	i386	ap-northeast-1	ami-00b10501	aki-d209a2d3		paravirtual
+natty	server	release	20111003	instance-store	amd64	ap-northeast-1	ami-fab004fb	aki-d409a2d5		paravirtual
+natty	server	release	20111003	instance-store	i386	ap-northeast-1	ami-f0b004f1	aki-d209a2d3		paravirtual
+natty	server	release	20111003	ebs	amd64	ap-southeast-1	ami-04255f56	aki-11d5aa43		paravirtual
+natty	server	release	20111003	ebs	i386	ap-southeast-1	ami-06255f54	aki-13d5aa41		paravirtual
+natty	server	release	20111003	instance-store	amd64	ap-southeast-1	ami-7a255f28	aki-11d5aa43		paravirtual
+natty	server	release	20111003	instance-store	i386	ap-southeast-1	ami-72255f20	aki-13d5aa41		paravirtual
+natty	server	release	20111003	ebs	amd64	eu-west-1	ami-a6f7c5d2	aki-4feec43b		paravirtual
+natty	server	release	20111003	ebs	i386	eu-west-1	ami-a4f7c5d0	aki-4deec439		paravirtual
+natty	server	release	20111003	instance-store	amd64	eu-west-1	ami-c0f7c5b4	aki-4feec43b		paravirtual
+natty	server	release	20111003	instance-store	i386	eu-west-1	ami-fef7c58a	aki-4deec439		paravirtual
+natty	server	release	20111003	ebs	amd64	us-east-1	ami-f1589598			hvm
+natty	server	release	20111003	ebs	amd64	us-east-1	ami-fd589594	aki-427d952b		paravirtual
+natty	server	release	20111003	ebs	i386	us-east-1	ami-e358958a	aki-407d9529		paravirtual
+natty	server	release	20111003	instance-store	amd64	us-east-1	ami-71589518	aki-427d952b		paravirtual
+natty	server	release	20111003	instance-store	i386	us-east-1	ami-c15994a8	aki-407d9529		paravirtual
+natty	server	release	20111003	ebs	amd64	us-west-1	ami-4d580408	aki-9ba0f1de		paravirtual
+natty	server	release	20111003	ebs	i386	us-west-1	ami-43580406	aki-99a0f1dc		paravirtual
+natty	server	release	20111003	instance-store	amd64	us-west-1	ami-a15f03e4	aki-9ba0f1de		paravirtual
+natty	server	release	20111003	instance-store	i386	us-west-1	ami-e95f03ac	aki-99a0f1dc		paravirtual
+natty	server	release	20111003	ebs	amd64	us-west-2	ami-1af9742a	aki-ace26f9c		paravirtual
+natty	server	release	20111003	ebs	i386	us-west-2	ami-18f97428	aki-dce26fec		paravirtual
+natty	server	release	20111003	instance-store	amd64	us-west-2	ami-16f67b26	aki-ace26f9c		paravirtual
+natty	server	release	20111003	instance-store	i386	us-west-2	ami-10f67b20	aki-dce26fec		paravirtual
 
=== added directory 'environs/ec2/images/query/oneiric'
=== added directory 'environs/ec2/images/query/oneiric/desktop'
=== added file 'environs/ec2/images/query/oneiric/desktop/daily.current.txt'
--- environs/ec2/images/query/oneiric/desktop/daily.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/oneiric/desktop/daily.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+oneiric	desktop	daily	20111120	ebs	amd64	ap-northeast-1	ami-eaec5beb	aki-ee5df7ef		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	ap-northeast-1	ami-d4ec5bd5	aki-ec5df7ed		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	ap-northeast-1	ami-c0ec5bc1	aki-ee5df7ef		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	ap-northeast-1	ami-9eec5b9f	aki-ec5df7ed		paravirtual
+oneiric	desktop	daily	20111120	ebs	amd64	ap-southeast-1	ami-48c9b31a	aki-aa225af8		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	ap-southeast-1	ami-58c9b30a	aki-a4225af6		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	ap-southeast-1	ami-b8c8b2ea	aki-aa225af8		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	ap-southeast-1	ami-9ec8b2cc	aki-a4225af6		paravirtual
+oneiric	desktop	daily	20111120	ebs	amd64	eu-west-1	ami-817b47f5	aki-62695816		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	eu-west-1	ami-af7b47db	aki-64695810		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	eu-west-1	ami-137b4767	aki-62695816		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	eu-west-1	ami-6f7b471b	aki-64695810		paravirtual
+oneiric	desktop	daily	20111120	ebs	amd64	us-east-1	ami-abed25c2			hvm
+oneiric	desktop	daily	20111120	ebs	amd64	us-east-1	ami-dded25b4	aki-825ea7eb		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	us-east-1	ami-f9ed2590	aki-805ea7e9		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	us-east-1	ami-6dec2404	aki-825ea7eb		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	us-east-1	ami-53eb233a	aki-805ea7e9		paravirtual
+oneiric	desktop	daily	20111120	ebs	amd64	us-west-1	ami-7b421d3e	aki-8d396bc8		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	us-west-1	ami-79421d3c	aki-83396bc6		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	us-west-1	ami-8b431cce	aki-8d396bc8		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	us-west-1	ami-e7431ca2	aki-83396bc6		paravirtual
+oneiric	desktop	daily	20111120	ebs	amd64	us-west-2	ami-be89048e	aki-98e26fa8		paravirtual
+oneiric	desktop	daily	20111120	ebs	i386	us-west-2	ami-bc89048c	aki-c2e26ff2		paravirtual
+oneiric	desktop	daily	20111120	instance-store	amd64	us-west-2	ami-48890478	aki-98e26fa8		paravirtual
+oneiric	desktop	daily	20111120	instance-store	i386	us-west-2	ami-58890468	aki-c2e26ff2		paravirtual
 
=== added directory 'environs/ec2/images/query/oneiric/server'
=== added file 'environs/ec2/images/query/oneiric/server/daily.current.txt'
--- environs/ec2/images/query/oneiric/server/daily.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/oneiric/server/daily.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+oneiric	server	daily	20111205	ebs	amd64	ap-northeast-1	ami-42942343	aki-ee5df7ef		paravirtual
+oneiric	server	daily	20111205	ebs	i386	ap-northeast-1	ami-3a94233b	aki-ec5df7ed		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	ap-northeast-1	ami-24942325	aki-ee5df7ef		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	ap-northeast-1	ami-20942321	aki-ec5df7ed		paravirtual
+oneiric	server	daily	20111205	ebs	amd64	ap-southeast-1	ami-9c3673ce	aki-aa225af8		paravirtual
+oneiric	server	daily	20111205	ebs	i386	ap-southeast-1	ami-9e3673cc	aki-a4225af6		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	ap-southeast-1	ami-fc3673ae	aki-aa225af8		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	ap-southeast-1	ami-f83673aa	aki-a4225af6		paravirtual
+oneiric	server	daily	20111205	ebs	amd64	eu-west-1	ami-87f9c5f3	aki-62695816		paravirtual
+oneiric	server	daily	20111205	ebs	i386	eu-west-1	ami-aff9c5db	aki-64695810		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	eu-west-1	ami-b5f9c5c1	aki-62695816		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	eu-west-1	ami-d5f9c5a1	aki-64695810		paravirtual
+oneiric	server	daily	20111205	ebs	amd64	us-east-1	ami-015d9668			hvm
+oneiric	server	daily	20111205	ebs	amd64	us-east-1	ami-2f5d9646	aki-825ea7eb		paravirtual
+oneiric	server	daily	20111205	ebs	i386	us-east-1	ami-695d9600	aki-805ea7e9		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	us-east-1	ami-c95e95a0	aki-825ea7eb		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	us-east-1	ami-4b5e9522	aki-805ea7e9		paravirtual
+oneiric	server	daily	20111205	ebs	amd64	us-west-1	ami-bba7f8fe	aki-8d396bc8		paravirtual
+oneiric	server	daily	20111205	ebs	i386	us-west-1	ami-b3a7f8f6	aki-83396bc6		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	us-west-1	ami-9da7f8d8	aki-8d396bc8		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	us-west-1	ami-85a7f8c0	aki-83396bc6		paravirtual
+oneiric	server	daily	20111205	ebs	amd64	us-west-2	ami-169b1626	aki-98e26fa8		paravirtual
+oneiric	server	daily	20111205	ebs	i386	us-west-2	ami-109b1620	aki-c2e26ff2		paravirtual
+oneiric	server	daily	20111205	instance-store	amd64	us-west-2	ami-209b1610	aki-98e26fa8		paravirtual
+oneiric	server	daily	20111205	instance-store	i386	us-west-2	ami-3c9b160c	aki-c2e26ff2		paravirtual
 
=== added file 'environs/ec2/images/query/oneiric/server/released.current.txt'
--- environs/ec2/images/query/oneiric/server/released.current.txt	1970-01-01 00:00:00 +0000
+++ environs/ec2/images/query/oneiric/server/released.current.txt	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+oneiric	server	release	20111011	ebs	amd64	ap-northeast-1	ami-30902431	aki-ee5df7ef		paravirtual
+oneiric	server	release	20111011	ebs	i386	ap-northeast-1	ami-2e90242f	aki-ec5df7ed		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	ap-northeast-1	ami-fa9723fb	aki-ee5df7ef		paravirtual
+oneiric	server	release	20111011	instance-store	i386	ap-northeast-1	ami-e49723e5	aki-ec5df7ed		paravirtual
+oneiric	server	release	20111011	ebs	amd64	ap-southeast-1	ami-7a057f28	aki-aa225af8		paravirtual
+oneiric	server	release	20111011	ebs	i386	ap-southeast-1	ami-76057f24	aki-a4225af6		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	ap-southeast-1	ami-54057f06	aki-aa225af8		paravirtual
+oneiric	server	release	20111011	instance-store	i386	ap-southeast-1	ami-82047ed0	aki-a4225af6		paravirtual
+oneiric	server	release	20111011	ebs	amd64	eu-west-1	ami-61b28015	aki-62695816		paravirtual
+oneiric	server	release	20111011	ebs	i386	eu-west-1	ami-65b28011	aki-64695810		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	eu-west-1	ami-75b28001	aki-62695816		paravirtual
+oneiric	server	release	20111011	instance-store	i386	eu-west-1	ami-dfcdffab	aki-64695810		paravirtual
+oneiric	server	release	20111011	ebs	amd64	us-east-1	ami-bff539d6			hvm
+oneiric	server	release	20111011	ebs	amd64	us-east-1	ami-bbf539d2	aki-825ea7eb		paravirtual
+oneiric	server	release	20111011	ebs	i386	us-east-1	ami-a7f539ce	aki-805ea7e9		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	us-east-1	ami-21f53948	aki-825ea7eb		paravirtual
+oneiric	server	release	20111011	instance-store	i386	us-east-1	ami-29f43840	aki-805ea7e9		paravirtual
+oneiric	server	release	20111011	ebs	amd64	us-west-1	ami-7b772b3e	aki-8d396bc8		paravirtual
+oneiric	server	release	20111011	ebs	i386	us-west-1	ami-79772b3c	aki-83396bc6		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	us-west-1	ami-4b772b0e	aki-8d396bc8		paravirtual
+oneiric	server	release	20111011	instance-store	i386	us-west-1	ami-a7762ae2	aki-83396bc6		paravirtual
+oneiric	server	release	20111011	ebs	amd64	us-west-2	ami-2af9741a	aki-98e26fa8		paravirtual
+oneiric	server	release	20111011	ebs	i386	us-west-2	ami-20f97410	aki-c2e26ff2		paravirtual
+oneiric	server	release	20111011	instance-store	amd64	us-west-2	ami-56f67b66	aki-98e26fa8		paravirtual
+oneiric	server	release	20111011	instance-store	i386	us-west-2	ami-52f67b62	aki-c2e26ff2		paravirtual
 
=== added file 'environs/ec2/live_test.go'
--- environs/ec2/live_test.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/live_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,34 @@
+package ec2_test
+
+import (
+	"fmt"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+	"launchpad.net/juju/go/environs/jujutest"
+)
+
+// integrationConfig holds the environments configuration
+// for running the amazon EC2 integration tests.
+//
+// This is missing keys for security reasons; set the following environment variables
+// to make the integration testing work:
+//  access-key: $AWS_ACCESS_KEY_ID
+//  admin-secret: $AWS_SECRET_ACCESS_KEY
+var integrationConfig = []byte(`
+environments:
+  sample:
+    type: ec2
+`)
+
+func registerIntegrationTests() {
+	envs, err := environs.ReadEnvironsBytes(integrationConfig)
+	if err != nil {
+		panic(fmt.Errorf("cannot parse integration tests config data: %v", err))
+	}
+	for _, name := range envs.Names() {
+		Suite(&jujutest.LiveTests{
+			Environs: envs,
+			Name:     name,
+		})
+	}
+}
 
=== added file 'environs/ec2/local_test.go'
--- environs/ec2/local_test.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/local_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,242 @@
+package ec2_test
+
+import (
+	"fmt"
+	"launchpad.net/goamz/aws"
+	amzec2 "launchpad.net/goamz/ec2"
+	"launchpad.net/goamz/ec2/ec2test"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+	"launchpad.net/juju/go/environs/ec2"
+	"launchpad.net/juju/go/environs/jujutest"
+)
+
+var functionalConfig = []byte(`
+environments:
+  sample:
+    type: ec2
+    region: test
+`)
+
+// localTests wraps jujutest.Tests by adding
+// set up and tear down functions that start a new
+// ec2test server for each test.
+// The server is accessed by using the "test" region,
+// which is changed to point to the network address
+// of the local server.
+type localTests struct {
+	*jujutest.Tests
+	srv localServer
+}
+
+// localLiveTests performs the live test suite, but locally.
+type localLiveTests struct {
+	*jujutest.LiveTests
+	srv localServer
+}
+
+type localServer struct {
+	srv   *ec2test.Server
+	setup func(*ec2test.Server)
+}
+
+// Each test is run in each of the following scenarios.
+// A scenario is implemented by mutating the ec2test
+// server after it starts.
+var scenarios = []struct {
+	name  string
+	setup func(*ec2test.Server)
+}{
+	{"normal", normalScenario},
+	{"initial-state-running", initialStateRunningScenario},
+	{"extra-instances", extraInstancesScenario},
+}
+
+func normalScenario(*ec2test.Server) {
+}
+
+func initialStateRunningScenario(srv *ec2test.Server) {
+	srv.SetInitialInstanceState(ec2test.Running)
+}
+
+func extraInstancesScenario(srv *ec2test.Server) {
+	states := []amzec2.InstanceState{
+		ec2test.ShuttingDown,
+		ec2test.Terminated,
+		ec2test.Stopped,
+	}
+	for _, state := range states {
+		srv.NewInstances(1, "m1.small", "ami-a7f539ce", state, nil)
+	}
+}
+
+func registerLocalTests() {
+	ec2.Regions["test"] = aws.Region{}
+	envs, err := environs.ReadEnvironsBytes(functionalConfig)
+	if err != nil {
+		panic(fmt.Errorf("cannot parse functional tests config data: %v", err))
+	}
+
+	for _, name := range envs.Names() {
+		for _, scen := range scenarios {
+			Suite(&localTests{
+				srv: localServer{setup: scen.setup},
+				Tests: &jujutest.Tests{
+					Environs: envs,
+					Name:     name,
+				},
+			})
+			Suite(&localLiveTests{
+				srv: localServer{setup: scen.setup},
+				LiveTests: &jujutest.LiveTests{
+					Environs: envs,
+					Name:     name,
+				},
+			})
+		}
+	}
+}
+
+func (t *localTests) TestInstanceGroups(c *C) {
+	env, err := t.Environs.Open(t.Name)
+	c.Assert(err, IsNil)
+
+	ec2conn := amzec2.New(aws.Auth{}, ec2.Regions["test"])
+
+	groups := amzec2.SecurityGroupNames(
+		fmt.Sprintf("juju-%s", t.Name),
+		fmt.Sprintf("juju-%s-%d", t.Name, 98),
+		fmt.Sprintf("juju-%s-%d", t.Name, 99),
+	)
+
+	inst0, err := env.StartInstance(98)
+	c.Assert(err, IsNil)
+	defer env.StopInstances([]environs.Instance{inst0})
+
+	// create a same-named group for the second instance
+	// before starting it, to check that it's deleted and
+	// recreated correctly.
+	oldGroup := ensureGroupExists(c, ec2conn, groups[2], "old group")
+
+	inst1, err := env.StartInstance(99)
+	c.Assert(err, IsNil)
+	defer env.StopInstances([]environs.Instance{inst1})
+
+	// go behind the scenes to check the machines have
+	// been put into the correct groups.
+
+	// first check that the old group has been deleted
+	groupsResp, err := ec2conn.SecurityGroups([]amzec2.SecurityGroup{oldGroup}, nil)
+	c.Assert(err, IsNil)
+	c.Check(len(groupsResp.Groups), Equals, 0)
+
+	// then check that the groups have been created.
+	groupsResp, err = ec2conn.SecurityGroups(groups, nil)
+	c.Assert(err, IsNil)
+	c.Assert(len(groupsResp.Groups), Equals, len(groups))
+
+	// for each group, check that it exists and record its id.
+	for i, group := range groups {
+		found := false
+		for _, g := range groupsResp.Groups {
+			if g.Name == group.Name {
+				groups[i].Id = g.Id
+				found = true
+				break
+			}
+		}
+		if !found {
+			c.Fatalf("group %q not found", group.Name)
+		}
+	}
+
+	// check that each instance is part of the correct groups.
+	resp, err := ec2conn.Instances([]string{inst0.Id(), inst1.Id()}, nil)
+	c.Assert(err, IsNil)
+	c.Assert(len(resp.Reservations), Equals, 2, Bug("reservations %#v", resp.Reservations))
+	for _, r := range resp.Reservations {
+		c.Assert(len(r.Instances), Equals, 1)
+		// each instance must be part of the general juju group.
+		msg := Bug("reservation %#v", r)
+		c.Assert(hasSecurityGroup(r, groups[0]), Equals, true, msg)
+		inst := r.Instances[0]
+		switch inst.InstanceId {
+		case inst0.Id():
+			c.Assert(hasSecurityGroup(r, groups[1]), Equals, true, msg)
+			c.Assert(hasSecurityGroup(r, groups[2]), Equals, false, msg)
+		case inst1.Id():
+			c.Assert(hasSecurityGroup(r, groups[2]), Equals, true, msg)
+
+			// check that the id of the second machine's group
+			// has changed - this implies that StartInstance has
+			// correctly deleted and re-created the group.
+			c.Assert(groups[2].Id, Not(Equals), oldGroup.Id)
+			c.Assert(hasSecurityGroup(r, groups[1]), Equals, false, msg)
+		default:
+			c.Errorf("unknown instance found: %v", inst)
+		}
+	}
+}
+
+// createGroup creates a new EC2 group if it doesn't already
+// exist, and returns full SecurityGroup.
+func ensureGroupExists(c *C, ec2conn *amzec2.EC2, group amzec2.SecurityGroup, descr string) amzec2.SecurityGroup {
+	groups, err := ec2conn.SecurityGroups([]amzec2.SecurityGroup{group}, nil)
+	c.Assert(err, IsNil)
+	if len(groups.Groups) > 0 {
+		return groups.Groups[0].SecurityGroup
+	}
+
+	resp, err := ec2conn.CreateSecurityGroup(group.Name, descr)
+	c.Assert(err, IsNil)
+
+	return resp.SecurityGroup
+}
+
+func hasSecurityGroup(r amzec2.Reservation, g amzec2.SecurityGroup) bool {
+	for _, rg := range r.SecurityGroups {
+		if rg.Id == g.Id {
+			return true
+		}
+	}
+	return false
+}
+
+func (t *localTests) SetUpTest(c *C) {
+	t.srv.startServer(c)
+	t.Tests.SetUpTest(c)
+}
+
+func (t *localTests) TearDownTest(c *C) {
+	t.Tests.TearDownTest(c)
+	t.srv.stopServer(c)
+}
+
+func (t *localLiveTests) SetUpSuite(c *C) {
+	t.srv.startServer(c)
+	t.LiveTests.SetUpSuite(c)
+}
+
+func (t *localLiveTests) TearDownSuite(c *C) {
+	t.srv.stopServer(c)
+	t.LiveTests.TearDownSuite(c)
+}
+
+func (srv *localServer) startServer(c *C) {
+	var err error
+	srv.srv, err = ec2test.NewServer()
+	if err != nil {
+		c.Fatalf("cannot start ec2 test server: %v", err)
+	}
+	ec2.Regions["test"] = aws.Region{
+		EC2Endpoint: srv.srv.Address(),
+	}
+	srv.setup(srv.srv)
+}
+
+func (srv *localServer) stopServer(c *C) {
+	srv.srv.Quit()
+	// Clear out the region because the server address is
+	// no longer valid.
+	ec2.Regions["test"] = aws.Region{}
+}
 
=== added file 'environs/ec2/suite_test.go'
--- environs/ec2/suite_test.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/suite_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+package ec2_test
+
+import (
+	"flag"
+	. "launchpad.net/gocheck"
+	"testing"
+)
+
+type suite struct{}
+
+var _ = Suite(suite{})
+
+var regenerate = flag.Bool("regenerate-images", false, "regenerate all data in images directory")
+var integration = flag.Bool("i", false, "Enable integration tests")
+
+func TestEC2(t *testing.T) {
+	if *regenerate {
+		regenerateImages(t)
+	}
+	if *integration {
+		registerIntegrationTests()
+	}
+	registerLocalTests()
+	TestingT(t)
+}
 
=== added file 'environs/ec2/util.go'
--- environs/ec2/util.go	1970-01-01 00:00:00 +0000
+++ environs/ec2/util.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,43 @@
+package ec2
+
+import (
+	"launchpad.net/juju/go/schema"
+)
+
+// this stuff could/should be in the schema package.
+
+// checkerFunc defines a schema.Checker using a function that
+// implemenets scheme.Checker.Coerce.
+type checkerFunc func(v interface{}, path []string) (newv interface{}, err error)
+
+func (f checkerFunc) Coerce(v interface{}, path []string) (newv interface{}, err error) {
+	return f(v, path)
+}
+
+// combineCheckers returns a Checker that checks a value by passing
+// it through the "pipeline" defined by checkers. When
+// the returned checker's Coerce method is called on a value,
+// the value is passed through the first checker in checkers;
+// the resulting value is used as input to the next checker, and so on.
+func combineCheckers(checkers ...schema.Checker) schema.Checker {
+	f := func(v interface{}, path []string) (newv interface{}, err error) {
+		for _, c := range checkers {
+			v, err = c.Coerce(v, path)
+			if err != nil {
+				return nil, err
+			}
+		}
+		return v, nil
+	}
+	return checkerFunc(f)
+}
+
+// oneOf(a, b, c) is equivalent to (but less verbose than):
+// schema.OneOf(schema.Const(a), schema.Const(b), schema.Const(c))
+func oneOf(values ...interface{}) schema.Checker {
+	c := make([]schema.Checker, len(values))
+	for i, v := range values {
+		c[i] = schema.Const(v)
+	}
+	return schema.OneOf(c...)
+}
 
=== added file 'environs/interface.go'
--- environs/interface.go	1970-01-01 00:00:00 +0000
+++ environs/interface.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,42 @@
+package environs
+
+import "launchpad.net/juju/go/schema"
+
+// A EnvironProvider represents a computing and storage provider.
+type EnvironProvider interface {
+	// ConfigChecker is used to check sections of the environments.yaml
+	// file that specify this provider. The value passed to the Checker is
+	// that returned from the yaml parse, of type schema.MapType.
+	ConfigChecker() schema.Checker
+
+	// NewEnviron creates a new Environ with
+	// the given attributes returned by the ConfigChecker.
+	// The name is that given in environments.yaml.
+	Open(name string, attributes interface{}) (Environ, error)
+}
+
+// Instance represents the provider-specific notion of a machine.
+type Instance interface {
+	// Id returns a provider-generated identifier for the Instance.
+	Id() string
+	DNSName() string
+}
+
+// An Environ represents a juju environment as specified
+// in the environments.yaml file.
+type Environ interface {
+	// StartInstance asks for a new instance to be created,
+	// associated with the provided machine identifier
+	// TODO add arguments to specify type of new machine.
+	StartInstance(machineId int) (Instance, error)
+
+	// StopInstances shuts down the given instances.
+	StopInstances([]Instance) error
+
+	// Instances returns the list of currently started instances.
+	Instances() ([]Instance, error)
+
+	// Destroy shuts down all known machines and destroys the
+	// rest of the environment.
+	Destroy() error
+}
 
=== added directory 'environs/jujutest'
=== added file 'environs/jujutest/Makefile'
--- environs/jujutest/Makefile	1970-01-01 00:00:00 +0000
+++ environs/jujutest/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,25 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/environs/jujutest
+
+GOFILES=\
+	test.go\
+	tests.go\
+	livetests.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'environs/jujutest/jujutest_test.go'
--- environs/jujutest/jujutest_test.go	1970-01-01 00:00:00 +0000
+++ environs/jujutest/jujutest_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,8 @@
+package jujutest
+
+import "testing"
+
+// A dummy test so that gotest succeeds when running
+// in this directory.
+func TestNothing(t *testing.T) {
+}
 
=== added file 'environs/jujutest/livetests.go'
--- environs/jujutest/livetests.go	1970-01-01 00:00:00 +0000
+++ environs/jujutest/livetests.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,52 @@
+package jujutest
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+)
+
+// TestStartStop is similar to Tests.TestStartStop except
+// that it does not assume a pristine environment.
+func (t *LiveTests) TestStartStop(c *C) {
+	names := make(map[string]environs.Instance)
+	insts, err := t.env.Instances()
+	c.Assert(err, IsNil)
+
+	// check there are no duplicate instance ids
+	for _, inst := range insts {
+		id := inst.Id()
+		c.Assert(names[id], IsNil)
+		names[id] = inst
+	}
+
+	inst, err := t.env.StartInstance(0)
+	c.Assert(err, IsNil)
+	c.Assert(inst, NotNil)
+	id0 := inst.Id()
+
+	insts, err = t.env.Instances()
+	c.Assert(err, IsNil)
+
+	// check the new instance is found
+	found := false
+	for _, inst := range insts {
+		if inst.Id() == id0 {
+			c.Assert(found, Equals, false)
+			found = true
+		}
+	}
+	c.Check(found, Equals, true)
+
+	err = t.env.StopInstances([]environs.Instance{inst})
+	c.Assert(err, IsNil)
+
+	insts, err = t.env.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(insts), Equals, 0)
+
+	// check the instance is no longer there.
+	found = true
+	for _, inst := range insts {
+		c.Assert(inst.Id(), Not(Equals), id0)
+	}
+}
 
=== added file 'environs/jujutest/test.go'
--- environs/jujutest/test.go	1970-01-01 00:00:00 +0000
+++ environs/jujutest/test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,66 @@
+package jujutest
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+)
+
+// Tests is a gocheck suite containing tests verifying
+// juju functionality against the environment with Name that
+// must exist within Environs.
+type Tests struct {
+	Environs *environs.Environs
+	Name     string
+
+	environs []environs.Environ
+}
+
+func (t *Tests) open(c *C) environs.Environ {
+	e, err := t.Environs.Open(t.Name)
+	c.Assert(err, IsNil, Bug("opening environ %q", t.Name))
+	c.Assert(e, NotNil)
+	t.environs = append(t.environs, e)
+	return e
+}
+
+func (t *Tests) SetUpSuite(*C) {
+}
+
+func (t *Tests) TearDownSuite(*C) {
+}
+
+func (t *Tests) SetUpTest(*C) {
+}
+
+func (t *Tests) TearDownTest(c *C) {
+	for _, e := range t.environs {
+		err := e.Destroy()
+		if err != nil {
+			c.Errorf("error destroying environment after test: %v", err)
+		}
+	}
+	t.environs = nil
+}
+
+type LiveTests struct {
+	Environs *environs.Environs
+	Name     string
+	env      environs.Environ
+}
+
+func (t *LiveTests) SetUpSuite(c *C) {
+	e, err := t.Environs.Open(t.Name)
+	c.Assert(err, IsNil, Bug("opening environ %q", t.Name))
+	c.Assert(e, NotNil)
+	t.env = e
+}
+
+func (t *LiveTests) TearDownSuite(c *C) {
+	t.env = nil
+}
+
+func (t *LiveTests) SetUpTest(*C) {
+}
+
+func (t *LiveTests) TearDownTest(*C) {
+}
 
=== added file 'environs/jujutest/tests.go'
--- environs/jujutest/tests.go	1970-01-01 00:00:00 +0000
+++ environs/jujutest/tests.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,31 @@
+package jujutest
+
+import (
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/environs"
+)
+
+func (t *Tests) TestStartStop(c *C) {
+	e := t.open(c)
+
+	insts, err := e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(insts), Equals, 0)
+
+	inst, err := e.StartInstance(0)
+	c.Assert(err, IsNil)
+	c.Assert(inst, NotNil)
+	id0 := inst.Id()
+
+	insts, err = e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(insts), Equals, 1)
+	c.Assert(insts[0].Id(), Equals, id0)
+
+	err = e.StopInstances([]environs.Instance{inst})
+	c.Assert(err, IsNil)
+
+	insts, err = e.Instances()
+	c.Assert(err, IsNil)
+	c.Assert(len(insts), Equals, 0)
+}
 
=== added file 'environs/open.go'
--- environs/open.go	1970-01-01 00:00:00 +0000
+++ environs/open.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,28 @@
+package environs
+
+import "fmt"
+
+// New creates a new Environ using the
+// environment configuration with the given name.
+// If name is empty, the default environment will be used.
+func (envs *Environs) Open(name string) (Environ, error) {
+	if name == "" {
+		name = envs.Default
+		if name == "" {
+			return nil, fmt.Errorf("no default environment found")
+		}
+	}
+	e, ok := envs.environs[name]
+	if !ok {
+		return nil, fmt.Errorf("unknown environment %q", name)
+	}
+	if e.err != nil {
+		return nil, e.err
+	}
+	env, err := providers[e.kind].Open(name, e.config)
+	if err != nil {
+		return nil, fmt.Errorf("cannot initialize environment %q: %v", name, err)
+	}
+
+	return env, nil
+}
 
=== added file 'environs/suite_test.go'
--- environs/suite_test.go	1970-01-01 00:00:00 +0000
+++ environs/suite_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,14 @@
+package environs_test
+
+import (
+	. "launchpad.net/gocheck"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	TestingT(t)
+}
+
+type suite struct{}
+
+var _ = Suite(suite{})
 
=== added directory 'log'
=== added file 'log/Makefile'
--- log/Makefile	1970-01-01 00:00:00 +0000
+++ log/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,23 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/log
+
+GOFILES=\
+	log.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'log/log.go'
--- log/log.go	1970-01-01 00:00:00 +0000
+++ log/log.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,27 @@
+package log
+
+import "fmt"
+
+type Logger interface {
+	Output(calldepth int, s string) error
+}
+
+var (
+	Target Logger
+	Debug  bool
+)
+
+// Printf logs the formatted message onto the Target Logger.
+func Printf(format string, v ...interface{}) {
+	if Target != nil {
+		Target.Output(2, "JUJU "+fmt.Sprintf(format, v...))
+	}
+}
+
+// Debugf logs the formatted message onto the Target Logger
+// if Debug is true.
+func Debugf(format string, v ...interface{}) {
+	if Debug && Target != nil {
+		Target.Output(2, "JUJU:DEBUG "+fmt.Sprintf(format, v...))
+	}
+}
 
=== added file 'log/log_test.go'
--- log/log_test.go	1970-01-01 00:00:00 +0000
+++ log/log_test.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,54 @@
+package log_test
+
+import (
+	"bytes"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/log"
+	stdlog "log"
+	"testing"
+)
+
+func Test(t *testing.T) {
+	TestingT(t)
+}
+
+type suite struct{}
+
+var _ = Suite(suite{})
+
+type logTest struct {
+	input string
+	debug bool
+}
+
+var logTests = []struct {
+	input string
+	debug bool
+}{
+	{
+		input: "Hello World",
+		debug: false,
+	},
+	{
+		input: "Hello World",
+		debug: true,
+	},
+}
+
+func (suite) TestLogger(c *C) {
+	buf := &bytes.Buffer{}
+	log.Target = stdlog.New(buf, "", 0)
+	for _, t := range logTests {
+		log.Debug = t.debug
+		log.Printf(t.input)
+		c.Assert(buf.String(), Equals, "JUJU "+t.input+"\n")
+		buf.Reset()
+		log.Debugf(t.input)
+		if t.debug {
+			c.Assert(buf.String(), Equals, "JUJU:DEBUG "+t.input+"\n")
+		} else {
+			c.Assert(buf.String(), Equals, "")
+		}
+		buf.Reset()
+	}
+}
 
=== added directory 'schema'
=== added file 'schema/Makefile'
--- schema/Makefile	1970-01-01 00:00:00 +0000
+++ schema/Makefile	2012-01-18 17:30:30 +0000
@@ -0,0 +1,23 @@
+include $(GOROOT)/src/Make.inc
+
+all: package
+
+TARG=launchpad.net/juju/go/schema
+
+GOFILES=\
+	schema.go\
+
+GOFMT=gofmt
+BADFMT:=$(shell $(GOFMT) -l $(GOFILES) $(CGOFILES) $(wildcard *_test.go))
+
+gofmt: $(BADFMT)
+	@for F in $(BADFMT); do $(GOFMT) -w $$F && echo $$F; done
+
+ifneq ($(BADFMT),)
+ifneq ($(MAKECMDGOALS),gofmt)
+$(warning WARNING: make gofmt: $(BADFMT))
+endif
+endif
+
+include $(GOROOT)/src/Make.pkg
+
 
=== added file 'schema/schema.go'
--- schema/schema.go	1970-01-01 00:00:00 +0000
+++ schema/schema.go	2012-01-18 17:30:30 +0000
@@ -0,0 +1,374 @@
+package schema
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// All map types used in the schema package are of type MapType.
+type MapType map[interface{}]interface{}
+
+// All the slice types generated in the schema package are of type ListType.
+type ListType []interface{}
+
+// The Coerce method of the Checker interface is called recursively when
+// v is being validated.  If err is nil, newv is used as the new value
+// at the recursion point.  If err is non-nil, v is taken as invalid and
+// may be either ignored or error out depending on where in the schema
+// checking process the error happened. Checkers like OneOf may continue
+// with an alternative, for instance.
+type Checker interface {
+	Coerce(v interface{}, path []string) (newv interface{}, err error)
+}
+
+type error_ struct {
+	want string
+	got  interface{}
+	path []string
+}
+
+func (e error_) Error() string {
+	var path string
+	if e.path[0] == "." {
+		path = strings.Join(e.path[1:], "")
+	} else {
+		path = strings.Join(e.path, "")
+	}
+	if e.want == "" {
+		return fmt.Sprintf("%s: unsupported value", path)
+	}
+	if e.got == nil {
+		return fmt.Sprintf("%s: expected %s, got nothing", path, e.want)
+	}
+	return fmt.Sprintf("%s: expected %s, got %#v", path, e.want, e.got)
+}
+
+// Any returns a Checker that succeeds with any input value and
+// results in the value itself unprocessed.
+func Any() Checker {
+	return anyC{}
+}
+
+type anyC struct{}
+
+func (c anyC) Coerce(v interface{}, path []string) (interface{}, error) {
+	return v, nil
+}
+
+// Const returns a Checker that only succeeds if the input matches
+// value exactly.  The value is compared with reflect.DeepEqual.
+func Const(value interface{}) Checker {
+	return constC{value}
+}
+
+type constC struct {
+	value interface{}
+}
+
+func (c constC) Coerce(v interface{}, path []string) (interface{}, error) {
+	if reflect.DeepEqual(v, c.value) {
+		return v, nil
+	}
+	return nil, error_{fmt.Sprintf("%#v", c.value), v, path}
+}
+
+// OneOf returns a Checker that attempts to Coerce the value with each
+// of the provided checkers. The value returned by the first checker
+// that succeeds will be returned by the OneOf checker itself.  If no
+// checker succeeds, OneOf will return an error on coercion.
+func OneOf(options ...Checker) Checker {
+	return oneOfC{options}
+}
+
+type oneOfC struct {
+	options []Checker
+}
+
+func (c oneOfC) Coerce(v interface{}, path []string) (interface{}, error) {
+	for _, o := range c.options {
+		newv, err := o.Coerce(v, path)
+		if err == nil {
+			return newv, nil
+		}
+	}
+	return nil, error_{path: path}
+}
+
+// Bool returns a Checker that accepts boolean values only.
+func Bool() Checker {
+	return boolC{}
+}
+
+type boolC struct{}
+
+func (c boolC) Coerce(v interface{}, path []string) (interface{}, error) {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.Bool {
+		return v, nil
+	}
+	return nil, error_{"bool", v, path}
+}
+
+// Int returns a Checker that accepts any integer value, and returns
+// the same value consistently typed as an int64.
+func Int() Checker {
+	return intC{}
+}
+
+type intC struct{}
+
+func (c intC) Coerce(v interface{}, path []string) (interface{}, error) {
+	if v == nil {
+		return nil, error_{"int", v, path}
+	}
+	switch reflect.TypeOf(v).Kind() {
+	case reflect.Int:
+	case reflect.Int8:
+	case reflect.Int16:
+	case reflect.Int32:
+	case reflect.Int64:
+	default:
+		return nil, error_{"int", v, path}
+	}
+	return reflect.ValueOf(v).Int(), nil
+}
+
+// Int returns a Checker that accepts any float value, and returns
+// the same value consistently typed as a float64.
+func Float() Checker {
+	return floatC{}
+}
+
+type floatC struct{}
+
+func (c floatC) Coerce(v interface{}, path []string) (interface{}, error) {
+	if v == nil {
+		return nil, error_{"float", v, path}
+	}
+	switch reflect.TypeOf(v).Kind() {
+	case reflect.Float32:
+	case reflect.Float64:
+	default:
+		return nil, error_{"float", v, path}
+	}
+	return reflect.ValueOf(v).Float(), nil
+}
+
+// String returns a Checker that accepts a string value only and returns
+// it unprocessed.
+func String() Checker {
+	return stringC{}
+}
+
+type stringC struct{}
+
+func (c stringC) Coerce(v interface{}, path []string) (interface{}, error) {
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
+		return reflect.ValueOf(v).String(), nil
+	}
+	return nil, error_{"string", v, path}
+}
+
+func SimpleRegexp() Checker {
+	return sregexpC{}
+}
+
+type sregexpC struct{}
+
+func (c sregexpC) Coerce(v interface{}, path []string) (interface{}, error) {
+	// XXX The regexp package happens to be extremely simple right now.
+	//     Once exp/regexp goes mainstream, we'll have to update this
+	//     logic to use a more widely accepted regexp subset.
+	if v != nil && reflect.TypeOf(v).Kind() == reflect.String {
+		s := reflect.ValueOf(v).String()
+		_, err := regexp.Compile(s)
+		if err != nil {
+			return nil, error_{"valid regexp", s, path}
+		}
+		return v, nil
+	}
+	return nil, error_{"regexp string", v, path}
+}
+
+// List returns a Checker that accepts a slice value with values
+// that are processed with the elem checker.  If any element of the
+// provided slice value fails to be processed, processing will stop
+// and return with the obtained error.
+//
+// The coerced output value has type schema.ListType.
+func List(elem Checker) Checker {
+	return listC{elem}
+}
+
+type listC struct {
+	elem Checker
+}
+
+func (c listC) Coerce(v interface{}, path []string) (interface{}, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Slice {
+		return nil, error_{"list", v, path}
+	}
+
+	path = append(path, "[", "?", "]")
+
+	l := rv.Len()
+	out := make(ListType, 0, l)
+	for i := 0; i != l; i++ {
+		path[len(path)-2] = strconv.Itoa(i)
+		elem, err := c.elem.Coerce(rv.Index(i).Interface(), path)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, elem)
+	}
+	return out, nil
+}
+
+// Map returns a Checker that accepts a map value. Every key and value
+// in the map are processed with the respective checker, and if any
+// value fails to be coerced, processing stops and returns with the
+// underlying error.
+//
+// The coerced output value has type schema.MapType.
+func Map(key Checker, value Checker) Checker {
+	return mapC{key, value}
+}
+
+type mapC struct {
+	key   Checker
+	value Checker
+}
+
+func (c mapC) Coerce(v interface{}, path []string) (interface{}, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return nil, error_{"map", v, path}
+	}
+
+	vpath := append(path, ".", "?")
+
+	l := rv.Len()
+	out := make(MapType, l)
+	keys := rv.MapKeys()
+	for i := 0; i != l; i++ {
+		k := keys[i]
+		newk, err := c.key.Coerce(k.Interface(), path)
+		if err != nil {
+			return nil, err
+		}
+		vpath[len(vpath)-1] = fmt.Sprint(k.Interface())
+		newv, err := c.value.Coerce(rv.MapIndex(k).Interface(), vpath)
+		if err != nil {
+			return nil, err
+		}
+		out[newk] = newv
+	}
+	return out, nil
+}
+
+type Fields map[string]Checker
+type Optional []string
+
+// FieldMap returns a Checker that accepts a map value with defined
+// string keys. Every key has an independent checker associated,
+// and processing will only succeed if all the values succeed
+// individually. If a field fails to be processed, processing stops
+// and returns with the underlying error.
+//
+// The coerced output value has type schema.MapType.
+func FieldMap(fields Fields, optional Optional) Checker {
+	return fieldMapC{fields, optional}
+}
+
+type fieldMapC struct {
+	fields   Fields
+	optional []string
+}
+
+func (c fieldMapC) isOptional(key string) bool {
+	for _, k := range c.optional {
+		if k == key {
+			return true
+		}
+	}
+	return false
+}
+
+func (c fieldMapC) Coerce(v interface{}, path []string) (interface{}, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Map {
+		return nil, error_{"map", v, path}
+	}
+
+	vpath := append(path, ".", "?")
+
+	l := rv.Len()
+	out := make(MapType, l)
+	for k, checker := range c.fields {
+		vpath[len(vpath)-1] = k
+		var value interface{}
+		valuev := rv.MapIndex(reflect.ValueOf(k))
+		if valuev.IsValid() {