applycheck

type Change ¶

type Change struct {
	ID     DocID
	Op     ChangeOp
	Fields []FieldChange
}

Change is one entry in the per-doc diff between two MachineConfig snapshots. Fields is non-empty only when Op == OpUpdate.

func Diff(current, desired []byte) ([]Change, error)

func FilterChanged(changes []Change) []Change

type ChangeOp ¶

type ChangeOp int

ChangeOp classifies a per-document diff between two MachineConfig snapshots.

const (
	// OpAdd: doc present in desired, absent in current.
	OpAdd ChangeOp = iota
	// OpRemove: doc present in current, absent in desired (the leftover
	// class — eth1 lingering after migration to eth0).
	OpRemove
	// OpUpdate: doc present on both sides with field-level differences.
	OpUpdate
	// OpEqual: doc present on both sides, structurally identical.
	OpEqual
)

func (o ChangeOp) String() string

type DiskInfo ¶

type DiskInfo struct {
	DevPath    string // /dev/sda
	Model      string
	Serial     string
	WWID       string
	Modalias   string
	UUID       string
	Transport  string // sata / nvme / scsi / mmc / virtio / ...
	BusPath    string
	Size       uint64 // bytes
	Rotational bool
	Readonly   bool
	CDROM      bool
	Symlinks   []string
}

DiskInfo describes one host block device. Fields mirror Talos's block.Disk COSI resource shape verbatim — InstallDiskSelector.type (an enum: ssd/hdd/nvme/sd) is NOT a stored field but a derived predicate over Transport + Rotational, mirrored in matchSelector. CDROM and Readonly devices are excluded by Talos's install-disk resolution; matchSelector mirrors that exclusion.

Symlinks captures the alternate path forms Talos exposes for the same device (/dev/disk/by-id/wwn-…, /dev/disk/by-path/pci-…, /dev/disk/by-diskseq/…); RefKindDiskLiteral validation accepts any of these as equivalent to DevPath, because by-id paths are the recommended stable form for `machine.install.disk` and an operator using them is doing the right thing.

type DiskSelector ¶

type DiskSelector struct {
	Size     string `yaml:"size,omitempty"`
	Name     string `yaml:"name,omitempty"`
	Model    string `yaml:"model,omitempty"`
	Serial   string `yaml:"serial,omitempty"`
	Modalias string `yaml:"modalias,omitempty"`
	UUID     string `yaml:"uuid,omitempty"`
	WWID     string `yaml:"wwid,omitempty"`
	Type     string `yaml:"type,omitempty"`
	BusPath  string `yaml:"busPath,omitempty"`
}

DiskSelector mirrors the Talos v1alpha1 InstallDiskSelector schema (also used by UserVolumeConfig provisioning). Fields are left as raw strings so the walker stays YAML-only; the evaluator interprets each.

func (s *DiskSelector) IsZero() bool

type DocID ¶

type DocID struct {
	Kind string
	Name string
}

DocID is the structural identity used to pair up documents across the current/desired snapshots. v1.12 multi-doc keys by (kind, name). v1.11 nested form is collapsed into a synthetic DocID{Kind: "MachineConfig", Name: ""} so the root config doc participates in the diff.

type FieldChange ¶

type FieldChange struct {
	Path   string
	Old    any
	New    any
	HasOld bool
	HasNew bool
}

FieldChange describes a single leaf-level difference between matched documents. Only populated for ChangeOp.OpUpdate. Path is the YAML dotted accessor inside the document.

HasOld / HasNew distinguish "field missing on this side" from "field present with literal nil/null value": a YAML leaf with value `~` (or `null`) is a legitimate value, not a missing field, and the diff has to be able to render it differently.

type Finding ¶

type Finding struct {
	Ref      Ref
	Severity Severity
	Reason   string
	Hint     string
}

Finding is one validation result for one Ref. ValidateRefs returns one Finding per Ref; clean refs produce no findings.

func ValidateRefs(refs []Ref, snapshot HostSnapshot) []Finding

func WalkNetAddrFindings(rendered []byte) ([]Finding, error)

func (f *Finding) IsBlocker() bool

type HostSnapshot ¶

type HostSnapshot struct {
	Links []string
	Disks []DiskInfo
}

HostSnapshot captures the host-side resource inventory the validator compares declared refs against. Fields are populated from COSI `links` and `disks` reads at apply time; tests construct fakes directly.

type Ref ¶

type Ref struct {
	Kind     RefKind
	Name     string       // populated for RefKindLink and RefKindDiskLiteral
	Selector DiskSelector // populated for RefKindDiskSelector (zero value otherwise)
	Source   string       // human-readable JSONPath pointing at the offending field
}

Ref is a host-side reference the walker found in the rendered MachineConfig.

func WalkRefs(rendered []byte) ([]Ref, error)

type RefKind ¶

type RefKind int

RefKind classifies a host-resource reference extracted from a rendered MachineConfig.

const (
	// RefKindLink is a host network link by name (eth0, bond0, vlan tag, ...).
	RefKindLink RefKind = iota
	// RefKindDiskLiteral is an install/extra disk identified by a literal
	// device path (machine.install.disk: /dev/sda).
	RefKindDiskLiteral
	// RefKindDiskSelector is an install/user-volume disk identified by a
	// selector (size, model, serial, wwid, modalias, type, busPath).
	RefKindDiskSelector
)

type Severity ¶

type Severity int

Severity classifies a finding's blocker status.

const (
	// SeverityBlocker fails the apply.
	SeverityBlocker Severity = iota
	// SeverityWarning prints the finding but does not block.
	SeverityWarning
)