client

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

type DynamicWatcher interface {
	AddWatcher(watcher ObjectIdentifier, watchedObject ObjectIdentifier) error
	// AddOrUpdateWatcher updates the watches for the watcher. When updating, any previously watched objects not
	// specified will stop being watched. If an error occurs, any created watches as part of this method execution will
	// be removed.
	AddOrUpdateWatcher(watcher ObjectIdentifier, watchedObjects ...ObjectIdentifier) error
	// RemoveWatcher removes a watcher and any of its API watches solely referenced by the watcher.
	RemoveWatcher(watcher ObjectIdentifier) error
	// Start will start the DynamicWatcher and block until the input context is canceled.
	Start(ctx context.Context) error
	// GetWatchCount returns the total number of active API watch requests which can be used for metrics.
	GetWatchCount() uint
	// Started returns a channel that is closed when the DynamicWatcher is ready to receive watch requests.
	Started() <-chan struct{}
	// Get will add an additional watch to the started query batch and return the watched object. Note that you must
	// call StartQueryBatch before calling this.
	Get(
		watcher ObjectIdentifier, gvk schema.GroupVersionKind, namespace string, name string,
	) (*unstructured.Unstructured, error)
	// GetFromCache will return the object from the cache. If it's not cached, the ErrNoCacheEntry error will be
	// returned.
	GetFromCache(gvk schema.GroupVersionKind, namespace string, name string) (*unstructured.Unstructured, error)
	// List will add an additional watch to the started query batch and return the watched objects. Note that you must
	// call StartQueryBatch before calling this.
	List(
		watcher ObjectIdentifier, gvk schema.GroupVersionKind, namespace string, selector labels.Selector,
	) ([]unstructured.Unstructured, error)
	// ListFromCache will return the objects from the cache. If it's not cached, the ErrNoCacheEntry error will be
	// returned.
	ListFromCache(
		gvk schema.GroupVersionKind, namespace string, selector labels.Selector,
	) ([]unstructured.Unstructured, error)
	// ListWatchedFromCache will return all watched objects by the watcher in the cache.
	ListWatchedFromCache(watcher ObjectIdentifier) ([]unstructured.Unstructured, error)
	// StartQueryBatch will start a query batch transaction for the watcher. After a series of Get/List calls, calling
	// EndQueryBatch will clean up the non-applicable preexisting watches made from before this query batch.
	StartQueryBatch(watcher ObjectIdentifier) error
	// EndQueryBatch will stop a query batch transaction for the watcher. This will clean up the non-applicable
	// preexisting watches made from before this query batch.
	EndQueryBatch(watcher ObjectIdentifier) error
	// GVKToGVR will convert a GVK to a GVR and cache the result for a default of 10 minutes (configurable) when found,
	// and not cache failed conversions by default (configurable).
	GVKToGVR(gvk schema.GroupVersionKind) (ScopedGVR, error)
}

type ObjectCache interface {
	// Get returns the object from the cache. A nil value can be returned to indicate a not found is cached. The error
	// ErrNoCacheEntry is returned if there is no cache entry at all.
	Get(gvk schema.GroupVersionKind, namespace string, name string) (*unstructured.Unstructured, error)
	// List returns the objects from the cache, which can be an empty list. The error ErrNoCacheEntry is returned if
	// there is no cache entry.
	List(gvk schema.GroupVersionKind, namespace string, selector labels.Selector) ([]unstructured.Unstructured, error)
	// FromObjectIdentifier returns the objects from the cache, which can be an empty list, based on the input object
	// identifier. The error ErrNoCacheEntry is returned if there is no cache entry at all.
	FromObjectIdentifier(objID ObjectIdentifier) ([]unstructured.Unstructured, error)
	// CacheList will cache a list of objects for the list query.
	CacheList(
		gvk schema.GroupVersionKind, namespace string, selector labels.Selector, objects []unstructured.Unstructured,
	)
	// CacheObject allows to cache an object. The input object can be nil to indicate a cached not found result.
	CacheObject(gvk schema.GroupVersionKind, namespace string, name string, object *unstructured.Unstructured)
	// CacheFromObjectIdentifier will cache a list of objects for the input object identifier.
	CacheFromObjectIdentifier(objID ObjectIdentifier, objects []unstructured.Unstructured)
	// UncacheObject will entirely remove the cache entry of the object.
	UncacheObject(gvk schema.GroupVersionKind, namespace string, name string)
	// UncacheObject will entirely remove the cache entries for the list query.
	UncacheList(gvk schema.GroupVersionKind, namespace string, selector labels.Selector)
	// UncacheObject will entirely remove the cache entries for the object identifier.
	UncacheFromObjectIdentifier(objID ObjectIdentifier)
	// GVKToGVR will convert a GVK to a GVR and cache the result for a default of 10 minutes (configurable) when found,
	// and not cache failed conversions by default (configurable).
	GVKToGVR(gvk schema.GroupVersionKind) (ScopedGVR, error)
	// Clear will entirely clear the cache.
	Clear()
}

type ObjectCacheOptions struct {
	// The time for a GVK to GVR conversion cache entry to be considered fresh (not expired). This excludes missing API
	// resources, which is configured by MissingAPIResourceCacheTTL. The default value is 10 minutes.
	GVKToGVRCacheTTL time.Duration
	// The time for a failed GVK to GVR conversion to not be retried. The default behavior is to not cache failures.
	// Setting this can be useful if you don't want to continuously query the Kubernetes API if a CRD is missing.
	MissingAPIResourceCacheTTL time.Duration
}

type ObjectIdentifier struct {
	Group     string
	Version   string
	Kind      string
	Namespace string
	Name      string
	Selector  string
}

type Options struct {
	// RateLimiter is used to limit how frequently requests may be queued.
	// Defaults to client-go's MaxOfRateLimiter which has both overall and per-item rate limiting. The overall is a
	// token bucket and the per-item is exponential.
	RateLimiter ratelimiter.RateLimiter
	// EnableCache causes the watched objects to be cached and retrievable.
	EnableCache bool
	// DisableInitialReconcile causes the initial reconcile from the list request before the watch to not cause a
	// reconcile. This is useful if you are exclusively using the caching query API.
	DisableInitialReconcile bool
	// Options for how long to cache GVK to GVR conversions.
	ObjectCacheOptions ObjectCacheOptions
}

type Reconciler interface {
	// Reconcile is called whenever an object has started being watched (if it exists) as well as when it has changed
	// (added, modified, or deleted). If the watch stops prematurely and is restarted, it may cause a duplicate call to
	// this method. If an error is returned, the request is requeued.
	Reconcile(ctx context.Context, watcher ObjectIdentifier) (reconcile.Result, error)
}

type ScopedGVR struct {
	schema.GroupVersionResource
	Namespaced bool
}