v3

package
v0.0.0-...-235145b Latest Latest
Warning

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

 Go to latest Published: May 14, 2025 License: Apache-2.0 Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterAPIServiceGeneratingHandler 

func RegisterAPIServiceGeneratingHandler(ctx context.Context, controller APIServiceController, apply apply.Apply,
	condition condition.Cond, name string, handler APIServiceGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterAPIServiceGeneratingHandler configures a APIServiceController to execute a APIServiceGeneratingHandler 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 RegisterAPIServiceStatusHandler 

func RegisterAPIServiceStatusHandler(ctx context.Context, controller APIServiceController, condition condition.Cond, name string, handler APIServiceStatusHandler)

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

func RegisterAuthConfigGeneratingHandler 

func RegisterAuthConfigGeneratingHandler(ctx context.Context, controller AuthConfigController, apply apply.Apply,
	condition condition.Cond, name string, handler AuthConfigGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterAuthConfigGeneratingHandler configures a AuthConfigController to execute a AuthConfigGeneratingHandler 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 RegisterAuthConfigStatusHandler 

func RegisterAuthConfigStatusHandler(ctx context.Context, controller AuthConfigController, condition condition.Cond, name string, handler AuthConfigStatusHandler)

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

func RegisterClusterGeneratingHandler 

func RegisterClusterGeneratingHandler(ctx context.Context, controller ClusterController, apply apply.Apply,
	condition condition.Cond, name string, handler ClusterGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterClusterGeneratingHandler configures a ClusterController to execute a ClusterGeneratingHandler 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 RegisterClusterRegistrationTokenGeneratingHandler 

func RegisterClusterRegistrationTokenGeneratingHandler(ctx context.Context, controller ClusterRegistrationTokenController, apply apply.Apply,
	condition condition.Cond, name string, handler ClusterRegistrationTokenGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterClusterRegistrationTokenGeneratingHandler configures a ClusterRegistrationTokenController to execute a ClusterRegistrationTokenGeneratingHandler 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 RegisterClusterRegistrationTokenStatusHandler 

func RegisterClusterRegistrationTokenStatusHandler(ctx context.Context, controller ClusterRegistrationTokenController, condition condition.Cond, name string, handler ClusterRegistrationTokenStatusHandler)

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

func RegisterClusterRoleTemplateBindingGeneratingHandler 

func RegisterClusterRoleTemplateBindingGeneratingHandler(ctx context.Context, controller ClusterRoleTemplateBindingController, apply apply.Apply,
	condition condition.Cond, name string, handler ClusterRoleTemplateBindingGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterClusterRoleTemplateBindingGeneratingHandler configures a ClusterRoleTemplateBindingController to execute a ClusterRoleTemplateBindingGeneratingHandler 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 RegisterClusterRoleTemplateBindingStatusHandler 

func RegisterClusterRoleTemplateBindingStatusHandler(ctx context.Context, controller ClusterRoleTemplateBindingController, condition condition.Cond, name string, handler ClusterRoleTemplateBindingStatusHandler)

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

func RegisterClusterStatusHandler 

func RegisterClusterStatusHandler(ctx context.Context, controller ClusterController, condition condition.Cond, name string, handler ClusterStatusHandler)

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

func RegisterClusterTemplateRevisionGeneratingHandler 

func RegisterClusterTemplateRevisionGeneratingHandler(ctx context.Context, controller ClusterTemplateRevisionController, apply apply.Apply,
	condition condition.Cond, name string, handler ClusterTemplateRevisionGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterClusterTemplateRevisionGeneratingHandler configures a ClusterTemplateRevisionController to execute a ClusterTemplateRevisionGeneratingHandler 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 RegisterClusterTemplateRevisionStatusHandler 

func RegisterClusterTemplateRevisionStatusHandler(ctx context.Context, controller ClusterTemplateRevisionController, condition condition.Cond, name string, handler ClusterTemplateRevisionStatusHandler)

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

func RegisterComposeConfigGeneratingHandler 

func RegisterComposeConfigGeneratingHandler(ctx context.Context, controller ComposeConfigController, apply apply.Apply,
	condition condition.Cond, name string, handler ComposeConfigGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterComposeConfigGeneratingHandler configures a ComposeConfigController to execute a ComposeConfigGeneratingHandler 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 RegisterComposeConfigStatusHandler 

func RegisterComposeConfigStatusHandler(ctx context.Context, controller ComposeConfigController, condition condition.Cond, name string, handler ComposeConfigStatusHandler)

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

func RegisterDynamicSchemaGeneratingHandler 

func RegisterDynamicSchemaGeneratingHandler(ctx context.Context, controller DynamicSchemaController, apply apply.Apply,
	condition condition.Cond, name string, handler DynamicSchemaGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterDynamicSchemaGeneratingHandler configures a DynamicSchemaController to execute a DynamicSchemaGeneratingHandler 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 RegisterDynamicSchemaStatusHandler 

func RegisterDynamicSchemaStatusHandler(ctx context.Context, controller DynamicSchemaController, condition condition.Cond, name string, handler DynamicSchemaStatusHandler)

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

func RegisterFeatureGeneratingHandler 

func RegisterFeatureGeneratingHandler(ctx context.Context, controller FeatureController, apply apply.Apply,
	condition condition.Cond, name string, handler FeatureGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterFeatureGeneratingHandler configures a FeatureController to execute a FeatureGeneratingHandler 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 RegisterFeatureStatusHandler 

func RegisterFeatureStatusHandler(ctx context.Context, controller FeatureController, condition condition.Cond, name string, handler FeatureStatusHandler)

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

func RegisterFleetWorkspaceGeneratingHandler 

func RegisterFleetWorkspaceGeneratingHandler(ctx context.Context, controller FleetWorkspaceController, apply apply.Apply,
	condition condition.Cond, name string, handler FleetWorkspaceGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterFleetWorkspaceGeneratingHandler configures a FleetWorkspaceController to execute a FleetWorkspaceGeneratingHandler 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 RegisterFleetWorkspaceStatusHandler 

func RegisterFleetWorkspaceStatusHandler(ctx context.Context, controller FleetWorkspaceController, condition condition.Cond, name string, handler FleetWorkspaceStatusHandler)

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

func RegisterGlobalRoleBindingGeneratingHandler 

func RegisterGlobalRoleBindingGeneratingHandler(ctx context.Context, controller GlobalRoleBindingController, apply apply.Apply,
	condition condition.Cond, name string, handler GlobalRoleBindingGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterGlobalRoleBindingGeneratingHandler configures a GlobalRoleBindingController to execute a GlobalRoleBindingGeneratingHandler 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 RegisterGlobalRoleBindingStatusHandler 

func RegisterGlobalRoleBindingStatusHandler(ctx context.Context, controller GlobalRoleBindingController, condition condition.Cond, name string, handler GlobalRoleBindingStatusHandler)

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

func RegisterGlobalRoleGeneratingHandler 

func RegisterGlobalRoleGeneratingHandler(ctx context.Context, controller GlobalRoleController, apply apply.Apply,
	condition condition.Cond, name string, handler GlobalRoleGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterGlobalRoleGeneratingHandler configures a GlobalRoleController to execute a GlobalRoleGeneratingHandler 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 RegisterGlobalRoleStatusHandler 

func RegisterGlobalRoleStatusHandler(ctx context.Context, controller GlobalRoleController, condition condition.Cond, name string, handler GlobalRoleStatusHandler)

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

func RegisterKontainerDriverGeneratingHandler 

func RegisterKontainerDriverGeneratingHandler(ctx context.Context, controller KontainerDriverController, apply apply.Apply,
	condition condition.Cond, name string, handler KontainerDriverGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterKontainerDriverGeneratingHandler configures a KontainerDriverController to execute a KontainerDriverGeneratingHandler 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 RegisterKontainerDriverStatusHandler 

func RegisterKontainerDriverStatusHandler(ctx context.Context, controller KontainerDriverController, condition condition.Cond, name string, handler KontainerDriverStatusHandler)

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

func RegisterManagedChartGeneratingHandler 

func RegisterManagedChartGeneratingHandler(ctx context.Context, controller ManagedChartController, apply apply.Apply,
	condition condition.Cond, name string, handler ManagedChartGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterManagedChartGeneratingHandler configures a ManagedChartController to execute a ManagedChartGeneratingHandler 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 RegisterManagedChartStatusHandler 

func RegisterManagedChartStatusHandler(ctx context.Context, controller ManagedChartController, condition condition.Cond, name string, handler ManagedChartStatusHandler)

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

func RegisterNodeDriverGeneratingHandler 

func RegisterNodeDriverGeneratingHandler(ctx context.Context, controller NodeDriverController, apply apply.Apply,
	condition condition.Cond, name string, handler NodeDriverGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterNodeDriverGeneratingHandler configures a NodeDriverController to execute a NodeDriverGeneratingHandler 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 RegisterNodeDriverStatusHandler 

func RegisterNodeDriverStatusHandler(ctx context.Context, controller NodeDriverController, condition condition.Cond, name string, handler NodeDriverStatusHandler)

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

func RegisterNodeGeneratingHandler 

func RegisterNodeGeneratingHandler(ctx context.Context, controller NodeController, apply apply.Apply,
	condition condition.Cond, name string, handler NodeGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterNodeGeneratingHandler configures a NodeController to execute a NodeGeneratingHandler 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 RegisterNodePoolGeneratingHandler 

func RegisterNodePoolGeneratingHandler(ctx context.Context, controller NodePoolController, apply apply.Apply,
	condition condition.Cond, name string, handler NodePoolGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterNodePoolGeneratingHandler configures a NodePoolController to execute a NodePoolGeneratingHandler 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 RegisterNodePoolStatusHandler 

func RegisterNodePoolStatusHandler(ctx context.Context, controller NodePoolController, condition condition.Cond, name string, handler NodePoolStatusHandler)

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

func RegisterNodeStatusHandler 

func RegisterNodeStatusHandler(ctx context.Context, controller NodeController, condition condition.Cond, name string, handler NodeStatusHandler)

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

func RegisterNodeTemplateGeneratingHandler 

func RegisterNodeTemplateGeneratingHandler(ctx context.Context, controller NodeTemplateController, apply apply.Apply,
	condition condition.Cond, name string, handler NodeTemplateGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterNodeTemplateGeneratingHandler configures a NodeTemplateController to execute a NodeTemplateGeneratingHandler 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 RegisterNodeTemplateStatusHandler 

func RegisterNodeTemplateStatusHandler(ctx context.Context, controller NodeTemplateController, condition condition.Cond, name string, handler NodeTemplateStatusHandler)

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

func RegisterOIDCClientGeneratingHandler 

func RegisterOIDCClientGeneratingHandler(ctx context.Context, controller OIDCClientController, apply apply.Apply,
	condition condition.Cond, name string, handler OIDCClientGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterOIDCClientGeneratingHandler configures a OIDCClientController to execute a OIDCClientGeneratingHandler 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 RegisterOIDCClientStatusHandler 

func RegisterOIDCClientStatusHandler(ctx context.Context, controller OIDCClientController, condition condition.Cond, name string, handler OIDCClientStatusHandler)

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

func RegisterProjectGeneratingHandler 

func RegisterProjectGeneratingHandler(ctx context.Context, controller ProjectController, apply apply.Apply,
	condition condition.Cond, name string, handler ProjectGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterProjectGeneratingHandler configures a ProjectController to execute a ProjectGeneratingHandler 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 RegisterProjectStatusHandler 

func RegisterProjectStatusHandler(ctx context.Context, controller ProjectController, condition condition.Cond, name string, handler ProjectStatusHandler)

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

func RegisterUserGeneratingHandler 

func RegisterUserGeneratingHandler(ctx context.Context, controller UserController, apply apply.Apply,
	condition condition.Cond, name string, handler UserGeneratingHandler, opts *generic.GeneratingHandlerOptions)

RegisterUserGeneratingHandler configures a UserController to execute a UserGeneratingHandler 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 RegisterUserStatusHandler 

func RegisterUserStatusHandler(ctx context.Context, controller UserController, condition condition.Cond, name string, handler UserStatusHandler)

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

Types

type APIServiceCache 

type APIServiceCache interface {
	generic.NonNamespacedCacheInterface[*v3.APIService]
}

APIServiceCache interface for retrieving APIService resources in memory.

type APIServiceClient 

type APIServiceClient interface {
	generic.NonNamespacedClientInterface[*v3.APIService, *v3.APIServiceList]
}

APIServiceClient interface for managing APIService resources in Kubernetes.

type APIServiceController 

type APIServiceController interface {
	generic.NonNamespacedControllerInterface[*v3.APIService, *v3.APIServiceList]
}

APIServiceController interface for managing APIService resources.

type APIServiceGeneratingHandler 

type APIServiceGeneratingHandler func(obj *v3.APIService, status v3.APIServiceStatus) ([]runtime.Object, v3.APIServiceStatus, error)

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

type APIServiceStatusHandler 

type APIServiceStatusHandler func(obj *v3.APIService, status v3.APIServiceStatus) (v3.APIServiceStatus, error)

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

type ActiveDirectoryProviderCache 

type ActiveDirectoryProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.ActiveDirectoryProvider]
}

ActiveDirectoryProviderCache interface for retrieving ActiveDirectoryProvider resources in memory.

type ActiveDirectoryProviderClient 

type ActiveDirectoryProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.ActiveDirectoryProvider, *v3.ActiveDirectoryProviderList]
}

ActiveDirectoryProviderClient interface for managing ActiveDirectoryProvider resources in Kubernetes.

type ActiveDirectoryProviderController 

type ActiveDirectoryProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.ActiveDirectoryProvider, *v3.ActiveDirectoryProviderList]
}

ActiveDirectoryProviderController interface for managing ActiveDirectoryProvider resources.

type AuthConfigCache 

type AuthConfigCache interface {
	generic.NonNamespacedCacheInterface[*v3.AuthConfig]
}

AuthConfigCache interface for retrieving AuthConfig resources in memory.

type AuthConfigClient 

type AuthConfigClient interface {
	generic.NonNamespacedClientInterface[*v3.AuthConfig, *v3.AuthConfigList]
}

AuthConfigClient interface for managing AuthConfig resources in Kubernetes.

type AuthConfigController 

type AuthConfigController interface {
	generic.NonNamespacedControllerInterface[*v3.AuthConfig, *v3.AuthConfigList]
}

AuthConfigController interface for managing AuthConfig resources.

type AuthConfigGeneratingHandler 

type AuthConfigGeneratingHandler func(obj *v3.AuthConfig, status v3.AuthConfigStatus) ([]runtime.Object, v3.AuthConfigStatus, error)

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

type AuthConfigStatusHandler 

type AuthConfigStatusHandler func(obj *v3.AuthConfig, status v3.AuthConfigStatus) (v3.AuthConfigStatus, error)

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

type AuthProviderCache 

type AuthProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.AuthProvider]
}

AuthProviderCache interface for retrieving AuthProvider resources in memory.

type AuthProviderClient 

type AuthProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.AuthProvider, *v3.AuthProviderList]
}

AuthProviderClient interface for managing AuthProvider resources in Kubernetes.

type AuthProviderController 

type AuthProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.AuthProvider, *v3.AuthProviderList]
}

AuthProviderController interface for managing AuthProvider resources.

type AuthTokenCache 

type AuthTokenCache interface {
	generic.NonNamespacedCacheInterface[*v3.AuthToken]
}

AuthTokenCache interface for retrieving AuthToken resources in memory.

type AuthTokenClient 

type AuthTokenClient interface {
	generic.NonNamespacedClientInterface[*v3.AuthToken, *v3.AuthTokenList]
}

AuthTokenClient interface for managing AuthToken resources in Kubernetes.

type AuthTokenController 

type AuthTokenController interface {
	generic.NonNamespacedControllerInterface[*v3.AuthToken, *v3.AuthTokenList]
}

AuthTokenController interface for managing AuthToken resources.

type AzureADProviderCache 

type AzureADProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.AzureADProvider]
}

AzureADProviderCache interface for retrieving AzureADProvider resources in memory.

type AzureADProviderClient 

type AzureADProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.AzureADProvider, *v3.AzureADProviderList]
}

AzureADProviderClient interface for managing AzureADProvider resources in Kubernetes.

type AzureADProviderController 

type AzureADProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.AzureADProvider, *v3.AzureADProviderList]
}

AzureADProviderController interface for managing AzureADProvider resources.

type CloudCredentialCache 

type CloudCredentialCache interface {
	generic.CacheInterface[*v3.CloudCredential]
}

CloudCredentialCache interface for retrieving CloudCredential resources in memory.

type CloudCredentialClient 

type CloudCredentialClient interface {
	generic.ClientInterface[*v3.CloudCredential, *v3.CloudCredentialList]
}

CloudCredentialClient interface for managing CloudCredential resources in Kubernetes.

type CloudCredentialController 

type CloudCredentialController interface {
	generic.ControllerInterface[*v3.CloudCredential, *v3.CloudCredentialList]
}

CloudCredentialController interface for managing CloudCredential resources.

type ClusterCache 

type ClusterCache interface {
	generic.NonNamespacedCacheInterface[*v3.Cluster]
}

ClusterCache interface for retrieving Cluster resources in memory.

type ClusterClient 

type ClusterClient interface {
	generic.NonNamespacedClientInterface[*v3.Cluster, *v3.ClusterList]
}

ClusterClient interface for managing Cluster resources in Kubernetes.

type ClusterController 

type ClusterController interface {
	generic.NonNamespacedControllerInterface[*v3.Cluster, *v3.ClusterList]
}

ClusterController interface for managing Cluster resources.

type ClusterGeneratingHandler 

type ClusterGeneratingHandler func(obj *v3.Cluster, status v3.ClusterStatus) ([]runtime.Object, v3.ClusterStatus, error)

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

type ClusterProxyConfigCache 

type ClusterProxyConfigCache interface {
	generic.CacheInterface[*v3.ClusterProxyConfig]
}

ClusterProxyConfigCache interface for retrieving ClusterProxyConfig resources in memory.

type ClusterProxyConfigClient 

type ClusterProxyConfigClient interface {
	generic.ClientInterface[*v3.ClusterProxyConfig, *v3.ClusterProxyConfigList]
}

ClusterProxyConfigClient interface for managing ClusterProxyConfig resources in Kubernetes.

type ClusterProxyConfigController 

type ClusterProxyConfigController interface {
	generic.ControllerInterface[*v3.ClusterProxyConfig, *v3.ClusterProxyConfigList]
}

ClusterProxyConfigController interface for managing ClusterProxyConfig resources.

type ClusterRegistrationTokenCache 

type ClusterRegistrationTokenCache interface {
	generic.CacheInterface[*v3.ClusterRegistrationToken]
}

ClusterRegistrationTokenCache interface for retrieving ClusterRegistrationToken resources in memory.

type ClusterRegistrationTokenClient 

type ClusterRegistrationTokenClient interface {
	generic.ClientInterface[*v3.ClusterRegistrationToken, *v3.ClusterRegistrationTokenList]
}

ClusterRegistrationTokenClient interface for managing ClusterRegistrationToken resources in Kubernetes.

type ClusterRegistrationTokenController 

type ClusterRegistrationTokenController interface {
	generic.ControllerInterface[*v3.ClusterRegistrationToken, *v3.ClusterRegistrationTokenList]
}

ClusterRegistrationTokenController interface for managing ClusterRegistrationToken resources.

type ClusterRegistrationTokenGeneratingHandler 

type ClusterRegistrationTokenGeneratingHandler func(obj *v3.ClusterRegistrationToken, status v3.ClusterRegistrationTokenStatus) ([]runtime.Object, v3.ClusterRegistrationTokenStatus, error)

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

type ClusterRegistrationTokenStatusHandler 

type ClusterRegistrationTokenStatusHandler func(obj *v3.ClusterRegistrationToken, status v3.ClusterRegistrationTokenStatus) (v3.ClusterRegistrationTokenStatus, error)

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

type ClusterRoleTemplateBindingCache 

type ClusterRoleTemplateBindingCache interface {
	generic.CacheInterface[*v3.ClusterRoleTemplateBinding]
}

ClusterRoleTemplateBindingCache interface for retrieving ClusterRoleTemplateBinding resources in memory.

type ClusterRoleTemplateBindingClient 

type ClusterRoleTemplateBindingClient interface {
	generic.ClientInterface[*v3.ClusterRoleTemplateBinding, *v3.ClusterRoleTemplateBindingList]
}

ClusterRoleTemplateBindingClient interface for managing ClusterRoleTemplateBinding resources in Kubernetes.

type ClusterRoleTemplateBindingController 

type ClusterRoleTemplateBindingController interface {
	generic.ControllerInterface[*v3.ClusterRoleTemplateBinding, *v3.ClusterRoleTemplateBindingList]
}

ClusterRoleTemplateBindingController interface for managing ClusterRoleTemplateBinding resources.

type ClusterRoleTemplateBindingGeneratingHandler 

type ClusterRoleTemplateBindingGeneratingHandler func(obj *v3.ClusterRoleTemplateBinding, status v3.ClusterRoleTemplateBindingStatus) ([]runtime.Object, v3.ClusterRoleTemplateBindingStatus, error)

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

type ClusterRoleTemplateBindingStatusHandler 

type ClusterRoleTemplateBindingStatusHandler func(obj *v3.ClusterRoleTemplateBinding, status v3.ClusterRoleTemplateBindingStatus) (v3.ClusterRoleTemplateBindingStatus, error)

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

type ClusterStatusHandler 

type ClusterStatusHandler func(obj *v3.Cluster, status v3.ClusterStatus) (v3.ClusterStatus, error)

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

type ClusterTemplateCache 

type ClusterTemplateCache interface {
	generic.CacheInterface[*v3.ClusterTemplate]
}

ClusterTemplateCache interface for retrieving ClusterTemplate resources in memory.

type ClusterTemplateClient 

type ClusterTemplateClient interface {
	generic.ClientInterface[*v3.ClusterTemplate, *v3.ClusterTemplateList]
}

ClusterTemplateClient interface for managing ClusterTemplate resources in Kubernetes.

type ClusterTemplateController 

type ClusterTemplateController interface {
	generic.ControllerInterface[*v3.ClusterTemplate, *v3.ClusterTemplateList]
}

ClusterTemplateController interface for managing ClusterTemplate resources.

type ClusterTemplateRevisionCache 

type ClusterTemplateRevisionCache interface {
	generic.CacheInterface[*v3.ClusterTemplateRevision]
}

ClusterTemplateRevisionCache interface for retrieving ClusterTemplateRevision resources in memory.

type ClusterTemplateRevisionClient 

type ClusterTemplateRevisionClient interface {
	generic.ClientInterface[*v3.ClusterTemplateRevision, *v3.ClusterTemplateRevisionList]
}

ClusterTemplateRevisionClient interface for managing ClusterTemplateRevision resources in Kubernetes.

type ClusterTemplateRevisionController 

type ClusterTemplateRevisionController interface {
	generic.ControllerInterface[*v3.ClusterTemplateRevision, *v3.ClusterTemplateRevisionList]
}

ClusterTemplateRevisionController interface for managing ClusterTemplateRevision resources.

type ClusterTemplateRevisionGeneratingHandler 

type ClusterTemplateRevisionGeneratingHandler func(obj *v3.ClusterTemplateRevision, status v3.ClusterTemplateRevisionStatus) ([]runtime.Object, v3.ClusterTemplateRevisionStatus, error)

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

type ClusterTemplateRevisionStatusHandler 

type ClusterTemplateRevisionStatusHandler func(obj *v3.ClusterTemplateRevision, status v3.ClusterTemplateRevisionStatus) (v3.ClusterTemplateRevisionStatus, error)

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

type ComposeConfigCache 

type ComposeConfigCache interface {
	generic.NonNamespacedCacheInterface[*v3.ComposeConfig]
}

ComposeConfigCache interface for retrieving ComposeConfig resources in memory.

type ComposeConfigClient 

type ComposeConfigClient interface {
	generic.NonNamespacedClientInterface[*v3.ComposeConfig, *v3.ComposeConfigList]
}

ComposeConfigClient interface for managing ComposeConfig resources in Kubernetes.

type ComposeConfigController 

type ComposeConfigController interface {
	generic.NonNamespacedControllerInterface[*v3.ComposeConfig, *v3.ComposeConfigList]
}

ComposeConfigController interface for managing ComposeConfig resources.

type ComposeConfigGeneratingHandler 

type ComposeConfigGeneratingHandler func(obj *v3.ComposeConfig, status v3.ComposeStatus) ([]runtime.Object, v3.ComposeStatus, error)

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

type ComposeConfigStatusHandler 

type ComposeConfigStatusHandler func(obj *v3.ComposeConfig, status v3.ComposeStatus) (v3.ComposeStatus, error)

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

type DynamicSchemaCache 

type DynamicSchemaCache interface {
	generic.NonNamespacedCacheInterface[*v3.DynamicSchema]
}

DynamicSchemaCache interface for retrieving DynamicSchema resources in memory.

type DynamicSchemaClient 

type DynamicSchemaClient interface {
	generic.NonNamespacedClientInterface[*v3.DynamicSchema, *v3.DynamicSchemaList]
}

DynamicSchemaClient interface for managing DynamicSchema resources in Kubernetes.

type DynamicSchemaController 

type DynamicSchemaController interface {
	generic.NonNamespacedControllerInterface[*v3.DynamicSchema, *v3.DynamicSchemaList]
}

DynamicSchemaController interface for managing DynamicSchema resources.

type DynamicSchemaGeneratingHandler 

type DynamicSchemaGeneratingHandler func(obj *v3.DynamicSchema, status v3.DynamicSchemaStatus) ([]runtime.Object, v3.DynamicSchemaStatus, error)

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

type DynamicSchemaStatusHandler 

type DynamicSchemaStatusHandler func(obj *v3.DynamicSchema, status v3.DynamicSchemaStatus) (v3.DynamicSchemaStatus, error)

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

type EtcdBackupCache 

type EtcdBackupCache interface {
	generic.CacheInterface[*v3.EtcdBackup]
}

EtcdBackupCache interface for retrieving EtcdBackup resources in memory.

type EtcdBackupClient 

type EtcdBackupClient interface {
	generic.ClientInterface[*v3.EtcdBackup, *v3.EtcdBackupList]
}

EtcdBackupClient interface for managing EtcdBackup resources in Kubernetes.

type EtcdBackupController 

type EtcdBackupController interface {
	generic.ControllerInterface[*v3.EtcdBackup, *v3.EtcdBackupList]
}

EtcdBackupController interface for managing EtcdBackup resources.

type FeatureCache 

type FeatureCache interface {
	generic.NonNamespacedCacheInterface[*v3.Feature]
}

FeatureCache interface for retrieving Feature resources in memory.

type FeatureClient 

type FeatureClient interface {
	generic.NonNamespacedClientInterface[*v3.Feature, *v3.FeatureList]
}

FeatureClient interface for managing Feature resources in Kubernetes.

type FeatureController 

type FeatureController interface {
	generic.NonNamespacedControllerInterface[*v3.Feature, *v3.FeatureList]
}

FeatureController interface for managing Feature resources.

type FeatureGeneratingHandler 

type FeatureGeneratingHandler func(obj *v3.Feature, status v3.FeatureStatus) ([]runtime.Object, v3.FeatureStatus, error)

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

type FeatureStatusHandler 

type FeatureStatusHandler func(obj *v3.Feature, status v3.FeatureStatus) (v3.FeatureStatus, error)

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

type FleetWorkspaceCache 

type FleetWorkspaceCache interface {
	generic.NonNamespacedCacheInterface[*v3.FleetWorkspace]
}

FleetWorkspaceCache interface for retrieving FleetWorkspace resources in memory.

type FleetWorkspaceClient 

type FleetWorkspaceClient interface {
	generic.NonNamespacedClientInterface[*v3.FleetWorkspace, *v3.FleetWorkspaceList]
}

FleetWorkspaceClient interface for managing FleetWorkspace resources in Kubernetes.

type FleetWorkspaceController 

type FleetWorkspaceController interface {
	generic.NonNamespacedControllerInterface[*v3.FleetWorkspace, *v3.FleetWorkspaceList]
}

FleetWorkspaceController interface for managing FleetWorkspace resources.

type FleetWorkspaceGeneratingHandler 

type FleetWorkspaceGeneratingHandler func(obj *v3.FleetWorkspace, status v3.FleetWorkspaceStatus) ([]runtime.Object, v3.FleetWorkspaceStatus, error)

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

type FleetWorkspaceStatusHandler 

type FleetWorkspaceStatusHandler func(obj *v3.FleetWorkspace, status v3.FleetWorkspaceStatus) (v3.FleetWorkspaceStatus, error)

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

type FreeIpaProviderCache 

type FreeIpaProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.FreeIpaProvider]
}

