v1beta2

package
v1.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 14, 2024 License: Apache-2.0 Imports: 20 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func FromBackingImageDataSourceHandlerToHandler

func FromBackingImageDataSourceHandlerToHandler(sync BackingImageDataSourceHandler) generic.Handler

func FromBackingImageHandlerToHandler

func FromBackingImageHandlerToHandler(sync BackingImageHandler) generic.Handler

func FromBackupHandlerToHandler

func FromBackupHandlerToHandler(sync BackupHandler) generic.Handler

func FromEngineHandlerToHandler added in v1.3.0

func FromEngineHandlerToHandler(sync EngineHandler) generic.Handler

func FromReplicaHandlerToHandler

func FromReplicaHandlerToHandler(sync ReplicaHandler) generic.Handler

func FromSettingHandlerToHandler

func FromSettingHandlerToHandler(sync SettingHandler) generic.Handler

func FromVolumeHandlerToHandler

func FromVolumeHandlerToHandler(sync VolumeHandler) generic.Handler

func RegisterBackingImageDataSourceStatusHandler

func RegisterBackingImageDataSourceStatusHandler(ctx context.Context, controller BackingImageDataSourceController, condition condition.Cond, name string, handler BackingImageDataSourceStatusHandler)

func RegisterBackingImageGeneratingHandler

func RegisterBackingImageGeneratingHandler(ctx context.Context, controller BackingImageController, apply apply.Apply,
	condition condition.Cond, name string, handler BackingImageGeneratingHandler, opts *generic.GeneratingHandlerOptions)

func RegisterBackingImageStatusHandler

func RegisterBackingImageStatusHandler(ctx context.Context, controller BackingImageController, condition condition.Cond, name string, handler BackingImageStatusHandler)

func RegisterBackupGeneratingHandler

func RegisterBackupGeneratingHandler(ctx context.Context, controller BackupController, apply apply.Apply,
	condition condition.Cond, name string, handler BackupGeneratingHandler, opts *generic.GeneratingHandlerOptions)

func RegisterBackupStatusHandler

func RegisterBackupStatusHandler(ctx context.Context, controller BackupController, condition condition.Cond, name string, handler BackupStatusHandler)

func RegisterEngineGeneratingHandler added in v1.3.0

func RegisterEngineGeneratingHandler(ctx context.Context, controller EngineController, apply apply.Apply,
	condition condition.Cond, name string, handler EngineGeneratingHandler, opts *generic.GeneratingHandlerOptions)

func RegisterEngineStatusHandler added in v1.3.0

func RegisterEngineStatusHandler(ctx context.Context, controller EngineController, condition condition.Cond, name string, handler EngineStatusHandler)

func RegisterReplicaGeneratingHandler

func RegisterReplicaGeneratingHandler(ctx context.Context, controller ReplicaController, apply apply.Apply,
	condition condition.Cond, name string, handler ReplicaGeneratingHandler, opts *generic.GeneratingHandlerOptions)

func RegisterReplicaStatusHandler

func RegisterReplicaStatusHandler(ctx context.Context, controller ReplicaController, condition condition.Cond, name string, handler ReplicaStatusHandler)

func RegisterVolumeGeneratingHandler

func RegisterVolumeGeneratingHandler(ctx context.Context, controller VolumeController, apply apply.Apply,
	condition condition.Cond, name string, handler VolumeGeneratingHandler, opts *generic.GeneratingHandlerOptions)

func RegisterVolumeStatusHandler

func RegisterVolumeStatusHandler(ctx context.Context, controller VolumeController, condition condition.Cond, name string, handler VolumeStatusHandler)

func UpdateBackingImageDeepCopyOnChange

func UpdateBackingImageDeepCopyOnChange(client BackingImageClient, obj *v1beta2.BackingImage, handler func(obj *v1beta2.BackingImage) (*v1beta2.BackingImage, error)) (*v1beta2.BackingImage, error)

func UpdateBackupDeepCopyOnChange

