// UpdateSettings persists all changes made to the local settings of
// all given pairs of relation and unit. Keys with empty values are
// considered a signal to delete these values.
func (u *UniterAPIV3) UpdateSettings(args params.RelationUnitsSettings) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.RelationUnits)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, arg := range args.RelationUnits {
unit, err := names.ParseUnitTag(arg.Unit)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
relUnit, err := u.getRelationUnit(canAccess, arg.Relation, unit)
if err == nil {
var settings *state.Settings
settings, err = relUnit.Settings()
if err == nil {
for k, v := range arg.Settings {
if v == "" {
settings.Delete(k)
} else {
settings.Set(k, v)
}
}
_, err = settings.Write()
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (d *DiskManagerAPI) SetMachineBlockDevices(args params.SetMachineBlockDevices) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.MachineBlockDevices)),
}
canAccess, err := d.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.MachineBlockDevices {
tag, err := names.ParseMachineTag(arg.Machine)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !canAccess(tag) {
err = common.ErrPerm
} else {
// TODO(axw) create volumes for block devices without matching
// volumes, if and only if the block device has a serial. Under
// the assumption of unique (to a machine) serial IDs, this
// gives us a guaranteed *persistently* unique way of identifying
// the volume.
//
// NOTE: we must predicate the above on there being no unprovisioned
// volume attachments for the machine, otherwise we would have
// a race between the volume attachment info being recorded and
// the diskmanager publishing block devices and erroneously creating
// volumes.
err = d.st.SetMachineBlockDevices(tag.Id(), stateBlockDeviceInfo(arg.BlockDevices))
// TODO(axw) set volume/filesystem attachment info.
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// DestroyModels will try to destroy the specified models.
// If there is a block on destruction, this method will return an error.
func (m *ModelManagerAPI) DestroyModels(args params.Entities) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
destroyModel := func(tag names.ModelTag) error {
model, err := m.state.GetModel(tag)
if err != nil {
return errors.Trace(err)
}
if err := m.authCheck(model.Owner()); err != nil {
return errors.Trace(err)
}
return errors.Trace(common.DestroyModel(m.state, model.ModelTag()))
}
for i, arg := range args.Entities {
tag, err := names.ParseModelTag(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
if err := destroyModel(tag); err != nil {
results.Results[i].Error = common.ServerError(err)
continue
}
}
return results, nil
}
// Save stores given cloud image metadata.
// It supports bulk calls.
func (api *API) Save(metadata params.MetadataSaveParams) (params.ErrorResults, error) {
all := make([]params.ErrorResult, len(metadata.Metadata))
if api.authorizer.AuthClient() {
admin, err := api.authorizer.HasPermission(permission.SuperuserAccess, api.metadata.ControllerTag())
if err != nil {
return params.ErrorResults{Results: all}, errors.Trace(err)
}
if !admin {
return params.ErrorResults{Results: all}, common.ServerError(common.ErrPerm)
}
}
if len(metadata.Metadata) == 0 {
return params.ErrorResults{Results: all}, nil
}
modelCfg, err := api.metadata.ModelConfig()
if err != nil {
return params.ErrorResults{}, errors.Annotatef(err, "getting model config")
}
for i, one := range metadata.Metadata {
md := api.parseMetadataListFromParams(one, modelCfg)
err := api.metadata.SaveMetadata(md)
all[i] = params.ErrorResult{Error: common.ServerError(err)}
}
return params.ErrorResults{Results: all}, nil
}
// AssignedMachine returns the machine tag for each given unit tag, or
// an error satisfying params.IsCodeNotAssigned when a unit has no
// assigned machine.
func (u *UniterAPIV1) AssignedMachine(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !canAccess(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
machineId, err := unit.AssignedMachineId()
if err != nil {
result.Results[i].Error = common.ServerError(err)
} else {
result.Results[i].Result = names.NewMachineTag(machineId).String()
}
}
return result, nil
}
// DistributionGroup returns, for each given machine entity,
// a slice of instance.Ids that belong to the same distribution
// group as that machine. This information may be used to
// distribute instances for high availability.
func (p *ProvisionerAPI) DistributionGroup(args params.Entities) (params.DistributionGroupResults, error) {
result := params.DistributionGroupResults{
Results: make([]params.DistributionGroupResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
// If the machine is an environment manager, return
// environment manager instances. Otherwise, return
// instances with services in common with the machine
// being provisioned.
if machine.IsManager() {
result.Results[i].Result, err = environManagerInstances(p.st)
} else {
result.Results[i].Result, err = commonServiceInstances(p.st, machine)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// InstanceStatus returns the instance status for each given entity.
// Only machine tags are accepted.
func (p *ProvisionerAPI) InstanceStatus(args params.Entities) (params.StatusResults, error) {
result := params.StatusResults{
Results: make([]params.StatusResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
logger.Errorf("failed to get an authorisation function: %v", err)
return result, errors.Trace(err)
}
for i, arg := range args.Entities {
mTag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
machine, err := p.getMachine(canAccess, mTag)
if err == nil {
var statusInfo status.StatusInfo
statusInfo, err = machine.InstanceStatus()
result.Results[i].Status = statusInfo.Status.String()
result.Results[i].Info = statusInfo.Message
result.Results[i].Data = statusInfo.Data
result.Results[i].Since = statusInfo.Since
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// CharmURL returns the charm URL for all given units or services.
func (u *UniterAPIV3) CharmURL(args params.Entities) (params.StringBoolResults, error) {
result := params.StringBoolResults{
Results: make([]params.StringBoolResult, len(args.Entities)),
}
accessUnitOrService := common.AuthEither(u.accessUnit, u.accessService)
canAccess, err := accessUnitOrService()
if err != nil {
return params.StringBoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unitOrService state.Entity
unitOrService, err = u.st.FindEntity(tag)
if err == nil {
charmURLer := unitOrService.(interface {
CharmURL() (*charm.URL, bool)
})
curl, ok := charmURLer.CharmURL()
if curl != nil {
result.Results[i].Result = curl.String()
result.Results[i].Ok = ok
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// SetCharmURL sets the charm URL for each given unit. An error will
// be returned if a unit is dead, or the charm URL is not know.
func (u *UniterAPIV3) SetCharmURL(args params.EntitiesCharmURL) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var curl *charm.URL
curl, err = charm.ParseURL(entity.CharmURL)
if err == nil {
err = unit.SetCharmURL(curl)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// GetPrincipal returns the result of calling PrincipalName() and
// converting it to a tag, on each given unit.
func (u *UniterAPIV3) GetPrincipal(args params.Entities) (params.StringBoolResults, error) {
result := params.StringBoolResults{
Results: make([]params.StringBoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringBoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
principal, ok := unit.PrincipalName()
if principal != "" {
result.Results[i].Result = names.NewUnitTag(principal).String()
}
result.Results[i].Ok = ok
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// HasSubordinates returns the whether each given unit has any subordinates.
func (u *UniterAPIV3) HasSubordinates(args params.Entities) (params.BoolResults, error) {
result := params.BoolResults{
Results: make([]params.BoolResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.BoolResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
subordinates := unit.SubordinateNames()
result.Results[i].Result = len(subordinates) > 0
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// Resolved returns the current resolved setting for each given unit.
func (u *UniterAPIV3) Resolved(args params.Entities) (params.ResolvedModeResults, error) {
result := params.ResolvedModeResults{
Results: make([]params.ResolvedModeResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ResolvedModeResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].Mode = params.ResolvedMode(unit.Resolved())
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// AvailabilityZone returns the availability zone for each given unit, if applicable.
func (u *UniterAPIV3) AvailabilityZone(args params.Entities) (params.StringResults, error) {
var results params.StringResults
canAccess, err := u.accessUnit()
if err != nil {
return results, errors.Trace(err)
}
// Prep the results.
results = params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
// Collect the zones. No zone will be collected for any entity where
// the tag is invalid or not authorized. Instead the corresponding
// result will be updated with the error.
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var zone string
zone, err = getZone(u.st, tag)
if err == nil {
results.Results[i].Result = zone
}
}
results.Results[i].Error = common.ServerError(err)
}
return results, nil
}
// PrivateAddress returns the private address for each given unit, if set.
func (u *UniterAPIV3) PrivateAddress(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var address network.Address
address, err = unit.PrivateAddress()
if err == nil {
result.Results[i].Result = address.Value
} else if network.IsNoAddressError(err) {
err = common.NoAddressSetError(tag, "private")
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// WatchInterfaces returns a NotifyWatcher for observing changes
// to each unit's service configuration settings.
func (n *NetworkerAPI) WatchInterfaces(args params.Entities) (params.NotifyWatchResults, error) {
result := params.NotifyWatchResults{
Results: make([]params.NotifyWatchResult, len(args.Entities)),
}
canAccess, err := n.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !canAccess(tag) {
err = common.ErrPerm
} else {
tag, ok := tag.(names.MachineTag)
if ok {
id := tag.Id()
result.Results[i].NotifyWatcherId, err = n.watchOneMachineInterfaces(id)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// SetWorkloadVersion sets the workload version for each given unit. An error will
// be returned if a unit is dead.
func (u *UniterAPIV3) SetWorkloadVersion(args params.EntityWorkloadVersions) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
resultItem := &result.Results[i]
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
if !canAccess(tag) {
resultItem.Error = common.ServerError(common.ErrPerm)
continue
}
unit, err := u.getUnit(tag)
if err != nil {
resultItem.Error = common.ServerError(err)
continue
}
err = unit.SetWorkloadVersion(entity.WorkloadVersion)
if err != nil {
resultItem.Error = common.ServerError(err)
}
}
return result, nil
}
// SetSupportedContainers updates the list of containers supported by the machines passed in args.
func (p *ProvisionerAPI) SetSupportedContainers(args params.MachineContainersParams) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Params)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, arg := range args.Params {
tag, err := names.ParseMachineTag(arg.MachineTag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if len(arg.ContainerTypes) == 0 {
err = machine.SupportsNoContainers()
} else {
err = machine.SetSupportedContainers(arg.ContainerTypes)
}
if err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
}
// ClosePorts sets the policy of the port range with protocol to be
// closed, for all given units.
func (u *UniterAPIV3) ClosePorts(args params.EntitiesPortRanges) (params.ErrorResults, error) {
result := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ErrorResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
err = unit.ClosePorts(entity.Protocol, entity.FromPort, entity.ToPort)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// Constraints returns the constraints for each given machine entity.
func (p *ProvisionerAPI) Constraints(args params.Entities) (params.ConstraintsResults, error) {
result := params.ConstraintsResults{
Results: make([]params.ConstraintsResult, len(args.Entities)),
}
canAccess, err := p.getAuthFunc()
if err != nil {
return result, err
}
for i, entity := range args.Entities {
tag, err := names.ParseMachineTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
machine, err := p.getMachine(canAccess, tag)
if err == nil {
var cons constraints.Value
cons, err = machine.Constraints()
if err == nil {
result.Results[i].Constraints = cons
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
// ConfigSettings returns the complete set of service charm config
// settings available to each given unit.
func (u *UniterAPIV3) ConfigSettings(args params.Entities) (params.ConfigSettingsResults, error) {
result := params.ConfigSettingsResults{
Results: make([]params.ConfigSettingsResult, len(args.Entities)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.ConfigSettingsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canAccess(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
var settings charm.Settings
settings, err = unit.ConfigSettings()
if err == nil {
result.Results[i].Settings = params.ConfigSettings(settings)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (a *API) volumeAttachments(all []state.Volume) []params.VolumeItem {
if all == nil || len(all) == 0 {
return nil
}
result := make([]params.VolumeItem, len(all))
for i, v := range all {
volume, err := a.convertStateVolumeToParams(v)
if err != nil {
result[i] = params.VolumeItem{
Error: common.ServerError(errors.Trace(err)),
}
continue
}
result[i] = params.VolumeItem{Volume: volume}
atts, err := a.storage.VolumeAttachments(v.VolumeTag())
if err != nil {
result[i].Error = common.ServerError(errors.Annotatef(
err, "attachments for volume %v", v.VolumeTag()))
continue
}
result[i].Attachments = convertStateVolumeAttachmentsToParams(atts)
}
return result
}
// JoinedRelations returns the tags of all relations for which each supplied unit
// has entered scope. It should be called RelationsInScope, but it's not convenient
// to make that change until we have versioned APIs.
func (u *UniterAPIV3) JoinedRelations(args params.Entities) (params.StringsResults, error) {
result := params.StringsResults{
Results: make([]params.StringsResult, len(args.Entities)),
}
if len(args.Entities) == 0 {
return result, nil
}
canRead, err := u.accessUnit()
if err != nil {
return params.StringsResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseUnitTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canRead(tag) {
var unit *state.Unit
unit, err = u.getUnit(tag)
if err == nil {
result.Results[i].Result, err = relationsInScopeTags(unit)
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}
func (*undertakerSuite) TestGetMachineProviderInterfaceInfo(c *gc.C) {
backend, _, api := makeApi(c, "")
backend.machines = map[string]*mockMachine{
"0": &mockMachine{
Stub: &testing.Stub{},
interfaceInfos: []network.ProviderInterfaceInfo{{
InterfaceName: "billy",
MACAddress: "hexadecimal!",
ProviderId: "a number",
}, {
InterfaceName: "lily",
MACAddress: "octal?",
ProviderId: "different number",
}}},
"2": &mockMachine{
Stub: &testing.Stub{},
interfaceInfos: []network.ProviderInterfaceInfo{{
InterfaceName: "gilly",
MACAddress: "sexagesimal?!",
ProviderId: "some number",
}},
},
}
backend.SetErrors(nil, errors.NotFoundf("no machine 100 fool!"))
args := makeEntities("machine-2", "machine-100", "machine-0", "machine-inv")
result := api.GetMachineProviderInterfaceInfo(args)
c.Assert(result, gc.DeepEquals, params.ProviderInterfaceInfoResults{
Results: []params.ProviderInterfaceInfoResult{{
MachineTag: "machine-2",
Interfaces: []params.ProviderInterfaceInfo{{
InterfaceName: "gilly",
MACAddress: "sexagesimal?!",
ProviderId: "some number",
}},
}, {
MachineTag: "machine-100",
Error: common.ServerError(
errors.NotFoundf("no machine 100 fool!"),
),
}, {
MachineTag: "machine-0",
Interfaces: []params.ProviderInterfaceInfo{{
InterfaceName: "billy",
MACAddress: "hexadecimal!",
ProviderId: "a number",
}, {
InterfaceName: "lily",
MACAddress: "octal?",
ProviderId: "different number",
}},
}, {
MachineTag: "machine-inv",
Error: common.ServerError(
errors.New(`"machine-inv" is not a valid machine tag`),
),
}},
})
}
// ListKeys returns the authorised ssh keys for the specified users.
func (api *KeyManagerAPI) ListKeys(arg params.ListSSHKeys) (params.StringsResults, error) {
if len(arg.Entities.Entities) == 0 {
return params.StringsResults{}, nil
}
results := make([]params.StringsResult, len(arg.Entities.Entities))
// For now, authorised keys are global, common to all users.
var keyInfo []string
cfg, configErr := api.state.EnvironConfig()
if configErr == nil {
keys := ssh.SplitAuthorisedKeys(cfg.AuthorizedKeys())
keyInfo = parseKeys(keys, arg.Mode)
}
for i, entity := range arg.Entities.Entities {
// NOTE: entity.Tag isn't a tag, but a username.
if !api.canRead(entity.Tag) {
results[i].Error = common.ServerError(common.ErrPerm)
continue
}
// All keys are global, no need to look up the user.
if configErr == nil {
results[i].Result = keyInfo
}
results[i].Error = common.ServerError(configErr)
}
return params.StringsResults{Results: results}, nil
}
// ServiceOwner returns the owner user for each given service tag.
func (u *UniterAPIV1) ServiceOwner(args params.Entities) (params.StringResults, error) {
result := params.StringResults{
Results: make([]params.StringResult, len(args.Entities)),
}
canAccess, err := u.accessService()
if err != nil {
return params.StringResults{}, err
}
for i, entity := range args.Entities {
tag, err := names.ParseServiceTag(entity.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
if !canAccess(tag) {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
service, err := u.getService(tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
result.Results[i].Result = service.GetOwnerTag()
}
return result, nil
}
func (api *MachinerAPI) SetMachineAddresses(args params.SetMachinesAddresses) (params.ErrorResults, error) {
results := params.ErrorResults{
Results: make([]params.ErrorResult, len(args.MachineAddresses)),
}
canModify, err := api.getCanModify()
if err != nil {
return results, err
}
for i, arg := range args.MachineAddresses {
tag, err := names.ParseMachineTag(arg.Tag)
if err != nil {
results.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
err = common.ErrPerm
if canModify(tag) {
var m *state.Machine
m, err = api.getMachine(tag)
if err == nil {
err = m.SetMachineAddresses(arg.Addresses...)
} else if errors.IsNotFound(err) {
err = common.ErrPerm
}
}
results.Results[i].Error = common.ServerError(err)
}
return results, nil
}
// DeleteImages deletes the images matching the specified filter.
func (api *ImageManagerAPI) DeleteImages(arg params.ImageFilterParams) (params.ErrorResults, error) {
if err := api.check.ChangeAllowed(); err != nil {
return params.ErrorResults{}, errors.Trace(err)
}
var result params.ErrorResults
result.Results = make([]params.ErrorResult, len(arg.Images))
stor := api.state.ImageStorage()
for i, imageSpec := range arg.Images {
filter := imagestorage.ImageFilter{
Kind: imageSpec.Kind,
Series: imageSpec.Series,
Arch: imageSpec.Arch,
}
imageMetadata, err := stor.ListImages(filter)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
if len(imageMetadata) != 1 {
result.Results[i].Error = common.ServerError(
errors.NotFoundf("image %s/%s/%s", filter.Kind, filter.Series, filter.Arch))
continue
}
logger.Infof("deleting image with metadata %+v", *imageMetadata[0])
err = stor.DeleteImage(imageMetadata[0])
if err != nil {
result.Results[i].Error = common.ServerError(err)
}
}
return result, nil
}
func (f *fakeRetryProvisioningClient) RetryProvisioning(machines ...names.MachineTag) (
[]params.ErrorResult, error) {
if f.err != nil {
return nil, f.err
}
results := make([]params.ErrorResult, len(machines))
// For each of the machines passed in, verify that we have the
// id and that the info string is "broken".
for i, machine := range machines {
m, ok := f.m[machine.Id()]
if ok {
if m.info == "broken" {
// The real RetryProvisioning command sets the
// status data "transient" : true.
m.data["transient"] = true
} else {
results[i].Error = common.ServerError(
fmt.Errorf("%s is not in an error state",
names.ReadableString(machine)))
}
} else {
results[i].Error = common.ServerError(
errors.NotFoundf("machine %s", machine.Id()))
}
}
return results, nil
}
// UnsetModelDefaults removes the specified default model settings.
func (m *ModelManagerAPI) UnsetModelDefaults(args params.UnsetModelDefaults) (params.ErrorResults, error) {
results := params.ErrorResults{Results: make([]params.ErrorResult, len(args.Keys))}
if !m.isAdmin {
return results, common.ErrPerm
}
if err := m.check.ChangeAllowed(); err != nil {
return results, errors.Trace(err)
}
for i, arg := range args.Keys {
var rspec *environs.RegionSpec
if arg.CloudRegion != "" {
spec, err := m.makeRegionSpec(arg.CloudTag, arg.CloudRegion)
if err != nil {
results.Results[i].Error = common.ServerError(
errors.Trace(err))
continue
}
rspec = spec
}
results.Results[i].Error = common.ServerError(
m.state.UpdateModelConfigDefaultValues(nil, arg.Keys, rspec),
)
}
return results, nil
}
// ReadRemoteSettings returns the remote settings of each given set of
// relation/local unit/remote unit.
func (u *UniterAPIV3) ReadRemoteSettings(args params.RelationUnitPairs) (params.SettingsResults, error) {
result := params.SettingsResults{
Results: make([]params.SettingsResult, len(args.RelationUnitPairs)),
}
canAccess, err := u.accessUnit()
if err != nil {
return params.SettingsResults{}, err
}
for i, arg := range args.RelationUnitPairs {
unit, err := names.ParseUnitTag(arg.LocalUnit)
if err != nil {
result.Results[i].Error = common.ServerError(common.ErrPerm)
continue
}
relUnit, err := u.getRelationUnit(canAccess, arg.Relation, unit)
if err == nil {
// TODO(dfc) rework this logic
remoteUnit := ""
remoteUnit, err = u.checkRemoteUnit(relUnit, arg.RemoteUnit)
if err == nil {
var settings map[string]interface{}
settings, err = relUnit.ReadSettings(remoteUnit)
if err == nil {
result.Results[i].Settings, err = convertRelationSettings(settings)
}
}
}
result.Results[i].Error = common.ServerError(err)
}
return result, nil
}