Documentation

Index

Constants

This section is empty.

Variables

View Source
var (

	// CSIInstanceID is the instance ID that is unique to an instance of CSI, used when sharing
	// ceph clusters across CSI instances, to differentiate omap names per CSI instance
	CSIInstanceID = "default"
)

Functions

This section is empty.

Types

type ControllerServer

type ControllerServer struct {
	*csicommon.DefaultControllerServer
	MetadataStore util.CachePersister
	// A map storing all volumes with ongoing operations so that additional operations
	// for that same volume (as defined by VolumeID/volume name) return an Aborted error
	VolumeLocks *util.VolumeLocks

	// A map storing all volumes with ongoing operations so that additional operations
	// for that same snapshot (as defined by SnapshotID/snapshot name) return an Aborted error
	SnapshotLocks *util.VolumeLocks
}

    ControllerServer struct of rbd CSI driver with supported methods of CSI controller server spec.

    func NewControllerServer

    func NewControllerServer(d *csicommon.CSIDriver, cachePersister util.CachePersister) *ControllerServer

      NewControllerServer initialize a controller server for rbd CSI driver

      func (*ControllerServer) ControllerExpandVolume

        ControllerExpandVolume expand RBD Volumes on demand based on resizer request

        func (*ControllerServer) CreateSnapshot

          CreateSnapshot creates the snapshot in backend and stores metadata in store nolint: gocyclo

          func (*ControllerServer) CreateVolume

            CreateVolume creates the volume in backend

            func (*ControllerServer) DeleteLegacyVolume

              DeleteLegacyVolume deletes a volume provisioned using version 1.0.0 of the plugin

              func (*ControllerServer) DeleteSnapshot

                DeleteSnapshot deletes the snapshot in backend and removes the snapshot metadata from store

                func (*ControllerServer) DeleteVolume

                  DeleteVolume deletes the volume in backend and removes the volume metadata from store

                  func (*ControllerServer) ValidateVolumeCapabilities

                    ValidateVolumeCapabilities checks whether the volume capabilities requested are supported.

                    type Driver

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

                      Driver contains the default identity,node and controller struct

                      func NewDriver

                      func NewDriver() *Driver

                        NewDriver returns new rbd driver

                        func (*Driver) Run

                        func (r *Driver) Run(conf *util.Config, cachePersister util.CachePersister)

                          Run start a non-blocking grpc controller,node and identityserver for rbd CSI driver which can serve multiple parallel requests

                          type ErrImageNotFound

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

                            ErrImageNotFound is returned when image name is not found in the cluster on the given pool

                            func (ErrImageNotFound) Error

                            func (e ErrImageNotFound) Error() string

                            type ErrInvalidVolID

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

                              ErrInvalidVolID is returned when a CSI passed VolumeID does not conform to any known volume ID formats

                              func (ErrInvalidVolID) Error

                              func (e ErrInvalidVolID) Error() string

                              type ErrMissingStash

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

                                ErrMissingStash is returned when the image metadata stash file is not found

                                func (ErrMissingStash) Error

                                func (e ErrMissingStash) Error() string

                                type ErrSnapNotFound

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

                                  ErrSnapNotFound is returned when snap name passed is not found in the list of snapshots for the given image

                                  func (ErrSnapNotFound) Error

                                  func (e ErrSnapNotFound) Error() string

                                  type ErrVolNameConflict

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

                                    ErrVolNameConflict is generated when a requested CSI volume name already exists on RBD but with different properties, and hence is in conflict with the passed in CSI volume name

                                    func (ErrVolNameConflict) Error

                                    func (e ErrVolNameConflict) Error() string

                                    type IdentityServer

                                    type IdentityServer struct {
                                    	*csicommon.DefaultIdentityServer
                                    }

                                      IdentityServer struct of rbd CSI driver with supported methods of CSI identity server spec.

                                      func NewIdentityServer

                                      func NewIdentityServer(d *csicommon.CSIDriver) *IdentityServer

                                        NewIdentityServer initialize a identity server for rbd CSI driver

                                        func (*IdentityServer) GetPluginCapabilities

                                          GetPluginCapabilities returns available capabilities of the rbd driver

                                          type NodeServer

                                          type NodeServer struct {
                                          	*csicommon.DefaultNodeServer
                                          
                                          	// A map storing all volumes with ongoing operations so that additional operations
                                          	// for that same volume (as defined by VolumeID) return an Aborted error
                                          	VolumeLocks *util.VolumeLocks
                                          	// contains filtered or unexported fields
                                          }

                                            NodeServer struct of ceph rbd driver with supported methods of CSI node server spec

                                            func NewNodeServer

                                            func NewNodeServer(d *csicommon.CSIDriver, t string) (*NodeServer, error)

                                              NewNodeServer initialize a node server for rbd CSI driver.

                                              func (*NodeServer) NodeExpandVolume

                                              func (*NodeServer) NodeGetCapabilities

                                                NodeGetCapabilities returns the supported capabilities of the node server

                                                func (*NodeServer) NodePublishVolume

                                                  NodePublishVolume mounts the volume mounted to the device path to the target path

                                                  func (*NodeServer) NodeStageVolume

                                                    NodeStageVolume mounts the volume to a staging path on the node. Implementation notes: - stagingTargetPath is the directory passed in the request where the volume needs to be staged

                                                    - We stage the volume into a directory, named after the VolumeID inside stagingTargetPath if
                                                     it is a file system
                                                    - We stage the volume into a file, named after the VolumeID inside stagingTargetPath if it is
                                                     a block volume
                                                    

                                                    - Order of operation execution: (useful for defer stacking and when Unstaging to ensure steps

                                                    	are done in reverse, this is done in undoStagingTransaction)
                                                      - Stash image metadata under staging path
                                                      - Map the image (creates a device)
                                                      - Create the staging file/directory under staging path
                                                      - Stage the device (mount the device mapped for image)
                                                    

                                                    func (*NodeServer) NodeUnpublishVolume

                                                      NodeUnpublishVolume unmounts the volume from the target path

                                                      func (*NodeServer) NodeUnstageVolume

                                                        NodeUnstageVolume unstages the volume from the staging path