common

package
Version: v0.0.0-...-2608902 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 25, 2016 License: AGPL-3.0 Imports: 33 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	ErrBadId              = errors.New("id not found")
	ErrBadCreds           = errors.New("invalid entity name or password")
	ErrPerm               = errors.New("permission denied")
	ErrNotLoggedIn        = errors.New("not logged in")
	ErrUnknownWatcher     = errors.New("unknown watcher id")
	ErrUnknownPinger      = errors.New("unknown pinger id")
	ErrStoppedWatcher     = errors.New("watcher has been stopped")
	ErrBadRequest         = errors.New("invalid request")
	ErrTryAgain           = errors.New("try again")
	ErrActionNotAvailable = errors.New("action no longer available")
)
View Source
var DefaultHTTPMethods = []string{"GET", "POST", "HEAD", "PUT", "DEL", "OPTIONS"}

DefaultHTTPMethods are the HTTP methods supported by default by the API.

View Source
var ErrIsNotLeader = errors.Errorf("this unit is not the leader")

ErrIsNotLeader is an error for operations that require for a unit to be the leader but it was not the case. TODO(fwereade) why do we have an alternative implementation of ErrPerm that is exported (implying people will be able to meaningfully check it) but not actually handled anywhere or converted into an error code by the api server?

View Source
var Facades = &FacadeRegistry{}

Facades is the registry that tracks all of the Facades that will be exposed in the API. It can be used to List/Get/Register facades. Most implementers of a facade will probably want to use RegisterStandardFacade rather than Facades.Register, as it provides much cleaner syntax and semantics for calling during init().

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 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 DestroyErr

func DestroyErr(desc string, ids, errs []string) error

func DestroyMachines

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

func DestroyModel

func DestroyModel(st *state.State, modelTag names.ModelTag) error

DestroyModel sets the environment to dying. Cleanup jobs then destroy all services and non-manager, non-manual machine instances in the specified model. This function assumes that all necessary authentication checks have been done. An error will be returned if this model is a controller hosting other model.

func DestroyModelIncludingHosted

func DestroyModelIncludingHosted(st *state.State, modelTag names.ModelTag) error

DestroyModelIncludingHosted sets the model to dying. Cleanup jobs then destroy all services and non-manager, non-manual machine instances in the specified model. This function assumes that all necessary authentication checks have been done. If the model is a controller hosting other models, they will also be destroyed.

func EntityStatusFromState

func EntityStatusFromState(status 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 IsDischargeRequiredError

func IsDischargeRequiredError(err error) bool

IsDischargeRequiredError reports whether the cause of the error is a *DischargeRequiredError.

func IsUpgradeInProgressError

func IsUpgradeInProgressError(err error) bool

IsUpgradeInProgress returns true if this error is caused by an upgrade in progress.

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 ModelUserInfo

func ModelUserInfo(user ModelUser) (params.ModelUserInfo, error)

ModelUserInfo converts *state.ModelUser to params.ModelUserInfo.

func NewToolsURLGetter

func NewToolsURLGetter(modelUUID string, a APIHostPortsGetter) *toolsURLGetter

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

func NoAddressSetError

func NoAddressSetError(unitTag names.UnitTag, addressName string) error

func NotSupportedError

func NotSupportedError(tag names.Tag, operation string) error

func OperationBlockedError

func OperationBlockedError(msg string) error

OperationBlockedError returns an error which signifies that an operation has been blocked; the message should describe what has been blocked.

func ParamsActionExecutionResultsToStateActionResults

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

ParamsActionExecutionResultsToStateActionResults does exactly what the name implies.

func RegisterAPIModelEndpoint

func RegisterAPIModelEndpoint(pattern string, spec apihttp.HandlerSpec) error

RegisterAPIModelEndpoint adds the provided endpoint to the registry. The pattern is prefixed with the model pattern: /model/:modeluuid.

func RegisterFacade

func RegisterFacade(name string, version int, factory FacadeFactory, facadeType reflect.Type)

RegisterFacade updates the global facade registry with a new version of a new type.

func RegisterFacadeForFeature

func RegisterFacadeForFeature(name string, version int, factory FacadeFactory, facadeType reflect.Type, feature string)

RegisterFacadeForFeature updates the global facade registry with a new version of a new type. If the feature is non-empty, this facade is only available when the specified feature flag is set.

func RegisterHookContextFacade

func RegisterHookContextFacade(name string, version int, newHookContextFacade NewHookContextFacadeFn, facadeType reflect.Type)

RegisterHookContextFacade registers facades for use within a hook context. This function handles the translation from a hook-context-facade to a standard facade so the caller's factory method can elide unnecessary arguments. This function also handles any necessary authorization for the client.

func RegisterStandardFacade

func RegisterStandardFacade(name string, version int, newFunc interface{})

RegisterStandardFacade registers a factory function for a normal New* style function. This requires that the function has the form: NewFoo(*state.State, *common.Resources, common.Authorizer) (*Type, error) With that syntax, we will create a helper function that wraps calling NewFoo with the right parameters, and returns the *Type correctly.

func RegisterStandardFacadeForFeature

func RegisterStandardFacadeForFeature(name string, version int, newFunc interface{}, feature string)

RegisterStandardFacadeForFeature registers a factory function for a normal New* style function. This requires that the function has the form: NewFoo(*state.State, *common.Resources, common.Authorizer) (*Type, error) With that syntax, we will create a helper function that wraps calling NewFoo with the right parameters, and returns the *Type correctly. If the feature is non-empty, this facade is only available when the specified feature flag is set.

func ResolveAPIEndpoints

func ResolveAPIEndpoints(newArgs func(apihttp.HandlerConstraints) apihttp.NewHandlerArgs) []apihttp.Endpoint

ResolveAPIEndpoints builds the set of endpoint handlers for all registered API endpoints.

func RestoreError

func RestoreError(err error) error

RestoreError makes a best effort at converting the given error back into an error originally converted by ServerError().

func ServerError

func ServerError(err error) *params.Error

ServerError returns an error suitable for returning to an API client, with an error code suitable for various kinds of errors generated in packages outside the API.

func ServerErrorAndStatus

func ServerErrorAndStatus(err error) (*params.Error, int)

ServerErrorAndStatus is like ServerError but also returns an HTTP status code appropriate for using in a response holding the given error.

func StateJobs

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

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

func StateToParamsModelAccess

func StateToParamsModelAccess(stateAccess state.ModelAccess) (params.ModelAccessPermission, error)

StateToParamsModelAccess converts state.ModelAccess to params.ModelAccessPermission.

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 UnknownModelError

func UnknownModelError(uuid string) error

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 Resource) string) func(names.Tag) (params.StringsWatchResult, error)