FreeIpaProviderCache interface for retrieving FreeIpaProvider resources in memory.

type FreeIpaProviderClient 

type FreeIpaProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.FreeIpaProvider, *v3.FreeIpaProviderList]
}

FreeIpaProviderClient interface for managing FreeIpaProvider resources in Kubernetes.

type FreeIpaProviderController 

type FreeIpaProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.FreeIpaProvider, *v3.FreeIpaProviderList]
}

FreeIpaProviderController interface for managing FreeIpaProvider resources.

type GenericOIDCProviderCache 

type GenericOIDCProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.GenericOIDCProvider]
}

GenericOIDCProviderCache interface for retrieving GenericOIDCProvider resources in memory.

type GenericOIDCProviderClient 

type GenericOIDCProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.GenericOIDCProvider, *v3.GenericOIDCProviderList]
}

GenericOIDCProviderClient interface for managing GenericOIDCProvider resources in Kubernetes.

type GenericOIDCProviderController 

type GenericOIDCProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.GenericOIDCProvider, *v3.GenericOIDCProviderList]
}

GenericOIDCProviderController interface for managing GenericOIDCProvider resources.

type GithubProviderCache 

type GithubProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.GithubProvider]
}

GithubProviderCache interface for retrieving GithubProvider resources in memory.

