Documentation

Index

Constants

View Source
const (
	LocalScope  = "local"
	GlobalScope = "global"
)

    Scopes define if a volume has is cluster-wide (global) or local only. Scopes are returned by the volume driver when it is queried for capabilities and then set on a volume

    View Source
    const (
    	// DefaultCopyMode is the copy mode used by default for normal/named volumes
    	DefaultCopyMode = true
    )
    View Source
    const DefaultDriverName = "local"

      DefaultDriverName is the driver name used for the driver implemented in the local package.

      View Source
      const DefaultPropagationMode = mounttypes.PropagationRPrivate

        DefaultPropagationMode defines what propagation mode should be used by default if user has not specified one explicitly. propagation modes

        Variables

        This section is empty.

        Functions

        func ConvertTmpfsOptions

        func ConvertTmpfsOptions(opt *mounttypes.TmpfsOptions, readOnly bool) (string, error)

          ConvertTmpfsOptions converts *mounttypes.TmpfsOptions to the raw option string for mount(2).

          func GetPropagation

          func GetPropagation(mode string) mounttypes.Propagation

            GetPropagation extracts and returns the mount propagation mode. If there are no specifications, then by default it is "private".

            func HasPropagation

            func HasPropagation(mode string) bool

              HasPropagation checks if there is a valid propagation mode present in passed string. Returns true if a valid propagation mode specifier is present, false otherwise.

              func IsVolumeNameValid

              func IsVolumeNameValid(name string) (bool, error)

                IsVolumeNameValid checks a volume name in a platform specific manner.

                func ParseVolumesFrom

                func ParseVolumesFrom(spec string) (string, string, error)

                  ParseVolumesFrom ensures that the supplied volumes-from is valid.

                  func ReadWrite

                  func ReadWrite(mode string) bool

                    ReadWrite tells you if a mode string is a valid read-write mode or not. If there are no specifications w.r.t read write mode, then by default it returns true.

                    func ValidMountMode

                    func ValidMountMode(mode string) bool

                      ValidMountMode will make sure the mount mode is valid. returns if it's a valid mount mode or not.

                      Types

                      type Capability

                      type Capability struct {
                      	// Scope is the scope of the driver, `global` or `local`
                      	// A `global` scope indicates that the driver manages volumes across the cluster
                      	// A `local` scope indicates that the driver only manages volumes resources local to the host
                      	// Scope is declared by the driver
                      	Scope string
                      }

                        Capability defines a set of capabilities that a driver is able to handle.

                        type DetailedVolume

                        type DetailedVolume interface {
                        	Labels() map[string]string
                        	Options() map[string]string
                        	Scope() string
                        	Volume
                        }

                          DetailedVolume wraps a Volume with user-defined labels, options, and cluster scope (e.g., `local` or `global`)

                          type Driver

                          type Driver interface {
                          	// Name returns the name of the volume driver.
                          	Name() string
                          	// Create makes a new volume with the given id.
                          	Create(name string, opts map[string]string) (Volume, error)
                          	// Remove deletes the volume.
                          	Remove(vol Volume) (err error)
                          	// List lists all the volumes the driver has
                          	List() ([]Volume, error)
                          	// Get retrieves the volume with the requested name
                          	Get(name string) (Volume, error)
                          	// Scope returns the scope of the driver (e.g. `global` or `local`).
                          	// Scope determines how the driver is handled at a cluster level
                          	Scope() string
                          }

                            Driver is for creating and removing volumes.

                            type MountPoint

                            type MountPoint struct {
                            	// Source is the source path of the mount.
                            	// E.g. `mount --bind /foo /bar`, `/foo` is the `Source`.
                            	Source string
                            	// Destination is the path relative to the container root (`/`) to the mount point
                            	// It is where the `Source` is mounted to
                            	Destination string
                            	// RW is set to true when the mountpoint should be mounted as read-write
                            	RW bool
                            	// Name is the name reference to the underlying data defined by `Source`
                            	// e.g., the volume name
                            	Name string
                            	// Driver is the volume driver used to create the volume (if it is a volume)
                            	Driver string
                            	// Type of mount to use, see `Type<foo>` definitions in github.com/docker/docker/api/types/mount
                            	Type mounttypes.Type `json:",omitempty"`
                            	// Volume is the volume providing data to this mountpoint.
                            	// This is nil unless `Type` is set to `TypeVolume`
                            	Volume Volume `json:"-"`
                            
                            	// Mode is the comma separated list of options supplied by the user when creating
                            	// the bind/volume mount.
                            	// Note Mode is not used on Windows
                            	Mode string `json:"Relabel,omitempty"` // Originally field was `Relabel`"
                            
                            	// Propagation describes how the mounts are propagated from the host into the
                            	// mount point, and vice-versa.
                            	// See https://www.kernel.org/doc/Documentation/filesystems/sharedsubtree.txt
                            	// Note Propagation is not used on Windows
                            	Propagation mounttypes.Propagation `json:",omitempty"` // Mount propagation string
                            
                            	// Specifies if data should be copied from the container before the first mount
                            	// Use a pointer here so we can tell if the user set this value explicitly
                            	// This allows us to error out when the user explicitly enabled copy but we can't copy due to the volume being populated
                            	CopyData bool `json:"-"`
                            	// ID is the opaque ID used to pass to the volume driver.
                            	// This should be set by calls to `Mount` and unset by calls to `Unmount`
                            	ID string `json:",omitempty"`
                            
                            	// Sepc is a copy of the API request that created this mount.
                            	Spec mounttypes.Mount
                            }

                              MountPoint is the intersection point between a volume and a container. It specifies which volume is to be used and where inside a container it should be mounted.

                              func ParseMountRaw

                              func ParseMountRaw(raw, volumeDriver string) (*MountPoint, error)

                                ParseMountRaw parses a raw volume spec (e.g. `-v /foo:/bar:shared`) into a structured spec. Once the raw spec is parsed it relies on `ParseMountSpec` to validate the spec and create a MountPoint

                                func ParseMountSpec

                                func ParseMountSpec(cfg mounttypes.Mount, options ...func(*validateOpts)) (*MountPoint, error)

                                  ParseMountSpec reads a mount config, validates it, and configures a mountpoint from it.

                                  func (*MountPoint) BackwardsCompatible

                                  func (m *MountPoint) BackwardsCompatible() bool

                                    BackwardsCompatible decides whether this mount point can be used in old versions of Docker or not. Only bind mounts and local volumes can be used in old versions of Docker.

                                    func (*MountPoint) HasResource

                                    func (m *MountPoint) HasResource(absolutePath string) bool

                                      HasResource checks whether the given absolute path for a container is in this mount point. If the relative path starts with `../` then the resource is outside of this mount point, but we can't simply check for this prefix because it misses `..` which is also outside of the mount, so check both.

                                      func (*MountPoint) Path

                                      func (m *MountPoint) Path() string

                                        Path returns the path of a volume in a mount point.

                                        func (*MountPoint) Setup

                                        func (m *MountPoint) Setup(mountLabel string, rootUID, rootGID int) (string, error)

                                          Setup sets up a mount point by either mounting the volume if it is configured, or creating the source directory if supplied.

                                          type Volume

                                          type Volume interface {
                                          	// Name returns the name of the volume
                                          	Name() string
                                          	// DriverName returns the name of the driver which owns this volume.
                                          	DriverName() string
                                          	// Path returns the absolute path to the volume.
                                          	Path() string
                                          	// Mount mounts the volume and returns the absolute path to
                                          	// where it can be consumed.
                                          	Mount(id string) (string, error)
                                          	// Unmount unmounts the volume when it is no longer in use.
                                          	Unmount(id string) error
                                          	// Status returns low-level status information about a volume
                                          	Status() map[string]interface{}
                                          }

                                            Volume is a place to store data. It is backed by a specific driver, and can be mounted.

                                            Directories

                                            Path Synopsis
                                            Package local provides the default implementation for volumes.
                                            Package local provides the default implementation for volumes.