Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

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.
	Run()

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

	TaskStateHandler
}

    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 {
        	RunnerHook
        	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 {
            	RunnerHook
            	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 {
              	RunnerHook
              
              	PreKill()
              }

                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 {
                	RunnerHook
                	Prerun() error
                }

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

                  type RunnerUpdateHook

                  type RunnerUpdateHook interface {
                  	RunnerHook
                  	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 {
                    	RunnerHook
                    
                    	Shutdown()
                    }

                      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 {
                      	TaskHook
                      
                      	// 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 {
                        	TaskHook
                        
                        	// 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 {
                        	TaskHook
                        
                        	// 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 {
                        	TaskHook
                        
                        	// 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.
                        	TaskStateUpdated()
                        }

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

                          type TaskStopHook

                          type TaskStopHook interface {
                          	TaskHook
                          
                          	// 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 {
                          	TaskHook
                          
                          	// 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{}