type GithubProviderClient 

type GithubProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.GithubProvider, *v3.GithubProviderList]
}

GithubProviderClient interface for managing GithubProvider resources in Kubernetes.

type GithubProviderController 

type GithubProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.GithubProvider, *v3.GithubProviderList]
}

GithubProviderController interface for managing GithubProvider resources.

type GlobalRoleBindingCache 

type GlobalRoleBindingCache interface {
	generic.NonNamespacedCacheInterface[*v3.GlobalRoleBinding]
}

GlobalRoleBindingCache interface for retrieving GlobalRoleBinding resources in memory.

type GlobalRoleBindingClient 

type GlobalRoleBindingClient interface {
	generic.NonNamespacedClientInterface[*v3.GlobalRoleBinding, *v3.GlobalRoleBindingList]
}

GlobalRoleBindingClient interface for managing GlobalRoleBinding resources in Kubernetes.

type GlobalRoleBindingController 

type GlobalRoleBindingController interface {
	generic.NonNamespacedControllerInterface[*v3.GlobalRoleBinding, *v3.GlobalRoleBindingList]
}

GlobalRoleBindingController interface for managing GlobalRoleBinding resources.

type GlobalRoleBindingGeneratingHandler 

type GlobalRoleBindingGeneratingHandler func(obj *v3.GlobalRoleBinding, status v3.GlobalRoleBindingStatus) ([]runtime.Object, v3.GlobalRoleBindingStatus, error)

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

