failover

type DBVMSource struct {
	NovaReader external.NovaReaderInterface
}

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

type FailoverConfig struct {
	// FlavorFailoverRequirements maps flavor name patterns to required failover count.
	// Example: {"hana_*": 2, "m1.xlarge": 1}
	// A VM with a matching flavor will need this many failover reservations.
	FlavorFailoverRequirements map[string]int `json:"flavorFailoverRequirements"`

	// ReconcileInterval is how often to check for missing failover reservations.
	// Supports Go duration strings like "30s", "1m", "15m".
	ReconcileInterval metav1.Duration `json:"reconcileInterval"`

	// Creator tag for failover reservations (for identification and cleanup).
	Creator string `json:"creator"`

	// DatasourceName is the name of the Datasource CRD that provides database connection info.
	// This is used to read VM data from the Nova database.
	DatasourceName string `json:"datasourceName"`

	// SchedulerURL is the URL of the nova external scheduler API.
	// Example: "http://localhost:8080/scheduler/nova/external"
	SchedulerURL string `json:"schedulerURL"`

	// MaxVMsToProcess limits the number of VMs to process per reconciliation cycle.
	// Set to negative to process all VMs (default behavior).
	// Useful for debugging and testing with large VM counts.
	MaxVMsToProcess int `json:"maxVMsToProcess"`

	// ShortReconcileInterval is used when MaxVMsToProcess limits processing.
	// This allows faster catch-up when there are more VMs to process.
	// Set to 0 to use ReconcileInterval (default behavior).
	// Supports Go duration strings like "100ms", "1s", "1m".
	ShortReconcileInterval metav1.Duration `json:"shortReconcileInterval"`

	// MinSuccessForShortInterval is the minimum number of successful reservations (created + reused)
	// required to use ShortReconcileInterval. Default: 1. Use 0 to require no minimum.
	MinSuccessForShortInterval *int `json:"minSuccessForShortInterval"`

	// MaxFailuresForShortInterval is the maximum number of failures allowed to still use
	// ShortReconcileInterval. Default: 99. Use 0 to allow no failures.
	MaxFailuresForShortInterval *int `json:"maxFailuresForShortInterval"`

	// TrustHypervisorLocation when true, uses the hypervisor CRD as the source of truth
	// for VM location instead of postgres (OSEXTSRVATTRHost). This is useful when there
	// are data sync issues between nova and the hypervisor operator.
	// When enabled:
	// - VM location comes from hypervisor CRD (which hypervisor lists the VM in its instances)
	// - VM size/flavor still comes from postgres (needed for scheduling)
	// Default: false (use postgres OSEXTSRVATTRHost for location)
	TrustHypervisorLocation bool `json:"trustHypervisorLocation"`

	// RevalidationInterval is how often to re-validate acknowledged failover reservations.
	// After a reservation is acknowledged, it will be re-validated after this interval
	// to ensure the reservation host is still valid for all allocated VMs.
	// Default: 30 minutes
	// Supports Go duration strings like "15m", "30m", "1h".
	RevalidationInterval metav1.Duration `json:"revalidationInterval"`

	// LimitOneNewReservationPerHypervisor when true, prevents creating multiple new
	// reservations on the same hypervisor within a single reconcile cycle.
	// This helps spread reservations across hypervisors.
	// Default: true
	LimitOneNewReservationPerHypervisor bool `json:"limitOneNewReservationPerHypervisor"`

	// VMSelectionRotationInterval controls how often the VM selection offset rotates
	// when MaxVMsToProcess limits processing. Every N reconcile cycles, the offset
	// rotates to process different VMs. This ensures all VMs eventually get processed.
	// Default: 4 (rotate every 4th reconcile cycle). Use 0 to disable rotation.
	VMSelectionRotationInterval *int `json:"vmSelectionRotationInterval"`
}

type FailoverReservationController struct {
	client.Client
	VMSource        VMSource
	Config          FailoverConfig
	SchedulerClient *reservations.SchedulerClient
	Recorder        events.EventRecorder // Event recorder for emitting Kubernetes events
	// contains filtered or unexported fields
}

type VM struct {
	// UUID is the unique identifier of the VM.
	UUID string
	// FlavorName is the name of the flavor used by the VM.
	FlavorName string
	// ProjectID is the OpenStack project ID that owns the VM.
	ProjectID string
	// CurrentHypervisor is the hypervisor where the VM is currently running.
	CurrentHypervisor string
	// AvailabilityZone is the availability zone where the VM is located.
	// This is used to ensure failover reservations are created in the same AZ.
	AvailabilityZone string
	// Resources contains the VM's resource allocations (e.g., "memory", "vcpus").
	Resources map[string]resource.Quantity
	// FlavorExtraSpecs contains the flavor's extra specifications (e.g., traits, capabilities).
	// This is used by filters like filter_has_requested_traits and filter_capabilities.
	FlavorExtraSpecs map[string]string
}

type VMSource interface {
	// ListVMs returns all VMs that might need failover reservations.
	ListVMs(ctx context.Context) ([]VM, error)
	// ListVMsOnHypervisors returns VMs that are on the given hypervisors.
	// If trustHypervisorLocation is true, uses hypervisor CRD as source of truth for VM location.
	// If trustHypervisorLocation is false, uses postgres as source of truth but filters to VMs on known hypervisors.
	// Also logs warnings about data sync issues between postgres and hypervisor CRD.
	ListVMsOnHypervisors(ctx context.Context, hypervisorList *hv1.HypervisorList, trustHypervisorLocation bool) ([]VM, error)
	// GetVM returns a specific VM by UUID.
	// Returns nil, nil if the VM is not found (not an error, just doesn't exist).
	GetVM(ctx context.Context, vmUUID string) (*VM, error)
}