environs: add configuration attributes and access

environs/ec2/config.go

 package ec2
 
 import (
         "fmt"
         "launchpad.net/goamz/aws"
         "launchpad.net/juju-core/environs"
+        "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/schema"
 )
 
 // providerConfig is a placeholder for any config information
 // that we will have in a configuration file.
 type providerConfig struct {
-        name           string
+        *config.Config
         region         string
         auth           aws.Auth
         bucket         string
         publicBucket   string
         authorizedKeys string
+        defaultSeries  string
 }
 
 var configChecker = schema.StrictFieldMap(
         schema.Fields{
-                "name":                 schema.String(),
-                "type":                 schema.Const("ec2"),
                 "access-key":           schema.String(),
                 "secret-key":           schema.String(),
                 "region":               schema.String(),
                 "control-bucket":       schema.String(),
                 "public-bucket":        schema.String(),
                 "authorized-keys":      schema.String(),
                 "authorized-keys-path": schema.String(),
+                "default-series":       schema.String(),
         }, []string{
                 "access-key",
                 "secret-key",
                 "region",
                 "authorized-keys",
                 "authorized-keys-path",
                 "public-bucket",
+                "default-series",
         },
 )
 
-func (p environProvider) NewConfig(config map[string]interface{}) (cfg environs.EnvironConfig, err error) {
-        v, err := configChecker.Coerce(config, nil)
+func (p environProvider) NewConfig(attrs map[string]interface{}) (environs.EnvironConfig, error) {
+        ccfg, attrs, err := config.New(attrs)
+        if err != nil {
+                return nil, err
+        }
+        return p.newConfig(ccfg, attrs)
+}
+
+func (p environProvider) newConfig(ccfg *config.Config, attrs map[string]interface{}) (cfg environs.EnvironConfig, err error) {
+        if ccfg.Type() != "ec2" {
+                return nil, fmt.Errorf("unexpected environment type %q", ccfg.Type())
+        }
+        v, err := configChecker.Coerce(attrs, nil)
         if err != nil {
                 return nil, err
         }
         m := v.(schema.MapType)
         var c providerConfig
 
-        c.name = m["name"].(string)
+        c.Config = ccfg
         c.bucket = m["control-bucket"].(string)
         c.publicBucket = maybeString(m["public-bucket"], "")
         c.auth.AccessKey = maybeString(m["access-key"], "")
         c.auth.SecretKey = maybeString(m["secret-key"], "")
         if c.auth.AccessKey == "" || c.auth.SecretKey == "" {
                 if c.auth.AccessKey != "" {
                         return nil, fmt.Errorf("environment has access-key but no secret-key")
                 }
                 if c.auth.SecretKey != "" {
                         return nil, fmt.Errorf("environment has secret-key but no access-key")
                 }
                 c.auth, err = aws.EnvAuth()
                 if err != nil {
                         return
                 }
         }
 
         regionName := maybeString(m["region"], "us-east-1")
         if _, ok := aws.Regions[regionName]; !ok {
                 return nil, fmt.Errorf("invalid region name %q", regionName)
         }
+        c.defaultSeries = maybeString(m["default-series"], environs.CurrentSeries)
         c.region = regionName
-        c.authorizedKeys = maybeString(m["authorized-keys"], "")
-        authorizedKeysPath := maybeString(m["authorized-keys-path"], "")
-        if c.authorizedKeys == "" {
-                c.authorizedKeys, err = authorizedKeys(authorizedKeysPath)
-                if err != nil {
-                        return nil, err
-                }
-        } else if authorizedKeysPath != "" {
-                return nil, fmt.Errorf("environment has both authorized-keys and authorized-keys-path")
+        return &c, nil
+}
+
+func (cfg *providerConfig) Clone() environs.EnvironConfig {
+        newCfg := *cfg
+        newCfg.Config = newCfg.Config.Clone()
+        return &newCfg
+}
+
+func (cfg *providerConfig) DefaultSeries() string {
+        return cfg.defaultSeries
+}
+
+func (cfg *providerConfig) Change(attrs map[string]interface{}) error {
+        ccfg := cfg.Config.Clone()
+        attrs, err := ccfg.Change(attrs)
+        if err != nil {
+                return err
         }
-        return &c, nil
+        newAttrs := cfg.localAttrs()
+        for k, v := range attrs {
+                newAttrs[k] = v
+        }
+        newCfg0, err := environProvider{}.newConfig(ccfg, newAttrs)
+        if err != nil {
+                return err
+        }
+        newCfg := newCfg0.(*providerConfig)
+        if newCfg.region != cfg.region {
+                return fmt.Errorf("cannot change region config field")
+        }
+        *cfg = *newCfg
+        return nil
+}
+
+// attrs returned locally defined attributes only.
+func (cfg *providerConfig) localAttrs() map[string]interface{} {
+        return map[string]interface{}{
+                "access-key":      cfg.auth.AccessKey,
+                "secret-key":      cfg.auth.SecretKey,
+                "region":          cfg.region,
+                "authorized-keys": cfg.authorizedKeys,
+                "control-bucket":  cfg.bucket,
+                "public-bucket":   cfg.publicBucket,
+                "default-series":  cfg.defaultSeries,
+        }
+}
+
+func (cfg *providerConfig) Attrs() map[string]interface{} {
+        attrs := cfg.localAttrs()
+        for k, v := range cfg.Config.Attrs() {
+                attrs[k] = v
+        }
+        return attrs
 }
 
 func maybeString(x interface{}, dflt string) string {
         if x == nil {
                 return dflt
         }
         return x.(string)
 }