dockerclient

type Address struct {
	Addr      string
	PrefixLen int
}

type BuildOptions struct {
	Image          string
	ContextDir     string
	DockerfilePath string
	NoCache        bool
	Pull           bool
	BuildArgs      map[string]string
	BuildFlags     map[string]bool
}

type Client interface {

	// Build will build a docker image, given build options
	Build(buildOptions *BuildOptions) error

	// CopyObjectsFromImage copies objects (files, directories) from a given image to local storage. it does
	// this through an intermediate container which is deleted afterwards
	CopyObjectsFromImage(imageName string, objectsToCopy map[string]string, allowCopyErrors bool) error

	// CopyObjectsToContainer copies objects (files, directories) from a local storage to a container
	// objectToCopy is a map where keys are local storage path and values are container paths
	CopyObjectsToContainer(containerName string, objectsToCopy map[string]string) error

	// PushImage pushes a local image to a remote docker repository
	PushImage(imageName string, registryURL string) error

	// PullImage pulls an image from a remote docker repository
	PullImage(imageURL string) error

	// RemoveImage will remove (delete) a local image
	RemoveImage(imageName string) error

	// RunContainer will run a container based on an image and run options
	RunContainer(imageName string, runOptions *RunOptions) (string, error)

	// ExecInContainer will run a command in a container
	ExecInContainer(containerID string, execOptions *ExecOptions) error

	// RemoveContainer removes a container given a container ID
	RemoveContainer(containerID string) error

	// StopContainer removes a container given a container ID
	StopContainer(containerID string) error

	// StartContainer starts a container given a container ID
	StartContainer(containerID string) error

	// GetContainerPort returns container port
	GetContainerPort(container *Container, boundPort int) (int, error)

	// GetContainerLogs returns raw logs from a given container ID
	GetContainerLogs(containerID string) (string, error)

	// GetContainers returns a list of containers which match a certain criteria
	GetContainers(*GetContainerOptions) ([]Container, error)

	// GetContainerEvents returns a list of container events which occurred within a time range
	GetContainerEvents(containerName string, since string, until string) ([]string, error)

	// AwaitContainerHealth blocks until the given container is healthy or the timeout passes
	AwaitContainerHealth(containerID string, timeout *time.Duration) error

	// LogIn allows docker client to access secured registries
	LogIn(options *LogInOptions) error

	// CreateNetwork creates a docker network
	CreateNetwork(*CreateNetworkOptions) error

	// GetContainerNetworkSettings returns container network settings
	GetContainerNetworkSettings(containerID string) (*NetworkSettings, error)

	// DeleteNetwork deletes a docker network
	DeleteNetwork(networkName string) error

	// CreateVolume create a docker volume
	CreateVolume(*CreateVolumeOptions) error

	// DeleteVolume delete a docker volume
	DeleteVolume(volumeName string) error

	// Save saves a docker image as tar in specified path
	Save(imageName string, outPath string) error

	// Load loads a docker image from tar as cached image
	Load(inPath string) error

	// GetVersion returns docker client and engine versions
	GetVersion(quiet bool) (string, error)

	// GetContainerIPAddresses return list of container ip addresses
	GetContainerIPAddresses(containerID string) ([]string, error)

	// GetContainerLogStream return container log stream
	GetContainerLogStream(ctx context.Context, containerID string, logOptions *ContainerLogsOptions) (io.ReadCloser, error)
}

type Config struct {
	Hostname     string              // Hostname
	Domainname   string              // Domainname
	User         string              // User that will run the command(s) inside the container, also support user:group
	AttachStdin  bool                // Attach the standard input, makes possible user interaction
	AttachStdout bool                // Attach the standard output
	AttachStderr bool                // Attach the standard error
	Tty          bool                // Attach standard streams to a tty, including stdin if it is not closed.
	OpenStdin    bool                // Open stdin
	StdinOnce    bool                // If true, close stdin after the 1 attached client disconnects.
	Env          []string            // List of environment variable to set in the container
	Cmd          StrSlice            // Command to run when starting the container
	Image        string              // Name of the image as it was passed by the operator (e.g. could be symbolic)
	Volumes      map[string]struct{} // List of volumes (mounts) used for the container
	WorkingDir   string              // Current directory (PWD) in the command will be launched
	Entrypoint   StrSlice            // Entrypoint to run when starting the container
	OnBuild      []string            // ONBUILD metadata that were defined on the image Dockerfile
	Labels       map[string]string   // List of labels set to this container
}

