Implemented the base of a juju openstack provider.

environs/openstack/config.go

 package openstack
 
 import (
         "fmt"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/schema"
         "os"
 )
 
 var configChecker = schema.StrictFieldMap(
         schema.Fields{
-                "username":     schema.String(),
-                "password":     schema.String(),
-                "region":       schema.String(),
-                "tenant-id":    schema.String(),
-                "identity-url": schema.String(),

[gz, 2012/11/21 17:28:20]

Where possible, use the existing keys names that python juju does, so 'auth-url'
rather than 'identity-url' here.

-                "container":    schema.String(),
+                "username":    schema.String(),
+                "password":    schema.String(),
+                "tenant-name": schema.String(),
+                "auth-url":    schema.String(),
+                "region":      schema.String(),
+                "container":   schema.String(),
         },
         schema.Defaults{
-                "username":     "",
-                "password":     "",
-                "region":       "",
-                "tenant-id":    "",
-                "identity-url": "",
-                "container":    "",
+                "username":    "",
+                "password":    "",
+                "tenant-name": "",
+                "auth-url":    "",
+                "region":      "",
+                "container":   "",
         },
 )
 
 type environConfig struct {
         *config.Config
         attrs map[string]interface{}
 }
 
 func (c *environConfig) region() string {
         return c.attrs["region"].(string)
 }
 
 func (c *environConfig) username() string {
         return c.attrs["username"].(string)
 }
 
 func (c *environConfig) password() string {
         return c.attrs["password"].(string)
 }
 
