statemachine

var (
	// TriggerUnknown refuses a name that is not one of the five triggers: a
	// journal written by something else, or damaged. The refused name is never
	// repeated — a journal is the caller's data.
	TriggerUnknown = errs.Static(CodeTriggerUnknown, "TRIGGER_UNKNOWN",
		"That is not a state-machine trigger",
		"core/app/statemachine: a trigger is start, event, delay, deadline or guard; the name given is none of them",
		0,
		0)

	// TransitionRefused is returned by Fire for an event no declared
	// transition takes from the entity's current state — including an event
	// that exists but leaves another state, and a timer or guard transition,
	// which only the machine's own loop fires. The entity is returned beside
	// it, so the caller can read the state that refused.
	TransitionRefused = errs.Static(CodeTransitionRefused, "TRANSITION_REFUSED",
		"That transition is not possible from the current state",
		"service/app/statemachine: no event transition by that name leaves the entity's state; the fields name the event and the state",
		409,
		0)

	// EntityMissing is returned when the store holds no entity under the key:
	// by Fire for a key never stored, and by any transition whose entity was
	// deleted while it ran — the store's Replace reported it gone, and the
	// transition stored nothing rather than bring it back.
	EntityMissing = errs.Static(CodeEntityMissing, "ENTITY_MISSING",
		"No such entity",
		"service/app/statemachine: the store holds no entity under the key, or it was deleted while the transition ran; the key field names it",
		404,
		0)

	// EntityExists is returned by Start when the store already holds an
	// entity under the new one's key. Nothing was stored and no hook ran
	// after the refusal.
	EntityExists = errs.Static(CodeEntityExists, "ENTITY_EXISTS",
		"An entity with that key already exists",
		"service/app/statemachine: the store's Insert reported the key taken; the key field names it",
		409,
		0)

	// KeyEmpty is returned by Start for an entity whose key is empty. The
	// engine locks, records and schedules by key, so an empty one would make
	// every such entity the same entity.
	KeyEmpty = errs.Static(CodeKeyEmpty, "KEY_EMPTY",
		"The entity has no key",
		"service/app/statemachine: Store.Key returned an empty key for the entity handed to Start",
		0,
		0)

	// HookFailed accompanies the error a hook returned, joined with it so
	// both errors.Is and errs.HasCode answer: an OnEnter hook's failure fails
	// its transition and is returned; an OnTransition hook's is reported
	// through Config.Report and the transition stands.
	HookFailed = errs.Static(CodeHookFailed, "HOOK_FAILED",
		"A state-machine hook failed",
		"service/app/statemachine: a hook returned an error, joined beside this one; the fields name the hook, the event and the state",
		0,
		0)

	// HookPanicked is a hook that panicked. The panic is recovered where the
	// hook ran, so an OnEnter hook fails its transition — and the entity's
	// lock is released on the way out, which is what kept a panicking hook
	// from leaving the machine locked for good. The recovered value and the
	// stack travel as log-only fields.
	HookPanicked = errs.Static(CodeHookPanicked, "HOOK_PANICKED",
		"A state-machine hook panicked",
		"service/app/statemachine: a hook panicked and was recovered; the fields carry the hook, the event, the value and the stack",
		0,
		0)

	// HookChangedState refuses a transition whose OnEnter hook changed the
	// entity's state. A hook may change the entity, not where it is going:
	// the history would record one state and the store hold another.
	HookChangedState = errs.Static(CodeHookChangedState, "HOOK_CHANGED_STATE",
		"A state-machine hook changed the state it was entering",
		"service/app/statemachine: after the OnEnter hooks the entity's state was no longer the transition's target; nothing was stored",
		0,
		0)

	// HookChangedKey refuses a transition whose OnEnter hook changed the
	// entity's key: storing it would replace, or create, another entity.
	HookChangedKey = errs.Static(CodeHookChangedKey, "HOOK_CHANGED_KEY",
		"A state-machine hook changed the key of its entity",
		"service/app/statemachine: after the OnEnter hooks Store.Key no longer returned the entity's key; nothing was stored",
		0,
		0)

	// Reentrant refuses a Start or a Fire made, through the context an
	// OnEnter hook was given, on the machine running that hook. The hook runs
	// while the machine holds its entity's lock, so the call would wait for
	// itself; it is refused instead of deadlocking. Fire from an
	// OnTransition hook, which runs once the lock is released.
	Reentrant = errs.Static(CodeReentrant, "REENTRANT",
		"A state-machine hook cannot fire its own machine",
		"service/app/statemachine: Start or Fire was called with a context an OnEnter hook of the same machine was given; fire from OnTransition instead",
		0,
		0)

	// StoreFailed wraps an error a Store method returned. When the store's
	// error is itself an SDK error its code is kept and this one joins the
	// trail, so both errs.HasCode checks answer.
	StoreFailed = errs.Static(CodeStoreFailed, "STORE_FAILED",
		"The state machine's store failed",
		"service/app/statemachine: a Store method returned an error; the fields name the operation",
		0,
		0)

	// JournalFailed wraps an error a Journal method returned. Load failing
	// fails the machine's opening; Save and Delete failing are reported and
	// the transition stands, since the store is the source of truth and a
	// lost record only costs a timer its origin after a restart.
	JournalFailed = errs.Static(CodeJournalFailed, "JOURNAL_FAILED",
		"The state machine's journal failed",
		"service/app/statemachine: a Journal method returned an error; the fields name the operation",
		0,
		0)

	// LoopRunning refuses a Run or a Step while another Run or Step of the
	// same machine is going: one loop at a time, so an entity takes at most
	// one automatic transition per run.
	LoopRunning = errs.Static(CodeLoopRunning, "LOOP_RUNNING",
		"The state machine's loop is already running",
		"service/app/statemachine: Run or Step was called while another Run or Step of this machine had not returned",
		0,
		0)

	// FunctionPanicked is a guard or an instant function that panicked while
	// the loop asked whether a transition was due. The entity is retried
	// after a backoff; the value and the stack travel as log-only fields.
	FunctionPanicked = errs.Static(CodeFunctionPanicked, "FUNCTION_PANICKED",
		"A state-machine guard or deadline function panicked",
		"service/app/statemachine: a guard or an instant function panicked and was recovered; the fields carry the event, the value and the stack",
		0,
		0)

	// InitialMissing refuses a definition that never called Initial: Start
	// would have no state to put a new entity in.
	InitialMissing = errs.Static(CodeInitialMissing, "INITIAL_MISSING",
		"The state machine has no initial state",
		"service/app/statemachine: the definition never called Initial",
		0,
		0)

	// EventInvalid refuses a transition declared with an empty event name or
	// with the name a creation's history step takes.
	EventInvalid = errs.Static(CodeEventInvalid, "EVENT_INVALID",
		"A transition needs a name, other than the reserved one",
		"service/app/statemachine: a transition was declared with an empty event name or with core/app/statemachine.CreateEvent",
		0,
		0)

	// TransitionDuplicate refuses a second transition for one event from one
	// state: Fire, and the loop's first-declared rule, would have two answers.
	TransitionDuplicate = errs.Static(CodeTransitionDuplicate, "TRANSITION_DUPLICATE",
		"That event already leaves that state",
		"service/app/statemachine: a transition was declared twice for one event from one state; the fields name them",
		0,
		0)

	// DelayInvalid refuses an After with a duration that is not positive: a
	// timer due the instant its state is entered is a guard that always
	// holds, and reads as a mistake.
	DelayInvalid = errs.Static(CodeDelayInvalid, "DELAY_INVALID",
		"A timer transition needs a positive duration",
		"service/app/statemachine: After was declared with a duration of zero or less; the event field names it",
		0,
		0)

	// FunctionMissing refuses a nil function a definition needs: the state
	// accessor, a guard, an instant function or a hook — and a nil
	// definition handed to NewStateMachine.
	FunctionMissing = errs.Static(CodeFunctionMissing, "FUNCTION_MISSING",
		"The state machine was given no function where it needs one",
		"service/app/statemachine: a nil state accessor, guard, instant function, hook or definition; the fields say which",
		0,
		0)

	// StoreMissing refuses a configuration with no store: a machine's
	// entities have to live somewhere.
	StoreMissing = errs.Static(CodeStoreMissing, "STORE_MISSING",
		"The state machine has no store",
		"service/app/statemachine: Config.Store is nil",
		0,
		0)

	// LoopPanicked is a panic the loop recovered from the caller's own code —
	// a store method, a journal, an observer — while it looked at one
	// entity. When the panic interrupted the entity's pass, the entity is
	// retried after its backoff; when it came from the observer's end, the
	// transition was stored already and stands — call=observe-end says so.
	// Either way the loop goes on. Start and Fire, which run on the caller's
	// goroutine, let such a panic through, with the entity's lock released.
	// The value and the stack travel as log-only fields.
	LoopPanicked = errs.Static(CodeLoopPanicked, "LOOP_PANICKED",
		"The state machine's loop recovered a panic",
		"service/app/statemachine: a store, journal or observer call panicked in the loop; the fields carry the key, the value, the stack and, for the observer's end, call",
		0,
		0)

	// WaitAbandoned is returned when the caller's context ended while it
	// waited for another transition of the same entity to finish. Nothing was
	// read or stored.
	WaitAbandoned = errs.Static(CodeWaitAbandoned, "WAIT_ABANDONED",
		"The request ended while the entity was busy",
		"service/app/statemachine: the context ended before the entity's lock was free; the cause is the context's error",
		503,
		0)
)