worker

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)

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

type Container interface {
	garden.Container

	Destroy() error

	Release(*time.Duration)

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

type ContainerSpec interface {
	WorkerSpec() WorkerSpec
	ImageResource() (atc.TaskImageConfig, bool)
}

type ExponentialRetryPolicy struct {
	Timeout time.Duration
}

type GardenConnectionFactory interface {
	BuildConnection() gconn.Connection
	BuildConnectionFromDB() (gconn.Connection, error)
}

type GardenConnectionFactoryDB interface {
	GetWorker(string) (db.SavedWorker, bool, error)
}

type GardenWorkerDB interface {
	CreateContainer(db.Container, time.Duration) (db.SavedContainer, error)
	UpdateExpiresAtOnContainer(handle string, ttl time.Duration) error
}

type Identifier db.ContainerIdentifier

type Image interface {
	Volume() Volume
	Metadata() ImageMetadata
	Release(*time.Duration)
}

type ImageFetcher interface {
	FetchImage(
		lager.Logger,
		atc.TaskImageConfig,
		<-chan os.Signal,
		Identifier,
		Metadata,
		ImageFetchingDelegate,
		Client,
		atc.Tags,
		atc.ResourceTypes,
	) (Image, error)
}

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

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

type Metadata db.ContainerMetadata

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

type MultipleContainersError struct {
	Handles []string
}

type MultipleWorkersFoundContainerError struct {
	Names []string
}

type NoCompatibleWorkersError struct {
	Spec    WorkerSpec
	Workers []Worker
}

type NoopImageFetchingDelegate struct{}

type ResourceTypeContainerSpec struct {
	Type                 string
	ImageResourcePointer *atc.TaskImageConfig
	Ephemeral            bool
	Tags                 []string
	Env                  []string

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

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

type RetryPolicy interface {
	DelayFor(uint) (time.Duration, bool)
}

type RetryableConnection struct {
	gconn.Connection

	Logger            lager.Logger
	Sleeper           Sleeper
	RetryPolicy       RetryPolicy
	ConnectionFactory GardenConnectionFactory
	// contains filtered or unexported fields
}

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

type Sleeper interface {
	Sleep(time.Duration)
}

type TaskContainerSpec struct {
	Platform             string
	Image                string
	ImageResourcePointer *atc.TaskImageConfig
	Privileged           bool
	Tags                 []string
	Inputs               []VolumeMount
	Outputs              []VolumeMount
}

type Volume interface {
	baggageclaim.Volume
}

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

type VolumeFactoryDB interface {
	GetVolumeTTL(volumeHandle string) (time.Duration, error)
	ReapVolume(handle string) error
	SetVolumeTTL(string, time.Duration) error
}

type VolumeMount struct {
	Volume    Volume
	MountPath string
}

type Worker interface {
	Client

	ActiveContainers() int

	Description() string
	Name() string

	VolumeManager() (baggageclaim.Client, bool)
}

type WorkerDB interface {
	Workers() ([]db.SavedWorker, error)
	GetWorker(string) (db.SavedWorker, bool, error)
	CreateContainer(db.Container, time.Duration) (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

	GetVolumeTTL(volumeHandle string) (time.Duration, error)
	ReapVolume(handle string) error
	SetVolumeTTL(string, time.Duration) error
}

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
}

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