// SetStatus sets the status of the service if the passed unitName,
// corresponding to the calling unit, is of the leader.
func (s *Service) SetStatus(unitName string, status params.Status, info string, data map[string]interface{}) error {
//TODO(perrito666) bump api version for this?
if s.st.facade.BestAPIVersion() < 2 {
return errors.NotImplementedf("SetStatus")
}
tag := names.NewUnitTag(unitName)
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatusArgs{
{
Tag: tag.String(),
Status: status,
Info: info,
Data: data,
},
},
}
err := s.st.facade.FacadeCall("SetServiceStatus", args, &result)
if err != nil {
if params.IsCodeNotImplemented(err) {
return errors.NotImplementedf("SetServiceStatus")
}
return errors.Trace(err)
}
return result.OneError()
}
// Deploy obtains the charm, either locally or from the charm store,
// and deploys it. It allows the specification of requested networks
// that must be present on the machines where the service is
// deployed. Another way to specify networks to include/exclude is
// using constraints. Placement directives, if provided, specify the
// machine on which the charm is deployed.
func (c *Client) Deploy(args DeployArgs) error {
deployArgs := params.ServicesDeploy{
Services: []params.ServiceDeploy{{
ServiceName: args.ServiceName,
Series: args.Series,
CharmUrl: args.CharmID.URL.String(),
Channel: string(args.CharmID.Channel),
NumUnits: args.NumUnits,
ConfigYAML: args.ConfigYAML,
Constraints: args.Cons,
Placement: args.Placement,
Networks: args.Networks,
Storage: args.Storage,
EndpointBindings: args.EndpointBindings,
Resources: args.Resources,
}},
}
var results params.ErrorResults
var err error
err = c.facade.FacadeCall("Deploy", deployArgs, &results)
if err != nil {
return err
}
return results.OneError()
}
// ServiceDeploy obtains the charm, either locally or from
// the charm store, and deploys it. It allows the specification of
// requested networks that must be present on the machines where the
// service is deployed. Another way to specify networks to include/exclude
// is using constraints.
func (c *Client) ServiceDeploy(
charmURL string,
serviceName string,
numUnits int,
configYAML string,
cons constraints.Value,
toMachineSpec string,
networks []string,
storage map[string]storage.Constraints,
) error {
args := params.ServicesDeploy{
Services: []params.ServiceDeploy{{
ServiceName: serviceName,
CharmUrl: charmURL,
NumUnits: numUnits,
ConfigYAML: configYAML,
Constraints: cons,
ToMachineSpec: toMachineSpec,
Networks: networks,
Storage: storage,
}},
}
var results params.ErrorResults
err := c.facade.FacadeCall("ServicesDeploy", args, &results)
if err != nil {
return err
}
return results.OneError()
}
// 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 (c *Client) modifyControllerUser(action params.ControllerAction, user, access string) error {
var args params.ModifyControllerAccessRequest
if !names.IsValidUser(user) {
return errors.Errorf("invalid username: %q", user)
}
userTag := names.NewUserTag(user)
args.Changes = []params.ModifyControllerAccess{{
UserTag: userTag.String(),
Action: action,
Access: access,
}}
var result params.ErrorResults
err := c.facade.FacadeCall("ModifyControllerAccess", args, &result)
if err != nil {
return errors.Trace(err)
}
if len(result.Results) != len(args.Changes) {
return errors.Errorf("expected %d results, got %d", len(args.Changes), len(result.Results))
}
return result.Combine()
}
// Deploy obtains the charm, either locally or from
// the charm store, and deploys it. It allows the specification of
// requested networks that must be present on the machines where the
// service is deployed. Another way to specify networks to include/exclude
// is using constraints. Placement directives, if provided, specify the
// machine on which the charm is deployed.
func (c *Client) Deploy(
charmURL string,
serviceName string,
series string,
numUnits int,
configYAML string,
cons constraints.Value,
placement []*instance.Placement,
networks []string,
storage map[string]storage.Constraints,
) error {
args := params.ServicesDeploy{
Services: []params.ServiceDeploy{{
ServiceName: serviceName,
Series: series,
CharmUrl: charmURL,
NumUnits: numUnits,
ConfigYAML: configYAML,
Constraints: cons,
Placement: placement,
Networks: networks,
Storage: storage,
}},
}
var results params.ErrorResults
var err error
err = c.facade.FacadeCall("Deploy", args, &results)
if err != nil {
return err
}
return results.OneError()
}
// ShareModel allows the given users access to the model.
func (c *Client) ShareModel(users ...names.UserTag) error {
var args params.ModifyModelUsers
for _, user := range users {
if &user != nil {
args.Changes = append(args.Changes, params.ModifyModelUser{
UserTag: user.String(),
Action: params.AddModelUser,
})
}
}
var result params.ErrorResults
err := c.facade.FacadeCall("ShareModel", args, &result)
if err != nil {
return errors.Trace(err)
}
for i, r := range result.Results {
if r.Error != nil && r.Error.Code == params.CodeAlreadyExists {
logger.Warningf("model is already shared with %s", users[i].Canonical())
result.Results[i].Error = nil
}
}
return result.Combine()
}
func (api *UserManagerAPI) enableUserImpl(args params.Entities, action string, method func(*state.User) error) (params.ErrorResults, error) {
var result params.ErrorResults
if len(args.Entities) == 0 {
return result, nil
}
isSuperUser, err := api.hasControllerAdminAccess()
if err != nil {
return result, errors.Trace(err)
}
if !api.isAdmin && isSuperUser {
return result, common.ErrPerm
}
// Create the results list to populate.
result.Results = make([]params.ErrorResult, len(args.Entities))
for i, arg := range args.Entities {
user, err := api.getUser(arg.Tag)
if err != nil {
result.Results[i].Error = common.ServerError(err)
continue
}
err = method(user)
if err != nil {
result.Results[i].Error = common.ServerError(errors.Errorf("failed to %s user: %s", action, err))
}
}
return result, nil
}
// UnshareEnvironment removes access to the environment for the given users.
func (c *Client) UnshareEnvironment(users ...names.UserTag) error {
var args params.ModifyEnvironUsers
for _, user := range users {
if &user != nil {
args.Changes = append(args.Changes, params.ModifyEnvironUser{
UserTag: user.String(),
Action: params.RemoveEnvUser,
})
}
}
var result params.ErrorResults
err := c.facade.FacadeCall("ShareEnvironment", args, &result)
if err != nil {
return errors.Trace(err)
}
for i, r := range result.Results {
if r.Error != nil && r.Error.Code == params.CodeNotFound {
logger.Warningf("environment was not previously shared with user %s", users[i].Username())
result.Results[i].Error = nil
}
}
return result.Combine()
}
// SetStatus sets the status of storage entities.
func (st *State) SetStatus(args []params.EntityStatusArgs) error {
var result params.ErrorResults
err := st.facade.FacadeCall("SetStatus", params.SetStatus{args}, &result)
if err != nil {
return err
}
return result.Combine()
}
// SetAgentStatus sets the status of the unit agents.
func (a API) SetAgentStatus(args params.SetStatus) error {
var result params.ErrorResults
err := a.facade.FacadeCall("SetAgentStatus", args, &result)
if err != nil {
return err
}
return result.Combine()
}
func (c *Client) RemoveUser(tag string) error {
u := params.Entity{Tag: tag}
p := params.Entities{Entities: []params.Entity{u}}
results := new(params.ErrorResults)
err := c.facade.FacadeCall("RemoveUser", p, results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
// Remove removes the IP address.
func (a *IPAddress) Remove() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: a.tag.String()}},
}
err := a.facade.FacadeCall("Remove", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// EnsureDead sets the unit lifecycle to Dead if it is Alive or
// Dying. It does nothing otherwise.
func (u *Unit) EnsureDead() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("EnsureDead", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// SetInstanceStatus sets the instance status of the machine.
func (m *Machine) SetInstanceStatus(status string) error {
var result params.ErrorResults
args := params.SetInstancesStatus{Entities: []params.InstanceStatus{
{Tag: m.tag.String(), Status: status},
}}
err := m.facade.FacadeCall("SetInstanceStatus", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// DestroyAllSubordinates destroys all subordinates of the unit.
func (u *Unit) DestroyAllSubordinates() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: u.tag.String()}},
}
err := u.st.facade.FacadeCall("DestroyAllSubordinates", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// CreateSpace creates a new Juju network space, associating the
// specified subnets with it (optional; can be empty).
func (api *API) CreateSpace(name string, subnetIds []string, public bool) error {
var response params.ErrorResults
params := params.CreateSpacesParams{
Spaces: []params.CreateSpaceParams{makeCreateSpaceParams(name, subnetIds, public)},
}
err := api.facade.FacadeCall("CreateSpaces", params, &response)
if err != nil {
return errors.Trace(err)
}
return response.OneError()
}
// SendMetrics will send any unsent metrics to the collection service.
func (c *Client) SendMetrics() error {
p := params.Entities{Entities: []params.Entity{
{c.modelTag.String()},
}}
var results params.ErrorResults
err := c.facade.FacadeCall("SendMetrics", p, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
// SetProviderNetworkConfig sets the machine network config as seen by the
// provider.
func (m *Machine) SetProviderNetworkConfig() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag.String()}},
}
err := m.st.facade.FacadeCall("SetProviderNetworkConfig", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// SetInstanceStatus sets the status for the provider instance.
func (m *Machine) SetInstanceStatus(status status.Status, message string, data map[string]interface{}) error {
var result params.ErrorResults
args := params.SetStatus{Entities: []params.EntityStatusArgs{
{Tag: m.tag.String(), Status: status.String(), Info: message, Data: data},
}}
err := m.st.facade.FacadeCall("SetInstanceStatus", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// CleanupOldMetrics looks for metrics that are 24 hours old (or older)
// and have been sent. Any metrics it finds are deleted.
func (c *Client) CleanupOldMetrics() error {
p := params.Entities{Entities: []params.Entity{
{c.st.EnvironTag()},
}}
results := new(params.ErrorResults)
err := c.facade.FacadeCall("CleanupOldMetrics", p, results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
// Remove removes the machine from state. It will fail if the machine
// is not Dead.
func (m *Machine) Remove() error {
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: m.tag.String()}},
}
err := m.st.facade.FacadeCall("Remove", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// ReleaseContainerAddresses releases a static IP address allocated to a
// container.
func (st *State) ReleaseContainerAddresses(containerTag names.MachineTag) (err error) {
defer errors.DeferredAnnotatef(&err, "cannot release static addresses for %q", containerTag.Id())
var result params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{Tag: containerTag.String()}},
}
if err := st.facade.FacadeCall("ReleaseContainerAddresses", args, &result); err != nil {
return err
}
return result.OneError()
}
// ReportKeys reports the public SSH host keys for a machine to the
// controller. The keys should be in the same format as the sshd host
// key files, one entry per key.
func (f *Facade) ReportKeys(machineId string, publicKeys []string) error {
args := params.SSHHostKeySet{EntityKeys: []params.SSHHostKeys{{
Tag: names.NewMachineTag(machineId).String(),
PublicKeys: publicKeys,
}}}
var result params.ErrorResults
err := f.caller.FacadeCall("ReportKeys", args, &result)
if err != nil {
return err
}
return result.OneError()
}
func (c *Client) convert(found []params.StorageDetailsResult) ([]params.StorageDetails, error) {
var storages []params.StorageDetails
var allErr params.ErrorResults
for _, result := range found {
if result.Error != nil {
allErr.Results = append(allErr.Results, params.ErrorResult{result.Error})
continue
}
storages = append(storages, result.Result)
}
return storages, allErr.Combine()
}
// RevokeCredential revokes/deletes a cloud credential.
func (c *Client) RevokeCredential(tag names.CloudCredentialTag) error {
var results params.ErrorResults
args := params.Entities{
Entities: []params.Entity{{
Tag: tag.String(),
}},
}
if err := c.facade.FacadeCall("RevokeCredentials", args, &results); err != nil {
return errors.Trace(err)
}
return results.OneError()
}
// SetMetricCredentials sets the metric credentials for the service specified.
func (c *Client) SetMetricCredentials(service string, credentials []byte) error {
creds := []params.ServiceMetricCredential{
{service, credentials},
}
p := params.ServiceMetricCredentials{creds}
results := new(params.ErrorResults)
err := c.facade.FacadeCall("SetMetricCredentials", p, results)
if err != nil {
return errors.Trace(err)
}
return errors.Trace(results.OneError())
}
// SetStatus sets the status of the unit.
func (u *Unit) SetStatus(status params.Status, info string, data params.StatusData) error {
var result params.ErrorResults
args := params.SetStatus{
Entities: []params.EntityStatus{
{Tag: u.tag.String(), Status: status, Info: info, Data: data},
},
}
err := u.st.facade.FacadeCall("SetStatus", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// SetPassword sets the machine's password.
func (m *Machine) SetPassword(password string) error {
var result params.ErrorResults
args := params.EntityPasswords{
Changes: []params.EntityPassword{
{Tag: m.tag.String(), Password: password},
},
}
err := m.st.facade.FacadeCall("SetPasswords", args, &result)
if err != nil {
return err
}
return result.OneError()
}
// Wait blocks until nobody has responsibility for model administration. It
// should probably be doing something watchy rather than blocky, but it's
// following the lease manager implementation underlying the original
// leadership approach and it doesn't seem worth rewriting all that.
func (api *API) Wait() error {
args := params.Entities{
Entities: []params.Entity{{
Tag: api.modelTag.String(),
}},
}
var results params.ErrorResults
err := api.facadeCaller.FacadeCall("Wait", args, &results)
if err != nil {
return errors.Trace(err)
}
return results.OneError()
}
