cmd/jujud: do not change password

state/machine_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state_test
 
 import (
         . "launchpad.net/gocheck"
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/errors"
+        "launchpad.net/juju-core/instance"
         "launchpad.net/juju-core/state"
         "launchpad.net/juju-core/state/api/params"
         "launchpad.net/juju-core/version"
         "sort"
         "time"
 )
 
 type MachineSuite struct {
         ConnSuite
         machine *state.Machine
@@ skipping 89 matching lines @@
         m, err := s.State.AddMachine("series", state.JobHostUnits)
         c.Assert(err, IsNil)
         err = m.Destroy()
         c.Assert(err, IsNil)
         c.Assert(m.Life(), Equals, state.Dying)
         err = m.EnsureDead()
         c.Assert(err, IsNil)
         c.Assert(m.Life(), Equals, state.Dead)
 }
 
+func (s *MachineSuite) TestDestroyAbort(c *C) {
+        defer state.SetBeforeHooks(c, s.State, func() {
+                c.Assert(s.machine.Destroy(), IsNil)
+        }).Check()
+        err := s.machine.Destroy()
+        c.Assert(err, IsNil)
+}
+
+func (s *MachineSuite) TestDestroyCancel(c *C) {
+        svc, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
+        c.Assert(err, IsNil)
+        unit, err := svc.AddUnit()
+        c.Assert(err, IsNil)
+
+        defer state.SetBeforeHooks(c, s.State, func() {
+                c.Assert(unit.AssignToMachine(s.machine), IsNil)
+        }).Check()
+        err = s.machine.Destroy()
+        c.Assert(err, FitsTypeOf, &state.HasAssignedUnitsError{})
+}
+
+func (s *MachineSuite) TestDestroyContention(c *C) {
+        svc, err := s.State.AddService("wordpress", s.AddTestingCharm(c, "wordpress"))
+        c.Assert(err, IsNil)
+        unit, err := svc.AddUnit()
+        c.Assert(err, IsNil)
+
+        perturb := state.TransactionHook{
+                Before: func() { c.Assert(unit.AssignToMachine(s.machine), IsNil) },
+                After:  func() { c.Assert(unit.UnassignFromMachine(), IsNil) },
+        }
+        defer state.SetTransactionHooks(
+                c, s.State, perturb, perturb, perturb,
+        ).Check()
+        err = s.machine.Destroy()
+        c.Assert(err, ErrorMatches, "machine 0 cannot advance lifecycle: state changing too quickly; try again soon")
+}
+
 func (s *MachineSuite) TestRemove(c *C) {
         err := s.machine.Remove()
         c.Assert(err, ErrorMatches, "cannot remove machine 0: machine is not dead")
         err = s.machine.EnsureDead()
         c.Assert(err, IsNil)
         err = s.machine.Remove()
         c.Assert(err, IsNil)
         err = s.machine.Refresh()
         c.Assert(errors.IsNotFoundError(err), Equals, true)
         _, err = s.machine.Containers()
         c.Assert(errors.IsNotFoundError(err), Equals, true)
+        err = s.machine.Remove()
+        c.Assert(err, IsNil)
+}
+
+func (s *MachineSuite) TestRemoveAbort(c *C) {
+        err := s.machine.EnsureDead()
+        c.Assert(err, IsNil)
+
+        defer state.SetBeforeHooks(c, s.State, func() {
+                c.Assert(s.machine.Remove(), IsNil)
+        }).Check()
         err = s.machine.Remove()
         c.Assert(err, IsNil)
 }
 
 func (s *MachineSuite) TestDestroyMachines(c *C) {
         m0 := s.machine
         m1, err := s.State.AddMachine("series", state.JobManageEnviron)
         c.Assert(err, IsNil)
         m2, err := s.State.AddMachine("series", state.JobHostUnits)
         c.Assert(err, IsNil)
@@ skipping 45 matching lines @@
 func (s *MachineSuite) TestTag(c *C) {
         c.Assert(s.machine.Tag(), Equals, "machine-0")
 }
 
 func (s *MachineSuite) TestMachineTag(c *C) {
         c.Assert(state.MachineTag("10"), Equals, "machine-10")
         // Check a container id.
         c.Assert(state.MachineTag("10/lxc/1"), Equals, "machine-10-lxc-1")
 }
 
+func (s *MachineSuite) TestMachineIdFromTag(c *C) {
+        c.Assert(state.MachineIdFromTag("machine-10"), Equals, "10")
+        // Check a container id.
+        c.Assert(state.MachineIdFromTag("machine-10-lxc-1"), Equals, "10/lxc/1")
+        // Check reversability.
+        nested := "2/kvm/0/lxc/3"
+        c.Assert(state.MachineIdFromTag(state.MachineTag(nested)), Equals, nested)
+}
+
 func (s *MachineSuite) TestSetMongoPassword(c *C) {
         testSetMongoPassword(c, func(st *state.State) (entity, error) {
                 return st.Machine(s.machine.Id())
         })
 }
 
 func (s *MachineSuite) TestSetPassword(c *C) {
         testSetPassword(c, func() (state.Authenticator, error) {
                 return s.State.Machine(s.machine.Id())
         })
@@ skipping 34 matching lines @@
         c.Assert(err, IsNil)
         err = s.machines.Update(
                 D{{"_id", machine.Id()}},
                 D{{"$set", D{{"instanceid", "spaceship/0"}}}},
         )
         c.Assert(err, IsNil)
 
         err = machine.Refresh()
         c.Assert(err, IsNil)
         iid, _ := machine.InstanceId()
-        c.Assert(iid, Equals, state.InstanceId("spaceship/0"))
+        c.Assert(iid, Equals, instance.Id("spaceship/0"))
 }
 
 func (s *MachineSuite) TestMachineInstanceIdCorrupt(c *C) {
         machine, err := s.State.AddMachine("series", state.JobHostUnits)
         c.Assert(err, IsNil)
         err = s.machines.Update(
                 D{{"_id", machine.Id()}},
                 D{{"$set", D{{"instanceid", D{{"foo", "bar"}}}}}},
         )
         c.Assert(err, IsNil)
 
         err = machine.Refresh()
         c.Assert(err, IsNil)
         iid, ok := machine.InstanceId()
         c.Assert(ok, Equals, false)
-        c.Assert(iid, Equals, state.InstanceId(""))
+        c.Assert(iid, Equals, instance.Id(""))
 }
 
 func (s *MachineSuite) TestMachineInstanceIdMissing(c *C) {
         iid, ok := s.machine.InstanceId()
         c.Assert(ok, Equals, false)
         c.Assert(string(iid), Equals, "")
 }
 
 func (s *MachineSuite) TestMachineInstanceIdBlank(c *C) {
         machine, err := s.State.AddMachine("series", state.JobHostUnits)
@@ skipping 191 matching lines @@
         m, svc, unit := s.assertMachineDirtyAfterAddingUnit(c)
         err := unit.EnsureDead()
         c.Assert(err, IsNil)
         err = unit.Remove()
         c.Assert(err, IsNil)
         err = svc.Destroy()
         c.Assert(err, IsNil)
         c.Assert(m.Clean(), Equals, false)
 }
 
-type machineInfo struct {
-        tools      *state.Tools
-        instanceId string
-}
-
-func tools(tools int, url string) *state.Tools {
-        return &state.Tools{
-                URL: url,
-                Binary: version.Binary{
-                        Number: version.Number{
-                                Major: 0, Minor: 0, Patch: tools,
-                        },
-                        Series: "series",
-                        Arch:   "arch",
-                },
-        }
-}
-
-var watchMachineTests = []func(m *state.Machine) error{
-        func(m *state.Machine) error {
-                return nil
-        },
-        func(m *state.Machine) error {
-                return m.SetProvisioned("m-foo", "fake_nonce")
-        },
-        func(m *state.Machine) error {
-                return m.SetAgentTools(tools(3, "baz"))
-        },
-}
-
 func (s *MachineSuite) TestWatchMachine(c *C) {
         w := s.machine.Watch()
-        defer func() {
-                c.Assert(w.Stop(), IsNil)
-        }()
-        for i, test := range watchMachineTests {
-                c.Logf("test %d", i)
-                err := test(s.machine)
-                c.Assert(err, IsNil)
-                s.State.StartSync()
-                select {
-                case _, ok := <-w.Changes():
-                        c.Assert(ok, Equals, true)
-                case <-time.After(5 * time.Second):
-                        c.Fatalf("did not get change")
-                }
-        }
-        select {
-        case got := <-w.Changes():
-                c.Fatalf("got unexpected change: %#v", got)
-        case <-time.After(50 * time.Millisecond):
-        }
+        defer AssertStop(c, w)
+
+        // Initial event.
+        wc := NotifyWatcherC{c, s.State, w}
+        wc.AssertOneChange()
+
+        // Make one change (to a separate instance), check one event.
+        machine, err := s.State.Machine(s.machine.Id())
+        c.Assert(err, IsNil)
+        err = machine.SetProvisioned("m-foo", "fake_nonce")
+        c.Assert(err, IsNil)
+        wc.AssertOneChange()
+
+        // Make two changes, check one event.
+        err = machine.SetAgentTools(&state.Tools{
+                URL:    "foo",
+                Binary: version.MustParseBinary("0.0.3-series-arch"),
+        })
+        c.Assert(err, IsNil)
+        err = machine.Destroy()
+        c.Assert(err, IsNil)
+        wc.AssertOneChange()
+
+        // Stop, check closed.
+        AssertStop(c, w)
+        wc.AssertClosed()
+
+        // Remove machine, start new watch, check single event.
+        err = machine.EnsureDead()
+        c.Assert(err, IsNil)
+        err = machine.Remove()
+        c.Assert(err, IsNil)
+        w = s.machine.Watch()
+        defer AssertStop(c, w)
+        NotifyWatcherC{c, s.State, w}.AssertOneChange()
 }
 
 func (s *MachineSuite) TestWatchPrincipalUnits(c *C) {
         // Start a watch on an empty machine; check no units reported.
         w := s.machine.WatchPrincipalUnits()
-        defer stop(c, w)
-        assertNoChange := func() {
-                s.State.Sync()
-                select {
-                case <-time.After(50 * time.Millisecond):
-                case got, ok := <-w.Changes():
-                        c.Fatalf("unexpected change: %#v, %v", got, ok)
-                }
-        }
-        assertChange := func(expect ...string) {
-                s.State.Sync()
-                select {
-                case <-time.After(500 * time.Millisecond):
-                        c.Fatalf("timed out")
-                case got, ok := <-w.Changes():
-                        c.Assert(ok, Equals, true)
-                        if len(expect) == 0 {
-                                c.Assert(got, HasLen, 0)
-                        } else {
-                                sort.Strings(expect)
-                                sort.Strings(got)
-                                c.Assert(expect, DeepEquals, got)
-                        }
-                }
-                assertNoChange()
-        }
-        assertChange()
-
-        // Change machine; no change.
+        defer AssertStop(c, w)
+        wc := StringsWatcherC{c, s.State, w}
+        wc.AssertOneChange()
+
+        // Change machine, and create a unit independently; no change.
         err := s.machine.SetProvisioned("cheese", "fake_nonce")
         c.Assert(err, IsNil)
-
-        // Assign a unit; change detected.
+        wc.AssertNoChange()
         mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
         c.Assert(err, IsNil)
         mysql0, err := mysql.AddUnit()
         c.Assert(err, IsNil)
-        err = mysql0.AssignToMachine(s.machine)
-        c.Assert(err, IsNil)
-        assertChange("mysql/0")
+        wc.AssertNoChange()
+
+        // Assign that unit (to a separate machine instance); change detected.
+        machine, err := s.State.Machine(s.machine.Id())
+        c.Assert(err, IsNil)
+        err = mysql0.AssignToMachine(machine)
+        c.Assert(err, IsNil)
+        wc.AssertOneChange("mysql/0")
 
         // Change the unit; no change.
         err = mysql0.SetStatus(params.StatusStarted, "")
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Assign another unit and make the first Dying; check both changes detected.
         mysql1, err := mysql.AddUnit()
         c.Assert(err, IsNil)
-        err = mysql1.AssignToMachine(s.machine)
+        err = mysql1.AssignToMachine(machine)
         c.Assert(err, IsNil)
         err = mysql0.Destroy()
         c.Assert(err, IsNil)
-        assertChange("mysql/0", "mysql/1")
+        wc.AssertOneChange("mysql/0", "mysql/1")
 
         // Add a subordinate to the Alive unit; no change.
         logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
         c.Assert(err, IsNil)
         eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
         c.Assert(err, IsNil)
         rel, err := s.State.AddRelation(eps...)
         c.Assert(err, IsNil)
         mysqlru1, err := rel.Unit(mysql1)
         c.Assert(err, IsNil)
         err = mysqlru1.EnterScope(nil)
         c.Assert(err, IsNil)
         logging0, err := logging.Unit("logging/0")
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Change the subordinate; no change.
         err = logging0.SetStatus(params.StatusStarted, "")
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Make the Dying unit Dead; change detected.
         err = mysql0.EnsureDead()
         c.Assert(err, IsNil)
-        assertChange("mysql/0")
+        wc.AssertOneChange("mysql/0")
 
         // Stop watcher; check Changes chan closed.
-        assertClosed := func() {
-                select {
-                case <-time.After(50 * time.Millisecond):
-                        c.Fatalf("not closed")
-                case _, ok := <-w.Changes():
-                        c.Assert(ok, Equals, false)
-                }
-        }
-        stop(c, w)
-        assertClosed()
+        AssertStop(c, w)
+        wc.AssertClosed()
 
         // Start a fresh watcher; check both principals reported.
         w = s.machine.WatchPrincipalUnits()
-        defer stop(c, w)
-        assertChange("mysql/0", "mysql/1")
+        defer AssertStop(c, w)
+        wc = StringsWatcherC{c, s.State, w}
+        wc.AssertOneChange("mysql/0", "mysql/1")
 
         // Remove the Dead unit; no change.
         err = mysql0.Remove()
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Destroy the subordinate; no change.
         err = logging0.Destroy()
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Unassign the unit; check change.
         err = mysql1.UnassignFromMachine()
         c.Assert(err, IsNil)
-        assertChange("mysql/1")
+        wc.AssertOneChange("mysql/1")
 }
 
 func (s *MachineSuite) TestWatchUnits(c *C) {
         // Start a watch on an empty machine; check no units reported.
         w := s.machine.WatchUnits()
-        defer stop(c, w)
-        assertNoChange := func() {
-                s.State.Sync()
-                select {
-                case <-time.After(50 * time.Millisecond):
-                case got, ok := <-w.Changes():
-                        c.Fatalf("unexpected change: %#v, %v", got, ok)
-                }
-        }
-        assertChange := func(expect ...string) {
-                s.State.Sync()
-                select {
-                case <-time.After(500 * time.Millisecond):
-                        c.Fatalf("timed out")
-                case got, ok := <-w.Changes():
-                        c.Assert(ok, Equals, true)
-                        if len(expect) == 0 {
-                                c.Assert(got, HasLen, 0)
-                        } else {
-                                sort.Strings(expect)
-                                sort.Strings(got)
-                                c.Assert(expect, DeepEquals, got)
-                        }
-                }
-                assertNoChange()
-        }
-        assertChange()
+        defer AssertStop(c, w)
+        wc := StringsWatcherC{c, s.State, w}
+        wc.AssertOneChange()
 
         // Change machine; no change.
         err := s.machine.SetProvisioned("cheese", "fake_nonce")
         c.Assert(err, IsNil)
-
-        // Assign a unit; change detected.
+        wc.AssertNoChange()
+
+        // Assign a unit (to a separate instance); change detected.
         mysql, err := s.State.AddService("mysql", s.AddTestingCharm(c, "mysql"))
         c.Assert(err, IsNil)
         mysql0, err := mysql.AddUnit()
         c.Assert(err, IsNil)
-        err = mysql0.AssignToMachine(s.machine)
-        c.Assert(err, IsNil)
-        assertChange("mysql/0")
+        machine, err := s.State.Machine(s.machine.Id())
+        c.Assert(err, IsNil)
+        err = mysql0.AssignToMachine(machine)
+        c.Assert(err, IsNil)
+        wc.AssertOneChange("mysql/0")
 
         // Change the unit; no change.
         err = mysql0.SetStatus(params.StatusStarted, "")
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Assign another unit and make the first Dying; check both changes detected.
         mysql1, err := mysql.AddUnit()
         c.Assert(err, IsNil)
-        err = mysql1.AssignToMachine(s.machine)
+        err = mysql1.AssignToMachine(machine)
         c.Assert(err, IsNil)
         err = mysql0.Destroy()
         c.Assert(err, IsNil)
-        assertChange("mysql/0", "mysql/1")
+        wc.AssertOneChange("mysql/0", "mysql/1")
 
         // Add a subordinate to the Alive unit; change detected.
         logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
         c.Assert(err, IsNil)
         eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
         c.Assert(err, IsNil)
         rel, err := s.State.AddRelation(eps...)
         c.Assert(err, IsNil)
         mysqlru1, err := rel.Unit(mysql1)
         c.Assert(err, IsNil)
         err = mysqlru1.EnterScope(nil)
         c.Assert(err, IsNil)
         logging0, err := logging.Unit("logging/0")
         c.Assert(err, IsNil)
-        assertChange("logging/0")
+        wc.AssertOneChange("logging/0")
 
         // Change the subordinate; no change.
         err = logging0.SetStatus(params.StatusStarted, "")
         c.Assert(err, IsNil)
-        assertNoChange()
+        wc.AssertNoChange()
 
         // Make the Dying unit Dead; change detected.
         err = mysql0.EnsureDead()
         c.Assert(err, IsNil)
-        assertChange("mysql/0")
+        wc.AssertOneChange("mysql/0")
 
         // Stop watcher; check Changes chan closed.
-        assertClosed := func() {
-                select {
-                case <-time.After(50 * time.Millisecond):
-                        c.Fatalf("not closed")
-                case _, ok := <-w.Changes():
-                        c.Assert(ok, Equals, false)
-                }
-        }
-        stop(c, w)
-        assertClosed()
+        AssertStop(c, w)
+        wc.AssertClosed()
 
         // Start a fresh watcher; check all units reported.
         w = s.machine.WatchUnits()
-        defer stop(c, w)
-        assertChange("mysql/0", "mysql/1", "logging/0")
+        defer AssertStop(c, w)
+        wc = StringsWatcherC{c, s.State, w}
+        wc.AssertOneChange("mysql/0", "mysql/1", "logging/0")
 
         // Remove the Dead unit; no change.
         err = mysql0.Remove()
         c.Assert(err, IsNil)
-        assertNoChange()
-
-        // Destroy the subordinate; no change.
+        wc.AssertNoChange()
+
+        // Destroy the subordinate; change detected.
         err = logging0.Destroy()
         c.Assert(err, IsNil)
-        assertChange("logging/0")
+        wc.AssertOneChange("logging/0")
 
         // Unassign the principal; check subordinate departure also reported.
         err = mysql1.UnassignFromMachine()
         c.Assert(err, IsNil)
-        assertChange("mysql/1", "logging/0")
+        wc.AssertOneChange("mysql/1", "logging/0")
 }
 
 func (s *MachineSuite) TestAnnotatorForMachine(c *C) {
         testAnnotator(c, func() (state.Annotator, error) {
                 return s.State.Machine(s.machine.Id())
         })
 }
 
 func (s *MachineSuite) TestAnnotationRemovalForMachine(c *C) {
         annotations := map[string]string{"mykey": "myvalue"}
@@ skipping 127 matching lines @@
         c.Assert(status, Equals, params.StatusStopped)
         c.Assert(info, Equals, "")
 
         err = s.machine.Remove()
         c.Assert(err, IsNil)
         err = s.machine.SetStatus(params.StatusStarted, "not really")
         c.Assert(err, ErrorMatches, `cannot set status of machine "0": not found or not alive`)
         _, _, err = s.machine.Status()
         c.Assert(err, ErrorMatches, "status not found")
 }