Merge lp:~themue/juju-core/009-local-environ-storage into lp:~juju/juju-core/trunk

[Frank Mueller]

local: added storage for environment

The backend pf the local storage is based on an internal
Go HTTP server using <basedir>/<environ-name>/private and
<basedir>/<environ-name>/public to store files. Additionally
some clean-up and first implementation steps of the
interfaces.

https://codereview.appspot.com/7323059/

[lp:~themue/juju-core/009-local-environ-storage]

889. By Frank Mueller on 2013-02-13

local: changed to use empty public storage

[William Reade (fwereade)]

A couple of comments - let me know your thoughts

https://codereview.appspot.com/7323059/diff/1/environs/local/config.go
File environs/local/config.go (right):

https://codereview.appspot.com/7323059/diff/1/environs/local/config.go#newcode10
environs/local/config.go:10: "port": schema.Int(),
storage-port, maybe? I have a suspicion we'll be needing an api-port too
(and a state-port in the meantime)... someone correct me if I'm crazy.
(hmm, should they actually be part of the base Config? I think they
might...)

https://codereview.appspot.com/7323059/diff/1/environs/local/local.go
File environs/local/local.go (right):

https://codereview.appspot.com/7323059/diff/1/environs/local/local.go#newcode73
environs/local/local.go:73: // TODO add arguments to specify type of new
machine.
Consider writing more relevant comments for all the methods that we know
will act differently -- I'm not sure it's helpful to duplicate the
interface comments here when their accuracy/relevance is ...variable ;).

https://codereview.appspot.com/7323059/

[lp:~themue/juju-core/009-local-environ-storage]

890. By Frank Mueller on 2013-02-14

config: changes after review

891. By Frank Mueller on 2013-02-14

environ: merging, consolidation, comment changing

[William Reade (fwereade)]

A few more thoughts follow; but I'm really confused by this patch set.
What's happened to config.go? Also: I don't see any tests for the
provider/environ at all.

https://codereview.appspot.com/7323059/diff/3013/environs/local/local.go
File environs/local/local.go (right):

https://codereview.appspot.com/7323059/diff/3013/environs/local/local.go#newcode100
environs/local/local.go:100: amazon:
Not amazon, please.

