storage

type BlockDevice struct {
	// Name is a unique name assigned by Juju to the block device.
	Name string `yaml:"name"`

	// ProviderId is a unique provider-supplied ID for the block device.
	// ProviderId is required to be unique for the lifetime of the block-
	// device, but may be reused.
	ProviderId string `yaml:"providerid"`

	// DeviceName is the block device's OS-specific name (e.g. "sdb").
	DeviceName string `yaml:"devicename,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"`

	// Serial is the block device's serial number. Not all block devices
	// have a serial number. This is used to identify a block device if
	// it is available, in preference to UUID or device name, as the serial
	// is immutable.
	Serial string `yaml:"serial,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"`
}

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

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
}

type Provider interface {
	// VolumeSource returns a VolumeSource given the
	// specified cloud and storage provider configurations.
	//
	// If the storage provider does not support creating volumes as a
	// first-class primitive, then VolumeSource must return an error
	// satisfying errors.IsNotSupported.
	VolumeSource(environConfig *config.Config, providerConfig *Config) (VolumeSource, error)

	// ValidateConfig validates the provided storage provider config,
	// returning an error if it is invalid.
	ValidateConfig(*Config) error
}

type ProviderType string

type StorageInstance struct {
	// Id is a unique name assigned by Juju to the storage instance.
	Id string `yaml:"id" json:"id"`

	// Kind is the kind of the datastore (block device, filesystem).
	Kind StorageKind `yaml:"kind" json:"kind"`

	// Location is the location relevant to the datastore (block device, filesystem).
	Location string `yaml:"location" json:"location"`
}

type StorageKind int

type VolumeParams struct {
	// Name is a unique name assigned by Juju for the requested volume.
	Name string

	// Size is the minimum size of the volume in MiB.
	Size uint64

	// Options is a set of provider-specific options for storage creation,
	// as defined in a storage pool.
	Options map[string]interface{}

	// Instance is the ID of the instance that the volume should be attached
	// to initially. This will only be empty if the instance is not yet
	// provisioned, in which case the parameters refer to a volume that is
	// being created in conjunction with the instance.
	Instance instance.Id
}

type VolumeSource interface {
	// CreateVolumes creates volumes with the specified size, in MiB.
	//
	// TODO(axw) CreateVolumes should return something other than
	// []BlockDevice, so we can communicate additional information
	// about the volumes that are not relevant at the attachment
	// level.
	CreateVolumes(params []VolumeParams) ([]BlockDevice, error)

	// DescribeVolumes returns the properties of the volumes with the
	// specified provider volume IDs.
	//
	// TODO(axw) as in CreateVolumes, we should return something other
	// than []BlockDevice here.
	DescribeVolumes(volIds []string) ([]BlockDevice, error)

	// DestroyVolumes destroys the volumes with the specified provider
	// volume IDs.
	DestroyVolumes(volIds []string) error

	// ValidateVolumeParams validates the provided volume creation
	// parameters, returning an error if they are invalid.
	//
	// If the provider is incapable of provisioning volumes separately
	// from machine instances (e.g. MAAS), then ValidateVolumeParams
	// must return an error if params.Instance is non-empty.
	ValidateVolumeParams(params VolumeParams) error

	// AttachVolumes attaches the volumes with the specified provider
	// volume IDs to the instances with the corresponding index.
	//
	// 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(volIds []string, instId []instance.Id) 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(volIds []string, instId []instance.Id) error
}