type GlobalRoleBindingStatusHandler 

type GlobalRoleBindingStatusHandler func(obj *v3.GlobalRoleBinding, status v3.GlobalRoleBindingStatus) (v3.GlobalRoleBindingStatus, error)

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

type GlobalRoleCache 

type GlobalRoleCache interface {
	generic.NonNamespacedCacheInterface[*v3.GlobalRole]
}

GlobalRoleCache interface for retrieving GlobalRole resources in memory.

type GlobalRoleClient 

type GlobalRoleClient interface {
	generic.NonNamespacedClientInterface[*v3.GlobalRole, *v3.GlobalRoleList]
}

GlobalRoleClient interface for managing GlobalRole resources in Kubernetes.

type GlobalRoleController 

type GlobalRoleController interface {
	generic.NonNamespacedControllerInterface[*v3.GlobalRole, *v3.GlobalRoleList]
}

GlobalRoleController interface for managing GlobalRole resources.

type GlobalRoleGeneratingHandler 

type GlobalRoleGeneratingHandler func(obj *v3.GlobalRole, status v3.GlobalRoleStatus) ([]runtime.Object, v3.GlobalRoleStatus, error)

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

type GlobalRoleStatusHandler 

type GlobalRoleStatusHandler func(obj *v3.GlobalRole, status v3.GlobalRoleStatus) (v3.GlobalRoleStatus, error)

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

