Add startup system limit tuning

Author: matveynator

chicha-ip-proxy.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/matveynator/chicha-ip-proxy/pkg/config"
+	"github.com/matveynator/chicha-ip-proxy/pkg/limits"
 	"github.com/matveynator/chicha-ip-proxy/pkg/logging"
 	"github.com/matveynator/chicha-ip-proxy/pkg/proxy"
 	"github.com/matveynator/chicha-ip-proxy/pkg/setup"
@@ -88,6 +89,10 @@ func main() {
 		log.Fatalf("Error setting up logger: %v", err)
 	}
 
+	if err := limits.SetupLimits(logger); err != nil {
+		logger.Printf("System limit tuning encountered an issue: %v", err)
+	}
+
 	log.Printf("Starting chicha-ip-proxy version %s", version)
 
 	numCPUs := runtime.NumCPU()

pkg/limits/limits.go

@@ -0,0 +1,55 @@
+// Package limits manages OS-specific resource limits to keep the proxy responsive under heavy load.
+// The code favors channels over mutexes so limit adjustments remain observable and coordinated.
+package limits
+
+import (
+	"fmt"
+	"log"
+	"time"
+)
+
+type limitRequest struct {
+	description string
+	apply       func() error
+}
+
+// SetupLimits applies platform-specific limit changes in a channel-driven pipeline.
+// Using goroutines ensures each adjustment can proceed without blocking unrelated work.
+func SetupLimits(logger *log.Logger) error {
+	requests := collectLimitRequests(logger)
+	if len(requests) == 0 {
+		logger.Printf("No system limit changes required on this platform")
+		return nil
+	}
+
+	requestChan := make(chan limitRequest)
+	resultChan := make(chan error)
+
+	go func() {
+		defer close(resultChan)
+		for req := range requestChan {
+			logger.Printf("Applying system limit: %s", req.description)
+			resultChan <- req.apply()
+		}
+	}()
+
+	go func() {
+		defer close(requestChan)
+		for _, req := range requests {
+			requestChan <- req
+		}
+	}()
+
+	for processed := 0; processed < len(requests); processed++ {
+		select {
+		case err := <-resultChan:
+			if err != nil {
+				return fmt.Errorf("system limit adjustment failed: %w", err)
+			}
+		case <-time.After(5 * time.Second):
+			return fmt.Errorf("timeout while applying system limits")
+		}
+	}
+
+	return nil
+}

pkg/limits/limits_posix.go

@@ -0,0 +1,90 @@
+//go:build linux || darwin || freebsd || openbsd
+
+// Package limits includes POSIX-specific limit tuning to mirror xinetd-like defaults.
+// Separating platforms keeps platform quirks localized and easier to maintain.
+package limits
+
+import (
+	"fmt"
+	"log"
+	"syscall"
+)
+
+func collectLimitRequests(logger *log.Logger) []limitRequest {
+	desiredOpenFiles := uint64(100000)
+	desiredProcesses := uint64(100000)
+
+	requests := []limitRequest{
+		buildInfinityRequest("virtual memory (rlimit_as)", syscall.RLIMIT_AS),
+		buildInfinityRequest("CPU time (rlimit_cpu)", syscall.RLIMIT_CPU),
+		buildTargetRequest("open files (rlimit_files)", syscall.RLIMIT_NOFILE, desiredOpenFiles, logger),
+	}
+
+	if procResource, ok := processLimitResource(); ok {
+		requests = append(requests, buildTargetRequest("process count (rlimit_proc)", procResource, desiredProcesses, logger))
+	} else {
+		logger.Printf("Process limit resource is unavailable on this platform; skipping rlimit_proc")
+	}
+
+	return requests
+}
+
+func buildInfinityRequest(label string, resource int) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> unlimited", label),
+		apply: func() error {
+			unlimited := ^uint64(0)
+
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			desired := &syscall.Rlimit{Cur: unlimited, Max: unlimited}
+			if current.Cur == desired.Cur && current.Max == desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				return fmt.Errorf("failed setting %s to unlimited: %w", label, err)
+			}
+			return nil
+		},
+	}
+}
+
+func buildTargetRequest(label string, resource int, target uint64, logger *log.Logger) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> %d", label, target),
+		apply: func() error {
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			desired := &syscall.Rlimit{Cur: target, Max: target}
+			if current.Max > desired.Max {
+				desired.Max = current.Max
+			}
+			if desired.Cur > desired.Max {
+				desired.Cur = desired.Max
+			}
+
+			if current.Cur >= desired.Cur && current.Max >= desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				logger.Printf("Adjusting %s hit %v; trying best-effort with existing max", label, err)
+				fallback := &syscall.Rlimit{Cur: desired.Cur, Max: current.Max}
+				if fallback.Cur > fallback.Max {
+					fallback.Cur = fallback.Max
+				}
+				if setErr := syscall.Setrlimit(resource, fallback); setErr != nil {
+					return fmt.Errorf("failed setting %s even after fallback: %w", label, setErr)
+				}
+			}
+			return nil
+		},
+	}
+}

pkg/limits/limits_proc_darwin.go

@@ -0,0 +1,9 @@
+//go:build darwin
+
+// Package limits records the Darwin RLIMIT_NPROC identifier without pulling extra headers.
+// Explicit constants keep cross-compilation predictable for release automation.
+package limits
+
+func processLimitResource() (int, bool) {
+	return 7, true
+}

pkg/limits/limits_proc_freebsd.go

@@ -0,0 +1,9 @@
+//go:build freebsd
+
+// Package limits defines FreeBSD's RLIMIT_NPROC numeric identifier for process cap tuning.
+// Encoding it here keeps the rest of the codebase decoupled from cgo or external packages.
+package limits
+
+func processLimitResource() (int, bool) {
+	return 8, true
+}

pkg/limits/limits_proc_linux.go

@@ -0,0 +1,9 @@
+//go:build linux
+
+// Package limits embeds Linux-specific resource numbers to avoid external dependencies.
+// Keeping the constant here prevents cross-platform files from importing non-standard modules.
+package limits
+
+func processLimitResource() (int, bool) {
+	return 6, true
+}

pkg/limits/limits_proc_openbsd.go

@@ -0,0 +1,9 @@
+//go:build openbsd
+
+// Package limits includes the OpenBSD RLIMIT_NPROC value so process ceilings can be raised at startup.
+// Hardcoding the numeric value keeps the build pure Go without extra dependencies.
+package limits
+
+func processLimitResource() (int, bool) {
+	return 7, true
+}

pkg/limits/limits_windows.go

@@ -0,0 +1,12 @@
+//go:build windows
+
+// Package limits documents the lack of configurable RLIMIT-style knobs on Windows.
+// The stub still runs through the channel pipeline so the caller sees consistent behavior.
+package limits
+
+import "log"
+
+func collectLimitRequests(logger *log.Logger) []limitRequest {
+	logger.Printf("Windows relies on dynamic kernel limits; no explicit RLIMIT tuning applied")
+	return nil
+}