Merge lp:~thumper/juju-core/local-config into lp:~go-bot/juju-core/trunk

[Tim Penhey]

Add initial local provider config.

Right now, just looking at the directories for storing
the files used by public and private storage. The branch
also adds in the Validation and setting/getting methods
for the config.

https://codereview.appspot.com/10734043/

Add initial local provider config.

Right now, just looking at the directories for storing
the files used by public and private storage. The branch
also adds in the Validation and setting/getting methods
for the config.

https://codereview.appspot.com/10734043/

[Tim Penhey (thumper)]

Reviewers: mp+171956_code.launchpad.net,

Message:
Please take a look.

Description:
Add initial local provider config.

Right now, just looking at the directories for storing
the files used by public and private storage. The branch
also adds in the Validation and setting/getting methods
for the config.

https://code.launchpad.net/~thumper/juju-core/local-config/+merge/171956

Requires:
https://code.launchpad.net/~thumper/juju-core/local-provider-skeleton/+merge/171951

(do not edit description out of merge proposal)

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

Affected files:
   A [revision details]
   A environs/local/config.go
   M environs/local/environ-provider.go
   A environs/local/environ-provider_test.go
   M environs/local/environ.go
   A environs/local/environ_test.go
   A environs/local/export_test.go

[Ian Booth (wallyworld)]

