Development Guide

// internal/daemon/daemon.go
package daemon

import (
    "context"
    "github.com/servin-dev/servin/pkg/container"
    "github.com/servin-dev/servin/pkg/image"
    "github.com/servin-dev/servin/pkg/network"
    "github.com/servin-dev/servin/pkg/storage"
)

type Daemon struct {
    containerManager *container.Manager
    imageManager     *image.Manager
    networkManager   *network.Manager
    storageManager   *storage.Manager
    config          *Config
}

func New(cfg *Config) (*Daemon, error) {
    d := &Daemon{
        config: cfg,
    }
    
    // Initialize managers
    d.containerManager = container.NewManager(cfg.ContainerConfig)
    d.imageManager = image.NewManager(cfg.ImageConfig)
    d.networkManager = network.NewManager(cfg.NetworkConfig)
    d.storageManager = storage.NewManager(cfg.StorageConfig)
    
    return d, nil
}

func (d *Daemon) Start(ctx context.Context) error {
    // Start all managers
    if err := d.storageManager.Start(ctx); err != nil {
        return err
    }
    
    if err := d.networkManager.Start(ctx); err != nil {
        return err
    }
    
    if err := d.imageManager.Start(ctx); err != nil {
        return err
    }
    
    if err := d.containerManager.Start(ctx); err != nil {
        return err
    }
    
    return nil
}

// pkg/container/manager.go
package container

import (
    "context"
    "github.com/opencontainers/runtime-spec/specs-go"
)

type Manager struct {
    runtime Runtime
    store   Store
    config  *Config
}

type Container struct {
    ID       string
    Name     string
    Image    string
    Config   *specs.Spec
    State    State
    Metadata map[string]string
}

type State int

const (
    StateCreated State = iota
    StateRunning
    StatePaused
    StateStopped
    StateUnknown
)

func (m *Manager) Create(ctx context.Context, req *CreateRequest) (*Container, error) {
    // Validate request
    if err := req.Validate(); err != nil {
        return nil, err
    }
    
    // Generate container ID
    id := generateID()
    
    // Create OCI spec
    spec, err := m.buildSpec(req)
    if err != nil {
        return nil, err
    }
    
    // Create container
    container := &Container{
        ID:     id,
        Name:   req.Name,
        Image:  req.Image,
        Config: spec,
        State:  StateCreated,
    }
    
    // Store container
    if err := m.store.Save(container); err != nil {
        return nil, err
    }
    
    return container, nil
}

func (m *Manager) Start(ctx context.Context, id string) error {
    container, err := m.store.Get(id)
    if err != nil {
        return err
    }
    
    if container.State != StateCreated {
        return ErrInvalidState
    }
    
    // Start container via runtime
    if err := m.runtime.Start(ctx, container); err != nil {
        return err
    }
    
    container.State = StateRunning
    return m.store.Save(container)
}

// pkg/vm/universal_development_provider.go
type UniversalDevelopmentVMProvider struct {
    config     *VMConfig
    vmPath     string
    sshPort    int
    running    bool
    containers map[string]*ContainerInfo
}

// State persistence for development workflows
func (p *UniversalDevelopmentVMProvider) saveRunningState() error {
    stateFile := filepath.Join(p.vmPath, "vm-running")
    if p.running {
        return os.WriteFile(stateFile, []byte("running"), 0644)
    } else {
        os.Remove(stateFile)
        return nil
    }
}

// Development mode provider selection
func GetVMProvider(config *VMConfig) (VMProvider, error) {
    if isDevelopmentMode() {
        // Use universal development provider for all platforms
        return NewDevelopmentVMProvider(config)
    }
    
    // Production providers (platform-specific)
    switch runtime.GOOS {
    case "darwin":
        return NewVirtualizationFrameworkProvider(config)
    case "windows": 
        return NewHyperVProvider(config)
    case "linux":
        return NewKVMProvider(config)
    }
}

// pkg/container/manager_test.go
package container_test

