storage

package
v19.10.1+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 21, 2020 License: Apache-2.0 Imports: 20 Imported by: 312

Documentation

Index

Constants

View Source 
const (
	Unknown  = BackendState("unknown")
	Online   = BackendState("online")
	Offline  = BackendState("offline")
	Deleting = BackendState("deleting")
	Failed   = BackendState("failed")
)
View Source 
const (
	BackendRename = iota
	VolumeAccessInfoChange
	InvalidUpdate
	UsernameChange
	PasswordChange
)
View Source 
const (
	SnapshotStateOnline         = SnapshotState("online")
	SnapshotStateMissingBackend = SnapshotState("missing_backend")
	SnapshotStateMissingVolume  = SnapshotState("missing_volume")
)
View Source 
const (
	VolumeStateUnknown        = VolumeState("unknown")
	VolumeStateOnline         = VolumeState("online")
	VolumeStateDeleting       = VolumeState("deleting")
	VolumeStateUpgrading      = VolumeState("upgrading")
	VolumeStateMissingBackend = VolumeState("missing_backend")
)
View Source 
const SnapshotNameFormat = "20060102T150405Z"
View Source 
const SnapshotTimestampFormat = "2006-01-02T15:04:05Z"

Variables

This section is empty.

Functions

func MakeSnapshotID 

func MakeSnapshotID(volumeName, snapshotName string) string

func ParseSnapshotID 

func ParseSnapshotID(snapshotID string) (string, string, error)

Types

type Backend 

type Backend struct {
	Driver      Driver
	Name        string
	BackendUUID string
	Online      bool
	State       BackendState
	Storage     map[string]*Pool
	Volumes     map[string]*Volume
}

func NewFailedStorageBackend 

func NewFailedStorageBackend(driver Driver) *Backend

func NewStorageBackend 

func NewStorageBackend(driver Driver) (*Backend, error)

func (*Backend) AddStoragePool 

func (b *Backend) AddStoragePool(pool *Pool)

func (*Backend) AddVolume 

func (b *Backend) AddVolume(
	volConfig *VolumeConfig, storagePool *Pool, volAttributes map[string]sa.Request,
) (*Volume, error)

func (*Backend) CloneVolume 

func (b *Backend) CloneVolume(volConfig *VolumeConfig) (*Volume, error)

func (*Backend) ConstructExternal 

func (b *Backend) ConstructExternal() *BackendExternal

func (*Backend) ConstructPersistent 

func (b *Backend) ConstructPersistent() *BackendPersistent

func (*Backend) CreateSnapshot 

func (b *Backend) CreateSnapshot(snapConfig *SnapshotConfig, volConfig *VolumeConfig) (*Snapshot, error)

func (*Backend) DeleteSnapshot 

func (b *Backend) DeleteSnapshot(snapConfig *SnapshotConfig, volConfig *VolumeConfig) error

func (*Backend) GetDriverName 

func (b *Backend) GetDriverName() string

func (*Backend) GetProtocol 

func (b *Backend) GetProtocol() tridentconfig.Protocol

func (*Backend) GetSnapshot 

func (b *Backend) GetSnapshot(snapConfig *SnapshotConfig) (*Snapshot, error)

func (*Backend) GetSnapshots 

func (b *Backend) GetSnapshots(volConfig *VolumeConfig) ([]*Snapshot, error)

func (*Backend) GetUpdateType 

func (b *Backend) GetUpdateType(origBackend *Backend) *roaring.Bitmap

func (*Backend) GetVolumeExternal 

func (b *Backend) GetVolumeExternal(volumeName string) (*VolumeExternal, error)

func (*Backend) HasVolumes 

func (b *Backend) HasVolumes() bool

HasVolumes returns true if the Backend has one or more volumes provisioned on it.

func (*Backend) ImportVolume 

func (b *Backend) ImportVolume(volConfig *VolumeConfig) (*Volume, error)

func (*Backend) RemoveCachedVolume 

func (b *Backend) RemoveCachedVolume(volumeName string)

