commitments

type APIConfig struct {
	// EnableChangeCommitments controls whether the change-commitments endpoint is active.
	// When false the endpoint returns HTTP 503; the info endpoint remains available.
	EnableChangeCommitments bool `json:"enableChangeCommitments"`
	// EnableReportUsage controls whether the report-usage endpoint is active.
	EnableReportUsage bool `json:"enableReportUsage"`
	// EnableReportCapacity controls whether the report-capacity endpoint is active.
	EnableReportCapacity bool `json:"enableReportCapacity"`
	// EnableQuotaAPI controls whether the quota API endpoint is active.
	// When false, the endpoint will return HTTP 503 Service Unavailable.
	EnableQuotaAPI bool `json:"enableQuota"`
	// WatchTimeout is how long the change-commitments handler polls CommittedResource
	// CRD conditions before giving up and rolling back.
	WatchTimeout metav1.Duration `json:"watchTimeout"`
	// WatchPollInterval is how frequently the change-commitments handler polls
	// CommittedResource CRD conditions while waiting for the controller outcome.
	WatchPollInterval metav1.Duration `json:"watchPollInterval"`
	// FlavorGroupResourceConfig maps flavor group IDs to resource flag configs; "*" acts as catch-all.
	FlavorGroupResourceConfig map[string]FlavorGroupResourcesConfig `json:"flavorGroupResourceConfig,omitempty"`
	// QuotaServedAvailabilityZones restricts quota handling to these AZs.
	// Quota received for AZs not in this list is silently skipped.
	// If empty/nil, no pre-filtering is applied (relies on error-based fallback).
	QuotaServedAvailabilityZones []string `json:"quotaServedAvailabilityZones,omitempty"`
}

type ApplyResult struct {
	// Created is the number of reservations created
	Created int
	// Deleted is the number of reservations deleted
	Deleted int
	// Repaired is the number of reservations repaired (metadata sync or recreated due to wrong config)
	Repaired int
	// TotalSlots is the total number of reservation slots that should exist after the apply.
	// Used by the CR controller to wait for the correct number of children in the cache.
	TotalSlots int
	// TouchedReservations are reservations that were created or updated
	TouchedReservations []v1alpha1.Reservation
	// RemovedReservations are reservations that were deleted
	RemovedReservations []v1alpha1.Reservation
}

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

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

type Commitment struct {
	// A unique numerical identifier for this commitment. This API uses this
	// numerical ID to refer to the commitment in other API calls.
	ID int `json:"id"`
	// A unique string identifier for this commitment. The next major version of
	// this API will use this UUID instead of the numerical ID to refer to
	// commitments in API calls.
	UUID string `json:"uuid"`
	// The resource for which usage is committed.
	ServiceType  string `json:"service_type"`
	ResourceName string `json:"resource_name"`
	// The availability zone in which usage is committed.
	AvailabilityZone string `json:"availability_zone"`
	// The amount of usage that was committed to.
	Amount uint64 `json:"amount"`
	// For measured resources, the unit for this resource. The value from the
	// amount field is measured in this unit.
	Unit string `json:"unit"`
	// The requested duration of this commitment, expressed as a comma-separated
	// sequence of positive integer multiples of time units like "1 year,
	// 3 months". Acceptable time units include "second", "minute", "hour",
	// "day", "month" and "year".
	Duration string `json:"duration"`
	// UNIX timestamp when this commitment was created.
	CreatedAt uint64 `json:"created_at"`
	// UNIX timestamp when this commitment should be confirmed. Only shown if
	// this was given when creating the commitment, to delay confirmation into
	// the future.
	ConfirmBy *uint64 `json:"confirm_by,omitempty"`
	// UNIX timestamp when this commitment was confirmed. Only shown after
	// confirmation.
	ConfirmedAt *uint64 `json:"confirmed_at,omitempty"`
	// UNIX timestamp when this commitment is set to expire. Note that the
	// duration counts from confirmBy (or from createdAt for immediately-
	// confirmed commitments) and is calculated at creation time, so this is
	// also shown on unconfirmed commitments.
	ExpiresAt uint64 `json:"expires_at"`
	// Whether the commitment is marked for transfer to a different project.
	// Transferable commitments do not count towards quota calculation in their
	// project, but still block capacity and still count towards billing. Not
	// shown if false.
	Transferable bool `json:"transferable"`
	// The current status of this commitment. If provided, one of "planned",
	// "pending", "guaranteed", "confirmed", "superseded", or "expired".
	Status string `json:"status,omitempty"`
	// Whether a mail notification should be sent if a created commitment is
	// confirmed. Can only be set if the commitment contains a confirmBy value.
	NotifyOnConfirm bool `json:"notify_on_confirm"`

	// The openstack project ID this commitment is for.
	ProjectID string `json:"project_id"`
	// The openstack domain ID this commitment is for.
	DomainID string `json:"domain_id"`
}

