Documentation

Index

Constants

View Source
const DefaultCharmIcon = `` /* 9060-byte string literal not displayed */

    DefaultCharmIcon holds the default charm icon SVG content. Keep this in sync with the default icon returned by the charm store.

    View Source
    const EveryoneTagName = "everyone@external"

      EveryoneTagName represents a special group that encompasses all external users.

      Variables

      This section is empty.

      Functions

      func Actions

      func Actions(args params.Entities, actionFn func(string) (state.Action, error)) params.ActionResults

        Actions returns the Actions by Tags passed in and ensures that the receiver asking for them is the same one that has the action. It's a helper function currently used by the uniter and by machineactions. It needs an actionFn that can fetch an action from state using it's id that's usually created by AuthAndActionFromTagFn

        func AuthAndActionFromTagFn

        func AuthAndActionFromTagFn(canAccess AuthFunc, getActionByTag func(names.ActionTag) (state.Action, error)) func(string) (state.Action, error)

          AuthAndActionFromTagFn takes in an authorizer function and a function that can fetch action by tags from state and returns a function that can fetch an action from state by id and check the authorization.

          func BeginActions

          func BeginActions(args params.Entities, actionFn func(string) (state.Action, error)) params.ErrorResults

            BeginActions calls begin on every action passed in through args. It's a helper function currently used by the uniter and by machineactions It needs an actionFn that can fetch an action from state using it's id, that's usually created by AuthAndActionFromTagFn

            func CharmArchiveEntry

            func CharmArchiveEntry(charmPath, entryPath string, wantIcon bool) ([]byte, error)

              CharmArchiveEntry retrieves the specified entry from the zip archive.

              func CloudFromParams

              func CloudFromParams(cloudName string, p params.Cloud) jujucloud.Cloud

              func CloudToParams

              func CloudToParams(cloud jujucloud.Cloud) params.Cloud

              func ConvertActions

              func ConvertActions(ar state.ActionReceiver, fn GetActionsFn) ([]params.ActionResult, error)

                ConvertActions takes a generic getActionsFn to obtain a slice of state.Action and then converts them to the API slice of params.ActionResult.

                func DestroyController

                func DestroyController(
                	st ModelManagerBackend,
                	destroyHostedModels bool,
                	destroyStorage *bool,
                ) error

                  DestroyController sets the controller model to Dying and, if requested, schedules cleanups so that all of the hosted models are destroyed, or otherwise returns an error indicating that there are hosted models remaining.

                  func DestroyMachines

                  func DestroyMachines(st origStateInterface, force bool, maxWait time.Duration, ids ...string) error

                  func DestroyModel

                  func DestroyModel(
                  	st ModelManagerBackend,
                  	destroyStorage *bool,
                  	force *bool,
                  	maxWait *time.Duration,
                  ) error

                    DestroyModel sets the model to Dying, such that the model's resources will be destroyed and the model removed from the controller.

                    func EntityStatusFromState

                    func EntityStatusFromState(statusInfo status.StatusInfo) params.EntityStatus

                      EntityStatusFromState converts a state.StatusInfo into a params.EntityStatus.

                      func FinishActions

                      func FinishActions(args params.ActionExecutionResults, actionFn func(string) (state.Action, error)) params.ErrorResults

                        FinishActions saves the result of a completed Action. It's a helper function currently used by the uniter and by machineactions It needs an actionFn that can fetch an action from state using it's id that's usually created by AuthAndActionFromTagFn

                        func GetPermission

                        func GetPermission(accessGetter userAccessFunc, userTag names.UserTag, target names.Tag) (permission.Access, error)

                          GetPermission returns the permission a user has on the specified target.

                          func HasModelAdmin

                          func HasModelAdmin(
                          	authorizer facade.Authorizer,
                          	user names.UserTag,
                          	controllerTag names.ControllerTag,
                          	model Model,
                          ) (bool, error)

                            HasModelAdmin reports whether or not a user has admin access to the specified model. A user has model access if they are a controller superuser, or if they have been explicitly granted admin access to the model.

                            func HasPermission

                            func HasPermission(
                            	accessGetter userAccessFunc, utag names.Tag,
                            	requestedPermission permission.Access, target names.Tag,
                            ) (bool, error)

                              HasPermission returns true if the specified user has the specified permission on target.

                              func InstanceTypes

                              func InstanceTypes(cons instanceTypeConstraints) (params.InstanceTypesResult, error)

                                InstanceTypes returns a list of the available instance types in the provider according to the passed constraints.

                                func JujuClientVersionFromRequest

                                func JujuClientVersionFromRequest(req *http.Request) (version.Number, error)

                                  JujuClientVersionFromRequest returns the Juju client version number from the HTTP request.

                                  func MakeActionResult

                                  func MakeActionResult(actionReceiverTag names.Tag, action state.Action) params.ActionResult

                                    MakeActionResult does the actual type conversion from state.Action to params.ActionResult.

                                    func MaxWait

                                    func MaxWait(in *time.Duration) time.Duration

                                      MaxWait is how far in the future the backstop force cleanup will be scheduled. Default is 1min if no value is provided.

                                      func ModelFilesystemInfo

                                      func ModelFilesystemInfo(in []state.Filesystem) []params.ModelFilesystemInfo

                                        ModelFilesystemInfo returns information about filesystems in the model.

                                        func ModelMachineInfo

                                        func ModelMachineInfo(st ModelManagerBackend) (machineInfo []params.ModelMachineInfo, _ error)

                                          ModelMachineInfo returns information about machine hardware for alive top level machines (not containers).

                                          func ModelUserInfo

                                          func ModelUserInfo(user permission.UserAccess, st modelConnectionAbleBackend) (params.ModelUserInfo, error)

                                            ModelUserInfo converts permission.UserAccess to params.ModelUserInfo.

                                            func ModelVolumeInfo

                                            func ModelVolumeInfo(in []state.Volume) []params.ModelVolumeInfo

                                              ModelVolumeInfo returns information about volumes in the model.

                                              func NewInstanceTypeConstraints

                                              func NewInstanceTypeConstraints(env environs.Environ, ctx context.ProviderCallContext, constraints constraints.Value) instanceTypeConstraints

                                                NewInstanceTypeConstraints returns an instanceTypeConstraints with the passed parameters.

                                                func NewToolsURLGetter

                                                func NewToolsURLGetter(modelUUID string, a APIHostPortsForAgentsGetter) *toolsURLGetter

                                                  NewToolsURLGetter creates a new ToolsURLGetter that returns tools URLs pointing at an API server.

                                                  func ParamsActionExecutionResultsToStateActionResults

                                                  func ParamsActionExecutionResultsToStateActionResults(arg params.ActionExecutionResult) (state.ActionResults, error)

                                                    ParamsActionExecutionResultsToStateActionResults does exactly what the name implies.

                                                    func ReadCharmFromStorage

                                                    func ReadCharmFromStorage(store storage.Storage, dataDir, storagePath string) (string, error)

                                                      ReadCharmFromStorage fetches the charm at the specified path from the store and copies it to a temp directory in dataDir.

                                                      func RevokeLeadershipFunc

                                                      func RevokeLeadershipFunc(leadershipRevoker leadership.Revoker) func(names.Tag)

                                                        RevokeLeadershipFunc returns a function that revokes leadership for dead units.

                                                        func StateControllerInfo

                                                        func StateControllerInfo(st *state.State) (addrs []string, caCert string, _ error)

                                                          StateControllerInfo returns the local controller details for the given State.

                                                          func StateJobs

                                                          func StateJobs(jobs []model.MachineJob) ([]state.MachineJob, error)

                                                            StateJobs translates a slice of multiwatcher jobs to their equivalents in state.

                                                            func StateToParamsUserAccessPermission

                                                            func StateToParamsUserAccessPermission(descriptionAccess permission.Access) (params.UserAccessPermission, error)

                                                              StateToParamsUserAccessPermission converts permission.Access to params.AccessPermission.

                                                              func TagToActionReceiverFn

                                                              func TagToActionReceiverFn(findEntity func(names.Tag) (state.Entity, error)) func(tag string) (state.ActionReceiver, error)

                                                                TagToActionReceiver takes a tag string and tries to convert it to an ActionReceiver. It needs a findEntity function passed in that can search for the tags in state.

                                                                func ToolsURL

                                                                func ToolsURL(serverRoot string, v version.Binary) string

                                                                  ToolsURL returns a tools URL pointing the API server specified by the "serverRoot".

                                                                  func WatchActionNotifications

                                                                  func WatchActionNotifications(args params.Entities, canAccess AuthFunc, watchOne func(names.Tag) (params.StringsWatchResult, error)) params.StringsWatchResults

                                                                    WatchActionNotifications returns a StringsWatcher for observing incoming actions towards an actionreceiver. It's a helper function currently used by the uniter and by machineactions canAccess is passed in by the respective caller to provide authorization. watchOne is usually a function created by WatchOneActionReceiverNotifications

                                                                    func WatchOneActionReceiverNotifications

                                                                    func WatchOneActionReceiverNotifications(tagToActionReceiver func(tag string) (state.ActionReceiver, error), registerFunc func(r facade.Resource) string) func(names.Tag) (params.StringsWatchResult, error)

                                                                      WatchOneActionReceiverNotifications returns a function for creating a watcher on all action notifications (action adds + changes) for one receiver. It needs a tagToActionReceiver function and a registerFunc to register resources. It's a helper function currently used by the uniter and by machineactions

                                                                      func WatchPendingActionsForReceiver

                                                                      func WatchPendingActionsForReceiver(tagToActionReceiver func(tag string) (state.ActionReceiver, error), registerFunc func(r facade.Resource) string) func(names.Tag) (params.StringsWatchResult, error)

                                                                        WatchPendingActionsForReceiver returns a function for creating a watcher on new pending Actions for one receiver. It needs a tagToActionReceiver function and a registerFunc to register resources. It's a helper function currently used by the uniter and by machineactions

                                                                        Types

                                                                        type APIAddressAccessor

                                                                        type APIAddressAccessor interface {
                                                                        	Addresses() ([]string, error)
                                                                        	APIHostPortsForAgents() ([]network.SpaceHostPorts, error)
                                                                        	WatchAPIHostPortsForAgents() state.NotifyWatcher
                                                                        }

                                                                          APIAddressAccessor describes methods that allow agents to maintain up-to-date information on how to connect to the Juju API server.

                                                                          type APIAddresser

                                                                          type APIAddresser struct {
                                                                          	// contains filtered or unexported fields
                                                                          }

                                                                            APIAddresser implements the APIAddresses method. Note that the getter backing for this implies that it is suitable for use by agents, which are bound by the configured controller management space. It is not suitable for callers requiring *all* available API addresses.

                                                                            func NewAPIAddresser

                                                                            func NewAPIAddresser(getter APIAddressAccessor, resources facade.Resources) *APIAddresser

                                                                              NewAPIAddresser returns a new APIAddresser that uses the given getter to fetch its addresses.

                                                                              func (*APIAddresser) APIAddresses

                                                                              func (a *APIAddresser) APIAddresses() (params.StringsResult, error)

                                                                                APIAddresses returns the list of addresses used to connect to the API.

                                                                                func (*APIAddresser) APIHostPorts

                                                                                func (a *APIAddresser) APIHostPorts() (params.APIHostPortsResult, error)

                                                                                  APIHostPorts returns the API server addresses.

                                                                                  func (*APIAddresser) WatchAPIHostPorts

                                                                                  func (a *APIAddresser) WatchAPIHostPorts() (params.NotifyWatchResult, error)

                                                                                    WatchAPIHostPorts watches the API server addresses.

                                                                                    type APIHostPortsForAgentsGetter

                                                                                    type APIHostPortsForAgentsGetter interface {
                                                                                    	// APIHostPortsForAgents returns the HostPorts for each API server that
                                                                                    	// are suitable for agent-to-controller API communication based on the
                                                                                    	// configured (if any) controller management space.
                                                                                    	APIHostPortsForAgents() ([]network.SpaceHostPorts, error)
                                                                                    }

                                                                                      APIHostPortsGetter is an interface providing the APIHostPortsForAgents method.

                                                                                      type AgentEntityWatcher

                                                                                      type AgentEntityWatcher struct {
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                        AgentEntityWatcher implements a common Watch method for use by various facades.

                                                                                        func NewAgentEntityWatcher

                                                                                        func NewAgentEntityWatcher(st state.EntityFinder, resources facade.Resources, getCanWatch GetAuthFunc) *AgentEntityWatcher

                                                                                          NewAgentEntityWatcher returns a new AgentEntityWatcher. The GetAuthFunc will be used on each invocation of Watch to determine current permissions.

                                                                                          func (*AgentEntityWatcher) Watch

                                                                                            Watch starts an NotifyWatcher for each given entity.

                                                                                            type AppWatcherApplication

                                                                                            type AppWatcherApplication interface {
                                                                                            	Charm() (AppWatcherCharm, bool, error)
                                                                                            }

                                                                                              AppWatcherApplication is Application for AppWatcher.

                                                                                              type AppWatcherCharm

                                                                                              type AppWatcherCharm interface {
                                                                                              	Meta() *charm.Meta
                                                                                              }

                                                                                                AppWatcherCharm is Charm for AppWatcher.

                                                                                                type AppWatcherState

                                                                                                type AppWatcherState interface {
                                                                                                	WatchApplications() state.StringsWatcher
                                                                                                	Application(name string) (AppWatcherApplication, error)
                                                                                                }

                                                                                                  AppWatcherState is State for AppWatcher.

                                                                                                  type Application

                                                                                                  type Application interface {
                                                                                                  	UnitCount() int
                                                                                                  }

                                                                                                    Application defines methods provided by a state.Application instance.

                                                                                                    type ApplicationFilter

                                                                                                    type ApplicationFilter int

                                                                                                      ApplicationFilter to apply to watched model.

                                                                                                      const (
                                                                                                      	// ApplicationFilterNone has no filtering.
                                                                                                      	ApplicationFilterNone ApplicationFilter = iota
                                                                                                      	// ApplicationFilterCAASLegacy filters to include only legacy applications.
                                                                                                      	ApplicationFilterCAASLegacy ApplicationFilter = iota
                                                                                                      	// ApplicationFilterCAASEmbedded filters to include only embedded applications.
                                                                                                      	ApplicationFilterCAASEmbedded ApplicationFilter = iota
                                                                                                      )

                                                                                                      type ApplicationStatusSetter

                                                                                                      type ApplicationStatusSetter struct {
                                                                                                      	// contains filtered or unexported fields
                                                                                                      }

                                                                                                        ApplicationStatusSetter implements a SetApplicationStatus method to be used by facades that can change an application status. This is only slightly less evil than ApplicationStatusGetter. We have StatusSetter already; all this does is set the status for the wrong entity, and render the auth so confused as to be ~worthless.

                                                                                                        func NewApplicationStatusSetter

                                                                                                        func NewApplicationStatusSetter(st *state.State, getCanModify GetAuthFunc, leadershipChecker leadership.Checker) *ApplicationStatusSetter

                                                                                                          NewApplicationStatusSetter returns a ServiceStatusSetter.

                                                                                                          func (*ApplicationStatusSetter) SetStatus

                                                                                                            SetStatus sets the status on the service given by the unit in args if the unit is the leader.

                                                                                                            type ApplicationWatcherFacade

                                                                                                            type ApplicationWatcherFacade struct {
                                                                                                            	// contains filtered or unexported fields
                                                                                                            }

                                                                                                              ApplicationWatcherFacade implements a common WatchApplications method for use by various facades.

                                                                                                              func NewApplicationWatcherFacade

                                                                                                              func NewApplicationWatcherFacade(st AppWatcherState, resources facade.Resources, filter ApplicationFilter) *ApplicationWatcherFacade

                                                                                                                NewApplicationWatcherFacade returns the optionally filtering WatchApplications facde call.

                                                                                                                func NewApplicationWatcherFacadeFromState

                                                                                                                func NewApplicationWatcherFacadeFromState(st *state.State, resources facade.Resources, filter ApplicationFilter) *ApplicationWatcherFacade

                                                                                                                  NewApplicationWatcherFacadeFromState returns the optionally filtering WatchApplications facde call.

                                                                                                                  func (*ApplicationWatcherFacade) WatchApplications

                                                                                                                  func (a *ApplicationWatcherFacade) WatchApplications() (_ params.StringsWatchResult, err error)

                                                                                                                    WatchApplications starts a StringsWatcher to watch applications deployed to this model.

                                                                                                                    type AuthFunc

                                                                                                                    type AuthFunc func(tag names.Tag) bool

                                                                                                                      AuthFunc returns whether the given entity is available to some operation.

                                                                                                                      type Authorizer

                                                                                                                      type Authorizer interface {
                                                                                                                      
                                                                                                                      	// AuthController returns whether the authenticated entity is
                                                                                                                      	// a machine acting as a controller. Can't be removed from this
                                                                                                                      	// interface without introducing a dependency on something else
                                                                                                                      	// to look up that property: it's not inherent in the result of
                                                                                                                      	// GetAuthTag, as the other methods all are.
                                                                                                                      	AuthController() bool
                                                                                                                      
                                                                                                                      	// AuthMachineAgent returns true if the entity is a machine agent.
                                                                                                                      	AuthMachineAgent() bool
                                                                                                                      
                                                                                                                      	// GetAuthTag returns the entity's tag.
                                                                                                                      	GetAuthTag() names.Tag
                                                                                                                      }

                                                                                                                        Authorizer represents the authenticated entity using the API server.

                                                                                                                        type BlockChecker

                                                                                                                        type BlockChecker struct {
                                                                                                                        	// contains filtered or unexported fields
                                                                                                                        }

                                                                                                                          BlockChecker checks for current blocks if any.

                                                                                                                          func NewBlockChecker

                                                                                                                          func NewBlockChecker(s BlockGetter) *BlockChecker

                                                                                                                          func (*BlockChecker) ChangeAllowed

                                                                                                                          func (c *BlockChecker) ChangeAllowed() error

                                                                                                                            ChangeAllowed checks if change block is in place. Change block prevents all operations that may change current model in any way from running successfully.

                                                                                                                            func (*BlockChecker) DestroyAllowed

                                                                                                                            func (c *BlockChecker) DestroyAllowed() error

                                                                                                                              DestroyAllowed checks if destroy block is in place. Destroy block prevents destruction of current model.

                                                                                                                              func (*BlockChecker) RemoveAllowed

                                                                                                                              func (c *BlockChecker) RemoveAllowed() error

                                                                                                                                RemoveAllowed checks if remove block is in place. Remove block prevents removal of machine, service, unit and relation from current model.

                                                                                                                                type BlockGetter

                                                                                                                                type BlockGetter interface {
                                                                                                                                	GetBlockForType(t state.BlockType) (state.Block, bool, error)
                                                                                                                                }

                                                                                                                                type ControllerConfigAPI

                                                                                                                                type ControllerConfigAPI struct {
                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                }

                                                                                                                                  ControllerConfigAPI implements two common methods for use by various facades - eg Provisioner and ControllerConfig.

                                                                                                                                  func NewControllerConfig

                                                                                                                                  func NewControllerConfig(st state.ControllerAccessor) *ControllerConfigAPI

                                                                                                                                    NewControllerConfig returns a new NewControllerConfigAPI.

                                                                                                                                    func NewStateControllerConfig

                                                                                                                                    func NewStateControllerConfig(st *state.State) *ControllerConfigAPI

                                                                                                                                      NewStateControllerConfig returns a new NewControllerConfigAPI.

                                                                                                                                      func (*ControllerConfigAPI) ControllerAPIInfoForModels

                                                                                                                                      func (s *ControllerConfigAPI) ControllerAPIInfoForModels(args params.Entities) (params.ControllerAPIInfoResults, error)

                                                                                                                                        ControllerAPIInfoForModels returns the controller api connection details for the specified models.

                                                                                                                                        func (*ControllerConfigAPI) ControllerConfig

                                                                                                                                        func (s *ControllerConfigAPI) ControllerConfig() (params.ControllerConfigResult, error)

                                                                                                                                          ControllerConfig returns the controller's configuration.

                                                                                                                                          type ControllerNode

                                                                                                                                          type ControllerNode interface {
                                                                                                                                          	Id() string
                                                                                                                                          	HasVote() bool
                                                                                                                                          	WantsVote() bool
                                                                                                                                          }

                                                                                                                                          type DeadEnsurer

                                                                                                                                          type DeadEnsurer struct {
                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                          }

                                                                                                                                            DeadEnsurer implements a common EnsureDead method for use by various facades.

                                                                                                                                            func NewDeadEnsurer

                                                                                                                                            func NewDeadEnsurer(st state.EntityFinder, afterDead func(names.Tag), getCanModify GetAuthFunc) *DeadEnsurer

                                                                                                                                              NewDeadEnsurer returns a new DeadEnsurer. The GetAuthFunc will be used on each invocation of EnsureDead to determine current permissions.

                                                                                                                                              func (*DeadEnsurer) EnsureDead

                                                                                                                                              func (d *DeadEnsurer) EnsureDead(args params.Entities) (params.ErrorResults, error)

                                                                                                                                                EnsureDead calls EnsureDead on each given entity from state. It will fail if the entity is not present. If it's Alive, nothing will happen (see state/EnsureDead() for units or machines).

                                                                                                                                                type EnvironConfigGetterFuncs

                                                                                                                                                type EnvironConfigGetterFuncs struct {
                                                                                                                                                	ModelConfigFunc func() (*config.Config, error)
                                                                                                                                                	CloudSpecFunc   func() (environscloudspec.CloudSpec, error)
                                                                                                                                                }

                                                                                                                                                  EnvironConfigGetterFuncs holds implements environs.EnvironConfigGetter in a pluggable way.

                                                                                                                                                  func (EnvironConfigGetterFuncs) CloudSpec

                                                                                                                                                    CloudSpec implements environs.EnvironConfigGetter.

                                                                                                                                                    func (EnvironConfigGetterFuncs) ModelConfig

                                                                                                                                                    func (f EnvironConfigGetterFuncs) ModelConfig() (*config.Config, error)

                                                                                                                                                      ModelConfig implements EnvironConfigGetter.

                                                                                                                                                      type GetActionsFn

                                                                                                                                                      type GetActionsFn func() ([]state.Action, error)

                                                                                                                                                        GetActionsFn declares the function type that returns a slice of state.Action and error, used to curry specific list functions.

                                                                                                                                                        type GetAuthFunc

                                                                                                                                                        type GetAuthFunc func() (AuthFunc, error)

                                                                                                                                                          GetAuthFunc returns an AuthFunc.

                                                                                                                                                          func AuthAlways

                                                                                                                                                          func AuthAlways() GetAuthFunc

                                                                                                                                                            AuthAlways returns an authentication function that always returns true iff it is passed a valid tag.

                                                                                                                                                            func AuthAny

                                                                                                                                                            func AuthAny(getFuncs ...GetAuthFunc) GetAuthFunc

                                                                                                                                                              AuthAny returns an AuthFunc generator that returns an AuthFunc that accepts any tag authorized by any of its arguments. If no arguments are passed this is equivalent to AuthNever.

                                                                                                                                                              func AuthFuncForMachineAgent

                                                                                                                                                              func AuthFuncForMachineAgent(authorizer Authorizer) GetAuthFunc

                                                                                                                                                                AuthFuncForMachineAgent returns a GetAuthFunc which creates an AuthFunc allowing only machine agents and their controllers

                                                                                                                                                                func AuthFuncForTag

                                                                                                                                                                func AuthFuncForTag(valid names.Tag) GetAuthFunc

                                                                                                                                                                  AuthFuncForTag returns an authentication function that always returns true iff it is passed a specific tag.

                                                                                                                                                                  func AuthFuncForTagKind

                                                                                                                                                                  func AuthFuncForTagKind(kind string) GetAuthFunc

                                                                                                                                                                    AuthFuncForTagKind returns a GetAuthFunc which creates an AuthFunc allowing only the given tag kind and denies all others. Passing an empty kind is an error.

                                                                                                                                                                    type InstanceIdGetter

                                                                                                                                                                    type InstanceIdGetter struct {
                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                    }

                                                                                                                                                                      InstanceIdGetter implements a common InstanceId method for use by various facades.

                                                                                                                                                                      func NewInstanceIdGetter

                                                                                                                                                                      func NewInstanceIdGetter(st state.EntityFinder, getCanRead GetAuthFunc) *InstanceIdGetter

                                                                                                                                                                        NewInstanceIdGetter returns a new InstanceIdGetter. The GetAuthFunc will be used on each invocation of InstanceId to determine current permissions.

                                                                                                                                                                        func (*InstanceIdGetter) InstanceId

                                                                                                                                                                        func (ig *InstanceIdGetter) InstanceId(args params.Entities) (params.StringResults, error)

                                                                                                                                                                          InstanceId returns the provider specific instance id for each given machine or an CodeNotProvisioned error, if not set.

                                                                                                                                                                          type LeadershipMachine

                                                                                                                                                                          type LeadershipMachine interface {
                                                                                                                                                                          	ApplicationNames() ([]string, error)
                                                                                                                                                                          }

                                                                                                                                                                            LeadershipMachine is an indirection for state.machine.

                                                                                                                                                                            type LeadershipPinning

                                                                                                                                                                            type LeadershipPinning struct {
                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                            }

                                                                                                                                                                              LeadershipPinning defines a type for pinning and unpinning application leaders.

                                                                                                                                                                              func NewLeadershipPinning

                                                                                                                                                                              func NewLeadershipPinning(
                                                                                                                                                                              	st LeadershipPinningBackend, modelTag names.ModelTag, pinner leadership.Pinner, authorizer facade.Authorizer,
                                                                                                                                                                              ) (*LeadershipPinning, error)

                                                                                                                                                                                NewLeadershipPinning creates and returns a new leadership API from the input tag, Pinner implementation and facade Authorizer.

                                                                                                                                                                                func NewLeadershipPinningFromContext

                                                                                                                                                                                func NewLeadershipPinningFromContext(ctx facade.Context) (*LeadershipPinning, error)

                                                                                                                                                                                  NewLeadershipPinningFromContext creates and returns a new leadership from a facade context. This signature is suitable for facade registration.

                                                                                                                                                                                  func (*LeadershipPinning) GetMachineApplicationNames

                                                                                                                                                                                  func (a *LeadershipPinning) GetMachineApplicationNames(id string) ([]string, error)

                                                                                                                                                                                    GetMachineApplicationNames returns the applications associated with a machine.

                                                                                                                                                                                    func (*LeadershipPinning) PinApplicationLeaders

                                                                                                                                                                                    func (a *LeadershipPinning) PinApplicationLeaders() (params.PinApplicationsResults, error)

                                                                                                                                                                                      PinApplicationLeaders pins leadership for applications based on the auth tag provided.

                                                                                                                                                                                      func (*LeadershipPinning) PinApplicationLeadersByName

                                                                                                                                                                                      func (a *LeadershipPinning) PinApplicationLeadersByName(tag names.Tag, appNames []string) (params.PinApplicationsResults, error)

                                                                                                                                                                                        PinApplicationLeadersByName takes a slice of application names and attempts to pin them accordingly.

                                                                                                                                                                                        func (*LeadershipPinning) PinnedLeadership

                                                                                                                                                                                        func (a *LeadershipPinning) PinnedLeadership() (params.PinnedLeadershipResult, error)

                                                                                                                                                                                          PinnedLeadership returns all pinned applications and the entities that require their pinned behaviour, for leadership in the current model.

                                                                                                                                                                                          func (*LeadershipPinning) UnpinApplicationLeaders

                                                                                                                                                                                          func (a *LeadershipPinning) UnpinApplicationLeaders() (params.PinApplicationsResults, error)

                                                                                                                                                                                            UnpinApplicationLeaders unpins leadership for applications based on the auth tag provided.

                                                                                                                                                                                            func (*LeadershipPinning) UnpinApplicationLeadersByName

                                                                                                                                                                                            func (a *LeadershipPinning) UnpinApplicationLeadersByName(tag names.Tag, appNames []string) (params.PinApplicationsResults, error)

                                                                                                                                                                                              UnpinApplicationLeadersByName takes a slice of application names and attempts to unpin them accordingly.

                                                                                                                                                                                              type LeadershipPinningBackend

                                                                                                                                                                                              type LeadershipPinningBackend interface {
                                                                                                                                                                                              	Machine(string) (LeadershipMachine, error)
                                                                                                                                                                                              }

                                                                                                                                                                                                LeadershipPinningBacked describes state method wrappers used by this API.

                                                                                                                                                                                                type LifeGetter

                                                                                                                                                                                                type LifeGetter struct {
                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                }

                                                                                                                                                                                                  LifeGetter implements a common Life method for use by various facades.

                                                                                                                                                                                                  func NewLifeGetter

                                                                                                                                                                                                  func NewLifeGetter(st state.EntityFinder, getCanRead GetAuthFunc) *LifeGetter

                                                                                                                                                                                                    NewLifeGetter returns a new LifeGetter. The GetAuthFunc will be used on each invocation of Life to determine current permissions.

                                                                                                                                                                                                    func (*LifeGetter) Life

                                                                                                                                                                                                    func (lg *LifeGetter) Life(args params.Entities) (params.LifeResults, error)

                                                                                                                                                                                                      Life returns the life status of every supplied entity, where available.

                                                                                                                                                                                                      type Machine

                                                                                                                                                                                                      type Machine interface {
                                                                                                                                                                                                      	Id() string
                                                                                                                                                                                                      	InstanceId() (instance.Id, error)
                                                                                                                                                                                                      	InstanceNames() (instance.Id, string, error)
                                                                                                                                                                                                      	Status() (status.StatusInfo, error)
                                                                                                                                                                                                      	ContainerType() instance.ContainerType
                                                                                                                                                                                                      	HardwareCharacteristics() (*instance.HardwareCharacteristics, error)
                                                                                                                                                                                                      	Life() state.Life
                                                                                                                                                                                                      	ForceDestroy(time.Duration) error
                                                                                                                                                                                                      	Destroy() error
                                                                                                                                                                                                      	IsManager() bool
                                                                                                                                                                                                      	IsLockedForSeriesUpgrade() (bool, error)
                                                                                                                                                                                                      }

                                                                                                                                                                                                      type MachineStatusGetter

                                                                                                                                                                                                      type MachineStatusGetter interface {
                                                                                                                                                                                                      	Status() (status.StatusInfo, error)
                                                                                                                                                                                                      	Id() string
                                                                                                                                                                                                      	Life() state.Life
                                                                                                                                                                                                      }

                                                                                                                                                                                                        MachineStatusGetter defines the machine functionality required to status.

                                                                                                                                                                                                        type Model

                                                                                                                                                                                                        type Model interface {
                                                                                                                                                                                                        	Type() state.ModelType
                                                                                                                                                                                                        	Config() (*config.Config, error)
                                                                                                                                                                                                        	Life() state.Life
                                                                                                                                                                                                        	ModelTag() names.ModelTag
                                                                                                                                                                                                        	Owner() names.UserTag
                                                                                                                                                                                                        	Status() (status.StatusInfo, error)
                                                                                                                                                                                                        	CloudName() string
                                                                                                                                                                                                        	Cloud() (cloud.Cloud, error)
                                                                                                                                                                                                        	CloudCredentialTag() (names.CloudCredentialTag, bool)
                                                                                                                                                                                                        	CloudCredential() (state.Credential, bool, error)
                                                                                                                                                                                                        	CloudRegion() string
                                                                                                                                                                                                        	Users() ([]permission.UserAccess, error)
                                                                                                                                                                                                        	Destroy(state.DestroyModelParams) error
                                                                                                                                                                                                        	SLALevel() string
                                                                                                                                                                                                        	SLAOwner() string
                                                                                                                                                                                                        	MigrationMode() state.MigrationMode
                                                                                                                                                                                                        	Name() string
                                                                                                                                                                                                        	UUID() string
                                                                                                                                                                                                        	ControllerUUID() string
                                                                                                                                                                                                        	LastModelConnection(user names.UserTag) (time.Time, error)
                                                                                                                                                                                                        	AddUser(state.UserAccessSpec) (permission.UserAccess, error)
                                                                                                                                                                                                        	AutoConfigureContainerNetworking(environ environs.BootstrapEnviron) error
                                                                                                                                                                                                        	SetCloudCredential(tag names.CloudCredentialTag) (bool, error)
                                                                                                                                                                                                        }

                                                                                                                                                                                                          Model defines methods provided by a state.Model instance. All the interface methods are defined directly on state.Model and are reproduced here for use in tests.

                                                                                                                                                                                                          type ModelMachinesWatcher

                                                                                                                                                                                                          type ModelMachinesWatcher struct {
                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                          }

                                                                                                                                                                                                            ModelMachinesWatcher implements a common WatchModelMachines method for use by various facades.

                                                                                                                                                                                                            func NewModelMachinesWatcher

                                                                                                                                                                                                            func NewModelMachinesWatcher(st state.ModelMachinesWatcher, resources facade.Resources, authorizer facade.Authorizer) *ModelMachinesWatcher

                                                                                                                                                                                                              NewModelMachinesWatcher returns a new ModelMachinesWatcher. The GetAuthFunc will be used on each invocation of WatchUnits to determine current permissions.

                                                                                                                                                                                                              func (*ModelMachinesWatcher) WatchModelMachineStartTimes

                                                                                                                                                                                                              func (e *ModelMachinesWatcher) WatchModelMachineStartTimes() (params.StringsWatchResult, error)

                                                                                                                                                                                                                WatchModelMachineStartTimes watches the non-container machines in the model for changes to the Life or AgentStartTime fields and reports them as a batch.

                                                                                                                                                                                                                func (*ModelMachinesWatcher) WatchModelMachines

                                                                                                                                                                                                                func (e *ModelMachinesWatcher) WatchModelMachines() (params.StringsWatchResult, error)

                                                                                                                                                                                                                  WatchModelMachines returns a StringsWatcher that notifies of changes to the life cycles of the top level machines in the current model.

                                                                                                                                                                                                                  type ModelManagerBackend

                                                                                                                                                                                                                  type ModelManagerBackend interface {
                                                                                                                                                                                                                  	APIHostPortsForAgentsGetter
                                                                                                                                                                                                                  	ToolsStorageGetter
                                                                                                                                                                                                                  	BlockGetter
                                                                                                                                                                                                                  	state.CloudAccessor
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	ModelUUID() string
                                                                                                                                                                                                                  	ModelUUIDsForUser(names.UserTag) ([]string, error)
                                                                                                                                                                                                                  	ModelBasicInfoForUser(user names.UserTag) ([]state.ModelAccessInfo, error)
                                                                                                                                                                                                                  	ModelSummariesForUser(user names.UserTag, all bool) ([]state.ModelSummary, error)
                                                                                                                                                                                                                  	IsControllerAdmin(user names.UserTag) (bool, error)
                                                                                                                                                                                                                  	NewModel(state.ModelArgs) (Model, ModelManagerBackend, error)
                                                                                                                                                                                                                  	Model() (Model, error)
                                                                                                                                                                                                                  	AllModelUUIDs() ([]string, error)
                                                                                                                                                                                                                  	GetModel(string) (Model, func() bool, error)
                                                                                                                                                                                                                  	GetBackend(string) (ModelManagerBackend, func() bool, error)
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	ComposeNewModelConfig(modelAttr map[string]interface{}, regionSpec *environscloudspec.CloudRegionSpec) (map[string]interface{}, error)
                                                                                                                                                                                                                  	ControllerModelUUID() string
                                                                                                                                                                                                                  	ControllerModelTag() names.ModelTag
                                                                                                                                                                                                                  	IsController() bool
                                                                                                                                                                                                                  	ControllerConfig() (controller.Config, error)
                                                                                                                                                                                                                  	ControllerNodes() ([]ControllerNode, error)
                                                                                                                                                                                                                  	ModelConfigDefaultValues(cloudName string) (config.ModelDefaultAttributes, error)
                                                                                                                                                                                                                  	UpdateModelConfigDefaultValues(update map[string]interface{}, remove []string, regionSpec *environscloudspec.CloudRegionSpec) error
                                                                                                                                                                                                                  	Unit(name string) (*state.Unit, error)
                                                                                                                                                                                                                  	Name() string
                                                                                                                                                                                                                  	ModelTag() names.ModelTag
                                                                                                                                                                                                                  	ModelConfig() (*config.Config, error)
                                                                                                                                                                                                                  	AddControllerUser(state.UserAccessSpec) (permission.UserAccess, error)
                                                                                                                                                                                                                  	RemoveUserAccess(names.UserTag, names.Tag) error
                                                                                                                                                                                                                  	UserAccess(names.UserTag, names.Tag) (permission.UserAccess, error)
                                                                                                                                                                                                                  	GetCloudAccess(cloud string, user names.UserTag) (permission.Access, error)
                                                                                                                                                                                                                  	AllMachines() (machines []Machine, err error)
                                                                                                                                                                                                                  	AllApplications() (applications []Application, err error)
                                                                                                                                                                                                                  	AllFilesystems() ([]state.Filesystem, error)
                                                                                                                                                                                                                  	AllVolumes() ([]state.Volume, error)
                                                                                                                                                                                                                  	ControllerUUID() string
                                                                                                                                                                                                                  	ControllerTag() names.ControllerTag
                                                                                                                                                                                                                  	Export() (description.Model, error)
                                                                                                                                                                                                                  	ExportPartial(state.ExportConfig) (description.Model, error)
                                                                                                                                                                                                                  	SetUserAccess(subject names.UserTag, target names.Tag, access permission.Access) (permission.UserAccess, error)
                                                                                                                                                                                                                  	SetModelMeterStatus(string, string) error
                                                                                                                                                                                                                  	AllSpaces() ([]*state.Space, error)
                                                                                                                                                                                                                  	AddSpace(string, network.Id, []string, bool) (*state.Space, error)
                                                                                                                                                                                                                  	AllEndpointBindingsSpaceNames() (set.Strings, error)
                                                                                                                                                                                                                  	ConstraintsBySpaceName(string) ([]*state.Constraints, error)
                                                                                                                                                                                                                  	DefaultEndpointBindingSpace() (string, error)
                                                                                                                                                                                                                  	SaveProviderSubnets([]network.SubnetInfo, string) error
                                                                                                                                                                                                                  	LatestMigration() (state.ModelMigration, error)
                                                                                                                                                                                                                  	DumpAll() (map[string]interface{}, error)
                                                                                                                                                                                                                  	Close() error
                                                                                                                                                                                                                  	HAPrimaryMachine() (names.MachineTag, error)
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Methods required by the metricsender package.
                                                                                                                                                                                                                  	MetricsManager() (*state.MetricsManager, error)
                                                                                                                                                                                                                  	MetricsToSend(batchSize int) ([]*state.MetricBatch, error)
                                                                                                                                                                                                                  	SetMetricBatchesSent(batchUUIDs []string) error
                                                                                                                                                                                                                  	CountOfUnsentMetrics() (int, error)
                                                                                                                                                                                                                  	CountOfSentMetrics() (int, error)
                                                                                                                                                                                                                  	CleanupOldMetrics() error
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    ModelManagerBackend defines methods provided by a state instance used by the model manager apiserver implementation. All the interface methods are defined directly on state.State and are reproduced here for use in tests.

                                                                                                                                                                                                                    func NewModelManagerBackend

                                                                                                                                                                                                                    func NewModelManagerBackend(m *state.Model, pool *state.StatePool) ModelManagerBackend

                                                                                                                                                                                                                      NewModelManagerBackend returns a modelManagerStateShim wrapping the passed state, which implements ModelManagerBackend.

                                                                                                                                                                                                                      func NewUserAwareModelManagerBackend

                                                                                                                                                                                                                      func NewUserAwareModelManagerBackend(m *state.Model, pool *state.StatePool, u names.UserTag) ModelManagerBackend

                                                                                                                                                                                                                        NewUserAwareModelManagerBackend returns a user-aware modelManagerStateShim wrapping the passed state, which implements ModelManagerBackend. The returned backend may emit redirect errors when attempting a model lookup for a migrated model that this user had been granted access to.

                                                                                                                                                                                                                        type ModelPresence

                                                                                                                                                                                                                        type ModelPresence interface {
                                                                                                                                                                                                                        	// For a given non controller agent, return the Status for that agent.
                                                                                                                                                                                                                        	AgentStatus(agent string) (presence.Status, error)
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          ModelPresence represents the API server connections for a model.

                                                                                                                                                                                                                          type ModelPresenceContext

                                                                                                                                                                                                                          type ModelPresenceContext struct {
                                                                                                                                                                                                                          	// Presence represents the API server connections for a model.
                                                                                                                                                                                                                          	Presence ModelPresence
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            ModelPresenceContext represents the known agent presence state for the entire model.

                                                                                                                                                                                                                            func (*ModelPresenceContext) MachineStatus

                                                                                                                                                                                                                            func (c *ModelPresenceContext) MachineStatus(machine MachineStatusGetter) (status.StatusInfo, error)

                                                                                                                                                                                                                              MachineStatus returns the machine agent status for a given machine, with special handling for agent presence.

                                                                                                                                                                                                                              func (*ModelPresenceContext) UnitStatus

                                                                                                                                                                                                                              func (c *ModelPresenceContext) UnitStatus(unit UnitStatusGetter) (agent StatusAndErr, workload StatusAndErr)

                                                                                                                                                                                                                                UnitStatus returns the unit agent and workload status for a given unit, with special handling for agent presence.

                                                                                                                                                                                                                                type ModelStatusAPI

                                                                                                                                                                                                                                type ModelStatusAPI struct {
                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  ModelStatusAPI implements the ModelStatus() API.

                                                                                                                                                                                                                                  func NewModelStatusAPI

                                                                                                                                                                                                                                  func NewModelStatusAPI(backend ModelManagerBackend, authorizer facade.Authorizer, apiUser names.UserTag) *ModelStatusAPI

                                                                                                                                                                                                                                    NewModelStatusAPI creates an implementation providing the ModelStatus() API.

                                                                                                                                                                                                                                    func (*ModelStatusAPI) ModelStatus

                                                                                                                                                                                                                                      ModelStatus returns a summary of the model.

                                                                                                                                                                                                                                      type ModelWatcher

                                                                                                                                                                                                                                      type ModelWatcher struct {
                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        ModelWatcher implements two common methods for use by various facades - WatchForModelConfigChanges and ModelConfig.

                                                                                                                                                                                                                                        func NewModelWatcher

                                                                                                                                                                                                                                        func NewModelWatcher(st state.ModelAccessor, resources facade.Resources, authorizer facade.Authorizer) *ModelWatcher

                                                                                                                                                                                                                                          NewModelWatcher returns a new ModelWatcher. Active watchers will be stored in the provided Resources. The two GetAuthFunc callbacks will be used on each invocation of the methods to determine current permissions. Right now, model tags are not used, so both created AuthFuncs are called with "" for tag, which means "the current model".

                                                                                                                                                                                                                                          func (*ModelWatcher) ModelConfig

                                                                                                                                                                                                                                          func (m *ModelWatcher) ModelConfig() (params.ModelConfigResult, error)

                                                                                                                                                                                                                                            ModelConfig returns the current model's configuration.

                                                                                                                                                                                                                                            func (*ModelWatcher) WatchForModelConfigChanges

                                                                                                                                                                                                                                            func (m *ModelWatcher) WatchForModelConfigChanges() (params.NotifyWatchResult, error)

                                                                                                                                                                                                                                              WatchForModelConfigChanges returns a NotifyWatcher that observes changes to the model configuration. Note that although the NotifyWatchResult contains an Error field, it's not used because we are only returning a single watcher, so we use the regular error return.

                                                                                                                                                                                                                                              type MultiNotifyWatcher

                                                                                                                                                                                                                                              type MultiNotifyWatcher struct {
                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                MultiNotifyWatcher implements state.NotifyWatcher, combining multiple NotifyWatchers.

                                                                                                                                                                                                                                                func NewMultiNotifyWatcher

                                                                                                                                                                                                                                                func NewMultiNotifyWatcher(w ...state.NotifyWatcher) *MultiNotifyWatcher

                                                                                                                                                                                                                                                  NewMultiNotifyWatcher creates a NotifyWatcher that combines each of the NotifyWatchers passed in. Each watcher's initial event is consumed, and a single initial event is sent. Subsequent events are not coalesced.

                                                                                                                                                                                                                                                  func (*MultiNotifyWatcher) Changes

                                                                                                                                                                                                                                                  func (w *MultiNotifyWatcher) Changes() <-chan struct{}

                                                                                                                                                                                                                                                  func (*MultiNotifyWatcher) Err

                                                                                                                                                                                                                                                  func (w *MultiNotifyWatcher) Err() error

                                                                                                                                                                                                                                                  func (*MultiNotifyWatcher) Kill

                                                                                                                                                                                                                                                  func (w *MultiNotifyWatcher) Kill()

                                                                                                                                                                                                                                                  func (*MultiNotifyWatcher) Stop

                                                                                                                                                                                                                                                  func (w *MultiNotifyWatcher) Stop() error

                                                                                                                                                                                                                                                  func (*MultiNotifyWatcher) Wait

                                                                                                                                                                                                                                                  func (w *MultiNotifyWatcher) Wait() error

                                                                                                                                                                                                                                                  type NewEnvironFunc

                                                                                                                                                                                                                                                  type NewEnvironFunc func() (environs.BootstrapEnviron, error)

                                                                                                                                                                                                                                                    NewEnvironFunc is a function that returns a BootstrapEnviron instance.

                                                                                                                                                                                                                                                    func EnvironFuncForModel

                                                                                                                                                                                                                                                    func EnvironFuncForModel(model stateenvirons.Model, configGetter environs.EnvironConfigGetter) NewEnvironFunc

                                                                                                                                                                                                                                                      EnvironFuncForModel is a helper function that returns a NewEnvironFunc suitable for the specified model.

                                                                                                                                                                                                                                                      type PasswordChanger

                                                                                                                                                                                                                                                      type PasswordChanger struct {
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        PasswordChanger implements a common SetPasswords method for use by various facades.

                                                                                                                                                                                                                                                        func NewPasswordChanger

                                                                                                                                                                                                                                                        func NewPasswordChanger(st state.EntityFinder, getCanChange GetAuthFunc) *PasswordChanger

                                                                                                                                                                                                                                                          NewPasswordChanger returns a new PasswordChanger. The GetAuthFunc will be used on each invocation of SetPasswords to determine current permissions.

                                                                                                                                                                                                                                                          func (*PasswordChanger) SetPasswords

                                                                                                                                                                                                                                                          func (pc *PasswordChanger) SetPasswords(args params.EntityPasswords) (params.ErrorResults, error)

                                                                                                                                                                                                                                                            SetPasswords sets the given password for each supplied entity, if possible.

                                                                                                                                                                                                                                                            type RebootActionGetter

                                                                                                                                                                                                                                                            type RebootActionGetter struct {
                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              RebootActionGetter implements the GetRebootAction API method

                                                                                                                                                                                                                                                              func NewRebootActionGetter

                                                                                                                                                                                                                                                              func NewRebootActionGetter(st state.EntityFinder, auth GetAuthFunc) *RebootActionGetter

                                                                                                                                                                                                                                                              func (*RebootActionGetter) GetRebootAction

                                                                                                                                                                                                                                                              func (r *RebootActionGetter) GetRebootAction(args params.Entities) (params.RebootActionResults, error)

                                                                                                                                                                                                                                                                GetRebootAction returns the action a machine agent should take. If a reboot flag is set on the machine, then that machine is expected to reboot (params.ShouldReboot). a reboot flag set on the machine parent or grandparent, will cause the machine to shutdown (params.ShouldShutdown). If no reboot flag is set, the machine should do nothing (params.ShouldDoNothing).

                                                                                                                                                                                                                                                                type RebootFlagClearer

                                                                                                                                                                                                                                                                type RebootFlagClearer struct {
                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  RebootFlagClearer implements the ClearReboot API call

                                                                                                                                                                                                                                                                  func NewRebootFlagClearer

                                                                                                                                                                                                                                                                  func NewRebootFlagClearer(st state.EntityFinder, auth GetAuthFunc) *RebootFlagClearer

                                                                                                                                                                                                                                                                  func (*RebootFlagClearer) ClearReboot

                                                                                                                                                                                                                                                                  func (r *RebootFlagClearer) ClearReboot(args params.Entities) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                    ClearReboot will clear the reboot flag on provided machines, if it exists.

                                                                                                                                                                                                                                                                    type RebootRequester

                                                                                                                                                                                                                                                                    type RebootRequester struct {
                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      RebootRequester implements the RequestReboot API method

                                                                                                                                                                                                                                                                      func NewRebootRequester

                                                                                                                                                                                                                                                                      func NewRebootRequester(st state.EntityFinder, auth GetAuthFunc) *RebootRequester

                                                                                                                                                                                                                                                                      func (*RebootRequester) RequestReboot

                                                                                                                                                                                                                                                                      func (r *RebootRequester) RequestReboot(args params.Entities) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                        RequestReboot sets the reboot flag on the provided machines

                                                                                                                                                                                                                                                                        type RelationUnitsWatcher

                                                                                                                                                                                                                                                                        type RelationUnitsWatcher interface {
                                                                                                                                                                                                                                                                        	watcher.CoreWatcher
                                                                                                                                                                                                                                                                        	Changes() <-chan params.RelationUnitsChange
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Stop is needed to implement facade.Resource.
                                                                                                                                                                                                                                                                        	Stop() error
                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                        	// Err implements watcher.Errer.
                                                                                                                                                                                                                                                                        	Err() error
                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                          RelationUnitsWatcher represents a state.RelationUnitsWatcher at the apiserver level (different type for changes).

                                                                                                                                                                                                                                                                          func RelationUnitsWatcherFromState

                                                                                                                                                                                                                                                                          func RelationUnitsWatcherFromState(source state.RelationUnitsWatcher) (RelationUnitsWatcher, error)

                                                                                                                                                                                                                                                                            NewRelationUnitsWatcherFromState wraps a state-level RelationUnitsWatcher in an equivalent apiserver-level one, taking responsibility for the source watcher's lifetime.

                                                                                                                                                                                                                                                                            type Remover

                                                                                                                                                                                                                                                                            type Remover struct {
                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              Remover implements a common Remove method for use by various facades.

                                                                                                                                                                                                                                                                              func NewRemover

                                                                                                                                                                                                                                                                              func NewRemover(st state.EntityFinder, afterDead func(tag names.Tag), callEnsureDead bool, getCanModify GetAuthFunc) *Remover

                                                                                                                                                                                                                                                                                NewRemover returns a new Remover. The callEnsureDead flag specifies whether EnsureDead should be called on an entity before removing. The GetAuthFunc will be used on each invocation of Remove to determine current permissions.

                                                                                                                                                                                                                                                                                func (*Remover) Remove

                                                                                                                                                                                                                                                                                func (r *Remover) Remove(args params.Entities) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                                  Remove removes every given entity from state, calling EnsureDead first, then Remove. It will fail if the entity is not present.

                                                                                                                                                                                                                                                                                  type Resources

                                                                                                                                                                                                                                                                                  type Resources struct {
                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    Resources holds all the resources for a connection. It allows the registration of resources that will be cleaned up when a connection terminates.

                                                                                                                                                                                                                                                                                    func NewResources

                                                                                                                                                                                                                                                                                    func NewResources() *Resources

                                                                                                                                                                                                                                                                                    func (*Resources) Count

                                                                                                                                                                                                                                                                                    func (rs *Resources) Count() int

                                                                                                                                                                                                                                                                                      Count returns the number of resources currently held.

                                                                                                                                                                                                                                                                                      func (*Resources) Get

                                                                                                                                                                                                                                                                                      func (rs *Resources) Get(id string) facade.Resource

                                                                                                                                                                                                                                                                                        Get returns the resource for the given id, or nil if there is no such resource.

                                                                                                                                                                                                                                                                                        func (*Resources) Register

                                                                                                                                                                                                                                                                                        func (rs *Resources) Register(r facade.Resource) string

                                                                                                                                                                                                                                                                                          Register registers the given resource. It returns a unique identifier for the resource which can then be used in subsequent API requests to refer to the resource.

                                                                                                                                                                                                                                                                                          func (*Resources) RegisterNamed

                                                                                                                                                                                                                                                                                          func (rs *Resources) RegisterNamed(name string, r facade.Resource) error

                                                                                                                                                                                                                                                                                            RegisterNamed registers the given resource. Callers must supply a unique name for the given resource. It is an error to try to register another resource with the same name as an already registered name. (This could be softened that you can overwrite an existing one and it will be Stopped and replaced, but we don't have a need for that yet.) It is also an error to supply a name that is an integer string, since that collides with the auto-naming from Register.

                                                                                                                                                                                                                                                                                            func (*Resources) Stop

                                                                                                                                                                                                                                                                                            func (rs *Resources) Stop(id string) error

                                                                                                                                                                                                                                                                                              Stop stops the resource with the given id and unregisters it. It returns any error from the underlying Stop call. It does not return an error if the resource has already been unregistered.

                                                                                                                                                                                                                                                                                              func (*Resources) StopAll

                                                                                                                                                                                                                                                                                              func (rs *Resources) StopAll()

                                                                                                                                                                                                                                                                                                StopAll stops all the resources.

                                                                                                                                                                                                                                                                                                type StatusAndErr

                                                                                                                                                                                                                                                                                                type StatusAndErr struct {
                                                                                                                                                                                                                                                                                                	Status status.StatusInfo
                                                                                                                                                                                                                                                                                                	Err    error
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  StatusAndErr pairs a StatusInfo with an error associated with retrieving it.

                                                                                                                                                                                                                                                                                                  type StatusGetter

                                                                                                                                                                                                                                                                                                  type StatusGetter struct {
                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    StatusGetter implements a common Status method for use by various facades.

                                                                                                                                                                                                                                                                                                    func NewStatusGetter

                                                                                                                                                                                                                                                                                                    func NewStatusGetter(st state.EntityFinder, getCanAccess GetAuthFunc) *StatusGetter

                                                                                                                                                                                                                                                                                                      NewStatusGetter returns a new StatusGetter. The GetAuthFunc will be used on each invocation of Status to determine current permissions.

                                                                                                                                                                                                                                                                                                      func (*StatusGetter) Status

                                                                                                                                                                                                                                                                                                        Status returns the status of each given entity.

                                                                                                                                                                                                                                                                                                        type StatusSetter

                                                                                                                                                                                                                                                                                                        type StatusSetter struct {
                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          StatusSetter implements a common SetStatus method for use by various facades.

                                                                                                                                                                                                                                                                                                          func NewStatusSetter

                                                                                                                                                                                                                                                                                                          func NewStatusSetter(st state.EntityFinder, getCanModify GetAuthFunc) *StatusSetter

                                                                                                                                                                                                                                                                                                            NewStatusSetter returns a new StatusSetter. The GetAuthFunc will be used on each invocation of SetStatus to determine current permissions.

                                                                                                                                                                                                                                                                                                            func (*StatusSetter) SetStatus

                                                                                                                                                                                                                                                                                                            func (s *StatusSetter) SetStatus(args params.SetStatus) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                                                              SetStatus sets the status of each given entity.

                                                                                                                                                                                                                                                                                                              func (*StatusSetter) UpdateStatus

                                                                                                                                                                                                                                                                                                              func (s *StatusSetter) UpdateStatus(args params.SetStatus) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                                                                UpdateStatus updates the status data of each given entity. TODO(fwereade): WTF. This method exists *only* for the convenience of the *client* API -- and is itself completely broken -- but we still expose it in every facade with a StatusSetter? FFS.

                                                                                                                                                                                                                                                                                                                type StringResource

                                                                                                                                                                                                                                                                                                                type StringResource string

                                                                                                                                                                                                                                                                                                                  StringResource is just a regular 'string' that matches the Resource interface.

                                                                                                                                                                                                                                                                                                                  func (StringResource) Stop

                                                                                                                                                                                                                                                                                                                  func (StringResource) Stop() error

                                                                                                                                                                                                                                                                                                                  func (StringResource) String

                                                                                                                                                                                                                                                                                                                  func (s StringResource) String() string

                                                                                                                                                                                                                                                                                                                  type ToolsFinder

                                                                                                                                                                                                                                                                                                                  type ToolsFinder struct {
                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                  func NewToolsFinder

                                                                                                                                                                                                                                                                                                                    NewToolsFinder returns a new ToolsFinder, returning tools with their URLs pointing at the API server.

                                                                                                                                                                                                                                                                                                                    func (*ToolsFinder) FindTools

                                                                                                                                                                                                                                                                                                                      FindTools returns a List containing all tools matching the given parameters.

                                                                                                                                                                                                                                                                                                                      type ToolsGetter

                                                                                                                                                                                                                                                                                                                      type ToolsGetter struct {
                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        ToolsGetter implements a common Tools method for use by various facades.

                                                                                                                                                                                                                                                                                                                        func NewToolsGetter

                                                                                                                                                                                                                                                                                                                          NewToolsGetter returns a new ToolsGetter. The GetAuthFunc will be used on each invocation of Tools to determine current permissions.

                                                                                                                                                                                                                                                                                                                          func (*ToolsGetter) Tools

                                                                                                                                                                                                                                                                                                                          func (t *ToolsGetter) Tools(args params.Entities) (params.ToolsResults, error)

                                                                                                                                                                                                                                                                                                                            Tools finds the tools necessary for the given agents.

                                                                                                                                                                                                                                                                                                                            type ToolsSetter

                                                                                                                                                                                                                                                                                                                            type ToolsSetter struct {
                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              ToolsSetter implements a common Tools method for use by various facades.

                                                                                                                                                                                                                                                                                                                              func NewToolsSetter

                                                                                                                                                                                                                                                                                                                              func NewToolsSetter(st state.EntityFinder, getCanWrite GetAuthFunc) *ToolsSetter

                                                                                                                                                                                                                                                                                                                                NewToolsSetter returns a new ToolsGetter. The GetAuthFunc will be used on each invocation of Tools to determine current permissions.

                                                                                                                                                                                                                                                                                                                                func (*ToolsSetter) SetTools

                                                                                                                                                                                                                                                                                                                                  SetTools updates the recorded tools version for the agents.

                                                                                                                                                                                                                                                                                                                                  type ToolsStorageGetter

                                                                                                                                                                                                                                                                                                                                  type ToolsStorageGetter interface {
                                                                                                                                                                                                                                                                                                                                  	// ToolsStorage returns a binarystorage.StorageCloser.
                                                                                                                                                                                                                                                                                                                                  	ToolsStorage() (binarystorage.StorageCloser, error)
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    ToolsStorageGetter is an interface providing the ToolsStorage method.

                                                                                                                                                                                                                                                                                                                                    type ToolsURLGetter

                                                                                                                                                                                                                                                                                                                                    type ToolsURLGetter interface {
                                                                                                                                                                                                                                                                                                                                    	// ToolsURLs returns URLs for the tools with
                                                                                                                                                                                                                                                                                                                                    	// the specified binary version.
                                                                                                                                                                                                                                                                                                                                    	ToolsURLs(v version.Binary) ([]string, error)
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      ToolsURLGetter is an interface providing the ToolsURL method.

                                                                                                                                                                                                                                                                                                                                      type UnitAgentFinder

                                                                                                                                                                                                                                                                                                                                      type UnitAgentFinder struct {
                                                                                                                                                                                                                                                                                                                                      	state.EntityFinder
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        UnitAgentFinder is a state.EntityFinder that finds unit agents.

                                                                                                                                                                                                                                                                                                                                        func (*UnitAgentFinder) FindEntity

                                                                                                                                                                                                                                                                                                                                        func (ua *UnitAgentFinder) FindEntity(tag names.Tag) (state.Entity, error)

                                                                                                                                                                                                                                                                                                                                          FindEntity implements state.EntityFinder and returns unit agents.

                                                                                                                                                                                                                                                                                                                                          type UnitStateAPI

                                                                                                                                                                                                                                                                                                                                          type UnitStateAPI struct {
                                                                                                                                                                                                                                                                                                                                          	AccessMachine GetAuthFunc
                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                          func NewExternalUnitStateAPI

                                                                                                                                                                                                                                                                                                                                          func NewExternalUnitStateAPI(
                                                                                                                                                                                                                                                                                                                                          	st *state.State,
                                                                                                                                                                                                                                                                                                                                          	resources facade.Resources,
                                                                                                                                                                                                                                                                                                                                          	authorizer facade.Authorizer,
                                                                                                                                                                                                                                                                                                                                          	accessUnit GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                          	logger loggo.Logger,
                                                                                                                                                                                                                                                                                                                                          ) *UnitStateAPI

                                                                                                                                                                                                                                                                                                                                            NewExternalUnitStateAPI can be used for API registration.

                                                                                                                                                                                                                                                                                                                                            func NewUnitStateAPI

                                                                                                                                                                                                                                                                                                                                            func NewUnitStateAPI(
                                                                                                                                                                                                                                                                                                                                            	backend UnitStateBackend,
                                                                                                                                                                                                                                                                                                                                            	resources facade.Resources,
                                                                                                                                                                                                                                                                                                                                            	authorizer facade.Authorizer,
                                                                                                                                                                                                                                                                                                                                            	accessUnit GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                            	logger loggo.Logger,
                                                                                                                                                                                                                                                                                                                                            ) *UnitStateAPI

                                                                                                                                                                                                                                                                                                                                              NewUnitStateAPI returns a new UnitStateAPI. Currently both GetAuthFuncs can used to determine current permissions.

                                                                                                                                                                                                                                                                                                                                              func (*UnitStateAPI) SetState

                                                                                                                                                                                                                                                                                                                                                SetState sets the state persisted by the charm running in this unit and the state internal to the uniter for this unit.

                                                                                                                                                                                                                                                                                                                                                func (*UnitStateAPI) State

                                                                                                                                                                                                                                                                                                                                                  State returns the state persisted by the charm running in this unit and the state internal to the uniter for this unit.

                                                                                                                                                                                                                                                                                                                                                  type UnitStateBackend

                                                                                                                                                                                                                                                                                                                                                  type UnitStateBackend interface {
                                                                                                                                                                                                                                                                                                                                                  	ApplyOperation(state.ModelOperation) error
                                                                                                                                                                                                                                                                                                                                                  	Unit(string) (UnitStateUnit, error)
                                                                                                                                                                                                                                                                                                                                                  	ControllerConfig() (controller.Config, error)
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    UnitStateUnit describes unit-receiver state methods required for UnitStateAPI.

                                                                                                                                                                                                                                                                                                                                                    type UnitStateState

                                                                                                                                                                                                                                                                                                                                                    type UnitStateState struct {
                                                                                                                                                                                                                                                                                                                                                    	St *state.State
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      UnitStateState implements the UnitStateBackend indirection over state.State.

                                                                                                                                                                                                                                                                                                                                                      func (UnitStateState) ApplyOperation

                                                                                                                                                                                                                                                                                                                                                      func (s UnitStateState) ApplyOperation(op state.ModelOperation) error

                                                                                                                                                                                                                                                                                                                                                      func (UnitStateState) ControllerConfig

                                                                                                                                                                                                                                                                                                                                                      func (s UnitStateState) ControllerConfig() (controller.Config, error)

                                                                                                                                                                                                                                                                                                                                                      func (UnitStateState) Unit

                                                                                                                                                                                                                                                                                                                                                      func (s UnitStateState) Unit(name string) (UnitStateUnit, error)

                                                                                                                                                                                                                                                                                                                                                      type UnitStateUnit

                                                                                                                                                                                                                                                                                                                                                      type UnitStateUnit interface {
                                                                                                                                                                                                                                                                                                                                                      	SetStateOperation(*state.UnitState, state.UnitStateSizeLimits) state.ModelOperation
                                                                                                                                                                                                                                                                                                                                                      	State() (*state.UnitState, error)
                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                        UnitStateUnit describes unit-receiver state methods required for UnitStateAPI.

                                                                                                                                                                                                                                                                                                                                                        type UnitStatusGetter

                                                                                                                                                                                                                                                                                                                                                        type UnitStatusGetter interface {
                                                                                                                                                                                                                                                                                                                                                        	AgentStatus() (status.StatusInfo, error)
                                                                                                                                                                                                                                                                                                                                                        	Status() (status.StatusInfo, error)
                                                                                                                                                                                                                                                                                                                                                        	ShouldBeAssigned() bool
                                                                                                                                                                                                                                                                                                                                                        	Name() string
                                                                                                                                                                                                                                                                                                                                                        	Life() state.Life
                                                                                                                                                                                                                                                                                                                                                        	IsEmbedded() (bool, error)
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          UnitStatusGetter defines the unit functionality required to determine unit agent and workload status.

                                                                                                                                                                                                                                                                                                                                                          type UnitsWatcher

                                                                                                                                                                                                                                                                                                                                                          type UnitsWatcher struct {
                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            UnitsWatcher implements a common WatchUnits method for use by various facades.

                                                                                                                                                                                                                                                                                                                                                            func NewUnitsWatcher

                                                                                                                                                                                                                                                                                                                                                            func NewUnitsWatcher(st state.EntityFinder, resources facade.Resources, getCanWatch GetAuthFunc) *UnitsWatcher

                                                                                                                                                                                                                                                                                                                                                              NewUnitsWatcher returns a new UnitsWatcher. The GetAuthFunc will be used on each invocation of WatchUnits to determine current permissions.

                                                                                                                                                                                                                                                                                                                                                              func (*UnitsWatcher) WatchUnits

                                                                                                                                                                                                                                                                                                                                                                WatchUnits starts a StringsWatcher to watch all units belonging to to any entity (machine or service) passed in args.

                                                                                                                                                                                                                                                                                                                                                                type UpgradeSeriesAPI

                                                                                                                                                                                                                                                                                                                                                                type UpgradeSeriesAPI struct {
                                                                                                                                                                                                                                                                                                                                                                	AccessMachine GetAuthFunc
                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                func NewExternalUpgradeSeriesAPI

                                                                                                                                                                                                                                                                                                                                                                func NewExternalUpgradeSeriesAPI(
                                                                                                                                                                                                                                                                                                                                                                	st *state.State,
                                                                                                                                                                                                                                                                                                                                                                	resources facade.Resources,
                                                                                                                                                                                                                                                                                                                                                                	authorizer facade.Authorizer,
                                                                                                                                                                                                                                                                                                                                                                	accessMachine GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                                                	accessUnit GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                                                	logger loggo.Logger,
                                                                                                                                                                                                                                                                                                                                                                ) *UpgradeSeriesAPI

                                                                                                                                                                                                                                                                                                                                                                  NewExternalUpgradeSeriesAPI can be used for API registration.

                                                                                                                                                                                                                                                                                                                                                                  func NewUpgradeSeriesAPI

                                                                                                                                                                                                                                                                                                                                                                  func NewUpgradeSeriesAPI(
                                                                                                                                                                                                                                                                                                                                                                  	backend UpgradeSeriesBackend,
                                                                                                                                                                                                                                                                                                                                                                  	resources facade.Resources,
                                                                                                                                                                                                                                                                                                                                                                  	authorizer facade.Authorizer,
                                                                                                                                                                                                                                                                                                                                                                  	accessMachine GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                                                  	accessUnit GetAuthFunc,
                                                                                                                                                                                                                                                                                                                                                                  	logger loggo.Logger,
                                                                                                                                                                                                                                                                                                                                                                  ) *UpgradeSeriesAPI

                                                                                                                                                                                                                                                                                                                                                                    NewUpgradeSeriesAPI returns a new UpgradeSeriesAPI. Currently both GetAuthFuncs can used to determine current permissions.

                                                                                                                                                                                                                                                                                                                                                                    func (*UpgradeSeriesAPI) GetMachine

                                                                                                                                                                                                                                                                                                                                                                    func (u *UpgradeSeriesAPI) GetMachine(tag names.Tag) (UpgradeSeriesMachine, error)

                                                                                                                                                                                                                                                                                                                                                                    func (*UpgradeSeriesAPI) SetUpgradeSeriesUnitStatus

                                                                                                                                                                                                                                                                                                                                                                    func (u *UpgradeSeriesAPI) SetUpgradeSeriesUnitStatus(
                                                                                                                                                                                                                                                                                                                                                                    	args params.UpgradeSeriesStatusParams,
                                                                                                                                                                                                                                                                                                                                                                    ) (params.ErrorResults, error)

                                                                                                                                                                                                                                                                                                                                                                      SetUpgradeSeriesUnitStatus sets the upgrade series status of the unit. If no upgrade is in progress an error is returned instead.

                                                                                                                                                                                                                                                                                                                                                                      func (*UpgradeSeriesAPI) UpgradeSeriesUnitStatus

                                                                                                                                                                                                                                                                                                                                                                      func (u *UpgradeSeriesAPI) UpgradeSeriesUnitStatus(args params.Entities) (params.UpgradeSeriesStatusResults, error)

                                                                                                                                                                                                                                                                                                                                                                        UpgradeSeriesUnitStatus returns the current preparation status of an upgrading unit. If no series upgrade is in progress an error is returned instead.

                                                                                                                                                                                                                                                                                                                                                                        func (*UpgradeSeriesAPI) WatchUpgradeSeriesNotifications

                                                                                                                                                                                                                                                                                                                                                                        func (u *UpgradeSeriesAPI) WatchUpgradeSeriesNotifications(args params.Entities) (params.NotifyWatchResults, error)

                                                                                                                                                                                                                                                                                                                                                                          WatchUpgradeSeriesNotifications returns a NotifyWatcher for observing changes to upgrade series locks.

                                                                                                                                                                                                                                                                                                                                                                          type UpgradeSeriesBackend

                                                                                                                                                                                                                                                                                                                                                                          type UpgradeSeriesBackend interface {
                                                                                                                                                                                                                                                                                                                                                                          	Machine(string) (UpgradeSeriesMachine, error)
                                                                                                                                                                                                                                                                                                                                                                          	Unit(string) (UpgradeSeriesUnit, error)
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                          type UpgradeSeriesMachine

                                                                                                                                                                                                                                                                                                                                                                          type UpgradeSeriesMachine interface {
                                                                                                                                                                                                                                                                                                                                                                          	WatchUpgradeSeriesNotifications() (state.NotifyWatcher, error)
                                                                                                                                                                                                                                                                                                                                                                          	Units() ([]UpgradeSeriesUnit, error)
                                                                                                                                                                                                                                                                                                                                                                          	UpgradeSeriesStatus() (model.UpgradeSeriesStatus, error)
                                                                                                                                                                                                                                                                                                                                                                          	SetUpgradeSeriesStatus(model.UpgradeSeriesStatus, string) error
                                                                                                                                                                                                                                                                                                                                                                          	StartUpgradeSeriesUnitCompletion(string) error
                                                                                                                                                                                                                                                                                                                                                                          	UpgradeSeriesUnitStatuses() (map[string]state.UpgradeSeriesUnitStatus, error)
                                                                                                                                                                                                                                                                                                                                                                          	RemoveUpgradeSeriesLock() error
                                                                                                                                                                                                                                                                                                                                                                          	UpgradeSeriesTarget() (string, error)
                                                                                                                                                                                                                                                                                                                                                                          	Series() string
                                                                                                                                                                                                                                                                                                                                                                          	UpdateMachineSeries(series string, force bool) error
                                                                                                                                                                                                                                                                                                                                                                          	SetInstanceStatus(status.StatusInfo) error
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            UpgradeSeriesMachine describes machine-receiver state methods for executing a series upgrade.

                                                                                                                                                                                                                                                                                                                                                                            type UpgradeSeriesState

                                                                                                                                                                                                                                                                                                                                                                            type UpgradeSeriesState struct {
                                                                                                                                                                                                                                                                                                                                                                            	St *state.State
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              UpgradeSeriesState implements the UpgradeSeriesBackend indirection over state.State.

                                                                                                                                                                                                                                                                                                                                                                              func (UpgradeSeriesState) Machine

                                                                                                                                                                                                                                                                                                                                                                              func (UpgradeSeriesState) Unit

                                                                                                                                                                                                                                                                                                                                                                              type UpgradeSeriesUnit

                                                                                                                                                                                                                                                                                                                                                                              type UpgradeSeriesUnit interface {
                                                                                                                                                                                                                                                                                                                                                                              	Tag() names.Tag
                                                                                                                                                                                                                                                                                                                                                                              	AssignedMachineId() (string, error)
                                                                                                                                                                                                                                                                                                                                                                              	UpgradeSeriesStatus() (model.UpgradeSeriesStatus, error)
                                                                                                                                                                                                                                                                                                                                                                              	SetUpgradeSeriesStatus(model.UpgradeSeriesStatus, string) error
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                UpgradeSeriesUnit describes unit-receiver state methods for executing a series upgrade.

                                                                                                                                                                                                                                                                                                                                                                                type ValueResource

                                                                                                                                                                                                                                                                                                                                                                                type ValueResource struct {
                                                                                                                                                                                                                                                                                                                                                                                	Value interface{}
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  ValueResource is a Resource with a no-op Stop method, containing an interface{} value.

                                                                                                                                                                                                                                                                                                                                                                                  func (ValueResource) Stop

                                                                                                                                                                                                                                                                                                                                                                                  func (r ValueResource) Stop() error

                                                                                                                                                                                                                                                                                                                                                                                  Directories

                                                                                                                                                                                                                                                                                                                                                                                  Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                  Package mocks is a generated GoMock package.
                                                                                                                                                                                                                                                                                                                                                                                  Package mocks is a generated GoMock package.
                                                                                                                                                                                                                                                                                                                                                                                  mocks
                                                                                                                                                                                                                                                                                                                                                                                  Package mocks is a generated GoMock package.
                                                                                                                                                                                                                                                                                                                                                                                  Package mocks is a generated GoMock package.
                                                                                                                                                                                                                                                                                                                                                                                  Package storagecommon provides common storage-related services for API server facades.
                                                                                                                                                                                                                                                                                                                                                                                  Package storagecommon provides common storage-related services for API server facades.