provider/local: always use filestorage on CLI

provider/local/environprovider.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package local
 
 import (
         "fmt"
         "net"
         "os"
+        "os/user"
         "syscall"
 
         "github.com/loggo/loggo"
 
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/juju/osenv"
         "launchpad.net/juju-core/provider"
         "launchpad.net/juju-core/utils"
         "launchpad.net/juju-core/version"
 )
 
 var logger = loggo.GetLogger("juju.provider.local")
 
 var _ environs.EnvironProvider = (*environProvider)(nil)
 
 type environProvider struct{}
 
 var providerInstance = &environProvider{}
 
 func init() {
         environs.RegisterProvider(provider.Local, providerInstance)
 }
 
+var userCurrent = user.Current
+
 // Open implements environs.EnvironProvider.Open.
 func (environProvider) Open(cfg *config.Config) (environs.Environ, error) {
         logger.Infof("opening environment %q", cfg.Name())
         if _, ok := cfg.AgentVersion(); !ok {
                 newCfg, err := cfg.Apply(map[string]interface{}{
                         "agent-version": version.Current.Number.String(),
                 })
                 if err != nil {
                         return nil, err
                 }
@@ skipping 20 matching lines @@
                 return nil, err
         }
         environ := &localEnviron{name: cfg.Name()}
         if err := environ.SetConfig(cfg); err != nil {
                 logger.Errorf("failure setting config: %v", err)
                 return nil, err
         }
         return environ, nil
 }
 
+var detectAptProxies = utils.DetectAptProxies
+
 // Prepare implements environs.EnvironProvider.Prepare.
 func (p environProvider) Prepare(cfg *config.Config) (environs.Environ, error) {
+        // The user must not set bootstrap-ip; this is determined by the provider,
+        // and its presence used to determine whether the environment has yet been
+        // bootstrapped.
+        if _, ok := cfg.UnknownAttrs()["bootstrap-ip"]; ok {
+                return nil, fmt.Errorf("bootstrap-ip must not be specified")
+        }
         err := checkLocalPort(cfg.StatePort(), "state port")
         if err != nil {
                 return nil, err
         }
         err = checkLocalPort(cfg.APIPort(), "API port")
         if err != nil {
                 return nil, err
         }
         // If the user has specified no values for any of the three normal
         // proxies, then look in the environment and set them.
         attrs := make(map[string]interface{})
         setIfNotBlank := func(key, value string) {
                 if value != "" {
                         attrs[key] = value
                 }
         }
         logger.Tracef("Look for proxies?")
         if cfg.HttpProxy() == "" &&
                 cfg.HttpsProxy() == "" &&
                 cfg.FtpProxy() == "" {
                 proxy := osenv.DetectProxies()
                 logger.Tracef("Proxies detected %#v", proxy)
                 setIfNotBlank("http-proxy", proxy.Http)
                 setIfNotBlank("https-proxy", proxy.Https)
                 setIfNotBlank("ftp-proxy", proxy.Ftp)
         }
         if cfg.AptHttpProxy() == "" &&
                 cfg.AptHttpsProxy() == "" &&
                 cfg.AptFtpProxy() == "" {
-                proxy, err := utils.DetectAptProxies()
+                proxy, err := detectAptProxies()
                 if err != nil {
                         return nil, err
                 }
                 setIfNotBlank("apt-http-proxy", proxy.Http)
                 setIfNotBlank("apt-https-proxy", proxy.Https)
                 setIfNotBlank("apt-ftp-proxy", proxy.Ftp)
         }
         if len(attrs) > 0 {
                 cfg, err = cfg.Apply(attrs)
                 if err != nil {
                         return nil, err
                 }
         }
 
         return p.Open(cfg)
 }
 
 // checkLocalPort checks that the passed port is not used so far.
-func checkLocalPort(port int, description string) error {
+var checkLocalPort = func(port int, description string) error {
         logger.Infof("checking %s", description)
         // Try to connect the port on localhost.
         address := fmt.Sprintf("localhost:%d", port)
         // TODO(mue) Add a timeout?
         conn, err := net.Dial("tcp", address)
         if err != nil {
                 if nerr, ok := err.(*net.OpError); ok {
                         if nerr.Err == syscall.ECONNREFUSED {
                                 // No connection, so everything is fine.
                                 return nil
@@ skipping 120 matching lines @@
         return getAddressForInterface("eth0")
 }
 
 func (p environProvider) newConfig(cfg *config.Config) (*environConfig, error) {
         valid, err := p.Validate(cfg, nil)
         if err != nil {
                 return nil, err
         }
         return newEnvironConfig(valid, valid.UnknownAttrs()), nil
 }