config

type AADApplication struct {
	PrincipalID string `yaml:"principalID" validate:"notblank"`
}

type AMIConfig struct {
	ID string `yaml:"id" validate:"notblank"`
}

type APIServerConfig struct {
	ExtraArgs    map[string]string     `yaml:"extraArgs"    default:"{}"`
	ExtraVolumes []HostPathMountConfig `yaml:"extraVolumes" default:"[]"`
	Files        []FileConfig          `yaml:"files"        default:"[]"`
}

type AWSAutoScalableNodeGroup struct {
	AutoScalableNodeGroup `yaml:",inline"`

	AMI            AMIConfig `yaml:"ami"            validate:"required"`
	InstanceType   string    `yaml:"instanceType"   validate:"notblank"`
	RootVolumeSize uint32    `yaml:"rootVolumeSize" validate:"required"`
	SSHKeyName     string    `yaml:"sshKeyName"     validate:"notblank"`
}

type AWSConfig struct {
	Region string `yaml:"region" validate:"notblank"`

	SSHKeyName     string                     `yaml:"sshKeyName"     validate:"notblank"`
	VPCID          *string                    `yaml:"vpcID"`
	BastionEnabled bool                       `yaml:"bastionEnabled"                     default:"True"`
	ControlPlane   AWSControlPlane            `yaml:"controlPlane"   validate:"required"`
	NodeGroups     []AWSAutoScalableNodeGroup `yaml:"nodeGroups"`
}

type AWSControlPlane struct {
	LoadBalancerScheme string    `yaml:"loadBalancerScheme" default:"internet-facing" validate:"notblank"`
	Replicas           uint32    `yaml:"replicas"                                     validate:"required"`
	InstanceType       string    `yaml:"instanceType"                                 validate:"notblank"`
	AMI                AMIConfig `yaml:"ami"                                          validate:"required"`
}

type AWSCredentials struct {
	AWSAccessKeyID     string `yaml:"accessKeyID"     validate:"notblank"`
	AWSSecretAccessKey string `yaml:"secretAccessKey" validate:"notblank"`
	AWSSessionToken    string `yaml:"sessionToken"`
}

type ArgoCDConfig struct {
	DeployKeys DeployKeysConfig `yaml:"deployKeys" validate:"required"`
}

type AutoScalableNodeGroup struct {
	NodeGroup `yaml:",inline"`

	CPU    uint32 `validate:"required"`
	Memory uint32 `validate:"required"`

	// Minimum number of replicas in the nodegroup.
	MinSize uint `yaml:"minSize" validate:"required"`

	// Maximum number of replicas in the nodegroup.
	Maxsize uint `yaml:"maxSize" validate:"required"`
}

type AzureAutoScalableNodeGroup struct {
	AutoScalableNodeGroup `yaml:",inline"`

	VMSize     string `yaml:"vmSize"     validate:"notblank"`
	DiskSizeGB uint32 `yaml:"diskSizeGB" validate:"required"`
}

type AzureConfig struct {
	TenantID       string         `yaml:"tenantID"       validate:"notblank"`
	SubscriptionID string         `yaml:"subscriptionID" validate:"notblank"`
	AADApplication AADApplication `yaml:"aadApplication" validate:"required"`
	Location       string         `yaml:"location"       validate:"notblank"`

	StorageAccount string `yaml:"storageAccount" validate:"notblank"`

	WorkloadIdentity WorkloadIdentity `yaml:"workloadIdentity" validate:"required"`

	SSHPublicKey string `yaml:"sshPublicKey" validate:"notblank"`

	CanonicalUbuntuImage CanonicalUbuntuImage `yaml:"canonicalUbuntuImage" validate:"required"`

	ControlPlane AzureControlPlane            `yaml:"controlPlane" validate:"required"`
	NodeGroups   []AzureAutoScalableNodeGroup `yaml:"nodeGroups"`
}

type AzureControlPlane struct {
	LoadBalancerType string `yaml:"loadBalancerType" validate:"notblank"        default:"Public"`
	DiskSizeGB       uint32 `yaml:"diskSizeGB"       validate:"required,gt=100"`
	VMSize           string `yaml:"vmSize"           validate:"notblank"`
	Replicas         uint32 `yaml:"replicas"         validate:"required,gt=0"`
}

