func (*volumesSuite) TestVolumeParamsStorageTags(c *gc.C) {
volumeTag := names.NewVolumeTag("100")
storageTag := names.NewStorageTag("mystore/0")
unitTag := names.NewUnitTag("mysql/123")
p, err := storagecommon.VolumeParams(
&fakeVolume{tag: volumeTag, params: &state.VolumeParams{
Pool: "loop", Size: 1024,
}},
&fakeStorageInstance{tag: storageTag, owner: unitTag},
testing.CustomModelConfig(c, nil),
&fakePoolManager{},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(p, jc.DeepEquals, params.VolumeParams{
VolumeTag: "volume-100",
Provider: "loop",
Size: 1024,
Tags: map[string]string{
tags.JujuController: testing.ModelTag.Id(),
tags.JujuModel: testing.ModelTag.Id(),
tags.JujuStorageInstance: "mystore/0",
tags.JujuStorageOwner: "mysql/123",
},
})
}
// 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
}
func (*volumesSuite) testVolumeParams(c *gc.C, volumeParams *state.VolumeParams, info *state.VolumeInfo) {
tag := names.NewVolumeTag("100")
p, err := storagecommon.VolumeParams(
&fakeVolume{tag: tag, params: volumeParams, info: info},
nil, // StorageInstance
testing.ModelTag.Id(),
testing.ControllerTag.Id(),
testing.CustomModelConfig(c, testing.Attrs{
"resource-tags": "a=b c=",
}),
&fakePoolManager{},
provider.CommonStorageProviders(),
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(p, jc.DeepEquals, params.VolumeParams{
VolumeTag: "volume-100",
Provider: "loop",
Size: 1024,
Tags: map[string]string{
tags.JujuController: testing.ControllerTag.Id(),
tags.JujuModel: testing.ModelTag.Id(),
"a": "b",
"c": "",
},
})
}
func (*volumesSuite) testVolumeParams(c *gc.C, provisioned bool) {
tag := names.NewVolumeTag("100")
p, err := storagecommon.VolumeParams(
&fakeVolume{tag: tag, provisioned: provisioned},
nil, // StorageInstance
testing.CustomEnvironConfig(c, testing.Attrs{
"resource-tags": "a=b c=",
}),
&fakePoolManager{},
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(p, jc.DeepEquals, params.VolumeParams{
VolumeTag: "volume-100",
Provider: "loop",
Size: 1024,
Tags: map[string]string{
tags.JujuEnv: testing.EnvironmentTag.Id(),
"a": "b",
"c": "",
},
})
}
// 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
}