controller

package
v0.0.0-...-34451c6 Latest Latest
Warning

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

 Go to latest Published: Jul 23, 2024 License: AGPL-3.0, Apache-2.0, MIT Imports: 32 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	ServiceFinalizer    = "deployments.plural.sh/service-protection"
	InventoryAnnotation = "config.k8s.io/owning-inventory"
)
View Source 
const (
	ClusterFinalizer = "deployments.plural.sh/cluster-protection"
)
View Source 
const CustomStackRunFinalizer = "deployments.plural.sh/stack-run-protection"
View Source 
const (
	GlobalServiceFinalizer = "deployments.plural.sh/global-service-protection"
)
View Source 
const InfrastructureStackFinalizer = "deployments.plural.sh/stack-protection"
View Source 
const ManagedNamespaceFinalizer = "deployments.plural.sh/managed-namespace-protection"
View Source 
const (
	NamespaceCredentialsFinalizer = "deployments.plural.sh/namespace-credentials-protection"
)
View Source 
const NotificationRouterFinalizer = "deployments.plural.sh/notification-router-protection"
View Source 
const (
	NotificationSinkFinalizer = "deployments.plural.sh/notification-sink-protection"
)
View Source 
const (
	PipelineFinalizer = "deployments.plural.sh/pipeline-protection"
)
View Source 
const (
	// PrAutomationProtectionFinalizerName defines name for the main finalizer that synchronizes
	// resource deletion from the Console API prior to removing the CRD.
	PrAutomationProtectionFinalizerName = "providers.deployments.plural.sh/provider-protection"
)
View Source 
const (
	// ProjectProtectionFinalizerName defines name for the main finalizer that synchronizes
	// resource deletion from the Console API prior to removing the CRD.
	ProjectProtectionFinalizerName = "projects.deployments.plural.sh/project-protection"
)
View Source 
const (
	// ProviderProtectionFinalizerName defines name for the main finalizer that synchronizes
	// resource deletion from the Console API prior to removing the CRD.
	ProviderProtectionFinalizerName = "providers.deployments.plural.sh/provider-protection"
)
View Source 
const (
	RepoFinalizer = "deployments.plural.sh/gitrepo-protection"
)
View Source 
const (
	// ScmConnectionProtectionFinalizerName defines name for the main finalizer that synchronizes
	// resource deletion from the Console API prior to removing the CRD.
	ScmConnectionProtectionFinalizerName = "scmconnections.deployments.plural.sh/scmconnection-protection"
)
View Source 
const StackDefinitionFinalizer = "deployments.plural.sh/stackdefinition-protection"

Variables

This section is empty.

Functions

This section is empty.

Types

type ClusterReconciler 

type ClusterReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	UserGroupCache   cache.UserGroupCache
	CredentialsCache credentials.NamespaceCredentialsCache
}

ClusterReconciler reconciles a Cluster object.

func (*ClusterReconciler) Reconcile 