type GoogleOAuthProviderCache 

type GoogleOAuthProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.GoogleOAuthProvider]
}

GoogleOAuthProviderCache interface for retrieving GoogleOAuthProvider resources in memory.

type GoogleOAuthProviderClient 

type GoogleOAuthProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.GoogleOAuthProvider, *v3.GoogleOAuthProviderList]
}

GoogleOAuthProviderClient interface for managing GoogleOAuthProvider resources in Kubernetes.

type GoogleOAuthProviderController 

type GoogleOAuthProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.GoogleOAuthProvider, *v3.GoogleOAuthProviderList]
}

GoogleOAuthProviderController interface for managing GoogleOAuthProvider resources.

type GroupCache 

type GroupCache interface {
	generic.NonNamespacedCacheInterface[*v3.Group]
}

GroupCache interface for retrieving Group resources in memory.

type GroupClient 

type GroupClient interface {
	generic.NonNamespacedClientInterface[*v3.Group, *v3.GroupList]
}

GroupClient interface for managing Group resources in Kubernetes.

type GroupController 

type GroupController interface {
	generic.NonNamespacedControllerInterface[*v3.Group, *v3.GroupList]
}

GroupController interface for managing Group resources.

type GroupMemberCache 

type GroupMemberCache interface {
	generic.NonNamespacedCacheInterface[*v3.GroupMember]
}

GroupMemberCache interface for retrieving GroupMember resources in memory.

type GroupMemberClient 

type GroupMemberClient interface {
	generic.NonNamespacedClientInterface[*v3.GroupMember, *v3.GroupMemberList]
}

GroupMemberClient interface for managing GroupMember resources in Kubernetes.

type GroupMemberController 

type GroupMemberController interface {
	generic.NonNamespacedControllerInterface[*v3.GroupMember, *v3.GroupMemberList]
}

GroupMemberController interface for managing GroupMember resources.

type Interface 

type Interface interface {
	APIService() APIServiceController
	ActiveDirectoryProvider() ActiveDirectoryProviderController
	AuthConfig() AuthConfigController
	AuthProvider() AuthProviderController
	AuthToken() AuthTokenController
	AzureADProvider() AzureADProviderController
	CloudCredential() CloudCredentialController
	Cluster() ClusterController
	ClusterProxyConfig() ClusterProxyConfigController
	ClusterRegistrationToken() ClusterRegistrationTokenController
	ClusterRoleTemplateBinding() ClusterRoleTemplateBindingController
	ClusterTemplate() ClusterTemplateController
	ClusterTemplateRevision() ClusterTemplateRevisionController
	ComposeConfig() ComposeConfigController
	DynamicSchema() DynamicSchemaController
	EtcdBackup() EtcdBackupController
	Feature() FeatureController
	FleetWorkspace() FleetWorkspaceController
	FreeIpaProvider() FreeIpaProviderController
	GenericOIDCProvider() GenericOIDCProviderController
	GithubProvider() GithubProviderController
	GlobalRole() GlobalRoleController
	GlobalRoleBinding() GlobalRoleBindingController
	GoogleOAuthProvider() GoogleOAuthProviderController
	Group() GroupController
	GroupMember() GroupMemberController
	KontainerDriver() KontainerDriverController
	LocalProvider() LocalProviderController
	ManagedChart() ManagedChartController
	Node() NodeController
	NodeDriver() NodeDriverController
	NodePool() NodePoolController
	NodeTemplate() NodeTemplateController
	OIDCClient() OIDCClientController
	OIDCProvider() OIDCProviderController
	OpenLdapProvider() OpenLdapProviderController
	PodSecurityAdmissionConfigurationTemplate() PodSecurityAdmissionConfigurationTemplateController
	Preference() PreferenceController
	Principal() PrincipalController
	Project() ProjectController
	ProjectNetworkPolicy() ProjectNetworkPolicyController
	ProjectRoleTemplateBinding() ProjectRoleTemplateBindingController
	RancherUserNotification() RancherUserNotificationController
	RkeAddon() RkeAddonController
	RkeK8sServiceOption() RkeK8sServiceOptionController
	RkeK8sSystemImage() RkeK8sSystemImageController
	RoleTemplate() RoleTemplateController
	SamlProvider() SamlProviderController
	SamlToken() SamlTokenController
	Setting() SettingController
	Token() TokenController
	User() UserController
	UserAttribute() UserAttributeController
}