func (*Backend) RemoveVolume 

func (b *Backend) RemoveVolume(volConfig *VolumeConfig) error

func (*Backend) RenameVolume 

func (b *Backend) RenameVolume(volConfig *VolumeConfig, newName string) error

func (*Backend) ResizeVolume 

func (b *Backend) ResizeVolume(volConfig *VolumeConfig, newSize string) error

func (*Backend) RestoreSnapshot 

func (b *Backend) RestoreSnapshot(snapConfig *SnapshotConfig, volConfig *VolumeConfig) error

func (*Backend) Terminate 

func (b *Backend) Terminate()

Terminate informs the backend that it is being deleted from the core and will not be called again. This may be a signal to the storage driver to clean up and stop any ongoing operations.

type BackendExternal 

type BackendExternal struct {
	Name        string                 `json:"name"`
	BackendUUID string                 `json:"backendUUID"`
	Protocol    tridentconfig.Protocol `json:"protocol"`
	Config      interface{}            `json:"config"`
	Storage     map[string]interface{} `json:"storage"`
	State       BackendState           `json:"state"`
	Online      bool                   `json:"online"`
	Volumes     []string               `json:"volumes"`
}

type BackendPersistent 

type BackendPersistent struct {
	Version     string                         `json:"version"`
	Config      PersistentStorageBackendConfig `json:"config"`
	Name        string                         `json:"name"`
	BackendUUID string                         `json:"backendUUID"`
	Online      bool                           `json:"online"`
	State       BackendState                   `json:"state"`
}

func (*BackendPersistent) ExtractBackendSecrets 

func (p *BackendPersistent) ExtractBackendSecrets(secretName string) (*BackendPersistent, map[string]string, error)

ExtractBackendSecrets clones itself (a BackendPersistent struct), builds a map of any secret data it contains (credentials, etc.), clears those fields in the clone, and returns the clone and the map.

func (*BackendPersistent) InjectBackendSecrets 

func (p *BackendPersistent) InjectBackendSecrets(secretMap map[string]string) error

func (*BackendPersistent) MarshalConfig 

func (p *BackendPersistent) MarshalConfig() (string, error)

Unfortunately, this method appears to be necessary to avoid arbitrary values ending up in the json.RawMessage fields of CommonStorageDriverConfig. Ideally, BackendPersistent would just store a serialized config, but doing so appears to cause problems with the json.RawMessage fields.

type BackendState 

type BackendState string

func (BackendState) IsDeleting 

func (s BackendState) IsDeleting() bool

func (BackendState) IsFailed 

func (s BackendState) IsFailed() bool

func (BackendState) IsOffline 

func (s BackendState) IsOffline() bool

func (BackendState) IsOnline 

func (s BackendState) IsOnline() bool

func (BackendState) IsUnknown 

func (s BackendState) IsUnknown() bool

func (BackendState) String 

func (s BackendState) String() string

type ByVolumeExternalName 

type ByVolumeExternalName []*VolumeExternal

func (ByVolumeExternalName) Len 

func (a ByVolumeExternalName) Len() int

func (ByVolumeExternalName) Less 

func (a ByVolumeExternalName) Less(i, j int) bool

func (ByVolumeExternalName) Swap 

func (a ByVolumeExternalName) Swap(i, j int)

type Driver 