func UpdateBackupDeepCopyOnChange(client BackupClient, obj *v1beta2.Backup, handler func(obj *v1beta2.Backup) (*v1beta2.Backup, error)) (*v1beta2.Backup, error)

func UpdateEngineDeepCopyOnChange added in v1.3.0

func UpdateEngineDeepCopyOnChange(client EngineClient, obj *v1beta2.Engine, handler func(obj *v1beta2.Engine) (*v1beta2.Engine, error)) (*v1beta2.Engine, error)

func UpdateReplicaDeepCopyOnChange

func UpdateReplicaDeepCopyOnChange(client ReplicaClient, obj *v1beta2.Replica, handler func(obj *v1beta2.Replica) (*v1beta2.Replica, error)) (*v1beta2.Replica, error)

func UpdateSettingDeepCopyOnChange

func UpdateSettingDeepCopyOnChange(client SettingClient, obj *v1beta2.Setting, handler func(obj *v1beta2.Setting) (*v1beta2.Setting, error)) (*v1beta2.Setting, error)

func UpdateVolumeDeepCopyOnChange

func UpdateVolumeDeepCopyOnChange(client VolumeClient, obj *v1beta2.Volume, handler func(obj *v1beta2.Volume) (*v1beta2.Volume, error)) (*v1beta2.Volume, error)

Types

type BackingImageCache

type BackingImageCache interface {
	Get(namespace, name string) (*v1beta2.BackingImage, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.BackingImage, error)

	AddIndexer(indexName string, indexer BackingImageIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.BackingImage, error)
}

type BackingImageClient

type BackingImageClient interface {
	Create(*v1beta2.BackingImage) (*v1beta2.BackingImage, error)
	Update(*v1beta2.BackingImage) (*v1beta2.BackingImage, error)
	UpdateStatus(*v1beta2.BackingImage) (*v1beta2.BackingImage, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.BackingImage, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.BackingImageList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.BackingImage, err error)
}

type BackingImageController

type BackingImageController interface {
	generic.ControllerMeta
	BackingImageClient

	OnChange(ctx context.Context, name string, sync BackingImageHandler)
	OnRemove(ctx context.Context, name string, sync BackingImageHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() BackingImageCache
}

func NewBackingImageController

func NewBackingImageController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) BackingImageController

type BackingImageDataSourceCache

type BackingImageDataSourceCache interface {
	Get(namespace, name string) (*v1beta2.BackingImageDataSource, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.BackingImageDataSource, error)

	AddIndexer(indexName string, indexer BackingImageDataSourceIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.BackingImageDataSource, error)
}

type BackingImageDataSourceClient

type BackingImageDataSourceClient interface {
	Create(*v1beta2.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error)
	Update(*v1beta2.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error)
	UpdateStatus(*v1beta2.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.BackingImageDataSource, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.BackingImageDataSourceList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.BackingImageDataSource, err error)
}

type BackingImageDataSourceController

type BackingImageDataSourceController interface {
	generic.ControllerMeta
	BackingImageDataSourceClient

	OnChange(ctx context.Context, name string, sync BackingImageDataSourceHandler)
	OnRemove(ctx context.Context, name string, sync BackingImageDataSourceHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() BackingImageDataSourceCache
}

func NewBackingImageDataSourceController

func NewBackingImageDataSourceController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) BackingImageDataSourceController

type BackingImageDataSourceIndexer

type BackingImageDataSourceIndexer func(obj *v1beta2.BackingImageDataSource) ([]string, error)

type BackingImageHandler

type BackingImageHandler func(string, *v1beta2.BackingImage) (*v1beta2.BackingImage, error)

type BackingImageIndexer

type BackingImageIndexer func(obj *v1beta2.BackingImage) ([]string, error)

type BackingImageStatusHandler

type BackingImageStatusHandler func(obj *v1beta2.BackingImage, status v1beta2.BackingImageStatus) (v1beta2.BackingImageStatus, error)

type BackupCache

