docker

type Auther interface {
	// DockerAuth should return docker auth credentials that will authenticate
	// against a docker registry for a given drivers.ContainerTask.Image(). An
	// error may be returned which will cause the task not to be run, this can be
	// useful for an implementer to do things like testing auth configurations
	// before returning them; e.g. if the implementer would like to impose
	// certain restrictions on images or if credentials must be acquired right
	// before runtime and there's an error doing so. If these credentials don't
	// work, the docker pull will fail and the task will be set to error status.
	DockerAuth(ctx context.Context, image string) (*docker.AuthConfiguration, error)
}

type CachedImage struct {
	ID       string // Image Cache key
	ParentID string
	RepoTags []string // RepoTags are used to match special/status images that are exempt from image cache
	Size     uint64
}

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

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

type DockerPool interface {
	// fetch a pre-allocated free id from the pool
	// may return too busy error.
	AllocPoolId() (string, error)

	// Release the id back to the pool
	FreePoolId(id string)

	// stop and terminate the pool
	Close() error

	// returns inuse versus free
	Usage() DockerPoolStats
}

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

type ImageCacher interface {
	// IsMaxCapacity returns true if total size of all images exceeds the limit
	// and if there's an image in LRU cache that can be removed.
	IsMaxCapacity() bool

	// GetNotifier returns a channel that can be monitored. The channel will return
	// data every time IsMaxCapacity() flips from false to true state.
	GetNotifier() <-chan struct{}

	// Removes an image from the LRU cache if cache is not empty
	Pop() *CachedImage

	// Update adds an image to the LRU cache if the image is not marked in-use
	Update(img *CachedImage)

	// Mark/Unmark an image in-use. If an image is in-use, it will
	// not be a candidate in LRU. When the reference count of the
	// image drops to zero (via MarkFree() calls), the image will
	// be added back to LRU.
	MarkBusy(img *CachedImage)
	MarkFree(img *CachedImage)

	// Stats Monitoring
	GetStats() *ImageCacherStats
}

type ImageCacherStats struct {
	BusyImgTotalSize uint64
	BusyImgCount     uint64
	IdleImgTotalSize uint64
	IdleImgCount     uint64
	MaxImgTotalSize  uint64
}

type ImagePuller interface {
	PullImage(ctx context.Context, cfg *docker.AuthConfiguration, img, repo, tag string) chan error
	SetRetryPolicy(policy common.BackOffConfig, checker drivers.RetryErrorChecker) error
}

type PoolTaskStateType int