// 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")}
}