timanager

type Cache[Client, UnderlayClient any] interface {
	Client() Client
	InformerFactory() SharedInformerFactory[UnderlayClient]

	Keys() []string

	Start(ctx context.Context)
	Stop()
}

type CacheKeysFunc[Object client.Object] func(obj Object) ([]string, error)

type CacheLister[T any, PT Object[T]] interface {
	List(selector labels.Selector) ([]PT, error)
	Get(name string) (PT, error)
}

type ClientManager[Object client.Object, Client any] interface {
	Register(obj Object) error
	Deregister(key string)
	Get(key string) (Client, bool)
}

type Equality[T any, PT Object[T]] interface {
	Equal(prev, cur PT) bool
}

type EventSource interface {
	source.Source
	For(key string, f cache.SharedIndexInformer) error
	HasSynced(key string) bool
}

type GlobalCacheLister[T any, PT Object[T]] interface {
	ByCluster(cluster string) CacheLister[T, PT]
}

type List[T any, PT Object[T]] struct {
	metav1.TypeMeta
	metav1.ListMeta

	Items []T
}

type Lister[T any, PT Object[T], L client.ObjectList] interface {
	List(ctx context.Context) (L, error)
	GetItems(l L) []PT
	MarkAsInvalid(PT) bool
}

type ListerWatcher[UnderlayClient any] interface {
	cache.ListerWatcher
}

type Manager[Object client.Object, Client any] interface {
	ClientManager[Object, Client]

	Source(obj runtime.Object, h handler.EventHandler) source.Source
	Start(ctx context.Context)
}

type ManagerBuilder[Object client.Object, UnderlayClient, Client any] interface {
	WithLogger(logger logr.Logger) ManagerBuilder[Object, UnderlayClient, Client]
	WithCacheKeysFunc(f CacheKeysFunc[Object]) ManagerBuilder[Object, UnderlayClient, Client]
	WithNewUnderlayClientFunc(f NewUnderlayClientFunc[Object, UnderlayClient]) ManagerBuilder[Object, UnderlayClient, Client]
	WithNewClientFunc(f NewClientFunc[Object, UnderlayClient, Client]) ManagerBuilder[Object, UnderlayClient, Client]
	WithNewPollerFunc(obj runtime.Object, f NewPollerFunc[UnderlayClient]) ManagerBuilder[Object, UnderlayClient, Client]
	WithResyncPeriod(time.Duration) ManagerBuilder[Object, UnderlayClient, Client]

	Build() Manager[Object, Client]
}

type NewClientFunc[Object client.Object, UnderlayClient, Client any] func(
	Object, UnderlayClient, SharedInformerFactory[UnderlayClient]) Client

type NewPollerFunc[UnderlayClient any] func(name string, logger logr.Logger, c UnderlayClient) Poller

type NewUnderlayClientFunc[Object client.Object, UnderlayClient any] func(obj Object) (UnderlayClient, error)

type Object[T any] interface {
	*T
	client.Object
	DeepCopy() *T
	DeepCopyInto(*T)
}

type Poller interface {
	// Sync will initialize the state of poller
	// It will poll and make sure state is available
	// Sync must be called before Run
	Sync(ctx context.Context) (runtime.Object, error)
	// IF Run is called multiple times, the previous one will be stopped
	// immediately and start a new one to push event to new channel
	Run(ctx context.Context, ch chan<- watch.Event)
	// Refresh once immediately
	Refresh()
}

type RefreshFunc func()

type RefreshableCacheLister[T any, PT Object[T]] interface {
	CacheLister[T, PT]
	Refresher
}

type Refresher interface {
	Refresh()
}

type SharedInformerFactory[UnderlayClient any] interface {
	Start(stopCh <-chan struct{})
	Shutdown()
	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
	InformerFor(obj runtime.Object) cache.SharedIndexInformer

	// call function for each registered informer
	ForEach(func(t reflect.Type, informer cache.SharedIndexInformer) error) error

	// Refresh will poll once immediately
	Refresh(obj runtime.Object)
}