worker

Documentation

Index

• Constants
• Variables
• func FinalTTL(ttl time.Duration) *time.Duration
• func NewHardcoded(logger lager.Logger, workerDB SaveWorkerDB, clock c.Clock, gardenAddr string, ...) ifrit.RunFunc
• type Client
  • func NewPool(provider WorkerProvider) Client
• type Container
• type ContainerRootFSStrategy
• type ContainerSpec
  • func (spec ContainerSpec) WorkerSpec() WorkerSpec
• type GardenConnectionFactory
  • func NewGardenConnectionFactory(db transport.TransportDB, logger lager.Logger, workerName string, ...) GardenConnectionFactory
• type GardenWorkerDB
• type HostRootFSStrategy
• type Identifier
• type Image
• type ImageArtifactReplicationStrategy
• type ImageFactory
• type ImageFetchingDelegate
• type ImageMetadata
• type ImageSpec
• type ImageVolumeAndMetadata
• type MalformedMetadataError
  • func (err MalformedMetadataError) Error() string
• type Metadata
• type NoCompatibleWorkersError
  • func (err NoCompatibleWorkersError) Error() string
• type NoopImageFetchingDelegate
  • func (NoopImageFetchingDelegate) ImageVersionDetermined(VolumeIdentifier) error
  • func (NoopImageFetchingDelegate) Stderr() io.Writer
• type OutputStrategy
• type ResourceCacheStrategy
• type RetryableConnection
  • func NewRetryableConnection(connection gconn.Connection) *RetryableConnection
  • func (conn *RetryableConnection) Attach(handle string, processID string, processIO garden.ProcessIO) (garden.Process, error)
  • func (conn *RetryableConnection) Run(handle string, processSpec garden.ProcessSpec, processIO garden.ProcessIO) (garden.Process, error)
• type SaveWorkerDB
• type Sleeper
• type Strategy
• type Volume
• type VolumeClient
  • func NewVolumeClient(baggageclaimClient baggageclaim.Client, db GardenWorkerDB, ...) VolumeClient
• type VolumeFactory
  • func NewVolumeFactory(db VolumeFactoryDB, clock clock.Clock) VolumeFactory
• type VolumeFactoryDB
• type VolumeIdentifier
• type VolumeMount
• type VolumeProperties
• type VolumeSpec
• type Worker
  • func NewGardenWorker(gardenClient garden.Client, baggageclaimClient baggageclaim.Client, ...) Worker
• type WorkerDB
• type WorkerProvider
  • func NewDBWorkerProvider(logger lager.Logger, db WorkerDB, dialer gconn.DialerFunc, ...) WorkerProvider
• type WorkerSpec
  • func (spec WorkerSpec) Description() string

Constants

const ContainerTTL = 5 * time.Minute

const RawRootFSScheme = "raw"

const VolumeTTL = 5 * time.Minute

Variables

var (
	ErrNoWorkers     = errors.New("no workers")
	ErrMissingWorker = errors.New("worker for container is missing")
)

var ErrIncompatiblePlatform = errors.New("incompatible platform")

var ErrMismatchedTags = errors.New("mismatched tags")

var ErrMissingVolume = errors.New("volume mounted to container is missing")

var ErrNoVolumeManager = errors.New("worker does not support volume management")

var ErrTeamMismatch = errors.New("mismatched team")

var ErrUnsupportedResourceType = errors.New("unsupported resource type")

var ErrVolumeExpiredImmediately = errors.New("volume expired immediately after saving")

Functions

func FinalTTL

func FinalTTL(ttl time.Duration) *time.Duration

func NewHardcoded

func NewHardcoded(
	logger lager.Logger, workerDB SaveWorkerDB, clock c.Clock,
	gardenAddr string, baggageclaimURL string, resourceTypesNG []atc.WorkerResourceType,
) ifrit.RunFunc

Types

type Client

type Client interface {
	CreateContainer(
		lager.Logger,
		<-chan os.Signal,
		ImageFetchingDelegate,
		Identifier,
		Metadata,
		ContainerSpec,
		atc.ResourceTypes,
	) (Container, error)

	FindContainerForIdentifier(lager.Logger, Identifier) (Container, bool, error)
	LookupContainer(lager.Logger, string) (Container, bool, error)
	ValidateResourceCheckVersion(container db.SavedContainer) (bool, error)
	FindResourceTypeByPath(path string) (atc.WorkerResourceType, bool)
	FindVolume(lager.Logger, VolumeSpec) (Volume, bool, error)
	CreateVolume(logger lager.Logger, vs VolumeSpec, teamID int) (Volume, error)
	ListVolumes(lager.Logger, VolumeProperties) ([]Volume, error)
	LookupVolume(lager.Logger, string) (Volume, bool, error)

	Satisfying(WorkerSpec, atc.ResourceTypes) (Worker, error)
	AllSatisfying(WorkerSpec, atc.ResourceTypes) ([]Worker, error)
	Workers() ([]Worker, error)
	GetWorker(workerName string) (Worker, error)
}

