func AddPayload(ctx *Context, id string, pl payload.Payload) { if _, ok := ctx.payloads[id]; !ok { ctx.payloads[id] = pl } else { ctx.updates[pl.FullID()] = pl } }
// Track adds records for the payload to persistence. If the payload // is already there then false gets returned (true if inserted). // Existing records are not checked for consistency. func (pp Persistence) Track(id string, pl payload.Payload) (bool, error) { logger.Tracef("insertng %#v", pl) _, err := pp.LookUp(pl.Name, pl.ID) if err == nil { return false, errors.AlreadyExistsf("payload for %q", pl.FullID()) } else if !errors.IsNotFound(err) { return false, errors.Annotate(err, "while checking for collisions") } // TODO(ericsnow) There is a *slight* race here. I haven't found // a simple way to check the secondary key in the transaction. var okay bool var ops []txn.Op // TODO(ericsnow) Add unitPersistence.newEnsureAliveOp(pp.unit)? ops = append(ops, pp.newInsertPayloadOps(id, pl)...) buildTxn := func(attempt int) ([]txn.Op, error) { if attempt > 0 { okay = false return nil, jujutxn.ErrNoOperations } okay = true return ops, nil } if err := pp.st.Run(buildTxn); err != nil { return false, errors.Trace(err) } return okay, nil }
func (c *stubContextComponent) Track(pl payload.Payload) error { c.stub.AddCall("Track", pl) if err := c.stub.NextErr(); err != nil { return errors.Trace(err) } c.payloads[pl.FullID()] = pl return nil }
// Track records the payload info in the hook context. func (c *Context) Track(pl payload.Payload) error { logger.Tracef("adding %q to hook context: %#v", pl.FullID(), pl) if err := pl.Validate(); err != nil { return errors.Trace(err) } // TODO(ericsnow) We are likely missing mechanisim for local persistence. id := pl.FullID() c.updates[id] = pl return nil }