environs: store bootstrap config in info

juju/apiconn_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package juju_test
 
 import (
         "fmt"
+        "os"
         "time"
 
         gc "launchpad.net/gocheck"
 
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/bootstrap"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/environs/configstore"
         envtesting "launchpad.net/juju-core/environs/testing"
-        "launchpad.net/juju-core/errors"
         "launchpad.net/juju-core/juju"
         "launchpad.net/juju-core/provider/dummy"
         "launchpad.net/juju-core/state/api"
         coretesting "launchpad.net/juju-core/testing"
         jc "launchpad.net/juju-core/testing/checkers"
         "launchpad.net/juju-core/testing/testbase"
 )
 
 type NewAPIConnSuite struct {
         testbase.LoggingSuite
@@ skipping 42 matching lines @@
 }
 
 func (*NewAPIClientSuite) TestNameDefault(c *gc.C) {
         defer coretesting.MakeMultipleEnvHome(c).Restore()
         // The connection logic should not delay the config connection
         // at all when there is no environment info available.
         // Make sure of that by providing a suitably long delay
         // and checking that the connection happens within that
         // time.
         defer testbase.PatchValue(juju.ProviderConnectDelay, coretesting.LongWait).Restore()
-        bootstrapEnv(c, coretesting.SampleEnvName)
+        bootstrapEnv(c, coretesting.SampleEnvName, nil)
 
         startTime := time.Now()
         apiclient, err := juju.NewAPIClientFromName("")
         c.Assert(err, gc.IsNil)
         defer apiclient.Close()
         c.Assert(time.Since(startTime), jc.LessThan, coretesting.LongWait)
 
         // We should get the default sample environment if we ask for ""
         assertEnvironmentName(c, apiclient, coretesting.SampleEnvName)
 }
 
 func (*NewAPIClientSuite) TestNameNotDefault(c *gc.C) {
         defer coretesting.MakeMultipleEnvHome(c).Restore()
-        // The default environment is "erewhemos", make sure we get the other one.
-        const envName = "erewhemos-2"
-        bootstrapEnv(c, envName)
+        envName := coretesting.SampleCertName + "-2"
+        bootstrapEnv(c, envName, nil)
         apiclient, err := juju.NewAPIClientFromName(envName)
         c.Assert(err, gc.IsNil)
         defer apiclient.Close()
         assertEnvironmentName(c, apiclient, envName)
 }
 
 func (*NewAPIClientSuite) TestWithInfoOnly(c *gc.C) {
         defer coretesting.MakeEmptyFakeHome(c).Restore()
-        creds := configstore.APICredentials{
-                User:     "foo",
-                Password: "foopass",
-        }
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{"foo.com"},
-                CACert:    "certificated",
-        }
         store := newConfigStore("noconfig", &environInfo{
-                creds:    creds,
-                endpoint: endpoint,
+                creds: configstore.APICredentials{
+                        User:     "foo",
+                        Password: "foopass",
+                },
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{"foo.com"},
+                        CACert:    "certificated",
+                },
         })
 
         called := 0
         expectState := new(api.State)
         apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
                 c.Check(apiInfo.Tag, gc.Equals, "user-foo")
                 c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
                 c.Check(apiInfo.Tag, gc.Equals, "user-foo")
                 c.Check(apiInfo.Password, gc.Equals, "foopass")
                 c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
                 called++
                 return expectState, nil
         }
         defer testbase.PatchValue(juju.APIOpen, apiOpen).Restore()
         st, err := juju.NewAPIFromName("noconfig", store)
         c.Assert(err, gc.IsNil)
         c.Assert(st, gc.Equals, expectState)
         c.Assert(called, gc.Equals, 1)
 }
 
 func (*NewAPIClientSuite) TestWithInfoError(c *gc.C) {
         defer coretesting.MakeEmptyFakeHome(c).Restore()
         expectErr := fmt.Errorf("an error")
-        store := newConfigStore("noconfig", &environInfo{
-                err: expectErr,
-        })
+        store := newConfigStoreWithError(expectErr)
         defer testbase.PatchValue(juju.APIOpen, panicAPIOpen).Restore()
         client, err := juju.NewAPIFromName("noconfig", store)
         c.Assert(err, gc.Equals, expectErr)
         c.Assert(client, gc.IsNil)
 }
 
 func panicAPIOpen(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
         panic("api.Open called unexpectedly")
 }
 
 func (*NewAPIClientSuite) TestWithInfoNoAddresses(c *gc.C) {
         defer coretesting.MakeEmptyFakeHome(c).Restore()
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{},
-                CACert:    "certificated",
-        }
         store := newConfigStore("noconfig", &environInfo{
-                endpoint: endpoint,
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{},
+                        CACert:    "certificated",
+                },
         })
         defer testbase.PatchValue(juju.APIOpen, panicAPIOpen).Restore()
 
         st, err := juju.NewAPIFromName("noconfig", store)
         c.Assert(err, gc.ErrorMatches, `environment "noconfig" not found`)
         c.Assert(st, gc.IsNil)
 }
 
 func (*NewAPIClientSuite) TestWithInfoAPIOpenError(c *gc.C) {
         defer coretesting.MakeEmptyFakeHome(c).Restore()
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{"foo.com"},
-        }
         store := newConfigStore("noconfig", &environInfo{
-                endpoint: endpoint,
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{"foo.com"},
+                },
         })
 
         expectErr := fmt.Errorf("an error")
         apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (*api.State, error) {
                 return nil, expectErr
         }
         defer testbase.PatchValue(juju.APIOpen, apiOpen).Restore()
         st, err := juju.NewAPIFromName("noconfig", store)
         c.Assert(err, gc.Equals, expectErr)
         c.Assert(st, gc.IsNil)
 }
 
 func (*NewAPIClientSuite) TestWithSlowInfoConnect(c *gc.C) {
         defer coretesting.MakeSampleHome(c).Restore()
-        bootstrapEnv(c, coretesting.SampleEnvName)
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{"infoapi.com"},
-        }
+        bootstrapEnv(c, coretesting.SampleEnvName, nil)
         store := newConfigStore(coretesting.SampleEnvName, &environInfo{
-                endpoint: endpoint,
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{"infoapi.com"},
+                },
         })
 
         infoOpenedState := new(api.State)
         infoEndpointOpened := make(chan struct{})
         cfgOpenedState := new(api.State)
         // On a sample run with no delay, the logic took 45ms to run, so
         // we make the delay slightly more than that, so that if the
         // logic doesn't delay at all, the test will fail reasonably consistently.
         defer testbase.PatchValue(juju.ProviderConnectDelay, 50*time.Millisecond).Restore()
         apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
