feat: add port forwarding history persistence

2026-01-27 03:04:21 +01:00 · 2025-09-12 11:29:17 +02:00
parent 71bf8ea2bb
commit 3c627a5d21
4 changed files with 334 additions and 37 deletions
--- a/internal/history/history.go
+++ b/internal/history/history.go
@@ -15,11 +15,21 @@ type ConnectionHistory struct {
 	Connections map[string]ConnectionInfo `json:"connections"`
 }

+// PortForwardConfig stores port forwarding configuration
+type PortForwardConfig struct {
+	Type        string `json:"type"` // "local", "remote", "dynamic"
+	LocalPort   string `json:"local_port"`
+	RemoteHost  string `json:"remote_host"`
+	RemotePort  string `json:"remote_port"`
+	BindAddress string `json:"bind_address"`
+}
+
 // ConnectionInfo stores information about a specific connection
 type ConnectionInfo struct {
-	HostName     string    `json:"host_name"`
-	LastConnect  time.Time `json:"last_connect"`
-	ConnectCount int       `json:"connect_count"`
+	HostName       string             `json:"host_name"`
+	LastConnect    time.Time          `json:"last_connect"`
+	ConnectCount   int                `json:"connect_count"`
+	PortForwarding *PortForwardConfig `json:"port_forwarding,omitempty"`
 }

 // HistoryManager manages the connection history
@@ -257,3 +267,42 @@ func (hm *HistoryManager) GetAllConnectionsInfo() []ConnectionInfo {

 	return connections
 }
