controllers

package
v0.8.5 Latest Latest
Warning

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

 Go to latest Published: Jan 7, 2023 License: Apache-2.0 Imports: 29 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuthEngineMountReconciler 

type AuthEngineMountReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

AuthEngineMountReconciler reconciles a AuthEngineMount object

func (*AuthEngineMountReconciler) Reconcile 

func (r *AuthEngineMountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the AuthEngineMount object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*AuthEngineMountReconciler) SetupWithManager 

func (r *AuthEngineMountReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type DatabaseSecretEngineConfigReconciler 

type DatabaseSecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

DatabaseSecretEngineConfigReconciler reconciles a DatabaseSecretEngineConfig object

func (*DatabaseSecretEngineConfigReconciler) Reconcile 

func (r *DatabaseSecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the DatabaseSecretEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*DatabaseSecretEngineConfigReconciler) SetupWithManager 

func (r *DatabaseSecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type DatabaseSecretEngineRoleReconciler 

type DatabaseSecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

DatabaseSecretEngineRoleReconciler reconciles a DatabaseSecretEngineRole object

func (*DatabaseSecretEngineRoleReconciler) Reconcile 

func (r *DatabaseSecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the DatabaseSecretEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*DatabaseSecretEngineRoleReconciler) SetupWithManager 

func (r *DatabaseSecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type DatabaseSecretEngineStaticRoleReconciler added in v0.8.3 

type DatabaseSecretEngineStaticRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

DatabaseSecretEngineStaticRoleReconciler reconciles a DatabaseSecretEngineStaticRole object

func (*DatabaseSecretEngineStaticRoleReconciler) Reconcile added in v0.8.3 

func (r *DatabaseSecretEngineStaticRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the DatabaseSecretEngineStaticRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*DatabaseSecretEngineStaticRoleReconciler) SetupWithManager added in v0.8.3 

func (r *DatabaseSecretEngineStaticRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type GitHubSecretEngineConfigReconciler 

type GitHubSecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

GitHubSecretEngineConfigReconciler reconciles a GitHubSecretEngineConfig object

func (*GitHubSecretEngineConfigReconciler) Reconcile 

func (r *GitHubSecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the GitHubSecretEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*GitHubSecretEngineConfigReconciler) SetupWithManager 

func (r *GitHubSecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type GitHubSecretEngineRoleReconciler 

type GitHubSecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

GitHubSecretEngineRoleReconciler reconciles a GitHubSecretEngineRole object

func (*GitHubSecretEngineRoleReconciler) Reconcile 

func (r *GitHubSecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the GitHubSecretEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*GitHubSecretEngineRoleReconciler) SetupWithManager 

func (r *GitHubSecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type JWTOIDCAuthEngineConfigReconciler added in v0.7.0 

type JWTOIDCAuthEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

JWTOIDCAuthEngineConfigReconciler reconciles a JWTOIDCAuthEngineConfig object

func (*JWTOIDCAuthEngineConfigReconciler) Reconcile added in v0.7.0 

func (r *JWTOIDCAuthEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the JWTOIDCAuthEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*JWTOIDCAuthEngineConfigReconciler) SetupWithManager added in v0.7.0 

func (r *JWTOIDCAuthEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

type JWTOIDCAuthEngineRoleReconciler added in v0.8.0 

type JWTOIDCAuthEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

JWTOIDCAuthEngineRoleReconciler reconciles a JWTOIDCAuthEngineRole object

func (*JWTOIDCAuthEngineRoleReconciler) Reconcile added in v0.8.0 

func (r *JWTOIDCAuthEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the JWTOIDCAuthEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*JWTOIDCAuthEngineRoleReconciler) SetupWithManager added in v0.8.0 

func (r *JWTOIDCAuthEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type KubernetesAuthEngineConfigReconciler 

type KubernetesAuthEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

KubernetesAuthEngineConfigReconciler reconciles a KubernetesAuthEngineConfig object

func (*KubernetesAuthEngineConfigReconciler) Reconcile 

func (r *KubernetesAuthEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the KubernetesAuthEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*KubernetesAuthEngineConfigReconciler) SetupWithManager 

func (r *KubernetesAuthEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type KubernetesAuthEngineRoleReconciler 

type KubernetesAuthEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

KubernetesAuthEngineRoleReconciler reconciles a KubernetesAuthEngineRole object

func (*KubernetesAuthEngineRoleReconciler) Reconcile 

func (r *KubernetesAuthEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the KubernetesAuthEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*KubernetesAuthEngineRoleReconciler) SetupWithManager 

func (r *KubernetesAuthEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type KubernetesSecretEngineConfigReconciler added in v0.6.0 

type KubernetesSecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

KubernetesSecretEngineConfigReconciler reconciles a KubernetesSecretEngineConfig object

func (*KubernetesSecretEngineConfigReconciler) Reconcile added in v0.6.0 

func (r *KubernetesSecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the KubernetesSecretEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*KubernetesSecretEngineConfigReconciler) SetupWithManager added in v0.6.0 

func (r *KubernetesSecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type KubernetesSecretEngineRoleReconciler added in v0.6.0 

type KubernetesSecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

KubernetesSecretEngineRoleReconciler reconciles a KubernetesSecretEngineRole object

func (*KubernetesSecretEngineRoleReconciler) Reconcile added in v0.6.0 

func (r *KubernetesSecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the KubernetesSecretEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*KubernetesSecretEngineRoleReconciler) SetupWithManager added in v0.6.0 

func (r *KubernetesSecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type LDAPAuthEngineConfigReconciler added in v0.5.0 

type LDAPAuthEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

LDAPAuthEngineConfigReconciler reconciles a LDAPAuthEngineConfig object

func (*LDAPAuthEngineConfigReconciler) Reconcile added in v0.5.0 

func (r *LDAPAuthEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the LDAPAuthEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*LDAPAuthEngineConfigReconciler) SetupWithManager added in v0.5.0 

func (r *LDAPAuthEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type LDAPAuthEngineGroupReconciler added in v0.5.1 

type LDAPAuthEngineGroupReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

LDAPAuthEngineGroupReconciler reconciles a LDAPAuthEngineGroup object

func (*LDAPAuthEngineGroupReconciler) Reconcile added in v0.5.1 

func (r *LDAPAuthEngineGroupReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the LDAPAuthEngineGroup object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*LDAPAuthEngineGroupReconciler) SetupWithManager added in v0.5.1 

func (r *LDAPAuthEngineGroupReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type PKISecretEngineConfigReconciler added in v0.3.0 

type PKISecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

PKISecretEngineConfigReconciler reconciles a PKISecretEngineConfig object

func (*PKISecretEngineConfigReconciler) Reconcile added in v0.3.0 

func (r *PKISecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the PKISecretEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*PKISecretEngineConfigReconciler) SetupWithManager added in v0.3.0 

func (r *PKISecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type PKISecretEngineRoleReconciler added in v0.3.0 

type PKISecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

PKISecretEngineRoleReconciler reconciles a PKISecretEngineRole object

func (*PKISecretEngineRoleReconciler) Reconcile added in v0.3.0 

func (r *PKISecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the PKISecretEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*PKISecretEngineRoleReconciler) SetupWithManager added in v0.3.0 

func (r *PKISecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type PasswordPolicyReconciler 

type PasswordPolicyReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

PasswordPolicyReconciler reconciles a PasswordPolicy object

func (*PasswordPolicyReconciler) Reconcile 

func (r *PasswordPolicyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the PasswordPolicy object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*PasswordPolicyReconciler) SetupWithManager 

func (r *PasswordPolicyReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type PolicyReconciler 

type PolicyReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

PolicyReconciler reconciles a Policy object

func (*PolicyReconciler) Reconcile 

func (r *PolicyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the Policy object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*PolicyReconciler) SetupWithManager 

func (r *PolicyReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type QuaySecretEngineConfigReconciler added in v0.4.0 

type QuaySecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

QuaySecretEngineConfigReconciler reconciles a QuaySecretEngineConfig object

func (*QuaySecretEngineConfigReconciler) Reconcile added in v0.4.0 

func (r *QuaySecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

func (*QuaySecretEngineConfigReconciler) SetupWithManager added in v0.4.0 

func (r *QuaySecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type QuaySecretEngineRoleReconciler added in v0.4.0 

type QuaySecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

QuaySecretEngineRoleReconciler reconciles a QuaySecretEngineRole object

func (*QuaySecretEngineRoleReconciler) Reconcile added in v0.4.0 

func (r *QuaySecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

func (*QuaySecretEngineRoleReconciler) SetupWithManager added in v0.4.0 

func (r *QuaySecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type QuaySecretEngineStaticRoleReconciler added in v0.4.0 

type QuaySecretEngineStaticRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

QuaySecretEngineStaticRoleReconciler reconciles a QuaySecretEngineStaticRole object

func (*QuaySecretEngineStaticRoleReconciler) Reconcile added in v0.4.0 

func (r *QuaySecretEngineStaticRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

func (*QuaySecretEngineStaticRoleReconciler) SetupWithManager added in v0.4.0 

func (r *QuaySecretEngineStaticRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type RabbitMQSecretEngineConfigReconciler 

type RabbitMQSecretEngineConfigReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

RabbitMQSecretEngineConfigReconciler reconciles a RabbitMQSecretEngineConfig object

func (*RabbitMQSecretEngineConfigReconciler) Reconcile 

func (r *RabbitMQSecretEngineConfigReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the RabbitMQSecretEngineConfig object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*RabbitMQSecretEngineConfigReconciler) SetupWithManager 

func (r *RabbitMQSecretEngineConfigReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type RabbitMQSecretEngineRoleReconciler 

type RabbitMQSecretEngineRoleReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

RabbitMQSecretEngineRoleReconciler reconciles a RabbitMQSecretEngineRole object

func (*RabbitMQSecretEngineRoleReconciler) Reconcile 

func (r *RabbitMQSecretEngineRoleReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the RabbitMQSecretEngineRole object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*RabbitMQSecretEngineRoleReconciler) SetupWithManager 

func (r *RabbitMQSecretEngineRoleReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type RandomSecretReconciler 

type RandomSecretReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

RandomSecretReconciler reconciles a RandomSecret object

func (*RandomSecretReconciler) Reconcile 

func (r *RandomSecretReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the RandomSecret object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*RandomSecretReconciler) SetupWithManager 

func (r *RandomSecretReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type SecretEngineMountReconciler 

type SecretEngineMountReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

SecretEngineMountReconciler reconciles a SecretEngineMount object

func (*SecretEngineMountReconciler) Reconcile 

func (r *SecretEngineMountReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state. TODO(user): Modify the Reconcile function to compare the state specified by the SecretEngineMount object against the actual cluster state, and then perform operations to make the cluster state reflect the state specified by the user.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*SecretEngineMountReconciler) SetupWithManager 

func (r *SecretEngineMountReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

type VaultAuthenticableResource added in v0.6.3 

type VaultAuthenticableResource interface {
	client.Object
	vaultutils.VaultObject
}

type VaultSecretReconciler 

type VaultSecretReconciler struct {
	util.ReconcilerBase
	Log            logr.Logger
	ControllerName string
}

VaultSecretReconciler reconciles a VaultSecret object

func (*VaultSecretReconciler) Reconcile 

func (r *VaultSecretReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the cluster closer to the desired state.

For more details, check Reconcile and its Result here: - https://pkgo.dev/sigs.k8s.io/[email protected]/pkg/reconcile

func (*VaultSecretReconciler) SetupWithManager 

func (r *VaultSecretReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

Source Files

View all Source files

Directories

Path Synopsis

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.
JackTT - Gopher 🇻🇳