dpucluster

type Backoff ¶

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

Backoff is a struct that implements a backoff algorithm.

func NewBackoff(d time.Duration, factor, jitter float64) *Backoff

func (b *Backoff) GetNextBackOff(attempt int) time.Duration

temp = backoff * factor ^ attempt
interval = temp * (1 - jitter) + rand.Int64N(2 * jitter * temp)

type ClientOption ¶

type ClientOption interface {
	Apply(options *ClientOptions)
}

type ClientOptionConfigHost ¶

type ClientOptionConfigHost struct {
	Host string
}

ClientOptionConfigHost overrides the host used for the REST config.

func (o ClientOptionConfigHost) Apply(options *ClientOptions)

type ClientOptionScheme ¶

type ClientOptionScheme struct {
	Scheme *runtime.Scheme
}

ClientOptionScheme is the scheme used for the client.

func (o ClientOptionScheme) Apply(options *ClientOptions)

type ClientOptionSkipVerifyTLS ¶

type ClientOptionSkipVerifyTLS struct {
	SkipVerifyTLS bool
}

ClientOptionSkipVerifyTLS is the option to skip TLS verification for the REST config.

func (o ClientOptionSkipVerifyTLS) Apply(options *ClientOptions)

type ClientOptionTimeout ¶

type ClientOptionTimeout struct {
	Timeout time.Duration
}

ClientOptionTimeout is the timeout used for the REST config, client and cache.

func (o ClientOptionTimeout) Apply(options *ClientOptions)

type ClientOptionUserAgent ¶

type ClientOptionUserAgent struct {
	UserAgent string
}

ClientOptionUserAgent is the user agent used for the REST config, client and cache.

func (o ClientOptionUserAgent) Apply(options *ClientOptions)

type ClientOptions ¶

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

ClientOptions holds the options for the client.

type ClusterClientProvider ¶

type ClusterClientProvider interface {
	// GetClient returns a client for the specified DPUCluster
	GetClient(clusterKey client.ObjectKey) (client.Client, error)
	// ListClients returns a list of clients for all DPUClusters known
	// to the provider.
	ListClients() ([]client.Client, error)
}

ClusterClientProvider is the interface that is used by the DPUClusterHelper to get clients for DPUClusters.

func NewStaticClusterClientProvider(clients map[client.ObjectKey]client.Client) ClusterClientProvider

type Config ¶

type Config struct {
	// Cluster is the DPU cluster for which the config is being fetched.
	Cluster *provisioningv1.DPUCluster
	// contains filtered or unexported fields
}

Config hold the cluster configuration. It provides methods to get the client, clientset, and rest config for the cluster.

func GetConfigs(ctx context.Context, c client.Client) ([]*Config, error)

func NewConfig(c client.Reader, cluster *provisioningv1.DPUCluster) *Config

func (cc *Config) CACertHashes(ctx context.Context) ([]string, error)

func (cc *Config) Client(ctx context.Context, opts ...ClientOption) (client.Client, error)

func (cc *Config) Clientset(ctx context.Context, opts ...ClientOption) (*kubernetes.Clientset, []byte, error)

func (cc *Config) ClusterNamespaceName() string

func (cc *Config) Kubeconfig(ctx context.Context) (*clientcmdv1.Config, error)

func (cc *Config) Server(ctx context.Context) (string, error)

type GetIndexerCallback ¶

type GetIndexerCallback func(ctx context.Context, cache cache.Cache) error

GetIndexerCallback is called when a cache for a dpu cluster is created. The function should add field indexes to the cache before it is started.

type GetWatcherCallback ¶

type GetWatcherCallback func(ctx context.Context, c client.Client, cluster client.ObjectKey) (Watcher, error)

GetWatcherCallback the function is called when a client for a dpu cluster is created. The function should return a Watcher that will be used to watch for events for the given cluster.

type Health ¶

type Health struct {
	Backoff
	// contains filtered or unexported fields
}

Health is the struct that implements the health check for the dpu cluster.

func NewHealthServer(client discovery.ServerVersionInterface, maxBackoff time.Duration, maxRetries int, interval time.Duration) *Health

func (h *Health) Check() (string, error)

func (h *Health) GetNextCheckTime() time.Duration

type Option ¶

type Option interface {
	Apply(options *Options)
}

type OptionByObject ¶

type OptionByObject struct {
	ByObject map[client.Object]cache.ByObject
}

OptionByObject restricts the cache's ListWatch to the desired fields per GVK at the specified object.

func (o OptionByObject) Apply(options *Options)

type OptionDefaultFieldSelector ¶

type OptionDefaultFieldSelector struct {
	DefaultFieldSelector fields.Selector
}

OptionDefaultFieldSelector will be used as a field selector for all object types.

func (o OptionDefaultFieldSelector) Apply(options *Options)

type OptionDefaultLabelSelector ¶

type OptionDefaultLabelSelector struct {
	DefaultLabelSelector labels.Selector
}

OptionDefaultLabelSelector will be used as a label selector for all objects.

func (o OptionDefaultLabelSelector) Apply(options *Options)

type OptionDefaultNamespaces ¶

type OptionDefaultNamespaces struct {
	DefaultNamespaces map[string]cache.Config
}

OptionDefaultNamespaces maps namespace names to cache configs.

func (o OptionDefaultNamespaces) Apply(options *Options)

type OptionDisableFor ¶

type OptionDisableFor struct {
	DisableFor []client.Object
}

OptionDisableFor is a list of objects for which the cache should be disabled.

