// machineVolumeParams retrieves VolumeParams for the volumes that should be // provisioned with, and attached to, the machine. The client should ignore // parameters that it does not know how to handle. func (p *ProvisionerAPI) machineVolumeParams(m *state.Machine) ([]params.VolumeParams, error) { volumeAttachments, err := m.VolumeAttachments() if err != nil { return nil, err } if len(volumeAttachments) == 0 { return nil, nil } envConfig, err := p.st.EnvironConfig() if err != nil { return nil, err } poolManager := poolmanager.New(state.NewStateSettings(p.st)) allVolumeParams := make([]params.VolumeParams, 0, len(volumeAttachments)) for _, volumeAttachment := range volumeAttachments { volumeTag := volumeAttachment.Volume() volume, err := p.st.Volume(volumeTag) if err != nil { return nil, errors.Annotatef(err, "getting volume %q", volumeTag.Id()) } storageInstance, err := common.MaybeAssignedStorageInstance( volume.StorageInstance, p.st.StorageInstance, ) if err != nil { return nil, errors.Annotatef(err, "getting volume %q storage instance", volumeTag.Id()) } volumeParams, err := common.VolumeParams(volume, storageInstance, envConfig, poolManager) if err != nil { return nil, errors.Annotatef(err, "getting volume %q parameters", volumeTag.Id()) } provider, err := registry.StorageProvider(storage.ProviderType(volumeParams.Provider)) if err != nil { return nil, errors.Annotate(err, "getting storage provider") } if provider.Dynamic() { // Leave dynamic storage to the storage provisioner. continue } volumeAttachmentParams, ok := volumeAttachment.Params() if !ok { // Attachment is already provisioned; this is an insane // state, so we should not proceed with the volume. return nil, errors.Errorf( "volume %s already attached to machine %s", volumeTag.Id(), m.Id(), ) } // Not provisioned yet, so ask the cloud provisioner do it. volumeParams.Attachment = ¶ms.VolumeAttachmentParams{ volumeTag.String(), m.Tag().String(), "", // we're creating the volume, so it has no volume ID. "", // we're creating the machine, so it has no instance ID. volumeParams.Provider, volumeAttachmentParams.ReadOnly, } allVolumeParams = append(allVolumeParams, volumeParams) } return allVolumeParams, 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 := common.MaybeAssignedStorageInstance( filesystem.Storage, s.st.StorageInstance, ) if err != nil { return params.FilesystemParams{}, err } filesystemParams, err := common.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 }
// VolumeParams returns the parameters for creating or destroying // the volumes with the specified tags. func (s *StorageProvisionerAPI) VolumeParams(args params.Entities) (params.VolumeParamsResults, error) { canAccess, err := s.getStorageEntityAuthFunc() if err != nil { return params.VolumeParamsResults{}, err } envConfig, err := s.st.EnvironConfig() if err != nil { return params.VolumeParamsResults{}, err } results := params.VolumeParamsResults{ Results: make([]params.VolumeParamsResult, len(args.Entities)), } poolManager := poolmanager.New(s.settings) one := func(arg params.Entity) (params.VolumeParams, error) { tag, err := names.ParseVolumeTag(arg.Tag) if err != nil || !canAccess(tag) { return params.VolumeParams{}, common.ErrPerm } volume, err := s.st.Volume(tag) if errors.IsNotFound(err) { return params.VolumeParams{}, common.ErrPerm } else if err != nil { return params.VolumeParams{}, err } volumeAttachments, err := s.st.VolumeAttachments(tag) if err != nil { return params.VolumeParams{}, err } storageInstance, err := common.MaybeAssignedStorageInstance( volume.StorageInstance, s.st.StorageInstance, ) if err != nil { return params.VolumeParams{}, err } volumeParams, err := common.VolumeParams(volume, storageInstance, envConfig, poolManager) if err != nil { return params.VolumeParams{}, err } if len(volumeAttachments) == 1 { // There is exactly one attachment to be made, so make // it immediately. Otherwise we will defer attachments // until later. volumeAttachment := volumeAttachments[0] volumeAttachmentParams, ok := volumeAttachment.Params() if !ok { return params.VolumeParams{}, errors.Errorf( "volume %q is already attached to machine %q", volumeAttachment.Volume().Id(), volumeAttachment.Machine().Id(), ) } machineTag := volumeAttachment.Machine() instanceId, err := s.st.MachineInstanceId(machineTag) if errors.IsNotProvisioned(err) { // Leave the attachment until later. instanceId = "" } else if err != nil { return params.VolumeParams{}, err } volumeParams.Attachment = ¶ms.VolumeAttachmentParams{ tag.String(), machineTag.String(), "", // volume ID string(instanceId), volumeParams.Provider, volumeAttachmentParams.ReadOnly, } } return volumeParams, nil } for i, arg := range args.Entities { var result params.VolumeParamsResult volumeParams, err := one(arg) if err != nil { result.Error = common.ServerError(err) } else { result.Result = volumeParams } results.Results[i] = result } return results, nil }