cmd/jujud: provisioning agent woodenman

cmd/jujud/provisioning_test.go

 package main
 
 import (
+        "time"
+
         . "launchpad.net/gocheck"
         "launchpad.net/gozk/zookeeper"
         "launchpad.net/juju-core/juju/cmd"
         "launchpad.net/juju-core/juju/environs/dummy"
         "launchpad.net/juju-core/juju/state"
         "launchpad.net/juju-core/juju/testing"
 )
 
 type ProvisioningSuite struct {
         zkConn *zookeeper.Conn
+        zkInfo *state.Info
         st     *state.State
 }
 
 var _ = Suite(&ProvisioningSuite{})
 
 func (s *ProvisioningSuite) SetUpTest(c *C) {
         zk, session, err := zookeeper.Dial(zkAddr, 15e9)
         c.Assert(err, IsNil)
         event := <-session
         c.Assert(event.Ok(), Equals, true)
         c.Assert(event.Type, Equals, zookeeper.EVENT_SESSION)
         c.Assert(event.State, Equals, zookeeper.STATE_CONNECTED)
 
         s.zkConn = zk
-        info := &state.Info{
+        s.zkInfo = &state.Info{
                 Addrs: []string{zkAddr},
         }
-        testing.ZkRemoveTree(s.zkConn, "/")
-        s.st, err = state.Initialize(info)
+        s.st, err = state.Initialize(s.zkInfo)
         c.Assert(err, IsNil)
 
         dummy.Reset()
+
+        // seed /environment to point to dummy
+        env, err := s.st.EnvironConfig()
+        c.Assert(err, IsNil)
+        env.Set("type", "dummy")
+        env.Set("zookeeper", false)
+        env.Set("name", "testing")
+        _, err = env.Write()
+        c.Assert(err, IsNil)
 }
 
 func (s *ProvisioningSuite) TearDownTest(c *C) {
+        testing.ZkRemoveTree(s.zkConn, "/")
         s.zkConn.Close()
 }
 
 func (s *ProvisioningSuite) TestParseSuccess(c *C) {
         create := func() (cmd.Command, *AgentConf) {
                 a := &ProvisioningAgent{}
                 return a, &a.Conf
         }
         CheckAgentCommand(c, create, []string{})
 }
 
 func (s *ProvisioningSuite) TestParseUnknown(c *C) {
         a := &ProvisioningAgent{}
         err := ParseAgentCommand(a, []string{"nincompoops"})
         c.Assert(err, ErrorMatches, `unrecognized args: \["nincompoops"\]`)
 }
 
 func initProvisioningAgent() (*ProvisioningAgent, error) {
         args := []string{"--zookeeper-servers", zkAddr}
         c := &ProvisioningAgent{}
         return c, initCmd(c, args)
 }
 
 func (s *ProvisioningSuite) TestProvisionerStartStop(c *C) {
-        p := NewProvisioner(s.st)
+        p := NewProvisioner(s.st, s.zkInfo)
         c.Assert(p.Stop(), IsNil)
 }
 
 func (s *ProvisioningSuite) TestProvisionerEnvironmentChange(c *C) {
-        p := NewProvisioner(s.st)
+        p := NewProvisioner(s.st, s.zkInfo)
 
-        // Change environment configuration to point to dummy.
+        // twiddle with the environment
         env, err := s.st.EnvironConfig()
         c.Assert(err, IsNil)
-        env.Set("type", "dummy")
-        env.Set("zookeeper", false)
-        env.Set("name", "testing")
-        _, err = env.Write()
-        c.Assert(err, IsNil)
-
-        // Twiddle with the environment configuration.
-        env, err = s.st.EnvironConfig()
-        c.Assert(err, IsNil)
         env.Set("name", "testing2")
         _, err = env.Write()
         c.Assert(err, IsNil)
         env.Set("name", "testing3")
         _, err = env.Write()
         c.Assert(p.Stop(), IsNil)
 }
 
 func (s *ProvisioningSuite) TestProvisionerStopOnStateClose(c *C) {
-        p := NewProvisioner(s.st)
-
-        // Change environment configuration to point to dummy.
-        env, err := s.st.EnvironConfig()
-        c.Assert(err, IsNil)
-        env.Set("type", "dummy")
-        env.Set("zookeeper", false)
-        env.Set("name", "testing")
-        _, err = env.Write()
-        c.Assert(err, IsNil)
+        p := NewProvisioner(s.st, s.zkInfo)
 
         s.st.Close()
 
         c.Assert(p.Wait(), ErrorMatches, "watcher.*")
         c.Assert(p.Stop(), ErrorMatches, "watcher.*")
-
-}
+}
+
+// Start and stop one machine, watch the PA.
+func (s *ProvisioningSuite) TestSimple(c *C) {
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // place a new machine into the state
+        m, err := s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // now remove it
+        c.Assert(s.st.RemoveMachine(m.Id()), IsNil)
+
+        // watch the PA remove it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStopInstances)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action RemoveMachine after 3 second")
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+func (s *ProvisioningSuite) TestProvisioningDoesNotOccurWithAnInvalidEnvironment(c *C) {
+        // make the environment unpalitable to the config checker
+        env, err := s.st.EnvironConfig()
+        c.Assert(err, IsNil)
+        env.Set("name", 1)
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // try to create a machine
+        _, err = s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should not create it
+        select {
+        case <-op:
+                c.Fatalf("provisioner started an instance")
+        case <-time.After(1 * time.Second):
+
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+func (s *ProvisioningSuite) TestProvisioningOccursWithFixedEnvironment(c *C) {
+        // make the environment unpalitable to the config checker
+        env, err := s.st.EnvironConfig()
+        c.Assert(err, IsNil)
+        env.Set("name", 1)
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // try to create a machine
+        _, err = s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should not create it
+        select {
+        case <-op:
+                c.Fatalf("provisioner started an instance")
+        case <-time.After(1 * time.Second):
+
+        }
+
+        // now fix the environment
+        env.Set("name", "testing")
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+func (s *ProvisioningSuite) TestProvisioningDoesOccurAfterInvalidEnvironmentPublished(c *C) {
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // place a new machine into the state
+        _, err := s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // make the environment unpalitable to the config checker
+        env, err := s.st.EnvironConfig()
+        c.Assert(err, IsNil)
+        env.Set("name", 1)
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        // create a second machine
+        _, err = s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should create it using the old environment
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+func (s *ProvisioningSuite) TestProvisioningDoesNotProvisionTheSameMachineAfterRestart(c *C) {
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // create a machine
+        _, err := s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // restart the PA
+        c.Assert(p.Stop(), IsNil)
+        p = NewProvisioner(s.st, s.zkInfo)
+
+        // the PA should not create it a second time
+        select {
+        case <-op:
+                c.Fatalf("provisioner started an instance")
+        case <-time.After(1 * time.Second):
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+// TODO(dfc) machines removed from the state while the PA isn't watching are not shut down.
+func (s *ProvisioningSuite) disabledTestProvisioningRemovesUnknownMachineAfterRestart(c *C) {
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // create a machine
+        m, err := s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // stop the PA
+        c.Assert(p.Stop(), IsNil)
+
+        // remove the machine from the topology
+        err = s.st.RemoveMachine(m.Id())
+        c.Assert(err, IsNil)
+
+        // start a new PA ······
+        p = NewProvisioner(s.st, s.zkInfo)
+
+        // the PA should remove this machine
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStopInstances)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action RemoveMachine after 3 second")
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+func (s *ProvisioningSuite) TestProvisioningRecoversAfterInvalidEnvironmentPublished(c *C) {
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        // place a new machine into the state
+        _, err := s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // make the environment unpalitable to the config checker
+        env, err := s.st.EnvironConfig()
+        c.Assert(err, IsNil)
+        env.Set("name", 1)
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        // create a second machine
+        _, err = s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should create it using the old environment
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        // now fix the environment
+        env.Set("name", "testing")
+        _, err = env.Write()
+        c.Assert(err, IsNil)
+
+        // create a third machine
+        _, err = s.st.AddMachine()
+        c.Assert(err, IsNil)
+
+        // the PA should create it using the new environment
+        // watch the PA create it
+        select {
+        case o := <-op:
+                c.Assert(o.Kind, Equals, dummy.OpStartInstance)
+        case <-time.After(3 * time.Second):
+                c.Fatalf("ProvisioningAgent did not action AddMachine after 3 second")
+        }
+
+        c.Assert(p.Stop(), IsNil)
+}
+
+// Start and stop lots of machines, watch the PA.
+func (s *ProvisioningSuite) TestHard(c *C) {
+        var N = 200
+
+        p := NewProvisioner(s.st, s.zkInfo)
+
+        op := make(chan dummy.Operation, 1)
+        dummy.Listen(op)
+
+        go func() {
+                for i := 0; i < N; i++ {
+                        m, err := s.st.AddMachine()
+                        <-time.After(20 * time.Millisecond)
+                        c.Assert(err, IsNil)
+                        c.Logf("added machine: %d", m.Id())
+                        go func() {
+                                err := s.st.RemoveMachine(m.Id())
+                                c.Assert(err, IsNil)
+                                c.Logf("removed machine: %d", m.Id())
+                        }()
+                }
+        }()
+
+        var started, stopped int
+
+        for stopped < N {
+                select {
+                case o := <-op:
+                        switch o.Kind {
+                        case dummy.OpStartInstance:
+                                started++
+                        case dummy.OpStopInstances:
+                                stopped++
+                        default:
+                                c.Fatalf("dummy reported unknown operation: %v", o)
+                        }
+                case <-time.After(10 * time.Second):
+                        c.Fatalf("PA stalled")
+                }
+        }
+
+        c.Assert(started, Equals, N)
+        c.Assert(stopped, Equals, N)
+
+        c.Assert(p.Stop(), IsNil)
+}