forked from mtusi2026/mtusi2026lab4
161 lines
5.6 KiB
Go
161 lines
5.6 KiB
Go
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 {
|
|
// InstanceID identifies this API process to the load balancer diagnostics.
|
|
InstanceID string
|
|
// 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: 10 << 20,
|
|
MaxConnections: 16,
|
|
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 {
|
|
cfg.InstanceID = os.Getenv("INSTANCE_ID")
|
|
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
|
|
}
|