type AzureCredentials struct {
	ClientID     string `yaml:"clientID"     validate:"notblank"`
	ClientSecret string `yaml:"clientSecret" validate:"notblank"`
}

type BareMetalConfig struct {
	SSH BareMetalSSHConfig `yaml:"ssh"`

	ControlPlane BareMetalControlPlane `yaml:"controlPlane" validate:"required"`
	NodeGroups   []BareMetalNodeGroup  `yaml:"nodeGroups"`
}

type BareMetalControlPlane struct {
	Endpoint BareMetalControlPlaneEndpoint `yaml:"endpoint" validate:"required"`
	Hosts    []*BareMetalHost              `yaml:"hosts"    validate:"required"`
}

type BareMetalControlPlaneEndpoint struct {
	Host string `yaml:"host" validate:"notblank"`
	Port uint   `yaml:"port" validate:"required" default:"6443"`
}

type BareMetalHost struct {
	PublicAddress  *string `yaml:"publicAddress"  validate:"notblank"`
	PrivateAddress *string `yaml:"privateAddress" validate:"notblank"`

	SSH *BareMetalSSHConfig `yaml:"ssh"`
}

type BareMetalNodeGroup struct {
	NodeGroup `yaml:",inline"`

	Hosts []*BareMetalHost `yaml:"hosts" validate:"required"`
}

type BareMetalSSHConfig struct {
	Port       uint                 `yaml:"port"       validate:"required" default:"22"`
	PrivateKey *SSHPrivateKeyConfig `yaml:"privateKey"`
}

type CanonicalUbuntuImage struct {
	Offer string `yaml:"offer" validate:"notblank"`
	SKU   string `yaml:"sku"   validate:"notblank"`
}

type CloudConfig struct {
	AWS       *AWSConfig       `yaml:"aws"`
	Azure     *AzureConfig     `yaml:"azure"`
	Hetzner   *HetznerConfig   `yaml:"hetzner"`
	BareMetal *BareMetalConfig `yaml:"bare-metal"`
	Local     *LocalConfig     `yaml:"local"`

	DisasterRecovery *DisasterRecoveryConfig `yaml:"disasterRecovery"`
}

type ClusterConfig struct {
	Type string `yaml:"type" validate:"notblank,oneof=vpn workload" default:"workload"`

	// Name of the Kubernetes cluster.
	//
	// We don't allow using dots in the cluster name, since it can cause issues with tools like
	// ClusterAPI and Cilium : which use the cluster name to generate other configurations.
	Name string `yaml:"name" validate:"notblank"`

	// Kubernetes version (>= 1.30.0).
	K8sVersion string `yaml:"k8sVersion" validate:"notblank"`

	// Whether you would like to enable Kubernetes Audit Logging out of the box.
	// Suitable Kubernetes API configurations will be done for you automatically. And they can be
	// changed using the apiSever struct field.
	EnableAuditLogging bool `yaml:"enableAuditLogging" default:"True"`

	// Configuration options for the Kubernetes API server.
	APIServer APIServerConfig `yaml:"apiServer"`

	// Other than the root user, addtional users that you would like to be created in each node.
	// NOTE : Currently, we can't register additional SSH key-pairs against the root user.
	AdditionalUsers []UserConfig `yaml:"additionalUsers"`

	// ArgoCD specific details.
	ArgoCD ArgoCDConfig `yaml:"argoCD" validate:"required"`
}

type DeployKeysConfig struct {
	KubeaidConfig SSHPrivateKeyConfig  `yaml:"kubeaidConfig" validate:"required"`
	Kubeaid       *SSHPrivateKeyConfig `yaml:"kubeaid"`
}

type DisasterRecoveryConfig struct {
	VeleroBackupsBucketName        string `yaml:"veleroBackupsBucketName"        validate:"notblank"`
	SealedSecretsBackupsBucketName string `yaml:"sealedSecretsBackupsBucketName" validate:"notblank"`
}