type BackupCache interface {
	Get(namespace, name string) (*v1beta2.Backup, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.Backup, error)

	AddIndexer(indexName string, indexer BackupIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.Backup, error)
}

type BackupClient

type BackupClient interface {
	Create(*v1beta2.Backup) (*v1beta2.Backup, error)
	Update(*v1beta2.Backup) (*v1beta2.Backup, error)
	UpdateStatus(*v1beta2.Backup) (*v1beta2.Backup, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.Backup, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.BackupList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Backup, err error)
}

type BackupController

type BackupController interface {
	generic.ControllerMeta
	BackupClient

	OnChange(ctx context.Context, name string, sync BackupHandler)
	OnRemove(ctx context.Context, name string, sync BackupHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() BackupCache
}

func NewBackupController

func NewBackupController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) BackupController

type BackupGeneratingHandler

type BackupGeneratingHandler func(obj *v1beta2.Backup, status v1beta2.BackupStatus) ([]runtime.Object, v1beta2.BackupStatus, error)

type BackupHandler

type BackupHandler func(string, *v1beta2.Backup) (*v1beta2.Backup, error)

type BackupIndexer

type BackupIndexer func(obj *v1beta2.Backup) ([]string, error)

type BackupStatusHandler

type BackupStatusHandler func(obj *v1beta2.Backup, status v1beta2.BackupStatus) (v1beta2.BackupStatus, error)

type EngineCache added in v1.3.0

type EngineCache interface {
	Get(namespace, name string) (*v1beta2.Engine, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.Engine, error)

	AddIndexer(indexName string, indexer EngineIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.Engine, error)
}

type EngineClient added in v1.3.0

type EngineClient interface {
	Create(*v1beta2.Engine) (*v1beta2.Engine, error)
	Update(*v1beta2.Engine) (*v1beta2.Engine, error)
	UpdateStatus(*v1beta2.Engine) (*v1beta2.Engine, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.Engine, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.EngineList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Engine, err error)
}

type EngineController added in v1.3.0

type EngineController interface {
	generic.ControllerMeta
	EngineClient

	OnChange(ctx context.Context, name string, sync EngineHandler)
	OnRemove(ctx context.Context, name string, sync EngineHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() EngineCache
}

func NewEngineController added in v1.3.0

func NewEngineController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) EngineController

type EngineGeneratingHandler added in v1.3.0

type EngineGeneratingHandler func(obj *v1beta2.Engine, status v1beta2.EngineStatus) ([]runtime.Object, v1beta2.EngineStatus, error)

type EngineHandler added in v1.3.0

type EngineHandler func(string, *v1beta2.Engine) (*v1beta2.Engine, error)

type EngineIndexer added in v1.3.0

type EngineIndexer func(obj *v1beta2.Engine) ([]string, error)

type EngineStatusHandler added in v1.3.0

type EngineStatusHandler func(obj *v1beta2.Engine, status v1beta2.EngineStatus) (v1beta2.EngineStatus, error)

type Interface

type Interface interface {
	BackingImage() BackingImageController
	BackingImageDataSource() BackingImageDataSourceController
	Backup() BackupController
	Engine() EngineController
	Replica() ReplicaController
	Setting() SettingController
	Volume() VolumeController
}

func New

func New(controllerFactory controller.SharedControllerFactory) Interface

type ReplicaCache

type ReplicaCache interface {
	Get(namespace, name string) (*v1beta2.Replica, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.Replica, error)

	AddIndexer(indexName string, indexer ReplicaIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.Replica, error)
}

type ReplicaClient

type ReplicaClient interface {
	Create(*v1beta2.Replica) (*v1beta2.Replica, error)
	Update(*v1beta2.Replica) (*v1beta2.Replica, error)
	UpdateStatus(*v1beta2.Replica) (*v1beta2.Replica, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.Replica, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.ReplicaList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Replica, err error)
}

type ReplicaController

