vdb

package
v1.6.0 Latest Latest
Warning

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

 Go to latest Published: Jun 30, 2022 License: Apache-2.0 Imports: 40 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	AWSRegionParm    = "awsregion"
	GCloudRegionParm = "GCSRegion"
)
View Source 
const (
	ServerContainer      = "server"
	ServerContainerIndex = 0
)
View Source 
const (
	ClusterShutdownOfflineMsgIndex = iota
	ReschedulePodsOfflineMsgIndex
	ClusterRestartOfflineMsgIndex
)
View Source 
const (
	// Amount of time to wait after a restart failover before doing another requeue.
	RequeueWaitTimeInSeconds = 10
	// The name of the IP map file that is used by re_ip.  re_ip is only ever used if the entire cluster is down.
	AdminToolsMapFile = "/opt/vertica/config/ipMap.txt"
	// Constant for an up node, this is taken from the STATE colume in NODES table
	StateUp = "UP"
)
View Source 
const (
	// This is a file that we run with the create_db to run custome SQL. This is
	// passed with the --sql parameter when running create_db.
	PostDBCreateSQLFile = "/home/dbadmin/post-db-create.sql"
)

Variables

View Source 
var OfflineUpgradeStatusMsgs = []string{
	"Shutting down cluster",
	"Rescheduling pods with new image",
	"Restarting cluster with new image",
}

Functions

func MakeClientRoutingLabelReconciler 

func MakeClientRoutingLabelReconciler(vdbrecon *VerticaDBReconciler,
	vdb *vapi.VerticaDB, pfacts *PodFacts, applyMethod ApplyMethodType, scName string) controllers.ReconcileActor

func MakeCreateDBReconciler 

func MakeCreateDBReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeCreateDBReconciler will build a CreateDBReconciler object

func MakeDBAddNodeReconciler 

func MakeDBAddNodeReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeDBAddNodeReconciler will build a DBAddNodeReconciler object

func MakeDBAddSubclusterReconciler 

func MakeDBAddSubclusterReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeDBAddSubclusterReconciler will build a DBAddSubclusterReconciler object

func MakeDBRemoveNodeReconciler 

func MakeDBRemoveNodeReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeDBRemoveNodeReconciler will build and return the DBRemoveNodeReconciler object.

func MakeDBRemoveSubclusterReconciler 

func MakeDBRemoveSubclusterReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeDBRemoveSubclusterReconciler will build a DBRemoveSubclusterReconciler object

func MakeDrainNodeReconciler 

func MakeDrainNodeReconciler(vdbrecon *VerticaDBReconciler,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

func MakeInstallReconciler 

func MakeInstallReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeInstallReconciler will build and return the InstallReconciler object.

func MakeMetricReconciler 

func MakeMetricReconciler(vrec *VerticaDBReconciler, vdb *vapi.VerticaDB, pfacts *PodFacts) controllers.ReconcileActor

MakeMetricReconciler will build a MetricReconciler object

func MakeObjReconciler 

func MakeObjReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger, vdb *vapi.VerticaDB, pfacts *PodFacts,
	mode ObjReconcileModeType) controllers.ReconcileActor

MakeObjReconciler will build an ObjReconciler object

func MakeOfflineUpgradeReconciler 

func MakeOfflineUpgradeReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeOfflineUpgradeReconciler will build an OfflineUpgradeReconciler object

func MakeOnlineUpgradeReconciler 

func MakeOnlineUpgradeReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeOnlineUpgradeReconciler will build an OnlineUpgradeReconciler object

func MakePodAnnotationReconciler 

func MakePodAnnotationReconciler(vdbrecon *VerticaDBReconciler,
	vdb *vapi.VerticaDB, pfacts *PodFacts) controllers.ReconcileActor

MakePodAnnotationReconciler will build a PodAnnotationReconciler object

func MakeRebalanceShardsReconciler 

func MakeRebalanceShardsReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts, scName string) controllers.ReconcileActor

MakeRebalanceShardsReconciler will build a RebalanceShardsReconciler object

func MakeRestartReconciler 

func MakeRestartReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts, restartReadOnly bool) controllers.ReconcileActor

MakeRestartReconciler will build a RestartReconciler object

func MakeReviveDBReconciler 

func MakeReviveDBReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeReviveDBReconciler will build a ReviveDBReconciler object

func MakeStatusReconciler 