A few comments inline.
It would be great also if the config tests could be structured a little
like the ones used for the other providers, where and array of test
scenarios for things like default value handling etc is tested.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go
File environs/local/environ-provider.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode30
environs/local/environ-provider.go:30: defaultPrivateStorageDir =
"/var/lib/juju/local/%s/private"
Perhaps a stupid question - do we really want to make these in a
location where the user needs privileges or access granted? Why not
somewhere in their home dir? That would also allow many users on the one
machine to run juju with a local provider without interfering with each
other/

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode45
environs/local/environ-provider.go:45: func ensureDirExists(path string)
error {
Just curious - do we already have this function somewhere? If not, could
we consider putting it in a utils package or something. I'm a bit
perplexed the std libs don't have this built in.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go
File environs/local/environ-provider_test.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode61
environs/local/environ-provider_test.go:61: func (s *providerSuite)
TestValidateConfig(c *C) {
Could we follow the other providers and put config tests in a
config_test.go file?

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

https://codereview.appspot.com/10734043/diff/1/environs/local/environ.go#newcode22
environs/local/environ.go:22: localMutex sync.Mutex
Other providers need more than one mutex. The one protecting config is
called cfgMutex. Perhaps we can follow that convention? Or do we think
there will only be the one mutex required?

https://codereview.appspot.com/10734043/diff/1/environs/local/environ.go#newcode43
environs/local/environ.go:43: func (env *localEnviron) Config()
*config.Config {
Other providers use an intermediate ecfg() method. I'm not sure why.
Perhaps we could find out if that approach is for a good reason and
adopt it if required here too?

https://codereview.appspot.com/10734043/

[William Reade (fwereade)]

LGTM, I think, modulo quibbles below:

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go
File environs/local/environ-provider.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode30
environs/local/environ-provider.go:30: defaultPrivateStorageDir =
"/var/lib/juju/local/%s/private"
On 2013/06/28 06:22:57, wallyworld wrote:
> Perhaps a stupid question - do we really want to make these in a
location where
> the user needs privileges or access granted? Why not somewhere in
their home
> dir? That would also allow many users on the one machine to run juju
with a
> local provider without interfering with each other/

This is a good point and a noble goal. Somewhat implies badging things
like containers with username as well as environment name; probably a
good thing.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode45
environs/local/environ-provider.go:45: func ensureDirExists(path string)
error {
On 2013/06/28 06:22:57, wallyworld wrote:
> Just curious - do we already have this function somewhere? If not,
could we
> consider putting it in a utils package or something. I'm a bit
perplexed the std
> libs don't have this built in.

os.MkdirAll

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode91
environs/local/environ-provider.go:91: }
We need to check the storage dirs don't change, I think.

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

https://codereview.appspot.com/10734043/diff/1/environs/local/environ.go#newcode22
environs/local/environ.go:22: localMutex sync.Mutex
On 2013/06/28 06:22:57, wallyworld wrote:
> Other providers need more than one mutex. The one protecting config is
called
> cfgMutex. Perhaps we can follow that convention? Or do we think there
will only
> be the one mutex required?

I'm ok with this as it is... I don't think this is going to be an
overwhelmingly complex provider. I hope.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ.go#newcode46
environs/local/environ.go:46: return env.config.Config
These are immutable, right?

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

https://codereview.appspot.com/10734043/diff/1/environs/local/environ_test.go#newcode12
environs/local/environ_test.go:12: providerSuite
This'll run all the tests in providerSuite a second time, won't it?

https://codereview.appspot.com/10734043/

[Tim Penhey (thumper)]

Please take a look.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go
File environs/local/environ-provider.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode30
environs/local/environ-provider.go:30: defaultPrivateStorageDir =
"/var/lib/juju/local/%s/private"
On 2013/06/28 06:22:57, wallyworld wrote:
> Perhaps a stupid question - do we really want to make these in a
location where
> the user needs privileges or access granted? Why not somewhere in
their home
> dir? That would also allow many users on the one machine to run juju
with a
> local provider without interfering with each other/

Interesting point. But there is a bigger problem here. lxc containers
(at least in precise now) require the containers to be in /var/lib/lxc.
This means that while also namespacing the storage area, we should also
make sure that we namespace the containers with the user id.

I really didn't consider multiple users using a local provider on one
machine as this was a little outside the scope of the local provider.
However we should probably support it.

With respect to the privileged location, this isn't an issue as the user
will need to 'sudo juju bootstrap' the local provider as we need to do
stuff with lxc containers, which requires root.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode45
environs/local/environ-provider.go:45: func ensureDirExists(path string)
error {
On 2013/06/28 14:43:50, fwereade wrote:
> On 2013/06/28 06:22:57, wallyworld wrote:
> > Just curious - do we already have this function somewhere? If not,
could we
> > consider putting it in a utils package or something. I'm a bit
perplexed the
> std
> > libs don't have this built in.

> os.MkdirAll

Hmm... will just simplify to use os.MkdirAll.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode91
environs/local/environ-provider.go:91: }
On 2013/06/28 14:43:50, fwereade wrote:
> We need to check the storage dirs don't change, I think.

OK

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go
File environs/local/environ-provider_test.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode61
environs/local/environ-provider_test.go:61: func (s *providerSuite)
TestValidateConfig(c *C) {
On 2013/06/28 06:22:57, wallyworld wrote:
> Could we follow the other providers and put config tests in a
config_test.go
> file?

OK.

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

https://codereview.appspot.com/10734043/diff/1/environs/local/environ.go#newcode43
environs/local/environ.go:43: func (env *localEnviron) Config()
*config.Config {
On 2013/06/28 06:22:57, wallyworld wrote:
> Other providers use an intermediate ecfg() method. I'm not sure why.
Perhaps we
> could find out if that approach is for a good reason and adopt it if
required
> here too?

I may do this if we decide that it is necessary. I'm not convinced that
it is necessary yet though.

https://codereview.appspot.com/10734043/dif...

[Ian Booth (wallyworld)]

LGTM. I think I'd prefer the config tests to use a similar structure as
those for other providers wrt testing default value handling etc but
won't block on that.

https://codereview.appspot.com/10734043/

[John A Meinel (jameinel)]

LGTM

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go
File environs/local/environ-provider.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode30
environs/local/environ-provider.go:30: defaultPrivateStorageDir =
"/var/lib/juju/local/%s/private"

> With respect to the privileged location, this isn't an issue as the
user will
> need to 'sudo juju bootstrap' the local provider as we need to do
stuff with lxc
> containers, which requires root.

Since you need sudo access, I think just badging the instances with the
environment gets you enough. You don't really need to also add the
username.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode106
environs/local/environ-provider.go:106: `[1:]
You don't have to add them here, but wouldn't you want to document the 2
fields that you just added (private-storage and public-storage).

Also, I think you don't support 'default-series' yet, so it doesn't make
sense to have it commented out, since people would think they could just
uncomment it and change it. (Though that is probably where you are
heading.)

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go
File environs/local/environ-provider_test.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode2
environs/local/environ-provider_test.go:2: // Licensed under the AGPLv3,
see LICENCE file for details.
I'm a bit surprised the file is named 'environ-provider_test.go'. (It
isn't valid as a go identifier, I believe, though only the package name
must match)

I don't think we have any other filenames with '-' in them, though.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode15
environs/local/environ-provider_test.go:15: "launchpad.net/loggo"
I've been following more of a:

stdlib

3rd-party-libs

juju-core libs

For imports. Does that make sense, or is it splitting them up too much?

It would look like:
import (
   "fmt"
   "path/filepath"

   . "launchpad.net/gocheck"
   "launchpad.net/loggo"

   "launchpad.net/juju-core/environs/config"
   "launchpad.net/juju-core/environs/local"
   "launchpad.net/juju-core/testing"
   . "launchpad.net/juju-core/testing/checkers"
)

https://codereview.appspot.com/10734043/

[Tim Penhey (thumper)]

On 2013/07/01 02:45:43, wallyworld wrote:
> LGTM. I think I'd prefer the config tests to use a similar structure
as those
> for other providers wrt testing default value handling etc but won't
block on
> that.

Actually I did try that, but there is too much state to deal with in the
tests
for this to be useful.

https://codereview.appspot.com/10734043/

[Tim Penhey (thumper)]

On 2013/07/01 10:34:04, jameinel wrote:
> LGTM

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go
> File environs/local/environ-provider.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode30
> environs/local/environ-provider.go:30: defaultPrivateStorageDir =
> "/var/lib/juju/local/%s/private"

> >
> > With respect to the privileged location, this isn't an issue as the
user will
> > need to 'sudo juju bootstrap' the local provider as we need to do
stuff with
> lxc
> > containers, which requires root.

> Since you need sudo access, I think just badging the instances with
the
> environment gets you enough. You don't really need to also add the
username.

Not if multiple people use the default environment name called "local".

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider.go#newcode106
> environs/local/environ-provider.go:106: `[1:]
> You don't have to add them here, but wouldn't you want to document the
2 fields
> that you just added (private-storage and public-storage).

I did in patch 2.

> Also, I think you don't support 'default-series' yet, so it doesn't
make sense
> to have it commented out, since people would think they could just
uncomment it
> and change it. (Though that is probably where you are heading.)

Removed it.

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go
> File environs/local/environ-provider_test.go (right):

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode2
> environs/local/environ-provider_test.go:2: // Licensed under the
AGPLv3, see
> LICENCE file for details.
> I'm a bit surprised the file is named 'environ-provider_test.go'. (It
isn't
> valid as a go identifier, I believe, though only the package name must
match)

> I don't think we have any other filenames with '-' in them, though.

We do, but I may have added them too. I've renamed it
environprovider.go and environprovider_test.go

https://codereview.appspot.com/10734043/diff/1/environs/local/environ-provider_test.go#newcode15
> environs/local/environ-provider_test.go:15: "launchpad.net/loggo"
> I've been following more of a:

> stdlib

> 3rd-party-libs

> juju-core libs

> For imports. Does that make sense, or is it splitting them up too
much?

> It would look like:
> import (
> "fmt"
> "path/filepath"

> . "launchpad.net/gocheck"
> "launchpad.net/loggo"

> "launchpad.net/juju-core/environs/config"
> "launchpad.net/juju-core/environs/local"
> "launchpad.net/juju-core/testing"
> . "launchpad.net/juju-core/testing/checkers"
> )

Actually I like that even more, and fixed the code to follow this.

https://codereview.appspot.com/10734043/

[John A Meinel (jameinel)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

...

>
>> Since you need sudo access, I think just badging the instances
>> with
> the
>> environment gets you enough. You don't really need to also add
>> the
> username.
>
> Not if multiple people use the default environment name called
> "local".
>

That is true, but it is also true if you use shared credentials on
Openstack or EC2 or anywhere else.

I think if people want to share a local system they can use different
names for their environments. (A lot of people run the user 'ubuntu'
anyway, right?)

We *can* add user, I just don't think it actually adds much, and it
isn't something we do anywhere else.

John
=:->

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.13 (Cygwin)
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iEYEARECAAYFAlHSkCIACgkQJdeBCYSNAAOTfgCfchBlt/YjayfD0DSQnu1S0SGx
UBIAoIebSwSIn7Vtfo1+Feu4n8u6vtG+
=NnXm
-----END PGP SIGNATURE-----

=== added file 'environs/local/config.go'
--- environs/local/config.go	1970-01-01 00:00:00 +0000
+++ environs/local/config.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,53 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package local
+
+import (
+	"fmt"
+	"os"
+
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/schema"
+)
+
+var configChecker = schema.StrictFieldMap(
+	schema.Fields{
+		"shared-storage": schema.String(),
+		"storage":        schema.String(),
+	},
+	schema.Defaults{
+		"shared-storage": "",
+		"storage":        "",
+	},
+)
+
+type environConfig struct {
+	*config.Config
+	user  string
+	attrs map[string]interface{}
+}
+
+func newEnvironConfig(config *config.Config, attrs map[string]interface{}) *environConfig {
+	user := os.Getenv("USER")
+	return &environConfig{
+		Config: config,
+		user:   user,
+		attrs:  attrs,
+	}
+}
+
+// Since it is technically possible for two different users on one machine to
+// have the same local provider name, we need to have a simple way to
+// namespace the file locations, but more importantly the lxc containers.
+func (c *environConfig) namespace() string {
+	return fmt.Sprintf("%s-%s", c.user, c.Name())
+}
+
+func (c *environConfig) publicStorageDir() string {
+	return c.attrs["shared-storage"].(string)
+}
+
+func (c *environConfig) privateStorageDir() string {
+	return c.attrs["storage"].(string)
+}

=== added file 'environs/local/config_test.go'
--- environs/local/config_test.go	1970-01-01 00:00:00 +0000
+++ environs/local/config_test.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,89 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package local_test
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	gc "launchpad.net/gocheck"
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/environs/local"
+	"launchpad.net/juju-core/testing"
+	jc "launchpad.net/juju-core/testing/checkers"
+)
+
+type configSuite struct {
+	baseProviderSuite
+	oldUser string
+}
+
+var _ = gc.Suite(&configSuite{})
+
+func (s *configSuite) SetUpTest(c *gc.C) {
+	s.baseProviderSuite.SetUpTest(c)
+	s.oldUser = os.Getenv("USER")
+	err := os.Setenv("USER", "tester")
+	c.Assert(err, gc.IsNil)
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *configSuite) TearDownTest(c *gc.C) {
+	os.Setenv("USER", s.oldUser)
+	s.baseProviderSuite.TearDownTest(c)
+}
+
+func minimalConfigValues() map[string]interface{} {
+	return map[string]interface{}{
+		"name": "test",
+		"type": "local",
+		// While the ca-cert bits aren't entirely minimal, they avoid the need
+		// to set up a fake home.
+		"ca-cert":        testing.CACert,
+		"ca-private-key": testing.CAKey,
+	}
+}
+
+func minimalConfig(c *gc.C) *config.Config {
+	minimal := minimalConfigValues()
+	testConfig, err := config.New(minimal)
+	c.Assert(err, gc.IsNil)
+	return testConfig
+}
+
+func (s *configSuite) TestValidateConfig(c *gc.C) {
+	testConfig := minimalConfig(c)
+
+	valid, err := local.Provider.Validate(testConfig, nil)
+	c.Assert(err, gc.IsNil)
+	unknownAttrs := valid.UnknownAttrs()
+
+	publicDir := fmt.Sprintf(s.public, "tester-test")
+	c.Assert(publicDir, jc.IsDirectory)
+	c.Assert(unknownAttrs["shared-storage"], gc.Equals, publicDir)
+
+	privateDir := fmt.Sprintf(s.private, "tester-test")
+	c.Assert(privateDir, jc.IsDirectory)
+	c.Assert(unknownAttrs["storage"], gc.Equals, privateDir)
+}
+
+func (s *configSuite) TestValidateConfigWithStorage(c *gc.C) {
+	values := minimalConfigValues()
+	public := filepath.Join(c.MkDir(), "public", "storage")
+	private := filepath.Join(c.MkDir(), "private", "storage")
+	values["shared-storage"] = public
+	values["storage"] = private
+	testConfig, err := config.New(values)
+	c.Assert(err, gc.IsNil)
+
+	valid, err := local.Provider.Validate(testConfig, nil)
+	c.Assert(err, gc.IsNil)
+	unknownAttrs := valid.UnknownAttrs()
+
+	c.Assert(public, jc.IsDirectory)
+	c.Assert(unknownAttrs["shared-storage"], gc.Equals, public)
+	c.Assert(private, jc.IsDirectory)
+	c.Assert(unknownAttrs["storage"], gc.Equals, private)
+}

=== modified file 'environs/local/environ.go'
--- environs/local/environ.go	2013-06-28 02:35:59 +0000
+++ environs/local/environ.go	2013-07-02 04:37:23 +0000
@@ -5,6 +5,7 @@
 
 import (
 	"fmt"
+	"sync"
 
 	"launchpad.net/juju-core/constraints"
 	"launchpad.net/juju-core/environs"
@@ -18,7 +19,9 @@
 var _ environs.Environ = (*localEnviron)(nil)
 
 type localEnviron struct {
-	name string
+	localMutex sync.Mutex
+	config     *environConfig
+	name       string
 }
 
 // Name is specified in the Environ interface.
@@ -38,12 +41,22 @@
 
 // Config is specified in the Environ interface.
 func (env *localEnviron) Config() *config.Config {
-	panic("unimplemented")
+	env.localMutex.Lock()
+	defer env.localMutex.Unlock()
+	return env.config.Config
 }
 
 // SetConfig is specified in the Environ interface.
 func (env *localEnviron) SetConfig(cfg *config.Config) error {
-	return fmt.Errorf("not implemented")
+	config, err := provider.newConfig(cfg)
+	if err != nil {
+		logger.Errorf("failed to create new environ config: %v", err)
+		return err
+	}
+	env.localMutex.Lock()
+	defer env.localMutex.Unlock()
+	env.config = config
+	return nil
 }
 
 // StartInstance is specified in the Environ interface.

=== added file 'environs/local/environ_test.go'
--- environs/local/environ_test.go	1970-01-01 00:00:00 +0000
+++ environs/local/environ_test.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,25 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package local_test
+
+import (
+	gc "launchpad.net/gocheck"
+
+	"launchpad.net/juju-core/environs/local"
+)
+
+type environSuite struct {
+	baseProviderSuite
+}
+
+var _ = gc.Suite(&environSuite{})
+
+func (*environSuite) TestName(c *gc.C) {
+	testConfig := minimalConfig(c)
+
+	environ, err := local.Provider.Open(testConfig)
+	c.Assert(err, gc.IsNil)
+
+	c.Assert(environ.Name(), gc.Equals, "test")
+}

=== renamed file 'environs/local/environ-provider.go' => 'environs/local/environprovider.go'
--- environs/local/environ-provider.go	2013-06-28 01:58:45 +0000
+++ environs/local/environprovider.go	2013-07-02 04:37:23 +0000
@@ -5,11 +5,14 @@
 
 import (
 	"fmt"
+	"os"
+
+	"launchpad.net/loggo"
 
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/instance"
-	"launchpad.net/loggo"
+	"launchpad.net/juju-core/utils"
 )
 
 var logger = loggo.GetLogger("juju.environs.local")
@@ -24,19 +27,92 @@
 	environs.RegisterProvider("local", &environProvider{})
 }
 
+var (
+	defaultPublicStorageDir  = "/var/lib/juju/local/%s/public"
+	defaultPrivateStorageDir = "/var/lib/juju/local/%s/private"
+)
+
 // Open implements environs.EnvironProvider.Open.
 func (environProvider) Open(cfg *config.Config) (environs.Environ, error) {
-	return nil, fmt.Errorf("not implemented")
+	logger.Infof("opening environment %q", cfg.Name())
+	environ := &localEnviron{name: cfg.Name()}
+	err := environ.SetConfig(cfg)
+	if err != nil {
+		logger.Errorf("failure setting config: %v", err)
+		return nil, err
+	}
+	return environ, nil
 }
 
 // Validate implements environs.EnvironProvider.Validate.
-func (environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
-	return nil, fmt.Errorf("not implemented")
+func (provider environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {
+	// Check for valid changes for the base config values.
+	if err := config.Validate(cfg, old); err != nil {
+		return nil, err
+	}
+	v, err := configChecker.Coerce(cfg.UnknownAttrs(), nil)
+	if err != nil {
+		return nil, err
+	}
+	localConfig := newEnvironConfig(cfg, v.(map[string]interface{}))
+	// Before potentially creating directories, make sure that the
+	// public storage and private storage values have not changed.
+	if old != nil {
+		oldLocalConfig, err := provider.newConfig(old)
+		if err != nil {
+			return nil, fmt.Errorf("old config is not a valid local config: %v", old)
+		}
+		if localConfig.publicStorageDir() != oldLocalConfig.publicStorageDir() {
+			return nil, fmt.Errorf("cannot change shared-storage from %q to %q",
+				oldLocalConfig.publicStorageDir(),
+				localConfig.publicStorageDir())
+		}
+		if localConfig.privateStorageDir() != oldLocalConfig.privateStorageDir() {
+			return nil, fmt.Errorf("cannot change storage from %q to %q",
+				oldLocalConfig.privateStorageDir(),
+				localConfig.privateStorageDir())
+		}
+	}
+	dir := utils.NormalizePath(localConfig.publicStorageDir())
+	if dir == "." {
+		dir = fmt.Sprintf(defaultPublicStorageDir, localConfig.namespace())
+		localConfig.attrs["shared-storage"] = dir
+	}
+	logger.Tracef("ensure shared-storage dir %s exists", dir)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		logger.Errorf("failed to make directory for shared storage at %s: %v", dir, err)
+		return nil, err
+	}
+
+	dir = utils.NormalizePath(localConfig.privateStorageDir())
+	if dir == "." {
+		dir = fmt.Sprintf(defaultPrivateStorageDir, localConfig.namespace())
+		localConfig.attrs["storage"] = dir
+	}
+	logger.Tracef("ensure storage dir %s exists", dir)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		logger.Errorf("failed to make directory for storage at %s: %v", dir, err)
+		return nil, err
+	}
+
+	// Apply the coerced unknown values back into the config.
+	return cfg.Apply(localConfig.attrs)
 }
 
 // BoilerplateConfig implements environs.EnvironProvider.BoilerplateConfig.
 func (environProvider) BoilerplateConfig() string {
-	return "not implemented"
+	return `
+## https://juju.ubuntu.com/get-started/local/
+local:
+  type: local
+  # Override the storage location to store the private files for this environment in the
+  # specified location.  The default location is /var/lib/juju/local/<USER>-<ENV>/private
+  # storage: ~/.juju/local/private
+  # Override the shared-storage location to store the public files for this environment in the
+  # specified location.  The default location is /var/lib/juju/local/<USER>-<ENV>/public
+  # shared-storage: ~/.juju/local/public
+
+`[1:]
 }
 
 // SecretAttrs implements environs.EnvironProvider.SecretAttrs.
@@ -63,3 +139,11 @@
 func (environProvider) InstanceId() (instance.Id, error) {
 	return "", fmt.Errorf("not implemented")
 }
+
+func (environProvider) newConfig(cfg *config.Config) (*environConfig, error) {
+	valid, err := provider.Validate(cfg, nil)
+	if err != nil {
+		return nil, err
+	}
+	return newEnvironConfig(valid, valid.UnknownAttrs()), nil
+}

=== added file 'environs/local/environprovider_test.go'
--- environs/local/environprovider_test.go	1970-01-01 00:00:00 +0000
+++ environs/local/environprovider_test.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,35 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package local_test
+
+import (
+	"path/filepath"
+
+	gc "launchpad.net/gocheck"
+	"launchpad.net/loggo"
+
+	"launchpad.net/juju-core/environs/local"
+	"launchpad.net/juju-core/testing"
+)
+
+type baseProviderSuite struct {
+	testing.LoggingSuite
+	public     string
+	private    string
+	oldPublic  string
+	oldPrivate string
+}
+
+func (s *baseProviderSuite) SetUpTest(c *gc.C) {
+	s.LoggingSuite.SetUpTest(c)
+	loggo.GetLogger("juju.environs.local").SetLogLevel(loggo.TRACE)
+	s.public = filepath.Join(c.MkDir(), "%s", "public")
+	s.private = filepath.Join(c.MkDir(), "%s", "private")
+	s.oldPublic, s.oldPrivate = local.SetDefaultStorageDirs(s.public, s.private)
+}
+
+func (s *baseProviderSuite) TearDownTest(c *gc.C) {
+	local.SetDefaultStorageDirs(s.oldPublic, s.oldPrivate)
+	s.LoggingSuite.TearDownTest(c)
+}

=== modified file 'environs/local/export_test.go'
--- environs/local/export_test.go	2013-06-30 22:58:37 +0000
+++ environs/local/export_test.go	2013-07-02 04:37:23 +0000
@@ -4,3 +4,9 @@
 package local
 
 var Provider = provider
+
+func SetDefaultStorageDirs(public, private string) (oldPublic, oldPrivate string) {
+	oldPublic, defaultPublicStorageDir = defaultPublicStorageDir, public
+	oldPrivate, defaultPrivateStorageDir = defaultPrivateStorageDir, private
+	return
+}

=== modified file 'environs/local/local_test.go'
--- environs/local/local_test.go	2013-06-30 22:58:37 +0000
+++ environs/local/local_test.go	2013-07-02 04:37:23 +0000
@@ -7,6 +7,7 @@
 	stdtesting "testing"
 
 	. "launchpad.net/gocheck"
+
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/local"
 	"launchpad.net/juju-core/testing"

=== added file 'utils/file.go'
--- utils/file.go	1970-01-01 00:00:00 +0000
+++ utils/file.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,19 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package utils
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// NormalizePath replaces a leading ~ with $HOME, and removes any .. or . path
+// elements.
+func NormalizePath(dir string) string {
+	if strings.HasPrefix(dir, "~/") {
+		dir = filepath.Join(os.Getenv("HOME"), dir[2:])
+	}
+	return filepath.Clean(dir)
+}

=== added file 'utils/file_test.go'
--- utils/file_test.go	1970-01-01 00:00:00 +0000
+++ utils/file_test.go	2013-07-02 04:37:23 +0000
@@ -0,0 +1,49 @@
+// Copyright 2013 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package utils_test
+
+import (
+	"os"
+
+	gc "launchpad.net/gocheck"
+	"launchpad.net/juju-core/utils"
+)
+
+type fileSuite struct {
+	oldHome string
+}
+
+var _ = gc.Suite(&fileSuite{})
+
+func (s *fileSuite) SetUpTest(c *gc.C) {
+	s.oldHome = os.Getenv("HOME")
+	err := os.Setenv("HOME", "/home/test-user")
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *fileSuite) TearDownTest(c *gc.C) {
+	err := os.Setenv("HOME", s.oldHome)
+	c.Assert(err, gc.IsNil)
+}
+
+func (*fileSuite) TestNormalizePath(c *gc.C) {
+	for _, test := range []struct {
+		path     string
+		expected string
+	}{{
+		path:     "/var/lib/juju",
+		expected: "/var/lib/juju",
+	}, {
+		path:     "~/foo",
+		expected: "/home/test-user/foo",
+	}, {
+		path:     "~/foo//../bar",
+		expected: "/home/test-user/bar",
+	}, {
+		path:     "~bob/foo",
+		expected: "~bob/foo",
+	}} {
+		c.Assert(utils.NormalizePath(test.path), gc.Equals, test.expected)
+	}
+}