package config import ( "fmt" "net" "os" "strconv" "time" ) const ( maxTCPPort = 65535 maxShutdownTimeoutSeconds = 9 maxRequestTimeoutSeconds = 15 ) // Controller contains settings owned exclusively by the HTTP transport. type Controller struct { // Host is the IP address on which the listener binds. Host string // Port is the TCP port, in the range 1..65535. Port int // TimeoutSeconds limits request reads, response writes and idle connections. TimeoutSeconds int // ShutdownTimeoutSeconds bounds draining of active requests; it must not exceed nine seconds. ShutdownTimeoutSeconds int // MaxBodyBytes is the maximum accepted request body size before decoding. MaxBodyBytes int // MaxConnections bounds simultaneous connections handled by fasthttp. MaxConnections int // Admission controls business request throughput and execution concurrency. Admission Admission } // Admission defines shared request policies; health endpoints bypass them. type Admission struct { // MaxInFlight is the maximum number of executing requests, with no waiting queue. MaxInFlight int // RequestsPerSecond is the token refill rate for the global admission bucket. RequestsPerSecond int // Burst is the bucket capacity and maximum immediate request burst. Burst int // AuthRate limits public registration/login attempts per second. AuthRate int // AuthSlots bounds concurrent password KDF work globally. AuthSlots int // UserRate limits each authenticated account across all groups. UserRate int // UserSlots bounds concurrency across one account's groups. UserSlots int // UserWriteRate limits one account's write attempts per second. UserWriteRate int // UserWriteSlots bounds one account's concurrent writes. UserWriteSlots int // UserAuthRate limits session-management operations per account. UserAuthRate int // UserAuthSlots bounds one account's session-management concurrency. UserAuthSlots int } // defaultController returns the default listener, timeout and admission settings. func defaultController() *Controller { return &Controller{ Host: "0.0.0.0", Port: 8080, TimeoutSeconds: 3, ShutdownTimeoutSeconds: 5, MaxBodyBytes: 64 << 10, MaxConnections: 256, Admission: Admission{ MaxInFlight: 32, RequestsPerSecond: 1000, Burst: 100, AuthRate: 100, AuthSlots: 4, UserRate: 100, UserSlots: 8, UserWriteRate: 50, UserWriteSlots: 4, UserAuthRate: 20, UserAuthSlots: 2, }, } } // loadEnvironment applies environment overrides to this configuration section. func (cfg *Controller) loadEnvironment() error { if host, exists := os.LookupEnv("APP_HOST"); exists { cfg.Host = host } return loadIntegers( integerSetting{"APP_PORT", &cfg.Port}, integerSetting{"REQUEST_TIMEOUT_SECONDS", &cfg.TimeoutSeconds}, integerSetting{"SHUTDOWN_TIMEOUT_SECONDS", &cfg.ShutdownTimeoutSeconds}, integerSetting{"MAX_BODY_BYTES", &cfg.MaxBodyBytes}, integerSetting{"MAX_CONNECTIONS", &cfg.MaxConnections}, integerSetting{"MAX_IN_FLIGHT", &cfg.Admission.MaxInFlight}, integerSetting{"REQUESTS_PER_SECOND", &cfg.Admission.RequestsPerSecond}, integerSetting{"REQUEST_BURST", &cfg.Admission.Burst}, integerSetting{"AUTH_RATE", &cfg.Admission.AuthRate}, integerSetting{"AUTH_SLOTS", &cfg.Admission.AuthSlots}, integerSetting{"USER_RATE", &cfg.Admission.UserRate}, integerSetting{"USER_SLOTS", &cfg.Admission.UserSlots}, integerSetting{"USER_WRITE_RATE", &cfg.Admission.UserWriteRate}, integerSetting{"USER_WRITE_SLOTS", &cfg.Admission.UserWriteSlots}, integerSetting{"USER_AUTH_RATE", &cfg.Admission.UserAuthRate}, integerSetting{"USER_AUTH_SLOTS", &cfg.Admission.UserAuthSlots}, ) } // Validate checks listener addresses, timeouts and admission bounds. func (cfg *Controller) Validate() error { if cfg == nil { return fmt.Errorf("HTTP configuration is required") } if cfg.TimeoutSeconds > maxRequestTimeoutSeconds { return fmt.Errorf("REQUEST_TIMEOUT_SECONDS must not exceed %d", maxRequestTimeoutSeconds) } if net.ParseIP(cfg.Host) == nil { return fmt.Errorf("APP_HOST must be an IP address") } if cfg.Port < 1 || cfg.Port > maxTCPPort { return fmt.Errorf("APP_PORT must be 1..%d", maxTCPPort) } if cfg.ShutdownTimeoutSeconds < 1 || cfg.ShutdownTimeoutSeconds > maxShutdownTimeoutSeconds { return fmt.Errorf("SHUTDOWN_TIMEOUT_SECONDS must be 1..%d", maxShutdownTimeoutSeconds) } settings := []integerSetting{ {"REQUEST_TIMEOUT_SECONDS", &cfg.TimeoutSeconds}, {"MAX_BODY_BYTES", &cfg.MaxBodyBytes}, {"MAX_CONNECTIONS", &cfg.MaxConnections}, {"MAX_IN_FLIGHT", &cfg.Admission.MaxInFlight}, {"REQUESTS_PER_SECOND", &cfg.Admission.RequestsPerSecond}, {"REQUEST_BURST", &cfg.Admission.Burst}, } for _, setting := range settings { if err := validatePositive(setting.name, *setting.target); err != nil { return err } } return nil } // Bind returns the listener address, including brackets for IPv6 hosts. func (cfg *Controller) Bind() string { return net.JoinHostPort(cfg.Host, strconv.Itoa(cfg.Port)) } // Timeout returns the configured read, write and idle timeout. func (cfg *Controller) Timeout() time.Duration { return time.Duration(cfg.TimeoutSeconds) * time.Second } // ShutdownTimeout returns the maximum time allowed to drain active requests. func (cfg *Controller) ShutdownTimeout() time.Duration { return time.Duration(cfg.ShutdownTimeoutSeconds) * time.Second }