firmwaremanager

type Config struct {
	// PackagesDir is the directory containing firmware package YAML definitions
	PackagesDir string

	// FirmwareDir is the directory containing firmware files
	FirmwareDir string

	// NumWorkers is the number of concurrent update workers
	NumWorkers int

	// SchedulerInterval is how often the scheduler queries for pending updates
	SchedulerInterval time.Duration
}

type ExecContext struct {
	// StartedAt is when the async operation began.
	StartedAt time.Time `json:"started_at"`

	// DeadlineAt is when the operation should timeout.
	DeadlineAt time.Time `json:"deadline_at"`

	// TaskURI is the Redfish task URI for polling (Redfish strategy).
	TaskURI string `json:"task_uri,omitempty"`

	// PID is the process ID for script/SCP operations (Script/SSH strategy).
	PID int `json:"pid,omitempty"`

	// TargetIP is the IP address being monitored for reachability checks.
	TargetIP string `json:"target_ip,omitempty"`

	// BecameUnreachableAt tracks when the target became unreachable (for reboot detection).
	BecameUnreachableAt *time.Time `json:"became_unreachable_at,omitempty"`

	// WaitingForReboot indicates we're waiting for the device to come back after reboot.
	WaitingForReboot bool `json:"waiting_for_reboot,omitempty"`
}

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

type FirmwareManagerStats struct {
	ActiveJobs    int
	LoadedBundles int
	WorkerCount   int
}

