build

type Build struct {
	ProducedSize int64
	VirtualSize  int64
	// contains filtered or unexported fields
}

type Cache interface {
	Get(s State) (s2 *State, err error)
	Put(s State) error
	Del(s State) error
}

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

type Client interface {
	InspectImage(name string) (*docker.Image, error)
	PullImage(name string) error
	ListImages() (images []*imagename.ImageName, err error)
	ListImageTags(name string) (images []*imagename.ImageName, err error)
	RemoveImage(imageID string) error
	TagImage(imageID, imageName string) error
	PushImage(imageName string) (digest string, err error)
	EnsureImage(imageName string) error
	CreateContainer(state State) (id string, err error)
	RunContainer(containerID string, attachStdin bool) error
	CommitContainer(state *State) (img *docker.Image, err error)
	RemoveContainer(containerID string) error
	UploadToContainer(containerID string, stream io.Reader, path string) error
	EnsureContainer(containerName string, config *docker.Config, hostConfig *docker.HostConfig, purpose string) (containerID string, err error)
	InspectContainer(containerName string) (*docker.Container, error)
	ResolveHostPath(path string) (resultPath string, err error)
}

type Command interface {
	// Execute does the command execution and returns modified state.
	// Note that here we use State not by reference because we want
	// it to be immutable. In future, it may encoded/decoded from json
	// and passed to the external command implementations.
	Execute(b *Build) (State, error)

	// Returns true if the command should be executed
	ShouldRun(b *Build) (bool, error)

	// String returns the human readable string representation of the command
	String() string
}

type CommandAdd struct {
	CommandBase
}

type CommandArg struct {
	CommandBase
}

type CommandAttach struct {
	CommandBase
}

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

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

type CommandCmd struct {
	CommandBase
}

type CommandCommit struct{}

type CommandCopy struct {
	CommandBase
}

type CommandEntrypoint struct {
	CommandBase
}

type CommandEnv struct {
	CommandBase
}

type CommandExport struct {
	CommandBase
}

type CommandExpose struct {
	CommandBase
}

type CommandFrom struct {
	CommandBase
}

type CommandImport struct {
	CommandBase
}

type CommandLabel struct {
	CommandBase
}

type CommandMaintainer struct {
	CommandBase
}

type CommandMount struct {
	CommandBase
}

type CommandOnbuild struct {
	CommandBase
}

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

type CommandPush struct {
	CommandBase
}

type CommandRun struct {
	CommandBase
}

type CommandTag struct {
	CommandBase
}

type CommandUser struct {
	CommandBase
}

type CommandVolume struct {
	CommandBase
}

type CommandWorkdir struct {
	CommandBase
}

type Config struct {
	OutStream     io.Writer
	InStream      io.ReadCloser
	ContextDir    string
	ID            string
	Dockerignore  []string
	ArtifactsPath string
	Pull          bool
	NoGarbage     bool
	Attach        bool
	Verbose       bool
	NoCache       bool
	ReloadCache   bool
	Push          bool
	CacheDir      string
	LogJSON       bool
	BuildArgs     map[string]string
}

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

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

type DockerClientOptions struct {
	Client                   *docker.Client
	Auth                     *docker.AuthConfigurations
	Log                      *logrus.Logger
	S3storage                *s3.StorageS3
	StdoutContainerFormatter logrus.Formatter
	StderrContainerFormatter logrus.Formatter
	PushRetryCount           int
	Host                     string
	LogExactSizes            bool
}

type EnvReplacableCommand interface {
	ReplaceEnv(env []string) error
}

type Plan []Command

type Rockerfile struct {
	Name    string
	Source  string
	Content string
	Vars    template.Vars
	Funs    template.Funs
	// contains filtered or unexported fields
}

type State struct {
	Config         docker.Config
	ImageID        string
	ParentID       string
	ExportsID      string
	NoBaseImage    bool
	ProducedImage  bool
	InjectCommands []string
	Commits        []string

	ParentSize int64
	Size       int64

	NoCache StateNoCache
}

type StateNoCache struct {
	Dockerignore []string
	CacheBusted  bool
	CmdSet       bool
	ContainerID  string
	HostConfig   docker.HostConfig
	BuildArgs    map[string]string
}

type URLFetcher interface {
	Get(url string) (*URLInfo, error)
	GetInfo(url string) (*URLInfo, error)
}

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

type URLInfo struct {
	ID       string
	URL      string
	FileName string `json:"-"`
	BaseName string
	HasEtag  bool
	Etag     string
	Size     int64
	Fetcher  *URLFetcherFS `json:"-"`
}