state: added status data to status doc

state/machine_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package state_test
 
 import (
         "sort"
 
         gc "launchpad.net/gocheck"
 
@@ skipping 645 matching lines @@
 
         // Assign that unit (to a separate machine instance); change detected.
         machine, err := s.State.Machine(s.machine.Id())
         c.Assert(err, gc.IsNil)
         err = mysql0.AssignToMachine(machine)
         c.Assert(err, gc.IsNil)
         wc.AssertChange("mysql/0")
         wc.AssertNoChange()
 
         // Change the unit; no change.
-        err = mysql0.SetStatus(params.StatusStarted, "")
+        err = mysql0.SetStatus(params.StatusStarted, "", nil)
         c.Assert(err, gc.IsNil)
         wc.AssertNoChange()
 
         // Assign another unit and make the first Dying; check both changes detected.
         mysql1, err := mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         err = mysql1.AssignToMachine(machine)
         c.Assert(err, gc.IsNil)
         err = mysql0.Destroy()
         c.Assert(err, gc.IsNil)
         wc.AssertChange("mysql/0", "mysql/1")
         wc.AssertNoChange()
 
         // Add a subordinate to the Alive unit; no change.
         logging, err := s.State.AddService("logging", s.AddTestingCharm(c, "logging"))
         c.Assert(err, gc.IsNil)
         eps, err := s.State.InferEndpoints([]string{"mysql", "logging"})
         c.Assert(err, gc.IsNil)
         rel, err := s.State.AddRelation(eps...)
         c.Assert(err, gc.IsNil)
         mysqlru1, err := rel.Unit(mysql1)
         c.Assert(err, gc.IsNil)
         err = mysqlru1.EnterScope(nil)
         c.Assert(err, gc.IsNil)
         logging0, err := logging.Unit("logging/0")
         c.Assert(err, gc.IsNil)
         wc.AssertNoChange()
 
         // Change the subordinate; no change.
-        err = logging0.SetStatus(params.StatusStarted, "")
+        err = logging0.SetStatus(params.StatusStarted, "", nil)
         c.Assert(err, gc.IsNil)
         wc.AssertNoChange()
 
         // Make the Dying unit Dead; change detected.
         err = mysql0.EnsureDead()
         c.Assert(err, gc.IsNil)
         wc.AssertChange("mysql/0")
         wc.AssertNoChange()
 
         // Stop watcher; check Changes chan closed.
@@ skipping 55 matching lines @@
         mysql0, err := mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         machine, err := s.State.Machine(s.machine.Id())
         c.Assert(err, gc.IsNil)
         err = mysql0.AssignToMachine(machine)
         c.Assert(err, gc.IsNil)
         wc.AssertChange("mysql/0")
         wc.AssertNoChange()
 
         // Change the unit; no change.
-        err = mysql0.SetStatus(params.StatusStarted, "")
+        err = mysql0.SetStatus(params.StatusStarted, "", nil)
         c.Assert(err, gc.IsNil)
         wc.AssertNoChange()
 
         // Assign another unit and make the first Dying; check both changes detected.
         mysql1, err := mysql.AddUnit()
         c.Assert(err, gc.IsNil)
         err = mysql1.AssignToMachine(machine)
         c.Assert(err, gc.IsNil)
         err = mysql0.Destroy()
         c.Assert(err, gc.IsNil)
@@ skipping 10 matching lines @@
         mysqlru1, err := rel.Unit(mysql1)
         c.Assert(err, gc.IsNil)
         err = mysqlru1.EnterScope(nil)
         c.Assert(err, gc.IsNil)
         logging0, err := logging.Unit("logging/0")
         c.Assert(err, gc.IsNil)
         wc.AssertChange("logging/0")
         wc.AssertNoChange()
 
         // Change the subordinate; no change.
-        err = logging0.SetStatus(params.StatusStarted, "")
+        err = logging0.SetStatus(params.StatusStarted, "", nil)
         c.Assert(err, gc.IsNil)
         wc.AssertNoChange()
 
         // Make the Dying unit Dead; change detected.
         err = mysql0.EnsureDead()
         c.Assert(err, gc.IsNil)
         wc.AssertChange("mysql/0")
         wc.AssertNoChange()
 
         // Stop watcher; check Changes chan closed.
@@ skipping 120 matching lines @@
 
         err := s.machine.Remove()
         c.Assert(err, gc.IsNil)
         err = s.machine.SetConstraints(cons)
         c.Assert(err, gc.ErrorMatches, cannotSet)
         _, err = s.machine.Constraints()
         c.Assert(err, gc.ErrorMatches, `constraints not found`)
 }
 
 func (s *MachineSuite) TestGetSetStatusWhileAlive(c *gc.C) {
-        err := s.machine.SetStatus(params.StatusError, "")
+        err := s.machine.SetStatus(params.StatusError, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "error" without info`)
-        err = s.machine.SetStatus(params.StatusPending, "")
+        err = s.machine.SetStatus(params.StatusPending, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "pending"`)
-        err = s.machine.SetStatus(params.StatusDown, "")
+        err = s.machine.SetStatus(params.StatusDown, "", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status "down"`)
-        err = s.machine.SetStatus(params.Status("vliegkat"), "orville")
+        err = s.machine.SetStatus(params.Status("vliegkat"), "orville", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set invalid status "vliegkat"`)
 
         status, info, err := s.machine.Status()
         c.Assert(err, gc.IsNil)
         c.Assert(status, gc.Equals, params.StatusPending)
         c.Assert(info, gc.Equals, "")
 
-        err = s.machine.SetStatus(params.StatusStarted, "")
+        err = s.machine.SetStatus(params.StatusStarted, "", nil)
         c.Assert(err, gc.IsNil)
         status, info, err = s.machine.Status()
         c.Assert(err, gc.IsNil)
         c.Assert(status, gc.Equals, params.StatusStarted)
         c.Assert(info, gc.Equals, "")
 
-        err = s.machine.SetStatus(params.StatusError, "provisioning failed")
+        err = s.machine.SetStatus(params.StatusError, "provisioning failed", nil)
         c.Assert(err, gc.IsNil)
         status, info, err = s.machine.Status()
         c.Assert(err, gc.IsNil)
         c.Assert(status, gc.Equals, params.StatusError)
         c.Assert(info, gc.Equals, "provisioning failed")
 }
 
 func (s *MachineSuite) TestGetSetStatusWhileNotAlive(c *gc.C) {
         // When Dying set/get should work.
         err := s.machine.Destroy()
         c.Assert(err, gc.IsNil)
-        err = s.machine.SetStatus(params.StatusStopped, "")
+        err = s.machine.SetStatus(params.StatusStopped, "", nil)
         c.Assert(err, gc.IsNil)
         status, info, err := s.machine.Status()
         c.Assert(err, gc.IsNil)
         c.Assert(status, gc.Equals, params.StatusStopped)
         c.Assert(info, gc.Equals, "")
 
         // When Dead set should fail, but get will work.
         err = s.machine.EnsureDead()
         c.Assert(err, gc.IsNil)
-        err = s.machine.SetStatus(params.StatusStarted, "not really")
+        err = s.machine.SetStatus(params.StatusStarted, "not really", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status of machine "0": not found or not alive`)
         status, info, err = s.machine.Status()
         c.Assert(err, gc.IsNil)
         c.Assert(status, gc.Equals, params.StatusStopped)
         c.Assert(info, gc.Equals, "")
 
         err = s.machine.Remove()
         c.Assert(err, gc.IsNil)
-        err = s.machine.SetStatus(params.StatusStarted, "not really")
+        err = s.machine.SetStatus(params.StatusStarted, "not really", nil)
         c.Assert(err, gc.ErrorMatches, `cannot set status of machine "0": not found or not alive`)
         _, _, err = s.machine.Status()
         c.Assert(err, gc.ErrorMatches, "status not found")
 }
 
+func (s *MachineSuite) TestGetSetStatusDataStandard(c *gc.C) {
+        err := s.machine.SetStatus(params.StatusStarted, "", nil)
+        c.Assert(err, gc.IsNil)
+        _, _, err = s.machine.Status()
+        c.Assert(err, gc.IsNil)
+
+        // Regular status setting with data.
+        err = s.machine.SetStatus(params.StatusError, "provisioning failed", params.StatusData{
+                "reason":  "unknown",
+                "retries": 5,
+        })
+        c.Assert(err, gc.IsNil)
+        status, info, err := s.machine.Status()
+        c.Assert(err, gc.IsNil)
+        c.Assert(status, gc.Equals, params.StatusError)
+        c.Assert(info, gc.Equals, "provisioning failed")
+
+        data, err := state.MachineStatusData(s.machine)
+        c.Assert(err, gc.IsNil)
+        c.Assert(data["reason"], gc.Equals, "unknown")
+        c.Assert(data["retries"], gc.Equals, 5)
+}
+
+func (s *MachineSuite) TestGetSetStatusDataMongo(c *gc.C) {
+        err := s.machine.SetStatus(params.StatusStarted, "", nil)
+        c.Assert(err, gc.IsNil)
+        _, _, err = s.machine.Status()
+        c.Assert(err, gc.IsNil)
+
+        // Status setting with MongoDB special values.
+        err = s.machine.SetStatus(params.StatusError, "mongo", params.StatusData{
+                `{name: "Joe"}`: "$where",
+                "eval":          `eval(function(foo) { return foo; }, "bar")`,
+                "mapReduce":     "mapReduce",
+                "group":         "group",
+        })
+        c.Assert(err, gc.IsNil)
+        status, info, err := s.machine.Status()
+        c.Assert(err, gc.IsNil)
+        c.Assert(status, gc.Equals, params.StatusError)
+        c.Assert(info, gc.Equals, "mongo")
+
+        data, err := state.MachineStatusData(s.machine)
+        c.Assert(err, gc.IsNil)
+        c.Assert(data[`{name: "Joe"}`], gc.Equals, "$where")
+        c.Assert(data["eval"], gc.Equals, `eval(function(foo) { return foo; }, "bar")`)
+        c.Assert(data["mapReduce"], gc.Equals, "mapReduce")
+        c.Assert(data["group"], gc.Equals, "group")
+}
+
 func (s *MachineSuite) TestSetAddresses(c *gc.C) {
         machine, err := s.State.AddMachine("series", state.JobHostUnits)
         c.Assert(err, gc.IsNil)
         c.Assert(machine.Addresses(), gc.HasLen, 0)
 
         addresses := []instance.Address{
                 instance.NewAddress("127.0.0.1"),
                 instance.NewAddress("8.8.8.8"),
         }
         err = machine.SetAddresses(addresses)
         c.Assert(err, gc.IsNil)
         err = machine.Refresh()
         c.Assert(err, gc.IsNil)
         c.Assert(machine.Addresses(), gc.DeepEquals, addresses)
 }