environs: add NewEnviron(kind, config)

environs/open.go

 package environs
 
 import "fmt"
 
-// New creates a new Environ using the
-// environment configuration with the given name.
-// If name is empty, the default environment will be used.
+// Open creates a new Environ using the environment configuration with the 
+// given name. If name is empty, the default environment will be used.
 func (envs *Environs) Open(name string) (Environ, error) {
         if name == "" {
                 name = envs.Default
                 if name == "" {
                         return nil, fmt.Errorf("no default environment found")
                 }
         }
         e, ok := envs.environs[name]
         if !ok {
                 return nil, fmt.Errorf("unknown environment %q", name)
         }
         if e.err != nil {
                 return nil, e.err
         }
         env, err := providers[e.kind].Open(name, e.config)
         if err != nil {
                 return nil, fmt.Errorf("cannot initialize environment %q: %v", name, err)
         }
 
         return env, nil
 }
+
+// NewEnviron creates a new Environ of the registered kind using the configuration
+// supplied.
+func NewEnviron(kind string, config map[string]interface{}) (Environ, error) {
+        p, ok := providers[kind]
+        if !ok {
+                return nil, fmt.Errorf("no registered provider for kind: %q", kind)
+        }
+        cfg, err := p.Check(config)

[rog, 2012/05/15 08:59:30]

If Environs.Check must always accept a map[string]interface{}, then the method
signature should specify that. However, my original idea, which I still think
could work ok, was to have Check take a Getter:

type Getter interface {
    Get(key string) (value interface{}, found bool)
}

then we can pass a *ConfigNode directly to NewEnviron and thence to p.Check.

To save config settings, we'd define a Setter interface:

type Setter interface {
    Set(key string, value interface{})
}

and define a new method (Environ.Write? Environ.Save?) which would use a Setter
to write out all its values.

[niemeyer, 2012/05/15 21:03:14]

I like part of your idea, but this specific bit doesn't seem to fit well with
the rest of it. The blob that goes through the coercion is an arbitrarily typed
map. It feels strange to have *that* map within a Getter. I suggest we keep the
logic of the coercion in interface with ConfigChecker, and have a function like
this within environs:

func CoerceConfig(e EnvironProvider, attrs interface{}) (config Getter, err
error)

This may be used both when parsing environments.yaml, and when parsing the
/environment node within ZooKeeper.

The EnvironProvider then becomes:

    func ConfigChecker() schema.Checker
    func Open(config Getter) (Environ, error)
+1 on Save. Write is generally associated with []byte or io.Writer.

[dfc, 2012/05/15 23:16:01]

It won't work, environProvider.Check() expects a map. It's not a big problem to
call .Map on the *ConfigNode.
 

+        if err != nil {
+                return nil, fmt.Errorf("error validating environment: %v", err)
+        }
+        // TODO(dfc) remove the requirement for an environment to know it's name, it's
+        // type should be sufficient.
+        return p.Open("default", cfg)
+}