type Driver interface {
	Name() string
	Initialize(tridentconfig.DriverContext, string, *drivers.CommonStorageDriverConfig) error
	Initialized() bool
	// Terminate tells the driver to clean up, as it won't be called again.
	Terminate()
	Create(volConfig *VolumeConfig, storagePool *Pool, volAttributes map[string]sa.Request) error
	CreatePrepare(volConfig *VolumeConfig) error
	// CreateFollowup adds necessary information for accessing the volume to VolumeConfig.
	CreateFollowup(volConfig *VolumeConfig) error
	// GetInternalVolumeName will return a name that satisfies any character
	// constraints present on the backend and that will be unique to Trident.
	// The latter requirement should generally be done by prepending the
	// value of CommonStorageDriver.SnapshotPrefix to the name.
	CreateClone(volConfig *VolumeConfig) error
	Import(volConfig *VolumeConfig, originalName string) error
	Destroy(name string) error
	Rename(name string, newName string) error
	Resize(volConfig *VolumeConfig, sizeBytes uint64) error
	Get(name string) error
	GetInternalVolumeName(name string) string
	GetStorageBackendSpecs(backend *Backend) error
	GetProtocol() tridentconfig.Protocol
	Publish(name string, publishInfo *utils.VolumePublishInfo) error
	GetSnapshot(snapConfig *SnapshotConfig) (*Snapshot, error)
	GetSnapshots(volConfig *VolumeConfig) ([]*Snapshot, error)
	CreateSnapshot(snapConfig *SnapshotConfig) (*Snapshot, error)
	RestoreSnapshot(snapConfig *SnapshotConfig) error
	DeleteSnapshot(snapConfig *SnapshotConfig) error
	StoreConfig(b *PersistentStorageBackendConfig)
	// GetExternalConfig returns a version of the driver configuration that
	// lacks confidential information, such as usernames and passwords.
	GetExternalConfig() interface{}
	// GetVolumeExternal accepts the internal name of a volume and returns a VolumeExternal
	// object.  This method is only available if using the passthrough store (i.e. Docker).
	GetVolumeExternal(name string) (*VolumeExternal, error)
	// GetVolumeExternalWrappers reads all volumes owned by this driver from the storage backend and
	// writes them to the supplied channel as VolumeExternalWrapper objects.  This method is only
	// available if using the passthrough store (i.e. Docker).
	GetVolumeExternalWrappers(chan *VolumeExternalWrapper)
	GetUpdateType(driver Driver) *roaring.Bitmap
}

Driver provides a common interface for storage related operations

type ImportVolumeRequest 

type ImportVolumeRequest struct {
	Backend      string `json:"backend"`
	InternalName string `json:"internalName"`
	NoManage     bool   `json:"noManage"`
	PVCData      string `json:"pvcData"` // Opaque, base64-encoded
}

func (*ImportVolumeRequest) Validate 

func (r *ImportVolumeRequest) Validate() error

type NotManagedError 

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

func (*NotManagedError) Error 

func (e *NotManagedError) Error() string

type PVUpgradeConfig 

type PVUpgradeConfig struct {
	PVCConfig       *v1.PersistentVolumeClaim `json:"pvcConfig,omitempty"`
	PVConfig        *v1.PersistentVolume      `json:"pvConfig,omitempty"`
	OwnedPodsForPVC []string                  `json:"ownedPodsForPVC,omitempty"`
}

type PersistentStorageBackendConfig 

type PersistentStorageBackendConfig struct {
	OntapConfig             *drivers.OntapStorageDriverConfig     `json:"ontap_config,omitempty"`
	SolidfireConfig         *drivers.SolidfireStorageDriverConfig `json:"solidfire_config,omitempty"`
	EseriesConfig           *drivers.ESeriesStorageDriverConfig   `json:"eseries_config,omitempty"`
	AWSConfig               *drivers.AWSNFSStorageDriverConfig    `json:"aws_config,omitempty"`
	AzureConfig             *drivers.AzureNFSStorageDriverConfig  `json:"azure_config,omitempty"`
	GCPConfig               *drivers.GCPNFSStorageDriverConfig    `json:"gcp_config,omitempty"`
	FakeStorageDriverConfig *drivers.FakeStorageDriverConfig      `json:"fake_config,omitempty"`
}

type Pool 

type Pool struct {
	Name string
	// A Trident storage pool can potentially satisfy more than one storage class.
	StorageClasses     []string
	Backend            *Backend
	Attributes         map[string]sa.Offer // These attributes are used to match storage classes
	InternalAttributes map[string]string   // These attributes are defined & used internally by storage drivers
}

func NewStoragePool 

func NewStoragePool(backend *Backend, name string) *Pool

func (*Pool) AddStorageClass 

func (pool *Pool) AddStorageClass(class string)