func New 

func New(controllerFactory controller.SharedControllerFactory, ts *session.Session) Interface

type KontainerDriverCache 

type KontainerDriverCache interface {
	generic.NonNamespacedCacheInterface[*v3.KontainerDriver]
}

KontainerDriverCache interface for retrieving KontainerDriver resources in memory.

type KontainerDriverClient 

type KontainerDriverClient interface {
	generic.NonNamespacedClientInterface[*v3.KontainerDriver, *v3.KontainerDriverList]
}

KontainerDriverClient interface for managing KontainerDriver resources in Kubernetes.

type KontainerDriverController 

type KontainerDriverController interface {
	generic.NonNamespacedControllerInterface[*v3.KontainerDriver, *v3.KontainerDriverList]
}

KontainerDriverController interface for managing KontainerDriver resources.

type KontainerDriverGeneratingHandler 

type KontainerDriverGeneratingHandler func(obj *v3.KontainerDriver, status v3.KontainerDriverStatus) ([]runtime.Object, v3.KontainerDriverStatus, error)

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

type KontainerDriverStatusHandler 

type KontainerDriverStatusHandler func(obj *v3.KontainerDriver, status v3.KontainerDriverStatus) (v3.KontainerDriverStatus, error)

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

type LocalProviderCache 

type LocalProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.LocalProvider]
}

LocalProviderCache interface for retrieving LocalProvider resources in memory.

type LocalProviderClient 

type LocalProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.LocalProvider, *v3.LocalProviderList]
}

LocalProviderClient interface for managing LocalProvider resources in Kubernetes.

type LocalProviderController 

type LocalProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.LocalProvider, *v3.LocalProviderList]
}

LocalProviderController interface for managing LocalProvider resources.

type ManagedChartCache 

type ManagedChartCache interface {
	generic.CacheInterface[*v3.ManagedChart]
}

ManagedChartCache interface for retrieving ManagedChart resources in memory.

type ManagedChartClient 

type ManagedChartClient interface {
	generic.ClientInterface[*v3.ManagedChart, *v3.ManagedChartList]
}

ManagedChartClient interface for managing ManagedChart resources in Kubernetes.

type ManagedChartController 

type ManagedChartController interface {
	generic.ControllerInterface[*v3.ManagedChart, *v3.ManagedChartList]
}

ManagedChartController interface for managing ManagedChart resources.

type ManagedChartGeneratingHandler 

type ManagedChartGeneratingHandler func(obj *v3.ManagedChart, status v3.ManagedChartStatus) ([]runtime.Object, v3.ManagedChartStatus, error)

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

type ManagedChartStatusHandler 

type ManagedChartStatusHandler func(obj *v3.ManagedChart, status v3.ManagedChartStatus) (v3.ManagedChartStatus, error)

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

type NodeCache 

type NodeCache interface {
	generic.CacheInterface[*v3.Node]
}

NodeCache interface for retrieving Node resources in memory.

type NodeClient 

type NodeClient interface {
	generic.ClientInterface[*v3.Node, *v3.NodeList]
}

NodeClient interface for managing Node resources in Kubernetes.

type NodeController 

type NodeController interface {
	generic.ControllerInterface[*v3.Node, *v3.NodeList]
}

NodeController interface for managing Node resources.

type NodeDriverCache 

type NodeDriverCache interface {
	generic.NonNamespacedCacheInterface[*v3.NodeDriver]
}

NodeDriverCache interface for retrieving NodeDriver resources in memory.

type NodeDriverClient 

type NodeDriverClient interface {
	generic.NonNamespacedClientInterface[*v3.NodeDriver, *v3.NodeDriverList]
}

NodeDriverClient interface for managing NodeDriver resources in Kubernetes.

type NodeDriverController 

type NodeDriverController interface {
	generic.NonNamespacedControllerInterface[*v3.NodeDriver, *v3.NodeDriverList]
}

NodeDriverController interface for managing NodeDriver resources.

type NodeDriverGeneratingHandler 

type NodeDriverGeneratingHandler func(obj *v3.NodeDriver, status v3.NodeDriverStatus) ([]runtime.Object, v3.NodeDriverStatus, error)

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

type NodeDriverStatusHandler 

type NodeDriverStatusHandler func(obj *v3.NodeDriver, status v3.NodeDriverStatus) (v3.NodeDriverStatus, error)

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

type NodeGeneratingHandler 

type NodeGeneratingHandler func(obj *v3.Node, status v3.NodeStatus) ([]runtime.Object, v3.NodeStatus, error)

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

type NodePoolCache 

type NodePoolCache interface {
	generic.CacheInterface[*v3.NodePool]
}

NodePoolCache interface for retrieving NodePool resources in memory.

type NodePoolClient 

type NodePoolClient interface {
	generic.ClientInterface[*v3.NodePool, *v3.NodePoolList]
}

NodePoolClient interface for managing NodePool resources in Kubernetes.

type NodePoolController 

type NodePoolController interface {
	generic.ControllerInterface[*v3.NodePool, *v3.NodePoolList]
}

NodePoolController interface for managing NodePool resources.

type NodePoolGeneratingHandler 

type NodePoolGeneratingHandler func(obj *v3.NodePool, status v3.NodePoolStatus) ([]runtime.Object, v3.NodePoolStatus, error)

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

type NodePoolStatusHandler 

type NodePoolStatusHandler func(obj *v3.NodePool, status v3.NodePoolStatus) (v3.NodePoolStatus, error)

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

type NodeStatusHandler 

type NodeStatusHandler func(obj *v3.Node, status v3.NodeStatus) (v3.NodeStatus, error)

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

type NodeTemplateCache 

type NodeTemplateCache interface {
	generic.CacheInterface[*v3.NodeTemplate]
}

NodeTemplateCache interface for retrieving NodeTemplate resources in memory.

type NodeTemplateClient 

type NodeTemplateClient interface {
	generic.ClientInterface[*v3.NodeTemplate, *v3.NodeTemplateList]
}

NodeTemplateClient interface for managing NodeTemplate resources in Kubernetes.

type NodeTemplateController 

type NodeTemplateController interface {
	generic.ControllerInterface[*v3.NodeTemplate, *v3.NodeTemplateList]
}

NodeTemplateController interface for managing NodeTemplate resources.

type NodeTemplateGeneratingHandler 

type NodeTemplateGeneratingHandler func(obj *v3.NodeTemplate, status v3.NodeTemplateStatus) ([]runtime.Object, v3.NodeTemplateStatus, error)

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

type NodeTemplateStatusHandler 

type NodeTemplateStatusHandler func(obj *v3.NodeTemplate, status v3.NodeTemplateStatus) (v3.NodeTemplateStatus, error)

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

type OIDCClientCache 

type OIDCClientCache interface {
	generic.NonNamespacedCacheInterface[*v3.OIDCClient]
}