https://codereview.appspot.com/7323059/diff/3013/environs/local/local.go#newcode169
environs/local/local.go:169: // Instances returns the one instance
representing the host system.
s/./, if requested./ ?

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go
File environs/local/storage.go (right):

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode17
environs/local/storage.go:17: type storageBackend struct {
This'll need to move, as discussed online. Would you put it in a
separate file please? I'm fine keeping it in this package for the very
short term, though.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode23
environs/local/storage.go:23: // newContainer returns a new container
using the given path.
s/newContainer/newStorageBackend/

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode173
environs/local/storage.go:173: if resp.StatusCode < 200 ||
resp.StatusCode > 299 {
These seem a bit loosely specified. We control the backend; don't we
know what codes we should be returning for various operations?

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode193
environs/local/storage.go:193: if resp.StatusCode < 200 ||
resp.StatusCode > 299 {
As above.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode211
environs/local/storage.go:211: return
fmt.Sprintf("http://localhost:%d/%s/%s", s.port, s.environName, name),
nil
This needs to work from inside containers.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode225
environs/local/storage.go:225: if resp.StatusCode < 200 ||
resp.StatusCode > 299 {
As above.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode247
environs/local/storage.go:247: if resp.StatusCode < 200 ||
resp.StatusCode > 299 {
As above.

https://codereview.appspot.com/7323059/

[Roger Peppe (rogpeppe)]

some comments; there might be more

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go
File environs/local/storage.go (right):

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode70
environs/local/storage.go:70: if isNotExist(err) {
i don't think we care much about the distinction between 404 and 500
here. i think we can just do:

http.Error(w, fmt.Sprintf("404 %v", err), http.StatusNotFound)

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode93
environs/local/storage.go:93: _, err := os.Stat(fp)
i think this operation should be PUT not post (there's nothing in the
API that says we can't write the same object twice); then we can get rid
of all the Stat and all error special casing here, and just return error
403 and the error.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode101
environs/local/storage.go:101: body, err := ioutil.ReadAll(req.Body)
there's no need to read everything into memory here.

     out, err := os.Create(fp)
     defer out.Close()
     if err != nil {...}
     err = io.Copy(out, req.Body)
     if err != nil {...}

if we think it needs to be atomic (i don't
think it matters really), then write to
a temporary file in the same dir, then rename it
to the destination.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode119
environs/local/storage.go:119: if !isNotExist(err) {
if err := os.Remove(fp); err != nil && !os.IsNotExist(err) {

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode128
environs/local/storage.go:128: // to get, put, list and remove the files
in the state's storage.
// listen starts an HTTP listener to serve the
// provider storage.
?

(it doesn't seem worth listing the methods here)

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode130
environs/local/storage.go:130: backend := newStorageBackend(basepath,
environName)
as this code is closely bound to the details of storageBackend, i'd
either put this function closer to newStorageBackend, or (my preference)
inline the constructor
in this function and delete newStorageBackend.

then it's obvious what backend.uri is below (which is what prompted this
remark)

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode131
environs/local/storage.go:131: if err := os.MkdirAll(backend.path,
0755); err != nil {
i wonder we should use 0777 here and let the caller's umask deal with
desired permissions.

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode136
environs/local/storage.go:136: panic(fmt.Errorf("cannot start listener:
%v", err))
return nil, err
(it's not an unlikely error if the port is not zero)

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode146
environs/local/storage.go:146: // storage implements the Storage
interface.
s/Storage/environs.Storage/
?

https://codereview.appspot.com/7323059/diff/3013/environs/local/storage.go#newcode174
environs/local/storage.go:174: return nil, fmt.Errorf(resp.Status)
s/fmt.Errorf/errors.NewError/

https://codereview.appsp...

Unmerged revisions

891. By Frank Mueller on 2013-02-14

environ: merging, consolidation, comment changing

890. By Frank Mueller on 2013-02-14

config: changes after review

889. By Frank Mueller on 2013-02-13

local: changed to use empty public storage

888. By Frank Mueller on 2013-02-13

local: first steps, adding a local storage

887. By John A Meinel on 2013-02-13

testing/charms: Remove the series parameter

This change removes some of the symlinks in the working tree (testing/repo/*).
Following on to it, there were a bunch of apis in testing.Charms that took a
series parameter, but all callers were just passing "series" anyway.

All the tests still pass, so I'm pretty happy with the changes.

R=dimitern, gz
CC=
https://codereview.appspot.com/7301073

886. By Gavin Panella on 2013-02-13

store, cmd/charm: Move them into lp:juju-store

Break out store and cmd/charm* into lp:juju-store

Red Squad are going to be working on the charm store, and it was
suggested that an early task would be to split the charm store out
into a separate project. That work has already been done - see
lp:juju-store - and this is the clean-up job.

mgz helped me a lot in doing both these tasks.

Fwiw, juju-store has not been advertised, so feel free to suggest a
different name.

R=fwereade
CC=
https://codereview.appspot.com/7058063/

885. By Roger Peppe on 2013-02-12

rpc: allow concurrent calls

The client side comes substantially from
the net/rpc package (no point in reinventing
the same wheel); the server side is a little
simpler, I hope.

R=fwereade
CC=
https://codereview.appspot.com/7307090

884. By Roger Peppe on 2013-02-12

state/api: enable password checking

R=TheMue, dimitern, fwereade
CC=
https://codereview.appspot.com/7299066

883. By Roger Peppe on 2013-02-12

rpc: new package

The rpc package is styled after the standard
Go rpc package, but is a little more flexible
and closer to our requirements.

We also change state/api to use this
package, so there's an idea of how it
will look in practice.

R=dimitern, TheMue, fwereade
CC=
https://codereview.appspot.com/6878052

882. By William Reade on 2013-02-11

state: remove AddUnitSubordinateTo

This involved entirely replacing the machine units watcher tests. They're
noticeably simplified; I don't think that I have reduced coverage, because
all the important considerations are still handled; I've just dropped all
the redundant coverage of multiple changes for each operation. If I've
missed something, please let me know.

R=dimitern, jameinel
CC=
https://codereview.appspot.com/7308080

=== added file 'environs/local/export_test.go'
--- environs/local/export_test.go	1970-01-01 00:00:00 +0000
+++ environs/local/export_test.go	2013-02-14 18:53:23 +0000
@@ -0,0 +1,15 @@
+package local
+
+import (
+	"net"
+
+	"launchpad.net/juju-core/environs"
+)
+
+func Listen(basepath, environName, ip string, port int) (net.Listener, error) {
+	return listen(basepath, environName, ip, port)
+}
+
+func NewStorage(port int, environName string) environs.Storage {
+	return newStorage(port, environName)
+}

=== added file 'environs/local/local.go'
--- environs/local/local.go	1970-01-01 00:00:00 +0000
+++ environs/local/local.go	2013-02-14 18:53:23 +0000
@@ -0,0 +1,232 @@
+package local
+
+import (
+	"fmt"
+	"sync"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/log"
+	"launchpad.net/juju-core/schema"
+	"launchpad.net/juju-core/state"
+	"launchpad.net/juju-core/state/api"
+)
+
+const storagePort = 60006
+const dataDir = "/var/lib/juju/local-data"
+
+// init registers the local provider.
+func init() {
+	environs.RegisterProvider("local", environProvider{})
+}
+
+var configChecker = schema.StrictFieldMap(
+	schema.Fields{
+		"storage-port": schema.Int(),
+		"data-dir":     schema.String(),
+	},
+	schema.Defaults{
+		"storage-port": storagePort,
+		"data-dir":     dataDir,
+	},
+)
+
+// environConfig extends the standard configuration by 
+// the storage port and the data directory.
+type environConfig struct {
+	*config.Config
+	attrs map[string]interface{}
+}
+
+func (c *environConfig) storagePort() int {
+	return c.attrs["storage-port"].(int)
+}
+
+func (c *environConfig) dataDir() string {
+	return c.attrs["data-dir"].(string)
+}
+
+// environProvider represents the local provider environment
+// provider.
+type environProvider struct {
+	mux sync.Mutex
+}
+
+func (p environProvider) newConfig(cfg *config.Config) (*environConfig, error) {
+	valid, err := p.Validate(cfg, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &environConfig{valid, valid.UnknownAttrs()}, nil
+}
+
+// Open checks if the environment exists and creates it otherwise.
+func (p environProvider) Open(cfg *config.Config) (environs.Environ, error) {
+	p.mux.Lock()
+	defer p.mux.Unlock()
+	log.Printf("environs/local: opening environment %q", cfg.Name())
+
+	name := cfg.Name()
+	ecfg, err := p.newConfig(cfg)
+	if err != nil {
+		return nil, err
+	}
+	env := &environ{
+		name:            name,
+		ecfgUnlocked:    ecfg,
+		storageUnlocked: newStorage(ecfg.storagePort(), name),
+	}
+	return env, nil
+}
+
+// Validate ensures that config is a valid configuration for the
+// local provider.
+func (p environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
+	v, err := configChecker.Coerce(cfg.UnknownAttrs(), nil)
+	if err != nil {
+		return nil, err
+	}
+	ecfg := &environConfig{cfg, v.(map[string]interface{})}
+	if ecfg.storagePort() < 0x0000 || ecfg.storagePort() > 0xFFFF {
+		return nil, fmt.Errorf("invalid local storage port number: %d", ecfg.storagePort())
+	}
+	// TODO(mue) Check if data-dir exists, otherwise create.
+	return nil, nil
+}
+
+// BoilerplateConfig returns a default configuration.
+func (p environProvider) BoilerplateConfig() string {
+	return `
+amazon:
+  type: local
+  admin-secret: {{rand}}
+  storage-port: 60006
+  # data-dir: /var/lib/juju/local-data
+`[1:]
+}
+
+// SecretAttrs returns nothing for the local environment.
+func (p environProvider) SecretAttrs(cfg *config.Config) (map[string]interface{}, error) {
+	return nil, nil
+}
+
+// PublicAddress returns an error, because the local environment
+// does not provide a public address.
+func (p environProvider) PublicAddress() (string, error) {
+	return "", fmt.Errorf("no public address for local environment")
+}
+
+// PrivateAddress returns this machine's private host name.
+func (p environProvider) PrivateAddress() (string, error) {
+	panic("not yet implemented")
+}
+
+// environ represents a local environment.
+type environ struct {
+	name            string
+	mux             sync.Mutex
+	ecfgUnlocked    *environConfig
+	storageUnlocked *storage
+}
+
+// Name returns the Environ's name.
+func (e *environ) Name() string {
+	return e.name
+}
+
+// Bootstrap ...
+func (e *environ) Bootstrap(uploadTools bool, stateServerCert, stateServerKey []byte) error {
+	panic("not yet implemented")
+}
+
+// StateInfo ...
+func (e *environ) StateInfo() (*state.Info, *api.Info, error) {
+	panic("not yet implemented")
+}
+
+// Config returns the configuration of the environment.
+func (e *environ) Config() *config.Config {
+	return e.ecfg().Config
+}
+
+// SetConfig allows no change of the configuration in the local environ.
+func (e *environ) SetConfig(cfg *config.Config) error {
+	return fmt.Errorf("change of configuration is not allowed")
+}
+
+// StartInstance returns an error as the only instance running 
+// is the LXC host.
+func (e *environ) StartInstance(machineId string, info *state.Info,
+	apiInfo *api.Info, tools *state.Tools) (environs.Instance, error) {
+	return nil, fmt.Errorf("LXC host is already running")
+}
+
+// StopInstances returns an error as the LXC host cannot be stopped.
+func (e *environ) StopInstances([]environs.Instance) error {
+	return fmt.Errorf("LXC host cannot be stopped")
+}
+
+// Instances returns the one instance representing the host system.
+func (e *environ) Instances(ids []state.InstanceId) ([]environs.Instance, error) {
+	panic("not yet implemented")
+}
+
+// AllInstances returns the one instance representing the host system.
+func (e *environ) AllInstances() ([]environs.Instance, error) {
+	panic("not yet implemented")
+}
+
+// Storage returns access to the local storage of the
+// environment.
+func (e *environ) Storage() environs.Storage {
+	e.mux.Lock()
+	storage := e.storageUnlocked
+	e.mux.Unlock()
+	return storage
+}
+
+// PublicStorage returns an empty storage as it isn't used
+// in the local environment.
+func (e *environ) PublicStorage() environs.StorageReader {
+	return environs.EmptyStorage
+}
+
+// Destroy cleans the complete environment.
+func (e *environ) Destroy(insts []environs.Instance) error {
+	panic("not yet implemented")
+}
+
+// AssignmentPolicy returns the local assignment policy.
+func (e *environ) AssignmentPolicy() state.AssignmentPolicy {
+	return state.AssignLocal
+}
+
+// OpenPorts returns an error, there are no ports in
+// local environment.
+func (e *environ) OpenPorts(ports []state.Port) error {
+	return fmt.Errorf("cannot open ports %v in local environment", ports)
+}
+
+// ClosePorts returns an error, there are no ports in
+// local environment.
+func (e *environ) ClosePorts(ports []state.Port) error {
+	return fmt.Errorf("cannot close ports %v in local environment", ports)
+}
+
+// Ports returns an error, there are no ports in
+// local environment.
+func (e *environ) Ports() ([]state.Port, error) {
+	return nil, fmt.Errorf("no ports in local environment")
+}
+
+// Provider ...
+func (e *environ) Provider() environs.EnvironProvider {
+	panic("not yet implemented")
+}
+
+func (e *environ) ecfg() *environConfig {
+	e.mux.Lock()
+	ecfg := e.ecfgUnlocked
+	e.mux.Unlock()
+	return ecfg
+}

=== added file 'environs/local/local_test.go'
--- environs/local/local_test.go	1970-01-01 00:00:00 +0000
+++ environs/local/local_test.go	2013-02-14 18:53:23 +0000
@@ -0,0 +1,231 @@
+package local_test
+
+import (
+	"bytes"
+	"io/ioutil"
+	. "launchpad.net/gocheck"
+	"net"
+	"path/filepath"
+	"testing"
+
+	"launchpad.net/juju-core/environs"
+	"launchpad.net/juju-core/environs/local"
+)
+
+func TestLocal(t *testing.T) {
+	TestingT(t)
+}
+
+type storageSuite struct {
+	listener net.Listener
+	storage  environs.Storage
+}
+
+var _ = Suite(&storageSuite{})
+
+func (s *storageSuite) SetUpSuite(c *C) {
+	var err error
+	basepath := c.MkDir()
+	environName := "test-environ"
+	s.listener, err = local.Listen(basepath, environName, "127.0.0.1", 60006)
+	c.Assert(err, IsNil)
+	s.storage = local.NewStorage(60006, environName)
+
+	createTestData(c, basepath)
+}
+
+func (s *storageSuite) TearDownSuite(c *C) {
+	s.listener.Close()
+}
+
+type getTest struct {
+	name    string
+	content string
+	err     string
+}
+
+var getTests = []getTest{
+	{
+		name:    "foo",
+		content: "this is file 'foo'",
+	},
+	{
+		name:    "bar",
+		content: "this is file 'bar'",
+	},
+	{
+		name:    "baz",
+		content: "this is file 'baz'",
+	},
+	{
+		name:    "yadda",
+		content: "this is file 'yadda'",
+	},
+	{
+		name: "dummy",
+		err:  "404 Not Found",
+	},
+	{
+		name: "../dummy",
+		err:  "404 Not Found",
+	},
+}
+
+func (s *storageSuite) TestGet(c *C) {
+	// Test retrieving a file from a storage.
+	check := func(gt getTest) {
+		r, err := s.storage.Get(gt.name)
+		if gt.err != "" {
+			c.Assert(err, ErrorMatches, gt.err)
+			return
+		}
+		defer r.Close()
+		c.Assert(err, IsNil)
+		var buf bytes.Buffer
+		_, err = buf.ReadFrom(r)
+		c.Assert(err, IsNil)
+		c.Assert(buf.String(), Equals, gt.content)
+	}
+	for _, gt := range getTests {
+		check(gt)
+	}
+}
+
+type listTest struct {
+	prefix string
+	found  []string
+	err    string
+}
+
+var listTests = []listTest{
+	{
+		prefix: "foo",
+		found:  []string{"foo"},
+	},
+	{
+		prefix: "ba",
+		found:  []string{"bar", "baz"},
+	},
+	{
+		prefix: "",
+		found:  []string{"bar", "baz", "foo", "yadda"},
+	},
+	{
+		prefix: "zzz",
+		found:  []string{},
+	},
+	{
+		prefix: "../",
+		err:    "404 Not Found",
+	},
+}
+
+func (s *storageSuite) TestList(c *C) {
+	// Test listing file of a storage.
+	check := func(lt listTest) {
+		l, err := s.storage.List(lt.prefix)
+		if lt.err != "" {
+			c.Assert(err, ErrorMatches, lt.err)
+			return
+		}
+		c.Assert(err, IsNil)
+		c.Assert(l, DeepEquals, lt.found)
+	}
+	for _, lt := range listTests {
+		check(lt)
+	}
+}
+
+type putTest struct {
+	name    string
+	content string
+	err     string
+}
+
+var putTests = []putTest{
+	{
+		name:    "porterhouse",
+		content: "this is the sent file 'porterhouse'",
+	},
+	{
+		name:    "porterhouse",
+		content: "this is the second sent file 'porterhouse'",
+		err:     "409 Conflict",
+	},
+	{
+		name: "../no-way",
+		err:  "301 Moved Permanently",
+	},
+	{
+		name:    "cambridge",
+		content: "this is the sent file 'cambridge'",
+	},
+}
+
+func (s *storageSuite) TestPut(c *C) {
+	// Test sending a file to the storage.
+	check := func(pt putTest) {
+		err := s.storage.Put(pt.name, bytes.NewBufferString(pt.content), 0)
+		if pt.err != "" {
+			c.Assert(err, ErrorMatches, pt.err)
+			return
+		}
+		c.Assert(err, IsNil)
+		r, err := s.storage.Get(pt.name)
+		c.Assert(err, IsNil)
+		defer r.Close()
+		var buf bytes.Buffer
+		_, err = buf.ReadFrom(r)
+		c.Assert(err, IsNil)
+		c.Assert(buf.String(), Equals, pt.content)
+	}
+	for _, pt := range putTests {
+		check(pt)
+	}
+}
+
+type removeTest struct {
+	name    string
+	content string
+	err     string
+}
+
+var removeTests = []removeTest{
+	{
+		name:    "fox",
+		content: "the quick brown fox yadda yadda",
+	},
+	{
+		name: "dog",
+	},
+}
+
+func (s *storageSuite) TestRemove(c *C) {
+	// Test removing a file in the storage.
+	check := func(rt removeTest) {
+		if rt.content != "" {
+			err := s.storage.Put(rt.name, bytes.NewBufferString(rt.content), 0)
+			c.Assert(err, IsNil)
+		}
+		err := s.storage.Remove(rt.name)
+		c.Assert(err, IsNil)
+	}
+	for _, rt := range removeTests {
+		check(rt)
+	}
+}
+
+func createTestData(c *C, basepath string) {
+	writeData := func(dir, name, data string) {
+		fn := filepath.Join(dir, name)
+		err := ioutil.WriteFile(fn, []byte(data), 0644)
+		c.Assert(err, IsNil)
+	}
+
+	dir := filepath.Join(basepath, "test-environ")
+
+	writeData(dir, "foo", "this is file 'foo'")
+	writeData(dir, "bar", "this is file 'bar'")
+	writeData(dir, "baz", "this is file 'baz'")
+	writeData(dir, "yadda", "this is file 'yadda'")
+}

=== removed file 'environs/local/lxc.go'
--- environs/local/lxc.go	2012-03-15 02:15:16 +0000
+++ environs/local/lxc.go	1970-01-01 00:00:00 +0000
@@ -1,64 +0,0 @@
-package local
-
-import (
-	"bytes"
-	"os/exec"
-	"strings"
-)
-
-// container represents an LXC container with the given name.
-type container struct {
-	Name string
-}
-
-// runLXCCommand runs an LXC command with the given arguments,
-// strip outing the usage message.
-func runLXCCommand(args ...string) ([]byte, error) {
-	output, err := exec.Command(args[0], args...).CombinedOutput()
-	if i := bytes.Index(bytes.ToLower(output), []byte("\nusage: ")); i > 0 {
-		output = output[:i]
-	}
-	return output, err
-}
-
-// rootPath returns the LXC container root filesystem path.
-func (c *container) rootPath() string {
-	return "/var/lib/lxc/" + c.Name + "/rootfs/"
-}
-
-// create creates the LXC container.
-func (c *container) create() ([]byte, error) {
-	return runLXCCommand("sudo", "lxc-create", "-n", c.Name)
-}
-
-// start starts the LXC container.
-func (c *container) start() ([]byte, error) {
-	return runLXCCommand("sudo", "lxc-start", "--daemon", "-n", c.Name)
-}
-
-// stop stops the LXC container.
-func (c *container) stop() ([]byte, error) {
-	return runLXCCommand("sudo", "lxc-stop", "-n", c.Name)
-}
-
-// destroy destroys the LXC container.
-func (c *container) destroy() ([]byte, error) {
-	return runLXCCommand("sudo", "lxc-destroy", "-n", c.Name)
-}
-
-// running returns true if the container name is in the
-// list of the containers that are running.
-func (c *container) running() bool {
-	for _, containerName := range list() {
-		if containerName == c.Name {
-			return true
-		}
-	}
-	return false
-}
-
-// list returns a list with the names of containers.
-func list() []string {
-	output, _ := runLXCCommand("sudo", "lxc-ls")
-	return strings.Fields(string(output))
-}

=== removed file 'environs/local/lxc_test.go'
--- environs/local/lxc_test.go	2012-03-14 14:13:43 +0000
+++ environs/local/lxc_test.go	1970-01-01 00:00:00 +0000
@@ -1,81 +0,0 @@
-package local
-
-import (
-	"flag"
-	. "launchpad.net/gocheck"
-	"testing"
-)
-
-const Defaultcontainer = "lxc_test"
-
-func Test(t *testing.T) { TestingT(t) }
-
-type S struct{}
-
-var _ = Suite(&S{})
-
-var lxcEnabled = flag.Bool("lxc", false, "enable LXC tests that require sudo")
-
-func (s *S) SetUpSuite(c *C) {
-	if !*lxcEnabled {
-		c.Skip("lxc tests need sudo access (-lxc to enable)")
-	}
-}
-
-func (s *S) TestCreate(c *C) {
-	var container container
-	container.Name = Defaultcontainer
-
-	_, err := container.create()
-	c.Assert(err, IsNil)
-
-	c.Assert(container.running(), Equals, true)
-
-	_, err = container.destroy()
-	c.Assert(err, IsNil)
-
-	c.Assert(container.running(), Equals, false)
-}
-
-func (s *S) TestStart(c *C) {
-	var container container
-	container.Name = Defaultcontainer
-
-	_, err := container.create()
-	c.Assert(err, IsNil)
-
-	_, err = container.start()
-	c.Assert(err, IsNil)
-
-	_, err = container.stop()
-	c.Assert(err, IsNil)
-
-	_, err = container.destroy()
-	c.Assert(err, IsNil)
-}
-
-func (s *S) TestIsRunningWhencontainerIsCreated(c *C) {
-	var container container
-	container.Name = Defaultcontainer
-
-	_, err := container.create()
-	c.Assert(err, IsNil)
-
-	c.Assert(container.running(), Equals, true)
-
-	_, err = container.destroy()
-	c.Assert(err, IsNil)
-}
-
-func (s *S) TestIsNotRunningWhencontainerIsNotCreated(c *C) {
-	var container container
-	container.Name = Defaultcontainer
-
-	c.Assert(container.running(), Equals, false)
-}
-
-func (s *S) TestRootPath(c *C) {
-	var container container
-	container.Name = Defaultcontainer
-	c.Assert(container.rootPath(), Equals, "/var/lib/lxc/"+Defaultcontainer+"/rootfs/")
-}

=== removed file 'environs/local/network.go'
--- environs/local/network.go	2012-05-24 17:10:58 +0000
+++ environs/local/network.go	1970-01-01 00:00:00 +0000
@@ -1,148 +0,0 @@
-package local
-
-import (
-	"encoding/xml"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"strings"
-	"text/template"
-)
-
-// network represents a local virtual network.
-type network struct {
-	XMLName xml.Name `xml:"network"`
-	Name    string   `xml:"name"`
-	Bridge  bridge   `xml:"bridge"`
-	Ip      ip       `xml:"ip"`
-	Subnet  int
-}
-
-// ip represents an ip with the given address and netmask.
-type ip struct {
-	Ip   string `xml:"address,attr"`
-	Mask string `xml:"netmask,attr"`
-}
-
-// bridge represents a briddge with the given name.
-type bridge struct {
-	Name string `xml:"name,attr"`
-}
-
-// newNetwork returns a started network.
-func newNetwork(name string, subnet int) (*network, error) {
-	n := network{Name: name, Subnet: subnet}
-	err := n.start()
-	if err != nil {
-		return nil, err
-	}
-	err = n.loadAttributes()
-	if err != nil {
-		return nil, err
-	}
-	return &n, nil
-}
-
-// loadAttributes loads the attributes for a network.
-func (n *network) loadAttributes() error {
-	output, err := exec.Command("virsh", "net-dumpxml", n.Name).Output()
-	if err != nil {
-		return err
-	}
-	return xml.Unmarshal(output, &n)
-}
-
-// running returns true if network name is in the
-// list of networks and is active.
-func (n *network) running() (bool, error) {
-	networks, err := listNetworks()
-	if err != nil {
-		return false, err
-	}
-	return networks[n.Name], nil
-}
-
-// exists returns true if network name is in the
-// list of networks.
-func (n *network) exists() (bool, error) {
-	networks, err := listNetworks()
-	if err != nil {
-		return false, err
-	}
-	_, exists := networks[n.Name]
-	return exists, nil
-}
-
-// virsh replaces %d with an auto increment
-// number to make the bridge name unique
-var libVirtNetworkTemplate = template.Must(template.New("").Parse(`
-<network>
-  <name>{{.Name}}</name>
-  <bridge name='vbr-{{.Name}}-%d' />
-  <forward/>
-  <ip address='192.168.{{.Subnet}}.1' netmask='255.255.255.0'>
-    <dhcp>
-      <range start='192.168.{{.Subnet}}.2' end='192.168.{{.Subnet}}.254' />
-    </dhcp>
-  </ip>
-</network>
-`))
-
-// start ensures that the network is started.
-// If the network name does not exist, it is created.
-func (n *network) start() error {
-	exists, err := n.exists()
-	if err != nil {
-		return err
-	}
-	if exists {
-		running, err := n.running()
-		if err != nil {
-			return err
-		}
-		if running {
-			return nil
-		}
-		return exec.Command("virsh", "net-start", n.Name).Run()
-	}
-	file, err := ioutil.TempFile(os.TempDir(), "network")
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-	defer os.Remove(file.Name())
-	err = libVirtNetworkTemplate.Execute(file, n)
-	if err != nil {
-		return err
-	}
-	err = exec.Command("virsh", "net-define", file.Name()).Run()
-	if err != nil {
-		return err
-	}
-	return exec.Command("virsh", "net-start", n.Name).Run()
-}
-
-// listNetworks returns a map from network name to active status.
-func listNetworks() (map[string]bool, error) {
-	output, err := exec.Command("virsh", "net-list", "--all").Output()
-	if err != nil {
-		return nil, err
-	}
-	// Remove the header.
-	networks := map[string]bool{}
-	lines := strings.Split(string(output), "\n")
-	if len(lines) < 3 {
-		return networks, nil
-	}
-	lines = lines[2:]
-	for _, line := range lines {
-		if line == "" {
-			continue
-		}
-		fields := strings.Fields(line)
-		if len(fields) > 2 {
-			networks[fields[0]] = fields[1] == "active"
-		}
-	}
-	return networks, nil
-}

=== removed file 'environs/local/network_test.go'
--- environs/local/network_test.go	2012-05-24 17:10:58 +0000
+++ environs/local/network_test.go	1970-01-01 00:00:00 +0000
@@ -1,144 +0,0 @@
-package local
-
-import (
-	. "launchpad.net/gocheck"
-	"os"
-)
-
-var scriptText = `#!/bin/bash
-#!/bin/bash
-
-case "$1" in
-net-list)
-cat <<END
-Name                 State      Autostart
------------------------------------------
-default              active     yes
-juju-test            active     yes
-foobar               inactive   no
-END
-;;
-
-net-dumpxml)
-cat <<END
-<network>
-<name>default</name>
-<uuid>7f5d45e4-2fa2-f713-0229-fb1fea419e3b</uuid>
-<forward mode='nat'/>
-<bridge name='virbr0' stp='on' delay='0' />
-<ip address='192.168.122.1' netmask='255.255.255.0'>
-<dhcp>
-<range start='192.168.122.2' end='192.168.122.254' />
-</dhcp>
-</ip>
-</network>
-END
-;;
-
-net-start)
-echo "net-start"
-;;
-
-net-define)
-echo "net-define"
-;;
-
-esac
-`
-
-type networkSuite struct {
-	oldPath string
-}
-
-var _ = Suite(&networkSuite{})
-
-func (s *networkSuite) SetUpSuite(c *C) {
-	s.oldPath = os.Getenv("PATH")
-	dir := c.MkDir()
-	os.Setenv("PATH", dir+":"+s.oldPath)
-	writeScript(c, dir)
-}
-
-func (s *networkSuite) TearDownSuite(c *C) {
-	os.Setenv("PATH", s.oldPath)
-}
-
-func (s *networkSuite) TestStartNetwork(c *C) {
-	// start a network that already exists
-	n := network{Name: "default"}
-	err := n.start()
-	c.Assert(err, IsNil)
-
-	// start a new network
-	n = network{Name: "newnet"}
-	err = n.start()
-	c.Assert(err, IsNil)
-}
-
-func (s *networkSuite) TestNewNetwork(c *C) {
-	_, err := newNetwork("name", 133)
-	c.Assert(err, IsNil)
-}
-
-func (s *networkSuite) TestLoadAttributes(c *C) {
-	n := network{Name: "default"}
-	err := n.loadAttributes()
-	c.Assert(err, IsNil)
-	c.Assert(n.Name, Equals, "default")
-	c.Assert(n.Bridge.Name, Equals, "virbr0")
-	c.Assert(n.Ip.Ip, Equals, "192.168.122.1")
-	c.Assert(n.Ip.Mask, Equals, "255.255.255.0")
-}
-
-func (s *networkSuite) TestRunning(c *C) {
-	n := network{Name: "default"}
-	running, err := n.running()
-	c.Assert(err, IsNil)
-	c.Assert(running, Equals, true)
-
-	n = network{Name: "foobar"}
-	running, err = n.running()
-	c.Assert(err, IsNil)
-	c.Assert(running, Equals, false)
-
-	n = network{Name: "fakeName"}
-	running, err = n.running()
-	c.Assert(err, IsNil)
-	c.Assert(running, Equals, false)
-}
-
-func (s *networkSuite) TestNetworkExists(c *C) {
-	n := network{Name: "default"}
-	exists, err := n.exists()
-	c.Assert(err, IsNil)
-	c.Assert(exists, Equals, true)
-
-	n = network{Name: "foobar"}
-	exists, err = n.exists()
-	c.Assert(err, IsNil)
-	c.Assert(exists, Equals, true)
-
-	n = network{Name: "fakeName"}
-	exists, err = n.exists()
-	c.Assert(err, IsNil)
-	c.Assert(exists, Equals, false)
-}
-
-func (s *networkSuite) TestListNetworks(c *C) {
-	expected := map[string]bool{
-		"juju-test": true,
-		"foobar":    false,
-		"default":   true,
-	}
-	networks, err := listNetworks()
-	c.Assert(err, IsNil)
-	c.Assert(networks, DeepEquals, expected)
-}
-
-func writeScript(c *C, dir string) {
-	f, err := os.OpenFile(dir+"/virsh", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0777)
-	c.Assert(err, IsNil)
-	defer f.Close()
-	_, err = f.WriteString(scriptText)
-	c.Assert(err, IsNil)
-}

=== added file 'environs/local/storage.go'
--- environs/local/storage.go	1970-01-01 00:00:00 +0000
+++ environs/local/storage.go	2013-02-14 18:53:23 +0000
@@ -0,0 +1,260 @@
+package local
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"syscall"
+)
+
+// storageBackend provides HTTP access to a defined path.
+type storageBackend struct {
+	environName string
+	uri         string
+	path        string
+}
+
+// newContainer returns a new container using the given path.
+func newStorageBackend(basepath, environName string) *storageBackend {
+	sb := &storageBackend{
+		environName: environName,
+		uri:         fmt.Sprintf("/%s/", environName),
+		path:        filepath.Join(basepath, environName),
+	}
+	return sb
+}
+
+// ServeHTTP handles the HTTP requests to the container.
+func (s *storageBackend) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	switch req.Method {
+	case "GET":
+		if strings.HasSuffix(req.URL.Path, "*") {
+			s.handleList(w, req)
+		} else {
+			s.handleGet(w, req)
+		}
+	case "POST":
+		s.handlePost(w, req)
+	case "DELETE":
+		s.handleDelete(w, req)
+	default:
+		http.Error(w, "method "+req.Method+" is not supported", http.StatusMethodNotAllowed)
+	}
+}
+
+// handleGet returns a storage file to the client.
+func (s *storageBackend) handleGet(w http.ResponseWriter, req *http.Request) {
+	data, err := ioutil.ReadFile(filepath.Join(s.path, req.URL.Path))
+	if err != nil {
+		if isNotExist(err) {
+			http.Error(w, fmt.Sprintf("404 '%s' Not Found", req.URL.Path), http.StatusNotFound)
+			return
+		}
+		http.Error(w, fmt.Sprintf("500 %v", err), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Write(data)
+}
+
+// handleList returns the names in the storage to the client.
+func (s *storageBackend) handleList(w http.ResponseWriter, req *http.Request) {
+	fis, err := ioutil.ReadDir(s.path)
+	if err != nil {
+		if isNotExist(err) {
+			http.Error(w, fmt.Sprintf("404 /%s not found", req.URL.Path), http.StatusNotFound)
+			return
+		}
+		http.Error(w, fmt.Sprintf("500 %v", err), http.StatusInternalServerError)
+		return
+	}
+	prefix := req.URL.Path[:len(req.URL.Path)-1]
+	names := []string{}
+	for _, fi := range fis {
+		name := fi.Name()
+		if strings.HasPrefix(name, prefix) {
+			names = append(names, name)
+		}
+	}
+	data := []byte(strings.Join(names, "\n"))
+	w.Header().Set("Content-Type", "application/octet-stream")
+	w.Write(data)
+}
+
+// handlePost stores data from the client in the storage.
+func (s *storageBackend) handlePost(w http.ResponseWriter, req *http.Request) {
+	fp := filepath.Join(s.path, req.URL.Path)
+	_, err := os.Stat(fp)
+	if err == nil {
+		http.Error(w, fmt.Sprintf("409 '%s' Already Exist", req.URL.Path), http.StatusConflict)
+		return
+	} else if !isNotExist(err) {
+		http.Error(w, fmt.Sprintf("500 %v", err), http.StatusInternalServerError)
+		return
+	}
+	body, err := ioutil.ReadAll(req.Body)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("500 %c", err), http.StatusInternalServerError)
+		return
+	}
+	err = ioutil.WriteFile(fp, body, 0644)
+	if err != nil {
+		http.Error(w, fmt.Sprintf("500 %v", err), http.StatusInternalServerError)
+		return
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// handleDelete removes data from the storage.
+func (s *storageBackend) handleDelete(w http.ResponseWriter, req *http.Request) {
+	fp := filepath.Join(s.path, req.URL.Path)
+	err := os.Remove(fp)
+	if err != nil {
+		if !isNotExist(err) {
+			http.Error(w, fmt.Sprintf("500 %v", err), http.StatusInternalServerError)
+			return
+		}
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+// listen starts a network listener listening for HTTP requests
+// to get, put, list and remove the files in the state's storage.
+func listen(basepath, environName, ip string, port int) (net.Listener, error) {
+	backend := newStorageBackend(basepath, environName)
+	if err := os.MkdirAll(backend.path, 0755); err != nil {
+		return nil, err
+	}
+	listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", ip, port))
+	if err != nil {
+		panic(fmt.Errorf("cannot start listener: %v", err))
+	}
+	mux := http.NewServeMux()
+	mux.Handle(backend.uri, http.StripPrefix(backend.uri, backend))
+
+	go http.Serve(listener, mux)
+
+	return listener, nil
+}
+
+// storage implements the Storage interface.
+type storage struct {
+	port        int
+	environName string
+}
+
+// newStorage returns a new local storage.
+func newStorage(port int, environName string) *storage {
+	return &storage{
+		port:        port,
+		environName: environName,
+	}
+}
+
+// Get opens the given storage file and returns a ReadCloser
+// that can be used to read its contents. It is the caller's
+// responsibility to close it after use. If the name does not
+// exist, it should return a *NotFoundError.
+func (s *storage) Get(name string) (io.ReadCloser, error) {
+	url, err := s.URL(name)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := http.Get(url)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return nil, fmt.Errorf(resp.Status)
+	}
+	return resp.Body, nil
+}
+
+// List lists all names in the storage with the given prefix, in
+// alphabetical order. The names in the storage are considered
+// to be in a flat namespace, so the prefix may include slashes
+// and the names returned are the full names for the matching
+// entries.
+func (s *storage) List(prefix string) ([]string, error) {
+	url, err := s.URL(prefix)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := http.Get(url + "*")
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return nil, fmt.Errorf(resp.Status)
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	if string(body) == "" {
+		return []string{}, nil
+	}
+	names := strings.Split(string(body), "\n")
+	sort.Strings(names)
+	return names, nil
+}
+
+// URL returns a URL that can be used to access the given storage file.
+func (s *storage) URL(name string) (string, error) {
+	return fmt.Sprintf("http://localhost:%d/%s/%s", s.port, s.environName, name), nil
+}
+
+// Put reads from r and writes to the given storage file.
+// The length must give the total length of the file.
+func (s *storage) Put(name string, r io.Reader, length int64) error {
+	url, err := s.URL(name)
+	if err != nil {
+		return err
+	}
+	resp, err := http.Post(url, "application/octet-stream", r)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return fmt.Errorf(resp.Status)
+	}
+	return nil
+}
+
+// Remove removes the given file from the environment's
+// storage. It should not return an error if the file does
+// not exist.
+func (s *storage) Remove(name string) error {
+	url, err := s.URL(name)
+	if err != nil {
+		return err
+	}
+	req, err := http.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return err
+	}
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		return fmt.Errorf(resp.Status)
+	}
+	return nil
+}
+
+// isNotExist checks if a returned error shows that a file 
+// does not exist.
+func isNotExist(err error) bool {
+	if err, ok := err.(*os.PathError); ok && (os.IsNotExist(err.Err) || err.Err == syscall.ENOTDIR) {
+		return true
+	}
+	return false
+}