func (*Pool) ConstructExternal 

func (pool *Pool) ConstructExternal() *PoolExternal

func (*Pool) RemoveStorageClass 

func (pool *Pool) RemoveStorageClass(class string) bool

type PoolExternal 

type PoolExternal struct {
	Name           string   `json:"name"`
	StorageClasses []string `json:"storageClasses"`
	//TODO: can't have an interface here for unmarshalling
	Attributes map[string]sa.Offer `json:"storageAttributes"`
}

type Snapshot 

type Snapshot struct {
	Config    *SnapshotConfig
	Created   string `json:"dateCreated"` // The UTC time that the snapshot was created, in RFC3339 format
	SizeBytes int64  `json:"size"`        // The size of the volume at the time the snapshot was created
	State     SnapshotState
}

func NewSnapshot 

func NewSnapshot(config *SnapshotConfig, created string, sizeBytes int64) *Snapshot

func (*Snapshot) ConstructClone 

func (s *Snapshot) ConstructClone() *Snapshot

func (*Snapshot) ConstructExternal 

func (s *Snapshot) ConstructExternal() *SnapshotExternal

func (*Snapshot) ConstructPersistent 

func (s *Snapshot) ConstructPersistent() *SnapshotPersistent

func (*Snapshot) ID 

func (s *Snapshot) ID() string

type SnapshotConfig 

type SnapshotConfig struct {
	Version            string `json:"version,omitempty"`
	Name               string `json:"name,omitempty"`
	InternalName       string `json:"internalName,omitempty"`
	VolumeName         string `json:"volumeName,omitempty"`
	VolumeInternalName string `json:"volumeInternalName,omitempty"`
}

func (*SnapshotConfig) ID 

func (c *SnapshotConfig) ID() string

func (*SnapshotConfig) Validate 

func (c *SnapshotConfig) Validate() error

type SnapshotExternal 

type SnapshotExternal struct {
	Snapshot
}

func (*SnapshotExternal) ID 

func (s *SnapshotExternal) ID() string

type SnapshotPersistent 

type SnapshotPersistent struct {
	Snapshot
}

func (*SnapshotPersistent) ConstructExternal 

func (s *SnapshotPersistent) ConstructExternal() *SnapshotExternal

type SnapshotState 

type SnapshotState string

func (SnapshotState) IsMissingBackend 

func (s SnapshotState) IsMissingBackend() bool

func (SnapshotState) IsMissingVolume 

func (s SnapshotState) IsMissingVolume() bool

func (SnapshotState) IsOnline 

func (s SnapshotState) IsOnline() bool

type UpdateBackendStateRequest 

type UpdateBackendStateRequest struct {
	State string `json:"state"`
}

type UpgradeVolumeRequest 

type UpgradeVolumeRequest struct {
	Type   string `json:"type"`
	Volume string `json:"volume"`
}

func (*UpgradeVolumeRequest) Validate 

func (r *UpgradeVolumeRequest) Validate() error

type Volume 

type Volume struct {
	Config      *VolumeConfig
	BackendUUID string // UUID of the storage backend
	Pool        string // Name of the pool on which this volume was first provisioned
	Orphaned    bool   // An Orphaned volume isn't currently tracked by the storage backend
	State       VolumeState
}

func NewVolume 

func NewVolume(conf *VolumeConfig, backendUUID string, pool string, orphaned bool) *Volume

func (*Volume) ConstructExternal 

func (v *Volume) ConstructExternal() *VolumeExternal

type VolumeConfig 