type ReplicaController interface {
	generic.ControllerMeta
	ReplicaClient

	OnChange(ctx context.Context, name string, sync ReplicaHandler)
	OnRemove(ctx context.Context, name string, sync ReplicaHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() ReplicaCache
}

func NewReplicaController

func NewReplicaController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) ReplicaController

type ReplicaGeneratingHandler

type ReplicaGeneratingHandler func(obj *v1beta2.Replica, status v1beta2.ReplicaStatus) ([]runtime.Object, v1beta2.ReplicaStatus, error)

type ReplicaHandler

type ReplicaHandler func(string, *v1beta2.Replica) (*v1beta2.Replica, error)

type ReplicaIndexer

type ReplicaIndexer func(obj *v1beta2.Replica) ([]string, error)

type ReplicaStatusHandler

type ReplicaStatusHandler func(obj *v1beta2.Replica, status v1beta2.ReplicaStatus) (v1beta2.ReplicaStatus, error)

type SettingCache

type SettingCache interface {
	Get(namespace, name string) (*v1beta2.Setting, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.Setting, error)

	AddIndexer(indexName string, indexer SettingIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.Setting, error)
}

type SettingClient

type SettingClient interface {
	Create(*v1beta2.Setting) (*v1beta2.Setting, error)
	Update(*v1beta2.Setting) (*v1beta2.Setting, error)

	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.Setting, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.SettingList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Setting, err error)
}

type SettingController

type SettingController interface {
	generic.ControllerMeta
	SettingClient

	OnChange(ctx context.Context, name string, sync SettingHandler)
	OnRemove(ctx context.Context, name string, sync SettingHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() SettingCache
}

func NewSettingController

func NewSettingController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) SettingController

type SettingHandler

type SettingHandler func(string, *v1beta2.Setting) (*v1beta2.Setting, error)

type SettingIndexer

type SettingIndexer func(obj *v1beta2.Setting) ([]string, error)

type VolumeCache

type VolumeCache interface {
	Get(namespace, name string) (*v1beta2.Volume, error)
	List(namespace string, selector labels.Selector) ([]*v1beta2.Volume, error)

	AddIndexer(indexName string, indexer VolumeIndexer)
	GetByIndex(indexName, key string) ([]*v1beta2.Volume, error)
}

type VolumeClient

type VolumeClient interface {
	Create(*v1beta2.Volume) (*v1beta2.Volume, error)
	Update(*v1beta2.Volume) (*v1beta2.Volume, error)
	UpdateStatus(*v1beta2.Volume) (*v1beta2.Volume, error)
	Delete(namespace, name string, options *metav1.DeleteOptions) error
	Get(namespace, name string, options metav1.GetOptions) (*v1beta2.Volume, error)
	List(namespace string, opts metav1.ListOptions) (*v1beta2.VolumeList, error)
	Watch(namespace string, opts metav1.ListOptions) (watch.Interface, error)
	Patch(namespace, name string, pt types.PatchType, data []byte, subresources ...string) (result *v1beta2.Volume, err error)
}

type VolumeController

type VolumeController interface {
	generic.ControllerMeta
	VolumeClient

	OnChange(ctx context.Context, name string, sync VolumeHandler)
	OnRemove(ctx context.Context, name string, sync VolumeHandler)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, duration time.Duration)

	Cache() VolumeCache
}

func NewVolumeController

func NewVolumeController(gvk schema.GroupVersionKind, resource string, namespaced bool, controller controller.SharedControllerFactory) VolumeController

type VolumeGeneratingHandler

type VolumeGeneratingHandler func(obj *v1beta2.Volume, status v1beta2.VolumeStatus) ([]runtime.Object, v1beta2.VolumeStatus, error)

type VolumeHandler

type VolumeHandler func(string, *v1beta2.Volume) (*v1beta2.Volume, error)

type VolumeIndexer

type VolumeIndexer func(obj *v1beta2.Volume) ([]string, error)

type VolumeStatusHandler

type VolumeStatusHandler func(obj *v1beta2.Volume, status v1beta2.VolumeStatus) (v1beta2.VolumeStatus, error)

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL