Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type FakeVolumeManager

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

    FakeVolumeManager is a test implementation that just tracks calls

    func NewFakeVolumeManager

    func NewFakeVolumeManager(initialVolumes []v1.UniqueVolumeName) *FakeVolumeManager

      NewFakeVolumeManager creates a new VolumeManager test instance

      func (*FakeVolumeManager) GetExtraSupplementalGroupsForPod

      func (f *FakeVolumeManager) GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64

        GetExtraSupplementalGroupsForPod is not implemented

        func (*FakeVolumeManager) GetMountedVolumesForPod

        func (f *FakeVolumeManager) GetMountedVolumesForPod(podName types.UniquePodName) container.VolumeMap

          GetMountedVolumesForPod is not implemented

          func (*FakeVolumeManager) GetVolumesInUse

          func (f *FakeVolumeManager) GetVolumesInUse() []v1.UniqueVolumeName

            GetVolumesInUse returns a list of the initial volumes

            func (*FakeVolumeManager) GetVolumesReportedInUse

            func (f *FakeVolumeManager) GetVolumesReportedInUse() []v1.UniqueVolumeName

              GetVolumesReportedInUse is a test function only that returns a list of volumes from the reportedInUse map

              func (*FakeVolumeManager) MarkVolumesAsReportedInUse

              func (f *FakeVolumeManager) MarkVolumesAsReportedInUse(volumesReportedAsInUse []v1.UniqueVolumeName)

                MarkVolumesAsReportedInUse adds the given volumes to the reportedInUse map

                func (*FakeVolumeManager) ReconcilerStatesHasBeenSynced

                func (f *FakeVolumeManager) ReconcilerStatesHasBeenSynced() bool

                  ReconcilerStatesHasBeenSynced is not implemented

                  func (*FakeVolumeManager) Run

                  func (f *FakeVolumeManager) Run(sourcesReady config.SourcesReady, stopCh <-chan struct{})

                    Run is not implemented

                    func (*FakeVolumeManager) VolumeIsAttached

                    func (f *FakeVolumeManager) VolumeIsAttached(volumeName v1.UniqueVolumeName) bool

                      VolumeIsAttached is not implemented

                      func (*FakeVolumeManager) WaitForAttachAndMount

                      func (f *FakeVolumeManager) WaitForAttachAndMount(pod *v1.Pod) error

                        WaitForAttachAndMount is not implemented

                        type VolumeManager

                        type VolumeManager interface {
                        	// Starts the volume manager and all the asynchronous loops that it controls
                        	Run(sourcesReady config.SourcesReady, stopCh <-chan struct{})
                        
                        	// WaitForAttachAndMount processes the volumes referenced in the specified
                        	// pod and blocks until they are all attached and mounted (reflected in
                        	// actual state of the world).
                        	// An error is returned if all volumes are not attached and mounted within
                        	// the duration defined in podAttachAndMountTimeout.
                        	WaitForAttachAndMount(pod *v1.Pod) error
                        
                        	// GetMountedVolumesForPod returns a VolumeMap containing the volumes
                        	// referenced by the specified pod that are successfully attached and
                        	// mounted. The key in the map is the OuterVolumeSpecName (i.e.
                        	// pod.Spec.Volumes[x].Name). It returns an empty VolumeMap if pod has no
                        	// volumes.
                        	GetMountedVolumesForPod(podName types.UniquePodName) container.VolumeMap
                        
                        	// GetExtraSupplementalGroupsForPod returns a list of the extra
                        	// supplemental groups for the Pod. These extra supplemental groups come
                        	// from annotations on persistent volumes that the pod depends on.
                        	GetExtraSupplementalGroupsForPod(pod *v1.Pod) []int64
                        
                        	// GetVolumesInUse returns a list of all volumes that implement the volume.Attacher
                        	// interface and are currently in use according to the actual and desired
                        	// state of the world caches. A volume is considered "in use" as soon as it
                        	// is added to the desired state of world, indicating it *should* be
                        	// attached to this node and remains "in use" until it is removed from both
                        	// the desired state of the world and the actual state of the world, or it
                        	// has been unmounted (as indicated in actual state of world).
                        	GetVolumesInUse() []v1.UniqueVolumeName
                        
                        	// ReconcilerStatesHasBeenSynced returns true only after the actual states in reconciler
                        	// has been synced at least once after kubelet starts so that it is safe to update mounted
                        	// volume list retrieved from actual state.
                        	ReconcilerStatesHasBeenSynced() bool
                        
                        	// VolumeIsAttached returns true if the given volume is attached to this
                        	// node.
                        	VolumeIsAttached(volumeName v1.UniqueVolumeName) bool
                        
                        	// Marks the specified volume as having successfully been reported as "in
                        	// use" in the nodes's volume status.
                        	MarkVolumesAsReportedInUse(volumesReportedAsInUse []v1.UniqueVolumeName)
                        }

                          VolumeManager runs a set of asynchronous loops that figure out which volumes need to be attached/mounted/unmounted/detached based on the pods scheduled on this node and makes it so.

                          func NewVolumeManager

                          func NewVolumeManager(
                          	controllerAttachDetachEnabled bool,
                          	nodeName k8stypes.NodeName,
                          	podManager pod.Manager,
                          	podStatusProvider status.PodStatusProvider,
                          	kubeClient clientset.Interface,
                          	volumePluginMgr *volume.VolumePluginMgr,
                          	kubeContainerRuntime container.Runtime,
                          	mounter mount.Interface,
                          	kubeletPodsDir string,
                          	recorder record.EventRecorder,
                          	checkNodeCapabilitiesBeforeMount bool,
                          	keepTerminatedPodVolumes bool) VolumeManager

                            NewVolumeManager returns a new concrete instance implementing the VolumeManager interface.

                            kubeClient - kubeClient is the kube API client used by DesiredStateOfWorldPopulator

                            to communicate with the API server to fetch PV and PVC objects
                            

                            volumePluginMgr - the volume plugin manager used to access volume plugins.

                            Must be pre-initialized.
                            

                            Directories

                            Path Synopsis
                            Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                            Package cache implements data structures used by the kubelet volume manager to keep track of attached volumes and the pods that mounted them.
                            Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                            Package populator implements interfaces that monitor and keep the states of the caches in sync with the "ground truth".
                            Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).
                            Package reconciler implements interfaces that attempt to reconcile the desired state of the world with the actual state of the world by triggering relevant actions (attach, detach, mount, unmount).