base

package
v0.0.0-...-4bd6544 Latest Latest
Warning

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

Go to latest
Published: Oct 5, 2016 License: AGPL-3.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewClientFacade

func NewClientFacade(caller APICallCloser, facadeName string) (ClientFacade, FacadeCaller)

NewClientFacade prepares a client-facing facade for work against the API. It is expected that most client-facing facades will embed a ClientFacade and will use a FacadeCaller so this function returns both.

Types

type APICallCloser

type APICallCloser interface {
	APICaller

	// Close is used when we have finished with this connection.
	Close() error
}

APICallCloser is the same as APICaller, but also provides a Close() method for when we are done with this connection.

type APICaller

type APICaller interface {
	// APICall makes a call to the API server with the given object type,
	// id, request and parameters. The response is filled in with the
	// call's result if the call is successful.
	APICall(objType string, version int, id, request string, params, response interface{}) error

	// BestFacadeVersion returns the newest version of 'objType' that this
	// client can use with the current API server.
	BestFacadeVersion(facade string) int

	// ModelTag returns the tag of the model the client is connected
	// to if there is one. It returns false for a controller-only connection.
	ModelTag() (names.ModelTag, bool)

	// HTTPClient returns an httprequest.Client that can be used
	// to make HTTP requests to the API. URLs passed to the client
	// will be made relative to the API host and the current model.
	//
	// Note that the URLs in HTTP requests passed to the Client.Do
	// method should not include a host part.
	HTTPClient() (*httprequest.Client, error)

	StreamConnector
}

APICaller is implemented by the client-facing State object. It defines the lowest level of API calls and is used by the various API implementations to actually make the calls to the API. It should not be used outside of tests or the api/* hierarchy.

type ClientFacade

type ClientFacade interface {
	// BestAPIVersion returns the API version that we were able to
	// determine is supported by both the client and the API Server
	BestAPIVersion() int

	// Close the connection to the API server.
	Close() error
}

ClientFacade should be embedded by client-side facades that are intended as "client" (aka user facing) facades versus agent facing facades. They provide two common methods for writing the client side code. BestAPIVersion() is used to allow for compatibility testing, and Close() is used to indicate when we are done with the connection.

type FacadeCaller

type FacadeCaller interface {
	// FacadeCall will place a request against the API using the requested
	// Facade and the best version that the API server supports that is
	// also known to the client.
	FacadeCall(request string, params, response interface{}) error

	// Name returns the facade name.
	Name() string

	// BestAPIVersion returns the API version that we were able to
	// determine is supported by both the client and the API Server
	BestAPIVersion() int

	// RawAPICaller returns the wrapped APICaller. This can be used if you need
	// to switch what Facade you are calling (such as Facades that return
	// Watchers and then need to use the Watcher facade)
	RawAPICaller() APICaller
}

FacadeCaller is a wrapper for the common paradigm that a given client just wants to make calls on a facade using the best known version of the API. And without dealing with an id parameter.

func NewFacadeCaller

func NewFacadeCaller(caller APICaller, facadeName string) FacadeCaller

NewFacadeCaller wraps an APICaller for a given facade name and the best available version.

func NewFacadeCallerForVersion

func NewFacadeCallerForVersion(caller APICaller, facadeName string, version int) FacadeCaller

NewFacadeCallerForVersion wraps an APICaller for a given facade name and version.

type Machine

type Machine struct {
	Id         string
	InstanceId string
	HasVote    bool
	WantsVote  bool
	Status     string
	Hardware   *instance.HardwareCharacteristics
}

Machine holds information about a machine in a juju model.

type ModelInfo

type ModelInfo struct {
	Name            string
	UUID            string
	ControllerUUID  string
	ProviderType    string
	DefaultSeries   string
	Cloud           string
	CloudRegion     string
	CloudCredential string
	Owner           string
	Life            string
	Status          Status
	Users           []UserInfo
	Machines        []Machine
}

ModelInfo holds information about a model.

type ModelStatus

type ModelStatus struct {
	UUID               string
	Life               string
	Owner              string
	TotalMachineCount  int
	CoreCount          int
	HostedMachineCount int
	ServiceCount       int
	Machines           []Machine
}

ModelStatus holds information about the status of a juju model.

type Status

type Status struct {
	Status status.Status
	Info   string
	Data   map[string]interface{}
	Since  *time.Time
}

Status represents the status of a machine, application, or unit.

type Stream

type Stream interface {
	io.ReadWriteCloser

	// WriteJSON encodes the given value as JSON
	// and writes it to the connection.
	WriteJSON(v interface{}) error

	// ReadJSON reads a JSON value from the stream
	// and decodes it into the element pointed to by
	// the given value, which should be a pointer.
	ReadJSON(v interface{}) error
}

Stream represents a streaming connection to the API.

type StreamConnector

type StreamConnector interface {
	// ConnectStream connects to the given HTTP websocket
	// endpoint path (interpreted relative to the receiver's
	// model) and returns the resulting connection.
	// The given parameters are used as URL query values
	// when making the initial HTTP request.
	//
	// The path must start with a "/".
	ConnectStream(path string, attrs url.Values) (Stream, error)
}

StreamConnector is implemented by the client-facing State object.

type UserInfo

type UserInfo struct {
	UserName       string
	DisplayName    string
	LastConnection *time.Time
	Access         string
}

UserInfo holds information about a user in a juju model.

type UserModel

type UserModel struct {
	Name           string
	UUID           string
	Owner          string
	LastConnection *time.Time
}

UserModel holds information about a model and the last time the model was accessed for a particular user. This is a client side structure that translates the owner tag into a user facing string.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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