This section is empty.


This section is empty.


This section is empty.


type AllocRunner

type AllocRunner interface {
	// ID returns the ID of the allocation being run.
	ID() string

	// Run starts the runner and begins executing all the tasks as part of the
	// allocation.

	// State returns a copy of the runners state object
	State() *state.State


AllocRunner is the interface for an allocation runner.

type AllocStatsReporter

type AllocStatsReporter interface {
	LatestAllocStats(taskFilter string) (*cstructs.AllocResourceUsage, error)

AllocStatsReporter gives acess to the latest resource usage from the allocation

type DriverStats

type DriverStats interface {
	Stats(context.Context, time.Duration) (<-chan *cstructs.TaskResourceUsage, error)

DriverStats is the interface implemented by DriverHandles to return task stats.

type RunnerDestroyHook

type RunnerDestroyHook interface {
	Destroy() error

RunnerDestroyHooks are executed after AllocRunner.Run has exited and must make a best effort cleanup allocation resources. Destroy hooks must be safe to call without first calling Prerun.

type RunnerHook

type RunnerHook interface {
	Name() string

RunnnerHook is a lifecycle hook into the life cycle of an allocation runner.

type RunnerPostrunHook

type RunnerPostrunHook interface {
	Postrun() error

RunnerPostrunHooks are executed after calling TaskRunner.Run, even for terminal allocations. Therefore Postrun hooks must be safe to call without first calling Prerun hooks.

type RunnerPreKillHook

type RunnerPreKillHook interface {


RunnerPreKillHooks are executed inside of KillTasks before iterating and killing each task. It will run before the Leader task is killed.

type RunnerPrerunHook

type RunnerPrerunHook interface {
	Prerun() error

RunnerPrerunHooks are executed before calling TaskRunner.Run for non-terminal allocations. Terminal allocations do *not* call prerun.

type RunnerUpdateHook

type RunnerUpdateHook interface {
	Update(*RunnerUpdateRequest) error

RunnerUpdateHooks are executed when an allocation update is received from the server. Update is called concurrently with AllocRunner execution and therefore must be safe for concurrent access with other hook methods. Calls to Update are serialized so allocaiton updates will always be processed in order.

type RunnerUpdateRequest

type RunnerUpdateRequest struct {
	Alloc *structs.Allocation

type ShutdownHook

type ShutdownHook interface {


ShutdownHook may be implemented by AllocRunner or TaskRunner hooks and will be called when the agent process is being shutdown gracefully.

type TaskExitedHook

type TaskExitedHook interface {

	// Exited is called after a task exits and may or may not be restarted.
	// Prestart may or may not have been called.
	// The context is cancelled if the task is killed.
	Exited(context.Context, *TaskExitedRequest, *TaskExitedResponse) error

type TaskExitedRequest

type TaskExitedRequest struct{}

type TaskExitedResponse

type TaskExitedResponse struct{}

type TaskHook

type TaskHook interface {
	Name() string

TaskHook is a lifecycle hook into the life cycle of a task runner.

type TaskPoststartHook

type TaskPoststartHook interface {

	// Poststart is called after the task has started. Poststart is not
	// called if the allocation is terminal.
	// The context is cancelled if the task is killed.
	Poststart(context.Context, *TaskPoststartRequest, *TaskPoststartResponse) error

type TaskPoststartRequest

type TaskPoststartRequest struct {
	// Exec hook (may be nil)
	DriverExec interfaces.ScriptExecutor

	// Network info (may be nil)
	DriverNetwork *drivers.DriverNetwork

	// TaskEnv is the task's environment
	TaskEnv *taskenv.TaskEnv

	// Stats collector
	DriverStats DriverStats

type TaskPoststartResponse

type TaskPoststartResponse struct{}

type TaskPreKillHook

type TaskPreKillHook interface {

	// PreKilling is called right before a task is going to be killed or
	// restarted. They are called concurrently with TaskRunner.Run and may
	// be called without Prestart being called.
	PreKilling(context.Context, *TaskPreKillRequest, *TaskPreKillResponse) error

type TaskPreKillRequest

type TaskPreKillRequest struct{}

type TaskPreKillResponse

type TaskPreKillResponse struct{}

type TaskPrestartHook

type TaskPrestartHook interface {

	// Prestart is called before the task is started including after every
	// restart. Prestart is not called if the allocation is terminal.
	// The context is cancelled if the task is killed or shutdown.
	Prestart(context.Context, *TaskPrestartRequest, *TaskPrestartResponse) error

type TaskPrestartRequest

type TaskPrestartRequest struct {
	// PreviousState is previously set data by the hook. It must be copied
	// to State below to be maintained across restarts.
	PreviousState map[string]string

	// Task is the task to run
	Task *structs.Task

	// TaskResources is the resources assigned to the task
	TaskResources *structs.AllocatedTaskResources

	// Vault token may optionally be set if a Vault token is available
	VaultToken string

	// TaskDir contains the task's directory tree on the host
	TaskDir *allocdir.TaskDir

	// TaskEnv is the task's environment
	TaskEnv *taskenv.TaskEnv

type TaskPrestartResponse

type TaskPrestartResponse struct {
	// Env is the environment variables to set for the task
	Env map[string]string

	// Mounts is the set of host volumes to mount into the task
	Mounts []*drivers.MountConfig

	// Devices are the set of devices to mount into the task
	Devices []*drivers.DeviceConfig

	// State allows the hook to emit data to be passed in the next time it is
	// run. Hooks must copy relevant PreviousState to State to maintain it
	// across restarts.
	State map[string]string

	// Done lets the hook indicate that it completed successfully and
	// should not be run again.
	Done bool

type TaskStateHandler

type TaskStateHandler interface {
	// TaskStateUpdated is used to notify the alloc runner about task state
	// changes.

TaskStateHandler exposes a handler to be called when a task's state changes

type TaskStopHook

type TaskStopHook interface {

	// Stop is called after the task has exited and will not be started
	// again. It is the only hook guaranteed to be executed whenever
	// TaskRunner.Run is called (and not gracefully shutting down).
	// Therefore it may be called even when prestart and the other hooks
	// have not.
	// Stop hooks must be idempotent. The context is cancelled if the task
	// is killed.
	Stop(context.Context, *TaskStopRequest, *TaskStopResponse) error

type TaskStopRequest

type TaskStopRequest struct {
	// ExistingState is previously set hook data and should only be
	// read. Stop hooks cannot alter state.
	ExistingState map[string]string

type TaskStopResponse

type TaskStopResponse struct{}

type TaskUpdateHook

type TaskUpdateHook interface {

	// Update is called when the servers have updated the Allocation for
	// this task. Updates are concurrent with all other task hooks and
	// therefore hooks that implement this interface must be completely
	// safe for concurrent access.
	// The context is cancelled if the task is killed.
	Update(context.Context, *TaskUpdateRequest, *TaskUpdateResponse) error

type TaskUpdateRequest

type TaskUpdateRequest struct {
	VaultToken string

	// Alloc is the current version of the allocation (may have been
	// updated since the hook was created)
	Alloc *structs.Allocation

	// TaskEnv is the task's environment
	TaskEnv *taskenv.TaskEnv

type TaskUpdateResponse

type TaskUpdateResponse struct{}