Documentation

Overview

    Package storage defines structures and functions relating to charm storage.

    Index

    Constants

    View Source
    const (
    	// ConfigStorageDir is the path to the directory which a
    	// machine-scoped storage source may use to contain storage
    	// artifacts. This should not be used for environment-wide
    	// storage sources, as the contents are bound to the
    	// lifetime of the machine.
    	//
    	// ConfigStorageDir is set by the storage provisioner, so
    	// should not be relied upon until a storage source is
    	// constructed.
    	ConfigStorageDir = "storage-dir"
    )

    Variables

    This section is empty.

    Functions

    func BlockDevicePath

    func BlockDevicePath(device BlockDevice) (string, error)

      BlockDevicePath returns the path to a block device, or an error if a path cannot be determined. The path is based on the hardware ID, if available; the first value in device.DeviceLinks, if non-empty; otherwise the device name.

      func IsValidPoolName

      func IsValidPoolName(s string) bool

        IsValidPoolName checks if given string is a valid pool name.

        func ParseConstraintsMap

        func ParseConstraintsMap(args []string, mustHaveConstraints bool) (map[string]Constraints, error)

          ParseConstraintsMap parses string representation of storage constraints into a map keyed on storage names with constraints as values.

          Storage constraints may be specified as

          <name>=<constraints>
          

          or as

          <name>
          

          where latter is equivalent to <name>=1.

          Duplicate storage names cause an error to be returned. Constraints presence can be enforced.

          func SortBlockDevices

          func SortBlockDevices(devices []BlockDevice)

            SortBlockDevices sorts block devices by device name.

            Types

            type AttachFilesystemsResult

            type AttachFilesystemsResult struct {
            	FilesystemAttachment *FilesystemAttachment
            	Error                error
            }

              AttachFilesystemsResult contains the result of a FilesystemSource.AttachFilesystems call for one filesystem. FilesystemAttachment should only be used if Error is nil.

              type AttachVolumesResult

              type AttachVolumesResult struct {
              	VolumeAttachment *VolumeAttachment
              	Error            error
              }

                AttachVolumesResult contains the result of a VolumeSource.AttachVolumes call for one volume. VolumeAttachment should only be used if Error is nil.

                type AttachmentParams

                type AttachmentParams struct {
                	// Provider is the name of the storage provider that is to be used to
                	// create the attachment.
                	Provider ProviderType
                
                	// Machine is the tag of the Juju machine that the storage should be
                	// attached to. Storage providers may use this to perform machine-
                	// specific operations, such as configuring access controls for the
                	// machine.
                	// This is a generic tag as it's also used to hold a unit for caas storage.
                	// TODO(caas)-rename to Host
                	Machine names.Tag
                
                	// InstanceId is the ID of the cloud instance that the storage should
                	// be attached to. This will only be of interest to storage providers
                	// that interact with the instances, such as EBS/EC2. The InstanceId
                	// field will be empty if the instance is not yet provisioned.
                	InstanceId instance.Id
                
                	// ReadOnly indicates that the storage should be attached as read-only.
                	ReadOnly bool
                }

                  AttachmentParams describes the parameters for attaching a volume or filesystem to a machine.

                  type Attrs

                  type Attrs map[string]interface{}

                    Attrs defines storage attributes.

                    type BlockDevice

                    type BlockDevice struct {
                    	// DeviceName is the block device's OS-specific name (e.g. "sdb").
                    	DeviceName string `yaml:"devicename,omitempty"`
                    
                    	// DeviceLinks is a collection of symlinks to the block device
                    	// that the OS maintains (e.g. "/dev/disk/by-id/..."). Storage
                    	// provisioners can match volume attachments to device links if
                    	// they know ahead of time how the OS will name them.
                    	DeviceLinks []string `yaml:"devicelinks,omitempty"`
                    
                    	// Label is the label for the filesystem on the block device.
                    	//
                    	// This will be empty if the block device does not have a filesystem,
                    	// or if the filesystem is not yet known to Juju.
                    	Label string `yaml:"label,omitempty"`
                    
                    	// UUID is a unique identifier for the filesystem on the block device.
                    	//
                    	// This will be empty if the block device does not have a filesystem,
                    	// or if the filesystem is not yet known to Juju.
                    	//
                    	// The UUID format is not necessarily uniform; for example, LVM UUIDs
                    	// differ in format to the standard v4 UUIDs.
                    	UUID string `yaml:"uuid,omitempty"`
                    
                    	// HardwareId is the block device's hardware ID, which is composed of
                    	// a serial number, vendor and model name. Not all block devices have
                    	// these properties, so HardwareId may be empty. This is used to identify
                    	// a block device if it is available, in preference to UUID or device
                    	// name, as the hardware ID is immutable.
                    	HardwareId string `yaml:"hardwareid,omitempty"`
                    
                    	// WWN is the block device's World Wide Name (WWN) unique identifier.
                    	// Not all block devices have one, so WWN may be empty. This is used
                    	// to identify a block device if it is available, in preference to
                    	// UUID or device name, as the WWN is immutable.
                    	WWN string `yaml:"wwn,omitempty"`
                    
                    	// BusAddress is the bus address: where the block device is attached
                    	// to the machine. This is currently only populated for disks attached
                    	// to the SCSI bus.
                    	//
                    	// The format for this is <bus>@<bus-specific-address> as according to
                    	// "lshw -businfo". For example, for a SCSI disk with Host=1, Bus=2,
                    	// Target=3, Lun=4, we populate this field with "scsi@1:2.3.4".
                    	BusAddress string `yaml:"busaddress,omitempty"`
                    
                    	// Size is the size of the block device, in MiB.
                    	Size uint64 `yaml:"size"`
                    
                    	// FilesystemType is the type of the filesystem present on the block
                    	// device, if any.
                    	FilesystemType string `yaml:"fstype,omitempty"`
                    
                    	// InUse indicates that the block device is in use (e.g. mounted).
                    	InUse bool `yaml:"inuse"`
                    
                    	// MountPoint is the path at which the block devices is mounted.
                    	MountPoint string `yaml:"mountpoint,omitempty"`
                    
                    	// SerialId is the block devices serial id used for matching.
                    	SerialId string `yaml:"serialid,omitempty"`
                    }

                      BlockDevice describes a block device discovered on a machine.

                      type ChainedProviderRegistry

                      type ChainedProviderRegistry []ProviderRegistry

                        ChainedProviderRegistry is storage provider registry that combines multiple storage provider registries, chaining their results. Registries earlier in the chain take precedence.

                        func (ChainedProviderRegistry) StorageProvider

                        func (r ChainedProviderRegistry) StorageProvider(t ProviderType) (Provider, error)

                          StorageProvider implements ProviderRegistry.

                          func (ChainedProviderRegistry) StorageProviderTypes

                          func (r ChainedProviderRegistry) StorageProviderTypes() ([]ProviderType, error)

                            StorageProviderTypes implements ProviderRegistry.

                            type Config

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

                              Config defines the configuration for a storage source.

                              func NewConfig

                              func NewConfig(name string, provider ProviderType, attrs Attrs) (*Config, error)

                                NewConfig creates a new Config for instantiating a storage source.

                                func (*Config) Attrs

                                func (c *Config) Attrs() Attrs

                                  Attrs returns the configuration attributes for a storage source.

                                  func (*Config) Name

                                  func (c *Config) Name() string

                                    Name returns the name of a storage source. This is not necessarily unique, and should only be used for informational purposes.

                                    func (*Config) Provider

                                    func (c *Config) Provider() ProviderType

                                      Provider returns the name of a storage provider.

                                      func (*Config) ValueString

                                      func (c *Config) ValueString(name string) (string, bool)

                                        ValueString returns the named config attribute as a string.

                                        type Constraints

                                        type Constraints struct {
                                        	// Pool is the name of the storage pool (ebs, ceph, custompool, ...)
                                        	// that must provide the storage, or "" if the default pool should be
                                        	// used.
                                        	Pool string
                                        
                                        	// Size is the minimum size of the storage in MiB.
                                        	Size uint64
                                        
                                        	// Count is the number of instances of the storage to create.
                                        	Count uint64
                                        }

                                          Constraints describes a set of storage constraints.

                                          func ParseConstraints

                                          func ParseConstraints(s string) (Constraints, error)

                                            ParseConstraints parses the specified string and creates a Constraints structure.

                                            The acceptable format for storage constraints is a comma separated sequence of: POOL, COUNT, and SIZE, where

                                            POOL identifies the storage pool. POOL can be a string
                                            starting with a letter, followed by zero or more digits
                                            or letters optionally separated by hyphens.
                                            
                                            COUNT is a positive integer indicating how many instances
                                            of the storage to create. If unspecified, and SIZE is
                                            specified, COUNT defaults to 1.
                                            
                                            SIZE describes the minimum size of the storage instances to
                                            create. SIZE is a floating point number and multiplier from
                                            the set (M, G, T, P, E, Z, Y), which are all treated as
                                            powers of 1024.
                                            

                                            type CreateFilesystemsResult

                                            type CreateFilesystemsResult struct {
                                            	Filesystem *Filesystem
                                            	Error      error
                                            }

                                              CreateFilesystemsResult contains the result of a FilesystemSource.CreateFilesystems call for one filesystem. Filesystem should only be used if Error is nil.

                                              type CreateVolumesResult

                                              type CreateVolumesResult struct {
                                              	Volume           *Volume
                                              	VolumeAttachment *VolumeAttachment
                                              	Error            error
                                              }

                                                CreateVolumesResult contains the result of a VolumeSource.CreateVolumes call for one volume. Volume and VolumeAttachment should only be used if Error is nil.

                                                type DescribeVolumesResult

                                                type DescribeVolumesResult struct {
                                                	VolumeInfo *VolumeInfo
                                                	Error      error
                                                }

                                                  DescribeVolumesResult contains the result of a VolumeSource.DescribeVolumes call for one volume. Volume should only be used if Error is nil.

                                                  type DeviceType

                                                  type DeviceType string
                                                  var (
                                                  	DeviceTypeLocal DeviceType = "local"
                                                  	DeviceTypeISCSI DeviceType = "iscsi"
                                                  )

                                                  type Filesystem

                                                  type Filesystem struct {
                                                  	// Tag is a unique name assigned by Juju to the filesystem.
                                                  	Tag names.FilesystemTag
                                                  
                                                  	// Volume is the tag of the volume that backs the filesystem, if any.
                                                  	Volume names.VolumeTag
                                                  
                                                  	FilesystemInfo
                                                  }

                                                    Filesystem identifies and describes a filesystem, either local or remote (NFS, Ceph etc).

                                                    type FilesystemAttachment

                                                    type FilesystemAttachment struct {
                                                    	// Filesystem is the unique tag assigned by Juju for the filesystem
                                                    	// that this attachment corresponds to.
                                                    	Filesystem names.FilesystemTag
                                                    
                                                    	// Machine is the unique tag assigned by Juju for the machine that
                                                    	// this attachment corresponds to.
                                                    	Machine names.Tag
                                                    
                                                    	FilesystemAttachmentInfo
                                                    }

                                                      FilesystemAttachment describes machine-specific filesystem attachment information, including how the filesystem is exposed on the machine.

                                                      type FilesystemAttachmentInfo

                                                      type FilesystemAttachmentInfo struct {
                                                      	// Path is the path at which the filesystem is mounted on the machine
                                                      	// that this attachment corresponds to.
                                                      	Path string
                                                      
                                                      	// ReadOnly indicates that the filesystem is mounted read-only.
                                                      	ReadOnly bool
                                                      }

                                                        FilesystemAttachmentInfo describes machine-specific filesystem attachment information, including how the filesystem is exposed on the machine.

                                                        type FilesystemAttachmentParams

                                                        type FilesystemAttachmentParams struct {
                                                        	AttachmentParams
                                                        
                                                        	// Filesystem is a unique tag assigned by Juju for the filesystem that
                                                        	// should be attached/detached.
                                                        	Filesystem names.FilesystemTag
                                                        
                                                        	// FilesystemId is the unique provider-supplied ID for the filesystem that
                                                        	// should be attached/detached.
                                                        	FilesystemId string
                                                        
                                                        	// Path is the path at which the filesystem is to be mounted on the machine that
                                                        	// this attachment corresponds to.
                                                        	Path string
                                                        }

                                                          FilesystemAttachmentParams is a set of parameters for filesystem attachment or detachment.

                                                          type FilesystemImporter

                                                          type FilesystemImporter interface {
                                                          	// ImportFilesystem updates the filesystem with the specified
                                                          	// filesystem provider ID with the given resource tags, so that
                                                          	// it is seen as being managed by this Juju controller/model.
                                                          	// ImportFilesystem returns the filesystem information to store
                                                          	// in the model.
                                                          	//
                                                          	// Implementations of ImportFilesystem should validate that the
                                                          	// filesystem is not in use before allowing the import to proceed.
                                                          	// Once it is imported, it is assumed to be in a detached state.
                                                          	ImportFilesystem(
                                                          		ctx context.ProviderCallContext,
                                                          		filesystemId string,
                                                          		resourceTags map[string]string,
                                                          	) (FilesystemInfo, error)
                                                          }

                                                            FilesystemImporter provides an interface for importing filesystems into the controller/model.

                                                            TODO(axw) make this part of FilesystemSource?

                                                            type FilesystemInfo

                                                            type FilesystemInfo struct {
                                                            	// FilesystemId is a unique provider-supplied ID for the filesystem.
                                                            	// FilesystemId is required to be unique for the lifetime of the
                                                            	// filesystem, but may be reused.
                                                            	FilesystemId string
                                                            
                                                            	// Size is the size of the filesystem, in MiB.
                                                            	Size uint64
                                                            }

                                                              Filesystem describes a filesystem, either local or remote (NFS, Ceph etc).

                                                              type FilesystemParams

                                                              type FilesystemParams struct {
                                                              	// Tag is a unique tag assigned by Juju for the requested filesystem.
                                                              	Tag names.FilesystemTag
                                                              
                                                              	// Volume is the tag of the volume that backs the filesystem, if any.
                                                              	Volume names.VolumeTag
                                                              
                                                              	// Size is the minimum size of the filesystem in MiB.
                                                              	Size uint64
                                                              
                                                              	// The provider type for this filesystem.
                                                              	Provider ProviderType
                                                              
                                                              	// Attributes is a set of provider-specific options for storage creation,
                                                              	// as defined in a storage pool.
                                                              	Attributes map[string]interface{}
                                                              
                                                              	// ResourceTags is a set of tags to set on the created filesystem, if the
                                                              	// storage provider supports tags.
                                                              	ResourceTags map[string]string
                                                              
                                                              	// Attachment identifies the machine that the filesystem should be attached
                                                              	// to initially, or nil if the filesystem should not be attached to any
                                                              	// machine.
                                                              	Attachment *FilesystemAttachmentParams
                                                              }

                                                                FilesystemParams is a fully specified set of parameters for filesystem creation, derived from one or more of user-specified storage constraints, a storage pool definition, and charm storage metadata.

                                                                type FilesystemSource

                                                                type FilesystemSource interface {
                                                                	// ValidateFilesystemParams validates the provided filesystem creation
                                                                	// parameters, returning an error if they are invalid.
                                                                	ValidateFilesystemParams(params FilesystemParams) error
                                                                
                                                                	// CreateFilesystems creates filesystems with the specified size, in MiB.
                                                                	CreateFilesystems(ctx context.ProviderCallContext, params []FilesystemParams) ([]CreateFilesystemsResult, error)
                                                                
                                                                	// DestroyFilesystems destroys the filesystems with the specified
                                                                	// providerd filesystem IDs.
                                                                	DestroyFilesystems(ctx context.ProviderCallContext, fsIds []string) ([]error, error)
                                                                
                                                                	// ReleaseFilesystems releases the filesystems with the specified provider
                                                                	// filesystem IDs from the model/controller.
                                                                	ReleaseFilesystems(ctx context.ProviderCallContext, volIds []string) ([]error, error)
                                                                
                                                                	// AttachFilesystems attaches filesystems to machines.
                                                                	//
                                                                	// AttachFilesystems must be idempotent; it may be called even if
                                                                	// the attachment already exists, to ensure that it exists, e.g. over
                                                                	// machine restarts.
                                                                	//
                                                                	// TODO(axw) we need to validate attachment requests prior to
                                                                	// recording in state. For example, the ec2 provider must reject
                                                                	// an attempt to attach a volume to an instance if they are in
                                                                	// different availability zones.
                                                                	AttachFilesystems(ctx context.ProviderCallContext, params []FilesystemAttachmentParams) ([]AttachFilesystemsResult, error)
                                                                
                                                                	// DetachFilesystems detaches the filesystems with the specified
                                                                	// provider filesystem IDs from the instances with the corresponding
                                                                	// index.
                                                                	DetachFilesystems(ctx context.ProviderCallContext, params []FilesystemAttachmentParams) ([]error, error)
                                                                }

                                                                  FilesystemSource provides an interface for creating, destroying and describing filesystems in the environment. A FilesystemSource is configured in a particular way, and corresponds to a storage "pool".

                                                                  type KubernetesFilesystemAttachmentParams

                                                                  type KubernetesFilesystemAttachmentParams struct {
                                                                  	AttachmentParams
                                                                  
                                                                  	// Path is the path at which the filesystem is to be mounted on the pod that
                                                                  	// this attachment corresponds to.
                                                                  	Path string
                                                                  }

                                                                    KubernetesFilesystemAttachmentParams is a set of parameters for filesystem attachment or detachment.

                                                                    type KubernetesFilesystemInfo

                                                                    type KubernetesFilesystemInfo struct {
                                                                    	// MountPoint is the path the filesystem is mounted at.
                                                                    	MountPoint string
                                                                    
                                                                    	// ReadOnly is true if the filesystem is readonly.
                                                                    	ReadOnly bool
                                                                    
                                                                    	// FilesystemId is a unique provider id for the filesystem.
                                                                    	FilesystemId string
                                                                    
                                                                    	// Pool is the name of the storage pool used to
                                                                    	// allocate the filesystem.
                                                                    	Pool string
                                                                    
                                                                    	// Size is the size of the filesystem in MiB.
                                                                    	Size uint64
                                                                    }

                                                                      FilesystemAttachmentInfo describes a filesystem attachment.

                                                                      type KubernetesFilesystemParams

                                                                      type KubernetesFilesystemParams struct {
                                                                      	// StorageName is the name of the storage as specified in the charm.
                                                                      	StorageName string
                                                                      
                                                                      	// Size is the minimum size of the filesystem in MiB.
                                                                      	Size uint64
                                                                      
                                                                      	// The provider type for this filesystem.
                                                                      	Provider ProviderType
                                                                      
                                                                      	// Attributes is a set of provider-specific options for storage creation,
                                                                      	// as defined in a storage pool.
                                                                      	Attributes map[string]interface{}
                                                                      
                                                                      	// ResourceTags is a set of tags to set on the created filesystem, if the
                                                                      	// storage provider supports tags.
                                                                      	ResourceTags map[string]string
                                                                      
                                                                      	// Attachment identifies the mount point the filesystem should be
                                                                      	// mounted at.
                                                                      	Attachment *KubernetesFilesystemAttachmentParams
                                                                      }

                                                                        KubernetesFilesystemParams is a fully specified set of parameters for filesystem creation, derived from one or more of user-specified storage constraints, a storage pool definition, and charm storage metadata.

                                                                        type Provider

                                                                        type Provider interface {
                                                                        	// VolumeSource returns a VolumeSource given the specified storage
                                                                        	// provider configurations, or an error if the provider does not
                                                                        	// support creating volumes or the configuration is invalid.
                                                                        	//
                                                                        	// If the storage provider does not support creating volumes as a
                                                                        	// first-class primitive, then VolumeSource must return an error
                                                                        	// satisfying errors.IsNotSupported.
                                                                        	VolumeSource(*Config) (VolumeSource, error)
                                                                        
                                                                        	// FilesystemSource returns a FilesystemSource given the specified
                                                                        	// storage provider configurations, or an error if the provider does
                                                                        	// not support creating filesystems or the configuration is invalid.
                                                                        	FilesystemSource(*Config) (FilesystemSource, error)
                                                                        
                                                                        	// Supports reports whether or not the storage provider supports
                                                                        	// the specified storage kind.
                                                                        	//
                                                                        	// A provider that supports volumes but not filesystems can still
                                                                        	// be used for creating filesystem storage; Juju will request a
                                                                        	// volume from the provider and then manage the filesystem itself.
                                                                        	Supports(kind StorageKind) bool
                                                                        
                                                                        	// Scope returns the scope of storage managed by this provider.
                                                                        	Scope() Scope
                                                                        
                                                                        	// Dynamic reports whether or not the storage provider is capable
                                                                        	// of dynamic storage provisioning. Non-dynamic storage must be
                                                                        	// created at the time a machine is provisioned.
                                                                        	Dynamic() bool
                                                                        
                                                                        	// Releasable reports whether or not the storage provider is capable
                                                                        	// of releasing dynamic storage, with either ReleaseVolumes or
                                                                        	// ReleaseFilesystems.
                                                                        	Releasable() bool
                                                                        
                                                                        	// DefaultPools returns the default storage pools for this provider,
                                                                        	// to register in each new model.
                                                                        	DefaultPools() []*Config
                                                                        
                                                                        	// ValidateConfig validates the provided storage provider config,
                                                                        	// returning an error if it is invalid.
                                                                        	ValidateConfig(*Config) error
                                                                        }

                                                                          Provider is an interface for obtaining storage sources.

                                                                          type ProviderRegistry

                                                                          type ProviderRegistry interface {
                                                                          	// StorageProviderTypes returns the storage provider types
                                                                          	// contained within this registry.
                                                                          	//
                                                                          	// Determining the supported storage providers may be dynamic.
                                                                          	// Multiple calls for the same registry must return consistent
                                                                          	// results.
                                                                          	StorageProviderTypes() ([]ProviderType, error)
                                                                          
                                                                          	// StorageProvider returns the storage provider with the given
                                                                          	// provider type. StorageProvider must return an errors satisfying
                                                                          	// errors.IsNotFound if the registry does not contain the
                                                                          	// specified provider type.
                                                                          	StorageProvider(ProviderType) (Provider, error)
                                                                          }

                                                                            ProviderRegistry is an interface for obtaining storage providers.

                                                                            type ProviderType

                                                                            type ProviderType string

                                                                              ProviderType uniquely identifies a storage provider, such as "ebs" or "loop".

                                                                              type Scope

                                                                              type Scope int

                                                                                Scope defines the scope of the storage that a provider manages. Machine-scoped storage must be managed from within the machine, whereas environment-level storage must be managed by an environment storage provisioner.

                                                                                const (
                                                                                	ScopeEnviron Scope = iota
                                                                                	ScopeMachine
                                                                                )

                                                                                type StaticProviderRegistry

                                                                                type StaticProviderRegistry struct {
                                                                                	// Providers contains the storage providers for this registry.
                                                                                	Providers map[ProviderType]Provider
                                                                                }

                                                                                  StaticProviderRegistry is a storage provider registry with a statically defined set of providers.

                                                                                  func (StaticProviderRegistry) StorageProvider

                                                                                  func (r StaticProviderRegistry) StorageProvider(t ProviderType) (Provider, error)

                                                                                    StorageProvider implements ProviderRegistry.

                                                                                    func (StaticProviderRegistry) StorageProviderTypes

                                                                                    func (r StaticProviderRegistry) StorageProviderTypes() ([]ProviderType, error)

                                                                                      StorageProviderTypes implements ProviderRegistry.

                                                                                      type StorageAttachmentInfo

                                                                                      type StorageAttachmentInfo struct {
                                                                                      	// Kind is the kind of the storage attachment.
                                                                                      	Kind StorageKind
                                                                                      
                                                                                      	// Location is the storage attachment's location: the mount point
                                                                                      	// for a filesystem-kind storage attachment, and the device path
                                                                                      	// for a block-kind.
                                                                                      	Location string
                                                                                      }

                                                                                        StorageAttachmentInfo provides unit-specific information about a storage instance. StorageAttachmentInfo is based on either a volume attachment or a filesystem attachment, depending on its kind.

                                                                                        type StorageInstance

                                                                                        type StorageInstance struct {
                                                                                        	// Tag is a unique tag assigned by Juju to the storage instance.
                                                                                        	Tag names.StorageTag
                                                                                        
                                                                                        	// Kind is the kind of the datastore (block device, filesystem).
                                                                                        	Kind StorageKind
                                                                                        }

                                                                                          StorageInstance describes a storage instance, assigned to an application or unit.

                                                                                          type StorageKind

                                                                                          type StorageKind int

                                                                                            StorageKind defines the type of the datastore: whether it is a raw block device, or a filesystem.

                                                                                            const (
                                                                                            	StorageKindUnknown StorageKind = iota
                                                                                            	StorageKindBlock
                                                                                            	StorageKindFilesystem
                                                                                            )

                                                                                            func (StorageKind) String

                                                                                            func (k StorageKind) String() string

                                                                                            type Volume

                                                                                            type Volume struct {
                                                                                            	// Name is a unique name assigned by Juju to the volume.
                                                                                            	Tag names.VolumeTag
                                                                                            
                                                                                            	VolumeInfo
                                                                                            }

                                                                                              Volume identifies and describes a volume (disk, logical volume, etc.)

                                                                                              type VolumeAttachment

                                                                                              type VolumeAttachment struct {
                                                                                              	// Volume is the unique tag assigned by Juju for the volume
                                                                                              	// that this attachment corresponds to.
                                                                                              	Volume names.VolumeTag
                                                                                              
                                                                                              	// Machine is the unique tag assigned by Juju for the machine that
                                                                                              	// this attachment corresponds to.
                                                                                              	Machine names.Tag
                                                                                              
                                                                                              	VolumeAttachmentInfo
                                                                                              }

                                                                                                VolumeAttachment identifies and describes machine-specific volume attachment information, including how the volume is exposed on the machine.

                                                                                                type VolumeAttachmentInfo

                                                                                                type VolumeAttachmentInfo struct {
                                                                                                	// DeviceName is the volume's OS-specific device name (e.g. "sdb").
                                                                                                	//
                                                                                                	// If the device name may change (e.g. on machine restart), then this
                                                                                                	// field must be left blank.
                                                                                                	DeviceName string
                                                                                                
                                                                                                	// DeviceLink is an OS-specific device link that must exactly match
                                                                                                	// one of the block device's links when attached.
                                                                                                	//
                                                                                                	// If no device link is known, or it may change (e.g. on machine
                                                                                                	// restart), then this field must be left blank.
                                                                                                	DeviceLink string
                                                                                                
                                                                                                	// BusAddress is the bus address, where the volume is attached to
                                                                                                	// the machine.
                                                                                                	//
                                                                                                	// The format of this field must match the field of the same name
                                                                                                	// in BlockDevice.
                                                                                                	BusAddress string
                                                                                                
                                                                                                	// ReadOnly signifies whether the volume is read only or writable.
                                                                                                	ReadOnly bool
                                                                                                
                                                                                                	// PlanInfo holds information that the machine agent might use to
                                                                                                	// initialize the block device that has been attached to it.
                                                                                                	PlanInfo *VolumeAttachmentPlanInfo
                                                                                                }

                                                                                                  VolumeAttachmentInfo describes machine-specific volume attachment information, including how the volume is exposed on the machine.

                                                                                                  type VolumeAttachmentParams

                                                                                                  type VolumeAttachmentParams struct {
                                                                                                  	AttachmentParams
                                                                                                  
                                                                                                  	// Volume is a unique tag assigned by Juju for the volume that
                                                                                                  	// should be attached/detached.
                                                                                                  	Volume names.VolumeTag
                                                                                                  
                                                                                                  	// VolumeId is the unique provider-supplied ID for the volume that
                                                                                                  	// should be attached/detached.
                                                                                                  	VolumeId string
                                                                                                  }

                                                                                                    VolumeAttachmentParams is a set of parameters for volume attachment or detachment.

                                                                                                    type VolumeAttachmentPlan

                                                                                                    type VolumeAttachmentPlan struct {
                                                                                                    	// Volume is the unique tag assigned by Juju for the volume
                                                                                                    	// that this attachment corresponds to.
                                                                                                    	Volume names.VolumeTag
                                                                                                    
                                                                                                    	// Machine is the unique tag assigned by Juju for the machine that
                                                                                                    	// this attachment corresponds to.
                                                                                                    	Machine names.MachineTag
                                                                                                    
                                                                                                    	VolumeAttachmentPlanInfo
                                                                                                    }

                                                                                                    type VolumeAttachmentPlanInfo

                                                                                                    type VolumeAttachmentPlanInfo struct {
                                                                                                    	// DeviceType describes what type of volume we are dealing with
                                                                                                    	// possible options are:
                                                                                                    	// * local - a block device that is directly attached to this instance
                                                                                                    	// * iscsi - an iSCSI disk. This type of disk will require the machine agent
                                                                                                    	// to execute additional steps before the device is available
                                                                                                    	DeviceType DeviceType
                                                                                                    	// DeviceAttributes is a map that contains DeviceType specific initialization
                                                                                                    	// values. For example, in the case of iscsi, it may contain server address:port,
                                                                                                    	// target, chap secrets, etc.
                                                                                                    	DeviceAttributes map[string]string
                                                                                                    }

                                                                                                    type VolumeImporter

                                                                                                    type VolumeImporter interface {
                                                                                                    	// ImportVolume updates the volume with the specified volume
                                                                                                    	// provider ID with the given resource tags, so that it is
                                                                                                    	// seen as being managed by this Juju controller/model.
                                                                                                    	// ImportVolume returns the volume information to store
                                                                                                    	// in the model.
                                                                                                    	//
                                                                                                    	// Implementations of ImportVolume should validate that the
                                                                                                    	// volume is not in use before allowing the import to proceed.
                                                                                                    	// Once it is imported, it is assumed to be in a detached state.
                                                                                                    	ImportVolume(
                                                                                                    		ctx context.ProviderCallContext,
                                                                                                    		volumeId string,
                                                                                                    		resourceTags map[string]string,
                                                                                                    	) (VolumeInfo, error)
                                                                                                    }

                                                                                                      VolumeImporter provides an interface for importing volumes into the controller/model.

                                                                                                      TODO(axw) make this part of VolumeSource?

                                                                                                      type VolumeInfo

                                                                                                      type VolumeInfo struct {
                                                                                                      	// VolumeId is a unique provider-supplied ID for the volume.
                                                                                                      	// VolumeId is required to be unique for the lifetime of the
                                                                                                      	// volume, but may be reused.
                                                                                                      	VolumeId string
                                                                                                      
                                                                                                      	// HardwareId is the volume's hardware ID. Not all volumes have
                                                                                                      	// a hardware ID, so this may be left blank.
                                                                                                      	HardwareId string
                                                                                                      
                                                                                                      	// WWN is the volume's World Wide Name (WWN). Not all volumes
                                                                                                      	// have a WWN, so this may be left blank.
                                                                                                      	WWN string
                                                                                                      
                                                                                                      	// Size is the size of the volume, in MiB.
                                                                                                      	Size uint64
                                                                                                      
                                                                                                      	// Persistent reflects whether the volume is destroyed with the
                                                                                                      	// machine to which it is attached.
                                                                                                      	Persistent bool
                                                                                                      }

                                                                                                        VolumeInfo describes a volume (disk, logical volume etc.)

                                                                                                        type VolumeParams

                                                                                                        type VolumeParams struct {
                                                                                                        	// Tag is a unique tag name assigned by Juju for the requested volume.
                                                                                                        	Tag names.VolumeTag
                                                                                                        
                                                                                                        	// Size is the minimum size of the volume in MiB.
                                                                                                        	Size uint64
                                                                                                        
                                                                                                        	// Provider is the name of the storage provider that is to be used to
                                                                                                        	// create the volume.
                                                                                                        	Provider ProviderType
                                                                                                        
                                                                                                        	// Attributes is the set of provider-specific attributes to pass to
                                                                                                        	// the storage provider when creating the volume. Attributes is derived
                                                                                                        	// from the storage pool configuration.
                                                                                                        	Attributes map[string]interface{}
                                                                                                        
                                                                                                        	// ResourceTags is a set of tags to set on the created volume, if the
                                                                                                        	// storage provider supports tags.
                                                                                                        	ResourceTags map[string]string
                                                                                                        
                                                                                                        	// Attachment identifies the machine that the volume should be attached
                                                                                                        	// to initially, or nil if the volume should not be attached to any
                                                                                                        	// machine. Some providers, such as MAAS, do not support dynamic
                                                                                                        	// attachment, and so provisioning time is the only opportunity to
                                                                                                        	// perform attachment.
                                                                                                        	//
                                                                                                        	// When machine instances are created, the instance provider will be
                                                                                                        	// presented with parameters for any due-to-be-attached volumes. If
                                                                                                        	// once the instance is created there are still unprovisioned volumes,
                                                                                                        	// the dynamic storage provisioner will take care of creating them.
                                                                                                        	Attachment *VolumeAttachmentParams
                                                                                                        }

                                                                                                          VolumeParams is a fully specified set of parameters for volume creation, derived from one or more of user-specified storage constraints, a storage pool definition, and charm storage metadata.

                                                                                                          type VolumeSource

                                                                                                          type VolumeSource interface {
                                                                                                          	// CreateVolumes creates volumes with the specified parameters. If the
                                                                                                          	// volumes are initially attached, then CreateVolumes returns
                                                                                                          	// information about those attachments too.
                                                                                                          	CreateVolumes(ctx context.ProviderCallContext, params []VolumeParams) ([]CreateVolumesResult, error)
                                                                                                          
                                                                                                          	// ListVolumes lists the provider volume IDs for every volume
                                                                                                          	// created by this volume source.
                                                                                                          	ListVolumes(ctx context.ProviderCallContext) ([]string, error)
                                                                                                          
                                                                                                          	// DescribeVolumes returns the properties of the volumes with the
                                                                                                          	// specified provider volume IDs.
                                                                                                          	DescribeVolumes(ctx context.ProviderCallContext, volIds []string) ([]DescribeVolumesResult, error)
                                                                                                          
                                                                                                          	// DestroyVolumes destroys the volumes with the specified provider
                                                                                                          	// volume IDs.
                                                                                                          	DestroyVolumes(ctx context.ProviderCallContext, volIds []string) ([]error, error)
                                                                                                          
                                                                                                          	// ReleaseVolumes releases the volumes with the specified provider
                                                                                                          	// volume IDs from the model/controller.
                                                                                                          	ReleaseVolumes(ctx context.ProviderCallContext, volIds []string) ([]error, error)
                                                                                                          
                                                                                                          	// ValidateVolumeParams validates the provided volume creation
                                                                                                          	// parameters, returning an error if they are invalid.
                                                                                                          	ValidateVolumeParams(params VolumeParams) error
                                                                                                          
                                                                                                          	// AttachVolumes attaches volumes to machines.
                                                                                                          	//
                                                                                                          	// AttachVolumes must be idempotent; it may be called even if the
                                                                                                          	// attachment already exists, to ensure that it exists, e.g. over
                                                                                                          	// machine restarts.
                                                                                                          	//
                                                                                                          	// TODO(axw) we need to validate attachment requests prior to
                                                                                                          	// recording in state. For example, the ec2 provider must reject
                                                                                                          	// an attempt to attach a volume to an instance if they are in
                                                                                                          	// different availability zones.
                                                                                                          	AttachVolumes(ctx context.ProviderCallContext, params []VolumeAttachmentParams) ([]AttachVolumesResult, error)
                                                                                                          
                                                                                                          	// DetachVolumes detaches the volumes with the specified provider
                                                                                                          	// volume IDs from the instances with the corresponding index.
                                                                                                          	//
                                                                                                          	// TODO(axw) we need to record in state whether or not volumes
                                                                                                          	// are detachable, and reject attempts to attach/detach on
                                                                                                          	// that basis.
                                                                                                          	DetachVolumes(ctx context.ProviderCallContext, params []VolumeAttachmentParams) ([]error, error)
                                                                                                          }

                                                                                                            VolumeSource provides an interface for creating, destroying, describing, attaching and detaching volumes in the environment. A VolumeSource is configured in a particular way, and corresponds to a storage "pool".

                                                                                                            Directories

                                                                                                            Path Synopsis