core

type Action interface {
	GetNamespace() string
	GetVerb() string
	GetResource() unversioned.GroupVersionResource
	GetSubresource() string
	Matches(verb, resource string) bool
}

type ActionImpl struct {
	Namespace   string
	Verb        string
	Resource    unversioned.GroupVersionResource
	Subresource string
}

type CreateAction interface {
	Action
	GetObject() runtime.Object
}

type CreateActionImpl struct {
	ActionImpl
	Object runtime.Object
}

type DeleteAction interface {
	Action
	GetName() string
}

type DeleteActionImpl struct {
	ActionImpl
	Name string
}

type DeleteCollectionActionImpl struct {
	ActionImpl
	ListRestrictions ListRestrictions
}

type Fake struct {
	sync.RWMutex

	// ReactionChain is the list of reactors that will be attempted for every request in the order they are tried
	ReactionChain []Reactor
	// WatchReactionChain is the list of watch reactors that will be attempted for every request in the order they are tried
	WatchReactionChain []WatchReactor
	// ProxyReactionChain is the list of proxy reactors that will be attempted for every request in the order they are tried
	ProxyReactionChain []ProxyReactor

	Resources map[string]*unversioned.APIResourceList
	// contains filtered or unexported fields
}

type FakeDiscovery struct {
	*Fake
}

type GenericAction interface {
	Action
	GetValue() interface{}
}

type GenericActionImpl struct {
	ActionImpl
	Value interface{}
}

type GetAction interface {
	Action
	GetName() string
}

type GetActionImpl struct {
	ActionImpl
	Name string
}

type ListAction interface {
	Action
	GetListRestrictions() ListRestrictions
}

type ListActionImpl struct {
	ActionImpl
	ListRestrictions ListRestrictions
}

type ListRestrictions struct {
	Labels labels.Selector
	Fields fields.Selector
}

type ObjectRetriever interface {
	// Kind should return a resource or a list of resources (depending on the provided kind and
	// name). It should return an error if the caller should communicate an error to the server.
	Kind(gvk unversioned.GroupVersionKind, name string) (runtime.Object, error)
	// Add adds a runtime object for test purposes into this object.
	Add(runtime.Object) error
}

type ObjectScheme interface {
	runtime.ObjectCreater
	runtime.ObjectCopier
	runtime.ObjectTyper
}

type PatchActionImpl struct {
	ActionImpl
	Object runtime.Object
}

type ProxyGetAction interface {
	Action
	GetScheme() string
	GetName() string
	GetPort() string
	GetPath() string
	GetParams() map[string]string
}

type ProxyGetActionImpl struct {
	ActionImpl
	Scheme string
	Name   string
	Port   string
	Path   string
	Params map[string]string
}

type ProxyReactionFunc func(action Action) (handled bool, ret restclient.ResponseWrapper, err error)

type ProxyReactor interface {
	// Handles indicates whether or not this Reactor deals with a given action
	Handles(action Action) bool
	// React handles a watch action and returns results.  It may choose to delegate by indicated handled=false
	React(action Action) (handled bool, ret restclient.ResponseWrapper, err error)
}

type ReactionFunc func(action Action) (handled bool, ret runtime.Object, err error)

type Reactor interface {
	// Handles indicates whether or not this Reactor deals with a given action
	Handles(action Action) bool
	// React handles the action and returns results.  It may choose to delegate by indicated handled=false
	React(action Action) (handled bool, ret runtime.Object, err error)
}

type SimpleProxyReactor struct {
	Resource string

	Reaction ProxyReactionFunc
}

type SimpleReactor struct {
	Verb     string
	Resource string

	Reaction ReactionFunc
}

type SimpleWatchReactor struct {
	Resource string

	Reaction WatchReactionFunc
}

type UpdateAction interface {
	Action
	GetObject() runtime.Object
}

type UpdateActionImpl struct {
	ActionImpl
	Object runtime.Object
}

type WatchAction interface {
	Action
	GetWatchRestrictions() WatchRestrictions
}

type WatchActionImpl struct {
	ActionImpl
	WatchRestrictions WatchRestrictions
}

type WatchReactionFunc func(action Action) (handled bool, ret watch.Interface, err error)

type WatchReactor interface {
	// Handles indicates whether or not this Reactor deals with a given action
	Handles(action Action) bool
	// React handles a watch action and returns results.  It may choose to delegate by indicated handled=false
	React(action Action) (handled bool, ret watch.Interface, err error)
}

type WatchRestrictions struct {
	Labels          labels.Selector
	Fields          fields.Selector
	ResourceVersion string
}