func MakeStatusReconciler(cli client.Client, scheme *runtime.Scheme, log logr.Logger,
	vdb *vapi.VerticaDB, pfacts *PodFacts) controllers.ReconcileActor

MakeStatusReconciler will build a StatusReconciler object

func MakeStopDBReconciler added in v1.6.0 

func MakeStopDBReconciler(
	vdbrecon *VerticaDBReconciler, vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts,
) controllers.ReconcileActor

MakeStopDBReconciler will build a StopDBReconciler object

func MakeUninstallReconciler 

func MakeUninstallReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts) controllers.ReconcileActor

MakeUninstallReconciler will build and return the UninstallReconciler object.

func MakeUpgradeOperator120Reconciler 

func MakeUpgradeOperator120Reconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB) controllers.ReconcileActor

MakeUpgradeOperator120Reconciler will build a UpgradeOperatorFrom120Reconciler object

func MakeVersionReconciler 

func MakeVersionReconciler(vdbrecon *VerticaDBReconciler, log logr.Logger,
	vdb *vapi.VerticaDB, prunner cmds.PodRunner, pfacts *PodFacts,
	enforceUpgradePath bool) controllers.ReconcileActor

MakeVersionReconciler will build a VersionReconciler object

Types

type ApplyMethodType 

type ApplyMethodType string
const (
	AddNodeApplyMethod       ApplyMethodType = "Add"           // Called after a db_add_node
	PodRescheduleApplyMethod ApplyMethodType = "PodReschedule" // Called after pod was rescheduled and vertica restarted
	DelNodeApplyMethod       ApplyMethodType = "RemoveNode"    // Called before a db_remove_node
)

type ClientRoutingLabelReconciler 

type ClientRoutingLabelReconciler struct {
	VRec        *VerticaDBReconciler
	Vdb         *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PFacts      *PodFacts
	ApplyMethod ApplyMethodType
	ScName      string // Subcluster we are going to reconcile.  Blank if all subclusters.
}

func (*ClientRoutingLabelReconciler) Reconcile 