type FirmwareUpdate struct {
	// Primary key - unique identifier for this update operation
	ID uuid.UUID `json:"id"`

	// Foreign key to nvswitch table
	SwitchUUID uuid.UUID `json:"switch_uuid"`

	// What is being updated
	Component     nvswitch.Component `json:"component"`      // FIRMWARE, CPLD, NVOS
	BundleVersion string             `json:"bundle_version"` // Version of the firmware bundle

	// How it's being updated
	Strategy Strategy `json:"strategy"` // script, ssh, redfish

	// Current state in the state machine
	State UpdateState `json:"state"`

	// Version tracking
	VersionFrom   string `json:"version_from"`   // Version before update
	VersionTo     string `json:"version_to"`     // Target version
	VersionActual string `json:"version_actual"` // Actual version after update (set during verify)

	// Redfish-specific: task URI for resume capability
	TaskURI string `json:"task_uri,omitempty"`

	// Error information
	ErrorMessage string `json:"error_message,omitempty"`

	// Sequencing fields for multi-component updates
	BundleUpdateID *uuid.UUID `json:"bundle_update_id,omitempty"` // Groups related updates
	SequenceOrder  int        `json:"sequence_order"`             // Order within bundle (1, 2, 3...)
	PredecessorID  *uuid.UUID `json:"predecessor_id,omitempty"`   // Must complete before this starts

	// Async worker pool fields
	ExecContext   *ExecContext `json:"exec_context,omitempty"`    // Persisted async execution state
	LastCheckedAt *time.Time   `json:"last_checked_at,omitempty"` // Last time worker polled this update

	// Timestamps
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

type FirmwareUpdateModel struct {
	bun.BaseModel `bun:"table:firmware_update,alias:fu"`

	ID            uuid.UUID          `bun:"id,pk,type:uuid"`
	SwitchUUID    uuid.UUID          `bun:"switch_uuid,notnull,type:uuid"`
	Component     nvswitch.Component `bun:"component,notnull"`
	BundleVersion string             `bun:"bundle_version,notnull"`
	Strategy      Strategy           `bun:"strategy,notnull"`
	State         UpdateState        `bun:"state,notnull"`
	VersionFrom   string             `bun:"version_from"`
	VersionTo     string             `bun:"version_to,notnull"`
	VersionActual string             `bun:"version_actual"`
	TaskURI       string             `bun:"task_uri"`
	ErrorMessage  string             `bun:"error_message"`
	// Sequencing fields for multi-component updates
	BundleUpdateID *uuid.UUID `bun:"bundle_update_id,type:uuid"`
	SequenceOrder  int        `bun:"sequence_order"`
	PredecessorID  *uuid.UUID `bun:"predecessor_id,type:uuid"`
	// Async worker pool fields
	ExecContext   *ExecContext `bun:"exec_context,type:jsonb"`
	LastCheckedAt *time.Time   `bun:"last_checked_at"`
	// Timestamps
	CreatedAt time.Time `bun:"created_at,notnull,default:now()"`
	UpdatedAt time.Time `bun:"updated_at,notnull,default:now()"`
}

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

type OutcomeType int

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

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

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

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

type StepOutcome struct {
	// Type indicates what kind of outcome this is.
	Type OutcomeType

	// NextState is the state to transition to (only valid for OutcomeTransition).
	NextState UpdateState

	// ExecContext holds async state to persist (only valid for OutcomeWait).
	ExecContext *ExecContext

	// Error is the error that caused failure (only valid for OutcomeFailed).
	Error error
}

type Strategy string

type StrategyFactory func(config interface{}) UpdateStrategy

type UpdateState string

type UpdateStore interface {
	// Save persists a firmware update (insert or update).
	Save(ctx context.Context, update *FirmwareUpdate) error

	// Get retrieves a firmware update by ID.
	Get(ctx context.Context, id uuid.UUID) (*FirmwareUpdate, error)

	// GetAll returns all firmware updates.
	GetAll(ctx context.Context) ([]*FirmwareUpdate, error)

	// GetPendingUpdates returns up to `limit` updates that need processing.
	// Priority:
	//   1. QUEUED updates whose predecessor has completed (or has no predecessor)
	//   2. Active (non-terminal, non-queued) updates, ordered by oldest updated_at first
	//
	// For QUEUED updates, the state is transitioned to the first active state before returning.
	// This method is used by the scheduler to dispatch work to workers.
	GetPendingUpdates(ctx context.Context, limit int) ([]*FirmwareUpdate, error)

	// GetBySwitch returns all firmware updates for a given switch.
	GetBySwitch(ctx context.Context, switchUUID uuid.UUID) ([]*FirmwareUpdate, error)

	// GetActive returns the active (non-terminal) update for a switch/component pair.
	// Returns nil, nil if no active update exists.
	GetActive(ctx context.Context, switchUUID uuid.UUID, component nvswitch.Component) (*FirmwareUpdate, error)

	// GetAnyActiveForSwitch returns any active (non-terminal) update for a switch.
	// Returns nil, nil if no active update exists.
	GetAnyActiveForSwitch(ctx context.Context, switchUUID uuid.UUID) (*FirmwareUpdate, error)

	// CancelRemainingInBundle cancels all QUEUED updates in a bundle that come after
	// the specified sequence order. Used when a predecessor fails.
	// Returns the number of updates cancelled.
	CancelRemainingInBundle(ctx context.Context, bundleUpdateID uuid.UUID, afterSequence int, failedComponent nvswitch.Component) (int, error)

	// Delete removes a firmware update by ID.
	Delete(ctx context.Context, id uuid.UUID) error
}

type UpdateStrategy interface {
	// Name returns the strategy type.
	Name() Strategy

	// Steps returns the ordered sequence of states for this strategy.
	// The executor will iterate through these states in order.
	// The update parameter allows strategies to return different steps based on
	// the component being updated and whether it's part of a bundle.
	Steps(update *FirmwareUpdate) []UpdateState

	// ExecuteStep performs the work for a single state in the update process.
	// Returns a StepOutcome indicating what the worker should do next:
	// - Wait: persist ExecContext and poll again after interval
	// - Transition: advance to the next state
	// - Failed: mark update as failed
	ExecuteStep(ctx context.Context, update *FirmwareUpdate, tray *nvswitch.NVSwitchTray) StepOutcome

	// GetCurrentVersion queries the current firmware version for a component.
	// This is used to populate VersionFrom before the update starts.
	GetCurrentVersion(ctx context.Context, tray *nvswitch.NVSwitchTray, component nvswitch.Component) (string, error)
}

type WorkItem struct {
	Update *FirmwareUpdate
	Done   func() // Called when processing is complete
}

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