vclusterops

type ClusterConfig map[string]DatabaseConfig

type ClusterLeaseNotExpiredError struct {
	Expiration string
}

type CmdType int

type CommandType int

type Config struct {
	Version   int           `yaml:"config_file_version"`
	Databases ClusterConfig `yaml:"databases"`
}

type DBIsRunningError struct {
	Detail string
}

type DatabaseConfig struct {
	Nodes                   []*NodeConfig `yaml:"nodes"`
	IsEon                   bool          `yaml:"eon_mode"`
	CommunalStorageLocation string        `yaml:"communal_storage_location"`
	Ipv6                    bool          `yaml:"ipv6"`
}

type DatabaseOptions struct {

	// name of the database
	DBName *string
	// expected to be IP addresses or hostnames
	RawHosts []string
	// expected to be IP addresses resolved from RawHosts
	Hosts []string
	// whether using IPv6 for host addresses
	Ipv6 vstruct.NullableBool
	// path of catalog directory
	CatalogPrefix *string
	// path of data directory
	DataPrefix *string
	// directory of the YAML config file
	ConfigDirectory *string

	// path of depot directory
	DepotPrefix *string
	// whether the database is in Eon mode
	IsEon vstruct.NullableBool
	// path of the communal storage
	CommunalStorageLocation *string
	// database configuration parameters
	ConfigurationParameters map[string]string

	// user name
	UserName *string
	// password
	Password *string
	// TLS Key
	Key string
	// TLS Certificate
	Cert string
	// TLS CA Certificate
	CaCert string

	// path of the log file
	LogPath *string
	// whether honor user's input rather than reading values from the config file
	HonorUserInput *bool

	// pointer to the cluster config object
	Config *ClusterConfig
	// contains filtered or unexported fields
}

type InstallPackageStatus struct {
	Packages []PackageStatus `json:"packages"`
}

type NodeConfig struct {
	Name        string `yaml:"name"`
	Address     string `yaml:"address"`
	Subcluster  string `yaml:"subcluster"`
	CatalogPath string `yaml:"catalog_path"`
	DataPath    string `yaml:"data_path"`
	DepotPath   string `yaml:"depot_path"`
}

type NodeInfo struct {
	Address     string `json:"address"`
	Name        string `json:"name"` // vnode name, e.g., v_dbname_node0001
	State       string `json:"state"`
	CatalogPath string `json:"catalog_path"`
}

type PackageStatus struct {
	// Name of the package this status is for
	PackageName string `json:"package_name"`
	// One word outcome of the install status:
	// Skipped, Success or Failure
	InstallStatus string `json:"install_status"`
}

type ReIPInfo struct {
	NodeName               string `json:"node_name"`
	NodeAddress            string `json:"-"`
	TargetAddress          string `json:"address"`
	TargetControlAddress   string `json:"control_address"`
	TargetControlBroadcast string `json:"control_broadcast"`
}

type ReIPNoClusterQuorumError struct {
	Detail string
}

type RestorePoint struct {
	// Name of the archive that this restore point was created in.
	Archive string `json:"archive,omitempty"`
	// The ID of the restore point. This is a form of a UID that is static for the restore point.
	ID string `json:"id,omitempty"`
	// The current index of this restore point. Lower value means it was taken more recently.
	// This changes when new restore points are created.
	Index int `json:"index,omitempty"`
	// The timestamp when the restore point was created.
	Timestamp string `json:"timestamp,omitempty"`
	// The version of Vertica running when the restore point was created.
	VerticaVersion string `json:"vertica_version,omitempty"`
}

type RestorePointPolicy struct {
	// Name of the restore archive to use for bootstrapping
	Archive *string
	// The (1-based) index of the restore point in the restore archive to restore from
	Index *int
	// The identifier of the restore point in the restore archive to restore from
	ID *string
}

type ReviveDBNodeCountMismatchError struct {
	ReviveDBStep  string
	FailureHost   string
	NumOfNewNodes int
	NumOfOldNodes int
}

type ReviveDBRestorePointNotFoundError struct {
	Archive      string
	InvalidID    string
	InvalidIndex int
}

type ShowRestorePointFilterOptions struct {
	// Only list restore points with given archive name
	ArchiveName *string
	// Only list restore points created no earlier than this timestamp (must be UTC timezone)
	StartTimestamp *string
	// Only list restore points created no later than this timestamp (must be UTC timezone)
	EndTimestamp *string
	// Only list restore points with given ID
	ArchiveID *string
	// Only list restore points with given index
	ArchiveIndex *string
}

