environs: turn environment configuration into a concrete type

worker/provisioner/provisioner.go

 package provisioner
 
 import (
         "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/state/watcher"
         "launchpad.net/tomb"
 )
 
 type Provisioner struct {
         st      *state.State
         info    *state.Info
         environ environs.Environ
@@ skipping 34 matching lines @@
         for {
                 select {
                 case <-p.tomb.Dying():
                         return
                 case config, ok := <-environWatcher.Changes():
                         if !ok {
                                 p.tomb.Kill(watcher.MustErr(environWatcher))
                                 return
                         }
                         var err error
-                        p.environ, err = environs.NewEnviron(config.Map())
+                        // TODO Change state so it hands off *config.Config.
+                        p.environ, err = environs.NewFromAttrs(config.Map())
                         if err != nil {
                                 log.Printf("provisioner loaded invalid environment configuration: %v", err)
                                 continue
                         }
                         log.Printf("provisioner loaded new environment configuration")
                         if p.info, err = p.environ.StateInfo(); err != nil {
                                 p.tomb.Kill(err)
                                 return
                         }
                         break refreshState
@@ skipping 12 matching lines @@
         defer watcher.Stop(machinesWatcher, &p.tomb)
         for {
                 select {
                 case <-p.tomb.Dying():
                         return
                 case change, ok := <-environWatcher.Changes():
                         if !ok {
                                 p.tomb.Kill(watcher.MustErr(environWatcher))
                                 return
                         }
-                        config, err := environs.NewConfig(change.Map())
+                        // TODO Change state so it hands off *config.Config.
+                        config, err := config.New(change.Map())
                         if err != nil {
                                 log.Printf("provisioner loaded invalid environment configuration: %v", err)
                                 continue
                         }
                         p.environ.SetConfig(config)
                         log.Printf("provisioner loaded new environment configuration")
                 case machines, ok := <-machinesWatcher.Changes():
                         if !ok {
                                 p.tomb.Kill(watcher.MustErr(machinesWatcher))
                                 return
@@ skipping 176 matching lines @@
         var insts []environs.Instance
         for _, m := range machines {
                 inst, err := p.instanceForMachine(m)
                 if err != nil {
                         return nil, err
                 }
                 insts = append(insts, inst)
         }
         return insts, nil
 }