func (c *ClientRoutingLabelReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will add or remove labels that control whether it accepts client connections. Pods that have at least one shard owned will have a label added so that it receives traffic. For pods that don't own a shard or about to be scaled down will have the label removed so that traffic isn't routed to it.

type CreateDBReconciler 

type CreateDBReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

CreateDBReconciler will create a database if one wasn't created yet.

func (*CreateDBReconciler) Reconcile 

func (c *CreateDBReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will ensure a DB exists and create one if it doesn't

type DBAddNodeReconciler 

type DBAddNodeReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

DBAddNodeReconciler will ensure each pod is added to the database.

func (*DBAddNodeReconciler) Reconcile 

func (d *DBAddNodeReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will ensure a DB exists and create one if it doesn't

type DBAddSubclusterReconciler 

type DBAddSubclusterReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
	ATPod   *PodFact // The pod that we run admintools from
}

DBAddSubclusterReconciler will create a new subcluster if necessary

func (*DBAddSubclusterReconciler) Reconcile 

func (d *DBAddSubclusterReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will ensure a subcluster exists for each one defined in the vdb.

type DBRemoveNodeReconciler 

type DBRemoveNodeReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

DBRemoveNodeReconciler will handle removing a node from the database during scale down.

func (*DBRemoveNodeReconciler) CollectPFacts 

func (d *DBRemoveNodeReconciler) CollectPFacts(ctx context.Context) error

func (*DBRemoveNodeReconciler) GetClient 

func (d *DBRemoveNodeReconciler) GetClient() client.Client

func (*DBRemoveNodeReconciler) GetVDB 

func (d *DBRemoveNodeReconciler) GetVDB() *vapi.VerticaDB

func (*DBRemoveNodeReconciler) Reconcile 

func (d *DBRemoveNodeReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will handle calling admintools -t db_remove_node when scale down is detected.

This reconcile function is meant to be called before we create/delete any kubernetes objects. It allows us to look at the state before applying everything in Vdb. We will know if we are scaling down by comparing the expected subcluster size with the current.

type DBRemoveSubclusterReconciler 

type DBRemoveSubclusterReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
	ATPod   *PodFact // The pod that we run admintools from
}

DBRemoveSubclusterReconciler will remove subclusters from the database

func (*DBRemoveSubclusterReconciler) Reconcile 

func (d *DBRemoveSubclusterReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will remove any subcluster that no longer exists in the vdb.

type DatabaseInitializer 

type DatabaseInitializer interface {
	// contains filtered or unexported methods
}

type DrainNodeReconciler 

type DrainNodeReconciler struct {
	VRec    *VerticaDBReconciler
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

func (*DrainNodeReconciler) Reconcile 

func (s *DrainNodeReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will wait for active connections to leave in any pod that is marked as pending delete. This will drain those pods that we are going to scale down before we actually remove them from the cluster.

type GenericDatabaseInitializer 

type GenericDatabaseInitializer struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB
	PRunner cmds.PodRunner
	PFacts  *PodFacts
	// contains filtered or unexported fields
}

func (*GenericDatabaseInitializer) ConstructAuthParms 

func (g *GenericDatabaseInitializer) ConstructAuthParms(ctx context.Context, atPod types.NamespacedName) (ctrl.Result, error)

ConstructAuthParms builds the authentication parms and ensure it exists in the pod

func (*GenericDatabaseInitializer) DestroyAuthParms 

func (g *GenericDatabaseInitializer) DestroyAuthParms(ctx context.Context, atPod types.NamespacedName) error

DestroyAuthParms will remove the auth parms file that was created in the pod

type InstallReconciler 

type InstallReconciler struct {
	VRec     *VerticaDBReconciler
	Log      logr.Logger
	Vdb      *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner  cmds.PodRunner
	PFacts   *PodFacts
	ATWriter atconf.Writer
}

InstallReconciler will handle reconcile for install of vertica

func (*InstallReconciler) Reconcile 

func (d *InstallReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will ensure Vertica is installed and running in the pods.

type MetricReconciler 

type MetricReconciler struct {
	VRec   *VerticaDBReconciler
	Vdb    *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PFacts *PodFacts
}

MetricReconciler will refresh any metrics based on latest podfacts

func (*MetricReconciler) Reconcile 

func (p *MetricReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will update the metrics based on the pod facts

type ObjReconcileModeType 

type ObjReconcileModeType string
const (
	// Consider all ways to reconcile - add, delete, modify k8s objects
	ObjReconcileModeAll ObjReconcileModeType = "All"
	// Only reconcile objects that are missing.
	ObjReconcileModeIfNotFound ObjReconcileModeType = "IfNotFound"
)

type ObjReconciler 

type ObjReconciler struct {
	VRec              *VerticaDBReconciler
	Log               logr.Logger
	Vdb               *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PFacts            *PodFacts
	PatchImageAllowed bool // a patch can only change the image when this is set to true
	Mode              ObjReconcileModeType
}

ObjReconciler will reconcile for all dependent Kubernetes objects. This is used for a single reconcile iteration.

func (*ObjReconciler) Reconcile 

func (o *ObjReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile is the main driver for reconciliation of Kubernetes objects. This will ensure the desired svc and sts objects exist and are in the correct state.

type OfflineUpgradeReconciler 

type OfflineUpgradeReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
	Finder  iter.SubclusterFinder
	Manager UpgradeManager
}

OfflineUpgradeReconciler will handle the process of doing an offline upgrade of the Vertica server.

func (*OfflineUpgradeReconciler) Reconcile 

func (o *OfflineUpgradeReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will handle the process of the vertica image changing. For example, this can automate the process for an upgrade.

type OnlineUpgradeReconciler 

type OnlineUpgradeReconciler struct {
	VRec          *VerticaDBReconciler
	Log           logr.Logger
	Vdb           *vapi.VerticaDB  // Vdb is the CRD we are acting on.
	TransientSc   *vapi.Subcluster // Set to the transient subcluster if applicable
	PRunner       cmds.PodRunner
	PFacts        *PodFacts
	Finder        iter.SubclusterFinder
	Manager       UpgradeManager
	PrimaryImages []string // Known images in the primaries.  Should be of length 1 or 2.
	StatusMsgs    []string // Precomputed status messages
	MsgIndex      int      // Current index in StatusMsgs
}

OnlineUpgradeReconciler will handle the process when the vertica image changes. It does this while keeping the database online.

func (*OnlineUpgradeReconciler) Reconcile 

func (o *OnlineUpgradeReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will handle the process of the vertica image changing. For example, this can automate the process for an upgrade.

type PodAnnotationReconciler 

type PodAnnotationReconciler struct {
	VRec   *VerticaDBReconciler
	Vdb    *vapi.VerticaDB
	PFacts *PodFacts
}

PodAnnotationReconciler will maintain annotations in the pod about the running system

func (*PodAnnotationReconciler) Reconcile 

func (s *PodAnnotationReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will add annotations to each of the pods so that we flow down system information with the downwardAPI. The intent of this additional data is for inclusion in Vertica data collector (DC) tables.

type PodFact 

type PodFact struct {
	// contains filtered or unexported fields
}

PodFact keeps track of facts for a specific pod

type PodFactDetail 

type PodFactDetail map[types.NamespacedName]*PodFact

type PodFacts 

type PodFacts struct {
	VRec           *VerticaDBReconciler
	PRunner        cmds.PodRunner
	Detail         PodFactDetail
	NeedCollection bool
}

A collection of facts for many pods.

func MakePodFacts 

func MakePodFacts(vrec *VerticaDBReconciler, prunner cmds.PodRunner) PodFacts

MakePodFacts will create a PodFacts object and return it

func (*PodFacts) Collect 

func (p *PodFacts) Collect(ctx context.Context, vdb *vapi.VerticaDB) error

Collect will gather up the for facts if a collection is needed If the facts are already up to date, this function does nothing.

func (*PodFacts) Invalidate 

func (p *PodFacts) Invalidate()

Invalidate will mark the pod facts as requiring a refresh. Next call to Collect will gather up the facts again.

type RebalanceShardsReconciler 

type RebalanceShardsReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
	ScName  string // Name of the subcluster to rebalance.  Leave this blank if you want to handle all subclusters.
}

RebalanceShardsReconciler will ensure each node has at least one shard subscription

func (*RebalanceShardsReconciler) Reconcile 

func (s *RebalanceShardsReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will ensure each node has at least one shard subscription

type RestartReconciler 

type RestartReconciler struct {
	VRec            *VerticaDBReconciler
	Log             logr.Logger
	Vdb             *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner         cmds.PodRunner
	PFacts          *PodFacts
	ATPod           types.NamespacedName // The pod that we run admintools from
	RestartReadOnly bool                 // Whether to restart nodes that are in read-only mode
}

RestartReconciler will ensure each pod has a running vertica process

func (*RestartReconciler) Reconcile 

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

Reconcile will ensure each pod is UP in the vertica sense. On success, each node will have a running vertica process.

type ReviveDBReconciler 

type ReviveDBReconciler struct {
	VRec    *VerticaDBReconciler
	Log     logr.Logger
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

ReviveDBReconciler will revive a database if one doesn't exist in the vdb yet.

func (*ReviveDBReconciler) Reconcile 

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

Reconcile will ensure a DB exists and revive one if it doesn't

type ScaledownActor 

type ScaledownActor interface {
	GetClient() client.Client
	GetVDB() *vapi.VerticaDB
	CollectPFacts(ctx context.Context) error
}

ScaledownActor is an interface that handles a part of scale down, either db_remove_node or uninstall.

type StatusReconciler 

type StatusReconciler struct {
	client.Client
	Scheme *runtime.Scheme
	Log    logr.Logger
	Vdb    *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PFacts *PodFacts
}

StatusReconciler will update the status field of the vdb.

func (*StatusReconciler) Reconcile 

func (s *StatusReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will update the status of the Vdb based on the pod facts

type StopDBReconciler added in v1.6.0 

type StopDBReconciler struct {
	VRec    *VerticaDBReconciler
	Vdb     *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner cmds.PodRunner
	PFacts  *PodFacts
}

StopDBReconciler will stop the cluster and clear the restart needed status condition

func (*StopDBReconciler) Reconcile added in v1.6.0 

func (s *StopDBReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will stop vertica if the status condition indicates a restart is needed

type SubclustersSet 

type SubclustersSet map[string]bool

type UninstallReconciler 

type UninstallReconciler struct {
	VRec     *VerticaDBReconciler
	Log      logr.Logger
	Vdb      *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner  cmds.PodRunner
	PFacts   *PodFacts
	ATWriter atconf.Writer
}

UninstallReconciler will handle reconcile looking specifically for scale down events.

func (*UninstallReconciler) CollectPFacts 

func (s *UninstallReconciler) CollectPFacts(ctx context.Context) error

func (*UninstallReconciler) GetClient 

func (s *UninstallReconciler) GetClient() client.Client

func (*UninstallReconciler) GetVDB 

func (s *UninstallReconciler) GetVDB() *vapi.VerticaDB

func (*UninstallReconciler) Reconcile 

func (s *UninstallReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will handle state where a pod in a subcluster is being scaled down. During a scale down we need to drive uninstall logic for each applicable pod.

This reconcile function is meant to be called before we create/delete any kubernetes objects. It allows us to look at the state before applying everything in Vdb. We will know if we are scaling down by comparing the expected subcluster size with the current.

type UpgradeManager 

type UpgradeManager struct {
	VRec              *VerticaDBReconciler
	Vdb               *vapi.VerticaDB
	Log               logr.Logger
	Finder            iter.SubclusterFinder
	ContinuingUpgrade bool // true if UpdateInProgress was already set upon entry
	StatusCondition   vapi.VerticaDBConditionType
	// Function that will check if the image policy allows for a type of upgrade (offline or online)
	IsAllowedForUpgradePolicyFunc func(vdb *vapi.VerticaDB) bool
}

func MakeUpgradeManager 

func MakeUpgradeManager(vdbrecon *VerticaDBReconciler, log logr.Logger, vdb *vapi.VerticaDB,
	statusCondition vapi.VerticaDBConditionType,
	isAllowedForUpgradePolicyFunc func(vdb *vapi.VerticaDB) bool) *UpgradeManager

MakeUpgradeManager will construct a UpgradeManager object

func (*UpgradeManager) IsUpgradeNeeded 

func (i *UpgradeManager) IsUpgradeNeeded(ctx context.Context) (bool, error)

IsUpgradeNeeded checks whether an upgrade is needed and/or in progress. It will return true for the first parm if an upgrade should proceed.

type UpgradeOperator120Reconciler 

type UpgradeOperator120Reconciler struct {
	VRec *VerticaDBReconciler
	Log  logr.Logger
	Vdb  *vapi.VerticaDB // Vdb is the CRD we are acting on.
}

UpgradeOperator120Reconciler will handle any upgrade actions for k8s objects created in 1.2.0 or prior.

func (*UpgradeOperator120Reconciler) Reconcile 

func (u *UpgradeOperator120Reconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will handle any upgrade actions for k8s objects created in 1.2.0 or prior.

type VersionReconciler 

type VersionReconciler struct {
	VRec               *VerticaDBReconciler
	Log                logr.Logger
	Vdb                *vapi.VerticaDB // Vdb is the CRD we are acting on.
	PRunner            cmds.PodRunner
	PFacts             *PodFacts
	EnforceUpgradePath bool                    // Fail the reconcile if we find incompatible version
	FindPodFunc        func() (*PodFact, bool) // Function to call to find pod
}

VersionReconciler will set the version as annotations in the vdb.

func (*VersionReconciler) Reconcile 

func (v *VersionReconciler) Reconcile(ctx context.Context, req *ctrl.Request) (ctrl.Result, error)

Reconcile will update the annotation in the Vdb with Vertica version info

type VerticaDBReconciler 

type VerticaDBReconciler struct {
	client.Client
	Log                logr.Logger
	Scheme             *runtime.Scheme
	Cfg                *rest.Config
	EVRec              record.EventRecorder
	ServiceAccountName string
}

VerticaDBReconciler reconciles a VerticaDB object

func (*VerticaDBReconciler) Event 

func (r *VerticaDBReconciler) Event(vdb *vapi.VerticaDB, eventtype, reason, message string)

Event a wrapper for Event() that also writes a log entry

func (*VerticaDBReconciler) Eventf 

func (r *VerticaDBReconciler) Eventf(vdb *vapi.VerticaDB, eventtype, reason, messageFmt string, args ...interface{})

Eventf is a wrapper for Eventf() that also writes a log entry

func (*VerticaDBReconciler) GetSuperuserPassword 

func (r *VerticaDBReconciler) GetSuperuserPassword(ctx context.Context, vdb *vapi.VerticaDB, log logr.Logger) (string, error)

GetSuperuserPassword returns the superuser password if it has been provided

func (*VerticaDBReconciler) Reconcile 

func (r *VerticaDBReconciler) 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 VerticaDB 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.7.2/pkg/reconcile

func (*VerticaDBReconciler) SetupWithManager 

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