+
+// RecordPortForwarding saves port forwarding configuration for a host
+func (hm *HistoryManager) RecordPortForwarding(hostName, forwardType, localPort, remoteHost, remotePort, bindAddress string) error {
+	now := time.Now()
+
+	portForwardConfig := &PortForwardConfig{
+		Type:        forwardType,
+		LocalPort:   localPort,
+		RemoteHost:  remoteHost,
+		RemotePort:  remotePort,
+		BindAddress: bindAddress,
+	}
+
+	if conn, exists := hm.history.Connections[hostName]; exists {
+		// Update existing connection
+		conn.LastConnect = now
+		conn.ConnectCount++
+		conn.PortForwarding = portForwardConfig
+		hm.history.Connections[hostName] = conn
+	} else {
+		// Create new connection record
+		hm.history.Connections[hostName] = ConnectionInfo{
+			HostName:       hostName,
+			LastConnect:    now,
+			ConnectCount:   1,
+			PortForwarding: portForwardConfig,
+		}
+	}
+
+	return hm.saveHistory()
+}
+
+// GetPortForwardingConfig retrieves the last used port forwarding configuration for a host
+func (hm *HistoryManager) GetPortForwardingConfig(hostName string) *PortForwardConfig {
+	if conn, exists := hm.history.Connections[hostName]; exists {
+		return conn.PortForwarding
+	}
+	return nil
+}
--- a/internal/history/port_forward_test.go
+++ b/internal/history/port_forward_test.go
@@ -0,0 +1,183 @@
+package history
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestPortForwardingHistory(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create history manager with temp directory
+	historyPath := filepath.Join(tempDir, "test_history.json")
+	hm := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	hostName := "test-server"
+
+	// Test recording port forwarding configuration
+	err = hm.RecordPortForwarding(hostName, "local", "8080", "localhost", "80", "127.0.0.1")
+	if err != nil {
+		t.Fatalf("Failed to record port forwarding: %v", err)
+	}
+
+	// Test retrieving port forwarding configuration
+	config := hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist")
+	}
+
+	// Verify the saved configuration
+	if config.Type != "local" {
+		t.Errorf("Expected Type 'local', got %s", config.Type)
+	}
+	if config.LocalPort != "8080" {
+		t.Errorf("Expected LocalPort '8080', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "localhost" {
+		t.Errorf("Expected RemoteHost 'localhost', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "80" {
+		t.Errorf("Expected RemotePort '80', got %s", config.RemotePort)
+	}
+	if config.BindAddress != "127.0.0.1" {
+		t.Errorf("Expected BindAddress '127.0.0.1', got %s", config.BindAddress)
+	}
+
+	// Test updating configuration with different values
+	err = hm.RecordPortForwarding(hostName, "remote", "3000", "app-server", "8000", "")
+	if err != nil {
+		t.Fatalf("Failed to record updated port forwarding: %v", err)
+	}
+
+	// Verify the updated configuration
+	config = hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist after update")
+	}
+
+	if config.Type != "remote" {
+		t.Errorf("Expected updated Type 'remote', got %s", config.Type)
+	}
+	if config.LocalPort != "3000" {
+		t.Errorf("Expected updated LocalPort '3000', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "app-server" {
+		t.Errorf("Expected updated RemoteHost 'app-server', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "8000" {
+		t.Errorf("Expected updated RemotePort '8000', got %s", config.RemotePort)
+	}
+	if config.BindAddress != "" {
+		t.Errorf("Expected updated BindAddress to be empty, got %s", config.BindAddress)
+	}
+
+	// Test dynamic forwarding
+	err = hm.RecordPortForwarding(hostName, "dynamic", "1080", "", "", "0.0.0.0")
+	if err != nil {
+		t.Fatalf("Failed to record dynamic port forwarding: %v", err)
+	}
+
+	config = hm.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to exist for dynamic forwarding")
+	}
+
+	if config.Type != "dynamic" {
+		t.Errorf("Expected Type 'dynamic', got %s", config.Type)
+	}
+	if config.LocalPort != "1080" {
+		t.Errorf("Expected LocalPort '1080', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "" {
+		t.Errorf("Expected RemoteHost to be empty for dynamic forwarding, got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "" {
+		t.Errorf("Expected RemotePort to be empty for dynamic forwarding, got %s", config.RemotePort)
+	}
+	if config.BindAddress != "0.0.0.0" {
+		t.Errorf("Expected BindAddress '0.0.0.0', got %s", config.BindAddress)
+	}
+}
+
+func TestPortForwardingHistoryPersistence(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	historyPath := filepath.Join(tempDir, "test_history.json")
+
+	// Create first history manager and record data
+	hm1 := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	hostName := "persistent-server"
+	err = hm1.RecordPortForwarding(hostName, "local", "9090", "db-server", "5432", "")
+	if err != nil {
+		t.Fatalf("Failed to record port forwarding: %v", err)
+	}
+
+	// Create second history manager and load data
+	hm2 := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	err = hm2.loadHistory()
+	if err != nil {
+		t.Fatalf("Failed to load history: %v", err)
+	}
+
+	// Verify the loaded configuration
+	config := hm2.GetPortForwardingConfig(hostName)
+	if config == nil {
+		t.Fatalf("Expected port forwarding config to be loaded from file")
+	}
+
+	if config.Type != "local" {
+		t.Errorf("Expected loaded Type 'local', got %s", config.Type)
+	}
+	if config.LocalPort != "9090" {
+		t.Errorf("Expected loaded LocalPort '9090', got %s", config.LocalPort)
+	}
+	if config.RemoteHost != "db-server" {
+		t.Errorf("Expected loaded RemoteHost 'db-server', got %s", config.RemoteHost)
+	}
+	if config.RemotePort != "5432" {
+		t.Errorf("Expected loaded RemotePort '5432', got %s", config.RemotePort)
+	}
+}
+
+func TestGetPortForwardingConfigNonExistent(t *testing.T) {
+	// Create temporary directory for testing
+	tempDir, err := os.MkdirTemp("", "sshm_test_*")
+	if err != nil {
+		t.Fatalf("Failed to create temp dir: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	historyPath := filepath.Join(tempDir, "test_history.json")
+	hm := &HistoryManager{
+		historyPath: historyPath,
+		history:     &ConnectionHistory{Connections: make(map[string]ConnectionInfo)},
+	}
+
+	// Test getting configuration for non-existent host
+	config := hm.GetPortForwardingConfig("non-existent-host")
+	if config != nil {
+		t.Errorf("Expected nil config for non-existent host, got %+v", config)
+	}
+}