type FileConfig struct {
	Path    string `yaml:"path"    validate:"notblank"`
	Content string `yaml:"content" validate:"notblank"`
}

type ForksConfig struct {
	// KubeAid repository specific details.
	KubeaidFork KubeAidForkConfig `yaml:"kubeaid" validate:"required"`

	// KubeAid Config repository specific details.
	KubeaidConfigFork KubeaidConfigForkConfig `yaml:"kubeaidConfig" validate:"required"`
}

type GeneralConfig struct {
	// Git server specific details.
	Git GitConfig `yaml:"git"`

	// KubeAid and KubeAid Config repository specific details.
	// The KubeAid and KubeAid Config repositories must be hosted in the same Git server.
	Forks ForksConfig `yaml:"forkURLs" validate:"required"`

	// Kubernetes specific details.
	Cluster ClusterConfig `yaml:"cluster" validate:"required"`

	// Cloud provider specific details.
	Cloud CloudConfig `yaml:"cloud" validate:"required"`

	// Kube Prometheus installation specific details. Defaults to Latest
	// Fill this only if you want a specific version
	KubePrometheus KubePrometheusConfig `yaml:"kubePrometheus"`

	// Obmondo customer specific details.
	Obmondo *ObmondoConfig `yaml:"obmondo"`
}

type GitConfig struct {
	CABundlePath string `yaml:"caBundlePath"`
	CABundle     []byte

	// SSH username.
	SSHUsername string `yaml:"sshUsername" validate:"notblank" default:"git"`

	// Either make KubeAid CLI use the given SSH private key.
	*SSHPrivateKeyConfig `yaml:",inline"`

	// Or, make KubeAid CLI use the SSH Agent.
	// So, you (the one who runs KubeAid CLI) can use your YubiKey.
	UseSSHAgent bool `yaml:"useSSHAgent"`

	// Additional SSH known host entries.
	// Merged with the bundled known hosts for
	// GitHub, GitLab, Bitbucket and Azure DevOps.
	KnownHosts []string `yaml:"knownHosts"`
}

type HCloudAutoScalableNodeGroup struct {
	AutoScalableNodeGroup `yaml:",inline"`

	// HCloud machine type.
	// You can browse all available HCloud machine types here : https://hetzner.com/cloud.
	MachineType string `yaml:"machineType" validate:"notblank"`

	// The root volume size for each HCloud machine.
	RootVolumeSize uint32 `validate:"required"`
}

type HCloudControlPlane struct {
	MachineType  string                         `yaml:"machineType"  validate:"notblank"`
	Replicas     uint                           `yaml:"replicas"     validate:"notblank"`
	LoadBalancer HCloudControlPlaneLoadBalancer `yaml:"loadBalancer" validate:"required"`
}

type HCloudControlPlaneLoadBalancer struct {
	Enabled bool   `yaml:"enabled" validate:"required"`
	Region  string `yaml:"region"  validate:"notblank"`
}

type HCloudVPNClusterConfig struct {
	Name string `yaml:"name" validate:"notblank"`
}

type HetznerBareMetalConfig struct {
	WipeDisks    bool                       `yaml:"wipeDisks"    default:"false"`
	InstallImage InstallImageConfig         `yaml:"installImage"`
	SSHKeyPair   HetznerBareMetalSSHKeyPair `yaml:"sshKeyPair"                   validate:"required"`
}

type HetznerBareMetalControlPlane struct {
	Endpoint       HetznerBareMetalControlPlaneEndpoint `yaml:"endpoint"       validate:"required"`
	BareMetalHosts []*HetznerBareMetalHost              `yaml:"bareMetalHosts" validate:"required,gt=0"`

	// ZFS specific configuration.
	// Every node runs a ZFS pool, named primary. We carve out storage for container images, pod
	// logs and pod ephemeral volumes from that ZFS pool, as required.
	// The ZFS pool has RAIDZ-1 enabled, which means it can survive single disk failure.
	ZFS ZFSConfig `yaml:"zfs" validate:"required"`

	StoragePlan storageplan.StoragePlan
}