OIDCClientCache interface for retrieving OIDCClient resources in memory.

type OIDCClientClient 

type OIDCClientClient interface {
	generic.NonNamespacedClientInterface[*v3.OIDCClient, *v3.OIDCClientList]
}

OIDCClientClient interface for managing OIDCClient resources in Kubernetes.

type OIDCClientController 

type OIDCClientController interface {
	generic.NonNamespacedControllerInterface[*v3.OIDCClient, *v3.OIDCClientList]
}

OIDCClientController interface for managing OIDCClient resources.

type OIDCClientGeneratingHandler 

type OIDCClientGeneratingHandler func(obj *v3.OIDCClient, status v3.OIDCClientStatus) ([]runtime.Object, v3.OIDCClientStatus, error)

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

type OIDCClientStatusHandler 

type OIDCClientStatusHandler func(obj *v3.OIDCClient, status v3.OIDCClientStatus) (v3.OIDCClientStatus, error)

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

type OIDCProviderCache 

type OIDCProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.OIDCProvider]
}

OIDCProviderCache interface for retrieving OIDCProvider resources in memory.

type OIDCProviderClient 

type OIDCProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.OIDCProvider, *v3.OIDCProviderList]
}

OIDCProviderClient interface for managing OIDCProvider resources in Kubernetes.

type OIDCProviderController 

type OIDCProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.OIDCProvider, *v3.OIDCProviderList]
}

OIDCProviderController interface for managing OIDCProvider resources.

type OpenLdapProviderCache 

type OpenLdapProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.OpenLdapProvider]
}

OpenLdapProviderCache interface for retrieving OpenLdapProvider resources in memory.

type OpenLdapProviderClient 

type OpenLdapProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.OpenLdapProvider, *v3.OpenLdapProviderList]
}

OpenLdapProviderClient interface for managing OpenLdapProvider resources in Kubernetes.

type OpenLdapProviderController 

type OpenLdapProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.OpenLdapProvider, *v3.OpenLdapProviderList]
}

OpenLdapProviderController interface for managing OpenLdapProvider resources.

type PodSecurityAdmissionConfigurationTemplateCache 

type PodSecurityAdmissionConfigurationTemplateCache interface {
	generic.NonNamespacedCacheInterface[*v3.PodSecurityAdmissionConfigurationTemplate]
}

PodSecurityAdmissionConfigurationTemplateCache interface for retrieving PodSecurityAdmissionConfigurationTemplate resources in memory.

type PodSecurityAdmissionConfigurationTemplateClient 

type PodSecurityAdmissionConfigurationTemplateClient interface {
	generic.NonNamespacedClientInterface[*v3.PodSecurityAdmissionConfigurationTemplate, *v3.PodSecurityAdmissionConfigurationTemplateList]
}

PodSecurityAdmissionConfigurationTemplateClient interface for managing PodSecurityAdmissionConfigurationTemplate resources in Kubernetes.

type PodSecurityAdmissionConfigurationTemplateController 

type PodSecurityAdmissionConfigurationTemplateController interface {
	generic.NonNamespacedControllerInterface[*v3.PodSecurityAdmissionConfigurationTemplate, *v3.PodSecurityAdmissionConfigurationTemplateList]
}

PodSecurityAdmissionConfigurationTemplateController interface for managing PodSecurityAdmissionConfigurationTemplate resources.

type PreferenceCache 

type PreferenceCache interface {
	generic.CacheInterface[*v3.Preference]
}

PreferenceCache interface for retrieving Preference resources in memory.

type PreferenceClient 

type PreferenceClient interface {
	generic.ClientInterface[*v3.Preference, *v3.PreferenceList]
}

PreferenceClient interface for managing Preference resources in Kubernetes.

type PreferenceController 

type PreferenceController interface {
	generic.ControllerInterface[*v3.Preference, *v3.PreferenceList]
}

PreferenceController interface for managing Preference resources.

type PrincipalCache 

type PrincipalCache interface {
	generic.NonNamespacedCacheInterface[*v3.Principal]
}

PrincipalCache interface for retrieving Principal resources in memory.

type PrincipalClient 

type PrincipalClient interface {
	generic.NonNamespacedClientInterface[*v3.Principal, *v3.PrincipalList]
}

PrincipalClient interface for managing Principal resources in Kubernetes.

type PrincipalController 

type PrincipalController interface {
	generic.NonNamespacedControllerInterface[*v3.Principal, *v3.PrincipalList]
}

PrincipalController interface for managing Principal resources.

type ProjectCache 

type ProjectCache interface {
	generic.CacheInterface[*v3.Project]
}

ProjectCache interface for retrieving Project resources in memory.

type ProjectClient 

type ProjectClient interface {
	generic.ClientInterface[*v3.Project, *v3.ProjectList]
}

ProjectClient interface for managing Project resources in Kubernetes.

type ProjectController 

type ProjectController interface {
	generic.ControllerInterface[*v3.Project, *v3.ProjectList]
}

ProjectController interface for managing Project resources.

type ProjectGeneratingHandler 

type ProjectGeneratingHandler func(obj *v3.Project, status v3.ProjectStatus) ([]runtime.Object, v3.ProjectStatus, error)

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

type ProjectNetworkPolicyCache 

type ProjectNetworkPolicyCache interface {
	generic.CacheInterface[*v3.ProjectNetworkPolicy]
}

ProjectNetworkPolicyCache interface for retrieving ProjectNetworkPolicy resources in memory.

type ProjectNetworkPolicyClient 

type ProjectNetworkPolicyClient interface {
	generic.ClientInterface[*v3.ProjectNetworkPolicy, *v3.ProjectNetworkPolicyList]
}

ProjectNetworkPolicyClient interface for managing ProjectNetworkPolicy resources in Kubernetes.

type ProjectNetworkPolicyController 

type ProjectNetworkPolicyController interface {
	generic.ControllerInterface[*v3.ProjectNetworkPolicy, *v3.ProjectNetworkPolicyList]
}

ProjectNetworkPolicyController interface for managing ProjectNetworkPolicy resources.

type ProjectRoleTemplateBindingCache 

type ProjectRoleTemplateBindingCache interface {
	generic.CacheInterface[*v3.ProjectRoleTemplateBinding]
}

ProjectRoleTemplateBindingCache interface for retrieving ProjectRoleTemplateBinding resources in memory.

type ProjectRoleTemplateBindingClient 

type ProjectRoleTemplateBindingClient interface {
	generic.ClientInterface[*v3.ProjectRoleTemplateBinding, *v3.ProjectRoleTemplateBindingList]
}

ProjectRoleTemplateBindingClient interface for managing ProjectRoleTemplateBinding resources in Kubernetes.

type ProjectRoleTemplateBindingController 

type ProjectRoleTemplateBindingController interface {
	generic.ControllerInterface[*v3.ProjectRoleTemplateBinding, *v3.ProjectRoleTemplateBindingList]
}

ProjectRoleTemplateBindingController interface for managing ProjectRoleTemplateBinding resources.

type ProjectStatusHandler 

type ProjectStatusHandler func(obj *v3.Project, status v3.ProjectStatus) (v3.ProjectStatus, error)

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

type RancherUserNotificationCache 

type RancherUserNotificationCache interface {
	generic.NonNamespacedCacheInterface[*v3.RancherUserNotification]
}

RancherUserNotificationCache interface for retrieving RancherUserNotification resources in memory.

type RancherUserNotificationClient 