type VolumeConfig struct {
	Version                   string                 `json:"version"`
	Name                      string                 `json:"name"`
	InternalName              string                 `json:"internalName"`
	Size                      string                 `json:"size"`
	Protocol                  config.Protocol        `json:"protocol"`
	SpaceReserve              string                 `json:"spaceReserve"`
	SecurityStyle             string                 `json:"securityStyle"`
	SnapshotPolicy            string                 `json:"snapshotPolicy,omitempty"`
	SnapshotReserve           string                 `json:"snapshotReserve,omitempty"`
	SnapshotDir               string                 `json:"snapshotDirectory,omitempty"`
	ExportPolicy              string                 `json:"exportPolicy,omitempty"`
	UnixPermissions           string                 `json:"unixPermissions,omitempty"`
	StorageClass              string                 `json:"storageClass,omitempty"`
	AccessMode                config.AccessMode      `json:"accessMode,omitempty"`
	VolumeMode                config.VolumeMode      `json:"volumeMode,omitempty"`
	AccessInfo                utils.VolumeAccessInfo `json:"accessInformation"`
	BlockSize                 string                 `json:"blockSize"`
	FileSystem                string                 `json:"fileSystem"`
	Encryption                string                 `json:"encryption"`
	CloneSourceVolume         string                 `json:"cloneSourceVolume"`
	CloneSourceVolumeInternal string                 `json:"cloneSourceVolumeInternal"`
	CloneSourceSnapshot       string                 `json:"cloneSourceSnapshot"`
	SplitOnClone              string                 `json:"splitOnClone"`
	QoS                       string                 `json:"qos,omitempty"`
	QoSType                   string                 `json:"type,omitempty"`
	ServiceLevel              string                 `json:"serviceLevel,omitempty"`
	Network                   string                 `json:"network,omitempty"`
	ImportOriginalName        string                 `json:"importOriginalName,omitempty"`
	ImportBackendUUID         string                 `json:"importBackendUUID,omitempty"`
	ImportNotManaged          bool                   `json:"importNotManaged,omitempty"`
}

func (*VolumeConfig) ConstructClone 

func (c *VolumeConfig) ConstructClone() *VolumeConfig

func (*VolumeConfig) Validate 

func (c *VolumeConfig) Validate() error

type VolumeExternal 

type VolumeExternal struct {
	Config      *VolumeConfig
	Backend     string      `json:"backend"`     // replaced w/ backendUUID, remains to read old records
	BackendUUID string      `json:"backendUUID"` // UUID of the storage backend
	Pool        string      `json:"pool"`
	Orphaned    bool        `json:"orphaned"`
	State       VolumeState `json:"state"`
}

func (*VolumeExternal) GetCHAPSecretName 

func (v *VolumeExternal) GetCHAPSecretName() string

type VolumeExternalWrapper 

type VolumeExternalWrapper struct {
	Volume *VolumeExternal
	Error  error
}

VolumeExternalWrapper is used to return volumes and errors via channels between goroutines

type VolumeOperation 

type VolumeOperation string
const (
	AddVolume      VolumeOperation = "addVolume"
	DeleteVolume   VolumeOperation = "deleteVolume"
	ImportVolume   VolumeOperation = "importVolume"
	ResizeVolume   VolumeOperation = "resizeVolume"
	UpgradeVolume  VolumeOperation = "upgradeVolume"
	AddSnapshot    VolumeOperation = "addSnapshot"
	DeleteSnapshot VolumeOperation = "deleteSnapshot"
)

type VolumeState 

type VolumeState string

func (VolumeState) IsDeleting 

func (s VolumeState) IsDeleting() bool

func (VolumeState) IsMissingBackend 

func (s VolumeState) IsMissingBackend() bool

func (VolumeState) IsOnline 

func (s VolumeState) IsOnline() bool

func (VolumeState) IsUnknown 

func (s VolumeState) IsUnknown() bool

func (VolumeState) String 

func (s VolumeState) String() string

type VolumeTransaction 

type VolumeTransaction struct {
	Config          *VolumeConfig
	SnapshotConfig  *SnapshotConfig
	PVUpgradeConfig *PVUpgradeConfig
	Op              VolumeOperation
}

func (*VolumeTransaction) Name 

func (t *VolumeTransaction) Name() string

Name returns a unique identifier for the VolumeTransaction. Volume transactions should only be identified by their name, while snapshot transactions should be identified by their name as well as their volume name. It's possible that some situations will leave a delete transaction dangling; an add transaction should overwrite this.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.