WatchOneActionReceiverNotifications to create a watcher 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 APIAddresser

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

APIAddresser implements the APIAddresses method

func NewAPIAddresser

func NewAPIAddresser(getter AddressAndCertGetter, resources *Resources) *APIAddresser

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

func (*APIAddresser) APIAddresses

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

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

func (*APIAddresser) APIHostPorts

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

APIHostPorts returns the API server addresses.

func (*APIAddresser) CACert

func (a *APIAddresser) CACert() params.BytesResult

CACert returns the certificate used to validate the state connection.

func (*APIAddresser) ModelUUID

func (a *APIAddresser) ModelUUID() params.StringResult

ModelUUID returns the model UUID to connect to the environment that the current connection is for.

func (*APIAddresser) WatchAPIHostPorts

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

WatchAPIHostPorts watches the API server addresses.

type APIHostPortsGetter

type APIHostPortsGetter interface {
	// APIHostPorst returns the HostPorts for each API server.
	APIHostPorts() ([][]network.HostPort, error)
}

APIHostPortsGetter is an interface providing the APIHostPorts method.

type AddressAndCertGetter

type AddressAndCertGetter interface {
	Addresses() ([]string, error)
	APIAddressesFromMachines() ([]string, error)
	CACert() string
	ModelUUID() string
	APIHostPorts() ([][]network.HostPort, error)
	WatchAPIHostPorts() state.NotifyWatcher
}

AddressAndCertGetter can be used to find out controller addresses and the CA public certificate.

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 *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 AuthFunc

type AuthFunc func(tag names.Tag) bool

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

type Authorizer

type Authorizer interface {
	// AuthMachineAgent returns whether the authenticated entity is a
	// machine agent.
	AuthMachineAgent() bool

	// AuthUnitAgent returns whether the authenticated entity is a
	// unit agent.
	AuthUnitAgent() bool

	// AuthOwner returns whether the authenticated entity is the same
	// as the given entity.
	AuthOwner(tag names.Tag) bool

	// AuthModelManager returns whether the authenticated entity is
	// a machine running the environment manager job.
	AuthModelManager() bool

	// AuthClient returns whether the authenticated entity
	// is a client user.
	AuthClient() bool

	// GetAuthTag returns the tag of the authenticated entity.
	GetAuthTag() names.Tag
}

Authorizer represents a value that can be asked for authorization information on its associated authenticated entity. It is implemented by an API server to allow an API implementation to ask questions about the client that is currently connected.

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 environment 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 environment.

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 environment.

type BlockGetter

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

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, 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 DischargeRequiredError

type DischargeRequiredError struct {
	Cause    error
	Macaroon *macaroon.Macaroon
}

DischargeRequiredError is the error returned when a macaroon requires discharging to complete authentication.

func (*DischargeRequiredError) Error

func (e *DischargeRequiredError) Error() string

Error implements the error interface.

type FacadeDescription

type FacadeDescription struct {
	Name     string
	Versions []int
}

FacadeDescription describes the name and what versions of a facade have been registered.

type FacadeFactory

type FacadeFactory func(
	st *state.State, resources *Resources, authorizer Authorizer, id string,
) (
	interface{}, error,
)

