vane 0.9.2

A flow-based reverse proxy with multi-layer routing and programmable pipelines.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

/* integration/pkg/env/sandbox.go */
package env

import (
	"fmt"
	"net"
	"os"
	"path/filepath"
	"time"
)

// Sandbox represents an isolated execution environment for a Vane instance.
type Sandbox struct {
	ID          string // Random ID for the run
	RootDir     string // /tmp/vane_test_xyz
	ConfigDir   string // /tmp/vane_test_xyz/config
	SocketDir   string // /tmp/vane_test_xyz/socket
	ConsolePort int    // TCP port for Vane Console/HealthCheck
	Env         map[string]string
}

// NewSandbox creates the directory structure and allocates a console port.
func NewSandbox() (*Sandbox, error) {
	// 1. Create a temporary directory prefix
	rootDir, err := os.MkdirTemp("", "vane_test_*")
	if err != nil {
		return nil, fmt.Errorf("failed to create temp root: %w", err)
	}

	// 2. Define sub-paths
	// Vane expects specific subdirectories inside CONFIG_DIR
	configDir := filepath.Join(rootDir, "config")
	socketDir := filepath.Join(rootDir, "socket")

	// 3. Create Directory Structure
	// Based on loader.rs requirements
	subDirs := []string{
		"listener",
		"application",
		"resolver",
		"certs",
	}

	for _, sub := range subDirs {
		path := filepath.Join(configDir, sub)
		if err := os.MkdirAll(path, 0755); err != nil {
			os.RemoveAll(rootDir) // Cleanup on fail
			return nil, fmt.Errorf("failed to create config subdir %s: %w", sub, err)
		}
	}

	// Also ensure socket dir exists
	if err := os.MkdirAll(socketDir, 0755); err != nil {
		os.RemoveAll(rootDir)
		return nil, fmt.Errorf("failed to create socket dir: %w", err)
	}

	// 4. Allocate Console Port
	port, err := GetFreePort()
	if err != nil {
		os.RemoveAll(rootDir)
		return nil, fmt.Errorf("failed to allocate console port: %w", err)
	}

	return &Sandbox{
		ID:          filepath.Base(rootDir),
		RootDir:     rootDir,
		ConfigDir:   configDir,
		SocketDir:   socketDir,
		ConsolePort: port,
		Env:         make(map[string]string),
	}, nil
}

// Cleanup removes all temporary files.
func (s *Sandbox) Cleanup() {
	if s.RootDir != "" {
		os.RemoveAll(s.RootDir)
	}
}

// WriteFile writes configuration content to the sandbox.
// relativePath example: "application/httpx.yaml"
func (s *Sandbox) WriteConfig(relativePath string, content []byte) error {
	fullPath := filepath.Join(s.ConfigDir, relativePath)
	dir := filepath.Dir(fullPath)

	if err := os.MkdirAll(dir, 0755); err != nil {
		return err
	}

	return os.WriteFile(fullPath, content, 0644)
}

// ConnectConsole attempts to dial the Vane console port.
func (s *Sandbox) ConnectConsole() (net.Conn, error) {
	return net.DialTimeout("tcp", fmt.Sprintf("127.0.0.1:%d", s.ConsolePort), 500*time.Millisecond)
}