func NewPool

func NewPool(provider WorkerProvider) Client

type Container

type Container interface {
	garden.Container

	Destroy() error

	Release(*time.Duration)

	Volumes() []Volume
	VolumeMounts() []VolumeMount

	WorkerName() string
}

type ContainerRootFSStrategy

type ContainerRootFSStrategy struct {
	Parent Volume
}

type ContainerSpec

type ContainerSpec struct {
	Platform  string
	Tags      []string
	TeamID    int
	ImageSpec ImageSpec
	Ephemeral bool
	Env       []string

	// Not Copy-on-Write. Used for a single mount in Get containers.
	Inputs []VolumeMount

	// Copy-on-Write. Used for mounting multiple resources into a Put container.
	Outputs []VolumeMount

	// Optional user to run processes as. Overwrites the one specified in the docker image.
	User string
}

func (ContainerSpec) WorkerSpec

func (spec ContainerSpec) WorkerSpec() WorkerSpec

type GardenConnectionFactory

type GardenConnectionFactory interface {
	BuildConnection() gconn.Connection
}

func NewGardenConnectionFactory

func NewGardenConnectionFactory(
	db transport.TransportDB,
	logger lager.Logger,
	workerName string,
	workerHost string,
	retryBackOffFactory retryhttp.BackOffFactory,
) GardenConnectionFactory

type GardenWorkerDB

type GardenWorkerDB interface {
	CreateContainer(container db.Container, ttl time.Duration, maxLifetime time.Duration, volumeHandles []string) (db.SavedContainer, error)
	GetContainer(handle string) (db.SavedContainer, bool, error)
	UpdateExpiresAtOnContainer(handle string, ttl time.Duration) error
	ReapContainer(string) error
	GetPipelineByID(pipelineID int) (db.SavedPipeline, error)
	InsertVolume(db.Volume) error
	SetVolumeTTLAndSizeInBytes(string, time.Duration, int64) error
	GetVolumeTTL(string) (time.Duration, bool, error)
	GetVolumesByIdentifier(db.VolumeIdentifier) ([]db.SavedVolume, error)
}

type HostRootFSStrategy

type HostRootFSStrategy struct {
	Path       string
	WorkerName string
	Version    *string
}

type Identifier

type Identifier db.ContainerIdentifier

type Image

type Image interface {
	Fetch() (Volume, io.ReadCloser, atc.Version, error)
}

type ImageArtifactReplicationStrategy

type ImageArtifactReplicationStrategy struct {
	Name string
}

type ImageFactory

type ImageFactory interface {
	NewImage(
		logger lager.Logger,
		cancel <-chan os.Signal,
		imageResource atc.ImageResource,
		id Identifier,
		metadata Metadata,
		tags atc.Tags,
		teamID int,
		resourceTypes atc.ResourceTypes,
		workerClient Client,
		delegate ImageFetchingDelegate,
		privileged bool,
	) Image
}

type ImageFetchingDelegate

type ImageFetchingDelegate interface {
	Stderr() io.Writer
	ImageVersionDetermined(VolumeIdentifier) error
}

type ImageMetadata

type ImageMetadata struct {
	Env  []string `json:"env"`
	User string   `json:"user"`
}

type ImageSpec

type ImageSpec struct {
	ResourceType           string
	ImageURL               string
	ImageResource          *atc.ImageResource
	ImageVolumeAndMetadata ImageVolumeAndMetadata
	Privileged             bool
}

type ImageVolumeAndMetadata

type ImageVolumeAndMetadata struct {
	Volume         Volume
	MetadataReader io.ReadCloser
}

type MalformedMetadataError

type MalformedMetadataError struct {
	UnmarshalError error
}

func (MalformedMetadataError) Error

func (err MalformedMetadataError) Error() string

type Metadata

type Metadata db.ContainerMetadata

type NoCompatibleWorkersError

type NoCompatibleWorkersError struct {
	Spec    WorkerSpec
	Workers []Worker
}

func (NoCompatibleWorkersError) Error

func (err NoCompatibleWorkersError) Error() string

type NoopImageFetchingDelegate

type NoopImageFetchingDelegate struct{}

func (NoopImageFetchingDelegate) ImageVersionDetermined

func (NoopImageFetchingDelegate) ImageVersionDetermined(VolumeIdentifier) error

func (NoopImageFetchingDelegate) Stderr

func (NoopImageFetchingDelegate) Stderr() io.Writer

type OutputStrategy

type OutputStrategy struct {
	Name string
}

type ResourceCacheStrategy

type ResourceCacheStrategy struct {
	ResourceHash    string
	ResourceVersion atc.Version
}

type RetryableConnection

type RetryableConnection struct {
	gconn.Connection
}

func NewRetryableConnection

func NewRetryableConnection(connection gconn.Connection) *RetryableConnection

func (*RetryableConnection) Attach

func (conn *RetryableConnection) Attach(handle string, processID string, processIO garden.ProcessIO) (garden.Process, error)

func (*RetryableConnection) Run

