// Filesystems returns details of filesystems with the specified tags. func (s *StorageProvisionerAPI) Filesystems(args params.Entities) (params.FilesystemResults, error) { canAccess, err := s.getStorageEntityAuthFunc() if err != nil { return params.FilesystemResults{}, common.ServerError(common.ErrPerm) } results := params.FilesystemResults{ Results: make([]params.FilesystemResult, len(args.Entities)), } one := func(arg params.Entity) (params.Filesystem, error) { tag, err := names.ParseFilesystemTag(arg.Tag) if err != nil || !canAccess(tag) { return params.Filesystem{}, common.ErrPerm } filesystem, err := s.st.Filesystem(tag) if errors.IsNotFound(err) { return params.Filesystem{}, common.ErrPerm } else if err != nil { return params.Filesystem{}, err } return storagecommon.FilesystemFromState(filesystem) } for i, arg := range args.Entities { var result params.FilesystemResult filesystem, err := one(arg) if err != nil { result.Error = common.ServerError(err) } else { result.Result = filesystem } results.Results[i] = result } return results, nil }
func createFilesystemInfo(result params.FilesystemDetailsResult) (names.FilesystemTag, FilesystemInfo, error) { details := result.Result filesystemTag, err := names.ParseFilesystemTag(details.FilesystemTag) if err != nil { return names.FilesystemTag{}, FilesystemInfo{}, errors.Trace(err) } var info FilesystemInfo info.ProviderFilesystemId = details.Info.FilesystemId info.Size = details.Info.Size info.Status = EntityStatus{ details.Status.Status, details.Status.Info, // TODO(axw) we should support formatting as ISO time common.FormatTime(details.Status.Since, false), } if details.VolumeTag != "" { volumeId, err := idFromTag(details.VolumeTag) if err != nil { return names.FilesystemTag{}, FilesystemInfo{}, errors.Trace(err) } info.Volume = volumeId } if len(details.MachineAttachments) > 0 { machineAttachments := make(map[string]MachineFilesystemAttachment) for machineTag, attachment := range details.MachineAttachments { machineId, err := idFromTag(machineTag) if err != nil { return names.FilesystemTag{}, FilesystemInfo{}, errors.Trace(err) } machineAttachments[machineId] = MachineFilesystemAttachment{ attachment.MountPoint, attachment.ReadOnly, } } info.Attachments = &FilesystemAttachments{ Machines: machineAttachments, } } if details.Storage != nil { storageTag, storageInfo, err := createStorageInfo(*details.Storage) if err != nil { return names.FilesystemTag{}, FilesystemInfo{}, errors.Trace(err) } info.Storage = storageTag.Id() if storageInfo.Attachments != nil { info.Attachments.Units = storageInfo.Attachments.Units } } return filesystemTag, info, nil }
// FilesystemToState converts a params.Filesystem to state.FilesystemInfo // and names.FilesystemTag. func FilesystemToState(v params.Filesystem) (names.FilesystemTag, state.FilesystemInfo, error) { filesystemTag, err := names.ParseFilesystemTag(v.FilesystemTag) if err != nil { return names.FilesystemTag{}, state.FilesystemInfo{}, errors.Trace(err) } return filesystemTag, state.FilesystemInfo{ v.Info.Size, "", // pool is set by state v.Info.FilesystemId, }, nil }
// FilesystemParams returns the parameters for creating the filesystems // with the specified tags. func (s *StorageProvisionerAPI) FilesystemParams(args params.Entities) (params.FilesystemParamsResults, error) { canAccess, err := s.getStorageEntityAuthFunc() if err != nil { return params.FilesystemParamsResults{}, err } envConfig, err := s.st.EnvironConfig() if err != nil { return params.FilesystemParamsResults{}, err } results := params.FilesystemParamsResults{ Results: make([]params.FilesystemParamsResult, len(args.Entities)), } poolManager := poolmanager.New(s.settings) one := func(arg params.Entity) (params.FilesystemParams, error) { tag, err := names.ParseFilesystemTag(arg.Tag) if err != nil || !canAccess(tag) { return params.FilesystemParams{}, common.ErrPerm } filesystem, err := s.st.Filesystem(tag) if errors.IsNotFound(err) { return params.FilesystemParams{}, common.ErrPerm } else if err != nil { return params.FilesystemParams{}, err } storageInstance, err := storagecommon.MaybeAssignedStorageInstance( filesystem.Storage, s.st.StorageInstance, ) if err != nil { return params.FilesystemParams{}, err } filesystemParams, err := storagecommon.FilesystemParams( filesystem, storageInstance, envConfig, poolManager, ) if err != nil { return params.FilesystemParams{}, err } return filesystemParams, nil } for i, arg := range args.Entities { var result params.FilesystemParamsResult filesystemParams, err := one(arg) if err != nil { result.Error = common.ServerError(err) } else { result.Result = filesystemParams } results.Results[i] = result } return results, nil }
// FilesystemAttachmentToState converts a storage.FilesystemAttachment // to a state.FilesystemAttachmentInfo. func FilesystemAttachmentToState(in params.FilesystemAttachment) (names.MachineTag, names.FilesystemTag, state.FilesystemAttachmentInfo, error) { machineTag, err := names.ParseMachineTag(in.MachineTag) if err != nil { return names.MachineTag{}, names.FilesystemTag{}, state.FilesystemAttachmentInfo{}, err } filesystemTag, err := names.ParseFilesystemTag(in.FilesystemTag) if err != nil { return names.MachineTag{}, names.FilesystemTag{}, state.FilesystemAttachmentInfo{}, err } info := state.FilesystemAttachmentInfo{ in.Info.MountPoint, in.Info.ReadOnly, } return machineTag, filesystemTag, info, nil }
func filesystemAttachmentFromParams(in params.FilesystemAttachment) (storage.FilesystemAttachment, error) { filesystemTag, err := names.ParseFilesystemTag(in.FilesystemTag) if err != nil { return storage.FilesystemAttachment{}, errors.Trace(err) } machineTag, err := names.ParseMachineTag(in.MachineTag) if err != nil { return storage.FilesystemAttachment{}, errors.Trace(err) } return storage.FilesystemAttachment{ filesystemTag, machineTag, storage.FilesystemAttachmentInfo{ in.Info.MountPoint, in.Info.ReadOnly, }, }, nil }
func filesystemAttachmentParamsFromParams(in params.FilesystemAttachmentParams) (storage.FilesystemAttachmentParams, error) { machineTag, err := names.ParseMachineTag(in.MachineTag) if err != nil { return storage.FilesystemAttachmentParams{}, errors.Trace(err) } filesystemTag, err := names.ParseFilesystemTag(in.FilesystemTag) if err != nil { return storage.FilesystemAttachmentParams{}, errors.Trace(err) } return storage.FilesystemAttachmentParams{ AttachmentParams: storage.AttachmentParams{ Provider: storage.ProviderType(in.Provider), Machine: machineTag, InstanceId: instance.Id(in.InstanceId), ReadOnly: in.ReadOnly, }, Filesystem: filesystemTag, FilesystemId: in.FilesystemId, Path: in.MountPoint, }, nil }
func filesystemFromParams(in params.Filesystem) (storage.Filesystem, error) { filesystemTag, err := names.ParseFilesystemTag(in.FilesystemTag) if err != nil { return storage.Filesystem{}, errors.Trace(err) } var volumeTag names.VolumeTag if in.VolumeTag != "" { volumeTag, err = names.ParseVolumeTag(in.VolumeTag) if err != nil { return storage.Filesystem{}, errors.Trace(err) } } return storage.Filesystem{ filesystemTag, volumeTag, storage.FilesystemInfo{ in.Info.FilesystemId, in.Info.Size, }, }, nil }
func filesystemParamsFromParams(in params.FilesystemParams) (storage.FilesystemParams, error) { filesystemTag, err := names.ParseFilesystemTag(in.FilesystemTag) if err != nil { return storage.FilesystemParams{}, errors.Trace(err) } var volumeTag names.VolumeTag if in.VolumeTag != "" { volumeTag, err = names.ParseVolumeTag(in.VolumeTag) if err != nil { return storage.FilesystemParams{}, errors.Trace(err) } } providerType := storage.ProviderType(in.Provider) return storage.FilesystemParams{ filesystemTag, volumeTag, in.Size, providerType, in.Attributes, in.Tags, }, nil }
func (s *StorageProvisionerAPI) oneFilesystemAttachment( id params.MachineStorageId, canAccess func(names.MachineTag, names.Tag) bool, ) (state.FilesystemAttachment, error) { machineTag, err := names.ParseMachineTag(id.MachineTag) if err != nil { return nil, err } filesystemTag, err := names.ParseFilesystemTag(id.AttachmentTag) if err != nil { return nil, err } if !canAccess(machineTag, filesystemTag) { return nil, common.ErrPerm } filesystemAttachment, err := s.st.FilesystemAttachment(machineTag, filesystemTag) if errors.IsNotFound(err) { return nil, common.ErrPerm } else if err != nil { return nil, err } return filesystemAttachment, nil }
func assertParseFilesystemTagInvalid(c *gc.C, tag string, expect error) { _, err := names.ParseFilesystemTag(tag) c.Assert(err, gc.ErrorMatches, expect.Error()) }
func assertParseFilesystemTag(c *gc.C, tag string, expect names.FilesystemTag) { t, err := names.ParseFilesystemTag(tag) c.Assert(err, gc.IsNil) c.Assert(t, gc.Equals, expect) }