-func (c *environConfig) tenantId() string {

[gz, 2012/11/21 17:28:20]

Using tenant-id vs. tenant-name is something we'll need to watch out for later.

[jameinel, 2012/11/22 07:19:49]

Just to follow up on this, "tenant-name" is what we'll get from the environment,
and what we would expect users to write themselves. "tenant-id" would be
something that we get from talking to the API.
So if we need to use it/store it we can, but ideally we would just go with
tenant name in the config.

-        return c.attrs["tenant-id"].(string)
+func (c *environConfig) tenantName() string {
+        return c.attrs["tenant-name"].(string)
 }
 
-func (c *environConfig) identityURL() string {

[gz, 2012/11/21 17:28:20]

As above, 'auth-url' instead.

-        return c.attrs["identity-url"].(string)
+func (c *environConfig) authURL() string {
+        return c.attrs["auth-url"].(string)
 }
 
 func (c *environConfig) container() string {

[niemeyer, 2012/11/22 12:54:14]

As we discussed, let's use controlBucket/"control-bucket" for this setting, for
compatibility with the ec2 provider.

[dimitern, 2012/11/22 13:13:17]

Done.

         return c.attrs["container"].(string)
 }
 
 func (p environProvider) newConfig(cfg *config.Config) (*environConfig, error) {
         valid, err := p.Validate(cfg, nil)
         if err != nil {
                 return nil, err
         }
         return &environConfig{valid, valid.UnknownAttrs()}, nil
 }
 
 func (p environProvider) Validate(cfg, old *config.Config) (valid *config.Config, err error) {

[gz, 2012/11/21 17:28:20]

Having one big function in the style of the current go code will get painful
with the various different authentication schemes openstack uses, but we will
want to delegate as much as possible to goose.

         v, err := configChecker.Coerce(cfg.UnknownAttrs(), nil)
         if err != nil {
                 return nil, err
         }
         ecfg := &environConfig{cfg, v.(map[string]interface{})}
         if ecfg.username() == "" ||
                 ecfg.password() == "" ||
-                ecfg.tenantId() == "" ||
-                ecfg.identityURL() == "" {
-                // TODO: get goose client to handle this
+                ecfg.tenantName() == "" ||
+                ecfg.authURL() == "" {

[niemeyer, 2012/11/22 12:54:14]

Can we please have these in the same line? We have lines around the same width
around here, and it ends up more reasonable as it doesn't align with the
internal block.

[dimitern, 2012/11/22 13:13:17]

Done.

+                // TODO(dimitern): get goose client to handle this
                 auth, err := dummyEnvAuth()
-                if err != nil ||
-                        ecfg.username() != "" ||

[rog, 2012/11/21 17:26:12]

perhaps these checks should be in dummyEnvAuth, and you could just return err
here. then the error message can be more useful.

-                        ecfg.password() != "" ||
-                        ecfg.tenantId() != "" ||
-                        ecfg.identityURL() != "" {
-                        return nil, fmt.Errorf("environment has no username, password, tenant-id, or identity-url")
+                if err != nil {
+                        return nil, fmt.Errorf("environment has no username, password, tenant-name, or auth-url")

[niemeyer, 2012/11/22 12:54:14]

"OpenStack environment requires options username, password, tenant-name, and
auth-url"

[dimitern, 2012/11/22 13:13:17]

Done.

                 }
                 ecfg.attrs["username"] = auth.username
                 ecfg.attrs["password"] = auth.password
-                ecfg.attrs["tenant-id"] = auth.tenantId
-                ecfg.attrs["identity-url"] = auth.identityURL
+                ecfg.attrs["tenant-name"] = auth.tenantName
+                ecfg.attrs["auth-url"] = auth.authURL
         }
         // We cannot validate the region name, since each OS installation
         // can have its own region names - only after authentication the
         // region names are known (from the service endpoints)
 
         if old != nil {
                 attrs := old.UnknownAttrs()
                 if region, _ := attrs["region"].(string); ecfg.region() != region {
                         return nil, fmt.Errorf("cannot change region from %q to %q", region, ecfg.region())
                 }
                 if container, _ := attrs["container"].(string); ecfg.container() != container {
                         return nil, fmt.Errorf("cannot change container from %q to %q", container, ecfg.container())
                 }
         }
 
         switch cfg.FirewallMode() {
         case config.FwDefault:
                 ecfg.attrs["firewall-mode"] = config.FwInstance
         case config.FwInstance, config.FwGlobal:
         default:
                 return nil, fmt.Errorf("unsupported firewall mode: %q", cfg.FirewallMode())
         }
 
         return cfg.Apply(ecfg.attrs)
 }
 
-// TODO: temporarily here, until goose client handles this

[gz, 2012/11/21 17:28:20]

You should be able to use Credentials from the identity package, the client has
now been refactored to look at that.

+// TODO(dimitern): temporarily here, until goose client handles this
 type dummyAuth struct {

[niemeyer, 2012/11/22 12:54:14]

Why dummy? This looks quite real. I think it should be envAuth or something like
that.

[dimitern, 2012/11/22 13:13:17]

This is here only because the goose identity package will handle this
eventually, but for now it's like this (hence the TODO), so we don't couple the
unstable code here. Anyway, renamed as suggested.

-        username, password, tenantId, identityURL string
+        username, password, tenantName, authURL string
 }
 
 func dummyEnvAuth() (dummyAuth, error) {

[gz, 2012/11/21 17:28:20]

Just use CredentialsFromEnv from the goose identity package as well.

[niemeyer, 2012/11/22 12:54:14]

getEnvAuth?

[dimitern, 2012/11/22 13:13:17]

Done.

-        return dummyAuth{
-                username:    os.Getenv("OS_USERNAME"),
-                password:    os.Getenv("OS_PASSWORD"),
-                tenantId:    os.Getenv("OS_TENANT_NAME"),
-                identityURL: os.Getenv("OS_AUTH_URL"),
-        }, nil
+        auth := dummyAuth{
+                username:   os.Getenv("OS_USERNAME"),
+                password:   os.Getenv("OS_PASSWORD"),
+                tenantName: os.Getenv("OS_TENANT_NAME"),
+                authURL:    os.Getenv("OS_AUTH_URL"),
+        }
+        if auth.username == "" ||
+                auth.password == "" ||
+                auth.tenantName == "" ||
+                auth.authURL == "" {

[niemeyer, 2012/11/22 12:54:14]

Same line as well, please.

[dimitern, 2012/11/22 13:13:17]

Done.

+                return auth, fmt.Errorf("missing username, password, tenant-name, or auth-url")

[niemeyer, 2012/11/22 12:54:14]

This function can be simplified to return (auth envAuth, ok bool) instead. This
error is pretty much the same one found above, and is being discarded, which
means the call site above is inferring what error it is.

+        }
+        return auth, nil
 }