func (conn *RetryableConnection) Run(handle string, processSpec garden.ProcessSpec, processIO garden.ProcessIO) (garden.Process, error)

type SaveWorkerDB

type SaveWorkerDB interface {
	SaveWorker(db.WorkerInfo, time.Duration) (db.SavedWorker, error)
}

type Sleeper

type Sleeper interface {
	Sleep(time.Duration)
}

type Strategy

type Strategy interface {
	// contains filtered or unexported methods
}

type Volume

type Volume interface {
	baggageclaim.Volume

	// a noop method to ensure things aren't just returning baggageclaim.Volume
	HeartbeatingToDB()
}

type VolumeClient

type VolumeClient interface {
	FindVolume(lager.Logger, VolumeSpec) (Volume, bool, error)
	CreateVolume(logger lager.Logger, vs VolumeSpec, teamID int) (Volume, error)
	ListVolumes(lager.Logger, VolumeProperties) ([]Volume, error)
	LookupVolume(lager.Logger, string) (Volume, bool, error)
}

func NewVolumeClient

func NewVolumeClient(
	baggageclaimClient baggageclaim.Client,
	db GardenWorkerDB,
	volumeFactory VolumeFactory,
	workerName string,
) VolumeClient

type VolumeFactory

type VolumeFactory interface {
	Build(lager.Logger, baggageclaim.Volume) (Volume, bool, error)
}

func NewVolumeFactory

func NewVolumeFactory(db VolumeFactoryDB, clock clock.Clock) VolumeFactory

type VolumeFactoryDB

type VolumeFactoryDB interface {
	GetVolumeTTL(volumeHandle string) (time.Duration, bool, error)
	ReapVolume(handle string) error
	SetVolumeTTLAndSizeInBytes(handle string, ttl time.Duration, sizeInBytes int64) error
	SetVolumeTTL(handle string, ttl time.Duration) error
}

type VolumeIdentifier

type VolumeIdentifier db.VolumeIdentifier

type VolumeMount

type VolumeMount struct {
	Volume    Volume
	MountPath string
}

type VolumeProperties

type VolumeProperties map[string]string

type VolumeSpec

type VolumeSpec struct {
	Strategy   Strategy
	Properties VolumeProperties
	Privileged bool
	TTL        time.Duration
}

type Worker

type Worker interface {
	Client

	ActiveContainers() int

	Description() string
	Name() string
	Uptime() time.Duration
	IsOwnedByTeam() bool
}

func NewGardenWorker

func NewGardenWorker(
	gardenClient garden.Client,
	baggageclaimClient baggageclaim.Client,
	volumeClient VolumeClient,
	volumeFactory VolumeFactory,
	imageFactory ImageFactory,
	pipelineDBFactory db.PipelineDBFactory,
	db GardenWorkerDB,
	provider WorkerProvider,
	clock clock.Clock,
	activeContainers int,
	resourceTypes []atc.WorkerResourceType,
	platform string,
	tags atc.Tags,
	teamID int,
	name string,
	startTime int64,
	httpProxyURL string,
	httpsProxyURL string,
	noProxy string,
) Worker

type WorkerDB

type WorkerDB interface {
	Workers() ([]db.SavedWorker, error)
	GetWorker(string) (db.SavedWorker, bool, error)
	CreateContainer(container db.Container, ttl time.Duration, maxLifetime time.Duration, volumeHandles []string) (db.SavedContainer, error)
	GetContainer(string) (db.SavedContainer, bool, error)
	FindContainerByIdentifier(db.ContainerIdentifier) (db.SavedContainer, bool, error)
	UpdateExpiresAtOnContainer(handle string, ttl time.Duration) error
	ReapContainer(handle string) error
	GetPipelineByID(pipelineID int) (db.SavedPipeline, error)
	InsertVolume(db.Volume) error
	GetVolumesByIdentifier(db.VolumeIdentifier) ([]db.SavedVolume, error)
	GetVolumeTTL(volumeHandle string) (time.Duration, bool, error)
	ReapVolume(handle string) error
	SetVolumeTTLAndSizeInBytes(string, time.Duration, int64) error
	SetVolumeTTL(string, time.Duration) error
}

type WorkerProvider

type WorkerProvider interface {
	Workers() ([]Worker, error)
	GetWorker(string) (Worker, bool, error)
	FindContainerForIdentifier(Identifier) (db.SavedContainer, bool, error)
	GetContainer(string) (db.SavedContainer, bool, error)
	ReapContainer(string) error
}

func NewDBWorkerProvider

func NewDBWorkerProvider(
	logger lager.Logger,
	db WorkerDB,
	dialer gconn.DialerFunc,
	retryBackOffFactory retryhttp.BackOffFactory,
	imageFactory ImageFactory,
	pipelineDBFactory db.PipelineDBFactory,
) WorkerProvider

type WorkerSpec

type WorkerSpec struct {
	Platform     string
	ResourceType string
	Tags         []string
	TeamID       int
}

func (WorkerSpec) Description

func (spec WorkerSpec) Description() string