mirror of
https://github.com/lordmathis/llamactl.git
synced 2025-12-22 17:14:22 +00:00
326 lines
11 KiB
Go
326 lines
11 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
// loadEnvVars overrides config with environment variables
|
|
func loadEnvVars(cfg *AppConfig) {
|
|
// Server config
|
|
if host := os.Getenv("LLAMACTL_HOST"); host != "" {
|
|
cfg.Server.Host = host
|
|
}
|
|
if port := os.Getenv("LLAMACTL_PORT"); port != "" {
|
|
if p, err := strconv.Atoi(port); err == nil {
|
|
cfg.Server.Port = p
|
|
}
|
|
}
|
|
if allowedOrigins := os.Getenv("LLAMACTL_ALLOWED_ORIGINS"); allowedOrigins != "" {
|
|
cfg.Server.AllowedOrigins = strings.Split(allowedOrigins, ",")
|
|
}
|
|
if enableSwagger := os.Getenv("LLAMACTL_ENABLE_SWAGGER"); enableSwagger != "" {
|
|
if b, err := strconv.ParseBool(enableSwagger); err == nil {
|
|
cfg.Server.EnableSwagger = b
|
|
}
|
|
}
|
|
|
|
// Data config
|
|
if dataDir := os.Getenv("LLAMACTL_DATA_DIRECTORY"); dataDir != "" {
|
|
cfg.DataDir = dataDir
|
|
}
|
|
if instancesDir := os.Getenv("LLAMACTL_INSTANCES_DIR"); instancesDir != "" {
|
|
cfg.Instances.InstancesDir = instancesDir
|
|
}
|
|
if logsDir := os.Getenv("LLAMACTL_LOGS_DIR"); logsDir != "" {
|
|
cfg.Instances.LogsDir = logsDir
|
|
}
|
|
if autoCreate := os.Getenv("LLAMACTL_AUTO_CREATE_DATA_DIR"); autoCreate != "" {
|
|
if b, err := strconv.ParseBool(autoCreate); err == nil {
|
|
cfg.Instances.AutoCreateDirs = b
|
|
}
|
|
}
|
|
|
|
// Instance config
|
|
if portRange := os.Getenv("LLAMACTL_INSTANCE_PORT_RANGE"); portRange != "" {
|
|
if ports := ParsePortRange(portRange); ports != [2]int{0, 0} {
|
|
cfg.Instances.PortRange = ports
|
|
}
|
|
}
|
|
if maxInstances := os.Getenv("LLAMACTL_MAX_INSTANCES"); maxInstances != "" {
|
|
if m, err := strconv.Atoi(maxInstances); err == nil {
|
|
cfg.Instances.MaxInstances = m
|
|
}
|
|
}
|
|
if maxRunning := os.Getenv("LLAMACTL_MAX_RUNNING_INSTANCES"); maxRunning != "" {
|
|
if m, err := strconv.Atoi(maxRunning); err == nil {
|
|
cfg.Instances.MaxRunningInstances = m
|
|
}
|
|
}
|
|
if enableLRUEviction := os.Getenv("LLAMACTL_ENABLE_LRU_EVICTION"); enableLRUEviction != "" {
|
|
if b, err := strconv.ParseBool(enableLRUEviction); err == nil {
|
|
cfg.Instances.EnableLRUEviction = b
|
|
}
|
|
}
|
|
// Backend config
|
|
// LlamaCpp backend
|
|
if llamaCmd := os.Getenv("LLAMACTL_LLAMACPP_COMMAND"); llamaCmd != "" {
|
|
cfg.Backends.LlamaCpp.Command = llamaCmd
|
|
}
|
|
if llamaArgs := os.Getenv("LLAMACTL_LLAMACPP_ARGS"); llamaArgs != "" {
|
|
cfg.Backends.LlamaCpp.Args = strings.Split(llamaArgs, " ")
|
|
}
|
|
if llamaEnv := os.Getenv("LLAMACTL_LLAMACPP_ENV"); llamaEnv != "" {
|
|
if cfg.Backends.LlamaCpp.Environment == nil {
|
|
cfg.Backends.LlamaCpp.Environment = make(map[string]string)
|
|
}
|
|
parseEnvVars(llamaEnv, cfg.Backends.LlamaCpp.Environment)
|
|
}
|
|
if llamaDockerEnabled := os.Getenv("LLAMACTL_LLAMACPP_DOCKER_ENABLED"); llamaDockerEnabled != "" {
|
|
if b, err := strconv.ParseBool(llamaDockerEnabled); err == nil {
|
|
if cfg.Backends.LlamaCpp.Docker == nil {
|
|
cfg.Backends.LlamaCpp.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.LlamaCpp.Docker.Enabled = b
|
|
}
|
|
}
|
|
if llamaDockerImage := os.Getenv("LLAMACTL_LLAMACPP_DOCKER_IMAGE"); llamaDockerImage != "" {
|
|
if cfg.Backends.LlamaCpp.Docker == nil {
|
|
cfg.Backends.LlamaCpp.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.LlamaCpp.Docker.Image = llamaDockerImage
|
|
}
|
|
if llamaDockerArgs := os.Getenv("LLAMACTL_LLAMACPP_DOCKER_ARGS"); llamaDockerArgs != "" {
|
|
if cfg.Backends.LlamaCpp.Docker == nil {
|
|
cfg.Backends.LlamaCpp.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.LlamaCpp.Docker.Args = strings.Split(llamaDockerArgs, " ")
|
|
}
|
|
if llamaDockerEnv := os.Getenv("LLAMACTL_LLAMACPP_DOCKER_ENV"); llamaDockerEnv != "" {
|
|
if cfg.Backends.LlamaCpp.Docker == nil {
|
|
cfg.Backends.LlamaCpp.Docker = &DockerSettings{}
|
|
}
|
|
if cfg.Backends.LlamaCpp.Docker.Environment == nil {
|
|
cfg.Backends.LlamaCpp.Docker.Environment = make(map[string]string)
|
|
}
|
|
parseEnvVars(llamaDockerEnv, cfg.Backends.LlamaCpp.Docker.Environment)
|
|
}
|
|
if llamaEnv := os.Getenv("LLAMACTL_LLAMACPP_RESPONSE_HEADERS"); llamaEnv != "" {
|
|
if cfg.Backends.LlamaCpp.ResponseHeaders == nil {
|
|
cfg.Backends.LlamaCpp.ResponseHeaders = make(map[string]string)
|
|
}
|
|
parseHeaders(llamaEnv, cfg.Backends.LlamaCpp.ResponseHeaders)
|
|
}
|
|
|
|
// vLLM backend
|
|
if vllmCmd := os.Getenv("LLAMACTL_VLLM_COMMAND"); vllmCmd != "" {
|
|
cfg.Backends.VLLM.Command = vllmCmd
|
|
}
|
|
if vllmArgs := os.Getenv("LLAMACTL_VLLM_ARGS"); vllmArgs != "" {
|
|
cfg.Backends.VLLM.Args = strings.Split(vllmArgs, " ")
|
|
}
|
|
if vllmEnv := os.Getenv("LLAMACTL_VLLM_ENV"); vllmEnv != "" {
|
|
if cfg.Backends.VLLM.Environment == nil {
|
|
cfg.Backends.VLLM.Environment = make(map[string]string)
|
|
}
|
|
parseEnvVars(vllmEnv, cfg.Backends.VLLM.Environment)
|
|
}
|
|
if vllmDockerEnabled := os.Getenv("LLAMACTL_VLLM_DOCKER_ENABLED"); vllmDockerEnabled != "" {
|
|
if b, err := strconv.ParseBool(vllmDockerEnabled); err == nil {
|
|
if cfg.Backends.VLLM.Docker == nil {
|
|
cfg.Backends.VLLM.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.VLLM.Docker.Enabled = b
|
|
}
|
|
}
|
|
if vllmDockerImage := os.Getenv("LLAMACTL_VLLM_DOCKER_IMAGE"); vllmDockerImage != "" {
|
|
if cfg.Backends.VLLM.Docker == nil {
|
|
cfg.Backends.VLLM.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.VLLM.Docker.Image = vllmDockerImage
|
|
}
|
|
if vllmDockerArgs := os.Getenv("LLAMACTL_VLLM_DOCKER_ARGS"); vllmDockerArgs != "" {
|
|
if cfg.Backends.VLLM.Docker == nil {
|
|
cfg.Backends.VLLM.Docker = &DockerSettings{}
|
|
}
|
|
cfg.Backends.VLLM.Docker.Args = strings.Split(vllmDockerArgs, " ")
|
|
}
|
|
if vllmDockerEnv := os.Getenv("LLAMACTL_VLLM_DOCKER_ENV"); vllmDockerEnv != "" {
|
|
if cfg.Backends.VLLM.Docker == nil {
|
|
cfg.Backends.VLLM.Docker = &DockerSettings{}
|
|
}
|
|
if cfg.Backends.VLLM.Docker.Environment == nil {
|
|
cfg.Backends.VLLM.Docker.Environment = make(map[string]string)
|
|
}
|
|
parseEnvVars(vllmDockerEnv, cfg.Backends.VLLM.Docker.Environment)
|
|
}
|
|
if llamaEnv := os.Getenv("LLAMACTL_VLLM_RESPONSE_HEADERS"); llamaEnv != "" {
|
|
if cfg.Backends.VLLM.ResponseHeaders == nil {
|
|
cfg.Backends.VLLM.ResponseHeaders = make(map[string]string)
|
|
}
|
|
parseHeaders(llamaEnv, cfg.Backends.VLLM.ResponseHeaders)
|
|
}
|
|
|
|
// MLX backend
|
|
if mlxCmd := os.Getenv("LLAMACTL_MLX_COMMAND"); mlxCmd != "" {
|
|
cfg.Backends.MLX.Command = mlxCmd
|
|
}
|
|
if mlxArgs := os.Getenv("LLAMACTL_MLX_ARGS"); mlxArgs != "" {
|
|
cfg.Backends.MLX.Args = strings.Split(mlxArgs, " ")
|
|
}
|
|
if mlxEnv := os.Getenv("LLAMACTL_MLX_ENV"); mlxEnv != "" {
|
|
if cfg.Backends.MLX.Environment == nil {
|
|
cfg.Backends.MLX.Environment = make(map[string]string)
|
|
}
|
|
parseEnvVars(mlxEnv, cfg.Backends.MLX.Environment)
|
|
}
|
|
if llamaEnv := os.Getenv("LLAMACTL_MLX_RESPONSE_HEADERS"); llamaEnv != "" {
|
|
if cfg.Backends.MLX.ResponseHeaders == nil {
|
|
cfg.Backends.MLX.ResponseHeaders = make(map[string]string)
|
|
}
|
|
parseHeaders(llamaEnv, cfg.Backends.MLX.ResponseHeaders)
|
|
}
|
|
|
|
// Instance defaults
|
|
if autoRestart := os.Getenv("LLAMACTL_DEFAULT_AUTO_RESTART"); autoRestart != "" {
|
|
if b, err := strconv.ParseBool(autoRestart); err == nil {
|
|
cfg.Instances.DefaultAutoRestart = b
|
|
}
|
|
}
|
|
if maxRestarts := os.Getenv("LLAMACTL_DEFAULT_MAX_RESTARTS"); maxRestarts != "" {
|
|
if m, err := strconv.Atoi(maxRestarts); err == nil {
|
|
cfg.Instances.DefaultMaxRestarts = m
|
|
}
|
|
}
|
|
if restartDelay := os.Getenv("LLAMACTL_DEFAULT_RESTART_DELAY"); restartDelay != "" {
|
|
if seconds, err := strconv.Atoi(restartDelay); err == nil {
|
|
cfg.Instances.DefaultRestartDelay = seconds
|
|
}
|
|
}
|
|
if onDemandStart := os.Getenv("LLAMACTL_DEFAULT_ON_DEMAND_START"); onDemandStart != "" {
|
|
if b, err := strconv.ParseBool(onDemandStart); err == nil {
|
|
cfg.Instances.DefaultOnDemandStart = b
|
|
}
|
|
}
|
|
if onDemandTimeout := os.Getenv("LLAMACTL_ON_DEMAND_START_TIMEOUT"); onDemandTimeout != "" {
|
|
if seconds, err := strconv.Atoi(onDemandTimeout); err == nil {
|
|
cfg.Instances.OnDemandStartTimeout = seconds
|
|
}
|
|
}
|
|
if timeoutCheckInterval := os.Getenv("LLAMACTL_TIMEOUT_CHECK_INTERVAL"); timeoutCheckInterval != "" {
|
|
if minutes, err := strconv.Atoi(timeoutCheckInterval); err == nil {
|
|
cfg.Instances.TimeoutCheckInterval = minutes
|
|
}
|
|
}
|
|
// Auth config
|
|
if requireInferenceAuth := os.Getenv("LLAMACTL_REQUIRE_INFERENCE_AUTH"); requireInferenceAuth != "" {
|
|
if b, err := strconv.ParseBool(requireInferenceAuth); err == nil {
|
|
cfg.Auth.RequireInferenceAuth = b
|
|
}
|
|
}
|
|
if inferenceKeys := os.Getenv("LLAMACTL_INFERENCE_KEYS"); inferenceKeys != "" {
|
|
cfg.Auth.InferenceKeys = strings.Split(inferenceKeys, ",")
|
|
}
|
|
if requireManagementAuth := os.Getenv("LLAMACTL_REQUIRE_MANAGEMENT_AUTH"); requireManagementAuth != "" {
|
|
if b, err := strconv.ParseBool(requireManagementAuth); err == nil {
|
|
cfg.Auth.RequireManagementAuth = b
|
|
}
|
|
}
|
|
if managementKeys := os.Getenv("LLAMACTL_MANAGEMENT_KEYS"); managementKeys != "" {
|
|
cfg.Auth.ManagementKeys = strings.Split(managementKeys, ",")
|
|
}
|
|
|
|
// Local node config
|
|
if localNode := os.Getenv("LLAMACTL_LOCAL_NODE"); localNode != "" {
|
|
cfg.LocalNode = localNode
|
|
}
|
|
|
|
// Database config
|
|
if dbPath := os.Getenv("LLAMACTL_DATABASE_PATH"); dbPath != "" {
|
|
cfg.Database.Path = dbPath
|
|
}
|
|
if maxOpenConns := os.Getenv("LLAMACTL_DATABASE_MAX_OPEN_CONNECTIONS"); maxOpenConns != "" {
|
|
if m, err := strconv.Atoi(maxOpenConns); err == nil {
|
|
cfg.Database.MaxOpenConnections = m
|
|
}
|
|
}
|
|
if maxIdleConns := os.Getenv("LLAMACTL_DATABASE_MAX_IDLE_CONNECTIONS"); maxIdleConns != "" {
|
|
if m, err := strconv.Atoi(maxIdleConns); err == nil {
|
|
cfg.Database.MaxIdleConnections = m
|
|
}
|
|
}
|
|
if connMaxLifetime := os.Getenv("LLAMACTL_DATABASE_CONN_MAX_LIFETIME"); connMaxLifetime != "" {
|
|
if d, err := time.ParseDuration(connMaxLifetime); err == nil {
|
|
cfg.Database.ConnMaxLifetime = d
|
|
}
|
|
}
|
|
|
|
// Log rotation config
|
|
if logRotationEnabled := os.Getenv("LLAMACTL_LOG_ROTATION_ENABLED"); logRotationEnabled != "" {
|
|
if b, err := strconv.ParseBool(logRotationEnabled); err == nil {
|
|
cfg.Instances.LogRotationEnabled = b
|
|
}
|
|
}
|
|
if logRotationMaxSize := os.Getenv("LLAMACTL_LOG_ROTATION_MAX_SIZE"); logRotationMaxSize != "" {
|
|
if m, err := strconv.Atoi(logRotationMaxSize); err == nil {
|
|
cfg.Instances.LogRotationMaxSize = m
|
|
}
|
|
}
|
|
if logRotationCompress := os.Getenv("LLAMACTL_LOG_ROTATION_COMPRESS"); logRotationCompress != "" {
|
|
if b, err := strconv.ParseBool(logRotationCompress); err == nil {
|
|
cfg.Instances.LogRotationCompress = b
|
|
}
|
|
}
|
|
}
|
|
|
|
// ParsePortRange parses port range from string formats like "8000-9000" or "8000,9000"
|
|
func ParsePortRange(s string) [2]int {
|
|
var parts []string
|
|
|
|
// Try both separators
|
|
if strings.Contains(s, "-") {
|
|
parts = strings.Split(s, "-")
|
|
} else if strings.Contains(s, ",") {
|
|
parts = strings.Split(s, ",")
|
|
}
|
|
|
|
// Parse the two parts
|
|
if len(parts) == 2 {
|
|
start, err1 := strconv.Atoi(strings.TrimSpace(parts[0]))
|
|
end, err2 := strconv.Atoi(strings.TrimSpace(parts[1]))
|
|
if err1 == nil && err2 == nil {
|
|
return [2]int{start, end}
|
|
}
|
|
}
|
|
|
|
return [2]int{0, 0} // Invalid format
|
|
}
|
|
|
|
// parseEnvVars parses environment variables in format "KEY1=value1,KEY2=value2"
|
|
// and populates the provided environment map
|
|
func parseEnvVars(envString string, envMap map[string]string) {
|
|
if envString == "" {
|
|
return
|
|
}
|
|
for _, envPair := range strings.Split(envString, ",") {
|
|
if parts := strings.SplitN(strings.TrimSpace(envPair), "=", 2); len(parts) == 2 {
|
|
envMap[parts[0]] = parts[1]
|
|
}
|
|
}
|
|
}
|
|
|
|
// parseHeaders parses HTTP headers in format "KEY1=value1;KEY2=value2"
|
|
// and populates the provided environment map
|
|
func parseHeaders(envString string, envMap map[string]string) {
|
|
if envString == "" {
|
|
return
|
|
}
|
|
for _, envPair := range strings.Split(envString, ";") {
|
|
if parts := strings.SplitN(strings.TrimSpace(envPair), "=", 2); len(parts) == 2 {
|
|
envMap[parts[0]] = parts[1]
|
|
}
|
|
}
|
|
}
|