// 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 := storagecommon.MaybeAssignedStorageInstance(
volume.StorageInstance, p.st.StorageInstance,
)
if err != nil {
return nil, errors.Annotatef(err, "getting volume %q storage instance", volumeTag.Id())
}
volumeParams, err := storagecommon.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
}
modelConfig, err := s.st.ModelConfig()
if err != nil {
return params.FilesystemParamsResults{}, err
}
controllerCfg, err := s.st.ControllerConfig()
if err != nil {
return params.FilesystemParamsResults{}, err
}
results := params.FilesystemParamsResults{
Results: make([]params.FilesystemParamsResult, len(args.Entities)),
}
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, modelConfig.UUID(), controllerCfg.ControllerUUID(),
modelConfig, s.poolManager, s.registry,
)
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
}
// 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
}
// 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 := storagecommon.MaybeAssignedStorageInstance(
volume.StorageInstance,
s.st.StorageInstance,
)
if err != nil {
return params.VolumeParams{}, err
}
volumeParams, err := storagecommon.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
}