type RancherUserNotificationClient interface {
	generic.NonNamespacedClientInterface[*v3.RancherUserNotification, *v3.RancherUserNotificationList]
}

RancherUserNotificationClient interface for managing RancherUserNotification resources in Kubernetes.

type RancherUserNotificationController 

type RancherUserNotificationController interface {
	generic.NonNamespacedControllerInterface[*v3.RancherUserNotification, *v3.RancherUserNotificationList]
}

RancherUserNotificationController interface for managing RancherUserNotification resources.

type RkeAddonCache 

type RkeAddonCache interface {
	generic.CacheInterface[*v3.RkeAddon]
}

RkeAddonCache interface for retrieving RkeAddon resources in memory.

type RkeAddonClient 

type RkeAddonClient interface {
	generic.ClientInterface[*v3.RkeAddon, *v3.RkeAddonList]
}

RkeAddonClient interface for managing RkeAddon resources in Kubernetes.

type RkeAddonController 

type RkeAddonController interface {
	generic.ControllerInterface[*v3.RkeAddon, *v3.RkeAddonList]
}

RkeAddonController interface for managing RkeAddon resources.

type RkeK8sServiceOptionCache 

type RkeK8sServiceOptionCache interface {
	generic.CacheInterface[*v3.RkeK8sServiceOption]
}

RkeK8sServiceOptionCache interface for retrieving RkeK8sServiceOption resources in memory.

type RkeK8sServiceOptionClient 

type RkeK8sServiceOptionClient interface {
	generic.ClientInterface[*v3.RkeK8sServiceOption, *v3.RkeK8sServiceOptionList]
}

RkeK8sServiceOptionClient interface for managing RkeK8sServiceOption resources in Kubernetes.

type RkeK8sServiceOptionController 

type RkeK8sServiceOptionController interface {
	generic.ControllerInterface[*v3.RkeK8sServiceOption, *v3.RkeK8sServiceOptionList]
}

RkeK8sServiceOptionController interface for managing RkeK8sServiceOption resources.

type RkeK8sSystemImageCache 

type RkeK8sSystemImageCache interface {
	generic.CacheInterface[*v3.RkeK8sSystemImage]
}

RkeK8sSystemImageCache interface for retrieving RkeK8sSystemImage resources in memory.

type RkeK8sSystemImageClient 

type RkeK8sSystemImageClient interface {
	generic.ClientInterface[*v3.RkeK8sSystemImage, *v3.RkeK8sSystemImageList]
}

RkeK8sSystemImageClient interface for managing RkeK8sSystemImage resources in Kubernetes.

type RkeK8sSystemImageController 

type RkeK8sSystemImageController interface {
	generic.ControllerInterface[*v3.RkeK8sSystemImage, *v3.RkeK8sSystemImageList]
}

RkeK8sSystemImageController interface for managing RkeK8sSystemImage resources.

type RoleTemplateCache 

type RoleTemplateCache interface {
	generic.NonNamespacedCacheInterface[*v3.RoleTemplate]
}

RoleTemplateCache interface for retrieving RoleTemplate resources in memory.

type RoleTemplateClient 

type RoleTemplateClient interface {
	generic.NonNamespacedClientInterface[*v3.RoleTemplate, *v3.RoleTemplateList]
}

RoleTemplateClient interface for managing RoleTemplate resources in Kubernetes.

type RoleTemplateController 

type RoleTemplateController interface {
	generic.NonNamespacedControllerInterface[*v3.RoleTemplate, *v3.RoleTemplateList]
}

RoleTemplateController interface for managing RoleTemplate resources.

type SamlProviderCache 

type SamlProviderCache interface {
	generic.NonNamespacedCacheInterface[*v3.SamlProvider]
}

SamlProviderCache interface for retrieving SamlProvider resources in memory.

type SamlProviderClient 

type SamlProviderClient interface {
	generic.NonNamespacedClientInterface[*v3.SamlProvider, *v3.SamlProviderList]
}

SamlProviderClient interface for managing SamlProvider resources in Kubernetes.

type SamlProviderController 

type SamlProviderController interface {
	generic.NonNamespacedControllerInterface[*v3.SamlProvider, *v3.SamlProviderList]
}

SamlProviderController interface for managing SamlProvider resources.

type SamlTokenCache 

type SamlTokenCache interface {
	generic.NonNamespacedCacheInterface[*v3.SamlToken]
}

SamlTokenCache interface for retrieving SamlToken resources in memory.

type SamlTokenClient 

type SamlTokenClient interface {
	generic.NonNamespacedClientInterface[*v3.SamlToken, *v3.SamlTokenList]
}

SamlTokenClient interface for managing SamlToken resources in Kubernetes.

type SamlTokenController 

type SamlTokenController interface {
	generic.NonNamespacedControllerInterface[*v3.SamlToken, *v3.SamlTokenList]
}

SamlTokenController interface for managing SamlToken resources.

type SettingCache 

type SettingCache interface {
	generic.NonNamespacedCacheInterface[*v3.Setting]
}

SettingCache interface for retrieving Setting resources in memory.

type SettingClient 

type SettingClient interface {
	generic.NonNamespacedClientInterface[*v3.Setting, *v3.SettingList]
}

SettingClient interface for managing Setting resources in Kubernetes.

type SettingController 

type SettingController interface {
	generic.NonNamespacedControllerInterface[*v3.Setting, *v3.SettingList]
}

SettingController interface for managing Setting resources.

type TokenCache 

type TokenCache interface {
	generic.NonNamespacedCacheInterface[*v3.Token]
}

TokenCache interface for retrieving Token resources in memory.

type TokenClient 

type TokenClient interface {
	generic.NonNamespacedClientInterface[*v3.Token, *v3.TokenList]
}

TokenClient interface for managing Token resources in Kubernetes.

type TokenController 

type TokenController interface {
	generic.NonNamespacedControllerInterface[*v3.Token, *v3.TokenList]
}

TokenController interface for managing Token resources.

type UserAttributeCache 

type UserAttributeCache interface {
	generic.NonNamespacedCacheInterface[*v3.UserAttribute]
}

UserAttributeCache interface for retrieving UserAttribute resources in memory.

type UserAttributeClient 

type UserAttributeClient interface {
	generic.NonNamespacedClientInterface[*v3.UserAttribute, *v3.UserAttributeList]
}

UserAttributeClient interface for managing UserAttribute resources in Kubernetes.

type UserAttributeController 

type UserAttributeController interface {
	generic.NonNamespacedControllerInterface[*v3.UserAttribute, *v3.UserAttributeList]
}

UserAttributeController interface for managing UserAttribute resources.

type UserCache 

type UserCache interface {
	generic.NonNamespacedCacheInterface[*v3.User]
}

UserCache interface for retrieving User resources in memory.

type UserClient 

type UserClient interface {
	generic.NonNamespacedClientInterface[*v3.User, *v3.UserList]
}

UserClient interface for managing User resources in Kubernetes.

type UserController 

type UserController interface {
	generic.NonNamespacedControllerInterface[*v3.User, *v3.UserList]
}

UserController interface for managing User resources.

type UserGeneratingHandler 

type UserGeneratingHandler func(obj *v3.User, status v3.UserStatus) ([]runtime.Object, v3.UserStatus, error)

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

type UserStatusHandler 

type UserStatusHandler func(obj *v3.User, status v3.UserStatus) (v3.UserStatus, error)

UserStatusHandler is executed for every added or modified User. 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.