// NewState returns a version of the state that provides functionality // required by agent code. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, "Agent") return &State{ facade: facadeCaller, ModelWatcher: common.NewModelWatcher(facadeCaller), } }
// NewState creates a new client-side Machiner facade. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, provisionerFacade) return &State{ ModelWatcher: common.NewModelWatcher(facadeCaller), APIAddresser: common.NewAPIAddresser(facadeCaller), facade: facadeCaller} }
// NewState creates a new client-side Firewaller facade. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, firewallerFacade) return &State{ facade: facadeCaller, EnvironWatcher: common.NewEnvironWatcher(facadeCaller), } }
// NewFacade returns a Facade backed by the supplied api caller. func NewFacade(apiCaller base.APICaller, newWatcher NewWatcherFunc) *Facade { facadeCaller := base.NewFacadeCaller(apiCaller, "MigrationFlag") return &Facade{ caller: facadeCaller, newWatcher: newWatcher, } }
// NewFacade returns a new api client facade instance. func NewFacade(caller base.APICaller) *Facade { facadeCaller := base.NewFacadeCaller(caller, apiName) return &Facade{ EnvironWatcher: common.NewEnvironWatcher(facadeCaller), ToolsVersionUpdater: NewToolsVersionUpdater(facadeCaller), } }
// NewState returns a version of the state that provides functionality // required by the reboot worker. func NewState(caller base.APICaller, machineTag names.MachineTag) *State { return &State{ facade: base.NewFacadeCaller(caller, "Reboot"), machineTag: machineTag, } }
// NewState creates a new client-side Firewaller API facade. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, firewallerFacade) return &State{ facade: facadeCaller, ModelWatcher: common.NewModelWatcher(facadeCaller), CloudSpecAPI: cloudspec.NewCloudSpecAPI(facadeCaller), } }
// NewAPI creates a new client-side Addresser facade. func NewAPI(caller base.APICaller) *API { if caller == nil { panic("caller is nil") } return &API{ facade: base.NewFacadeCaller(caller, addresserFacade), } }
// NewState creates a new client-side Machiner facade. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, machinerFacade) return &State{ facade: facadeCaller, APIAddresser: common.NewAPIAddresser(facadeCaller), } }
// NewState creates a new client-side Uniter facade. func NewState(caller base.APICaller, authTag names.UnitTag) *State { facadeCaller := base.NewFacadeCaller(caller, uniterFacade) return &State{ EnvironWatcher: common.NewEnvironWatcher(facadeCaller), APIAddresser: common.NewAPIAddresser(facadeCaller), facade: facadeCaller, unitTag: authTag, } }
// NewAPI creates a new facade. func NewAPI(caller base.APICaller) *API { if caller == nil { panic("caller is nil") } facadeCaller := base.NewFacadeCaller(caller, discoverspacesFacade) return &API{ facade: facadeCaller, } }
// NewState returns a version of the state that provides functionality // required by agent code. func NewState(caller base.APICaller) *State { facadeCaller := base.NewFacadeCaller(caller, "Agent") return &State{ facade: facadeCaller, ModelWatcher: common.NewModelWatcher(facadeCaller), CloudSpecAPI: cloudspec.NewCloudSpecAPI(facadeCaller), ControllerConfigAPI: common.NewControllerConfig(facadeCaller), } }
func newLastSentTracker(sink string, caller base.APICaller) *lastSentTracker { client := logfwdapi.NewLastSentClient(func(name string) logfwdapi.FacadeCaller { return base.NewFacadeCaller(caller, name) }) return &lastSentTracker{ sink: sink, client: client, } }
// NewAPI creates a new client-side InstancePoller facade. func NewAPI(caller base.APICaller) *API { if caller == nil { panic("caller is nil") } facadeCaller := base.NewFacadeCaller(caller, instancePollerFacade) return &API{ EnvironWatcher: common.NewEnvironWatcher(facadeCaller), facade: facadeCaller, } }
// NewState creates a new client-side StorageProvisioner facade. func NewState(caller base.APICaller, scope names.Tag) (*State, error) { switch scope.(type) { case names.ModelTag: case names.MachineTag: default: return nil, errors.Errorf("expected ModelTag or MachineTag, got %T", scope) } facadeCaller := base.NewFacadeCaller(caller, storageProvisionerFacade) return &State{facadeCaller, scope}, nil }
// NewClient creates a new client for accessing the metricsmanager api func NewClient(apiCaller base.APICaller) (*Client, error) { modelTag, err := apiCaller.ModelTag() if err != nil { return nil, errors.Trace(err) } facade := base.NewFacadeCaller(apiCaller, "MetricsManager") return &Client{ modelTag: modelTag, facade: facade, }, nil }
// NewClient creates a new client for accessing the undertaker API. func NewClient(caller base.APICaller, newWatcher NewWatcherFunc) (*Client, error) { modelTag, ok := caller.ModelTag() if !ok { return nil, errors.New("undertaker client is not appropriate for controller-only API") } return &Client{ modelTag: modelTag, caller: base.NewFacadeCaller(caller, "Undertaker"), newWatcher: newWatcher, }, nil }
// NewClient creates a new client for accessing the undertaker API. func NewClient(caller base.APICaller, newWatcher NewWatcherFunc) (*Client, error) { modelTag, err := caller.ModelTag() if err != nil { return nil, errors.Trace(err) } return &Client{ modelTag: modelTag, caller: base.NewFacadeCaller(caller, "Undertaker"), newWatcher: newWatcher, }, nil }
// NewAPI creates a new client-side machine undertaker facade. func NewAPI(caller base.APICaller, newWatcher NewWatcherFunc) (*API, error) { modelTag, ok := caller.ModelTag() if !ok { return nil, errors.New("machine undertaker client requires a model API connection") } api := API{ facade: base.NewFacadeCaller(caller, "MachineUndertaker"), modelTag: modelTag, newWatcher: newWatcher, } return &api, nil }
// NewClient creates a new client for accessing the metricsmanager api func NewClient(apiCaller base.APICaller) (*Client, error) { modelTag, ok := apiCaller.ModelTag() if !ok { return nil, errors.New("metricsmanager client is not appropriate for controller-only API") } facade := base.NewFacadeCaller(apiCaller, "MetricsManager") return &Client{ modelTag: modelTag, facade: facade, }, nil }
// NewAPI returns a new api client facade instance. func NewAPI(caller base.APICaller, tag names.Tag) (*API, error) { if caller == nil { return nil, fmt.Errorf("caller is nil") } if tag == nil { return nil, fmt.Errorf("tag is nil") } return &API{ facade: base.NewFacadeCaller(caller, proxyUpdaterFacade), tag: tag, }, nil }
// NewState creates a new client-side StorageProvisioner facade. func NewState(caller base.APICaller, scope names.Tag) *State { switch scope.(type) { case names.EnvironTag: case names.MachineTag: default: panic(errors.Errorf("expected EnvironTag or MachineTag, got %T", scope)) } facadeCaller := base.NewFacadeCaller(caller, storageProvisionerFacade) return &State{ facadeCaller, scope, common.NewEnvironWatcher(facadeCaller), } }
// NewAPI returns a new API client for the Singular facade. It exposes methods // for claiming and observing administration responsibility for the apiCaller's // model, on behalf of the supplied controller machine. func NewAPI(apiCaller base.APICaller, controllerTag names.MachineTag) (*API, error) { controllerId := controllerTag.Id() if !names.IsValidMachine(controllerId) { return nil, errors.NotValidf("controller tag") } modelTag, err := apiCaller.ModelTag() if err != nil { return nil, errors.Trace(err) } facadeCaller := base.NewFacadeCaller(apiCaller, "Singular") return &API{ modelTag: modelTag, controllerTag: controllerTag, facadeCaller: facadeCaller, }, nil }
// NewAPI returns a new API client for the Singular facade. It exposes methods // for claiming and observing administration responsibility for the apiCaller's // model, on behalf of the supplied controller machine. func NewAPI(apiCaller base.APICaller, controllerTag names.MachineTag) (*API, error) { controllerId := controllerTag.Id() if !names.IsValidMachine(controllerId) { return nil, errors.NotValidf("controller tag") } modelTag, ok := apiCaller.ModelTag() if !ok { return nil, errors.New("cannot use singular API on controller-only connection") } facadeCaller := base.NewFacadeCaller(apiCaller, "Singular") return &API{ modelTag: modelTag, controllerTag: controllerTag, facadeCaller: facadeCaller, }, nil }
// NewState returns a version of the state that provides functionality required by the worker. func NewState(caller base.APICaller) *State { return &State{base.NewFacadeCaller(caller, "KeyUpdater")} }
// NewClient creates a new client for accessing the metricsadder API. func NewClient(caller base.APICaller) *Client { return &Client{facade: base.NewFacadeCaller(caller, "MetricsAdder")} }
// NewClient returns a new Client based on an existing API connection. func NewClient(caller base.APICaller) Client { return &client{base.NewFacadeCaller(caller, "MigrationMaster")} }
// NewState returns a version of the state that provides functionality // required by the upgrader worker. func NewState(caller base.APICaller) *State { return &State{base.NewFacadeCaller(caller, "Upgrader")} }
// NewClient returns a new Client based on an existing API connection. func NewClient(caller base.APICaller) *Client { return &Client{base.NewFacadeCaller(caller, "MigrationTarget")} }
// NewFacade returns a new Facade based on an existing API connection. func NewFacade(caller base.APICaller) *Facade { return &Facade{base.NewFacadeCaller(caller, "SSHClient")} }