v1beta2

package
v1.2.0-rc3 Latest Latest
Warning

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

 Go to latest Published: Jul 7, 2023 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 FromReplicaHandlerToHandler 

func FromReplicaHandlerToHandler(sync ReplicaHandler) generic.Handler

func FromSettingHandlerToHandler 

func FromSettingHandlerToHandler(sync SettingHandler) generic.Handler

func FromVolumeHandlerToHandler 

func FromVolumeHandlerToHandler(sync VolumeHandler) generic.Handler

func RegisterBackingImageDataSourceGeneratingHandler 

func RegisterBackingImageDataSourceGeneratingHandler(ctx context.Context, controller BackingImageDataSourceController, apply apply.Apply,
	condition condition.Cond, name string, handler BackingImageDataSourceGeneratingHandler, opts *generic.GeneratingHandlerOptions)

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 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 UpdateBackingImageDataSourceDeepCopyOnChange 

func UpdateBackingImageDataSourceDeepCopyOnChange(client BackingImageDataSourceClient, obj *v1beta2.BackingImageDataSource, handler func(obj *v1beta2.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error)) (*v1beta2.BackingImageDataSource, error)

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 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 BackingImageDataSourceGeneratingHandler 

type BackingImageDataSourceGeneratingHandler func(obj *v1beta2.BackingImageDataSource, status v1beta2.BackingImageDataSourceStatus) ([]runtime.Object, v1beta2.BackingImageDataSourceStatus, error)

type BackingImageDataSourceHandler 

type BackingImageDataSourceHandler func(string, *v1beta2.BackingImageDataSource) (*v1beta2.BackingImageDataSource, error)

type BackingImageDataSourceIndexer 

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

type BackingImageDataSourceStatusHandler 

type BackingImageDataSourceStatusHandler func(obj *v1beta2.BackingImageDataSource, status v1beta2.BackingImageDataSourceStatus) (v1beta2.BackingImageDataSourceStatus, error)

type BackingImageGeneratingHandler 

type BackingImageGeneratingHandler func(obj *v1beta2.BackingImage, status v1beta2.BackingImageStatus) ([]runtime.Object, v1beta2.BackingImageStatus, 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 Interface 

type Interface interface {
	BackingImage() BackingImageController
	BackingImageDataSource() BackingImageDataSourceController
	Backup() BackupController
	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)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.