@@ skipping 26 matching lines @@
         select {
         case st := <-stateClosed:
                 c.Assert(st, gc.Equals, infoOpenedState)
         case <-time.After(coretesting.LongWait):
                 c.Errorf("timed out waiting for state to be closed")
         }
 }
 
 func (*NewAPIClientSuite) TestWithSlowConfigConnect(c *gc.C) {
         defer coretesting.MakeSampleHome(c).Restore()
-        bootstrapEnv(c, coretesting.SampleEnvName)
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{"infoapi.com"},
-        }
+        bootstrapEnv(c, coretesting.SampleEnvName, nil)
         store := newConfigStore(coretesting.SampleEnvName, &environInfo{
-                endpoint: endpoint,
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{"infoapi.com"},
+                },
         })
 
         infoOpenedState := new(api.State)
         infoEndpointOpened := make(chan struct{})
         cfgOpenedState := new(api.State)
         cfgEndpointOpened := make(chan struct{})
 
         defer testbase.PatchValue(juju.ProviderConnectDelay, 0*time.Second).Restore()
         apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
                 if info.Addrs[0] == "infoapi.com" {
@@ skipping 44 matching lines @@
         select {
         case st := <-stateClosed:
                 c.Assert(st, gc.Equals, cfgOpenedState)
         case <-time.After(coretesting.LongWait):
                 c.Errorf("timed out waiting for state to be closed")
         }
 }
 
 func (*NewAPIClientSuite) TestBothErrror(c *gc.C) {
         defer coretesting.MakeSampleHome(c).Restore()
-        bootstrapEnv(c, coretesting.SampleEnvName)
-        endpoint := configstore.APIEndpoint{
-                Addresses: []string{"infoapi.com"},
-        }
+        bootstrapEnv(c, coretesting.SampleEnvName, nil)
         store := newConfigStore(coretesting.SampleEnvName, &environInfo{
-                endpoint: endpoint,
+                endpoint: configstore.APIEndpoint{
+                        Addresses: []string{"infoapi.com"},
+                },
         })
 
         defer testbase.PatchValue(juju.ProviderConnectDelay, 0*time.Second).Restore()
         apiOpen := func(info *api.Info, opts api.DialOpts) (*api.State, error) {
                 if info.Addrs[0] == "infoapi.com" {
                         return nil, fmt.Errorf("info connect failed")
                 }
                 return nil, fmt.Errorf("config connect failed")
         }
         defer testbase.PatchValue(juju.APIOpen, apiOpen).Restore()
         st, err := juju.NewAPIFromName(coretesting.SampleEnvName, store)
         c.Check(err, gc.ErrorMatches, "config connect failed")
         c.Check(st, gc.IsNil)
 }
 
 // TODO(jam): 2013-08-27 This should move somewhere in api.*
 func (*NewAPIClientSuite) TestMultipleCloseOk(c *gc.C) {
         defer coretesting.MakeSampleHome(c).Restore()
-        bootstrapEnv(c, "")
+        bootstrapEnv(c, "", nil)
         client, _ := juju.NewAPIClientFromName("")
         c.Assert(client.Close(), gc.IsNil)
         c.Assert(client.Close(), gc.IsNil)
         c.Assert(client.Close(), gc.IsNil)
+}
+
+func (*NewAPIClientSuite) TestWithBootstrapConfigAndNoEnvironmentsFile(c *gc.C) {
+        defer coretesting.MakeSampleHome(c).Restore()
+        store := configstore.NewMem()
+        bootstrapEnv(c, coretesting.SampleEnvName, store)
+        info, err := store.ReadInfo(coretesting.SampleEnvName)
+        c.Assert(err, gc.IsNil)
+        c.Assert(info.BootstrapConfig(), gc.NotNil)
+        c.Assert(info.APIEndpoint().Addresses, gc.HasLen, 0)
+
+        err = os.Remove(config.JujuHomePath("environments.yaml"))
+        c.Assert(err, gc.IsNil)
+
+        st, err := juju.NewAPIFromName(coretesting.SampleEnvName, store)
+        c.Check(err, gc.IsNil)
+        st.Close()
+}
+
+func (*NewAPIClientSuite) TestWithBootstrapConfigTakesPrecedence(c *gc.C) {
+        // We want to make sure that the code is using the bootstrap
+        // config rather than information from environments.yaml,
+        // even when there is an entry in environments.yaml
+        // We can do that by changing the info bootstrap config
+        // so it has a different environment name.
+        defer coretesting.MakeMultipleEnvHome(c).Restore()
+
+        store := configstore.NewMem()
+        bootstrapEnv(c, coretesting.SampleEnvName, store)
+        info, err := store.ReadInfo(coretesting.SampleEnvName)
+        c.Assert(err, gc.IsNil)
+
+        envName2 := coretesting.SampleCertName + "-2"
+        info2, err := store.CreateInfo(envName2)
+        c.Assert(err, gc.IsNil)
+        info2.SetBootstrapConfig(info.BootstrapConfig())
+        err = info2.Write()
+        c.Assert(err, gc.IsNil)
+
+        // Now we have info for envName2 which will actually
+        // cause a connection to the originally bootstrapped
+        // state.
+        st, err := juju.NewAPIFromName(envName2, store)
+        c.Check(err, gc.IsNil)
+        st.Close()
+
+        // Sanity check that connecting to the envName2
+        // but with no info fails.
+        // Currently this panics with an "environment not prepared" error.
+        // Disable for now until an upcoming branch fixes it.
+        //      err = info2.Destroy()
+        //      c.Assert(err, gc.IsNil)
+        //      st, err = juju.NewAPIFromName(envName2, store)
+        //      if err == nil {
+        //              st.Close()
+        //      }
+        //      c.Assert(err, gc.ErrorMatches, "fooobie")
 }
 
 func assertEnvironmentName(c *gc.C, client *api.Client, expectName string) {
         envInfo, err := client.EnvironmentInfo()
         c.Assert(err, gc.IsNil)
         c.Assert(envInfo.Name, gc.Equals, expectName)
 }
 
 func setAPIClosed() (<-chan *api.State, testbase.Restorer) {
         stateClosed := make(chan *api.State)
         apiClose := func(st *api.State) error {
                 stateClosed <- st
                 return nil
         }
         return stateClosed, testbase.PatchValue(juju.APIClose, apiClose)
 }
 
