// changed ensures that the named unit is deployed, recalled, or removed, as
// indicated by its state.
func (d *Deployer) changed(unitName string) error {
unitTag := names.NewUnitTag(unitName)
// Determine unit life state, and whether we're responsible for it.
logger.Infof("checking unit %q", unitName)
var life params.Life
unit, err := d.st.Unit(unitTag)
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
life = params.Dead
} else if err != nil {
return err
} else {
life = unit.Life()
}
// Deployed units must be removed if they're Dead, or if the deployer
// is no longer responsible for them.
if d.deployed.Contains(unitName) {
if life == params.Dead {
if err := d.recall(unitName); err != nil {
return err
}
}
}
// The only units that should be deployed are those that (1) we are responsible
// for and (2) are Alive -- if we're responsible for a Dying unit that is not
// yet deployed, we should remove it immediately rather than undergo the hassle
// of deploying a unit agent purely so it can set itself to Dead.
if !d.deployed.Contains(unitName) {
if life == params.Alive {
return d.deploy(unit)
} else if unit != nil {
return d.remove(unit)
}
}
return nil
}
func (mr *Machiner) SetUp() (watcher.NotifyWatcher, error) {
// Find which machine we're responsible for.
tag, err := names.ParseMachineTag(mr.tag)
if err != nil {
return nil, err
}
m, err := mr.st.Machine(tag)
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
return nil, worker.ErrTerminateAgent
} else if err != nil {
return nil, err
}
mr.machine = m
// Set the addresses in state to the host's addresses.
if err := setMachineAddresses(m); err != nil {
return nil, err
}
// Mark the machine as started and log it.
if err := m.SetStatus(params.StatusStarted, "", nil); err != nil {
return nil, fmt.Errorf("%s failed to set status started: %v", mr.tag, err)
}
logger.Infof("%q started", mr.tag)
return m.Watch()
}
// findUnknownInstances finds instances which are not associated with a machine.
func (task *provisionerTask) findUnknownInstances(stopping []instance.Instance) ([]instance.Instance, error) {
// Make a copy of the instances we know about.
instances := make(map[instance.Id]instance.Instance)
for k, v := range task.instances {
instances[k] = v
}
for _, m := range task.machines {
instId, err := m.InstanceId()
switch {
case err == nil:
delete(instances, instId)
case params.IsCodeNotProvisioned(err):
case params.IsCodeNotFoundOrCodeUnauthorized(err):
default:
return nil, err
}
}
// Now remove all those instances that we are stopping already as we
// know about those and don't want to include them in the unknown list.
for _, inst := range stopping {
delete(instances, inst.Id())
}
var unknown []instance.Instance
for _, inst := range instances {
unknown = append(unknown, inst)
}
return unknown, nil
}
func (task *provisionerTask) populateMachineMaps(ids []string) error {
task.instances = make(map[instance.Id]instance.Instance)
instances, err := task.broker.AllInstances()
if err != nil {
logger.Errorf("failed to get all instances from broker: %v", err)
return err
}
for _, i := range instances {
task.instances[i.Id()] = i
}
// Update the machines map with new data for each of the machines in the
// change list.
// TODO(thumper): update for API server later to get all machines in one go.
for _, id := range ids {
machineTag := names.NewMachineTag(id).String()
machine, err := task.machineGetter.Machine(machineTag)
switch {
case params.IsCodeNotFoundOrCodeUnauthorized(err):
logger.Debugf("machine %q not found in state", id)
delete(task.machines, id)
case err == nil:
task.machines[id] = machine
default:
logger.Errorf("failed to get machine: %v", err)
}
}
return nil
}
func (mr *Machiner) Handle() error {
if err := mr.machine.Refresh(); params.IsCodeNotFoundOrCodeUnauthorized(err) {
return worker.ErrTerminateAgent
} else if err != nil {
return err
}
if mr.machine.Life() == params.Alive {
return nil
}
logger.Debugf("%q is now %s", mr.tag, mr.machine.Life())
if err := mr.machine.SetStatus(params.StatusStopped, "", nil); err != nil {
return fmt.Errorf("%s failed to set status stopped: %v", mr.tag, err)
}
// If the machine is Dying, it has no units,
// and can be safely set to Dead.
if err := mr.machine.EnsureDead(); err != nil {
return fmt.Errorf("%s failed to set machine to dead: %v", mr.tag, err)
}
return worker.ErrTerminateAgent
}
func (f *filter) loop(unitTag string) (err error) {
// TODO(dfc) named return value is a time bomb
defer func() {
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
err = worker.ErrTerminateAgent
}
}()
tag, err := names.ParseUnitTag(unitTag)
if err != nil {
return err
}
if f.unit, err = f.st.Unit(tag); err != nil {
return err
}
if err = f.unitChanged(); err != nil {
return err
}
f.service, err = f.unit.Service()
if err != nil {
return err
}
if err = f.serviceChanged(); err != nil {
return err
}
unitw, err := f.unit.Watch()
if err != nil {
return err
}
defer f.maybeStopWatcher(unitw)
servicew, err := f.service.Watch()
if err != nil {
return err
}
defer f.maybeStopWatcher(servicew)
// configw and relationsw can get restarted, so we need to use
// their eventual values in the defer calls.
var configw apiwatcher.NotifyWatcher
var configChanges <-chan struct{}
curl, err := f.unit.CharmURL()
if err == nil {
configw, err = f.unit.WatchConfigSettings()
if err != nil {
return err
}
configChanges = configw.Changes()
f.upgradeFrom.url = curl
} else if err != uniter.ErrNoCharmURLSet {
filterLogger.Errorf("unit charm: %v", err)
return err
}
defer func() {
if configw != nil {
watcher.Stop(configw, &f.tomb)
}
}()
actionsw, err := f.unit.WatchActions()
if err != nil {
return err
}
f.actionsPending = make([]string, 0)
defer func() {
if actionsw != nil {
watcher.Stop(actionsw, &f.tomb)
}
}()
relationsw, err := f.service.WatchRelations()
if err != nil {
return err
}
defer func() {
if relationsw != nil {
watcher.Stop(relationsw, &f.tomb)
}
}()
var addressChanges <-chan struct{}
addressesw, err := f.unit.WatchAddresses()
if err != nil {
return err
}
defer watcher.Stop(addressesw, &f.tomb)
// Config events cannot be meaningfully discarded until one is available;
// once we receive the initial change, we unblock discard requests by
// setting this channel to its namesake on f.
var discardConfig chan struct{}
for {
var ok bool
select {
case <-f.tomb.Dying():
return tomb.ErrDying
// Handle watcher changes.
case _, ok = <-unitw.Changes():
filterLogger.Debugf("got unit change")
if !ok {
return watcher.MustErr(unitw)
}
if err = f.unitChanged(); err != nil {
return err
}
case _, ok = <-servicew.Changes():
filterLogger.Debugf("got service change")
if !ok {
return watcher.MustErr(servicew)
}
if err = f.serviceChanged(); err != nil {
return err
}
case _, ok = <-configChanges:
filterLogger.Debugf("got config change")
if !ok {
return watcher.MustErr(configw)
}
if addressChanges == nil {
// We start reacting to address changes after the
// first config-changed is processed, ignoring the
// initial address changed event.
addressChanges = addressesw.Changes()
if _, ok := <-addressChanges; !ok {
return watcher.MustErr(addressesw)
}
}
filterLogger.Debugf("preparing new config event")
f.outConfig = f.outConfigOn
discardConfig = f.discardConfig
case _, ok = <-addressChanges:
filterLogger.Debugf("got address change")
if !ok {
return watcher.MustErr(addressesw)
}
// address change causes config-changed event
filterLogger.Debugf("preparing new config event")
f.outConfig = f.outConfigOn
case ids, ok := <-actionsw.Changes():
filterLogger.Debugf("got %d actions", len(ids))
if !ok {
return watcher.MustErr(actionsw)
}
f.actionsPending = append(f.actionsPending, ids...)
f.nextAction = f.getNextAction()
case keys, ok := <-relationsw.Changes():
filterLogger.Debugf("got relations change")
if !ok {
return watcher.MustErr(relationsw)
}
var ids []int
for _, key := range keys {
relationTag := names.NewRelationTag(key).String()
rel, err := f.st.Relation(relationTag)
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
// If it's actually gone, this unit cannot have entered
// scope, and therefore never needs to know about it.
} else if err != nil {
return err
} else {
ids = append(ids, rel.Id())
}
}
f.relationsChanged(ids)
// Send events on active out chans.
case f.outUpgrade <- f.upgrade:
filterLogger.Debugf("sent upgrade event")
f.outUpgrade = nil
case f.outResolved <- f.resolved:
filterLogger.Debugf("sent resolved event")
f.outResolved = nil
case f.outConfig <- nothing:
filterLogger.Debugf("sent config event")
f.outConfig = nil
case f.outAction <- f.nextAction:
f.nextAction = f.getNextAction()
filterLogger.Debugf("sent action event")
case f.outRelations <- f.relations:
filterLogger.Debugf("sent relations event")
f.outRelations = nil
f.relations = nil
// Handle explicit requests.
case curl := <-f.setCharm:
filterLogger.Debugf("changing charm to %q", curl)
// We need to restart the config watcher after setting the
// charm, because service config settings are distinct for
// different service charms.
if configw != nil {
if err := configw.Stop(); err != nil {
return err
}
}
if err := f.unit.SetCharmURL(curl); err != nil {
filterLogger.Debugf("failed setting charm url %q: %v", curl, err)
return err
}
select {
case <-f.tomb.Dying():
return tomb.ErrDying
case f.didSetCharm <- nothing:
}
configw, err = f.unit.WatchConfigSettings()
if err != nil {
return err
}
configChanges = configw.Changes()
// Restart the relations watcher.
if err := relationsw.Stop(); err != nil {
return err
}
relationsw, err = f.service.WatchRelations()
if err != nil {
return err
}
f.upgradeFrom.url = curl
if err = f.upgradeChanged(); err != nil {
return err
}
case force := <-f.wantForcedUpgrade:
filterLogger.Debugf("want forced upgrade %v", force)
f.upgradeFrom.force = force
if err = f.upgradeChanged(); err != nil {
return err
}
case <-f.wantResolved:
filterLogger.Debugf("want resolved event")
if f.resolved != params.ResolvedNone {
f.outResolved = f.outResolvedOn
}
case <-f.clearResolved:
filterLogger.Debugf("resolved event handled")
f.outResolved = nil
if err := f.unit.ClearResolved(); err != nil {
return err
}
if err := f.unitChanged(); err != nil {
return err
}
select {
case <-f.tomb.Dying():
return tomb.ErrDying
case f.didClearResolved <- nothing:
}
case <-discardConfig:
filterLogger.Debugf("discarded config event")
f.outConfig = nil
}
}
}
// updateRelations responds to changes in the life states of the relations
// with the supplied ids. If any id corresponds to an alive relation not
// known to the unit, the uniter will join that relation and return its
// relationer in the added list.
func (u *Uniter) updateRelations(ids []int) (added []*Relationer, err error) {
for _, id := range ids {
if r, found := u.relationers[id]; found {
rel := r.ru.Relation()
if err := rel.Refresh(); err != nil {
return nil, fmt.Errorf("cannot update relation %q: %v", rel, err)
}
if rel.Life() == params.Dying {
if err := r.SetDying(); err != nil {
return nil, err
} else if r.IsImplicit() {
delete(u.relationers, id)
}
}
continue
}
// Relations that are not alive are simply skipped, because they
// were not previously known anyway.
rel, err := u.st.RelationById(id)
if err != nil {
if params.IsCodeNotFoundOrCodeUnauthorized(err) {
continue
}
return nil, err
}
if rel.Life() != params.Alive {
continue
}
// Make sure we ignore relations not implemented by the unit's charm.
ch, err := corecharm.ReadDir(u.charmPath)
if err != nil {
return nil, err
}
if ep, err := rel.Endpoint(); err != nil {
return nil, err
} else if !ep.ImplementedBy(ch) {
logger.Warningf("skipping relation with unknown endpoint %q", ep.Name)
continue
}
dir, err := relation.ReadStateDir(u.relationsDir, id)
if err != nil {
return nil, err
}
err = u.addRelation(rel, dir)
if err == nil {
added = append(added, u.relationers[id])
continue
}
e := dir.Remove()
if !params.IsCodeCannotEnterScope(err) {
return nil, err
}
if e != nil {
return nil, e
}
}
if ok, err := u.unit.IsPrincipal(); err != nil {
return nil, err
} else if ok {
return added, nil
}
// If no Alive relations remain between a subordinate unit's service
// and its principal's service, the subordinate must become Dying.
keepAlive := false
for _, r := range u.relationers {
scope := r.ru.Endpoint().Scope
if scope == corecharm.ScopeContainer && !r.dying {
keepAlive = true
break
}
}
if !keepAlive {
if err := u.unit.Destroy(); err != nil {
return nil, err
}
}
return added, nil
}