import (
    "context"
    "testing"
    
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
    "github.com/servin-dev/servin/pkg/container"
)

func TestManager_Create(t *testing.T) {
    tests := []struct {
        name    string
        request *container.CreateRequest
        want    *container.Container
        wantErr bool
    }{
        {
            name: "valid container creation",
            request: &container.CreateRequest{
                Name:  "test-container",
                Image: "nginx:latest",
            },
            want: &container.Container{
                Name:  "test-container",
                Image: "nginx:latest",
                State: container.StateCreated,
            },
            wantErr: false,
        },
        {
            name: "invalid container name",
            request: &container.CreateRequest{
                Name:  "",
                Image: "nginx:latest",
            },
            want:    nil,
            wantErr: true,
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            manager := setupTestManager(t)
            
            got, err := manager.Create(context.Background(), tt.request)
            
            if tt.wantErr {
                assert.Error(t, err)
                assert.Nil(t, got)
            } else {
                assert.NoError(t, err)
                assert.NotNil(t, got)
                assert.Equal(t, tt.want.Name, got.Name)
                assert.Equal(t, tt.want.Image, got.Image)
                assert.Equal(t, tt.want.State, got.State)
            }
        })
    }
}

func setupTestManager(t *testing.T) *container.Manager {
    mockRuntime := &MockRuntime{}
    mockStore := &MockStore{}
    
    config := &container.Config{
        Runtime: "test",
    }
    
    return container.NewManager(mockRuntime, mockStore, config)
}

// test/integration/container_test.go
// +build integration

package integration

import (
    "context"
    "testing"
    "time"
    
    "github.com/stretchr/testify/suite"
    "github.com/servin-dev/servin/pkg/container"
)

type ContainerIntegrationSuite struct {
    suite.Suite
    manager *container.Manager
    ctx     context.Context
}

func (s *ContainerIntegrationSuite) SetupSuite() {
    s.ctx = context.Background()
    
    // Setup real container manager with test config
    config := &container.Config{
        Runtime:   "runc",
        StateDir:  "/tmp/servin-test",
        ImageDir:  "/tmp/servin-images",
    }
    
    manager, err := container.NewManager(config)
    s.Require().NoError(err)
    
    s.manager = manager
}

func (s *ContainerIntegrationSuite) TestContainerLifecycle() {
    // Create container
    req := &container.CreateRequest{
        Name:  "test-integration",
        Image: "alpine:latest",
        Cmd:   []string{"sleep", "30"},
    }
    
    container, err := s.manager.Create(s.ctx, req)
    s.Require().NoError(err)
    s.Assert().Equal("test-integration", container.Name)
    
    // Start container
    err = s.manager.Start(s.ctx, container.ID)
    s.Require().NoError(err)
    
    // Wait for container to be running
    time.Sleep(1 * time.Second)
    
    // Check status
    status, err := s.manager.Status(s.ctx, container.ID)
    s.Require().NoError(err)
    s.Assert().Equal(container.StateRunning, status.State)
    
    // Stop container
    err = s.manager.Stop(s.ctx, container.ID, 10)
    s.Require().NoError(err)
    
    // Remove container
    err = s.manager.Remove(s.ctx, container.ID)
    s.Require().NoError(err)
}

func TestContainerIntegration(t *testing.T) {
    suite.Run(t, new(ContainerIntegrationSuite))
}

// test/e2e/cli_test.go
// +build e2e

package e2e

import (
    "os/exec"
    "strings"
    "testing"
    
    "github.com/stretchr/testify/assert"
)

