v1beta2

package
v1.3.1-rc1 Latest Latest
Warning

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

 Go to latest Published: May 24, 2024 License: Apache-2.0 Imports: 21 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 RegisterBackingImageDataSourceGeneratingHandler 

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

RegisterBackingImageDataSourceGeneratingHandler configures a BackingImageDataSourceController to execute a BackingImageDataSourceGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterBackingImageDataSourceStatusHandler 

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

RegisterBackingImageDataSourceStatusHandler configures a BackingImageDataSourceController to execute a BackingImageDataSourceStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterBackingImageGeneratingHandler 

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

RegisterBackingImageGeneratingHandler configures a BackingImageController to execute a BackingImageGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterBackingImageStatusHandler 

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

RegisterBackingImageStatusHandler configures a BackingImageController to execute a BackingImageStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterBackupGeneratingHandler 

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

RegisterBackupGeneratingHandler configures a BackupController to execute a BackupGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterBackupStatusHandler 

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

RegisterBackupStatusHandler configures a BackupController to execute a BackupStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

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)

RegisterEngineGeneratingHandler configures a EngineController to execute a EngineGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterEngineStatusHandler added in v1.3.0 

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

RegisterEngineStatusHandler configures a EngineController to execute a EngineStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterReplicaGeneratingHandler 

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

RegisterReplicaGeneratingHandler configures a ReplicaController to execute a ReplicaGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterReplicaStatusHandler 

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

RegisterReplicaStatusHandler configures a ReplicaController to execute a ReplicaStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterVolumeGeneratingHandler 

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

RegisterVolumeGeneratingHandler configures a VolumeController to execute a VolumeGeneratingHandler for every events observed, passing the returned objects to the provided apply.Apply. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

func RegisterVolumeStatusHandler 

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

RegisterVolumeStatusHandler configures a VolumeController to execute a VolumeStatusHandler for every events observed. If a non-empty condition is provided, it will be updated in the status conditions for every handler execution

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

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

BackingImageDataSourceGeneratingHandler is the top-level handler that is executed for every BackingImageDataSource event. It extends BackingImageDataSourceStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

BackingImageDataSourceStatusHandler is executed for every added or modified BackingImageDataSource. Should return the new status to be updated

type BackingImageGeneratingHandler 

type BackingImageGeneratingHandler func(obj *v1beta2.BackingImage, status v1beta2.BackingImageStatus) ([]runtime.Object, v1beta2.BackingImageStatus, error)

BackingImageGeneratingHandler is the top-level handler that is executed for every BackingImage event. It extends BackingImageStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

BackingImageStatusHandler is executed for every added or modified BackingImage. Should return the new status to be updated

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)

BackupGeneratingHandler is the top-level handler that is executed for every Backup event. It extends BackupStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

BackupStatusHandler is executed for every added or modified Backup. Should return the new status to be updated

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)

EngineGeneratingHandler is the top-level handler that is executed for every Engine event. It extends EngineStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

EngineStatusHandler is executed for every added or modified Engine. Should return the new status to be updated

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)

ReplicaGeneratingHandler is the top-level handler that is executed for every Replica event. It extends ReplicaStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

ReplicaStatusHandler is executed for every added or modified Replica. Should return the new status to be updated

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)

VolumeGeneratingHandler is the top-level handler that is executed for every Volume event. It extends VolumeStatusHandler by a returning a slice of child objects to be passed to apply.Apply

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)

VolumeStatusHandler is executed for every added or modified Volume. Should return the new status to be updated

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.