hostconformance

type Candidate ¶

type Candidate struct {
	StackKitsVersion string
	Digest           string
}

func CandidateFromExecutable(stackKitsVersion, path string) (Candidate, error)

type Check ¶

type Check struct {
	ID       string
	Category string
	Status   string
	Summary  string
}

type Facts ¶

type Facts struct {
	OS                          OSFacts
	Architecture                string
	AMD64MicroarchitectureLevel int
	KernelRelease               string
	Runtime                     RuntimeFacts
	Virtualization              VirtualizationFacts
	InitSystem                  InitSystemFacts
}

type InitSystemFacts ¶

type InitSystemFacts struct {
	Name         string `json:"name"`
	PID1         string `json:"pid1"`
	ManagerState string `json:"managerState"`
}

InitSystemFacts is the bounded, read-only observation needed by consumers that may later offer a native systemd timer. Name is systemd only when the observed PID 1 is systemd and its manager reports an active state. Other init systems and an unavailable manager remain explicit non-capabilities.

func ObserveInitSystem(ctx context.Context, source LocalSource) InitSystemFacts

func (f InitSystemFacts) Observed() bool

func (f InitSystemFacts) SystemdActive() bool

type LocalProbe ¶

type LocalProbe struct {
	Source           LocalSource
	Architecture     string
	StorageSourceRef string
	StoragePath      string
}

func (p LocalProbe) Observe(ctx context.Context) (Observation, error)

type LocalSource ¶

type LocalSource interface {
	ReadFile(string) ([]byte, error)
	LookPath(string) (string, error)
	Run(context.Context, string, ...string) ([]byte, error)
}

type NodeInventoryFacts ¶

type NodeInventoryFacts struct {
	SiteAddress                 string
	Architecture                string
	AMD64MicroarchitectureLevel int
	CPUCores                    int
	RamGB                       int
	StorageGB                   int
	Virtualization              string
	StorageCapacity             *StorageCapacityFacts
}

NodeInventoryFacts are the attested host facts written onto one Inventory node. They are compiler input, not a HostConformanceReceipt.

func ObserveNodeInventory(ctx context.Context, probe LocalProbe) (NodeInventoryFacts, error)

type OSFacts ¶

type OSFacts struct {
	Family       string
	Distribution string
	Version      string
}

type OSPolicy ¶

type OSPolicy interface {
	EvaluateOS(OSFacts, Candidate) Check
}

OSPolicy is the only component allowed to turn an observed OS tuple into a compatibility statement. Host diagnostics cannot promote OS support.

type Observation ¶

type Observation struct {
	Facts  Facts
	Checks []Check
}

type Probe ¶

type Probe interface {
	Observe(context.Context) (Observation, error)
}

type ProbeError ¶

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

ProbeError retains the private cause while exposing only a fixed probe stage and an error category. Command output and host file contents stay private.

func (e *ProbeError) Diagnostic() string

func (e *ProbeError) Error() string

func (e *ProbeError) Unwrap() error

type Producer ¶

type Producer struct {
	Probe    Probe
	Policy   OSPolicy
	Now      func() time.Time
	Validity time.Duration
}

func (p Producer) Produce(ctx context.Context, binding resolvedplan.ExternalHostBinding, candidate Candidate) (resolvedplan.HostConformanceReceipt, error)

type RuntimeFacts ¶

type RuntimeFacts struct {
	Engine  string
	Version string
}

type StorageCapacityFacts ¶

type StorageCapacityFacts struct {
	SourceRef         string
	Path              string
	FreeGiB           float64
	FilesystemType    string
	FilesystemClass   StorageFilesystemClass
	SupportsOwnership bool
}

StorageCapacityFacts is an observation of free space on the exact storage target used by the resolved plan. It is intentionally separate from the legacy total storage fact, which may describe the host root filesystem.

type StorageFilesystemClass ¶

type StorageFilesystemClass string

StorageFilesystemClass is the bounded classification of the filesystem mounted at a resolved storage target. Only local-posix is sufficient for a persistent application data root; all other known classes are deliberately reported so admission can distinguish a known mismatch from an observation that is missing or too unfamiliar to assess.

const (
	StorageFilesystemLocalPOSIX StorageFilesystemClass = "local-posix"
	StorageFilesystemNetwork    StorageFilesystemClass = "network"
	StorageFilesystemNonPOSIX   StorageFilesystemClass = "non-posix"
	StorageFilesystemEphemeral  StorageFilesystemClass = "ephemeral"
	StorageFilesystemUnknown    StorageFilesystemClass = "unknown"
)

type StorageFilesystemFacts ¶

type StorageFilesystemFacts struct {
	FilesystemType    string
	FilesystemClass   StorageFilesystemClass
	MountPoint        string
	MountSource       string
	SupportsOwnership bool
}

StorageFilesystemFacts describes the mount selected for one exact storage path. MountPoint is diagnostic evidence; callers keep the original contract path as the storage identity. A local-posix observation is restricted to filesystems with known ownership and persistence semantics.

func ObserveStorageFilesystem(ctx context.Context, source LocalSource, storagePath string) (StorageFilesystemFacts, error)

type UnverifiedOSPolicy ¶

type UnverifiedOSPolicy struct{}

func (UnverifiedOSPolicy) EvaluateOS(OSFacts, Candidate) Check

type VirtualizationFacts ¶

type VirtualizationFacts struct {
	Class  string
	Nested bool
}