func TestCLIWorkflow(t *testing.T) {
    // Start daemon
    daemon := exec.Command("servind", "--config", "test-config.json")
    err := daemon.Start()
    assert.NoError(t, err)
    defer daemon.Process.Kill()
    
    // Wait for daemon to start
    time.Sleep(3 * time.Second)
    
    // Test container creation
    cmd := exec.Command("servin", "run", "-d", "--name", "test-e2e", "alpine:latest", "sleep", "30")
    output, err := cmd.CombinedOutput()
    assert.NoError(t, err)
    
    containerID := strings.TrimSpace(string(output))
    assert.NotEmpty(t, containerID)
    
    // Test container listing
    cmd = exec.Command("servin", "ps")
    output, err = cmd.CombinedOutput()
    assert.NoError(t, err)
    assert.Contains(t, string(output), "test-e2e")
    
    // Test container stop
    cmd = exec.Command("servin", "stop", "test-e2e")
    _, err = cmd.CombinedOutput()
    assert.NoError(t, err)
    
    // Test container removal
    cmd = exec.Command("servin", "rm", "test-e2e")
    _, err = cmd.CombinedOutput()
    assert.NoError(t, err)
}

// Good: Clear function names and documentation
// CreateContainer creates a new container with the specified configuration.
// It validates the input parameters and returns an error if validation fails.
func (m *Manager) CreateContainer(ctx context.Context, req *CreateContainerRequest) (*Container, error) {
    if err := req.Validate(); err != nil {
        return nil, fmt.Errorf("invalid request: %w", err)
    }
    
    // Implementation...
}

// Good: Use meaningful variable names
containerManager := container.NewManager(config)
networkInterface := "eth0"
maxRetries := 3

// Bad: Unclear names
mgr := container.NewManager(config)
iface := "eth0"
max := 3

// Good: Handle errors appropriately
result, err := operation()
if err != nil {
    return fmt.Errorf("operation failed: %w", err)
}

// Good: Use context for cancellation
func (s *Server) handleRequest(ctx context.Context, req *Request) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
        // Handle request
    }
}

// internal/server/routes.go
func (s *Server) setupRoutes() {
    // Container routes
    s.router.Handle("/containers/json", s.handleContainerList).Methods("GET")
    s.router.Handle("/containers/create", s.handleContainerCreate).Methods("POST")
    s.router.Handle("/containers/{id}/start", s.handleContainerStart).Methods("POST")
    
    // New endpoint
    s.router.Handle("/containers/{id}/health", s.handleContainerHealth).Methods("GET")
}

func (s *Server) handleContainerHealth(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    id := vars["id"]
    
    health, err := s.daemon.GetContainerHealth(r.Context(), id)
    if err != nil {
        s.writeError(w, err)
        return
    }
    
    s.writeJSON(w, health)
}

// Enable profiling
import _ "net/http/pprof"

func main() {
    go func() {
        log.Println(http.ListenAndServe("localhost:6060", nil))
    }()
    
    // Main application
}

// Profile CPU usage
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

// Profile memory usage
go tool pprof http://localhost:6060/debug/pprof/heap

// Profile goroutines
go tool pprof http://localhost:6060/debug/pprof/goroutine

// pkg/container/manager_bench_test.go
func BenchmarkContainerCreate(b *testing.B) {
    manager := setupBenchmarkManager(b)
    
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        req := &container.CreateRequest{
            Name:  fmt.Sprintf("bench-container-%d", i),
            Image: "alpine:latest",
        }
        
        _, err := manager.Create(context.Background(), req)
        if err != nil {
            b.Fatal(err)
        }
    }
}

func BenchmarkContainerStart(b *testing.B) {
    manager := setupBenchmarkManager(b)
    containers := make([]*container.Container, b.N)
    
    // Setup containers
    for i := 0; i < b.N; i++ {
        req := &container.CreateRequest{
            Name:  fmt.Sprintf("bench-container-%d", i),
            Image: "alpine:latest",
        }
        
        c, err := manager.Create(context.Background(), req)
        if err != nil {
            b.Fatal(err)
        }
        containers[i] = c
    }
    
    b.ResetTimer()
    
    for i := 0; i < b.N; i++ {
        err := manager.Start(context.Background(), containers[i].ID)
        if err != nil {
            b.Fatal(err)
        }
    }
}