type CommitmentReservationController struct {
	// Client for the kubernetes API.
	client.Client
	// Kubernetes scheme to use for the reservations.
	Scheme *runtime.Scheme
	// Configuration for the controller.
	Conf ReservationControllerConfig
	// SchedulerClient for making scheduler API calls.
	SchedulerClient *reservations.SchedulerClient
	// DomainResolver resolves OpenStack domain IDs to domain names so the
	// domain_name scheduler hint can be populated for filter_external_customer.
	// Nil when KeystoneSecretRef is not configured; hint is omitted in that case.
	DomainResolver DomainResolver
}

type CommitmentState struct {
	// CommitmentUUID is the UUID of the commitment this state corresponds to.
	CommitmentUUID string
	// ProjectID is the OpenStack project this commitment belongs to
	ProjectID string
	// DomainID is the OpenStack domain this commitment belongs to
	DomainID string
	// FlavorGroupName identifies the flavor group (e.g., "hana_medium_v2")
	FlavorGroupName string
	// ResourceType is the kind of resource committed: memory or cores.
	ResourceType v1alpha1.CommittedResourceType
	// TotalMemoryBytes is the total memory in bytes across all reservation slots (memory commitments only).
	TotalMemoryBytes int64
	// TotalCores is the number of committed CPU cores (cores commitments only).
	TotalCores int64
	// AvailabilityZone specifies the availability zone for this commitment
	AvailabilityZone string
	// StartTime is when the commitment becomes active
	StartTime *time.Time
	// EndTime is when the commitment expires
	EndTime *time.Time
	// CreatorRequestID is the request ID that triggered this state change (for traceability)
	CreatorRequestID string
	// NamePrefix overrides the default "commitment-<uuid>-" reservation naming convention.
	// When set (e.g. "<cr-name>-"), Reservation CRDs are named "<NamePrefix><slot-index>".
	// Used by the CommittedResource controller; leave empty for the legacy syncer path.
	NamePrefix string
	// ParentGeneration is the Generation of the parent CommittedResource CRD. Written into
	// Reservation spec so the Reservation controller can echo it back in status, letting
	// the CR controller detect when all children have been processed for the current spec.
	// Zero for syncer-created reservations (no parent CR).
	ParentGeneration int64
	// State is the lifecycle state from Limes (planned/pending/guaranteed/confirmed/superseded/expired).
	State v1alpha1.CommitmentStatus
}

type CommitmentStateWithUsage struct {
	CommitmentState
	RemainingMemoryBytes int64
	AssignedInstances    []string
	UsedVCPUs            int64
}

type CommitmentsClient interface {
	// Init the client.
	Init(ctx context.Context, client client.Client, conf SyncerConfig) error
	// List all projects to resolve commitments.
	ListProjects(ctx context.Context) ([]Project, error)
	// List all commitments with resolved metadata (e.g. project, flavor, ...).
	ListCommitmentsByID(ctx context.Context, projects ...Project) (map[string]Commitment, error)
}

type CommittedResourceController struct {
	client.Client
	Scheme  *runtime.Scheme
	Conf    CommittedResourceControllerConfig
	Monitor *CRControllerMonitor
	// VMSource enables PAYG pre-allocation when creating reservation slots. When nil the
	// PAYG scan is skipped and all slots are created via blind scheduler probes.
	VMSource reservations.VMSource
}