type HetznerBareMetalControlPlaneEndpoint struct {
	IsFailoverIP bool   `yaml:"isFailoverIP"`
	Host         string `yaml:"host"         validate:"ip"`
}

type HetznerBareMetalHost struct {
	ServerID string `yaml:"serverID" validate:"notblank"`
	WWNs     []string
}

type HetznerBareMetalNodeGroup struct {
	NodeGroup `yaml:",inline"`

	BareMetalHosts []*HetznerBareMetalHost `yaml:"bareMetalHosts" validate:"required,gt=0"`

	// ZFS specific configuration.
	// Every node runs a ZFS pool, named primary. We carve out storage for container images, pod
	// logs and pod ephemeral volumes from that ZFS pool, as required.
	// The ZFS pool has RAIDZ-1 enabled, which means it can survive single disk failure.
	ZFS ZFSConfig `yaml:"zfs" validate:"required"`

	StoragePlan storageplan.StoragePlan
}

type HetznerBareMetalSSHKeyPair struct {
	Name             string `yaml:"name"    validate:"notblank"`
	SSHKeyPairConfig `       yaml:",inline"`
}

type HetznerConfig struct {
	/*
		The Hetzner mode to use :

		  (1) hcloud : Both the control-plane and the nodegroups will be in HCloud.

		  (2) bare-metal : Both the control-plane and the nodegroups will be in Hetzner Bare Metal.

		  (3) hybrid : The control-plane will be in HCloud, and each node-group can be either in
		               HCloud or Hetzner Bare Metal.
	*/
	Mode string `yaml:"mode" default:"hcloud" validate:"notblank,oneof=bare-metal hcloud hybrid"`

	VSwitch *VSwitchConfig `yaml:"vswitch"`

	HCloud    *HetznerHCloudConfig    `yaml:"hcloud"`
	BareMetal *HetznerBareMetalConfig `yaml:"bareMetal"`

	ControlPlane HetznerControlPlane `yaml:"controlPlane" validate:"required"`

	// Details about node-groups in Hetzner.
	NodeGroups HetznerNodeGroups `yaml:"nodeGroups"`

	VPNCluster *HCloudVPNClusterConfig `yaml:"vpnCluster"`
}

type HetznerControlPlane struct {
	HCloud    *HCloudControlPlane           `yaml:"hcloud"`
	BareMetal *HetznerBareMetalControlPlane `yaml:"bareMetal"`

	Regions []string `yaml:"regions" validate:"required"`
}

type HetznerCredentials struct {
	APIToken string                   `yaml:"apiToken" validate:"notblank"`
	Robot    *HetznerRobotCredentials `yaml:"robot"`
}

type HetznerHCloudConfig struct {
	Zone           string `yaml:"zone"           validate:"notblank"`
	ImageName      string `yaml:"imageName"      validate:"notblank" default:"ubuntu-24.04"`
	SSHKeyPairName string `yaml:"sshKeyPairName" validate:"notblank"`
}

type HetznerNodeGroups struct {
	// Details about node-groups in HCloud.
	HCloud []HCloudAutoScalableNodeGroup `yaml:"hcloud"`

	// Details about node-groups in Hetzner Bare Metal.
	BareMetal []*HetznerBareMetalNodeGroup `yaml:"bareMetal"`
}

type HetznerRobotCredentials struct {
	User     string `yaml:"user"     validate:"notblank"`
	Password string `yaml:"password" validate:"notblank"`
}

type HostPathMountConfig struct {
	Name      string              `yaml:"name"      validate:"notblank"`
	HostPath  string              `yaml:"hostPath"  validate:"notblank"`
	MountPath string              `yaml:"mountPath" validate:"notblank"`
	PathType  coreV1.HostPathType `yaml:"pathType"  validate:"required"`

	// Whether the mount should be read-only.
	ReadOnly bool `yaml:"readOnly" default:"true"`
}

type InstallImageConfig struct {
	ImagePath string    `yaml:"imagePath" default:"/root/.oldroot/nfs/images/Ubuntu-2404-noble-amd64-base.tar.gz" validate:"notblank"`
	VG0       VG0Config `yaml:"vg0"`
}

