lib: Add CheckpointOptions struct and parsing for CRI options

Add support for parsing checkpoint options from the Kubernetes CRI
CheckpointPodRequest map[string]string options field. The new
ParseCheckpointOptions function validates known options and their
expected types (bool, int, string).

Known options: leave-running, tcp-established, ghost-limit, network-lock

Boolean values accept: yes, no, true, false, on, off, 0, 1

Generated with Claude Code (https://claude.ai/code)

Signed-off-by: Adrian Reber <areber@redhat.com>

Author: adrianreber

lib/checkpoint_options.go

@@ -0,0 +1,108 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package metadata
+
+import (
+	"fmt"
+)
+
+// OptionType represents the type of a checkpoint option value
+type OptionType int
+
+const (
+	OptionTypeBool OptionType = iota
+	OptionTypeInt
+	OptionTypeString
+)
+
+// CheckpointOption defines a known checkpoint option with its expected type
+type CheckpointOption struct {
+	Type OptionType
+}
+
+// CheckpointOptions represents the options from a CheckpointPodRequest
+type CheckpointOptions struct {
+	// LeaveRunning leaves the processes running in the container after checkpointing
+	LeaveRunning bool `json:"leaveRunning,omitempty"`
+	// TCPEstablished enables support for established TCP connections in the checkpoint
+	TCPEstablished bool `json:"tcpEstablished,omitempty"`
+	// GhostLimit limits max size of deleted file contents inside image
+	GhostLimit int64 `json:"ghostLimit,omitempty"`
+	// NetworkLock specifies the network locking/unlocking method
+	NetworkLock string `json:"networkLock,omitempty"`
+}
+
+// knownCheckpointOptions defines all known checkpoint options and their expected types
+var knownCheckpointOptions = map[string]CheckpointOption{
+	"leave-running":   {Type: OptionTypeBool},
+	"tcp-established": {Type: OptionTypeBool},
+	"ghost-limit":     {Type: OptionTypeInt},
+	"network-lock":    {Type: OptionTypeString},
+}
+
+// parseBool parses a string value as a boolean, accepting:
+// yes, no, true, false, on, off, 0, 1 (case-insensitive)
+func parseBool(value string) (bool, error) {
+	switch value {
+	case "yes", "Yes", "YES", "true", "True", "TRUE", "on", "On", "ON", "1":
+		return true, nil
+	case "no", "No", "NO", "false", "False", "FALSE", "off", "Off", "OFF", "0":
+		return false, nil
+	default:
+		return false, fmt.Errorf("invalid boolean value: %q (accepted: yes, no, true, false, on, off, 0, 1)", value)
+	}
+}
+
+// ParseCheckpointOptions validates and parses checkpoint options from a map[string]string.
+// It checks if the options are known and if their values match the expected types.
+// Returns a CheckpointOptions struct and any validation errors encountered.
+func ParseCheckpointOptions(options map[string]string) (*CheckpointOptions, error) {
+	result := &CheckpointOptions{}
+	var errs []string
+
+	for key, value := range options {
+		opt, known := knownCheckpointOptions[key]
+		if !known {
+			errs = append(errs, fmt.Sprintf("unknown option: %q", key))
+			continue
+		}
+
+		switch opt.Type {
+		case OptionTypeBool:
+			boolVal, err := parseBool(value)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("option %q: %v", key, err))
+				continue
+			}
+			switch key {
+			case "leave-running":
+				result.LeaveRunning = boolVal
+			case "tcp-established":
+				result.TCPEstablished = boolVal
+			}
+
+		case OptionTypeInt:
+			var intVal int64
+			if _, err := fmt.Sscanf(value, "%d", &intVal); err != nil {
+				errs = append(errs, fmt.Sprintf("option %q: invalid integer value: %q", key, value))
+				continue
+			}
+			switch key {
+			case "ghost-limit":
+				result.GhostLimit = intVal
+			}
+
+		case OptionTypeString:
+			switch key {
+			case "network-lock":
+				result.NetworkLock = value
+			}
+		}
+	}
+
+	if len(errs) > 0 {
+		return result, fmt.Errorf("validation errors: %v", errs)
+	}
+
+	return result, nil
+}