type CommittedResourceControllerConfig struct {
	// RequeueIntervalRetry is the base back-off interval when placement fails (AllowRejection=false path).
	// The actual delay doubles with each consecutive failure: base * 2^min(failures, 6), capped at MaxRequeueInterval.
	// If zero (unconfigured), backoff is disabled and the controller retries immediately on every failure.
	RequeueIntervalRetry metav1.Duration `json:"requeueIntervalRetry"`

	// MaxRequeueInterval caps the exponential backoff delay.
	// Once this ceiling is reached, every subsequent retry fires after exactly this interval.
	MaxRequeueInterval metav1.Duration `json:"maxRequeueInterval"`

	// SlotCreationDelay is the pause inserted between consecutive Reservation CRD creates.
	// Spreads scheduler calls over time instead of bursting them all at once.
	// 0 disables the delay.
	SlotCreationDelay metav1.Duration `json:"slotCreationDelay"`

	// MaxSlotsPerCommitment caps the number of Reservation CRDs that may be created for a single
	// CommittedResource on the AllowRejection=true (API) path. Requests that would exceed this
	// limit are rejected immediately before any slots are created.
	// Has no effect on the AllowRejection=false (syncer) path.
	// 0 disables the cap.
	MaxSlotsPerCommitment int `json:"maxSlotsPerCommitment"`

	// EnablePaygPreAllocation enables scanning the AZ for existing PAYG VMs before creating
	// blind reservation slots. When true, the controller absorbs matching PAYG VMs into
	// pre-populated slots, consuming CR delta before falling back to the blind scheduler path.
	EnablePaygPreAllocation bool `json:"enablePaygPreAllocation,omitempty"`
}

type Config struct {
	ReservationController       ReservationControllerConfig       `json:"committedResourceReservationController"`
	CommittedResourceController CommittedResourceControllerConfig `json:"committedResourceController"`
	UsageReconciler             UsageReconcilerConfig             `json:"committedResourceUsageReconciler"`
	API                         APIConfig                         `json:"committedResourceAPI"`

	// DatasourceName is the name of the Datasource CRD that provides database
	// connection info. Used to construct the UsageDBClient for report-usage and usage reconciler.
	DatasourceName string `json:"datasourceName,omitempty"`
}

type DomainResolver interface {
	// ResolveDomainName returns the name of the domain with the given ID.
	// Returns an error if the domain cannot be found or the lookup fails.
	ResolveDomainName(ctx context.Context, domainID string) (string, error)
}

type E2EChecksConfig struct {
	// BaseURL for the commitments API. If empty, defaults to defaultCommitmentsAPIURL.
	BaseURL string `json:"baseURL"`
	// NoCleanup prevents test commitments from being deleted after a successful run.
	// Useful for local inspection with Tilt. Zero value (false) means cleanup runs normally.
	NoCleanup bool `json:"noCleanup,omitempty"`
	// ProjectID is the OpenStack project UUID for all e2e test commitments.
	// If empty, falls back to RoundTripCheck.TestProjectID, then defaultE2EProjectUUID.
	ProjectID string `json:"projectID,omitempty"`
	// AZs is the list of availability zones to test. If empty, falls back to
	// RoundTripCheck.AZ, then uses "qa-de-1b".
	AZs []string `json:"azs,omitempty"`
	// RequestTimeout is the per-request HTTP timeout for change-commitments calls.
	// Defaults to 30s if unset.
	RequestTimeout metav1.Duration `json:"requestTimeout,omitempty"`
	// RoundTripCheck holds optional overrides for backward compatibility.
	// Prefer the top-level ProjectID and AZs fields for new configurations.
	RoundTripCheck *E2ERoundTripConfig `json:"roundTripCheck,omitempty"`
}

type Flavor struct {
	ID          string  `json:"id"`
	Disk        int     `json:"disk"` // in GB.
	RAM         int     `json:"ram"`  // in MB.
	Name        string  `json:"name"`
	RxTxFactor  float64 `json:"rxtx_factor"`
	VCPUs       int     `json:"vcpus"`
	IsPublic    bool    `json:"os-flavor-access:is_public"`
	Ephemeral   int     `json:"OS-FLV-EXT-DATA:ephemeral"`
	Description string  `json:"description"`

	// JSON string of extra specifications used when scheduling the flavor.
	ExtraSpecs map[string]string `json:"extra_specs" db:"extra_specs"`
}

type FlavorGroupResourcesConfig struct {
	RAM       RAMResourceTypeConfig `json:"ram"`
	Cores     ResourceTypeConfig    `json:"cores"`
	Instances ResourceTypeConfig    `json:"instances"`
}

