Introduce the null provider

environs/manual/bootstrap.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package manual
 
 import (
         "errors"
         "fmt"
 
         "launchpad.net/juju-core/agent"
@@ skipping 12 matching lines @@
 // LocalStorageEnviron is an Environ where the bootstrap node
 // manages its own local storage.
 type LocalStorageEnviron interface {
         environs.Environ
         environs.BootstrapStorager
         localstorage.LocalStorageConfig
 }
 
 type BootstrapArgs struct {
         Host          string
+        DataDir       string
         Environ       LocalStorageEnviron
         MachineId     string
         PossibleTools tools.List
 }
 
-// TODO(axw) make this configurable?
-const dataDir = "/var/lib/juju"
-
 func errMachineIdInvalid(machineId string) error {
         return fmt.Errorf("%q is not a valid machine ID", machineId)
 }
 
 // NewManualBootstrapEnviron wraps a LocalStorageEnviron with another which
 // overrides the Bootstrap method; when Bootstrap is invoked, the specified
 // host will be manually bootstrapped.
 func Bootstrap(args BootstrapArgs) (err error) {
         if args.Host == "" {
                 return errors.New("host argument is empty")
         }
         if args.Environ == nil {
                 return errors.New("environ argument is nil")
         }
+        if args.DataDir == "" {
+                return errors.New("data-dir argument is empty")
+        }
         if !names.IsMachine(args.MachineId) {
                 return errMachineIdInvalid(args.MachineId)
         }
 
         provisioned, err := checkProvisioned(args.Host)
         if err != nil {
                 return fmt.Errorf("failed to check provisioned status: %v", err)
         }
         if provisioned {
                 return ErrProvisioned
@@ skipping 31 matching lines @@
         if err != nil {
                 return err
         }
         defer func() {
                 if err != nil {
                         logger.Errorf("bootstrapping failed, removing state file: %v", err)
                         bootstrapStorage.Remove(provider.StateFile)
                 }
         }()
 
+        // Set the new tools prefix so StorageName returns the right thing.
+        restore := envtools.SetToolPrefix(envtools.NewToolPrefix)
+        defer restore()
+
         // Get a file:// scheme tools URL for the tools, which will have been
         // copied to the remote machine's storage directory.
         tools := *possibleTools[0]
         storageDir := args.Environ.StorageDir()
         toolsStorageName := envtools.StorageName(tools.Version)
         tools.URL = fmt.Sprintf("file://%s/%s", storageDir, toolsStorageName)
 
         // Add the local storage configuration.
         agentEnv := map[string]string{
                 agent.StorageAddr:       args.Environ.StorageAddr(),
                 agent.StorageDir:        storageDir,
                 agent.SharedStorageAddr: args.Environ.SharedStorageAddr(),
                 agent.SharedStorageDir:  args.Environ.SharedStorageDir(),
         }
 
         // Finally, provision the machine agent.
         stateFileURL := fmt.Sprintf("file://%s/%s", storageDir, provider.StateFile)
         err = provisionMachineAgent(provisionMachineAgentArgs{
                 host:          args.Host,
-                dataDir:       dataDir,
+                dataDir:       args.DataDir,
                 environConfig: args.Environ.Config(),
                 stateFileURL:  stateFileURL,
                 machineId:     args.MachineId,
                 bootstrap:     true,
                 nonce:         state.BootstrapNonce,
                 tools:         &tools,
                 agentEnv:      agentEnv,
         })
         return err
 }