cmd/juju: add --upload-tools flag to bootstrap command

environs/dummy/environs.go

-package dummy
-
-import (
-        "bytes"
-        "errors"
-        "fmt"
-        "io"
-        "io/ioutil"
-        "launchpad.net/juju/go/environs"
-        "launchpad.net/juju/go/schema"
-        "launchpad.net/juju/go/state"
-        "sort"
-        "strings"
-        "sync"
-)
-
-type Operation struct {
-        Kind OperationKind
-        Env  string
-}
-
-// Operation represents an action on the dummy provider.
-type OperationKind int
-
-const (
-        OpNone OperationKind = iota
-        OpBootstrap
-        OpDestroy
-        OpStartInstance
-        OpStopInstances
-        OpPutFile
-)
-
-var kindNames = []string{
-        OpNone:          "OpNone",
-        OpBootstrap:     "OpBootstrap",
-        OpDestroy:       "OpDestroy",
-        OpStartInstance: "OpStartInstance",
-        OpStopInstances: "OpStopInstances",
-        OpPutFile:       "OpPutFile",
-}
-
-func (k OperationKind) String() string {
-        return kindNames[k]
-}
-
-// environProvider represents the dummy provider.  There is only ever one
-// instance of this type (providerInstance)
-type environProvider struct {
-        mu    sync.Mutex
-        state *environState
-        ops   chan<- Operation
-}
-
-// environState represents the state of an environment.
-// It can be shared between several environ values,
-// so that a given environment can be opened several times.
-type environState struct {
-        mu           sync.Mutex
-        maxId        int // maximum instance id allocated so far.
-        insts        map[string]*instance
-        files        map[string][]byte
-        bootstrapped bool
-}
-
-var providerInstance environProvider
-
-// discardOperations discards all Operations written to it.
-var discardOperations chan<- Operation
-
-func init() {
-        environs.RegisterProvider("dummy", &providerInstance)
-
-        // Prime the first ops channel, so that naive clients can use
-        // the testing environment by simply importing it.
-        c := make(chan Operation)
-        go func() {
-                for _ = range c {
-                }
-        }()
-        discardOperations = c
-        Reset(discardOperations, true)
-}
-
-// Reset closes any previously registered operation channel,
-// cleans the environment state, and registers c to receive
-// notifications of operations performed on newly opened
-// dummy environments. All opened environments after a Reset
-// will share the same underlying state (instances, etc).
-// If clean is true, this will be empty; otherwise

[niemeyer, 2012/05/17 01:08:42]

This will be empty? That comment doesn't seem to make sense in its context, and
I'm not sure it makes sense even if we explain it further, because with clear
being false, Reset does not reset, which is pretty strange. I'd appreciate
removing this flag and simplifying the test so that they're not resetting the
environment in the middle if they don't want that, as pointed out in the other
comment.

The other changes in this file seem good, though.

[rog, 2012/05/17 11:43:33]

will refactor as mentioned in cmd_test.go

-// it will remain the same as before.
+// The dummy provider implements an environment provider for testing
+// purposes, registered with environs under the name "dummy".
 //·
 // The configuration YAML for the testing environment
 // must specify a "zookeeper" property with a boolean
 // value. If this is true, a zookeeper instance will be started
 // the first time StateInfo is called on a newly reset environment.
 // NOTE: ZooKeeper isn't actually being started yet.
 //·
 // The configuration data also accepts a "broken" property
 // of type boolean. If this is non-empty, any operation
 // after the environment has been opened will return
 // the error "broken environment", and will also log that.
 //·
 // The DNS name of instances is the same as the Id,
 // with ".dns" appended.
-func Reset(c chan<- Operation, clean bool) {
-        providerInstance.reset(c, clean)
-}
-
-func (e *environProvider) reset(c chan<- Operation, clean bool) {
+package dummy
+
+import (
+        "bytes"
+        "errors"
+        "fmt"
+        "io"
+        "io/ioutil"
+        "launchpad.net/juju/go/environs"
+        "launchpad.net/juju/go/schema"
+        "launchpad.net/juju/go/state"
+        "sort"
+        "strings"
+        "sync"
+)
+
+type Operation struct {
+        Kind OperationKind
+        Env  string
+}
+
+// Operation represents an action on the dummy provider.
+type OperationKind int
+
+const (
+        OpNone OperationKind = iota
+        OpBootstrap
+        OpDestroy
+        OpStartInstance
+        OpStopInstances
+        OpPutFile
+)
+
+var kindNames = []string{
+        OpNone:          "OpNone",
+        OpBootstrap:     "OpBootstrap",
+        OpDestroy:       "OpDestroy",
+        OpStartInstance: "OpStartInstance",
+        OpStopInstances: "OpStopInstances",
+        OpPutFile:       "OpPutFile",
+}
+
+func (k OperationKind) String() string {
+        return kindNames[k]
+}
+
+// environProvider represents the dummy provider.  There is only ever one
+// instance of this type (providerInstance)
+type environProvider struct {
+        mu    sync.Mutex
+        state *environState
+        ops   chan<- Operation
+}
+
+// environState represents the state of an environment.
+// It can be shared between several environ values,
+// so that a given environment can be opened several times.
+type environState struct {
+        mu           sync.Mutex
+        maxId        int // maximum instance id allocated so far.
+        insts        map[string]*instance
+        files        map[string][]byte
+        bootstrapped bool
+}
+
+var providerInstance environProvider
+
+// discardOperations discards all Operations written to it.
+var discardOperations chan<- Operation
+
+func init() {
+        environs.RegisterProvider("dummy", &providerInstance)
+
+        // Prime the first ops channel, so that naive clients can use
+        // the testing environment by simply importing it.
+        c := make(chan Operation)
+        go func() {
+                for _ = range c {
+                }
+        }()
+        discardOperations = c
+        Reset()
+}
+
+// Reset resets the entire dummy environment and forgets any registered
+// operation listener.  All opened environments after Reset will share
+// the same underlying state.
+func Reset() {
+        e := &providerInstance
+        e.mu.Lock()
+        defer e.mu.Unlock()
+        e.ops = discardOperations
+        e.state = &environState{
+                insts: make(map[string]*instance),
+                files: make(map[string][]byte),
+        }
+}
+
+// Listen closes the previously registered listener (if any),
+// and if c is not nil registers it to receive notifications·
+// of follow up operations in the environment.
+func Listen(c chan<- Operation) {
+        e := &providerInstance
         e.mu.Lock()
         defer e.mu.Unlock()
         if c == nil {
                 c = discardOperations
         }
-        if ops := e.ops; ops != discardOperations && ops != nil {
-                close(ops)
+        if e.ops != discardOperations {
+                close(e.ops)
         }
         e.ops = c
-
-        if clean {
-                e.state = &environState{
-                        insts: make(map[string]*instance),
-                        files: make(map[string][]byte),
-                }
-        }
 }
 
 func (e *environProvider) ConfigChecker() schema.Checker {
         return schema.FieldMap(
                 schema.Fields{
                         "type":      schema.Const("dummy"),
                         "zookeeper": schema.Const(false), // TODO
                         "broken":    schema.Bool(),
                 },
                 []string{
@@ skipping 208 matching lines @@
 // it's closed.
 type notifyCloser struct {
         io.Reader
         notify chan bool
 }
 
 func (r *notifyCloser) Close() error {
         r.notify <- true
         return nil
 }