environs: turn environment configuration into a concrete type

environs/dummy/environs.go

 // The dummy provider implements an environment provider for testing
 // purposes, registered with environs under the name "dummy".
 //·
 // The configuration YAML for the testing environment
 // must specify a "zookeeper" property with a boolean
 // value. If this is true, a zookeeper instance will be started
 // the first time StateInfo is called on a newly reset environment.
 // NOTE: ZooKeeper isn't actually being started yet.
 //·
 // The configuration data also accepts a "broken" property
 // of type boolean. If this is non-empty, any operation
 // after the environment has been opened will return
 // the error "broken environment", and will also log that.
 //·
 // The DNS name of instances is the same as the Id,
 // with ".dns" appended.
 package dummy
 
 import (
         "errors"
         "fmt"
         "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/testing"
         "net"
         "net/http"
         "sync"
 )
 
 // stateInfo returns a *state.Info which allows clients to connect to the
@@ skipping 82 matching lines @@
 // storage holds the storage for an environState.
 // There are two instances for each environState
 // instance, one for public files and one for private.
 type storage struct {
         path  string // path prefix in http space.
         state *environState
         files map[string][]byte
 }
 
 type environConfig struct {
-        provider  *environProvider
-        name      string
+        *config.Config
         zookeeper bool
         broken    bool

[fwereade, 2012/07/17 07:19:06]

My instinct warns me against the duplication here, but it seems to work out
rather well. Nice :).

[niemeyer, 2012/07/17 12:10:30]

I'm actually hoping to improve it further in the coming CL, but I'm trying to
get agreement on the basics first.

 }
 
 var providerInstance environProvider
 
 // discardOperations discards all Operations written to it.
 var discardOperations chan<- Operation
 
 func init() {
         environs.RegisterProvider("dummy", &providerInstance)
 
@@ skipping 69 matching lines @@
                 c = discardOperations
         }
         if p.ops != discardOperations {
                 close(p.ops)
         }
         p.ops = c
 }
 
 var checker = schema.StrictFieldMap(
         schema.Fields{
-                "type":      schema.Const("dummy"),
                 "zookeeper": schema.Bool(),
                 "broken":    schema.Bool(),
-                "name":      schema.String(),
         },
         []string{
                 "broken",
         },
 )
 
-func (p *environProvider) NewConfig(attrs map[string]interface{}) (environs.EnvironConfig, error) {
-        m0, err := checker.Coerce(attrs, nil)
+func newConfig(cfg *config.Config) (*environConfig, error) {
+        m0, err := checker.Coerce(cfg.TypeMap(), nil)
         if err != nil {
                 return nil, err
         }
         m1 := m0.(schema.MapType)
-        cfg := &environConfig{
-                provider:  p,
-                name:      m1["name"].(string),
+        ecfg := &environConfig{
+                Config:    cfg,
                 zookeeper: m1["zookeeper"].(bool),
         }
-        cfg.broken, _ = m1["broken"].(bool)
-        return cfg, nil
+        ecfg.broken, _ = m1["broken"].(bool)
+        return ecfg, nil
 }
 
-func (cfg *environConfig) Open() (environs.Environ, error) {
-        p := cfg.provider
+func (p *environProvider) Open(cfg *config.Config) (environs.Environ, error) {
         p.mu.Lock()
         defer p.mu.Unlock()
-        state := p.state[cfg.name]
+        name := cfg.Name()
+        ecfg, err := newConfig(cfg)
+        if err != nil {
+                return nil, err
+        }
+        state := p.state[name]
         if state == nil {
-                if cfg.zookeeper && len(p.state) != 0 {
+                if ecfg.zookeeper && len(p.state) != 0 {
                         panic("cannot share a zookeeper between two dummy environs")
                 }
-                state = newState(cfg.name, p.ops)
-                p.state[cfg.name] = state
+                state = newState(name, p.ops)
+                p.state[name] = state
         }
         env := &environ{
-                state: state,
+                state:  state,
+                config: ecfg,
         }
-        env.SetConfig(cfg)
         return env, nil
 }
 
 var errBroken = errors.New("broken environment")
 
 func (e *environ) Name() string {
         return e.state.name
 }
 
 func (e *environ) Bootstrap(uploadTools bool) error {
@@ skipping 11 matching lines @@
         e.state.ops <- OpBootstrap{Env: e.state.name}
         if e.state.bootstrapped {
                 return fmt.Errorf("environment is already bootstrapped")
         }
         if e.config.zookeeper {
                 info := stateInfo()
                 st, err := state.Initialize(info)
                 if err != nil {
                         panic(err)
                 }
                 cfg, err := st.EnvironConfig()

[rog, 2012/07/17 12:55:07]

isn't EnvironConfig supposed to return a *config.Config?

[niemeyer, 2012/07/17 13:16:25]

Please see the message on juju-dev regarding follow up steps.

                 if err != nil {
                         panic(err)
                 }
                 cfg.Set("type", "dummy")
                 cfg.Set("zookeeper", true)
-                cfg.Set("name", e.config.name)
+                cfg.Set("name", e.config.Name())
                 _, err = cfg.Write()
                 if err != nil {
                         panic(err)
                 }
                 err = st.Close()
                 if err != nil {
                         panic(err)
                 }
         }
         e.state.bootstrapped = true
@@ skipping 10 matching lines @@
         if !e.state.bootstrapped {
                 return nil, errors.New("dummy environment not bootstrapped")
         }
         return stateInfo(), nil
 }
 
 func (e *environ) AssignmentPolicy() state.AssignmentPolicy {
         return state.AssignUnused
 }
 
-func (e *environ) SetConfig(cfg environs.EnvironConfig) {
-        config := cfg.(*environConfig)
+func (e *environ) SetConfig(cfg *config.Config) error {
+        config, err := newConfig(cfg)
+        if err != nil {
+                return err
+        }
         e.configMutex.Lock()
         defer e.configMutex.Unlock()
         e.config = config
+        return nil
 }
 
 func (e *environ) Destroy([]environs.Instance) error {
         if e.isBroken() {
                 return errBroken
         }
         e.state.mu.Lock()
         defer e.state.mu.Unlock()
         e.state.ops <- OpDestroy{Env: e.state.name}
         if testing.ZkAddr != "" {
@@ skipping 146 matching lines @@
         if inst.machineId != machineId {
                 panic(fmt.Errorf("Ports with mismatched machine id, expected %d got %d", inst.machineId, machineId))
         }
         inst.state.mu.Lock()
         defer inst.state.mu.Unlock()
         for p := range inst.ports {
                 ports = append(ports, p)
         }
         return
 }