Beispiel #1
0
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
	}
}
Beispiel #2
0
// 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
}
Beispiel #3
0
// Track inserts the provided payload info in state. If the payload
// is already in the DB then it is replaced.
func (up UnitPayloads) Track(pl payload.Payload) error {

	// XXX OMFG payload/context/register.go:83 launches bad data
	// which flies on a majestic unvalidated arc right through the
	// system until it lands here. This code should be:
	//
	//    if pl.Unit != up.unit {
	//        return errors.NotValidf("unexpected Unit %q", pl.Unit)
	//    }
	//
	// ...but is instead:
	pl.Unit = up.unit

	if err := pl.Validate(); err != nil {
		return errors.Trace(err)
	}

	doc := nsPayloads.asDoc(payload.FullPayloadInfo{
		Payload: pl,
		Machine: up.machine,
	})
	change := payloadTrackChange{doc}
	if err := Apply(up.db, change); err != nil {
		return errors.Trace(err)
	}
	return nil
}
Beispiel #4
0
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
}
Beispiel #5
0
// Track inserts the provided payload info in state. The new Juju ID
// for the payload is returned.
func (uw UnitPayloads) Track(pl payload.Payload) error {
	logger.Tracef("tracking %#v", pl)

	if err := pl.Validate(); err != nil {
		return errors.NewNotValid(err, "bad payload")
	}

	id, err := uw.newID()
	if err != nil {
		return errors.Trace(err)
	}

	ok, err := uw.Persist.Track(id, pl)
	if err != nil {
		return errors.Trace(err)
	}
	if !ok {
		return errors.NotValidf("payload %s (already in state)", id)
	}

	return nil
}
Beispiel #6
0
// 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
}