func (d expect) check(c *C, in chan state.RelationUnitsChange, out chan hook.Info) { if d.hook == "" { select { case unexpected := <-out: c.Fatalf("got %#v", unexpected) case <-time.After(coretesting.ShortWait): } return } expect := hook.Info{ Kind: d.hook, RelationId: 21345, RemoteUnit: d.unit, ChangeVersion: d.version, } if d.members != nil { expect.Members = map[string]map[string]interface{}{} for name, version := range d.members { expect.Members[name] = settings(name, version) } } select { case actual := <-out: c.Assert(actual, DeepEquals, expect) case <-time.After(coretesting.LongWait): c.Fatalf("timed out waiting for %#v", expect) } }
// runHook executes the supplied hook.Info in an appropriate hook context. If // the hook itself fails to execute, it returns errHookFailed. func (u *Uniter) runHook(hi hook.Info) (err error) { // Prepare context. if err = hi.Validate(); err != nil { return err } hookName := string(hi.Kind) relationId := -1 if hi.Kind.IsRelation() { relationId = hi.RelationId if hookName, err = u.relationers[relationId].PrepareHook(hi); err != nil { return err } } hctxId := fmt.Sprintf("%s:%s:%d", u.unit.Name(), hookName, u.rand.Int63()) hctx := &HookContext{ service: u.service, unit: u.unit, id: hctxId, relationId: relationId, remoteUnitName: hi.RemoteUnit, relations: map[int]*ContextRelation{}, } for id, r := range u.relationers { hctx.relations[id] = r.Context() } // Prepare server. getCmd := func(ctxId, cmdName string) (cmd.Command, error) { // TODO: switch to long-running server with single context; // use nonce in place of context id. if ctxId != hctxId { return nil, fmt.Errorf("expected context id %q, got %q", hctxId, ctxId) } return jujuc.NewCommand(hctx, cmdName) } socketPath := filepath.Join(u.baseDir, "agent.socket") srv, err := jujuc.NewServer(getCmd, socketPath) if err != nil { return err } go srv.Run() defer srv.Close() // Run the hook. if err := u.writeState(RunHook, Pending, &hi, nil); err != nil { return err } log.Printf("worker/uniter: running %q hook", hookName) if err := hctx.RunHook(hookName, u.charm.Path(), u.toolsDir, socketPath); err != nil { log.Printf("worker/uniter: hook failed: %s", err) return errHookFailed } if err := u.writeState(RunHook, Done, &hi, nil); err != nil { return err } log.Printf("worker/uniter: ran %q hook", hookName) return u.commitHook(hi) }
// deploy deploys the supplied charm, and sets follow-up hook operation state // as indicated by reason. func (u *Uniter) deploy(sch *state.Charm, reason Op) error { if reason != Install && reason != Upgrade { panic(fmt.Errorf("%q is not a deploy operation", reason)) } var hi *hook.Info if u.s != nil && (u.s.Op == RunHook || u.s.Op == Upgrade) { // If this upgrade interrupts a RunHook, we need to preserve the hook // info so that we can return to the appropriate error state. However, // if we're resuming (or have force-interrupted) an Upgrade, we also // need to preserve whatever hook info was preserved when we initially // started upgrading, to ensure we still return to the correct state. hi = u.s.Hook } url := sch.URL() if u.s == nil || u.s.OpStep != Done { log.Printf("worker/uniter: fetching charm %q", url) bun, err := u.bundles.Read(sch, u.tomb.Dying()) if err != nil { return err } if err = u.deployer.Stage(bun, url); err != nil { return err } log.Printf("worker/uniter: deploying charm %q", url) if err = u.writeState(reason, Pending, hi, url); err != nil { return err } if err = u.deployer.Deploy(u.charm); err != nil { return err } if err = u.writeState(reason, Done, hi, url); err != nil { return err } } log.Printf("worker/uniter: charm %q is deployed", url) if err := u.unit.SetCharm(sch); err != nil { return err } status := Queued if hi != nil { // If a hook operation was interrupted, restore it. status = Pending } else { // Otherwise, queue the relevant post-deploy hook. hi = &hook.Info{} switch reason { case Install: hi.Kind = hook.Install case Upgrade: hi.Kind = hook.UpgradeCharm } } return u.writeState(RunHook, status, hi, nil) }
func (s *RelationerSuite) assertHook(c *C, expect hook.Info) { s.State.StartSync() select { case hi, ok := <-s.hooks: c.Assert(ok, Equals, true) expect.ChangeVersion = hi.ChangeVersion c.Assert(hi, DeepEquals, expect) c.Assert(s.dir.Write(hi), Equals, nil) case <-time.After(500 * time.Millisecond): c.Fatalf("timed out waiting for %#v", expect) } }
func (s *RelationerSuite) assertHook(c *C, expect hook.Info) { s.State.StartSync() // We must ensure the local state dir exists first. c.Assert(s.dir.Ensure(), IsNil) select { case hi, ok := <-s.hooks: c.Assert(ok, Equals, true) expect.ChangeVersion = hi.ChangeVersion c.Assert(hi, DeepEquals, expect) c.Assert(s.dir.Write(hi), Equals, nil) case <-time.After(coretesting.LongWait): c.Fatalf("timed out waiting for %#v", expect) } }
func (s *RelationerSuite) TestPrepareCommitHooks(c *C) { r := uniter.NewRelationer(s.ru, s.dir, s.hooks) err := r.Join() c.Assert(err, IsNil) ctx := r.Context() c.Assert(ctx.UnitNames(), HasLen, 0) // Check preparing an invalid hook changes nothing. changed := hook.Info{ Kind: hook.RelationChanged, RemoteUnit: "u/1", ChangeVersion: 7, Members: map[string]map[string]interface{}{ "u/1": {"private-address": "glastonbury"}, }, } _, err = r.PrepareHook(changed) c.Assert(err, ErrorMatches, `inappropriate "relation-changed" for "u/1": unit has not joined`) c.Assert(ctx.UnitNames(), HasLen, 0) c.Assert(s.dir.State().Members, HasLen, 0) // Check preparing a valid hook updates the context, but not persistent // relation state. joined := hook.Info{ Kind: hook.RelationJoined, RemoteUnit: "u/1", Members: map[string]map[string]interface{}{ "u/1": {"private-address": "u-1.example.com"}, }, } name, err := r.PrepareHook(joined) c.Assert(err, IsNil) c.Assert(s.dir.State().Members, HasLen, 0) c.Assert(name, Equals, "my-relation-relation-joined") c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1"}) s1, err := ctx.ReadSettings("u/1") c.Assert(err, IsNil) c.Assert(s1, DeepEquals, joined.Members["u/1"]) // Clear the changed hook's Members, as though it had been deserialized. changed.Members = nil // Check that preparing the following hook fails as before... _, err = r.PrepareHook(changed) c.Assert(err, ErrorMatches, `inappropriate "relation-changed" for "u/1": unit has not joined`) c.Assert(s.dir.State().Members, HasLen, 0) c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1"}) s1, err = ctx.ReadSettings("u/1") c.Assert(err, IsNil) c.Assert(s1, DeepEquals, joined.Members["u/1"]) // ...but that committing the previous hook updates the persistent // relation state... err = r.CommitHook(joined) c.Assert(err, IsNil) c.Assert(s.dir.State().Members, DeepEquals, map[string]int64{"u/1": 0}) c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1"}) s1, err = ctx.ReadSettings("u/1") c.Assert(err, IsNil) c.Assert(s1, DeepEquals, joined.Members["u/1"]) // ...and allows us to prepare the next hook... name, err = r.PrepareHook(changed) c.Assert(err, IsNil) c.Assert(name, Equals, "my-relation-relation-changed") c.Assert(s.dir.State().Members, DeepEquals, map[string]int64{"u/1": 0}) c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1"}) s1, err = ctx.ReadSettings("u/1") c.Assert(err, IsNil) c.Assert(s1, DeepEquals, map[string]interface{}{"private-address": "u-1.example.com"}) // ...and commit it. err = r.CommitHook(changed) c.Assert(err, IsNil) c.Assert(s.dir.State().Members, DeepEquals, map[string]int64{"u/1": 7}) c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1"}) // To verify implied behaviour above, prepare a new joined hook with // missing membership information, and check relation context // membership is updated appropriately... joined.RemoteUnit = "u/2" joined.ChangeVersion = 3 joined.Members = nil name, err = r.PrepareHook(joined) c.Assert(err, IsNil) c.Assert(s.dir.State().Members, HasLen, 1) c.Assert(name, Equals, "my-relation-relation-joined") c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1", "u/2"}) // ...and so is relation state on commit. err = r.CommitHook(joined) c.Assert(err, IsNil) c.Assert(s.dir.State().Members, DeepEquals, map[string]int64{"u/1": 7, "u/2": 3}) c.Assert(ctx.UnitNames(), DeepEquals, []string{"u/1", "u/2"}) }
// runHook executes the supplied hook.Info in an appropriate hook context. If // the hook itself fails to execute, it returns errHookFailed. func (u *Uniter) runHook(hi hook.Info) (err error) { // Prepare context. if err = hi.Validate(); err != nil { return err } hookName := string(hi.Kind) relationId := -1 if hi.Kind.IsRelation() { relationId = hi.RelationId if hookName, err = u.relationers[relationId].PrepareHook(hi); err != nil { return err } } hctxId := fmt.Sprintf("%s:%s:%d", u.unit.Name(), hookName, u.rand.Int63()) // We want to make sure we don't block forever when locking, but take the // tomb into account. checkTomb := func() error { select { case <-u.tomb.Dying(): return tomb.ErrDying default: // no-op to fall through to return. } return nil } lockMessage := fmt.Sprintf("%s: running hook %q", u.unit.Name(), hookName) if err = u.hookLock.LockWithFunc(lockMessage, checkTomb); err != nil { return err } defer u.hookLock.Unlock() ctxRelations := map[int]*ContextRelation{} for id, r := range u.relationers { ctxRelations[id] = r.Context() } apiAddrs, err := u.st.APIAddresses() if err != nil { return err } hctx := NewHookContext(u.unit, hctxId, u.uuid, relationId, hi.RemoteUnit, ctxRelations, apiAddrs) // Prepare server. getCmd := func(ctxId, cmdName string) (cmd.Command, error) { // TODO: switch to long-running server with single context; // use nonce in place of context id. if ctxId != hctxId { return nil, fmt.Errorf("expected context id %q, got %q", hctxId, ctxId) } return jujuc.NewCommand(hctx, cmdName) } socketPath := filepath.Join(u.baseDir, "agent.socket") srv, err := jujuc.NewServer(getCmd, socketPath) if err != nil { return err } go srv.Run() defer srv.Close() // Run the hook. if err := u.writeState(RunHook, Pending, &hi, nil); err != nil { return err } log.Infof("worker/uniter: running %q hook", hookName) if err := hctx.RunHook(hookName, u.charm.Path(), u.toolsDir, socketPath); err != nil { log.Errorf("worker/uniter: hook failed: %s", err) return errHookFailed } if err := u.writeState(RunHook, Done, &hi, nil); err != nil { return err } log.Infof("worker/uniter: ran %q hook", hookName) return u.commitHook(hi) }
// deploy deploys the supplied charm URL, and sets follow-up hook operation state // as indicated by reason. func (u *Uniter) deploy(curl *corecharm.URL, reason Op) error { if reason != Install && reason != Upgrade { panic(fmt.Errorf("%q is not a deploy operation", reason)) } var hi *hook.Info if u.s != nil && (u.s.Op == RunHook || u.s.Op == Upgrade) { // If this upgrade interrupts a RunHook, we need to preserve the hook // info so that we can return to the appropriate error state. However, // if we're resuming (or have force-interrupted) an Upgrade, we also // need to preserve whatever hook info was preserved when we initially // started upgrading, to ensure we still return to the correct state. hi = u.s.Hook } if u.s == nil || u.s.OpStep != Done { // Get the new charm bundle before announcing intention to use it. log.Infof("worker/uniter: fetching charm %q", curl) sch, err := u.st.Charm(curl) if err != nil { return err } bun, err := u.bundles.Read(sch, u.tomb.Dying()) if err != nil { return err } if err = u.deployer.Stage(bun, curl); err != nil { return err } // Set the new charm URL - this returns when the operation is complete, // at which point we can refresh the local copy of the unit to get a // version with the correct charm URL, and can go ahead and deploy // the charm proper. if err := u.f.SetCharm(curl); err != nil { return err } if err := u.unit.Refresh(); err != nil { return err } log.Infof("worker/uniter: deploying charm %q", curl) if err = u.writeState(reason, Pending, hi, curl); err != nil { return err } if err = u.deployer.Deploy(u.charm); err != nil { return err } if err = u.writeState(reason, Done, hi, curl); err != nil { return err } } log.Infof("worker/uniter: charm %q is deployed", curl) status := Queued if hi != nil { // If a hook operation was interrupted, restore it. status = Pending } else { // Otherwise, queue the relevant post-deploy hook. hi = &hook.Info{} switch reason { case Install: hi.Kind = hooks.Install case Upgrade: hi.Kind = hooks.UpgradeCharm } } return u.writeState(RunHook, status, hi, nil) }