docker

type BuildOptions struct {
	Context            io.Reader
	Dockerfile         string
	Remove             bool
	BuildArgs          map[string]*string
	Target             string
	SSHSpecs           []string
	SecretSpecs        []string
	Network            string
	CacheFrom          []string
	PullParent         bool
	Platform           string
	ExtraTags          []string
	ForceLegacyBuilder bool
	DirSource          filesync.DirSource
	ExtraHosts         []string
}

type Cli struct {
	*client.Client
	// contains filtered or unexported fields
}

type Client interface {
	CheckConnected() error

	// If you'd like to call this Docker instance in a separate process, these
	// are the environment variables you'll need to do so.
	Env() Env

	// If you'd like to call this Docker instance in a separate process, this
	// is the default builder version you want (buildkit or legacy)
	BuilderVersion(ctx context.Context) (types.BuilderVersion, error)

	ServerVersion(ctx context.Context) (types.Version, error)

	// Set the orchestrator we're talking to. This is only relevant to switchClient,
	// which can talk to either the Local or in-cluster docker daemon.
	SetOrchestrator(orc model.Orchestrator)
	// Return a client suitable for use with the given orchestrator. Only
	// relevant for the switchClient which has clients for both types.
	ForOrchestrator(orc model.Orchestrator) Client

	ContainerLogs(ctx context.Context, container string, options types.ContainerLogsOptions) (io.ReadCloser, error)
	ContainerInspect(ctx context.Context, containerID string) (types.ContainerJSON, error)
	ContainerList(ctx context.Context, options types.ContainerListOptions) ([]types.Container, error)
	ContainerRestartNoWait(ctx context.Context, containerID string) error

	Run(ctx context.Context, opts RunConfig) (RunResult, error)

	// Execute a command in a container, streaming the command output to `out`.
	// Returns an ExitError if the command exits with a non-zero exit code.
	ExecInContainer(ctx context.Context, cID container.ID, cmd model.Cmd, in io.Reader, out io.Writer) error

	ImagePull(ctx context.Context, ref reference.Named) (reference.Canonical, error)
	ImagePush(ctx context.Context, image reference.NamedTagged) (io.ReadCloser, error)
	ImageBuild(ctx context.Context, g *errgroup.Group, buildContext io.Reader, options BuildOptions) (types.ImageBuildResponse, error)
	ImageTag(ctx context.Context, source, target string) error
	ImageInspectWithRaw(ctx context.Context, imageID string) (types.ImageInspect, []byte, error)
	ImageList(ctx context.Context, options types.ImageListOptions) ([]types.ImageSummary, error)
	ImageRemove(ctx context.Context, imageID string, options types.ImageRemoveOptions) ([]types.ImageDeleteResponseItem, error)

	NewVersionError(APIrequired, feature string) error
	BuildCachePrune(ctx context.Context, opts types.BuildCachePruneOptions) (*types.BuildCachePruneReport, error)
	ContainersPrune(ctx context.Context, pruneFilters filters.Args) (types.ContainersPruneReport, error)
}

type ClientCreator interface {
	FromCLI(ctx context.Context) (DaemonClient, error)
	FromEnvMap(envMap map[string]string) (DaemonClient, error)
}

type ClusterClient Client

type ClusterEnv Env

type CompositeClient interface {
	Client
	DefaultLocalClient() Client
	DefaultClusterClient() Client
	ClientFor(cluster v1alpha1.Cluster) Client
	HasMultipleClients() bool
}

type DaemonClient interface {
	DaemonHost() string
}

type Env struct {
	// The Docker API client.
	//
	// The Docker API builders are very complex, with lots of different interfaces
	// and concrete types, even though, underneath, they're all the same *client.Client.
	// We use DaemonClient here because that's what we need to compare envs.
	Client DaemonClient

	// Environment variables to inject into any subshell that uses this client.
	Environ []string

	// Minikube's docker client has a bug where it can't use buildkit. See:
	// https://github.com/kubernetes/minikube/issues/4143
	IsOldMinikube bool

	// Some Kubernetes contexts have a Docker daemon that they use directly
	// as their container runtime. Any images built on that daemon will
	// show up automatically in the runtime.
	//
	// We used to store this as a property of the k8s env but now store it as a field of the Docker Env, because this
	// really affects how we interact with the Docker Env (rather than
	// how we interact with the K8s Env).
	//
	// In theory, you can have more than one, but in practice,
	// this is very difficult to set up.
	BuildToKubeContexts []string

	// If the env failed to load for some reason, propagate that error
	// so that we can report it when the user tries to do a docker_build.
	Error error
}

type ExecCall struct {
	Container string
	Cmd       model.Cmd
}

type ExitError struct {
	ExitCode int
}

type FakeClient struct {
	FakeEnv Env

	PushCount   int
	PushImage   string
	PushOptions types.ImagePushOptions
	PushOutput  string

	BuildCount        int
	BuildOptions      BuildOptions
	BuildContext      *bytes.Buffer
	BuildOutput       string
	BuildErrorToThrow error // next call to Build will throw this err (after which we clear the error)

	ImageListCount int
	ImageListOpts  []types.ImageListOptions

	TagCount  int
	TagSource string
	TagTarget string

	ContainerListOutput map[string][]types.Container

	CopyCount     int
	CopyContainer string
	CopyContent   io.Reader

	ExecCalls         []ExecCall
	ExecErrorsToThrow []error // next call to exec will throw ExecError[0] (which we then pop)

	RestartsByContainer map[string]int
	RemovedImageIDs     []string

	// Images returned by ImageInspect.
	Images map[string]types.ImageInspect

	// Containers returned by ContainerInspect
	Containers        map[string]types.ContainerState
	ContainerLogChans map[string]<-chan string

	// If true, ImageInspectWithRaw will always return an ImageInspect,
	// even if one hasn't been explicitly pre-loaded.
	ImageAlwaysExists bool

	Orchestrator      model.Orchestrator
	CheckConnectedErr error

	ThrowNewVersionError   bool
	BuildCachePruneErr     error
	BuildCachePruneOpts    types.BuildCachePruneOptions
	BuildCachesPruned      []string
	ContainersPruneErr     error
	ContainersPruneFilters filters.Args
	ContainersPruned       []string
}

type ImgNameAndTag struct {
	Name string
	Tag  string
}

type LocalClient Client

type LocalEnv Env

type RealClientCreator struct{}

type RunConfig struct {
	// Image to execute.
	//
	// If Pull is true, this must be a reference.Named.
	Image reference.Reference
	// Pull will ensure the image exists locally before running.
	//
	// If an image will only be used once, this is a convenience to avoid calling ImagePull first.
	// If an image will be used multiple times (across containers), prefer explicitly calling ImagePull
	// to avoid the overhead of calling the registry API to check if the image is up-to-date every time.
	Pull bool
	// ContainerName is a unique name for the container. If not specified, Docker will generate a random name.
	ContainerName string
	// Stdout from the container will be written here if non-nil.
	//
	// Errors copying the container output are logged but not propagated.
	Stdout io.Writer
	// Stderr from the container will be written here if non-nil.
	//
	// Errors copying the container output are logged but not propagated.
	Stderr io.Writer
	// Cmd to run when starting the container.
	Cmd []string
	// Mounts to attach to the container.
	Mounts []mount.Mount
}

type RunResult struct {
	ContainerID string
	// contains filtered or unexported fields
}