// TODO(axw) move this and createParamsStorageInstance to
// apiserver/common/storage.go, alongside StorageAttachmentInfo.
func (api *API) isPersistent(si state.StorageInstance) (bool, error) {
if si.Kind() != state.StorageKindBlock {
// TODO(axw) when we support persistent filesystems,
// e.g. CephFS, we'll need to do the same thing as
// we do for volumes for filesystems.
return false, nil
}
volume, err := api.storage.StorageInstanceVolume(si.StorageTag())
if err != nil {
return false, err
}
// If the volume is not provisioned, we read its config attributes.
if params, ok := volume.Params(); ok {
_, cfg, err := common.StoragePoolConfig(params.Pool, api.poolManager)
if err != nil {
return false, err
}
return cfg.IsPersistent(), nil
}
// If the volume is provisioned, we look at its provisioning info.
info, err := volume.Info()
if err != nil {
return false, err
}
return info.Persistent, nil
}
// FilesystemAttachmentParams returns the parameters for creating the filesystem
// attachments with the specified IDs.
func (s *StorageProvisionerAPI) FilesystemAttachmentParams(
args params.MachineStorageIds,
) (params.FilesystemAttachmentParamsResults, error) {
canAccess, err := s.getAttachmentAuthFunc()
if err != nil {
return params.FilesystemAttachmentParamsResults{}, common.ServerError(common.ErrPerm)
}
results := params.FilesystemAttachmentParamsResults{
Results: make([]params.FilesystemAttachmentParamsResult, len(args.Ids)),
}
poolManager := poolmanager.New(s.settings)
one := func(arg params.MachineStorageId) (params.FilesystemAttachmentParams, error) {
filesystemAttachment, err := s.oneFilesystemAttachment(arg, canAccess)
if err != nil {
return params.FilesystemAttachmentParams{}, err
}
instanceId, err := s.st.MachineInstanceId(filesystemAttachment.Machine())
if errors.IsNotProvisioned(err) {
// The worker must watch for machine provisioning events.
instanceId = ""
} else if err != nil {
return params.FilesystemAttachmentParams{}, err
}
filesystem, err := s.st.Filesystem(filesystemAttachment.Filesystem())
if err != nil {
return params.FilesystemAttachmentParams{}, err
}
var filesystemId string
var pool string
if filesystemParams, ok := filesystem.Params(); ok {
pool = filesystemParams.Pool
} else {
filesystemInfo, err := filesystem.Info()
if err != nil {
return params.FilesystemAttachmentParams{}, err
}
filesystemId = filesystemInfo.FilesystemId
pool = filesystemInfo.Pool
}
providerType, _, err := common.StoragePoolConfig(pool, poolManager)
if err != nil {
return params.FilesystemAttachmentParams{}, errors.Trace(err)
}
var location string
var readOnly bool
if filesystemAttachmentParams, ok := filesystemAttachment.Params(); ok {
location = filesystemAttachmentParams.Location
readOnly = filesystemAttachmentParams.ReadOnly
} else {
// Attachment parameters may be requested even if the
// attachment exists; i.e. for reattachment.
filesystemAttachmentInfo, err := filesystemAttachment.Info()
if err != nil {
return params.FilesystemAttachmentParams{}, errors.Trace(err)
}
location = filesystemAttachmentInfo.MountPoint
readOnly = filesystemAttachmentInfo.ReadOnly
}
return params.FilesystemAttachmentParams{
filesystemAttachment.Filesystem().String(),
filesystemAttachment.Machine().String(),
filesystemId,
string(instanceId),
string(providerType),
// TODO(axw) dealias MountPoint. We now have
// Path, MountPoint and Location in different
// parts of the codebase.
location,
readOnly,
}, nil
}
for i, arg := range args.Ids {
var result params.FilesystemAttachmentParamsResult
filesystemAttachment, err := one(arg)
if err != nil {
result.Error = common.ServerError(err)
} else {
result.Result = filesystemAttachment
}
results.Results[i] = result
}
return results, nil
}
// VolumeAttachmentParams returns the parameters for creating the volume
// attachments with the specified IDs.
func (s *StorageProvisionerAPI) VolumeAttachmentParams(
args params.MachineStorageIds,
) (params.VolumeAttachmentParamsResults, error) {
canAccess, err := s.getAttachmentAuthFunc()
if err != nil {
return params.VolumeAttachmentParamsResults{}, common.ServerError(common.ErrPerm)
}
results := params.VolumeAttachmentParamsResults{
Results: make([]params.VolumeAttachmentParamsResult, len(args.Ids)),
}
poolManager := poolmanager.New(s.settings)
one := func(arg params.MachineStorageId) (params.VolumeAttachmentParams, error) {
volumeAttachment, err := s.oneVolumeAttachment(arg, canAccess)
if err != nil {
return params.VolumeAttachmentParams{}, err
}
instanceId, err := s.st.MachineInstanceId(volumeAttachment.Machine())
if errors.IsNotProvisioned(err) {
// The worker must watch for machine provisioning events.
instanceId = ""
} else if err != nil {
return params.VolumeAttachmentParams{}, err
}
volume, err := s.st.Volume(volumeAttachment.Volume())
if err != nil {
return params.VolumeAttachmentParams{}, err
}
var volumeId string
var pool string
if volumeParams, ok := volume.Params(); ok {
pool = volumeParams.Pool
} else {
volumeInfo, err := volume.Info()
if err != nil {
return params.VolumeAttachmentParams{}, err
}
volumeId = volumeInfo.VolumeId
pool = volumeInfo.Pool
}
providerType, _, err := common.StoragePoolConfig(pool, poolManager)
if err != nil {
return params.VolumeAttachmentParams{}, errors.Trace(err)
}
var readOnly bool
if volumeAttachmentParams, ok := volumeAttachment.Params(); ok {
readOnly = volumeAttachmentParams.ReadOnly
} else {
// Attachment parameters may be requested even if the
// attachment exists; i.e. for reattachment.
volumeAttachmentInfo, err := volumeAttachment.Info()
if err != nil {
return params.VolumeAttachmentParams{}, errors.Trace(err)
}
readOnly = volumeAttachmentInfo.ReadOnly
}
return params.VolumeAttachmentParams{
volumeAttachment.Volume().String(),
volumeAttachment.Machine().String(),
volumeId,
string(instanceId),
string(providerType),
readOnly,
}, nil
}
for i, arg := range args.Ids {
var result params.VolumeAttachmentParamsResult
volumeAttachment, err := one(arg)
if err != nil {
result.Error = common.ServerError(err)
} else {
result.Result = volumeAttachment
}
results.Results[i] = result
}
return results, nil
}