Make the API address easily accessible by charms

environs/maas/environ.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package maas
 
 import (
         "encoding/base64"
         "errors"
         "fmt"
         "launchpad.net/gomaasapi"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/environs"
         "launchpad.net/juju-core/environs/cloudinit"
         "launchpad.net/juju-core/environs/config"
         "launchpad.net/juju-core/environs/tools"
         "launchpad.net/juju-core/log"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/utils"
         "net/url"
         "sync"
         "time"
 )
 
 const (
-        mgoPort     = 37017
-        apiPort     = 17070
         jujuDataDir = "/var/lib/juju"
         // We're using v1.0 of the MAAS API.
         apiVersion = "1.0"
 )
 
-var mgoPortSuffix = fmt.Sprintf(":%d", mgoPort)
-var apiPortSuffix = fmt.Sprintf(":%d", apiPort)
-
 var longAttempt = utils.AttemptStrategy{
         Total: 3 * time.Minute,
         Delay: 1 * time.Second,
 }
 
 type maasEnviron struct {
         name string
 
         // ecfgMutex protects the *Unlocked fields below.
         ecfgMutex sync.Mutex
@@ skipping 20 matching lines @@
         return env, nil
 }
 
 func (env *maasEnviron) Name() string {
         return env.name
 }
 
 // makeMachineConfig sets up a basic machine configuration for use with
 // userData().  You may still need to supply more information, but this takes
 // care of the fixed entries and the ones that are always needed.
-func (env *maasEnviron) makeMachineConfig(machineID, machineNonce string, stateInfo *state.Info, apiInfo *api.Info) *cloudinit.MachineConfig {
+func (env *maasEnviron) makeMachineConfig(machineID, machineNonce string,
+        stateInfo *state.Info, apiInfo *api.Info) *cloudinit.MachineConfig {
         return &cloudinit.MachineConfig{
                 // Fixed entries.
-                MongoPort: mgoPort,
-                APIPort:   apiPort,
-                DataDir:   jujuDataDir,
+                DataDir: jujuDataDir,
 
                 // Parameter entries.
                 MachineId:    machineID,
                 MachineNonce: machineNonce,
                 StateInfo:    stateInfo,
                 APIInfo:      apiInfo,
         }
 }
 
 // startBootstrapNode starts the juju bootstrap node for this environment.
@@ skipping 41 matching lines @@
 // StateInfo is specified in the Environ interface.
 func (env *maasEnviron) StateInfo() (*state.Info, *api.Info, error) {
         // This code is cargo-culted from the openstack/ec2 providers.
         // It's a bit unclear what the "longAttempt" loop is actually for
         // but this should probably be refactored outside of the provider
         // code.
         st, err := env.loadState()
         if err != nil {
                 return nil, nil, err
         }
-        cert, hasCert := env.Config().CACert()
+        config := env.Config()
+        cert, hasCert := config.CACert()
         if !hasCert {
                 return nil, nil, fmt.Errorf("no CA certificate in environment configuration")
         }
         var stateAddrs []string
         var apiAddrs []string
         // Wait for the DNS names of any of the instances
         // to become available.
         log.Debugf("environs/maas: waiting for DNS name(s) of state server instances %v", st.StateInstances)
         for a := longAttempt.Start(); len(stateAddrs) == 0 && a.Next(); {
                 insts, err := env.Instances(st.StateInstances)
                 if err != nil && err != environs.ErrPartialInstances {
                         log.Debugf("environs/maas: error getting state instance: %v", err.Error())
                         return nil, nil, err
                 }
                 log.Debugf("environs/maas: started processing instances: %#v", insts)
                 for _, inst := range insts {
                         if inst == nil {
                                 continue
                         }
                         name, err := inst.DNSName()
                         if err != nil {
                                 continue
                         }
                         if name != "" {
-                                stateAddrs = append(stateAddrs, name+mgoPortSuffix)
+                                statePortSuffix := fmt.Sprintf(":%d", config.StatePort())
+                                apiPortSuffix := fmt.Sprintf(":%d", config.APIPort())
+                                stateAddrs = append(stateAddrs, name+statePortSuffix)
                                 apiAddrs = append(apiAddrs, name+apiPortSuffix)
                         }
                 }
         }
         if len(stateAddrs) == 0 {
                 return nil, nil, fmt.Errorf("timed out waiting for mgo address from %v", st.StateInstances)
         }
         return &state.Info{
                         Addrs:  stateAddrs,
                         CACert: cert,
@@ skipping 323 matching lines @@
 }
 
 func (*maasEnviron) Ports() ([]params.Port, error) {
         log.Debugf("environs/maas: unimplemented Ports() called")
         return []params.Port{}, nil
 }
 
 func (*maasEnviron) Provider() environs.EnvironProvider {
         return &providerInstance
 }