kubernetes: github.com/bobintornado/kubernetes/pkg/volume Index | Files | Directories

package volume

import "github.com/bobintornado/kubernetes/pkg/volume"

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

Index

Package Files

doc.go metrics_cached.go metrics_du.go metrics_nil.go plugins.go util.go volume.go volume_linux.go

Constants

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"
)

func CalculateTimeoutForVolume Uses

func CalculateTimeoutForVolume(minimumTimeout, timeoutIncrement int, pv *api.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 GenerateVolumeName Uses

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 NewPersistentVolumeRecyclerPodTemplate Uses

func NewPersistentVolumeRecyclerPodTemplate() *api.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 Uses

func RecycleVolumeByWatchingPodUntilCompletion(pod *api.Pod, kubeClient clientset.Interface) 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.

pod - the pod designed by a volume plugin to recycle the volume
client - kube client for API operations.

func RenameDirectory Uses

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

func RoundUpSize Uses

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 Uses

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.

type AttachableVolumePlugin Uses

type AttachableVolumePlugin interface {
    VolumePlugin
    NewAttacher() (Attacher, error)
    NewDetacher() (Detacher, error)
}

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

type Attacher Uses

type Attacher interface {
    // Attach the volume specified by the given spec to the given host
    Attach(spec *Spec, hostName string) 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, 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(host VolumeHost, spec *Spec) string

    // MountDevice mounts the disk to a global path which
    // individual pods can then bind mount
    MountDevice(spec *Spec, devicePath string, deviceMountPath string, mounter mount.Interface) error
}

Attacher can attach a volume to a node.

type Attributes Uses

type Attributes struct {
    ReadOnly        bool
    Managed         bool
    SupportsSELinux bool
}

Attributes represents the attributes of this mounter.

type DeletableVolumePlugin Uses

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 Uses

type Deleter interface {
    Volume
    // This method should block until completion.
    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 Uses

type Detacher interface {
    // Detach the given device from the given host.
    Detach(deviceName, hostName string) error

    // WaitForDetach blocks until the device is detached from this
    // node. If the device does not detach within the given timeout
    // period an error is returned.
    WaitForDetach(devicePath string, timeout time.Duration) error

    // UnmountDevice unmounts the global mount of the disk. This
    // should only be called once all bind mounts have been
    // unmounted.
    UnmountDevice(deviceMountPath string, mounter mount.Interface) error
}

Detacher can detach a volume from a node.

type Metrics Uses

type Metrics struct {
    // 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
}

Metrics represents the used and available bytes of the Volume.

type MetricsNil Uses

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 Uses

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

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

type MetricsProvider Uses

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 Uses

func NewCachedMetrics(provider MetricsProvider) MetricsProvider

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

func NewMetricsDu Uses

func NewMetricsDu(path string) MetricsProvider

NewMetricsDu creates a new metricsDu with the Volume path.

type Mounter Uses

type Mounter interface {
    // Uses Interface to provide the path for Docker binds.
    Volume
    // 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 Uses

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

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

type ProvisionableVolumePlugin Uses

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 Uses

type Provisioner interface {
    // Provision creates the resource by allocating the underlying volume in a storage system.
    // This method should block until completion.
    Provision(*api.PersistentVolume) error
    // NewPersistentVolumeTemplate creates a new PersistentVolume to be used as a template before saving.
    // The provisioner will want to tweak its properties, assign correct annotations, etc.
    // This func should *NOT* persist the PV in the API.  That is left to the caller.
    NewPersistentVolumeTemplate() (*api.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 Uses

type RecyclableVolumePlugin interface {
    VolumePlugin
    // NewRecycler creates a new volume.Recycler which knows how to reclaim this resource
    // after the volume's release from a PersistentVolumeClaim
    NewRecycler(spec *Spec) (Recycler, 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 Recycler Uses

type Recycler interface {
    Volume
    // Recycle reclaims the resource.  Calls to this method should block until the recycling task is complete.
    // Any error returned indicates the volume has failed to be reclaimed.  A nil return indicates success.
    Recycle() error
}

Recycler provides methods to reclaim the volume resource.

type Spec Uses

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

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

func NewSpecFromPersistentVolume Uses

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

NewSpecFromPersistentVolume creates an Spec from an api.PersistentVolume

func NewSpecFromVolume Uses

func NewSpecFromVolume(vs *api.Volume) *Spec

NewSpecFromVolume creates an Spec from an api.Volume

func (*Spec) Name Uses

func (spec *Spec) Name() string

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

type Unmounter Uses

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 Uses

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 Uses

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 *api.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

    // 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
}

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 Uses

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 *api.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
}

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

type VolumeOptions Uses

type VolumeOptions struct {
    // The rootcontext to use when performing mounts for a volume.
    // This is a temporary measure in order to set the rootContext of tmpfs mounts correctly.
    // it will be replaced and expanded on by future SecurityContext work.
    RootContext string

    // Capacity is the size of a volume.
    Capacity resource.Quantity
    // AccessModes of a volume
    AccessModes []api.PersistentVolumeAccessMode
    // Reclamation policy for a persistent volume
    PersistentVolumeReclaimPolicy api.PersistentVolumeReclaimPolicy
    // PV.Name of the appropriate PersistentVolume. Used to generate cloud volume name.
    PVName string
    // 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
}

VolumeOptions contains option information about a volume.

type VolumePlugin Uses

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.
    Name() string

    // CanSupport tests whether the plugin supports a given volume
    // specification from the API.  The spec pointer should be considered
    // const.
    CanSupport(spec *Spec) bool

    // NewMounter creates a new volume.Mounter from an API specification.
    // Ownership of the spec pointer in *not* transferred.
    // - spec: The api.Volume spec
    // - pod: The enclosing pod
    NewMounter(spec *Spec, podRef *api.Pod, opts VolumeOptions) (Mounter, error)

    // NewUnmounter creates a new volume.Unmounter from recoverable state.
    // - name: The volume name, as per the api.Volume spec.
    // - podUID: The UID of the enclosing pod
    NewUnmounter(name string, podUID types.UID) (Unmounter, error)
}

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 Uses

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

VolumePluginMgr tracks registered plugins.

func (*VolumePluginMgr) FindAttachablePluginByName Uses

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 Uses

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 Uses

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) FindDeletablePluginBySpec Uses

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

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

func (*VolumePluginMgr) FindPersistentPluginByName Uses

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 Uses

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 Uses

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 Uses

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) FindRecyclablePluginBySpec Uses

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 Uses

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

PathSynopsis
aws_ebsPackage aws_ebs contains the internal representation of AWS Elastic Block Store volumes.
azure_filePackage azure_file contains the internal representation of Azure File Service Volume
cephfsPackage nfs contains the internal representation of Ceph file system (CephFS) volumes.
cinderPackage cinder contains the internal representation of cinder volumes.
configmapPackage configmap contains the internal representation of configMap volumes.
downwardapi
empty_dirPackage empty_dir contains the internal representation of emptyDir volumes.
fcPackage fc contains the internal representation of Fibre Channel (fc) volumes.
flexvolume
flockerPackage flocker contains the internal representation of Flocker volumes
gce_pdPackage gce_pd contains the internal representation of GCE PersistentDisk volumes.
git_repoPackage git_repo contains the internal representation of git repo volumes.
glusterfsPackage glusterfs contains the internal representation of glusterfs volumes.
host_pathPackage host_path contains the internal representation of hostPath volumes.
iscsiPackage iscsi contains the internal representation of Internet Small Computer System Interface (iSCSI) volumes.
nfsPackage nfs contains the internal representation of network file system (NFS) volumes.
persistent_claimPackage persistent_claim contains the internal representation of persistent volume claims.
rbdPackage rbd contains the internal representation of Rados Block Store (Ceph) volumes.
secretPackage secret contains the internal representation of secret volumes.
testing
utilContains utility code for use by volume plugins.

Package volume imports 28 packages (graph). Updated 2017-03-06. Refresh now. Tools for package owners. This is a quick bug-fix fork (has fewer than three commits, and only during the week it was created).