type PAYGCandidate struct {
	VMID       string
	HVName     string
	MemoryMB   uint64
	FlavorName string // exact flavor of the VM — used directly as the slot ResourceName
}

type Project struct {
	// DomainID is the domain ID the project belongs to.
	DomainID string `json:"domain_id"`
	// ID is the unique ID of the project.
	ID string `json:"id"`
	// Name is the name of the project.
	Name string `json:"name"`
	// ParentID is the parent_id of the project.
	ParentID string `json:"parent_id"`
}

type RAMResourceTypeConfig struct {
	HandlesCommitments bool `json:"handlesCommitments"`
	HandlesDryRun      bool `json:"handlesDryRun"`
	HasCapacity        bool `json:"hasCapacity"`
	HasQuota           bool `json:"hasQuota"`
	// RAMUnitGiB is the size of one declared LIQUID RAM unit in GiB.
	// Fixed-ratio groups set this to the smallest flavor's RAM (e.g. 480 for a 480 GiB HANA slot).
	// Variable-ratio groups set this to 1 (1 unit = 1 GiB).
	// Defaults to 1 if unset.
	RAMUnitGiB uint64 `json:"ramUnitGiB,omitempty"`
}

type ReservationControllerConfig struct {
	// RequeueIntervalActive is how often to re-verify a healthy Reservation CRD.
	RequeueIntervalActive metav1.Duration `json:"requeueIntervalActive"`
	// RequeueIntervalRetry is the back-off interval when knowledge is unavailable.
	RequeueIntervalRetry metav1.Duration `json:"requeueIntervalRetry"`
	// RequeueIntervalGracePeriod is how often to re-check while a VM allocation
	// is still within AllocationGracePeriod. Shorter than RequeueIntervalActive.
	RequeueIntervalGracePeriod metav1.Duration `json:"requeueIntervalGracePeriod"`
	// AllocationGracePeriod is the time window after a VM is allocated to a
	// reservation during which it's expected to appear on the target host.
	// VMs not confirmed within this period are considered stale and removed.
	AllocationGracePeriod metav1.Duration `json:"allocationGracePeriod"`
	// SchedulerURL is the endpoint of the nova external scheduler.
	SchedulerURL string `json:"schedulerURL"`
	// PipelineDefault is the fallback pipeline when no FlavorGroupPipelines entry matches.
	PipelineDefault string `json:"pipelineDefault"`
	// FlavorGroupPipelines maps flavor group IDs to pipeline names; "*" acts as catch-all.
	FlavorGroupPipelines map[string]string `json:"flavorGroupPipelines,omitempty"`
	// KeystoneSecretRef references a Kubernetes Secret that holds OpenStack credentials
	// used to resolve domain IDs to domain names for the domain_name scheduler hint.
	// The secret must contain the same keys as the syncer's keystoneSecretRef.
	// When empty, domain name resolution is skipped and filter_external_customer will
	// not enforce domain restrictions for CR reservations.
	KeystoneSecretRef corev1.SecretReference `json:"keystoneSecretRef,omitempty"`
	// SSOSecretRef is an optional reference to a Secret holding SSO credentials.
	// Required in environments that use SSO-based Keystone authentication.
	// When nil, http.DefaultClient is used, which will fail in SSO-only environments.
	SSOSecretRef *corev1.SecretReference `json:"ssoSecretRef,omitempty"`
}

type ReservationManager struct {
	client.Client
	// contains filtered or unexported fields
}

type ReservationManagerConfig struct {
	// SlotCreationDelay adds a pause between consecutive Reservation CRD creates to spread
	// scheduler load across time rather than bursting all creates at once.
	SlotCreationDelay time.Duration
	// MaxSlots caps the number of new blind-scheduler slots created per apply call.
	// PAYG remapping slots and already-existing slots are excluded from this limit.
	// Only set by the caller on the AllowRejection=true (API) path.
	MaxSlots                int
	EnablePaygPreAllocation bool
	VMSource                reservations.VMSource
}

type ResourceTypeConfig struct {
	HandlesCommitments bool `json:"handlesCommitments"`
	HandlesDryRun      bool `json:"handlesDryRun"`
	HasCapacity        bool `json:"hasCapacity"`
	HasQuota           bool `json:"hasQuota"`
}

