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)

	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)
	GetWorker(workerName string) (Worker, error)
}

type Container interface {
	garden.Container

	Destroy() error

	Release(*time.Duration)

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

	WorkerName() string
}

type ContainerRootFSStrategy struct {
	Parent Volume
}

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
}

type GardenConnectionFactory interface {
	BuildConnection() gconn.Connection
}

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
	FindWorkerCheckResourceTypeVersion(workerName string, checkType string) (string, bool, error)

	InsertVolume(db.Volume) error
	SetVolumeTTL(string, time.Duration) error
	GetVolumeTTL(string) (time.Duration, bool, error)
	GetVolumesByIdentifier(db.VolumeIdentifier) ([]db.SavedVolume, error)
}

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

type Identifier db.ContainerIdentifier

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

type ImageArtifactReplicationStrategy struct {
	Name string
}

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 interface {
	Stderr() io.Writer
	ImageVersionDetermined(VolumeIdentifier) error
}

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

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

type ImageVolumeAndMetadata struct {
	Volume         Volume
	MetadataReader io.ReadCloser
}

type MalformedMetadataError struct {
	UnmarshalError error
}

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 OutputStrategy struct {
	Name string
}

type ResourceCacheStrategy struct {
	ResourceHash    string
	ResourceVersion atc.Version
}

type RetryableConnection struct {
	gconn.Connection
}

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

type Sleeper interface {
	Sleep(time.Duration)
}

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

type Volume interface {
	baggageclaim.Volume

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

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)
}

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

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

type VolumeIdentifier db.VolumeIdentifier

type VolumeMount struct {
	Volume    Volume
	MountPath string
}

type VolumeProperties map[string]string

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

type Worker interface {
	Client

	ActiveContainers() int

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

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)

	FindWorkerCheckResourceTypeVersion(workerName string, checkType string) (string, bool, error)

	UpdateExpiresAtOnContainer(handle string, ttl time.Duration) error
	ReapContainer(handle string) error

	InsertVolume(db.Volume) error
	GetVolumesByIdentifier(db.VolumeIdentifier) ([]db.SavedVolume, error)
	GetVolumeTTL(volumeHandle string) (time.Duration, bool, error)
	ReapVolume(handle string) error
	SetVolumeTTL(string, time.Duration) error
	SetVolumeSizeInBytes(string, int64) 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
	TeamID       int
}