type Container struct {
	ID              string `json:"Id"`
	Created         string
	Path            string
	Args            []string
	State           *ContainerState
	Image           string
	ResolvConfPath  string
	HostnamePath    string
	HostsPath       string
	LogPath         string
	Name            string
	RestartCount    int
	Driver          string
	Platform        string
	MountLabel      string
	ProcessLabel    string
	AppArmorProfile string
	ExecIDs         []string
	HostConfig      *HostConfig
	Mounts          []MountPoint
	Config          *Config
	NetworkSettings *NetworkSettings
}

type ContainerLogsOptions struct {
	ShowStdout bool
	ShowStderr bool
	Since      string
	Until      string
	Timestamps bool
	Follow     bool
	Tail       string
	Details    bool
}

type ContainerState struct {
	Status     string // String representation of the container state. Can be one of "created", "running", "paused", "restarting", "removing", "exited", or "dead"
	Running    bool
	Paused     bool
	Restarting bool
	OOMKilled  bool
	Dead       bool
	Pid        int
	ExitCode   int
	Error      string
	StartedAt  string
	FinishedAt string
	Health     *Health
}

type CreateNetworkOptions struct {
	Name string
}

type CreateVolumeOptions struct {
	Name string
}

type DefaultNetworkSettings struct {
	EndpointID          string // EndpointID uniquely represents a service endpoint in a Sandbox
	Gateway             string // Gateway holds the gateway address for the network
	GlobalIPv6Address   string // GlobalIPv6Address holds network's global IPv6 address
	GlobalIPv6PrefixLen int    // GlobalIPv6PrefixLen represents mask length of network's global IPv6 address
	IPAddress           string // IPAddress holds the IPv4 address for the network
	IPPrefixLen         int    // IPPrefixLen represents mask length of network's IPv4 address
	IPv6Gateway         string // IPv6Gateway holds gateway address specific for IPv6
	MacAddress          string // MacAddress holds the MAC address for the network
}

type EndpointSettings struct {
	// Configurations
	Links   []string
	Aliases []string
	// Operational data
	NetworkID           string
	EndpointID          string
	Gateway             string
	IPAddress           string
	IPPrefixLen         int
	IPv6Gateway         string
	GlobalIPv6Address   string
	GlobalIPv6PrefixLen int
	MacAddress          string
	DriverOpts          map[string]string
}

type ExecOptions struct {
	Command string
	Stdout  *string
	Stderr  *string
	Env     map[string]string
}

type GetContainerOptions struct {
	Name    string
	Labels  map[string]string
	Stopped bool
	ID      string
}

type Health struct {
	Status        string
	FailingStreak int
	Log           []HealthLog
}

type HealthLog struct {
	Start    string
	End      string
	ExitCode int
	Output   string
}