FacadeFactory represent a way of creating a Facade from the current connection to the State.

type FacadeRegistry

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

FacadeRegistry is responsible for tracking what Facades are going to be exported in the API. See the variable "Facades" for the singleton that tracks them. It would be possible to have multiple registries if we decide to change how the API exposes methods based on Login information.

func (*FacadeRegistry) Discard

func (f *FacadeRegistry) Discard(name string, version int)

Discard gets rid of a registration that has already been done. Calling discard on an entry that is not present is not considered an error.

func (*FacadeRegistry) GetFactory

func (f *FacadeRegistry) GetFactory(name string, version int) (FacadeFactory, error)

GetFactory returns just the FacadeFactory for a given Facade name and version. See also GetType for getting the type information instead of the creation factory.

func (*FacadeRegistry) GetType

func (f *FacadeRegistry) GetType(name string, version int) (reflect.Type, error)

GetType returns the type information for a given Facade name and version. This can be used for introspection purposes (to determine what methods are available, etc).

func (*FacadeRegistry) List

func (f *FacadeRegistry) List() []FacadeDescription

List returns a slice describing each of the registered Facades.

func (*FacadeRegistry) Register

func (f *FacadeRegistry) Register(name string, version int, factory FacadeFactory, facadeType reflect.Type, feature string) error

Register adds a single named facade at a given version to the registry. FacadeFactory will be called when someone wants to instantiate an object of this facade, and facadeType defines the concrete type that the returned object will be. The Type information is used to define what methods will be exported in the API, and it must exactly match the actual object returned by the factory.

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 AuthEither

func AuthEither(a, b GetAuthFunc) GetAuthFunc

AuthEither returns an AuthFunc generator that returns an AuthFunc that accepts any tag authorized by either of its arguments.

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.

func AuthNever

func AuthNever() GetAuthFunc

AuthNever returns an authentication function that never returns true.

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 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 {
	Life() state.Life
	ForceDestroy() error
	Destroy() error
}

type ModelConfigGetter

type ModelConfigGetter interface {
	ModelConfig() (*config.Config, error)
}

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 *Resources, authorizer Authorizer) *ModelMachinesWatcher

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

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 ModelUser

type ModelUser interface {
	Access() state.ModelAccess
	DisplayName() string
	LastConnection() (time.Time, error)
	UserName() string
	UserTag() names.UserTag
}

ModelUser defines the subset of the state.ModelUser type that we require to convert to a params.ModelUserInfo.

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 *Resources, authorizer 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, environment tags are not used, so both created AuthFuncs are called with "" for tag, which means "the current environment".

func (*ModelWatcher) ModelConfig

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

ModelConfig returns the current environment's configuration.

func (*ModelWatcher) WatchForModelConfigChanges

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

WatchForModelConfigChanges returns a NotifyWatcher that observes changes to the environment 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 NewHookContextFacadeFn

type NewHookContextFacadeFn func(*state.State, *state.Unit) (interface{}, error)

NewHookContextFacadeFn specifies the function signature that can be used to register a hook context facade.

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 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, 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 Resource

type Resource interface {
	Stop() error
}

Resource represents any resource that should be cleaned up when an API connection terminates. The Stop method will be called when that happens.

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) 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 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 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 ServiceStatusGetter

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

ServiceStatusGetter is a StatusGetter for combined service and unit statuses. TODO(fwereade) this is completely evil and should never have been created. We have a perfectly adequate StatusGetter already, that accepts bulk args; all this does is break the user model, break the api model, and lie about unit statuses).

func NewServiceStatusGetter

func NewServiceStatusGetter(st *state.State, getCanAccess GetAuthFunc) *ServiceStatusGetter

NewServiceStatusGetter returns a ServiceStatusGetter.

func (*ServiceStatusGetter) Status

Status returns the status of the Service for each given Unit tag.

type ServiceStatusSetter

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

ServiceStatusSetter implements a SetServiceStatus method to be used by facades that can change a service status. This is only slightly less evil than ServiceStatusGetter. 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 NewServiceStatusSetter

func NewServiceStatusSetter(st *state.State, getCanModify GetAuthFunc) *ServiceStatusSetter

NewServiceStatusSetter returns a ServiceStatusSetter.

func (*ServiceStatusSetter) SetStatus

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

type StateAddresser

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

StateAddresser implements a common set of methods for getting state server addresses, and the CA certificate used to authenticate them.

func NewStateAddresser

func NewStateAddresser(getter AddressAndCertGetter) *StateAddresser

NewStateAddresser returns a new StateAddresser that uses the given st value to fetch its addresses.

func (*StateAddresser) StateAddresses

func (a *StateAddresser) StateAddresses() (params.StringsResult, error)

StateAddresses returns the list of addresses used to connect to the state.

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 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 *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 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 storagecommon provides common storage-related services for API server facades.
Package storagecommon provides common storage-related services for API server facades.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL