controller

package
v0.1.2 Latest Latest
Warning

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

 Go to latest Published: Nov 7, 2025 License: Apache-2.0 Imports: 26 Imported by: 0

Documentation

Overview

Package controller implements all reconciler logic

Index

Constants

View Source 
const (
	AlertSystemPort          = 9908
	AlertWebserverPort       = 3000
	AssetGRPCPort            = 8091
	AssetHTTPPort            = 8090
	BlockAssemblyPort        = 8085
	BlockchainGRPCPort       = 8087
	BlockchainHTTPPort       = 8082
	BlockValidationGRPCPort  = 8088
	BlockValidationHTTPPort  = 8188
	BootstrapGRPCPort        = 8089
	BootstrapHTTPPort        = 8099
	CoinbaseGRPCPort         = 8093
	CoinbaseHTTPPort         = 8094
	CoinbaseP2PPort          = 9907
	MinerHTTPPort            = 8092
	PeerPort                 = 9905
	PeerLegacyPort           = 8333
	PeerHTTPPort             = 9906
	PropagationGRPCPort      = 8084
	PropagationHTTPPort      = 8833
	PropagationQuicPort      = 8384
	RPCPort                  = 9292
	SubtreeValidatorGRPCPort = 8086
	LegacyHTTPPort           = 8098
	ProfilerPort             = 9091
	DebuggerPort             = 4040
	HealthPort               = 8000
)
View Source 
const BlockchainServiceName = "blockchain"
View Source 
const DefaultCoinbaseImage = "434394763103.dkr.ecr.eu-north-1.amazonaws.com/teranode-coinbase:v0.1.0"

DefaultCoinbaseImage is the default coinbase service image

View Source 
const DefaultImage = "434394763103.dkr.ecr.eu-north-1.amazonaws.com/teranode-public:v0.6.2"

DefaultImage is the default teranode service image

View Source 
const DefaultServiceAccountName = "teranode-operator-service-runner"

DefaultServiceAccountName defines the name of the service acount created by the bundle

View Source 
const SharedPVCName = "cluster-storage"

SharedPVCName is the PVC name for shared storage

View Source 
const (
	UtxoPersisterName = "utxo-persister"
)

Variables

View Source 
var ErrFSMDisabled = errors.New("finite state machine is disabled")

ErrFSMDisabled is returned when the finite state machine is disabled

Functions

This section is empty.

Types

type AlertSystemReconciler 

type AlertSystemReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	Context        context.Context //nolint:containedctx // Required for reconciler pattern
}

AlertSystemReconciler reconciles a AlertSystem object

func (*AlertSystemReconciler) Reconcile 

func (r *AlertSystemReconciler) 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 AlertSystem 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.17.3/pkg/reconcile

func (*AlertSystemReconciler) ReconcileDeployment 

func (r *AlertSystemReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the alert service deployment reconciler

func (*AlertSystemReconciler) ReconcileService 

func (r *AlertSystemReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the alert service reconciler

func (*AlertSystemReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type AssetReconciler 

type AssetReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	Context        context.Context //nolint:containedctx // Required for reconciler pattern
}

AssetReconciler reconciles a Asset object

func (*AssetReconciler) Reconcile 

func (r *AssetReconciler) 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 Asset 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*AssetReconciler) ReconcileDeployment 

func (r *AssetReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the asset service deployment reconciler

func (*AssetReconciler) ReconcileHTTPIngress 

func (r *AssetReconciler) ReconcileHTTPIngress(log logr.Logger) (bool, error)

ReconcileHTTPIngress is the ingress for the asset grpc server

func (*AssetReconciler) ReconcileHTTPSIngress 

func (r *AssetReconciler) ReconcileHTTPSIngress(log logr.Logger) (bool, error)

ReconcileHTTPSIngress is the ingress for the asset grpc server

func (*AssetReconciler) ReconcileService 

func (r *AssetReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the asset service reconciler

func (*AssetReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type BlockAssemblyReconciler 

type BlockAssemblyReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	Context        context.Context //nolint:containedctx // Required for reconciler pattern
}

BlockAssemblyReconciler reconciles a BlockAssembly object

func (*BlockAssemblyReconciler) Reconcile 

func (r *BlockAssemblyReconciler) 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 BlockAssembly 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*BlockAssemblyReconciler) ReconcileDeployment 

func (r *BlockAssemblyReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the block assembly service deployment reconciler

func (*BlockAssemblyReconciler) ReconcileService 

func (r *BlockAssemblyReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the blockassembly service reconciler

func (*BlockAssemblyReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type BlockPersisterReconciler 

type BlockPersisterReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	Context        context.Context //nolint:containedctx // Required for reconciler pattern
}

BlockPersisterReconciler reconciles a BlockPersister object

func (*BlockPersisterReconciler) Reconcile 

func (r *BlockPersisterReconciler) 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 BlockPersister 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*BlockPersisterReconciler) ReconcileDeployment 

func (r *BlockPersisterReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the block persister service deployment reconciler

func (*BlockPersisterReconciler) ReconcileService 

func (r *BlockPersisterReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the blockPersister service reconciler

func (*BlockPersisterReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type BlockValidatorReconciler 

type BlockValidatorReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	Context        context.Context //nolint:containedctx // Required for reconciler pattern
}

BlockValidatorReconciler reconciles a BlockValidator object

func (*BlockValidatorReconciler) Reconcile 

func (r *BlockValidatorReconciler) 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 BlockValidator 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*BlockValidatorReconciler) ReconcileDeployment 

func (r *BlockValidatorReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the blockchain service deployment reconciler

func (*BlockValidatorReconciler) ReconcileService 

func (r *BlockValidatorReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the block-validator service reconciler

func (*BlockValidatorReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type BlockchainReconciler 

type BlockchainReconciler struct {
	client.Client

	BlockchainClient blockchain.ClientI
	Scheme           *runtime.Scheme
	Log              logr.Logger
	NamespacedName   types.NamespacedName
	Context          context.Context //nolint:containedctx // Required for reconciler pattern
}

BlockchainReconciler reconciles a Blockchain object

func (*BlockchainReconciler) GetFSMState 

func (r *BlockchainReconciler) GetFSMState(log logr.Logger) (*blockchain.FSMStateType, error)

GetFSMState gets the current state of the FSM

func (*BlockchainReconciler) IsLegacyEnabled 

func (r *BlockchainReconciler) IsLegacyEnabled() (bool, error)

func (*BlockchainReconciler) Reconcile 

func (r *BlockchainReconciler) 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 Blockchain 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*BlockchainReconciler) ReconcileDeployment 

func (r *BlockchainReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the blockchain service deployment reconciler

func (*BlockchainReconciler) ReconcileService 

func (r *BlockchainReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the blockchain service reconciler

func (*BlockchainReconciler) ReconcileState 

func (r *BlockchainReconciler) ReconcileState(state blockchain.FSMStateType) error

func (*BlockchainReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type BootstrapReconciler 

type BootstrapReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

BootstrapReconciler reconciles a Bootstrap object

func (*BootstrapReconciler) Reconcile 

func (r *BootstrapReconciler) 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 Bootstrap 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*BootstrapReconciler) ReconcileDeployment 

func (r *BootstrapReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the bootstrap service deployment reconciler

func (*BootstrapReconciler) ReconcileService 

func (r *BootstrapReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the bootstrap service reconciler

func (*BootstrapReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ClusterReconciler 

type ClusterReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

ClusterReconciler reconciles a Cluster object

func (*ClusterReconciler) Reconcile 

func (r *ClusterReconciler) 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 Cluster 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*ClusterReconciler) ReconcileAdditionalIngresses 

func (r *ClusterReconciler) ReconcileAdditionalIngresses(log logr.Logger) (bool, error)

ReconcileAdditionalIngresses defines the network policy reconciler

func (*ClusterReconciler) ReconcileAlertSystem 

func (r *ClusterReconciler) ReconcileAlertSystem(log logr.Logger) (bool, error)

ReconcileAlertSystem is the alert system reconciler

func (*ClusterReconciler) ReconcileAsset 

func (r *ClusterReconciler) ReconcileAsset(log logr.Logger) (bool, error)

ReconcileAsset is the asset reconciler

func (*ClusterReconciler) ReconcileBlockAssembly 

func (r *ClusterReconciler) ReconcileBlockAssembly(log logr.Logger) (bool, error)

ReconcileBlockAssembly is the cluster blockassembly reconciler

func (*ClusterReconciler) ReconcileBlockPersister 

func (r *ClusterReconciler) ReconcileBlockPersister(log logr.Logger) (bool, error)

ReconcileBlockPersister is the cluster blockpersister reconciler

func (*ClusterReconciler) ReconcileBlockValidator 

func (r *ClusterReconciler) ReconcileBlockValidator(log logr.Logger) (bool, error)

ReconcileBlockValidator is the cluster blockvalidator reconciler

func (*ClusterReconciler) ReconcileBlockchain 

func (r *ClusterReconciler) ReconcileBlockchain(log logr.Logger) (bool, error)

ReconcileBlockchain is the cluster blockchain reconciler

func (*ClusterReconciler) ReconcileBootstrap 

func (r *ClusterReconciler) ReconcileBootstrap(log logr.Logger) (bool, error)

ReconcileBootstrap is the cluster bootstrap reconciler

func (*ClusterReconciler) ReconcileCoinbase 

func (r *ClusterReconciler) ReconcileCoinbase(log logr.Logger) (bool, error)

ReconcileCoinbase is the cluster coinbase reconciler

func (*ClusterReconciler) ReconcileLegacy 

func (r *ClusterReconciler) ReconcileLegacy(log logr.Logger) (bool, error)

ReconcileLegacy is the cluster coinbase reconciler

func (*ClusterReconciler) ReconcileNetworkPolicy 

func (r *ClusterReconciler) ReconcileNetworkPolicy(log logr.Logger) (bool, error)

ReconcileNetworkPolicy defines the network policy reconciler

func (*ClusterReconciler) ReconcilePVC 

func (r *ClusterReconciler) ReconcilePVC(log logr.Logger) (bool, error)

ReconcilePVC is the postgres PVC

func (*ClusterReconciler) ReconcilePeer 

func (r *ClusterReconciler) ReconcilePeer(log logr.Logger) (bool, error)

ReconcilePeer is the cluster peer reconciler

func (*ClusterReconciler) ReconcilePropagation 

func (r *ClusterReconciler) ReconcilePropagation(log logr.Logger) (bool, error)

ReconcilePropagation is the cluster propagation reconciler

func (*ClusterReconciler) ReconcileRPC 

func (r *ClusterReconciler) ReconcileRPC(log logr.Logger) (bool, error)

ReconcileRPC is the cluster rpc reconciler

func (*ClusterReconciler) ReconcileSubtreeValidator 

func (r *ClusterReconciler) ReconcileSubtreeValidator(log logr.Logger) (bool, error)

ReconcileSubtreeValidator is the cluster subtreeValidator reconciler

func (*ClusterReconciler) ReconcileUtxoPersister 

func (r *ClusterReconciler) ReconcileUtxoPersister(log logr.Logger) (bool, error)

ReconcileUtxoPersister is the cluster coinbase reconciler

func (*ClusterReconciler) ReconcileValidator 

func (r *ClusterReconciler) ReconcileValidator(log logr.Logger) (bool, error)

ReconcileValidator is the cluster validator reconciler

func (*ClusterReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type CoinbaseReconciler 

type CoinbaseReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

CoinbaseReconciler reconciles a Coinbase object

func (*CoinbaseReconciler) Reconcile 

func (r *CoinbaseReconciler) 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 Coinbase 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*CoinbaseReconciler) ReconcileDeployment 

func (r *CoinbaseReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the coinbase service deployment reconciler

func (*CoinbaseReconciler) ReconcileGrpcIngress 

func (r *CoinbaseReconciler) ReconcileGrpcIngress(log logr.Logger) (bool, error)

ReconcileGrpcIngress is the ingress for the coinbase grpc server

func (*CoinbaseReconciler) ReconcileService 

func (r *CoinbaseReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the coinbase service reconciler

func (*CoinbaseReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type FaucetReconciler 

type FaucetReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

FaucetReconciler reconciles a Faucet object

func (*FaucetReconciler) Reconcile 

func (r *FaucetReconciler) 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 Faucet 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*FaucetReconciler) ReconcileDeployment 

func (r *FaucetReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the faucet service deployment reconciler

func (*FaucetReconciler) ReconcileService 

func (r *FaucetReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the faucet service reconciler

func (*FaucetReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type LegacyReconciler 

type LegacyReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

LegacyReconciler reconciles a Legacy object

func (*LegacyReconciler) Reconcile 

func (r *LegacyReconciler) 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 Legacy 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*LegacyReconciler) ReconcileDeployment 

func (r *LegacyReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the legacy service deployment reconciler

func (*LegacyReconciler) ReconcileService 

func (r *LegacyReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the legacy service reconciler

func (*LegacyReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type PeerReconciler 

type PeerReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

PeerReconciler reconciles a Peer object

func (*PeerReconciler) Reconcile 

func (r *PeerReconciler) 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 Peer 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*PeerReconciler) ReconcileDeployment 

func (r *PeerReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the peer service deployment reconciler

func (*PeerReconciler) ReconcileGrpcIngress 

func (r *PeerReconciler) ReconcileGrpcIngress(log logr.Logger) (bool, error)

ReconcileGrpcIngress is the ingress for the peer grpc server

func (*PeerReconciler) ReconcileService 

func (r *PeerReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the peer service reconciler

func (*PeerReconciler) ReconcileWsIngress 

func (r *PeerReconciler) ReconcileWsIngress(log logr.Logger) (bool, error)

ReconcileWsIngress is the ingress for the peer ws server

func (*PeerReconciler) ReconcileWssIngress 

func (r *PeerReconciler) ReconcileWssIngress(log logr.Logger) (bool, error)

ReconcileWssIngress is the ingress for the peer wss server

func (*PeerReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type PropagationReconciler 

type PropagationReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

PropagationReconciler reconciles a Propagation object

func (*PropagationReconciler) Reconcile 

func (r *PropagationReconciler) 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 Propagation 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*PropagationReconciler) ReconcileDeployment 

func (r *PropagationReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the propagation service deployment reconciler

func (*PropagationReconciler) ReconcileGrpcIngress 

func (r *PropagationReconciler) ReconcileGrpcIngress(log logr.Logger) (bool, error)

ReconcileGrpcIngress is the ingress for the propagation grpc server

func (*PropagationReconciler) ReconcileService 

func (r *PropagationReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the propagation service reconciler

func (*PropagationReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type RPCReconciler 

type RPCReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

RPCReconciler reconciles a RPC object

func (*RPCReconciler) Reconcile 

func (r *RPCReconciler) 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 RPC 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.17.3/pkg/reconcile

func (*RPCReconciler) ReconcileDeployment 

func (r *RPCReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the rpc service deployment reconciler

func (*RPCReconciler) ReconcileService 

func (r *RPCReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the rpc service reconciler

func (*RPCReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type SubtreeValidatorReconciler 

type SubtreeValidatorReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

SubtreeValidatorReconciler reconciles a SubtreeValidator object

func (*SubtreeValidatorReconciler) Reconcile 

func (r *SubtreeValidatorReconciler) 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 SubtreeValidator 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*SubtreeValidatorReconciler) ReconcileDeployment 

func (r *SubtreeValidatorReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the subtreeValidator service deployment reconciler

func (*SubtreeValidatorReconciler) ReconcileService 

func (r *SubtreeValidatorReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the subtree-validator service reconciler

func (*SubtreeValidatorReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type UtxoPersisterReconciler 

type UtxoPersisterReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

UtxoPersisterReconciler reconciles a UtxoPersister object

func (*UtxoPersisterReconciler) Reconcile 

func (r *UtxoPersisterReconciler) 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.17.3/pkg/reconcile

func (*UtxoPersisterReconciler) ReconcileDeployment 

func (r *UtxoPersisterReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the utxo persister service deployment reconciler

func (*UtxoPersisterReconciler) ReconcileService 

func (r *UtxoPersisterReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the utxop service reconciler

func (*UtxoPersisterReconciler) SetupWithManager 

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

SetupWithManager sets up the controller with the Manager.

type ValidatorReconciler 

type ValidatorReconciler struct {
	client.Client

	Scheme         *runtime.Scheme
	Log            logr.Logger
	NamespacedName types.NamespacedName
	//nolint:containedctx // Required for reconciler pattern
	Context context.Context
}

ValidatorReconciler reconciles a Validator object

func (*ValidatorReconciler) Reconcile 

func (r *ValidatorReconciler) 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 Validator 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://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.16.3/pkg/reconcile

func (*ValidatorReconciler) ReconcileDeployment 

func (r *ValidatorReconciler) ReconcileDeployment(log logr.Logger) (bool, error)

ReconcileDeployment is the validator service deployment reconciler

func (*ValidatorReconciler) ReconcileService 

func (r *ValidatorReconciler) ReconcileService(log logr.Logger) (bool, error)

ReconcileService is the validator service reconciler

func (*ValidatorReconciler) SetupWithManager 

func (r *ValidatorReconciler) 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.