Golang NewWatcher示例

示例#1

文件： state.go 项目： jkary/core

func (st *State) Watch() *multiwatcher.Watcher {
	st.mu.Lock()
	if st.allManager == nil {
		st.allManager = multiwatcher.NewStoreManager(newAllWatcherStateBacking(st))
	}
	st.mu.Unlock()
	return multiwatcher.NewWatcher(st.allManager)
}

示例#2

文件： megawatcher_internal_test.go 项目： jkary/core

// TestStateWatcher tests the integration of the state watcher
// with the state-based backing. Most of the logic is tested elsewhere -
// this just tests end-to-end.
func (s *storeManagerStateSuite) TestStateWatcher(c *gc.C) {
	m0, err := s.State.AddMachine("quantal", JobManageEnviron)
	c.Assert(err, gc.IsNil)
	c.Assert(m0.Id(), gc.Equals, "0")

	m1, err := s.State.AddMachine("saucy", JobHostUnits)
	c.Assert(err, gc.IsNil)
	c.Assert(m1.Id(), gc.Equals, "1")

	b := newAllWatcherStateBacking(s.State)
	aw := multiwatcher.NewStoreManager(b)
	defer aw.Stop()
	w := multiwatcher.NewWatcher(aw)
	s.State.StartSync()
	checkNext(c, w, b, []params.Delta{{
		Entity: &params.MachineInfo{
			Id:        "0",
			Status:    params.StatusPending,
			Life:      params.Alive,
			Series:    "quantal",
			Jobs:      []params.MachineJob{JobManageEnviron.ToParams()},
			Addresses: []instance.Address{},
		},
	}, {
		Entity: &params.MachineInfo{
			Id:        "1",
			Status:    params.StatusPending,
			Life:      params.Alive,
			Series:    "saucy",
			Jobs:      []params.MachineJob{JobHostUnits.ToParams()},
			Addresses: []instance.Address{},
		},
	}}, "")

	// Make some changes to the state.
	arch := "amd64"
	mem := uint64(4096)
	hc := &instance.HardwareCharacteristics{
		Arch: &arch,
		Mem:  &mem,
	}
	err = m0.SetProvisioned("i-0", "bootstrap_nonce", hc)
	c.Assert(err, gc.IsNil)
	err = m1.Destroy()
	c.Assert(err, gc.IsNil)
	err = m1.EnsureDead()
	c.Assert(err, gc.IsNil)
	err = m1.Remove()
	c.Assert(err, gc.IsNil)
	m2, err := s.State.AddMachine("trusty", JobHostUnits)
	c.Assert(err, gc.IsNil)
	c.Assert(m2.Id(), gc.Equals, "2")
	s.State.StartSync()

	// Check that we see the changes happen within a
	// reasonable time.
	var deltas []params.Delta
	for {
		d, err := getNext(c, w, 100*time.Millisecond)
		if err == errTimeout {
			break
		}
		c.Assert(err, gc.IsNil)
		deltas = append(deltas, d...)
	}
	checkDeltasEqual(c, b, deltas, []params.Delta{{
		Removed: true,
		Entity: &params.MachineInfo{
			Id:        "1",
			Status:    params.StatusPending,
			Life:      params.Alive,
			Series:    "saucy",
			Jobs:      []params.MachineJob{JobHostUnits.ToParams()},
			Addresses: []instance.Address{},
		},
	}, {
		Entity: &params.MachineInfo{
			Id:        "2",
			Status:    params.StatusPending,
			Life:      params.Alive,
			Series:    "trusty",
			Jobs:      []params.MachineJob{JobHostUnits.ToParams()},
			Addresses: []instance.Address{},
		},
	}, {
		Entity: &params.MachineInfo{
			Id:                      "0",
			InstanceId:              "i-0",
			Status:                  params.StatusPending,
			Life:                    params.Alive,
			Series:                  "quantal",
			Jobs:                    []params.MachineJob{JobManageEnviron.ToParams()},
			Addresses:               []instance.Address{},
			HardwareCharacteristics: hc,
		},
	}})

	err = w.Stop()
	c.Assert(err, gc.IsNil)

	_, err = w.Next()
	c.Assert(err, gc.Equals, multiwatcher.ErrWatcherStopped)
}