map-backed Config type

environs/ec2/provider.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
-        region         string
-        auth           aws.Auth
-        bucket         string
-        publicBucket   string
-        authorizedKeys string
+type environProvider struct{}
+
+func init() {
+        environs.RegisterProvider("ec2", environProvider{})
 }
 
-var configChecker = schema.StrictFieldMap(
+func (p environProvider) New(cfg *config.Config) (environs.Environ, error) {
+        env := &environ{}
+        if err := env.SetConfig(cfg); err != nil {
+                return nil, err
+        }
+        return env, nil
+}
+
+func (environProvider) ComposeConfig(base *config.Config, changes map[string]interface{}) (new *config.Config, err error) {
+        // Create a fresh map.
+        final := map[string]interface{}{}
+        for k, v := range changes {
+                final[k] = v
+        }
+
+        // Insert missing settings from base, if available.
+        if base != nil {
+                m := base.Map()
+                baseRegion := m["region"].(string)
+                if region, ok := final["region"].(string); !ok {
+                        final["region"] = baseRegion
+                } else if region != baseRegion {
+                        return nil, fmt.Errorf("mismatched regions")
+                }
+                baseBucket := m["control-bucket"].(string)
+                if bucket, ok := final["control-bucket"].(string); !ok {
+                        final["control-bucket"] = baseBucket
+                } else if bucket != baseBucket {
+                        return nil, fmt.Errorf("mismatched control-buckets")
+                }
+                if final["public-bucket"] == nil {
+                        if publicBucket, found := m["public-bucket"]; found {
+                                final["public-bucket"] = publicBucket
+                        }
+                }
+                if final["access-key"] == nil && final["secret-key"] == nil {
+                        final["access-key"] = m["access-key"]
+                        final["secret-key"] = m["secret-key"]
+                }
+        }
+
+        // Insert default region if unset, and check region has endpoint.
+        if region, found := final["region"]; !found {
+                final["region"] = "us-east-1"
+        } else if sregion, ok := region.(string); ok && sregion == "" {
+                final["region"] = "us-east-1"
+        } else if ok {
+                if awsRegion, found := aws.Regions[sregion]; found {
+                        if awsRegion.EC2Endpoint == "" {
+                                return nil, fmt.Errorf("no EC2 endpoint found for region %q", region)
+                        }
+                } else {
+                        return nil, fmt.Errorf("unknown AWS region %q", region)
+                }
+        } // else let the final checker deal with the gibberish consistently
+
+        // Insert default AWS auth if unset.
+        accessKey, _ := final["access-key"].(string)
+        secretKey, _ := final["secret-key"].(string)

[dfc, 2012/07/13 02:18:37]

damn I love the zero value.

+        if accessKey == "" || secretKey == "" {
+                if accessKey != "" {
+                        return nil, fmt.Errorf("environment has access-key but no secret-key")
+                }
+                if secretKey != "" {
+                        return nil, fmt.Errorf("environment has secret-key but no access-key")
+                }
+                auth, err := aws.EnvAuth()
+                if err != nil {
+                        return nil, err
+                }
+                final["access-key"] = auth.AccessKey
+                final["secret-key"] = auth.SecretKey
+        }
+        return config.Compose(base, final, checker)
+}
+
+var checker = config.Checker(
         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(),
-        }, []string{
-                "access-key",
-                "secret-key",
-                "region",
-                "authorized-keys",
-                "authorized-keys-path",
+                "type":           schema.Const("ec2"),
+                "region":         schema.ContentString(),
+                "control-bucket": schema.ContentString(),
+                "public-bucket":  schema.String(),
+                "access-key":     schema.ContentString(),
+                "secret-key":     schema.ContentString(),
+        },
+        schema.Optional{
                 "public-bucket",
         },
 )
-
-func (p environProvider) NewConfig(config map[string]interface{}) (cfg environs.EnvironConfig, err error) {
-        v, err := configChecker.Coerce(config, nil)
-        if err != nil {
-                return nil, err
-        }
-        m := v.(schema.MapType)
-        var c providerConfig
-
-        c.name = m["name"].(string)
-        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.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 maybeString(x interface{}, dflt string) string {
-        if x == nil {
-                return dflt
-        }
-        return x.(string)
-}