func (p *Provisioner) loop() error {
environWatcher := p.st.WatchEnvironConfig()
defer watcher.Stop(environWatcher, &p.tomb)
var err error
p.environ, err = worker.WaitForEnviron(environWatcher, p.tomb.Dying())
if err != nil {
return err
}
auth, err := NewSimpleAuthenticator(p.environ)
if err != nil {
return err
}
// Start a new worker for the environment provider.
// Start responding to changes in machines, and to any further updates
// to the environment config.
instanceBroker, err := p.getBroker()
if err != nil {
return err
}
machineWatcher, err := p.getWatcher()
if err != nil {
return err
}
environmentProvisioner := NewProvisionerTask(
p.machineId,
p.st,
machineWatcher,
instanceBroker,
auth)
defer watcher.Stop(environmentProvisioner, &p.tomb)
for {
select {
case <-p.tomb.Dying():
return tomb.ErrDying
case <-environmentProvisioner.Dying():
err := environmentProvisioner.Err()
logger.Errorf("environment provisioner died: %v", err)
return err
case cfg, ok := <-environWatcher.Changes():
if !ok {
return watcher.MustErr(environWatcher)
}
if err := p.setConfig(cfg); err != nil {
logger.Errorf("loaded invalid environment configuration: %v", err)
}
}
}
panic("not reached")
}
func (s *suite) TestStop(c *C) {
w := s.State.WatchEnvironConfig()
defer stopWatcher(c, w)
stop := make(chan struct{})
done := make(chan error)
go func() {
env, err := worker.WaitForEnviron(w, stop)
c.Check(env, IsNil)
done <- err
}()
close(stop)
c.Assert(<-done, Equals, tomb.ErrDying)
}
func (p *Provisioner) loop() error {
environWatcher := p.st.WatchEnvironConfig()
defer watcher.Stop(environWatcher, &p.tomb)
var err error
p.environ, err = worker.WaitForEnviron(environWatcher, p.tomb.Dying())
if err != nil {
return err
}
// Get a new StateInfo from the environment: the one used to
// launch the agent may refer to localhost, which will be
// unhelpful when attempting to run an agent on a new machine.
if p.stateInfo, p.apiInfo, err = p.environ.StateInfo(); err != nil {
return err
}
// Call processMachines to stop any unknown instances before watching machines.
if err := p.processMachines(nil); err != nil {
return err
}
// Start responding to changes in machines, and to any further updates
// to the environment config.
machinesWatcher := p.st.WatchMachines()
defer watcher.Stop(machinesWatcher, &p.tomb)
// START OMIT
// launchpad.net/juju-core/worker/provisioner/provisioner.go
for {
select {
case <-p.tomb.Dying():
return tomb.ErrDying
case cfg, ok := <-environWatcher.Changes():
if !ok {
return watcher.MustErr(environWatcher)
}
if err := p.setConfig(cfg); err != nil {
log.Errorf("worker/provisioner: loaded invalid environment configuration: %v", err)
}
case ids, ok := <-machinesWatcher.Changes():
if !ok {
return watcher.MustErr(machinesWatcher)
}
if err := p.processMachines(ids); err != nil {
return err
}
}
}
// END OMIT
panic("not reached")
}
func (s *suite) TestInvalidConfig(c *C) {
// Create an invalid config by taking the current config and
// tweaking the provider type.
cfg, err := s.State.EnvironConfig()
c.Assert(err, IsNil)
m := cfg.AllAttrs()
m["type"] = "unknown"
invalidCfg, err := config.New(m)
c.Assert(err, IsNil)
err = s.State.SetEnvironConfig(invalidCfg)
c.Assert(err, IsNil)
w := s.State.WatchEnvironConfig()
defer stopWatcher(c, w)
done := make(chan environs.Environ)
go func() {
env, err := worker.WaitForEnviron(w, nil)
c.Check(err, IsNil)
done <- env
}()
// Wait for the loop to process the invalid configuratrion
<-worker.LoadedInvalid
// Then load a valid configuration back in.
m = cfg.AllAttrs()
m["secret"] = "environ_test"
validCfg, err := config.New(m)
c.Assert(err, IsNil)
err = s.State.SetEnvironConfig(validCfg)
c.Assert(err, IsNil)
s.State.StartSync()
env := <-done
c.Assert(env, NotNil)
c.Assert(env.Config().AllAttrs()["secret"], Equals, "environ_test")
}
func (fw *Firewaller) loop() error {
defer fw.stopWatchers()
var err error
var reconciled bool
fw.environ, err = worker.WaitForEnviron(fw.environWatcher, fw.tomb.Dying())
if err != nil {
return err
}
if fw.environ.Config().FirewallMode() == config.FwGlobal {
fw.globalMode = true
fw.globalPortRef = make(map[instance.Port]int)
}
for {
select {
case <-fw.tomb.Dying():
return tomb.ErrDying
case change, ok := <-fw.environWatcher.Changes():
if !ok {
return watcher.MustErr(fw.environWatcher)
}
if err := fw.environ.SetConfig(change); err != nil {
log.Errorf("worker/firewaller: loaded invalid environment configuration: %v", err)
}
case change, ok := <-fw.machinesWatcher.Changes():
if !ok {
return watcher.MustErr(fw.machinesWatcher)
}
for _, id := range change {
fw.machineLifeChanged(id)
}
if !reconciled {
reconciled = true
var err error
if fw.globalMode {
err = fw.reconcileGlobal()
} else {
err = fw.reconcileInstances()
}
if err != nil {
return err
}
}
case change := <-fw.unitsChange:
if err := fw.unitsChanged(change); err != nil {
return err
}
case change := <-fw.portsChange:
change.unitd.ports = change.ports
if err := fw.flushUnits([]*unitData{change.unitd}); err != nil {
return fmt.Errorf("cannot change firewall ports: %v", err)
}
case change := <-fw.exposedChange:
change.serviced.exposed = change.exposed
unitds := []*unitData{}
for _, unitd := range change.serviced.unitds {
unitds = append(unitds, unitd)
}
if err := fw.flushUnits(unitds); err != nil {
return fmt.Errorf("cannot change firewall ports: %v", err)
}
}
}
}