type VAddNodeOptions struct {
	DatabaseOptions
	// Hosts to add to database
	NewHosts []string
	// Name of the subcluster that the new nodes will be added to
	SCName *string
	// A primary up host that will be used to execute add_node operations
	Initiator string
	// Depot size, e.g. 10G
	DepotSize *string
	// Skip rebalance shards if true
	SkipRebalanceShards *bool
	// Use force remove if true
	ForceRemoval *bool
	// If the path is set, the NMA will store the Vertica start command at the path
	// instead of executing it. This is useful in containerized environments where
	// you may not want to have both the NMA and Vertica server in the same container.
	// This feature requires version 24.2.0+.
	StartUpConf *string
	// Names of the existing nodes in the cluster. This option can be
	// used to remove partially added nodes from catalog.
	ExpectedNodeNames []string
}

type VAddSubclusterInfo struct {
	DBName         string
	Hosts          []string
	UserName       string
	Password       *string
	SCName         string
	SCHosts        []string
	IsPrimary      bool
	ControlSetSize int
	CloneSC        string
}

type VAddSubclusterOptions struct {
	// part 1: basic db info
	DatabaseOptions
	// part 2: subcluster info
	SCName         *string
	SCHosts        []string
	SCRawHosts     []string
	IsPrimary      *bool
	ControlSetSize *int
	CloneSC        *string
}

type VClusterCommands struct {
	Log vlog.Printer
}

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

type VCoordinationDatabase struct {
	Name string
	// processed path prefixes
	CatalogPrefix string
	DataPrefix    string
	HostNodeMap   vHostNodeMap
	// for convenience
	HostList []string // expected to be resolved IP addresses

	// Eon params, the boolean values are for convenience
	IsEon                   bool
	CommunalStorageLocation string
	UseDepot                bool
	DepotPrefix             string
	DepotSize               string
	AwsIDKey                string
	AwsSecretKey            string
	NumShards               int

	// authentication
	LicensePathOnNode string

	// more to add when useful
	Ipv6 bool

	PrimaryUpNodes []string
}

type VCoordinationNode struct {
	Name    string `json:"name"`
	Address string
	// complete paths, not just prefix
	CatalogPath          string `json:"catalog_path"`
	StorageLocations     []string
	UserStorageLocations []string
	DepotPath            string
	// DB client port, should be 5433 by default
	Port int
	// default should be ipv4
	ControlAddressFamily string
	IsPrimary            bool
	State                string
	// empty string if it is not an eon db
	Subcluster string
	// empty string if it is not in a sandbox
	Sandbox string
}

type VCreateDatabaseOptions struct {
	/* part 1: basic db info */
	DatabaseOptions
	Policy            *string // database restart policy
	SQLFile           *string // SQL file to run (as dbadmin) immediately on database creation
	LicensePathOnNode *string // required to be a fully qualified path

	ShardCount               *int    // number of shards in the database"
	DepotSize                *string // depot size with two supported formats: % and KMGT, e.g., 50% or 10G
	GetAwsCredentialsFromEnv *bool   // whether get AWS credentials from environmental variables
	// part 3: optional info
	ForceCleanupOnFailure     *bool // whether force remove existing directories on failure
	ForceRemovalAtCreation    *bool // whether force remove existing directories before creating the database
	SkipPackageInstall        *bool // whether skip package installation
	TimeoutNodeStartupSeconds *int  // timeout in seconds for polling node start up state

	Broadcast          *bool // configure Spread to use UDP broadcast traffic between nodes on the same subnet
	P2p                *bool // configure Spread to use point-to-point communication between all Vertica nodes
	LargeCluster       *int  // whether enables a large cluster layout
	ClientPort         *int  // for internal QA test only, do not abuse
	SpreadLogging      *bool // whether enable spread logging
	SpreadLoggingLevel *int  // spread logging level

	SkipStartupPolling *bool // whether skip startup polling
	GenerateHTTPCerts  *bool // whether generate http certificates
	// If the path is set, the NMA will store the Vertica start command at the path
	// instead of executing it. This is useful in containerized environments where
	// you may not want to have both the NMA and Vertica server in the same container.
	// This feature requires version 24.2.0+.
	StartUpConf *string
	// contains filtered or unexported fields
}

type VDropDatabaseOptions struct {
	VCreateDatabaseOptions
	ForceDelete *bool // whether force delete directories
}