type KubeAidForkConfig struct {
	// KubeAid repository SSH URL.
	URL       string `yaml:"url" validate:"required"`
	ParsedURL gogiturl.IGitURL

	// KubeAid tag.
	Version string `yaml:"version" validate:"notblank"`
}

type KubePrometheusConfig struct {
	Version    string `yaml:"version"`
	GrafanaURL string `yaml:"grafanaURL"`
}

type KubeaidConfigForkConfig struct {
	// KubeAid Config repository SSH URL.
	URL       string `yaml:"url" validate:"required"`
	ParsedURL gogiturl.IGitURL

	// Name of the directory inside your KubeAid Config repository's k8s folder, where the KubeAid
	// Config files for this cluster will be contained.
	//
	// When not specified, the directory name will default to the cluster name.
	//
	// So, suppose your cluster name is 'staging'. Then, the directory name will default to
	// 'staging'. Or you can customize it to something like 'staging.qa'.
	Directory string `yaml:"directory"`
}

type LocalConfig struct{}

type NodeGroup struct {
	// Nodegroup name.
	Name string `yaml:"name" validate:"notblank"`

	// Labels that you want to be propagated to each node in the nodegroup.
	//
	// Each label should meet one of the following criterias to propagate to each of the nodes :
	//
	//   1. Has node-role.kubernetes.io as prefix.
	//   2. Belongs to node-restriction.kubernetes.io domain.
	//   3. Belongs to node.cluster.x-k8s.io domain.
	//
	// REFER : https://cluster-api.sigs.k8s.io/developer/architecture/controllers/metadata-propagation#machine.
	Labels map[string]string `yaml:"labels" default:"[]"`

	// Taints that you want to be propagated to each node in the nodegroup.
	Taints []*coreV1.Taint `yaml:"taints" default:"[]"`
}

type ObmondoConfig struct {
	CustomerID string `yaml:"customerID" validate:"notblank"`
	Monitoring bool   `yaml:"monitoring"`
}

type ReleaseDetails struct {
	TagName string `json:"tag_name"`
}

type SSHKeyPairConfig struct {
	SSHPrivateKeyConfig `yaml:",inline"`

	PublicKeyFilePath string `yaml:"publicKeyFilePath" validate:"notblank"`
	PublicKey         string `                         validate:"notblank"`
}

type SSHPrivateKeyConfig struct {
	PrivateKeyFilePath string `yaml:"privateKeyFilePath" validate:"notblank"`
	PrivateKey         string `                          validate:"notblank"`
}

type SecretsConfig struct {
	AWS     *AWSCredentials     `yaml:"aws"`
	Azure   *AzureCredentials   `yaml:"azure"`
	Hetzner *HetznerCredentials `yaml:"hetzner"`
}

type UserConfig struct {
	Name         string `yaml:"name"         validate:"required"`
	SSHPublicKey string `yaml:"sshPublicKey" validate:"required"`
}

type VG0Config struct {
	Size           int `yaml:"size"           validate:"notblank" default:"80"`
	RootVolumeSize int `yaml:"rootVolumeSize" validate:"notblank" default:"50"`
}

type VSwitchConfig struct {
	VLANID int    `yaml:"vlanID"`
	Name   string `yaml:"name"   validate:"notblank"`
}

type WorkloadIdentity struct {
	OpenIDProviderSSHKeyPair SSHKeyPairConfig `yaml:"openIDProviderSSHKeyPair" validate:"notblank"`
}

type ZFSConfig struct {
	// ZFS pool size (in GB), on each node in the corresponding node-group.
	// Must be >= 200 GB : reserving 100 GB for container images, 50 GB for pod logs and 50 GB for
	// pod ephemeral volumes.
	// On top of that, if you want x GB of node-local storage for your workloads (like Redis),
	// the ZFS pool size will be (200 + 2x) GB, keeping in mind that RAIDZ-1 is enabled.
	Size int `yaml:"size" validate:"required,gt=200" default:"220"`
}