func (s *storageMockSuite) TestAddToUnit(c *gc.C) {
size := uint64(42)
cons := params.StorageConstraints{
Pool: "value",
Size: &size,
}
errOut := "error"
unitStorages := []params.StorageAddParams{
params.StorageAddParams{UnitTag: "u-a", StorageName: "one", Constraints: cons},
params.StorageAddParams{UnitTag: "u-b", StorageName: errOut, Constraints: cons},
params.StorageAddParams{UnitTag: "u-b", StorageName: "nil-constraints"},
}
storageN := 3
expectedError := common.ServerError(errors.NotValidf("storage directive"))
one := func(u, s string, attrs params.StorageConstraints) params.ErrorResult {
result := params.ErrorResult{}
if s == errOut {
result.Error = expectedError
}
return result
}
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "Storage")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "AddToUnit")
args, ok := a.(params.StoragesAddParams)
c.Assert(ok, jc.IsTrue)
c.Assert(args.Storages, gc.HasLen, storageN)
c.Assert(args.Storages, gc.DeepEquals, unitStorages)
if results, k := result.(*params.ErrorResults); k {
out := []params.ErrorResult{}
for _, s := range args.Storages {
out = append(out, one(s.UnitTag, s.StorageName, s.Constraints))
}
results.Results = out
}
return nil
})
storageClient := storage.NewClient(apiCaller)
r, err := storageClient.AddToUnit(unitStorages)
c.Assert(err, jc.ErrorIsNil)
c.Assert(r, gc.HasLen, storageN)
expected := []params.ErrorResult{
{nil},
{expectedError},
{nil},
}
c.Assert(r, jc.SameContents, expected)
}
// SetRsyslogCert sets the rsyslog CACert.
func (api *RsyslogAPI) SetRsyslogCert(args params.SetRsyslogCertParams) (params.ErrorResult, error) {
var result params.ErrorResult
if !api.canModify {
result.Error = common.ServerError(common.ErrBadCreds)
return result, nil
}
if _, err := cert.ParseCert(string(args.CACert)); err != nil {
result.Error = common.ServerError(err)
return result, nil
}
attrs := map[string]interface{}{"rsyslog-ca-cert": string(args.CACert)}
if err := api.st.UpdateEnvironConfig(attrs, nil, nil); err != nil {
result.Error = common.ServerError(err)
}
return result, nil
}
// CleanupIPAddresses releases and removes the dead IP addresses.
func (api *AddresserAPI) CleanupIPAddresses() params.ErrorResult {
result := params.ErrorResult{}
netEnv, ok, err := api.getNetworkingEnviron()
if err != nil {
result.Error = common.ServerError(err)
return result
}
if !ok {
result.Error = common.ServerError(errors.NotSupportedf("IP address deallocation"))
return result
}
// Retrieve dead addresses, release and remove them.
logger.Debugf("retrieving dead IP addresses")
ipAddresses, err := api.st.DeadIPAddresses()
if err != nil {
err = errors.Annotate(err, "getting dead addresses")
result.Error = common.ServerError(err)
return result
}
canRetry := false
for _, ipAddress := range ipAddresses {
ipAddressValue := ipAddress.Value()
logger.Debugf("releasing dead IP address %q", ipAddressValue)
err := api.releaseIPAddress(netEnv, ipAddress)
if err != nil {
logger.Warningf("cannot release IP address %q: %v (will retry)", ipAddressValue, err)
canRetry = true
continue
}
logger.Debugf("removing released IP address %q", ipAddressValue)
err = ipAddress.Remove()
if errors.IsNotFound(err) {
continue
}
if err != nil {
logger.Warningf("failed to remove released IP address %q: %v (will retry)", ipAddressValue, err)
canRetry = true
continue
}
}
if canRetry {
result.Error = common.ServerError(common.ErrTryAgain)
}
return result
}