parade

type ActionManager struct {
	// contains filtered or unexported fields
}

type Actor interface {
	// Handle performs actions with the given body and return the ActorResult
	Handle(action string, body *string, signalledErrors int) ActorResult
	// Actions returns the list of actions that could be performed by the Actor
	Actions() []string
	// ActorID returns the ID of the actor
	ActorID() ActorID
}

type ActorID string

type ActorResult struct {
	Status     string
	StatusCode TaskStatusCodeValue
}

type ManagerProperties struct {
	Workers     int            // number of goroutines handling tasks
	ChannelSize int            // size of the channel containing tasks for workers
	MaxTasks    int            // max tasks requested in every ownTasks request
	WaitTime    *time.Duration // time to wait if OwnTasks returned no tasks.
	ErrWaitTime *time.Duration // time to wait if OwnTasks returned err.
	MaxDuration *time.Duration // maxDuration passed to parade.OwnTasks
}

type OwnedTaskData struct {
	ID                   TaskID           `db:"task_id"`
	Token                PerformanceToken `db:"token"`
	NumSignalledFailures int              `db:"num_failures"`
	Action               string           `db:"action"`
	Body                 *string
}

type Parade interface {
	// InsertTasks adds tasks efficiently
	InsertTasks(ctx context.Context, tasks []TaskData) error

	// OwnTasks owns and returns up to maxTasks tasks for actor for performing any of
	// actions.  It will return tasks and for another OwnTasks call to acquire them after
	// maxDuration (if specified).
	OwnTasks(actor ActorID, maxTasks int, actions []string, maxDuration *time.Duration) ([]OwnedTaskData, error)

	// ExtendTaskDeadline extends the deadline for completing taskID which was acquired with
	// the specified token, for maxDuration longer.  It returns nil if the task is still
	// owned and its deadline was extended, or an SQL error, or ErrInvalidToken.  deadline
	// was extended.
	ExtendTaskDeadline(taskID TaskID, token PerformanceToken, maxDuration time.Duration) error

	// ReturnTask returns taskID which was acquired using the specified performanceToken,
	// giving it resultStatus and resultStatusCode.  It returns ErrInvalidToken if the
	// performanceToken is invalid; this happens when ReturnTask is called after its
	// deadline expires, or due to a logic error.
	ReturnTask(taskID TaskID, token PerformanceToken, resultStatus string, resultStatusCode TaskStatusCodeValue) error

	// NewWaiter returns TaskWaiter to wait for id on conn.  conn is owned by the returned
	// TaskWaiter until the waiter is done or cancelled.
	NewWaiter(ctx context.Context, taskID TaskID) (Waiter, error)

	// DeleteTasks deletes taskIDs, removing dependencies and deleting (effectively
	// recursively) any tasks that are left with no dependencies.  It creates a temporary
	// table on tx, so ideally close the transaction shortly after.  The effect is easiest
	// to analyze when all deleted tasks have been either completed or been aborted.
	DeleteTasks(ctx context.Context, taskIDs []TaskID) error
}

type ParadeDB pgxpool.Pool

type ParadePrefix struct {
	Base   Parade
	Prefix string
}

type PerformanceToken pgtype.UUID

type TaskDBWaiter struct {
	// contains filtered or unexported fields
}

type TaskData struct {
	ID     TaskID `db:"task_id"`
	Action string `db:"action"`
	// Body is JSON-formatted
	Body               *string             `db:"body"`
	Status             *string             `db:"status"`
	StatusCode         TaskStatusCodeValue `db:"status_code"`
	NumTries           int                 `db:"num_tries"`
	NumFailures        int                 `db:"num_failures"`
	MaxTries           *int                `db:"max_tries"`
	NumSignals         int                 `db:"num_signals"` // Internal; set (only) in tests
	TotalDependencies  *int                `db:"total_dependencies"`
	ActorID            ActorID             `db:"actor_id"`
	ActionDeadline     *time.Time          `db:"action_deadline"`
	PerformanceToken   *PerformanceToken   `db:"performance_token"`
	ToSignalAfter      []TaskID            `db:"to_signal_after"`
	NotifyChannelAfter *string             `db:"notify_channel_after"`
}

type TaskDataIterator struct {
	Data []TaskData
	// contains filtered or unexported fields
}

type TaskID string

type TaskStatusCodeValue string

type Waiter interface {
	// Wait waits for the task to finish or the waiter to be cancelled and returns the task
	// status and status code.  It may safely be called from multiple goroutines.
	Wait() (string, TaskStatusCodeValue, error)

	// Cancel cancels waiting.
	Cancel()
}