type HostConfig struct {
	// Applicable to all platforms
	Binds           []string      // List of volume bindings for this container
	ContainerIDFile string        // File (path) where the containerId is written
	LogConfig       LogConfig     // Configuration of the logs for this container
	NetworkMode     string        // Network mode to use for the container
	PortBindings    PortMap       // Port mapping between the exposed port (container) and the host
	RestartPolicy   RestartPolicy // Restart policy to be used for the container
	AutoRemove      bool          // Automatically remove container when it exits
	VolumeDriver    string        // Name of the volume driver used to mount volumes
	VolumesFrom     []string      // List of volumes to take from other container

	// Applicable to UNIX platforms
	CapAdd          StrSlice          // List of kernel capabilities to add to the container
	CapDrop         StrSlice          // List of kernel capabilities to remove from the container
	DNS             []string          `json:"Dns"`        // List of DNS server to lookup
	DNSOptions      []string          `json:"DnsOptions"` // List of DNSOption to look for
	DNSSearch       []string          `json:"DnsSearch"`  // List of DNSSearch to look for
	ExtraHosts      []string          // List of extra hosts
	GroupAdd        []string          // List of additional groups that the container process will run as
	IpcMode         string            // IPC namespace to use for the container
	Cgroup          string            // Cgroup to use for the container
	Links           []string          // List of links (in the name:alias form)
	OomScoreAdj     int               // Container preference for OOM-killing
	PidMode         string            // PID namespace to use for the container
	Privileged      bool              // Is the container in privileged mode
	PublishAllPorts bool              // Should docker publish all exposed port for the container
	ReadonlyRootfs  bool              // Is the container root filesystem in read-only
	SecurityOpt     []string          // List of string values to customize labels for MLS systems, such as SELinux.
	StorageOpt      map[string]string `json:",omitempty"` // Storage driver options per container.
	Tmpfs           map[string]string `json:",omitempty"` // List of tmpfs (mounts) used for the container
	UTSMode         string            // UTS namespace to use for the container
	UsernsMode      string            // The user namespace to use for the container
	ShmSize         int64             // Total shm memory usage
	Sysctls         map[string]string `json:",omitempty"` // List of Namespaced sysctls used for the container
	Runtime         string            `json:",omitempty"` // Runtime to use with this container

	// Applicable to Windows
	ConsoleSize [2]uint // Initial console size (height,width)
	Isolation   string  // Isolation technology of the container (e.g. default, hyperv)

	// Run a custom init inside the container, if null, use the daemon's configured settings
	Init *bool `json:",omitempty"`
}

type LogConfig struct {
	Type   string
	Config map[string]string
}

type LogInOptions struct {
	Username string
	Password string
	URL      string
}

type MockDockerClient struct {
	mock.Mock
}

type MountPoint struct {
	Source      string
	Destination string
	Mode        string
	RW          bool
	Type        string
	Driver      string
	Name        string
}

type NetworkSettings struct {
	NetworkSettingsBase
	DefaultNetworkSettings
	Networks map[string]*EndpointSettings
}

type NetworkSettingsBase struct {
	Bridge                 string  // Bridge is the Bridge name the network uses(e.g. `docker0`)
	SandboxID              string  // SandboxID uniquely represents a container's network stack
	HairpinMode            bool    // HairpinMode specifies if hairpin NAT should be enabled on the virtual interface
	LinkLocalIPv6Address   string  // LinkLocalIPv6Address is an IPv6 unicast address using the link-local prefix
	LinkLocalIPv6PrefixLen int     // LinkLocalIPv6PrefixLen is the prefix length of an IPv6 unicast address
	Ports                  PortMap // Ports is a collection of PortBinding indexed by Port
	SandboxKey             string  // SandboxKey identifies the sandbox
	SecondaryIPAddresses   []Address
	SecondaryIPv6Addresses []Address
}

type Port string

type PortBinding struct {
	// HostIP is the host IP Address
	HostIP string `json:"HostIp"`
	// HostPort is the host port number
	HostPort string
}

type PortMap map[Port][]PortBinding

type PortSet map[Port]struct{}

type RestartPolicy struct {
	Name              RestartPolicyName
	MaximumRetryCount int
}

type RestartPolicyName string

type RunOptions struct {
	Ports            map[int]int
	ContainerName    string
	Env              map[string]string
	Labels           map[string]string
	Volumes          map[string]string
	Remove           bool
	Command          string
	Stdout           *string
	Stderr           *string
	Attach           bool
	ImageMayNotExist bool
	Network          string
	RestartPolicy    *RestartPolicy
	GPUs             string
	CPUs             string
	Memory           string
	MountPoints      []MountPoint
	RunAsUser        *int64
	RunAsGroup       *int64
	FSGroup          *int64
	Devices          []string
}

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

type StrSlice []string