feat: implement preflight

pkg/resourceprovider/preflight/docker.go

@@ -0,0 +1,58 @@
+package preflight
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+)
+
+type dockerInfo struct {
+	Runtimes map[string]interface{} `json:"Runtimes"`
+}
+
+func (p *preflightChecker) CheckDockerRuntime(ctx context.Context) CheckResult {
+	cmd := exec.CommandContext(ctx, "docker", "info", "--format", "{{json .}}")
+	output, err := cmd.Output()
+	if err != nil {
+		return CheckResult{
+			Passed:  false,
+			Error:   fmt.Errorf("failed to get Docker info: %w", err),
+			Message: "Docker check failed",
+		}
+	}
+
+	var info dockerInfo
+	if err := json.Unmarshal(output, &info); err != nil {
+		return CheckResult{
+			Passed:  false,
+			Error:   fmt.Errorf("failed to parse Docker info: %w", err),
+			Message: "Docker info parsing failed",
+		}
+	}
+
+	// Check for nvidia runtime
+	_, hasNvidia := info.Runtimes["nvidia"]
+	if !hasNvidia {
+		return CheckResult{
+			Passed:  false,
+			Error:   fmt.Errorf("nvidia runtime not found in Docker configuration"),
+			Message: "NVIDIA runtime not found in Docker",
+		}
+	}
+
+	// Test nvidia runtime
+	testCmd := exec.CommandContext(ctx, "docker", "run", "--rm", "--runtime=nvidia", "nvidia/cuda:11.8.0-base", "nvidia-smi")
+	if err := testCmd.Run(); err != nil {
+		return CheckResult{
+			Passed:  false,
+			Error:   fmt.Errorf("failed to run NVIDIA runtime test: %w", err),
+			Message: "NVIDIA runtime test failed",
+		}
+	}
+
+	return CheckResult{
+		Passed:  true,
+		Message: "NVIDIA runtime is available and functional",
+	}
+}

pkg/resourceprovider/preflight/gpu.go

@@ -0,0 +1,151 @@
+package preflight
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/rs/zerolog/log"
+)
+
+type GPUCheckConfig struct {
+	Required     bool
+	MinGPUs      int
+	MinMemory    int64
+	Capabilities []string
+}
+
+func checkNvidiaSMI() error {
+	_, err := exec.LookPath("nvidia-smi")
+	return err
+}
+
+type nvidiaSmiResponse struct {
+	UUID          string
+	Name          string
+	MemoryTotal   string
+	DriverVersion string
+}
+
+func parseGPURecord(record string) (*GPUInfo, error) {
+	fields := strings.Split(record, ", ")
+	if len(fields) != 4 {
+		return nil, fmt.Errorf("invalid record format: expected 4 fields, got %d", len(fields))
+	}
+
+	// Parse memory, handling potential empty fields
+	memoryParts := strings.Split(strings.TrimSpace(fields[2]), " ")
+	if len(memoryParts) != 2 {
+		return nil, fmt.Errorf("invalid memory format: %s", fields[2])
+	}
+
+	memoryStr := memoryParts[0]
+	if memoryStr == "" {
+		return nil, fmt.Errorf("empty memory value")
+	}
+
+	memoryMiB, err := strconv.ParseInt(memoryStr, 10, 64)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse memory value '%s': %w", memoryStr, err)
+	}
+
+	// Create GPU info with trimmed fields and validated memory
+	gpu := &GPUInfo{
+		UUID:          strings.TrimSpace(fields[0]),
+		Name:          strings.TrimSpace(fields[1]),
+		MemoryTotal:   memoryMiB,
+		DriverVersion: strings.TrimSpace(fields[3]),
+	}
+
+	// Validate required fields
+	if gpu.UUID == "" {
+		return nil, fmt.Errorf("empty UUID")
+	}
+	if gpu.Name == "" {
+		return nil, fmt.Errorf("empty Name")
+	}
+	if gpu.DriverVersion == "" {
+		return nil, fmt.Errorf("empty DriverVersion")
+	}
+
+	return gpu, nil
+}
+
+func (p *preflightChecker) GetGPUInfo(ctx context.Context) ([]GPUInfo, error) {
+	if err := checkNvidiaSMI(); err != nil {
+		return nil, fmt.Errorf("nvidia-smi not available: %w", err)
+	}
+
+	cmd := exec.CommandContext(ctx, "nvidia-smi",
+		"--query-gpu=gpu_uuid,gpu_name,memory.total,driver_version",
+		"--format=csv,noheader")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		log.Error().Str("output", string(output)).Err(err).Msg("nvidia-smi command failed")
+		return nil, fmt.Errorf("error running nvidia-smi: %w", err)
+	}
+
+	records := strings.Split(strings.TrimSpace(string(output)), "\n")
+	gpus := make([]GPUInfo, 0, len(records))
+
+	for i, record := range records {
+		gpu, err := parseGPURecord(record)
+		if err != nil {
+			log.Warn().Err(err).Int("index", i).Msg("Failed to parse GPU record")
+			continue
+		}
+
+		gpus = append(gpus, *gpu)
+		log.Info().
+			Str("name", gpu.Name).
+			Str("uuid", gpu.UUID).
+			Int64("memory_mb", gpu.MemoryTotal).
+			Msgf("🎮 GPU %d details", len(gpus))
+	}
+
+	if len(gpus) == 0 {
+		return nil, fmt.Errorf("no valid GPUs found in nvidia-smi output")
+	}
+
+	return gpus, nil
+}
+
+func (p *preflightChecker) CheckGPU(ctx context.Context, config *GPUCheckConfig) CheckResult {
+	if !config.Required {
+		// Attempt to retrieve GPU info
+		gpus, err := p.GetGPUInfo(ctx)
+		if err != nil {
+			log.Warn().Msg("⚠️  Running without GPU support - Resource Provider will operate in CPU-only mode")
+			return CheckResult{
+				Passed:  true,
+				Message: "Operating in CPU-only mode",
+			}
+		}
+
+		// If we found GPUs, log them but still continue
+		log.Info().Msgf("🎮 Found %d optional GPUs available for use", len(gpus))
+		return CheckResult{
+			Passed:  true,
+			Message: fmt.Sprintf("Found %d NVIDIA GPUs (optional)", len(gpus)),
+		}
+	}
+
+	// Required GPU checks
+	log.Info().Msg("Starting required GPU checks")
+	gpus, err := p.GetGPUInfo(ctx)
+	if err != nil {
+		return CheckResult{
+			Passed:  false,
+			Error:   err,
+			Message: "Required GPU check failed - no NVIDIA GPUs detected",
+		}
+	}
+
+	log.Info().Msg("✅ GPU requirements satisfied")
+	return CheckResult{
+		Passed:  true,
+		Message: fmt.Sprintf("Found %d suitable GPUs", len(gpus)),
+	}
+}