func (r *ClusterReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

func (*ClusterReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ClusterRestoreReconciler 

type ClusterRestoreReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

ClusterRestoreReconciler reconciles a ClusterRestore object

func (*ClusterRestoreReconciler) Reconcile 

func (r *ClusterRestoreReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ reconcile.Result, reterr 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.

func (*ClusterRestoreReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ClusterRestoreScope 

type ClusterRestoreScope struct {
	Client  client.Client
	Restore *v1alpha1.ClusterRestore
	// contains filtered or unexported fields
}

func NewClusterRestoreScope 

func NewClusterRestoreScope(ctx context.Context, client client.Client, restore *v1alpha1.ClusterRestore) (*ClusterRestoreScope, error)

func (*ClusterRestoreScope) PatchObject 

func (p *ClusterRestoreScope) PatchObject() error

type ClusterRestoreTrigger 

type ClusterRestoreTrigger struct {
	Client  client.Client
	Trigger *v1alpha1.ClusterRestoreTrigger
	// contains filtered or unexported fields
}

func NewClusterRestoreTriggerScope 

func NewClusterRestoreTriggerScope(ctx context.Context, client client.Client, trigger *v1alpha1.ClusterRestoreTrigger) (*ClusterRestoreTrigger, error)

func (*ClusterRestoreTrigger) PatchObject 

func (p *ClusterRestoreTrigger) PatchObject() error

type ClusterRestoreTriggerReconciler 

type ClusterRestoreTriggerReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

ClusterRestoreTriggerReconciler reconciles a ClusterRestoreTrigger object

func (*ClusterRestoreTriggerReconciler) Reconcile 

func (r *ClusterRestoreTriggerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ reconcile.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*ClusterRestoreTriggerReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ClusterScope 

type ClusterScope struct {
	Client  client.Client
	Cluster *v1alpha1.Cluster
	// contains filtered or unexported fields
}

func NewClusterScope 

func NewClusterScope(ctx context.Context, client client.Client, cluster *v1alpha1.Cluster) (*ClusterScope, error)

func (*ClusterScope) PatchObject 

func (p *ClusterScope) PatchObject() error

type CustomStackRunReconciler 

type CustomStackRunReconciler struct {
	client.Client
	Scheme           *runtime.Scheme
	ConsoleClient    consoleclient.ConsoleClient
	CredentialsCache credentials.NamespaceCredentialsCache
}

CustomStackRunReconciler reconciles a CustomStackRun object

func (*CustomStackRunReconciler) Reconcile 

func (r *CustomStackRunReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*CustomStackRunReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type CustomStackRunScope 

type CustomStackRunScope struct {
	Client         client.Client
	CustomStackRun *v1alpha1.CustomStackRun
	// contains filtered or unexported fields
}

func NewCustomStackRunScope 

func NewCustomStackRunScope(ctx context.Context, client client.Client, customStackRun *v1alpha1.CustomStackRun) (*CustomStackRunScope, error)

func (*CustomStackRunScope) PatchObject 

func (p *CustomStackRunScope) PatchObject() error

type DefaultScope 

type DefaultScope[T client.Object] struct {
	// contains filtered or unexported fields
}

func (*DefaultScope[T]) PatchObject 

func (in *DefaultScope[T]) PatchObject() error

type DeploymentSettingsReconciler 

type DeploymentSettingsReconciler struct {
	client.Client
	Scheme           *runtime.Scheme
	ConsoleClient    consoleclient.ConsoleClient
	CredentialsCache credentials.NamespaceCredentialsCache
}

DeploymentSettingsReconciler reconciles a DeploymentSettings object

func (*DeploymentSettingsReconciler) Reconcile 

func (r *DeploymentSettingsReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*DeploymentSettingsReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type DeploymentSettingsScope 

type DeploymentSettingsScope struct {
	Client             client.Client
	DeploymentSettings *v1alpha1.DeploymentSettings
	// contains filtered or unexported fields
}

func NewDeploymentSettingsScope 

func NewDeploymentSettingsScope(ctx context.Context, client client.Client, ds *v1alpha1.DeploymentSettings) (*DeploymentSettingsScope, error)

func (*DeploymentSettingsScope) PatchObject 

func (p *DeploymentSettingsScope) PatchObject() error

type GitRepoCred 

type GitRepoCred struct {
	PrivateKey *string
	Passphrase *string
	Username   *string
	Password   *string
}

type GitRepositoryReconciler 

type GitRepositoryReconciler struct {
	client.Client
	ConsoleClient consoleclient.ConsoleClient
	Scheme        *runtime.Scheme
}

GitRepositoryReconciler reconciles a GitRepository object

func (*GitRepositoryReconciler) Reconcile 

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

func (*GitRepositoryReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type GitRepositoryScope 

type GitRepositoryScope struct {
	Client        client.Client
	GitRepository *v1alpha1.GitRepository
	// contains filtered or unexported fields
}

func NewGitRepositoryScope 

func NewGitRepositoryScope(ctx context.Context, client client.Client, repository *v1alpha1.GitRepository) (*GitRepositoryScope, error)

func (*GitRepositoryScope) PatchObject 

func (p *GitRepositoryScope) PatchObject() error

type GlobalServiceReconciler 

type GlobalServiceReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

GlobalServiceReconciler reconciles a GlobalService object

func (*GlobalServiceReconciler) Reconcile 

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

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

For more details, check Reconcile and its Result here: - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*GlobalServiceReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type GlobalServiceScope 

type GlobalServiceScope struct {
	Client  client.Client
	Service *v1alpha1.GlobalService
	// contains filtered or unexported fields
}

func NewGlobalServiceScope 

func NewGlobalServiceScope(ctx context.Context, client client.Client, service *v1alpha1.GlobalService) (*GlobalServiceScope, error)

func (*GlobalServiceScope) PatchObject 

func (p *GlobalServiceScope) PatchObject() error

type InfrastructureStackReconciler 

type InfrastructureStackReconciler struct {
	client.Client
	Scheme           *runtime.Scheme
	ConsoleClient    consoleclient.ConsoleClient
	UserGroupCache   cache.UserGroupCache
	CredentialsCache credentials.NamespaceCredentialsCache
}

InfrastructureStackReconciler reconciles a InfrastructureStack object

func (*InfrastructureStackReconciler) Reconcile 

func (r *InfrastructureStackReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*InfrastructureStackReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type InfrastructureStackScope 

type InfrastructureStackScope struct {
	Client client.Client
	// contains filtered or unexported fields
}

func NewInfrastructureStackScope 

func NewInfrastructureStackScope(ctx context.Context, client client.Client, infrastructureStack *v1alpha1.InfrastructureStack) (*InfrastructureStackScope, error)

func (*InfrastructureStackScope) PatchObject 

func (p *InfrastructureStackScope) PatchObject() error

type ManagedNamespaceReconciler 

type ManagedNamespaceReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

ManagedNamespaceReconciler reconciles a ManagedNamespace object

func (*ManagedNamespaceReconciler) Reconcile 

func (r *ManagedNamespaceReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*ManagedNamespaceReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ManagedNamespaceScope 

type ManagedNamespaceScope struct {
	Client           client.Client
	ManagedNamespace *v1alpha1.ManagedNamespace
	// contains filtered or unexported fields
}

func NewManagedNamespaceScope 

func NewManagedNamespaceScope(ctx context.Context, client client.Client, managedNamespace *v1alpha1.ManagedNamespace) (*ManagedNamespaceScope, error)

func (*ManagedNamespaceScope) PatchObject 

func (p *ManagedNamespaceScope) PatchObject() error

type NamespaceCredentialsReconciler 

type NamespaceCredentialsReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

NamespaceCredentialsReconciler reconciles a v1alpha1.NamespaceCredentials object. Implements reconcile.Reconciler and types.Controller

func (*NamespaceCredentialsReconciler) Reconcile 

func (r *NamespaceCredentialsReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to sync v1alpha1.NamespaceCredentials with a global credentials map that will be later used by other reconcilers.

func (*NamespaceCredentialsReconciler) SetupWithManager 

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

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type NamespaceCredentialsScope 

type NamespaceCredentialsScope struct {
	Client               client.Client
	NamespaceCredentials *v1alpha1.NamespaceCredentials
	// contains filtered or unexported fields
}

func NewNamespaceCredentialsScope 

func NewNamespaceCredentialsScope(ctx context.Context, client client.Client, nc *v1alpha1.NamespaceCredentials) (*NamespaceCredentialsScope, error)

func (*NamespaceCredentialsScope) PatchObject 

func (in *NamespaceCredentialsScope) PatchObject() error

type NotificationRouterReconciler 

type NotificationRouterReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

NotificationRouterReconciler reconciles a NotificationRouter object

func (*NotificationRouterReconciler) Reconcile 

func (r *NotificationRouterReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*NotificationRouterReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type NotificationRouterScope 

type NotificationRouterScope struct {
	Client             client.Client
	NotificationRouter *v1alpha1.NotificationRouter
	// contains filtered or unexported fields
}

func NewNotificationRouterScope 

func NewNotificationRouterScope(ctx context.Context, client client.Client, notification *v1alpha1.NotificationRouter) (*NotificationRouterScope, error)

func (*NotificationRouterScope) PatchObject 

func (p *NotificationRouterScope) PatchObject() error

type NotificationSinkReconciler 

type NotificationSinkReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

NotificationSinkReconciler reconciles a NotificationSink object

func (*NotificationSinkReconciler) Reconcile 

func (r *NotificationSinkReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*NotificationSinkReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type NotificationSinkScope 

type NotificationSinkScope struct {
	Client           client.Client
	NotificationSink *v1alpha1.NotificationSink
	// contains filtered or unexported fields
}

func NewNotificationSinkScope 

func NewNotificationSinkScope(ctx context.Context, client client.Client, notificationSink *v1alpha1.NotificationSink) (*NotificationSinkScope, error)

func (*NotificationSinkScope) PatchObject 

func (p *NotificationSinkScope) PatchObject() error

type PipelineContext 

type PipelineContext struct {
	Client  client.Client
	Context *v1alpha1.PipelineContext
	// contains filtered or unexported fields
}

func NewPipelineContextScope 

func NewPipelineContextScope(ctx context.Context, client client.Client, context *v1alpha1.PipelineContext) (*PipelineContext, error)

func (*PipelineContext) PatchObject 

func (p *PipelineContext) PatchObject() error

type PipelineContextReconciler 

type PipelineContextReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

PipelineContextReconciler reconciles a PipelineContext object

func (*PipelineContextReconciler) Reconcile 

func (r *PipelineContextReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ reconcile.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*PipelineContextReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type PipelineReconciler 

type PipelineReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

PipelineReconciler reconciles a Pipeline object

func (*PipelineReconciler) Reconcile 

func (r *PipelineReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ reconcile.Result, reterr 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.

func (*PipelineReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type PipelineScope 

type PipelineScope struct {
	Client   client.Client
	Pipeline *v1alpha1.Pipeline
	// contains filtered or unexported fields
}

func NewPipelineScope 

func NewPipelineScope(ctx context.Context, client client.Client, pipeline *v1alpha1.Pipeline) (*PipelineScope, error)

func (*PipelineScope) PatchObject 

func (p *PipelineScope) PatchObject() error

type PrAutomationReconciler 

type PrAutomationReconciler struct {
	client.Client

	ConsoleClient consoleclient.ConsoleClient
	Scheme        *runtime.Scheme
}

PrAutomationReconciler reconciles a v1alpha1.PrAutomation object. Implements reconcile.Reconciler and types.Controller

func (*PrAutomationReconciler) Reconcile 

func (in *PrAutomationReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the v1alpha1.PrAutomation closer to the desired state and syncs it with the Console API state.

func (*PrAutomationReconciler) SetupWithManager 

func (in *PrAutomationReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type PrAutomationScope 

type PrAutomationScope struct {
	Client       client.Client
	PrAutomation *v1alpha1.PrAutomation
	// contains filtered or unexported fields
}

func NewPrAutomationScope 

func NewPrAutomationScope(ctx context.Context, client client.Client, prAutomation *v1alpha1.PrAutomation) (*PrAutomationScope, error)

func (*PrAutomationScope) PatchObject 

func (p *PrAutomationScope) PatchObject() error

type PrAutomationTrigger 

type PrAutomationTrigger struct {
	Client  client.Client
	Trigger *v1alpha1.PrAutomationTrigger
	// contains filtered or unexported fields
}

func NewPrAutomationTriggerScope 

func NewPrAutomationTriggerScope(ctx context.Context, client client.Client, trigger *v1alpha1.PrAutomationTrigger) (*PrAutomationTrigger, error)

func (*PrAutomationTrigger) PatchObject 

func (p *PrAutomationTrigger) PatchObject() error

type PrAutomationTriggerReconciler 

type PrAutomationTriggerReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

PrAutomationTriggerReconciler reconciles a PrAutomationTrigger object

func (*PrAutomationTriggerReconciler) Reconcile 

func (r *PrAutomationTriggerReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ reconcile.Result, reterr 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*PrAutomationTriggerReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ProjectReconciler 

type ProjectReconciler struct {
	client.Client

	ConsoleClient  consoleclient.ConsoleClient
	Scheme         *runtime.Scheme
	UserGroupCache cache.UserGroupCache
}

ProjectReconciler reconciles a v1alpha1.Project object. Implements reconcile.Reconciler and types.Controller.

func (*ProjectReconciler) Reconcile 

func (in *ProjectReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, retErr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the v1alpha1.Project closer to the desired state and syncs it with the Console API state.

func (*ProjectReconciler) SetupWithManager 

func (in *ProjectReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type ProjectScope 

type ProjectScope struct {
	Client  client.Client
	Project *v1alpha1.Project
	// contains filtered or unexported fields
}

func NewProjectScope 

func NewProjectScope(ctx context.Context, client client.Client, project *v1alpha1.Project) (*ProjectScope, error)

func (*ProjectScope) PatchObject 

func (in *ProjectScope) PatchObject() error

type ProviderReconciler 

type ProviderReconciler struct {
	client.Client

	ConsoleClient consoleclient.ConsoleClient
	Scheme        *runtime.Scheme
}

ProviderReconciler reconciles a v1alpha1.Provider object. Implements reconcile.Reconciler and types.Controller

func (*ProviderReconciler) Reconcile 

func (r *ProviderReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the v1alpha1.Provider closer to the desired state and syncs it with the Console API state.

func (*ProviderReconciler) SetupWithManager 

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

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type ProviderScope 

type ProviderScope struct {
	Client   client.Client
	Provider *v1alpha1.Provider
	// contains filtered or unexported fields
}

func NewProviderScope 

func NewProviderScope(ctx context.Context, client client.Client, provider *v1alpha1.Provider) (*ProviderScope, error)

func (*ProviderScope) PatchObject 

func (p *ProviderScope) PatchObject() error

type ScmConnectionReconciler 

type ScmConnectionReconciler struct {
	client.Client

	ConsoleClient consoleclient.ConsoleClient
	Scheme        *runtime.Scheme
}

ScmConnectionReconciler reconciles a v1alpha1.ScmConnection object. Implements reconcile.Reconciler and types.Controller

func (*ScmConnectionReconciler) Reconcile 

func (r *ScmConnectionReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the v1alpha1.ScmConnection closer to the desired state and syncs it with the Console API state.

func (*ScmConnectionReconciler) SetupWithManager 

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

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type ScmConnectionScope 

type ScmConnectionScope struct {
	Client        client.Client
	ScmConnection *v1alpha1.ScmConnection
	// contains filtered or unexported fields
}

func NewScmConnectionScope 

func NewScmConnectionScope(ctx context.Context, client client.Client, provider *v1alpha1.ScmConnection) (*ScmConnectionScope, error)

func (*ScmConnectionScope) PatchObject 

func (p *ScmConnectionScope) PatchObject() error

type Scope 

type Scope[T client.Object] interface {
	PatchObject() error
}

func NewDefaultScope 

func NewDefaultScope[T client.Object](ctx context.Context, client client.Client, object T) (Scope[T], error)

type ServiceAccountReconciler 

type ServiceAccountReconciler struct {
	client.Client

	ConsoleClient consoleclient.ConsoleClient
	Scheme        *runtime.Scheme
}

ServiceAccountReconciler reconciles a v1alpha1.ServiceAccount object. Implements reconcile.Reconciler and types.Controller

func (*ServiceAccountReconciler) Reconcile 

func (r *ServiceAccountReconciler) Reconcile(ctx context.Context, req reconcile.Request) (_ reconcile.Result, reterr error)

Reconcile is part of the main kubernetes reconciliation loop which aims to move the current state of the v1alpha1.ServiceAccount closer to the desired state and syncs it with the Console API state.

func (*ServiceAccountReconciler) SetupWithManager 

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

SetupWithManager is responsible for initializing new reconciler within provided ctrl.Manager.

type ServiceAccountScope 

type ServiceAccountScope struct {
	Client         client.Client
	ServiceAccount *v1alpha1.ServiceAccount
	// contains filtered or unexported fields
}

func NewServiceAccountScope 

func NewServiceAccountScope(ctx context.Context, client client.Client, sa *v1alpha1.ServiceAccount) (*ServiceAccountScope, error)

func (*ServiceAccountScope) PatchObject 

func (in *ServiceAccountScope) PatchObject() error

type ServiceReconciler 

type ServiceReconciler struct {
	client.Client
	ConsoleClient    consoleclient.ConsoleClient
	UserGroupCache   cache.UserGroupCache
	Scheme           *runtime.Scheme
	CredentialsCache credentials.NamespaceCredentialsCache
}

ServiceReconciler reconciles a Service object

func (*ServiceReconciler) MergeHelmValues 

func (r *ServiceReconciler) MergeHelmValues(ctx context.Context, secretRef *corev1.SecretReference, values *runtime.RawExtension) (*string, error)

func (*ServiceReconciler) Reconcile 

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

func (*ServiceReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ServiceScope 

type ServiceScope struct {
	Client  client.Client
	Service *v1alpha1.ServiceDeployment
	// contains filtered or unexported fields
}

func NewServiceScope 

func NewServiceScope(ctx context.Context, client client.Client, service *v1alpha1.ServiceDeployment) (*ServiceScope, error)

func (*ServiceScope) PatchObject 

func (p *ServiceScope) PatchObject() error

type StackDefinitionReconciler 

type StackDefinitionReconciler struct {
	client.Client
	Scheme           *runtime.Scheme
	ConsoleClient    consoleclient.ConsoleClient
	CredentialsCache credentials.NamespaceCredentialsCache
}

StackDefinitionReconciler reconciles a v1alpha1.StackDefinition object

func (*StackDefinitionReconciler) Reconcile 

func (in *StackDefinitionReconciler) Reconcile(ctx context.Context, req ctrl.Request) (_ ctrl.Result, reterr error)

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

func (*StackDefinitionReconciler) SetupWithManager 

func (in *StackDefinitionReconciler) SetupWithManager(mgr ctrl.Manager) error

SetupWithManager sets up the controller with the Manager.

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.