type VFetchNodeStateOptions struct {
	DatabaseOptions
}

type VInstallPackagesOptions struct {
	/* part 1: basic db info */
	DatabaseOptions

	// If true, the packages will be reinstalled even if they are already installed.
	ForceReinstall *bool
}

type VReIPOptions struct {
	DatabaseOptions

	// re-ip list
	ReIPList []ReIPInfo

	// whether trim re-ip list based on the catalog info
	TrimReIPList bool
}

type VRemoveNodeOptions struct {
	DatabaseOptions
	HostsToRemove []string // Hosts to remove from database
	Initiator     string   // A primary up host that will be used to execute remove_node operations.
	ForceDelete   *bool    // whether force delete directories
}

type VRemoveScOptions struct {
	DatabaseOptions
	SubclusterToRemove *string // subcluster to remove from database
	ForceDelete        *bool   // whether force delete directories
}

type VReviveDatabaseOptions struct {
	/* part 1: basic db info */
	DatabaseOptions

	// timeout in seconds of loading remote catalog
	LoadCatalogTimeout *uint
	// whether force remove existing directories before revive the database
	ForceRemoval *bool
	// describe the database on communal storage, and exit
	DisplayOnly *bool
	// whether ignore the cluster lease
	IgnoreClusterLease *bool
	// the restore policy
	RestorePoint *RestorePointPolicy
}

type VSandboxOptions struct {
	DatabaseOptions
	SandboxName *string
	SCName      *string
	SCHosts     []string
	SCRawHosts  []string
}

type VSandboxSubclusterInfo struct {
	DBName string
	// Hosts should contain at least one primary host for performing sandboxing,
	// as sandboxing requires the subcluster to be secondary.
	Hosts       []string
	SCHosts     []string
	UserName    string
	Password    *string
	SCName      string
	SandboxName string
}

type VScrutinizeOptions struct {
	DatabaseOptions
	ID string // generated: "VerticaScrutinize.yyyymmddhhmmss"
}

type VShowRestorePointsOptions struct {
	DatabaseOptions
	// Optional arguments to list only restore points that
	// meet the specified condition(s)
	FilterOptions *ShowRestorePointFilterOptions
}

type VStartDatabaseOptions struct {
	// basic db info
	DatabaseOptions
	// timeout for polling the states of all nodes in the database in HTTPSPollNodeStateOp
	StatePollingTimeout *int
	// whether trim the input host list based on the catalog info
	TrimHostList *bool
	// If the path is set, the NMA will store the Vertica start command at the path
	// instead of executing it. This is useful in containerized environments where
	// you may not want to have both the NMA and Vertica server in the same container.
	// This feature requires version 24.2.0+.
	StartUpConf *string
}

type VStartNodesInfo struct {
	// The IP address that we intend to re-IP can be obtained from a set of nodes provided as input
	// within VStartNodesOptions struct
	ReIPList []string
	// The names of the nodes that we intend to re-IP can be acquired from a set of nodes provided as input
	// within the VStartNodesOptions struct
	NodeNamesToStart []string
	// the hosts that we want to start
	HostsToStart []string
}

type VStartNodesOptions struct {
	// basic db info
	DatabaseOptions
	// A set of nodes(nodename - host) that we want to start in the database
	Nodes map[string]string
	// timeout for polling nodes that we want to start in httpsPollNodeStateOp
	StatePollingTimeout int
	// If the path is set, the NMA will store the Vertica start command at the path
	// instead of executing it. This is useful in containerized environments where
	// you may not want to have both the NMA and Vertica server in the same container.
	// This feature requires version 24.2.0+.
	StartUpConf *string
}

type VStopDatabaseInfo struct {
	DBName       string
	Hosts        []string
	UserName     string
	Password     *string
	DrainSeconds *int
	IsEon        bool
	Sandbox      string
	MainCluster  bool
}

type VStopDatabaseOptions struct {
	/* part 1: basic db info */
	DatabaseOptions

	/* part 2: eon db info */
	DrainSeconds *int    // time in seconds to wait for database users' disconnection
	Sandbox      *string // Stop db on given sandbox
	MainCluster  *bool   // Stop db on main cluster only
	/* part 3: hidden info */
	CheckUserConn *bool // whether check user connection
	ForceKill     *bool // whether force kill connections
}

type VUnsandboxOptions struct {
	DatabaseOptions
	SCName *string
}

type VclusterOpVersion struct {
	Origin string `json:"origin"`
	SemVer semVer
}