web

type API ¶

type API struct {
	// Controllers contains the registered controllers
	Controllers []Controller

	// Filters contains the registered filters
	Filters []Filter

	// Registry is the health indicators registry for this API
	health.Registry
}

API is the primary point for REST API registration

func (api *API) RegisterControllers(controllers ...Controller)

func (api *API) RegisterFilters(filters ...Filter)

func (api *API) RegisterFiltersAfter(afterFilterName string, filters ...Filter)

func (api *API) RegisterFiltersBefore(beforeFilterName string, filters ...Filter)

func (api *API) RegisterPlugins(plugins ...Plugin)

func (api *API) RemoveFilter(name string)

func (api *API) ReplaceFilter(replacedFilterName string, filter Filter)

type Binder ¶

type Binder interface {
	Plugin

	Bind(request *Request, next Handler) (*Response, error)
}

Binder should be implemented by plugins that need to intercept OSB call for bind service operation

type BindingFetcher ¶

type BindingFetcher interface {
	Plugin

	FetchBinding(request *Request, next Handler) (*Response, error)
}

BindingFetcher should be implemented by plugins that need to intercept OSB call for unbind service operation

type BindingPoller ¶

type BindingPoller interface {
	Plugin

	PollBinding(request *Request, next Handler) (*Response, error)
}

BindingPoller should be implemented by plugins that need to intercept OSB Calls for polling last operation for service bindings

type CatalogFetcher ¶

type CatalogFetcher interface {
	Plugin

	FetchCatalog(request *Request, next Handler) (*Response, error)
}

CatalogFetcher should be implemented by plugins that need to intercept OSB call for get catalog operation

type Controller ¶

type Controller interface {
	// Routes returns the set of routes for this controller
	Routes() []Route
}

Controller is an entity that wraps a set of HTTP Routes

type CredentialsAdapter ¶ added in v0.1.5

type CredentialsAdapter interface {
	Plugin

	AdaptCredentials(request *Request, next Handler) (*Response, error)
}

type Data ¶ added in v0.1.6

type Data interface {
	// Data reads the additional data from the context into the specified struct
	Data(v interface{}) error
}

type Deprovisioner ¶

type Deprovisioner interface {
	Plugin

	Deprovision(request *Request, next Handler) (*Response, error)
}

Deprovisioner should be implemented by plugins that need to intercept OSB call for deprovision operation

type Endpoint ¶

type Endpoint struct {
	Method string
	Path   string
}

Endpoint is a combination of a Path and an HTTP Method

type Filter ¶

type Filter interface {
	Named
	Middleware

	// FilterMatchers Returns a set of FilterMatchers each containing a set of Matchers. Each FilterMatcher represents
	// one place where the Filter would run.
	FilterMatchers() []FilterMatcher
}

Filter is an interface that Named Middlewares that should satisfy a set of Matchers (conditions) should implement.

type FilterMatcher ¶

type FilterMatcher struct {
	// Matchers represents a set of conditions that need to be matched
	Matchers []Matcher
}

FilterMatcher type represents a set of conditions (Matchers) that need to match if order for a FilterMatcher to match

type Filters ¶

type Filters []Filter

Filters represents a slice of Filter elements

func (fs Filters) Chain(h Handler) Handler

func (fs Filters) ChainMatching(route Route) Handler

func (fs Filters) Matching(endpoint Endpoint) Filters

type Handler ¶

type Handler interface {
	// Handle processes a Request and returns a corresponding Response or error
	Handle(req *Request) (resp *Response, err error)
}

Handler is an interface that objects can implement to be registered in the SM REST API.

type HandlerFunc ¶

type HandlerFunc func(req *Request) (resp *Response, err error)

HandlerFunc is an adapter that allows to use regular functions as Handler interface implementations.

func (rhf HandlerFunc) Handle(req *Request) (resp *Response, err error)

type InstancePoller ¶

type InstancePoller interface {
	Plugin

	PollInstance(request *Request, next Handler) (*Response, error)
}

InstancePoller should be implemented by plugins that need to intercept OSB calls for polling last operation for service instances

type Matcher ¶

type Matcher interface {
	// Matches matches a route against a particular condition
	Matches(endpoint Endpoint) (bool, error)
}

Matcher allows checking whether an Endpoint matches a particular condition

func Methods(methods ...string) Matcher

func Path(patterns ...string) Matcher

type MatcherFunc ¶

type MatcherFunc func(endpoint Endpoint) (bool, error)

MatcherFunc is an adapter that allows regular functions to act as Matchers

func (m MatcherFunc) Matches(endpoint Endpoint) (bool, error)

type Middleware ¶

type Middleware interface {
	// Run returns a handler that contains the handling logic of the Middleware. The implementation of Run
	// should invoke next's Handle if the request should be chained to the next Handler.
	// It may also terminate the request by not invoking the next Handler.
	Run(req *Request, next Handler) (*Response, error)
}

Middleware is an interface that objects that should act as filters or plugins need to implement. It intercepts the request before reaching the final handler and allows during preprocessing and postprocessing.

type MiddlewareFunc ¶

type MiddlewareFunc func(req *Request, next Handler) (*Response, error)

MiddlewareFunc is an adapter that allows to use regular functions as Middleware

func (mf MiddlewareFunc) Run(req *Request, handler Handler) (*Response, error)

type Named ¶

type Named interface {
	// Name returns the string identifier for the object
	Name() string
}

Named is an interface that objects that need to be identified by a particular name should implement.

type Plugin ¶

type Plugin interface {
	Named
}

Plugin can intercept Service Manager operations and augment them with additional logic. To intercept SM operations a plugin implements one or more of the interfaces defined in this package.

type Provisioner ¶

type Provisioner interface {
	Plugin

	Provision(request *Request, next Handler) (*Response, error)
}

Provisioner should be implemented by plugins that need to intercept OSB call for provision operation

type Request ¶

type Request struct {
	// Request is the original http.Request
	*http.Request

	// PathParams contains the URL path parameters
	PathParams map[string]string

	// Body is the loaded request body (usually JSON)
	Body []byte
}

Request contains the original http.Request, path parameters and the raw body Request.Request.Body should not be used as it would be already processed by internal implementation

type Response ¶

type Response struct {
	// StatusCode is the HTTP status code
	StatusCode int

	// Header contains the response headers
	Header http.Header

	// Body is the response body (usually JSON)
	Body []byte
}

Response defines the attributes of the HTTP response that will be sent to the client

type Route ¶

type Route struct {
	// Endpoint is the combination of Path and HTTP Method for the specified route
	Endpoint Endpoint

	// Handler is the function that should handle incoming requests for this endpoint
	Handler HandlerFunc
}

Route is a mapping between an Endpoint and a REST API SMHandler

type ServiceFetcher ¶

type ServiceFetcher interface {
	Plugin

	FetchService(request *Request, next Handler) (*Response, error)
}

ServiceFetcher should be implemented by plugins that need to intercept OSB call for get service operation

type ServiceUpdater ¶

type ServiceUpdater interface {
	Plugin

	UpdateService(request *Request, next Handler) (*Response, error)
}

ServiceUpdater should be implemented by plugins that need to intercept OSB call for update service operation

type Unbinder ¶

type Unbinder interface {
	Plugin

	Unbind(request *Request, next Handler) (*Response, error)
}

Unbinder should be implemented by plugins that need to intercept OSB call for unbind service operation

type UserContext ¶ added in v0.1.6

type UserContext struct {
	Data

	Name string
}

UserContext holds the information for the current user

func UserFromContext(ctx context.Context) (*UserContext, bool)