usher

type APIGroup struct {

	// ParentGroup
	ParentGroup *APIGroup

	// APIName is the API partial for the resource (e.g. projects)
	APIName string

	// Kind is the type of the API resource (e.g. Project)
	Kind string
	// contains filtered or unexported fields
}

type AuthenticatorFunc func(ctx Context, id, secret string) (bool, Context)

type AuthorizationContext struct {

	// Subject is the entity that is performing the action.
	Subject string `json:"subject"`

	// These 3 fields together identify the entity on which
	// action is being performed.
	Kind    string      `json:"kind"`
	Name    string      `json:"name"`
	Parents []ParentRef `json:"parent"`

	// Action is the operation being performed on the object.
	Action string `json:"action"`
}

type AuthorizerFunc func(reqCtx Context, authCtx AuthorizationContext) bool

type ByName QueryClause

type ByOwner QueryClause

type ByState QueryClause

type Context context.Context

type ContextKey string

type Controller interface {

	// GetAll should fetch all the objects matching the given query. If
	// query fails for any reason, an appropriate error should be returned
	// in which case the first return value can be nil-pointer.
	// GetAll maps to `GET /{kind}?filter1=value&...`
	GetAll(query Query) (*[]Object, *Error)

	// Create should store the object. This matches to `POST /{kind}`
	// endpoints.
	Create(obj Object) (*Object, *Error)

	// Resource Operations
	// Get should return the object identifying the `id`. This maps
	// to `GET /{kind}/{name}` requests.
	Get(id ObjectID) (*Object, *Error)

	// Exists should return nil-pointer if an object exists which
	// can be identified using `id`. If the object is not found,
	// a not-found error should be returned. Other errors can be
	// returned, but note that, in some places all errors might
	// be considered as NotFound error.
	// This method maps to `HEAD /{kind}/{name}`
	Exists(id ObjectID) *Error

	// Update should replace the existing object identified by the
	// `id` by the newObject completely. Note that, fields (Kind,
	// Name, Parents, Meta) should never be changed for an object.
	// This method maps to `PUT /{kind}/{name}` request.
	Update(id ObjectID, newObject Object) (*Object, *Error)

	// PartialUpdate should partially update the object identified by
	// the `id`. Update should consider only the fields specified in
	// the `updates` array for modifications. Other fields should be
	// left untouched.
	// This method maps to `PATCH /{kind}/{name}`.
	PartialUpdate(id ObjectID, updates []UpdateClause) (*Object, *Error)

	// Delete should remove the resource from the server completely.
	// This method maps to `DELETE /{kind}/{name}`.
	Delete(id ObjectID) (*Object, *Error)
}

type Error struct {
	// Code is generally a 4xx or 5xx HTTP Standard code
	Code int `json:"code"`

	// Type is a single word, camel-cased name for the error. This helps in
	// differentiating between common error codes. For example, code can be
	// 400 to represent bad request and type name an be InvalidValue, InvalidType
	// MissingParameter etc.
	Type string `json:"type"`

	// Details provides any additional information abou the error. For example,
	// in case of MissingParameter error, details will contain the name of the
	// missing parameter.
	Details map[string]interface{} `json:"details"`

	// Message is a string which can be directly shown to user. This should
	// not contain any technical errors.
	Message string `json:"message"`

	// Err object if this struct was initialized in response to an `error`.
	Err error `json:"error,omitempty"`
}

type MapSpec map[string]interface{}

type Meta struct {

	// CreatedOn should contain the time of creation of this object.
	CreatedOn time.Time `json:"created_on"`

	// ModifiedOn should contain the time of last modification of this
	// object. While creating the object, this should be same as the
	// CreatedOn timestamp.
	ModifiedOn time.Time `json:"modified_on"`

	// Owner can be used to store information regarding the subject who
	// created the resource to which this meta is attached.
	Owner string `json:"owner"`

	// SelfURI contains self link to the resource
	SelfURI string `json:"self_uri"`
}

type Middleware func(h http.HandlerFunc) http.HandlerFunc

type NoOpController struct {
}

type Object struct {

	// ObjectID contains all the information required to uniquey and completely
	// identify an object in Usher.
	ObjectID `json:",inline"`

	// Meta is used to represent meta information about an object which
	// includes creation and modification timestamps, tags, parent information
	// etc.
	Meta `json:",inline"`

	// Tags can be used to store additional information for the object
	// which can later be used to filter search results.
	Tags Tags `json:"tags"`

	// State represents the state of object. State will not be used by
	// usher, but is a field to be used by usher applications.
	State string `json:"state"`

	// Spec should contain the specification for the object. This is the
	// field that actually describes the intent/data of the object. The
	// specification model registered with the resource will be used to
	// verify and populate this field. So, inside the controller, simple
	// assertion will be enough without error handling to load this to
	// a variable of that type.
	Spec Spec `json:"spec"`
}

type ObjectID struct {
	// Kind represents the type of the object. Kind will be CamelCased.
	// API name for a kind will be generated by converting it to plural.
	// For example, for kind `Test` the api endpoint will be `/tests`.
	// Look at ToAPIName() and ToKindName() for information on how the
	// conversion is done.
	Kind string `json:"kind"`

	// Name represents a unique name for the object. Name is not
	// exclusively unique. Name will be unique in a (Kind, Parents)
	// scope.
	Name string `json:"name"`

	// Parents represents all the logical parents of this resource. The
	// array is ordered according to the hierarchy of APIGroups.
	Parents ParentRefs `json:"parents"`
}

type ParentRef struct {
	Kind string `json:"kind"`
	Name string `json:"name"`
}

type ParentRefs []ParentRef

type Query struct {

	// Filter by parts of ID
	ObjectID

	// Owner can be used to filter objects by user who
	// created the resource.
	Owner string

	// State can be used to filter objects by state.
	State string

	// Tags can be used to filter objects by tags.
	Tags map[string]string

	// Params can be used to provide additional parameters to
	// controllers and ObjectStore implementations.
	Params map[string]string
}

type QueryClause string

type SelfValidator interface {
	Validate() *Error
}

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

type Spec interface{}

type Tags map[string]string

type UpdateClause interface{}

type UpdateSpec struct {
	Spec Spec
}

type UpdateState struct {
	State string
}

type UpdateTags struct {
	Tags map[string]string
}