type Server struct {
	ID                             string  `json:"id" db:"id,primarykey"`
	Name                           string  `json:"name" db:"name"`
	Status                         string  `json:"status" db:"status"`
	TenantID                       string  `json:"tenant_id" db:"tenant_id"`
	UserID                         string  `json:"user_id" db:"user_id"`
	HostID                         string  `json:"hostId" db:"host_id"`
	Created                        string  `json:"created" db:"created"`
	Updated                        string  `json:"updated" db:"updated"`
	AccessIPv4                     string  `json:"accessIPv4" db:"access_ipv4"`
	AccessIPv6                     string  `json:"accessIPv6" db:"access_ipv6"`
	OSDCFdiskConfig                string  `json:"OS-DCF:diskConfig" db:"os_dcf_disk_config"`
	Progress                       int     `json:"progress" db:"progress"`
	OSEXTAvailabilityZone          string  `json:"OS-EXT-AZ:availability_zone" db:"os_ext_az_availability_zone"`
	ConfigDrive                    string  `json:"config_drive" db:"config_drive"`
	KeyName                        string  `json:"key_name" db:"key_name"`
	OSSRVUSGLaunchedAt             string  `json:"OS-SRV-USG:launched_at" db:"os_srv_usg_launched_at"`
	OSSRVUSGTerminatedAt           *string `json:"OS-SRV-USG:terminated_at" db:"os_srv_usg_terminated_at"`
	OSEXTSRVATTRHost               string  `json:"OS-EXT-SRV-ATTR:host" db:"os_ext_srv_attr_host"`
	OSEXTSRVATTRInstanceName       string  `json:"OS-EXT-SRV-ATTR:instance_name" db:"os_ext_srv_attr_instance_name"`
	OSEXTSRVATTRHypervisorHostname string  `json:"OS-EXT-SRV-ATTR:hypervisor_hostname" db:"os_ext_srv_attr_hypervisor_hostname"`
	OSEXTSTSTaskState              *string `json:"OS-EXT-STS:task_state" db:"os_ext_sts_task_state"`
	OSEXTSTSVmState                string  `json:"OS-EXT-STS:vm_state" db:"os_ext_sts_vm_state"`
	OSEXTSTSPowerState             int     `json:"OS-EXT-STS:power_state" db:"os_ext_sts_power_state"`

	// From nested JSON
	FlavorName string `json:"-" db:"flavor_name"`
}

type SlotLimitExceededError struct {
	NewSlots int
	Limit    int
}

type Syncer struct {
	// Client to fetch commitments from Limes
	CommitmentsClient
	// Kubernetes client for CRD operations
	client.Client
	// contains filtered or unexported fields
}

type SyncerConfig struct {
	// Secret ref to keystone credentials stored in a k8s secret.
	KeystoneSecretRef corev1.SecretReference `json:"keystoneSecretRef"`
	// Secret ref to SSO credentials stored in a k8s secret, if applicable.
	SSOSecretRef *corev1.SecretReference `json:"ssoSecretRef"`
	// SyncInterval defines how often the syncer reconciles Limes commitments to Reservation CRDs.
	SyncInterval metav1.Duration `json:"committedResourceSyncInterval"`
	// FlavorGroupResourceConfig maps flavor group names to resource configs; "*" acts as catch-all.
	// Not read from JSON — populated by the caller from the shared APIConfig.
	FlavorGroupResourceConfig map[string]FlavorGroupResourcesConfig
}

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

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

type UsageReconciler struct {
	client.Client
	Conf     UsageReconcilerConfig
	VMSource reservations.VMSource
	Monitor  UsageReconcilerMonitor
}

type UsageReconcilerConfig struct {
	// CooldownInterval is the minimum time between usage reconcile runs for the same CommittedResource.
	// If a reconcile ran within this window, the next trigger is deferred until the window expires.
	// This interval also acts as the periodic fallback: every successful reconcile schedules the
	// next run after this duration so that changes not caught by watches are still picked up.
	CooldownInterval metav1.Duration `json:"cooldownInterval"`
}

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

type VMUsageInfo struct {
	UUID          string
	Name          string
	FlavorName    string
	FlavorGroup   string
	Status        string
	MemoryMB      uint64
	VCPUs         uint64
	DiskGB        uint64
	VideoRAMMiB   *uint64
	OSType        string
	AZ            string
	Hypervisor    string
	CreatedAt     time.Time
	UsageMultiple uint64
}