func (s *environSuite) TestEnvironmentChanges(c *gc.C) {
originalConfig, err := s.State.EnvironConfig()
c.Assert(err, gc.IsNil)
logc := make(logChan, 1009)
c.Assert(loggo.RegisterWriter("testing", logc, loggo.WARNING), gc.IsNil)
defer loggo.RemoveWriter("testing")
obs, err := worker.NewEnvironObserver(s.State)
c.Assert(err, gc.IsNil)
env := obs.Environ()
c.Assert(env.Config().AllAttrs(), gc.DeepEquals, originalConfig.AllAttrs())
var oldType string
oldType = env.Config().AllAttrs()["type"].(string)
info := s.StateInfo(c)
opts := state.DefaultDialOpts()
st2, err := state.Open(info, opts, state.Policy(nil))
defer st2.Close()
// Change to an invalid configuration and check
// that the observer's environment remains the same.
st2.UpdateEnvironConfig(map[string]interface{}{"type": "invalid"}, nil, nil)
st2.StartSync()
// Wait for the observer to register the invalid environment
timeout := time.After(coretesting.LongWait)
loop:
for {
select {
case msg := <-logc:
if strings.Contains(msg, "error creating Environ") {
break loop
}
case <-timeout:
c.Fatalf("timed out waiting to see broken environment")
}
}
// Check that the returned environ is still the same.
env = obs.Environ()
c.Assert(env.Config().AllAttrs(), gc.DeepEquals, originalConfig.AllAttrs())
// Change the environment back to a valid configuration
// with a different name and check that we see it.
st2.UpdateEnvironConfig(map[string]interface{}{"type": oldType, "name": "a-new-name"}, nil, nil)
st2.StartSync()
for a := coretesting.LongAttempt.Start(); a.Next(); {
env := obs.Environ()
if !a.HasNext() {
c.Fatalf("timed out waiting for new environ")
}
if env.Config().Name() == "a-new-name" {
break
}
}
}
func (s *environSuite) TestErrorWhenEnvironIsInvalid(c *gc.C) {
// reopen the state so that we can wangle a dodgy environ config in there.
st, err := state.Open(s.StateInfo(c), state.DefaultDialOpts(), state.Policy(nil))
c.Assert(err, gc.IsNil)
defer st.Close()
err = st.UpdateEnvironConfig(map[string]interface{}{"secret": 999}, nil, nil)
c.Assert(err, gc.IsNil)
obs, err := worker.NewEnvironObserver(s.State)
c.Assert(err, gc.ErrorMatches, `cannot make Environ: secret: expected string, got int\(999\)`)
c.Assert(obs, gc.IsNil)
}
func (u *updaterWorker) loop() (err error) {
u.observer, err = worker.NewEnvironObserver(u.st)
if err != nil {
return err
}
u.aggregator = newAggregator(u.observer.Environ())
logger.Infof("instance poller received inital environment configuration")
defer func() {
obsErr := worker.Stop(u.observer)
if err == nil {
err = obsErr
}
}()
return watchMachinesLoop(u, u.st.WatchEnvironMachines())
}