+// newConfigStoreWithError that will return the given
+// error from ReadInfo.
+func newConfigStoreWithError(err error) configstore.Storage {
+        return &errorConfigStorage{
+                Storage: configstore.NewMem(),
+                err:     err,
+        }
+}
+
+type errorConfigStorage struct {
+        configstore.Storage
+        err error
+}
+
+func (store *errorConfigStorage) ReadInfo(envName string) (configstore.EnvironInfo, error) {
+        return nil, store.err
+}
+
+type environInfo struct {
+        creds           configstore.APICredentials
+        endpoint        configstore.APIEndpoint
+        bootstrapConfig map[string]interface{}
+}
+
+// newConfigStore returns a storage that contains information
+// for the environment name.
 func newConfigStore(envName string, info *environInfo) configstore.Storage {
-        return &configStorage{
-                envs: map[string]*environInfo{
-                        envName: info,
-                },
-        }
-}
-
-type environInfo struct {
-        configstore.EnvironInfo // panic on methods we don't care about
-        creds                   configstore.APICredentials
-        endpoint                configstore.APIEndpoint
-        bootstrapConfig         map[string]interface{}
-        err                     error
-}
-
-type configStorage struct {
-        configstore.Storage // panic on methods we don't care about
-        envs                map[string]*environInfo
-}
-
-func (store *configStorage) ReadInfo(envName string) (configstore.EnvironInfo, error) {
-        info := store.envs[envName]
-        if info == nil {
-                return nil, errors.NotFoundf("info on environment %q", envName)
-        }
-        if info.err != nil {
-                return nil, info.err
-        }
-        return info, nil
-}
-
-func (info *environInfo) APICredentials() configstore.APICredentials {
-        return info.creds
-}
-
-func (info *environInfo) APIEndpoint() configstore.APIEndpoint {
-        return info.endpoint
-}
-
-func (info *environInfo) BootstrapConfig() map[string]interface{} {
-        return info.bootstrapConfig
-}
+        store := configstore.NewMem()
+        newInfo, err := store.CreateInfo(envName)
+        if err != nil {
+                panic(err)
+        }
+        newInfo.SetAPICredentials(info.creds)
+        newInfo.SetAPIEndpoint(info.endpoint)
+        newInfo.SetBootstrapConfig(info.bootstrapConfig)
+        err = newInfo.Write()
+        if err != nil {
+                panic(err)
+        }
+        return store
+}