func storageAttachmentInfo(st storageAccess, a state.StorageAttachment) (_ names.MachineTag, location string, _ error) {
machineTag, err := st.UnitAssignedMachine(a.Unit())
if errors.IsNotAssigned(err) {
return names.MachineTag{}, "", nil
} else if err != nil {
return names.MachineTag{}, "", errors.Trace(err)
}
info, err := storagecommon.StorageAttachmentInfo(st, a, machineTag)
if errors.IsNotProvisioned(err) {
return machineTag, "", nil
} else if err != nil {
return names.MachineTag{}, "", errors.Trace(err)
}
return machineTag, info.Location, nil
}
// StorageAttachmentInfo returns the StorageAttachmentInfo for the specified
// StorageAttachment by gathering information from related entities (volumes,
// filesystems).
func StorageAttachmentInfo(
st StorageInterface,
att state.StorageAttachment,
machineTag names.MachineTag,
) (*storage.StorageAttachmentInfo, error) {
storageInstance, err := st.StorageInstance(att.StorageInstance())
if err != nil {
return nil, errors.Annotate(err, "getting storage instance")
}
switch storageInstance.Kind() {
case state.StorageKindBlock:
return volumeStorageAttachmentInfo(st, storageInstance, machineTag)
case state.StorageKindFilesystem:
return filesystemStorageAttachmentInfo(st, storageInstance, machineTag)
}
return nil, errors.Errorf("invalid storage kind %v", storageInstance.Kind())
}
func (api *API) createParamsStorageAttachment(si params.StorageDetails, sa state.StorageAttachment) (params.StorageDetails, error) {
result := params.StorageDetails{Status: "pending"}
result.StorageTag = sa.StorageInstance().String()
if result.StorageTag != si.StorageTag {
panic("attachment does not belong to storage instance")
}
result.UnitTag = sa.Unit().String()
result.OwnerTag = si.OwnerTag
result.Kind = si.Kind
result.Persistent = si.Persistent
// TODO(axw) set status according to whether storage has been provisioned.
// This is only for provisioned attachments
machineTag, err := api.storage.UnitAssignedMachine(sa.Unit())
if err != nil {
return params.StorageDetails{}, errors.Annotate(err, "getting unit for storage attachment")
}
info, err := common.StorageAttachmentInfo(api.storage, sa, machineTag)
if err != nil {
if errors.IsNotProvisioned(err) {
// If Info returns an error, then the storage has not yet been provisioned.
return result, nil
}
return params.StorageDetails{}, errors.Annotate(err, "getting storage attachment info")
}
result.Location = info.Location
if result.Location != "" {
result.Status = "attached"
}
return result, nil
}
func (s *StorageAPI) fromStateStorageAttachment(stateStorageAttachment state.StorageAttachment) (params.StorageAttachment, error) {
machineTag, err := s.st.UnitAssignedMachine(stateStorageAttachment.Unit())
if err != nil {
return params.StorageAttachment{}, err
}
info, err := common.StorageAttachmentInfo(s.st, stateStorageAttachment, machineTag)
if err != nil {
return params.StorageAttachment{}, err
}
stateStorageInstance, err := s.st.StorageInstance(stateStorageAttachment.StorageInstance())
if err != nil {
return params.StorageAttachment{}, err
}
return params.StorageAttachment{
stateStorageAttachment.StorageInstance().String(),
stateStorageInstance.Owner().String(),
stateStorageAttachment.Unit().String(),
params.StorageKind(stateStorageInstance.Kind()),
info.Location,
params.Life(stateStorageAttachment.Life().String()),
}, nil
}