pkg/resourceprovider/preflight/preflight.go

@@ -0,0 +1,86 @@
+package preflight
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rs/zerolog/log"
+)
+
+const RequiredGPUMemoryGB = 1 // 1GB of VRAM is required to startup if GPU is enabled
+
+type GPUInfo struct {
+	UUID          string
+	Name          string
+	MemoryTotal   int64
+	DriverVersion string
+}
+
+type CheckResult struct {
+	Passed  bool
+	Message string
+	Error   error
+}
+
+type preflightConfig struct {
+	GPU struct {
+		MinMemoryGB int64
+	}
+	Docker struct {
+		CheckRuntime bool
+	}
+}
+
+type preflightChecker struct {
+	gpuInfo []GPUInfo
+}
+
+func RunPreflightChecks() error {
+	ctx := context.Background()
+	log.Info().Msg("Starting preflight checks...")
+	checker := &preflightChecker{}
+	config := preflightConfig{
+		GPU: struct {
+			MinMemoryGB int64
+		}{
+			MinMemoryGB: RequiredGPUMemoryGB,
+		},
+	}
+
+	// Logging GPU requirements
+	gpuInfo, err := checker.GetGPUInfo(ctx)
+	if err != nil {
+		log.Warn().Err(err).Msg("⚠️  No GPU detected - will operate in CPU-only mode")
+	} else {
+		log.Info().
+			Int("gpu_count", len(gpuInfo)).
+			Int64("min_memory_gb", config.GPU.MinMemoryGB).
+			Msg("🎮 GPU requirements")
+	}
+
+	err = checker.RunAllChecks(ctx, config)
+	if err != nil {
+		log.Error().Err(err).Msg("❌ Preflight checks failed")
+		return err
+	}
+	return nil
+}
+
+func (p *preflightChecker) RunAllChecks(ctx context.Context, config preflightConfig) error {
+
+	gpuResult := p.CheckGPU(ctx, &GPUCheckConfig{
+		MinMemory: config.GPU.MinMemoryGB * 1024 * 1024 * 1024,
+	})
+	if !gpuResult.Passed {
+		return fmt.Errorf("GPU check failed: %s", gpuResult.Message)
+	}
+
+	if config.Docker.CheckRuntime {
+		runtimeResult := p.CheckDockerRuntime(ctx)
+		if !runtimeResult.Passed {
+			return fmt.Errorf("Docker runtime check failed: %s", runtimeResult.Message)
+		}
+	}
+
+	return nil
+}

pkg/resourceprovider/resourceprovider.go

@@ -17,6 +17,7 @@ import (
 	"github.com/lilypad-tech/lilypad/pkg/executor/bacalhau"
 	"github.com/lilypad-tech/lilypad/pkg/ipfs"
 	"github.com/lilypad-tech/lilypad/pkg/powLogs"
+	"github.com/lilypad-tech/lilypad/pkg/resourceprovider/preflight"
 	"github.com/lilypad-tech/lilypad/pkg/system"
 	"github.com/lilypad-tech/lilypad/pkg/web3"
 	"github.com/lilypad-tech/lilypad/pkg/web3/bindings/pow"
@@ -59,9 +60,8 @@ type ResourceProviderOfferOptions struct {
 
 // this configures the pow we will keep track of
 type ResourceProviderPowOptions struct {
-	DisablePow bool
-	NumWorkers int
-
+	DisablePow         bool
+	NumWorkers         int
 	CudaGridSize       int
 	CudaBlockSize      int
 	CudaHashsPerThread int
@@ -80,6 +80,7 @@ type ResourceProvider struct {
 	web3SDK    *web3.Web3SDK
 	options    ResourceProviderOptions
 	controller *ResourceProviderController
+	gpuInfo    []preflight.GPUInfo
 }
 
 func NewResourceProvider(
@@ -88,10 +89,16 @@ func NewResourceProvider(
 	executor executor.Executor,
 	tracer trace.Tracer,
 ) (*ResourceProvider, error) {
+
+	if err := preflight.RunPreflightChecks(); err != nil {
+		return nil, fmt.Errorf("preflight checks failed: %w", err)
+	}
+
 	controller, err := NewResourceProviderController(options, web3SDK, executor, tracer)
 	if err != nil {
 		return nil, err
 	}
+
 	solver := &ResourceProvider{
 		controller: controller,
 		options:    options,