controllers

type MachineAnnotatorReconciler struct {
	client.Client

	MachineEvents irievent.Source[*iri.Machine]
}

type MachinePoolAnnotatorReconciler struct {
	client.Client

	MachinePoolName    string
	MachineClassMapper mcm.MachineClassMapper
}

type MachinePoolHeartbeat struct {
	Client          client.Client
	MachinePoolName string
	MachineRuntime  machine.RuntimeService

	// ReadyState receives the latest probe result on every tick.
	ReadyState *MachinePoolReadyState

	// Events is owned by the caller. The heartbeat sends a single
	// GenericEvent for the pool whenever the probe result changes, so the
	// MachinePoolReconciler picks up the change without waiting for an
	// unrelated reconcile trigger. May be nil in tests where no reconciler
	// consumes the events.
	Events chan<- event.GenericEvent

	HeartbeatInterval  time.Duration
	LeaseDuration      time.Duration
	StatusProbeTimeout time.Duration
	// contains filtered or unexported fields
}

type MachinePoolInit struct {
	client.Client

	MachinePoolName string
	ProviderID      string

	TopologyLabels map[commonv1alpha1.TopologyLabel]string

	OnInitialized func(ctx context.Context) error
	OnFailed      func(ctx context.Context, reason error) error
}

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

type MachinePoolReconciler struct {
	client.Client

	// MachinePoolName is the name of the computev1alpha1.MachinePool to report / update.
	MachinePoolName string
	// Addresses are the addresses the machinepoollet server is available on.
	Addresses []computev1alpha1.MachinePoolAddress
	// Port is the port the machinepoollet server is available on.
	Port int32

	MachineRuntime     machine.RuntimeService
	MachineClassMapper mcm.MachineClassMapper

	TopologyLabels map[commonv1alpha1.TopologyLabel]string

	// ReadyState carries the latest IRI Status probe result published by the
	// MachinePoolHeartbeat. When non-nil and populated, the reconciler
	// reflects it into Status.Conditions[Ready] as part of its single status
	// patch. The reconciler is the only poollet-side writer of that
	// condition. May be nil; in that case the condition is left untouched.
	ReadyState *MachinePoolReadyState

	// HeartbeatEvents is an optional channel that the heartbeat uses to
	// nudge this reconciler when ReadyState changes. SetupWithManager wires
	// it as a source.Channel. May be nil.
	HeartbeatEvents <-chan event.GenericEvent
}

type MachineReconciler struct {
	events.EventRecorder
	client.Client

	MachineRuntime        irimachine.RuntimeService
	MachineRuntimeName    string
	MachineRuntimeVersion string

	MachineClassMapper mcm.MachineClassMapper

	MachinePoolName string

	MachineDownwardAPILabels      map[string]string
	MachineDownwardAPIAnnotations map[string]string

	NicDownwardAPILabels      map[string]string
	NicDownwardAPIAnnotations map[string]string

	VolumeDownwardAPILabels      map[string]string
	VolumeDownwardAPIAnnotations map[string]string

	NetworkDownwardAPILabels      map[string]string
	NetworkDownwardAPIAnnotations map[string]string

	WatchFilterValue string

	MaxConcurrentReconciles int
}