Implemented PublicAddress() and PrivateAddress()

environs/openstack/provider.go

 // Stub provider for OpenStack, using goose will be implemented here
 
 package openstack
 
 import (
+        "fmt"
+        "io/ioutil"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
+        "launchpad.net/juju-core/trivial"
+        "net/http"
+        "strings"
         "sync"
+        "time"
 )
 
 type environProvider struct{}
 
 var _ environs.EnvironProvider = (*environProvider)(nil)
 
 var providerInstance environProvider
 
+// A request may fail to due "eventual consistency" semantics, which
+// should resolve fairly quickly.  A request may also fail due to a slow
+// state transition (for instance an instance taking a while to release
+// a security group after termination).  The former failure mode is
+// dealt with by shortAttempt, the latter by longAttempt.
+var shortAttempt = trivial.AttemptStrategy{

[rog, 2012/11/22 15:11:48]

does openstack have the same eventual-consistency issues as ec2? if not, you
probably won't need this at all.

+        Total: 5 * time.Second,
+        Delay: 200 * time.Millisecond,
+}
+
+var longAttempt = trivial.AttemptStrategy{
+        Total: 3 * time.Minute,
+        Delay: 1 * time.Second,
+}
+
 func init() {
         environs.RegisterProvider("openstack", environProvider{})
 }
 
 func (p environProvider) Open(cfg *config.Config) (environs.Environ, error) {
         log.Printf("environs/openstack: opening environment %q", cfg.Name())
         e := new(environ)
         err := e.SetConfig(cfg)
         if err != nil {
                 return nil, err
         }
         return e, nil
 }
 
 func (p environProvider) SecretAttrs(cfg *config.Config) (map[string]interface{}, error) {
         m := make(map[string]interface{})
         ecfg, err := providerInstance.newConfig(cfg)
         if err != nil {
                 return nil, err
         }
         m["username"] = ecfg.username()
         m["password"] = ecfg.password()
         m["tenant-name"] = ecfg.tenantName()
         return m, nil
 }
 
 func (p environProvider) PublicAddress() (string, error) {
-        panic("not implemented")
+        return fetchMetadata("public-hostname")
 }
 
 func (p environProvider) PrivateAddress() (string, error) {
-        panic("not implemented")
+        return fetchMetadata("local-hostname")
 }
 
 type environ struct {
         name string
 
         ecfgMutex    sync.Mutex
         ecfgUnlocked *environConfig
 }
 
 var _ environs.Environ = (*environ)(nil)
@@ skipping 75 matching lines @@
         panic("not implemented")
 }
 
 func (e *environ) Ports() ([]state.Port, error) {
         panic("not implemented")
 }
 
 func (e *environ) Provider() environs.EnvironProvider {
         return &providerInstance
 }
+
+// metadataHost holds the address of the instance metadata service.
+// It is a variable so that tests can change it to refer to a local
+// server when needed.
+var metadataHost = "http://169.254.169.254"
+
+// fetchMetadata fetches a single atom of data from the openstack instance metadata service.
+// http://docs.amazonwebservices.com/AWSEC2/latest/UserGuide/AESDG-chapter-instancedata.html

[TheMue, 2012/11/22 14:31:57]

Here again a reference to EC2. But maybe only I don't get the connection between
EC2 and OpenStack. In this case don't care.

+func fetchMetadata(name string) (value string, err error) {
+        uri := fmt.Sprintf("%s/2011-01-01/meta-data/%s", metadataHost, name)
+        defer trivial.ErrorContextf(&err, "cannot get %q", uri)
+        for a := shortAttempt.Start(); a.Next(); {
+                var resp *http.Response
+                resp, err = http.Get(uri)
+                if err != nil {
+                        continue
+                }
+                defer resp.Body.Close()
+                if resp.StatusCode != http.StatusOK {
+                        err = fmt.Errorf("bad http response %v", resp.Status)
+                        continue
+                }
+                var data []byte
+                data, err = ioutil.ReadAll(resp.Body)
+                if err != nil {
+                        continue
+                }
+                return strings.TrimSpace(string(data)), nil
+        }
+        return
+}