Documentation

Overview

    Package volume includes internal representations of external volume types as well as utility methods required to mount/unmount volumes to kubelets.

    Index

    Constants

    View Source
    const (
    	// ErrCodeNotSupported code for NotSupported Errors.
    	ErrCodeNotSupported int = iota + 1
    	ErrCodeNoPathDefined
    	ErrCodeFsInfoFailed
    )
    View Source
    const (
    	// Name of a volume in external cloud that is being provisioned and thus
    	// should be ignored by rest of Kubernetes.
    	ProvisionedVolumeName = "placeholder-for-provisioning"
    	// Mount options annotations
    	MountOptionAnnotation = "volume.beta.kubernetes.io/mount-options"
    )

    Variables

    This section is empty.

    Functions

    func CalculateTimeoutForVolume

    func CalculateTimeoutForVolume(minimumTimeout, timeoutIncrement int, pv *v1.PersistentVolume) int64

      CalculateTimeoutForVolume calculates time for a Recycler pod to complete a recycle operation. The calculation and return value is either the minimumTimeout or the timeoutIncrement per Gi of storage size, whichever is greater.

      func ChooseZoneForVolume

      func ChooseZoneForVolume(zones sets.String, pvcName string) string

        ChooseZone implements our heuristics for choosing a zone for volume creation based on the volume name Volumes are generally round-robin-ed across all active zones, using the hash of the PVC Name. However, if the PVCName ends with `-<integer>`, we will hash the prefix, and then add the integer to the hash. This means that a StatefulSet's volumes (`claimname-statefulsetname-id`) will spread across available zones, assuming the id values are consecutive.

        func GenerateVolumeName

        func GenerateVolumeName(clusterName, pvName string, maxLength int) string

          GenerateVolumeName returns a PV name with clusterName prefix. The function should be used to generate a name of GCE PD or Cinder volume. It basically adds "<clusterName>-dynamic-" before the PV name, making sure the resulting string fits given length and cuts "dynamic" if not.

          func GetPath

          func GetPath(mounter Mounter) (string, error)

            Check if the path from the mounter is empty.

            func IsDeletedVolumeInUse

            func IsDeletedVolumeInUse(err error) bool

              IsDeletedVolumeInUse returns true if an error returned from Delete() is deletedVolumeInUseError

              func IsNotSupported

              func IsNotSupported(err error) bool

                IsNotSupported returns true if and only if err is "key" not found error.

                func JoinMountOptions

                func JoinMountOptions(userOptions []string, systemOptions []string) []string

                  JoinMountOptions joins mount options eliminating duplicates

                  func MountOptionFromSpec

                  func MountOptionFromSpec(spec *Spec, options ...string) []string

                    MountOptionFromSpec extracts and joins mount options from volume spec with supplied options

                    func NewDeletedVolumeInUseError

                    func NewDeletedVolumeInUseError(message string) error

                      NewDeletedVolumeInUseError returns a new instance of DeletedVolumeInUseError error.

                      func NewPersistentVolumeRecyclerPodTemplate

                      func NewPersistentVolumeRecyclerPodTemplate() *v1.Pod

                        NewPersistentVolumeRecyclerPodTemplate creates a template for a recycler pod. By default, a recycler pod simply runs "rm -rf" on a volume and tests for emptiness. Most attributes of the template will be correct for most plugin implementations. The following attributes can be overridden per plugin via configuration:

                        1. pod.Spec.Volumes[0].VolumeSource must be overridden. Recycler

                        implementations without a valid VolumeSource will fail.
                        

                        2. pod.GenerateName helps distinguish recycler pods by name. Recommended.

                        Default is "pv-recycler-".
                        

                        3. pod.Spec.ActiveDeadlineSeconds gives the recycler pod a maximum timeout

                        before failing.  Recommended.  Default is 60 seconds.
                        

                        See HostPath and NFS for working recycler examples

                        func RecycleVolumeByWatchingPodUntilCompletion

                        func RecycleVolumeByWatchingPodUntilCompletion(pvName string, pod *v1.Pod, kubeClient clientset.Interface, recorder RecycleEventRecorder) error

                          RecycleVolumeByWatchingPodUntilCompletion is intended for use with volume Recyclers. This function will save the given Pod to the API and watch it until it completes, fails, or the pod's ActiveDeadlineSeconds is exceeded, whichever comes first. An attempt to delete a recycler pod is always attempted before returning.

                          In case there is a pod with the same namespace+name already running, this function assumes it's an older instance of the recycler pod and watches this old pod instead of starting a new one.

                           pod - the pod designed by a volume plugin to recycle the volume. pod.Name
                                 will be overwritten with unique name based on PV.Name.
                          	client - kube client for API operations.
                          

                          func RenameDirectory

                          func RenameDirectory(oldPath, newName string) (string, error)

                          func RoundUpSize

                          func RoundUpSize(volumeSizeBytes int64, allocationUnitBytes int64) int64

                            RoundUpSize calculates how many allocation units are needed to accommodate a volume of given size. E.g. when user wants 1500MiB volume, while AWS EBS allocates volumes in gibibyte-sized chunks, RoundUpSize(1500 * 1024*1024, 1024*1024*1024) returns '2' (2 GiB is the smallest allocatable volume that can hold 1500MiB)

                            func SetVolumeOwnership

                            func SetVolumeOwnership(mounter Mounter, fsGroup *int64) error

                              SetVolumeOwnership modifies the given volume to be owned by fsGroup, and sets SetGid so that newly created files are owned by fsGroup. If fsGroup is nil nothing is done.

                              func UnmountViaEmptyDir

                              func UnmountViaEmptyDir(dir string, host VolumeHost, volName string, volSpec Spec, podUID types.UID) error

                                UnmountViaEmptyDir delegates the tear down operation for secret, configmap, git_repo and downwardapi to empty_dir

                                func ValidateRecyclerPodTemplate

                                func ValidateRecyclerPodTemplate(pod *v1.Pod) error

                                  Check validity of recycle pod template List of checks: - at least one volume is defined in the recycle pod template If successful, returns nil if unsuccessful, returns an error.

                                  Types

                                  type AttachableVolumePlugin

                                  type AttachableVolumePlugin interface {
                                  	VolumePlugin
                                  	NewAttacher() (Attacher, error)
                                  	NewDetacher() (Detacher, error)
                                  	GetDeviceMountRefs(deviceMountPath string) ([]string, error)
                                  }

                                    AttachableVolumePlugin is an extended interface of VolumePlugin and is used for volumes that require attachment to a node before mounting.

                                    type Attacher

                                    type Attacher interface {
                                    	// Attaches the volume specified by the given spec to the node with the given Name.
                                    	// On success, returns the device path where the device was attached on the
                                    	// node.
                                    	Attach(spec *Spec, nodeName types.NodeName) (string, error)
                                    
                                    	// VolumesAreAttached checks whether the list of volumes still attached to the specified
                                    	// node. It returns a map which maps from the volume spec to the checking result.
                                    	// If an error is occurred during checking, the error will be returned
                                    	VolumesAreAttached(specs []*Spec, nodeName types.NodeName) (map[*Spec]bool, error)
                                    
                                    	// WaitForAttach blocks until the device is attached to this
                                    	// node. If it successfully attaches, the path to the device
                                    	// is returned. Otherwise, if the device does not attach after
                                    	// the given timeout period, an error will be returned.
                                    	WaitForAttach(spec *Spec, devicePath string, timeout time.Duration) (string, error)
                                    
                                    	// GetDeviceMountPath returns a path where the device should
                                    	// be mounted after it is attached. This is a global mount
                                    	// point which should be bind mounted for individual volumes.
                                    	GetDeviceMountPath(spec *Spec) (string, error)
                                    
                                    	// MountDevice mounts the disk to a global path which
                                    	// individual pods can then bind mount
                                    	MountDevice(spec *Spec, devicePath string, deviceMountPath string) error
                                    }

                                      Attacher can attach a volume to a node.

                                      type Attributes

                                      type Attributes struct {
                                      	ReadOnly        bool
                                      	Managed         bool
                                      	SupportsSELinux bool
                                      }

                                        Attributes represents the attributes of this mounter.

                                        type BulkVolumeVerifier

                                        type BulkVolumeVerifier interface {
                                        	// BulkVerifyVolumes checks whether the list of volumes still attached to the
                                        	// the clusters in the node. It returns a map which maps from the volume spec to the checking result.
                                        	// If an error occurs during check - error should be returned and volume on nodes
                                        	// should be assumed as still attached.
                                        	BulkVerifyVolumes(volumesByNode map[types.NodeName][]*Spec) (map[types.NodeName]map[*Spec]bool, error)
                                        }

                                        type DeletableVolumePlugin

                                        type DeletableVolumePlugin interface {
                                        	VolumePlugin
                                        	// NewDeleter creates a new volume.Deleter which knows how to delete this
                                        	// resource in accordance with the underlying storage provider after the
                                        	// volume's release from a claim
                                        	NewDeleter(spec *Spec) (Deleter, error)
                                        }

                                          DeletableVolumePlugin is an extended interface of VolumePlugin and is used by persistent volumes that want to be deleted from the cluster after their release from a PersistentVolumeClaim.

                                          type Deleter

                                          type Deleter interface {
                                          	Volume
                                          	// This method should block until completion.
                                          	// deletedVolumeInUseError returned from this function will not be reported
                                          	// as error and it will be sent as "Info" event to the PV being deleted. The
                                          	// volume controller will retry deleting the volume in the next periodic
                                          	// sync. This can be used to postpone deletion of a volume that is being
                                          	// detached from a node. Deletion of such volume would fail anyway and such
                                          	// error would confuse users.
                                          	Delete() error
                                          }

                                            Deleter removes the resource from the underlying storage provider. Calls to this method should block until the deletion is complete. Any error returned indicates the volume has failed to be reclaimed. A nil return indicates success.

                                            type Detacher

                                            type Detacher interface {
                                            	// Detach the given device from the node with the given Name.
                                            	Detach(deviceName string, nodeName types.NodeName) error
                                            
                                            	// UnmountDevice unmounts the global mount of the disk. This
                                            	// should only be called once all bind mounts have been
                                            	// unmounted.
                                            	UnmountDevice(deviceMountPath string) error
                                            }

                                              Detacher can detach a volume from a node.

                                              type Metrics

                                              type Metrics struct {
                                              	// The time at which these stats were updated.
                                              	Time metav1.Time
                                              
                                              	// Used represents the total bytes used by the Volume.
                                              	// Note: For block devices this maybe more than the total size of the files.
                                              	Used *resource.Quantity
                                              
                                              	// Capacity represents the total capacity (bytes) of the volume's
                                              	// underlying storage. For Volumes that share a filesystem with the host
                                              	// (e.g. emptydir, hostpath) this is the size of the underlying storage,
                                              	// and will not equal Used + Available as the fs is shared.
                                              	Capacity *resource.Quantity
                                              
                                              	// Available represents the storage space available (bytes) for the
                                              	// Volume. For Volumes that share a filesystem with the host (e.g.
                                              	// emptydir, hostpath), this is the available space on the underlying
                                              	// storage, and is shared with host processes and other Volumes.
                                              	Available *resource.Quantity
                                              
                                              	// InodesUsed represents the total inodes used by the Volume.
                                              	InodesUsed *resource.Quantity
                                              
                                              	// Inodes represents the total number of inodes available in the volume.
                                              	// For volumes that share a filesystem with the host (e.g. emptydir, hostpath),
                                              	// this is the inodes available in the underlying storage,
                                              	// and will not equal InodesUsed + InodesFree as the fs is shared.
                                              	Inodes *resource.Quantity
                                              
                                              	// InodesFree represent the inodes available for the volume.  For Volumes that share
                                              	// a filesystem with the host (e.g. emptydir, hostpath), this is the free inodes
                                              	// on the underlying storage, and is shared with host processes and other volumes
                                              	InodesFree *resource.Quantity
                                              }

                                                Metrics represents the used and available bytes of the Volume.

                                                type MetricsError

                                                type MetricsError struct {
                                                	Code int
                                                	Msg  string
                                                }

                                                  MetricsError to distinguish different Metrics Errors.

                                                  func NewFsInfoFailedError

                                                  func NewFsInfoFailedError(err error) *MetricsError

                                                    NewFsInfoFailedError creates a new MetricsError with code FsInfoFailed.

                                                    func NewNoPathDefinedError

                                                    func NewNoPathDefinedError() *MetricsError

                                                      NewNoPathDefined creates a new MetricsError with code NoPathDefined.

                                                      func NewNotSupportedError

                                                      func NewNotSupportedError() *MetricsError

                                                        NewNotSupportedError creates a new MetricsError with code NotSupported.

                                                        func (*MetricsError) Error

                                                        func (e *MetricsError) Error() string

                                                        type MetricsNil

                                                        type MetricsNil struct{}

                                                          MetricsNil represents a MetricsProvider that does not support returning Metrics. It serves as a placeholder for Volumes that do not yet support metrics.

                                                          func (*MetricsNil) GetMetrics

                                                          func (*MetricsNil) GetMetrics() (*Metrics, error)

                                                            GetMetrics returns an empty Metrics and an error. See MetricsProvider.GetMetrics

                                                            type MetricsProvider

                                                            type MetricsProvider interface {
                                                            	// GetMetrics returns the Metrics for the Volume. Maybe expensive for
                                                            	// some implementations.
                                                            	GetMetrics() (*Metrics, error)
                                                            }

                                                              MetricsProvider exposes metrics (e.g. used,available space) related to a Volume.

                                                              func NewCachedMetrics

                                                              func NewCachedMetrics(provider MetricsProvider) MetricsProvider

                                                                NewCachedMetrics creates a new cachedMetrics wrapping another MetricsProvider and caching the results.

                                                                func NewMetricsDu

                                                                func NewMetricsDu(path string) MetricsProvider

                                                                  NewMetricsDu creates a new metricsDu with the Volume path.

                                                                  func NewMetricsStatFS

                                                                  func NewMetricsStatFS(path string) MetricsProvider

                                                                    NewMetricsStatfs creates a new metricsStatFS with the Volume path.

                                                                    type Mounter

                                                                    type Mounter interface {
                                                                    	// Uses Interface to provide the path for Docker binds.
                                                                    	Volume
                                                                    
                                                                    	// CanMount is called immediately prior to Setup to check if
                                                                    	// the required components (binaries, etc.) are available on
                                                                    	// the underlying node to complete the subsequent SetUp (mount)
                                                                    	// operation. If CanMount returns error, the mount operation is
                                                                    	// aborted and an event is generated indicating that the node
                                                                    	// does not have the required binaries to complete the mount.
                                                                    	// If CanMount succeeds, the mount operation continues
                                                                    	// normally. The CanMount check can be enabled or disabled
                                                                    	// using the experimental-check-mount-binaries binary flag
                                                                    	CanMount() error
                                                                    
                                                                    	// SetUp prepares and mounts/unpacks the volume to a
                                                                    	// self-determined directory path. The mount point and its
                                                                    	// content should be owned by 'fsGroup' so that it can be
                                                                    	// accessed by the pod. This may be called more than once, so
                                                                    	// implementations must be idempotent.
                                                                    	SetUp(fsGroup *int64) error
                                                                    	// SetUpAt prepares and mounts/unpacks the volume to the
                                                                    	// specified directory path, which may or may not exist yet.
                                                                    	// The mount point and its content should be owned by
                                                                    	// 'fsGroup' so that it can be accessed by the pod. This may
                                                                    	// be called more than once, so implementations must be
                                                                    	// idempotent.
                                                                    	SetUpAt(dir string, fsGroup *int64) error
                                                                    	// GetAttributes returns the attributes of the mounter.
                                                                    	GetAttributes() Attributes
                                                                    }

                                                                      Mounter interface provides methods to set up/mount the volume.

                                                                      type PersistentVolumePlugin

                                                                      type PersistentVolumePlugin interface {
                                                                      	VolumePlugin
                                                                      	// GetAccessModes describes the ways a given volume can be accessed/mounted.
                                                                      	GetAccessModes() []v1.PersistentVolumeAccessMode
                                                                      }

                                                                        PersistentVolumePlugin is an extended interface of VolumePlugin and is used by volumes that want to provide long term persistence of data

                                                                        type ProvisionableVolumePlugin

                                                                        type ProvisionableVolumePlugin interface {
                                                                        	VolumePlugin
                                                                        	// NewProvisioner creates a new volume.Provisioner which knows how to
                                                                        	// create PersistentVolumes in accordance with the plugin's underlying
                                                                        	// storage provider
                                                                        	NewProvisioner(options VolumeOptions) (Provisioner, error)
                                                                        }

                                                                          ProvisionableVolumePlugin is an extended interface of VolumePlugin and is used to create volumes for the cluster.

                                                                          type Provisioner

                                                                          type Provisioner interface {
                                                                          	// Provision creates the resource by allocating the underlying volume in a
                                                                          	// storage system. This method should block until completion and returns
                                                                          	// PersistentVolume representing the created storage resource.
                                                                          	Provision() (*v1.PersistentVolume, error)
                                                                          }

                                                                            Provisioner is an interface that creates templates for PersistentVolumes and can create the volume as a new resource in the infrastructure provider.

                                                                            type RecyclableVolumePlugin

                                                                            type RecyclableVolumePlugin interface {
                                                                            	VolumePlugin
                                                                            
                                                                            	// Recycle knows how to reclaim this
                                                                            	// resource after the volume's release from a PersistentVolumeClaim.
                                                                            	// Recycle will use the provided recorder to write any events that might be
                                                                            	// interesting to user. It's expected that caller will pass these events to
                                                                            	// the PV being recycled.
                                                                            	Recycle(pvName string, spec *Spec, eventRecorder RecycleEventRecorder) error
                                                                            }

                                                                              RecyclableVolumePlugin is an extended interface of VolumePlugin and is used by persistent volumes that want to be recycled before being made available again to new claims

                                                                              type RecycleEventRecorder

                                                                              type RecycleEventRecorder func(eventtype, message string)

                                                                              type Spec

                                                                              type Spec struct {
                                                                              	Volume           *v1.Volume
                                                                              	PersistentVolume *v1.PersistentVolume
                                                                              	ReadOnly         bool
                                                                              }

                                                                                Spec is an internal representation of a volume. All API volume types translate to Spec.

                                                                                func NewSpecFromPersistentVolume

                                                                                func NewSpecFromPersistentVolume(pv *v1.PersistentVolume, readOnly bool) *Spec

                                                                                  NewSpecFromPersistentVolume creates an Spec from an v1.PersistentVolume

                                                                                  func NewSpecFromVolume

                                                                                  func NewSpecFromVolume(vs *v1.Volume) *Spec

                                                                                    NewSpecFromVolume creates an Spec from an v1.Volume

                                                                                    func (*Spec) Name

                                                                                    func (spec *Spec) Name() string

                                                                                      Name returns the name of either Volume or PersistentVolume, one of which must not be nil.

                                                                                      type Unmounter

                                                                                      type Unmounter interface {
                                                                                      	Volume
                                                                                      	// TearDown unmounts the volume from a self-determined directory and
                                                                                      	// removes traces of the SetUp procedure.
                                                                                      	TearDown() error
                                                                                      	// TearDown unmounts the volume from the specified directory and
                                                                                      	// removes traces of the SetUp procedure.
                                                                                      	TearDownAt(dir string) error
                                                                                      }

                                                                                        Unmounter interface provides methods to cleanup/unmount the volumes.

                                                                                        type Volume

                                                                                        type Volume interface {
                                                                                        	// GetPath returns the path to which the volume should be mounted for the
                                                                                        	// pod.
                                                                                        	GetPath() string
                                                                                        
                                                                                        	// MetricsProvider embeds methods for exposing metrics (e.g.
                                                                                        	// used, available space).
                                                                                        	MetricsProvider
                                                                                        }

                                                                                          Volume represents a directory used by pods or hosts on a node. All method implementations of methods in the volume interface must be idempotent.

                                                                                          type VolumeConfig

                                                                                          type VolumeConfig struct {
                                                                                          	// RecyclerPodTemplate is pod template that understands how to scrub clean
                                                                                          	// a persistent volume after its release. The template is used by plugins
                                                                                          	// which override specific properties of the pod in accordance with that
                                                                                          	// plugin. See NewPersistentVolumeRecyclerPodTemplate for the properties
                                                                                          	// that are expected to be overridden.
                                                                                          	RecyclerPodTemplate *v1.Pod
                                                                                          
                                                                                          	// RecyclerMinimumTimeout is the minimum amount of time in seconds for the
                                                                                          	// recycler pod's ActiveDeadlineSeconds attribute. Added to the minimum
                                                                                          	// timeout is the increment per Gi of capacity.
                                                                                          	RecyclerMinimumTimeout int
                                                                                          
                                                                                          	// RecyclerTimeoutIncrement is the number of seconds added to the recycler
                                                                                          	// pod's ActiveDeadlineSeconds for each Gi of capacity in the persistent
                                                                                          	// volume. Example: 5Gi volume x 30s increment = 150s + 30s minimum = 180s
                                                                                          	// ActiveDeadlineSeconds for recycler pod
                                                                                          	RecyclerTimeoutIncrement int
                                                                                          
                                                                                          	// PVName is name of the PersistentVolume instance that is being recycled.
                                                                                          	// It is used to generate unique recycler pod name.
                                                                                          	PVName string
                                                                                          
                                                                                          	// OtherAttributes stores config as strings.  These strings are opaque to
                                                                                          	// the system and only understood by the binary hosting the plugin and the
                                                                                          	// plugin itself.
                                                                                          	OtherAttributes map[string]string
                                                                                          
                                                                                          	// ProvisioningEnabled configures whether provisioning of this plugin is
                                                                                          	// enabled or not. Currently used only in host_path plugin.
                                                                                          	ProvisioningEnabled bool
                                                                                          }

                                                                                            VolumeConfig is how volume plugins receive configuration. An instance specific to the plugin will be passed to the plugin's ProbeVolumePlugins(config) func. Reasonable defaults will be provided by the binary hosting the plugins while allowing override of those default values. Those config values are then set to an instance of VolumeConfig and passed to the plugin.

                                                                                            Values in VolumeConfig are intended to be relevant to several plugins, but not necessarily all plugins. The preference is to leverage strong typing in this struct. All config items must have a descriptive but non-specific name (i.e, RecyclerMinimumTimeout is OK but RecyclerMinimumTimeoutForNFS is !OK). An instance of config will be given directly to the plugin, so config names specific to plugins are unneeded and wrongly expose plugins in this VolumeConfig struct.

                                                                                            OtherAttributes is a map of string values intended for one-off configuration of a plugin or config that is only relevant to a single plugin. All values are passed by string and require interpretation by the plugin. Passing config as strings is the least desirable option but can be used for truly one-off configuration. The binary should still use strong typing for this value when binding CLI values before they are passed as strings in OtherAttributes.

                                                                                            type VolumeHost

                                                                                            type VolumeHost interface {
                                                                                            	// GetPluginDir returns the absolute path to a directory under which
                                                                                            	// a given plugin may store data.  This directory might not actually
                                                                                            	// exist on disk yet.  For plugin data that is per-pod, see
                                                                                            	// GetPodPluginDir().
                                                                                            	GetPluginDir(pluginName string) string
                                                                                            
                                                                                            	// GetPodVolumeDir returns the absolute path a directory which
                                                                                            	// represents the named volume under the named plugin for the given
                                                                                            	// pod.  If the specified pod does not exist, the result of this call
                                                                                            	// might not exist.
                                                                                            	GetPodVolumeDir(podUID types.UID, pluginName string, volumeName string) string
                                                                                            
                                                                                            	// GetPodPluginDir returns the absolute path to a directory under which
                                                                                            	// a given plugin may store data for a given pod.  If the specified pod
                                                                                            	// does not exist, the result of this call might not exist.  This
                                                                                            	// directory might not actually exist on disk yet.
                                                                                            	GetPodPluginDir(podUID types.UID, pluginName string) string
                                                                                            
                                                                                            	// GetKubeClient returns a client interface
                                                                                            	GetKubeClient() clientset.Interface
                                                                                            
                                                                                            	// NewWrapperMounter finds an appropriate plugin with which to handle
                                                                                            	// the provided spec.  This is used to implement volume plugins which
                                                                                            	// "wrap" other plugins.  For example, the "secret" volume is
                                                                                            	// implemented in terms of the "emptyDir" volume.
                                                                                            	NewWrapperMounter(volName string, spec Spec, pod *v1.Pod, opts VolumeOptions) (Mounter, error)
                                                                                            
                                                                                            	// NewWrapperUnmounter finds an appropriate plugin with which to handle
                                                                                            	// the provided spec.  See comments on NewWrapperMounter for more
                                                                                            	// context.
                                                                                            	NewWrapperUnmounter(volName string, spec Spec, podUID types.UID) (Unmounter, error)
                                                                                            
                                                                                            	// Get cloud provider from kubelet.
                                                                                            	GetCloudProvider() cloudprovider.Interface
                                                                                            
                                                                                            	// Get mounter interface.
                                                                                            	GetMounter() mount.Interface
                                                                                            
                                                                                            	// Get writer interface for writing data to disk.
                                                                                            	GetWriter() io.Writer
                                                                                            
                                                                                            	// Returns the hostname of the host kubelet is running on
                                                                                            	GetHostName() string
                                                                                            
                                                                                            	// Returns host IP or nil in the case of error.
                                                                                            	GetHostIP() (net.IP, error)
                                                                                            
                                                                                            	// Returns node allocatable.
                                                                                            	GetNodeAllocatable() (v1.ResourceList, error)
                                                                                            
                                                                                            	// Returns a function that returns a secret.
                                                                                            	GetSecretFunc() func(namespace, name string) (*v1.Secret, error)
                                                                                            }

                                                                                              VolumeHost is an interface that plugins can use to access the kubelet.

                                                                                              type VolumeOptions

                                                                                              type VolumeOptions struct {
                                                                                              
                                                                                              	// Reclamation policy for a persistent volume
                                                                                              	PersistentVolumeReclaimPolicy v1.PersistentVolumeReclaimPolicy
                                                                                              	// Suggested PV.Name of the PersistentVolume to provision.
                                                                                              	// This is a generated name guaranteed to be unique in Kubernetes cluster.
                                                                                              	// If you choose not to use it as volume name, ensure uniqueness by either
                                                                                              	// combining it with your value or create unique values of your own.
                                                                                              	PVName string
                                                                                              	// PVC is reference to the claim that lead to provisioning of a new PV.
                                                                                              	// Provisioners *must* create a PV that would be matched by this PVC,
                                                                                              	// i.e. with required capacity, accessMode, labels matching PVC.Selector and
                                                                                              	// so on.
                                                                                              	PVC *v1.PersistentVolumeClaim
                                                                                              	// Unique name of Kubernetes cluster.
                                                                                              	ClusterName string
                                                                                              	// Tags to attach to the real volume in the cloud provider - e.g. AWS EBS
                                                                                              	CloudTags *map[string]string
                                                                                              	// Volume provisioning parameters from StorageClass
                                                                                              	Parameters map[string]string
                                                                                              }

                                                                                                VolumeOptions contains option information about a volume.

                                                                                                type VolumePlugin

                                                                                                type VolumePlugin interface {
                                                                                                	// Init initializes the plugin.  This will be called exactly once
                                                                                                	// before any New* calls are made - implementations of plugins may
                                                                                                	// depend on this.
                                                                                                	Init(host VolumeHost) error
                                                                                                
                                                                                                	// Name returns the plugin's name.  Plugins should use namespaced names
                                                                                                	// such as "example.com/volume".  The "kubernetes.io" namespace is
                                                                                                	// reserved for plugins which are bundled with kubernetes.
                                                                                                	GetPluginName() string
                                                                                                
                                                                                                	// GetVolumeName returns the name/ID to uniquely identifying the actual
                                                                                                	// backing device, directory, path, etc. referenced by the specified volume
                                                                                                	// spec.
                                                                                                	// For Attachable volumes, this value must be able to be passed back to
                                                                                                	// volume Detach methods to identify the device to act on.
                                                                                                	// If the plugin does not support the given spec, this returns an error.
                                                                                                	GetVolumeName(spec *Spec) (string, error)
                                                                                                
                                                                                                	// CanSupport tests whether the plugin supports a given volume
                                                                                                	// specification from the API.  The spec pointer should be considered
                                                                                                	// const.
                                                                                                	CanSupport(spec *Spec) bool
                                                                                                
                                                                                                	// RequiresRemount returns true if this plugin requires mount calls to be
                                                                                                	// reexecuted. Atomically updating volumes, like Downward API, depend on
                                                                                                	// this to update the contents of the volume.
                                                                                                	RequiresRemount() bool
                                                                                                
                                                                                                	// NewMounter creates a new volume.Mounter from an API specification.
                                                                                                	// Ownership of the spec pointer in *not* transferred.
                                                                                                	// - spec: The v1.Volume spec
                                                                                                	// - pod: The enclosing pod
                                                                                                	NewMounter(spec *Spec, podRef *v1.Pod, opts VolumeOptions) (Mounter, error)
                                                                                                
                                                                                                	// NewUnmounter creates a new volume.Unmounter from recoverable state.
                                                                                                	// - name: The volume name, as per the v1.Volume spec.
                                                                                                	// - podUID: The UID of the enclosing pod
                                                                                                	NewUnmounter(name string, podUID types.UID) (Unmounter, error)
                                                                                                
                                                                                                	// ConstructVolumeSpec constructs a volume spec based on the given volume name
                                                                                                	// and mountPath. The spec may have incomplete information due to limited
                                                                                                	// information from input. This function is used by volume manager to reconstruct
                                                                                                	// volume spec by reading the volume directories from disk
                                                                                                	ConstructVolumeSpec(volumeName, mountPath string) (*Spec, error)
                                                                                                
                                                                                                	// SupportsMountOption returns true if volume plugins supports Mount options
                                                                                                	// Specifying mount options in a volume plugin that doesn't support
                                                                                                	// user specified mount options will result in error creating persistent volumes
                                                                                                	SupportsMountOption() bool
                                                                                                
                                                                                                	// SupportsBulkVolumeVerification checks if volume plugin type is capable
                                                                                                	// of enabling bulk polling of all nodes. This can speed up verification of
                                                                                                	// attached volumes by quite a bit, but underlying pluging must support it.
                                                                                                	SupportsBulkVolumeVerification() bool
                                                                                                }

                                                                                                  VolumePlugin is an interface to volume plugins that can be used on a kubernetes node (e.g. by kubelet) to instantiate and manage volumes.

                                                                                                  type VolumePluginMgr

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

                                                                                                    VolumePluginMgr tracks registered plugins.

                                                                                                    func (*VolumePluginMgr) FindAttachablePluginByName

                                                                                                    func (pm *VolumePluginMgr) FindAttachablePluginByName(name string) (AttachableVolumePlugin, error)

                                                                                                      FindAttachablePluginByName fetches an attachable volume plugin by name. Unlike the other "FindPlugin" methods, this does not return error if no plugin is found. All volumes require a mounter and unmounter, but not every volume will have an attacher/detacher.

                                                                                                      func (*VolumePluginMgr) FindAttachablePluginBySpec

                                                                                                      func (pm *VolumePluginMgr) FindAttachablePluginBySpec(spec *Spec) (AttachableVolumePlugin, error)

                                                                                                        FindAttachablePluginBySpec fetches a persistent volume plugin by name. Unlike the other "FindPlugin" methods, this does not return error if no plugin is found. All volumes require a mounter and unmounter, but not every volume will have an attacher/detacher.

                                                                                                        func (*VolumePluginMgr) FindCreatablePluginBySpec

                                                                                                        func (pm *VolumePluginMgr) FindCreatablePluginBySpec(spec *Spec) (ProvisionableVolumePlugin, error)

                                                                                                          FindCreatablePluginBySpec fetches a persistent volume plugin by name. If no plugin is found, returns error.

                                                                                                          func (*VolumePluginMgr) FindDeletablePluginByName

                                                                                                          func (pm *VolumePluginMgr) FindDeletablePluginByName(name string) (DeletableVolumePlugin, error)

                                                                                                            FindDeletablePluginByName fetches a persistent volume plugin by name. If no plugin is found, returns error.

                                                                                                            func (*VolumePluginMgr) FindDeletablePluginBySpec

                                                                                                            func (pm *VolumePluginMgr) FindDeletablePluginBySpec(spec *Spec) (DeletableVolumePlugin, error)

                                                                                                              FindDeletablePluginBySppec fetches a persistent volume plugin by spec. If no plugin is found, returns error.

                                                                                                              func (*VolumePluginMgr) FindPersistentPluginByName

                                                                                                              func (pm *VolumePluginMgr) FindPersistentPluginByName(name string) (PersistentVolumePlugin, error)

                                                                                                                FindPersistentPluginByName fetches a persistent volume plugin by name. If no plugin is found, returns error.

                                                                                                                func (*VolumePluginMgr) FindPersistentPluginBySpec

                                                                                                                func (pm *VolumePluginMgr) FindPersistentPluginBySpec(spec *Spec) (PersistentVolumePlugin, error)

                                                                                                                  FindPersistentPluginBySpec looks for a persistent volume plugin that can support a given volume specification. If no plugin is found, return an error

                                                                                                                  func (*VolumePluginMgr) FindPluginByName

                                                                                                                  func (pm *VolumePluginMgr) FindPluginByName(name string) (VolumePlugin, error)

                                                                                                                    FindPluginByName fetches a plugin by name or by legacy name. If no plugin is found, returns error.

                                                                                                                    func (*VolumePluginMgr) FindPluginBySpec

                                                                                                                    func (pm *VolumePluginMgr) FindPluginBySpec(spec *Spec) (VolumePlugin, error)

                                                                                                                      FindPluginBySpec looks for a plugin that can support a given volume specification. If no plugins can support or more than one plugin can support it, return error.

                                                                                                                      func (*VolumePluginMgr) FindProvisionablePluginByName

                                                                                                                      func (pm *VolumePluginMgr) FindProvisionablePluginByName(name string) (ProvisionableVolumePlugin, error)

                                                                                                                        FindProvisionablePluginByName fetches a persistent volume plugin by name. If no plugin is found, returns error.

                                                                                                                        func (*VolumePluginMgr) FindRecyclablePluginBySpec

                                                                                                                        func (pm *VolumePluginMgr) FindRecyclablePluginBySpec(spec *Spec) (RecyclableVolumePlugin, error)

                                                                                                                          FindRecyclablePluginByName fetches a persistent volume plugin by name. If no plugin is found, returns error.

                                                                                                                          func (*VolumePluginMgr) InitPlugins

                                                                                                                          func (pm *VolumePluginMgr) InitPlugins(plugins []VolumePlugin, host VolumeHost) error

                                                                                                                            InitPlugins initializes each plugin. All plugins must have unique names. This must be called exactly once before any New* methods are called on any plugins.

                                                                                                                            Directories

                                                                                                                            Path Synopsis
                                                                                                                            Package aws_ebs contains the internal representation of AWS Elastic Block Store volumes.
                                                                                                                            Package aws_ebs contains the internal representation of AWS Elastic Block Store volumes.
                                                                                                                            Package azure_file contains the internal representation of Azure File Service Volume
                                                                                                                            Package azure_file contains the internal representation of Azure File Service Volume
                                                                                                                            Package nfs contains the internal representation of Ceph file system (CephFS) volumes.
                                                                                                                            Package nfs contains the internal representation of Ceph file system (CephFS) volumes.
                                                                                                                            Package cinder contains the internal representation of cinder volumes.
                                                                                                                            Package cinder contains the internal representation of cinder volumes.
                                                                                                                            Package configmap contains the internal representation of configMap volumes.
                                                                                                                            Package configmap contains the internal representation of configMap volumes.
                                                                                                                            Package empty_dir contains the internal representation of emptyDir volumes.
                                                                                                                            Package empty_dir contains the internal representation of emptyDir volumes.
                                                                                                                            Package fc contains the internal representation of Fibre Channel (fc) volumes.
                                                                                                                            Package fc contains the internal representation of Fibre Channel (fc) volumes.
                                                                                                                            Package flocker contains the internal representation of Flocker volumes
                                                                                                                            Package flocker contains the internal representation of Flocker volumes
                                                                                                                            Package gce_pd contains the internal representation of GCE PersistentDisk volumes.
                                                                                                                            Package gce_pd contains the internal representation of GCE PersistentDisk volumes.
                                                                                                                            Package git_repo contains the internal representation of git repo volumes.
                                                                                                                            Package git_repo contains the internal representation of git repo volumes.
                                                                                                                            Package glusterfs contains the internal representation of glusterfs volumes.
                                                                                                                            Package glusterfs contains the internal representation of glusterfs volumes.
                                                                                                                            Package host_path contains the internal representation of hostPath volumes.
                                                                                                                            Package host_path contains the internal representation of hostPath volumes.
                                                                                                                            Package iscsi contains the internal representation of Internet Small Computer System Interface (iSCSI) volumes.
                                                                                                                            Package iscsi contains the internal representation of Internet Small Computer System Interface (iSCSI) volumes.
                                                                                                                            Package nfs contains the internal representation of network file system (NFS) volumes.
                                                                                                                            Package nfs contains the internal representation of network file system (NFS) volumes.
                                                                                                                            Package portworx contains the internal representation of Portworx Block Device volumes.
                                                                                                                            Package portworx contains the internal representation of Portworx Block Device volumes.
                                                                                                                            Package quobyte contains the internal representation of Quobyte volumes.
                                                                                                                            Package quobyte contains the internal representation of Quobyte volumes.
                                                                                                                            Package rbd contains the internal representation of Rados Block Store (Ceph) volumes.
                                                                                                                            Package rbd contains the internal representation of Rados Block Store (Ceph) volumes.
                                                                                                                            Package secret contains the internal representation of secret volumes.
                                                                                                                            Package secret contains the internal representation of secret volumes.
                                                                                                                            Contains utility code for use by volume plugins.
                                                                                                                            Contains utility code for use by volume plugins.
                                                                                                                            nestedpendingoperations
                                                                                                                            Package nestedpendingoperations is a modified implementation of pkg/util/goroutinemap.
                                                                                                                            Package nestedpendingoperations is a modified implementation of pkg/util/goroutinemap.
                                                                                                                            operationexecutor
                                                                                                                            Package operationexecutor implements interfaces that enable execution of attach, detach, mount, and unmount operations with a nestedpendingoperations so that more than one operation is never triggered on the same volume for the same pod.
                                                                                                                            Package operationexecutor implements interfaces that enable execution of attach, detach, mount, and unmount operations with a nestedpendingoperations so that more than one operation is never triggered on the same volume for the same pod.
                                                                                                                            types
                                                                                                                            Package types defines types used only by volume components
                                                                                                                            Package types defines types used only by volume components
                                                                                                                            volumehelper
                                                                                                                            Package volumehelper contains consts and helper methods used by various volume components (attach/detach controller, kubelet, etc.).
                                                                                                                            Package volumehelper contains consts and helper methods used by various volume components (attach/detach controller, kubelet, etc.).