func (o OptionDisableFor) Apply(options *Options)

type OptionGetIndexerCallbacks ¶

type OptionGetIndexerCallbacks struct {
	GetIndexerCallbacks []GetIndexerCallback
}

OptionGetIndexerCallbacks is a list of functions that are called when a cache for a dpu cluster is created.

func (o OptionGetIndexerCallbacks) Apply(options *Options)

type OptionGetWatcherCallbacks ¶

type OptionGetWatcherCallbacks struct {
	GetWatcherCallbacks []GetWatcherCallback
}

OptionGetWatcherCallbacks is a list of functions that are called when a client for a dpu cluster is created.

func (o OptionGetWatcherCallbacks) Apply(options *Options)

type OptionHostClient ¶

type OptionHostClient struct {
	Client client.Reader
}

OptionHostClient is the client for the host cluster. It is used to fetch the kubeconfig secret.

func (o OptionHostClient) Apply(options *Options)

type OptionInitialSyncTimeout ¶

type OptionInitialSyncTimeout struct {
	InitialSyncTimeout time.Duration
}

OptionInitialSyncTimeout is the timeout used when waiting for the cache to sync after cache start.

func (o OptionInitialSyncTimeout) Apply(options *Options)

type OptionRequeueAfter ¶

type OptionRequeueAfter struct {
	RequeueAfter time.Duration
}

OptionRequeueAfter tells the remoteCacheReconciler to requeue after the given duration.

func (o OptionRequeueAfter) Apply(options *Options)

type OptionScheme ¶

type OptionScheme struct {
	Scheme *runtime.Scheme
}

OptionScheme is the scheme used for the client and the cache.

func (o OptionScheme) Apply(options *Options)

type OptionSyncPeriod ¶

type OptionSyncPeriod struct {
	SyncPeriod time.Duration
}

OptionSyncPeriod is the sync period of the cache.

func (o OptionSyncPeriod) Apply(options *Options)

type OptionTimeout ¶

type OptionTimeout struct {
	Timeout time.Duration
}

OptionTimeout is the timeout used for the REST config, client and cache.

func (o OptionTimeout) Apply(options *Options)

type OptionUserAgent ¶

type OptionUserAgent struct {
	UserAgent string
}

OptionUserAgent is the user agent used for the REST config, client and cache.

func (o OptionUserAgent) Apply(options *Options)

type Options ¶

type Options struct {
	ClientOptions
	// contains filtered or unexported fields
}

type RemoteCache ¶

type RemoteCache struct {

	// Lock to synchronize acess to accessors.
	sync.RWMutex
	// contains filtered or unexported fields
}

RemoteCache reconcile dpuClusters CRs and manges caches for those dpuClusters. It provides a way to watch dpuClusters and get cachedClients for dpuClusters. Specific objects can be watched in the dpu cluster.

func SetupRemoteCacheWithManager(ctx context.Context, mgr ctrl.Manager, opts ...Option) (*RemoteCache, error)

func (rc *RemoteCache) GetClient(cluster client.ObjectKey) (client.Client, error)

func (rc *RemoteCache) ListClients() ([]client.Client, error)

func (rc *RemoteCache) Reconcile(ctx context.Context, req reconcile.Request) (reconcile.Result, error)

func (rc *RemoteCache) Watch(ctx context.Context, cluster client.ObjectKey, watcher Watcher) error

err := RemoteCache.Watch(ctx, util.ObjectKey(cluster), clustercache.NewWatcher(clustercache.WatcherOptions{
	Name:         "watch-DPUNodes",
	Watcher:      r.controller,
	Kind:         &provisionningv1aplha1.DPUNode{},
	EventHandler: handler.EnqueueRequestsFromMapFunc(r.dpuNodeToVPC),
})

type SourceWatcher ¶

type SourceWatcher[request comparable] interface {
	Watch(src source.TypedSource[request]) error
}

SourceWatcher is a scoped-down interface from Controller that only has the Watch func.

type TypedWatcherOptions ¶

type TypedWatcherOptions[object client.Object, request comparable] struct {
	// Name represents a unique Watch request for the specified Cluster.
	Name string

	// Watcher is the watcher (controller) whose Reconcile() function will be called for events.
	Watcher SourceWatcher[request]

	// Kind is the type of resource to watch.
	Kind object

	// EventHandler contains the event handlers to invoke for resource events.
	EventHandler handler.TypedEventHandler[object, request]

	// Predicates is used to filter resource events.
	Predicates []predicate.TypedPredicate[object]
}

TypedWatcherOptions specifies the parameters used to establish a new watch for a dpu cluster. A source.TypedKind source (configured with Kind, TypedEventHandler and Predicates) will be added to the Watcher. To watch for events, the source.TypedKind will create an informer on the Cache that we have created and cached for the given Cluster.

type Watcher ¶

type Watcher interface {
	Name() string
	Object() client.Object
	Watch(cache cache.Cache) error
}

Watcher is an interface that can start a Watch.

func NewWatcher[object client.Object, request comparable](options TypedWatcherOptions[object, request]) Watcher

type WatcherOptions ¶

type WatcherOptions = TypedWatcherOptions[client.Object, ctrl.Request]

WatcherOptions specifies the parameters used to establish a new watch for a dpu cluster. A source.TypedKind source (configured with Kind, TypedEventHandler and Predicates) will be added to the Watcher. To watch for events, the source.TypedKind will create an informer on the Cache that we have created and cached for the given Cluster.