mirror of
https://github.com/Rain-kl/OpenFlare.git
synced 2026-09-30 22:26:38 +08:00
ryan
328 lines
11 KiB
Go
328 lines
11 KiB
Go
package config
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"net"
|
|
"os"
|
|
pathpkg "path"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
const (
|
|
defaultDockerMainConfigRelativePath = "etc/nginx/nginx.conf"
|
|
defaultDockerRouteConfigRelativePath = "etc/nginx/conf.d/openflare_routes.conf"
|
|
defaultCertDirRelativePath = "etc/nginx/certs"
|
|
defaultLuaDirRelativePath = "etc/nginx/lua"
|
|
defaultDockerStateRelativePath = "var/lib/openflare/agent-state.json"
|
|
defaultObservabilityBufferRelativePath = "var/lib/openflare/observability-buffer.json"
|
|
defaultDockerOpenRestyCertDir = "/etc/nginx/openflare-certs"
|
|
defaultDockerOpenRestyLuaDir = "/etc/nginx/openflare-lua"
|
|
defaultOpenRestyObservabilityPort = 18081
|
|
defaultObservabilityReplayMinutes = 15
|
|
)
|
|
|
|
type Config struct {
|
|
ServerURL string `json:"server_url"`
|
|
AgentToken string `json:"agent_token"`
|
|
DiscoveryToken string `json:"discovery_token"`
|
|
NodeName string `json:"node_name"`
|
|
NodeIP string `json:"node_ip"`
|
|
AgentVersion string `json:"-"`
|
|
NginxVersion string `json:"-"`
|
|
OpenrestyPath string `json:"openresty_path"`
|
|
OpenrestyContainerName string `json:"openresty_container_name"`
|
|
OpenrestyDockerImage string `json:"openresty_docker_image"`
|
|
DockerBinary string `json:"docker_binary"`
|
|
DataDir string `json:"data_dir"`
|
|
MainConfigPath string `json:"main_config_path"`
|
|
RouteConfigPath string `json:"route_config_path"`
|
|
CertDir string `json:"cert_dir"`
|
|
OpenrestyCertDir string `json:"openresty_cert_dir"`
|
|
LuaDir string `json:"lua_dir"`
|
|
OpenrestyLuaDir string `json:"openresty_lua_dir"`
|
|
OpenrestyObservabilityPort int `json:"openresty_observability_port"`
|
|
ObservabilityBufferPath string `json:"observability_buffer_path"`
|
|
ObservabilityReplayMinutes int `json:"observability_replay_minutes"`
|
|
StatePath string `json:"state_path"`
|
|
HeartbeatInterval MillisecondDuration `json:"heartbeat_interval"`
|
|
RequestTimeout MillisecondDuration `json:"request_timeout"`
|
|
configPath string
|
|
}
|
|
|
|
type configFile struct {
|
|
ServerURL string `json:"server_url"`
|
|
AgentToken string `json:"agent_token"`
|
|
DiscoveryToken string `json:"discovery_token"`
|
|
NodeName string `json:"node_name"`
|
|
NodeIP string `json:"node_ip"`
|
|
OpenrestyPath string `json:"openresty_path"`
|
|
OpenrestyContainerName string `json:"openresty_container_name"`
|
|
OpenrestyDockerImage string `json:"openresty_docker_image"`
|
|
DockerBinary string `json:"docker_binary"`
|
|
DataDir string `json:"data_dir"`
|
|
MainConfigPath string `json:"main_config_path"`
|
|
RouteConfigPath string `json:"route_config_path"`
|
|
CertDir string `json:"cert_dir"`
|
|
OpenrestyCertDir string `json:"openresty_cert_dir"`
|
|
LuaDir string `json:"lua_dir"`
|
|
OpenrestyLuaDir string `json:"openresty_lua_dir"`
|
|
OpenrestyObservabilityPort int `json:"openresty_observability_port"`
|
|
ObservabilityBufferPath string `json:"observability_buffer_path"`
|
|
ObservabilityReplayMinutes int `json:"observability_replay_minutes"`
|
|
StatePath string `json:"state_path"`
|
|
HeartbeatInterval MillisecondDuration `json:"heartbeat_interval"`
|
|
RequestTimeout MillisecondDuration `json:"request_timeout"`
|
|
}
|
|
|
|
func Load(path string) (*Config, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
file := &configFile{}
|
|
if err = json.Unmarshal(data, file); err != nil {
|
|
return nil, err
|
|
}
|
|
cfg := &Config{
|
|
ServerURL: file.ServerURL,
|
|
AgentToken: file.AgentToken,
|
|
DiscoveryToken: file.DiscoveryToken,
|
|
NodeName: file.NodeName,
|
|
NodeIP: file.NodeIP,
|
|
OpenrestyPath: file.OpenrestyPath,
|
|
OpenrestyContainerName: file.OpenrestyContainerName,
|
|
OpenrestyDockerImage: file.OpenrestyDockerImage,
|
|
DockerBinary: file.DockerBinary,
|
|
DataDir: file.DataDir,
|
|
MainConfigPath: file.MainConfigPath,
|
|
RouteConfigPath: file.RouteConfigPath,
|
|
CertDir: file.CertDir,
|
|
OpenrestyCertDir: file.OpenrestyCertDir,
|
|
LuaDir: file.LuaDir,
|
|
OpenrestyLuaDir: file.OpenrestyLuaDir,
|
|
OpenrestyObservabilityPort: file.OpenrestyObservabilityPort,
|
|
ObservabilityBufferPath: file.ObservabilityBufferPath,
|
|
ObservabilityReplayMinutes: file.ObservabilityReplayMinutes,
|
|
StatePath: file.StatePath,
|
|
HeartbeatInterval: file.HeartbeatInterval,
|
|
RequestTimeout: file.RequestTimeout,
|
|
}
|
|
cfg.configPath = path
|
|
applyDefaults(cfg, filepath.Dir(path))
|
|
if err = validate(cfg); err != nil {
|
|
return nil, err
|
|
}
|
|
return cfg, nil
|
|
}
|
|
|
|
func applyDefaults(cfg *Config, baseDir string) {
|
|
baseDir = filepath.Clean(baseDir)
|
|
cfg.AgentVersion = AgentVersion
|
|
if cfg.OpenrestyContainerName == "" {
|
|
cfg.OpenrestyContainerName = "openflare-openresty"
|
|
}
|
|
if cfg.OpenrestyDockerImage == "" {
|
|
cfg.OpenrestyDockerImage = "openresty/openresty:alpine"
|
|
}
|
|
if cfg.DockerBinary == "" {
|
|
cfg.DockerBinary = "docker"
|
|
}
|
|
if cfg.DataDir == "" {
|
|
cfg.DataDir = filepath.Join(baseDir, "data")
|
|
}
|
|
if cfg.NodeName == "" {
|
|
cfg.NodeName = detectHostname()
|
|
}
|
|
if cfg.NodeIP == "" {
|
|
cfg.NodeIP = detectNodeIP()
|
|
}
|
|
if cfg.OpenrestyPath == "" {
|
|
cfg.MainConfigPath = joinManagedPath(cfg.DataDir, defaultDockerMainConfigRelativePath)
|
|
cfg.RouteConfigPath = joinManagedPath(cfg.DataDir, defaultDockerRouteConfigRelativePath)
|
|
cfg.StatePath = joinManagedPath(cfg.DataDir, defaultDockerStateRelativePath)
|
|
} else {
|
|
if cfg.MainConfigPath == "" {
|
|
cfg.MainConfigPath = joinManagedPath(cfg.DataDir, defaultDockerMainConfigRelativePath)
|
|
}
|
|
if cfg.RouteConfigPath == "" {
|
|
cfg.RouteConfigPath = joinManagedPath(cfg.DataDir, defaultDockerRouteConfigRelativePath)
|
|
}
|
|
if cfg.StatePath == "" {
|
|
cfg.StatePath = joinManagedPath(cfg.DataDir, defaultDockerStateRelativePath)
|
|
}
|
|
}
|
|
if cfg.CertDir == "" {
|
|
cfg.CertDir = joinManagedPath(cfg.DataDir, defaultCertDirRelativePath)
|
|
}
|
|
if cfg.OpenrestyCertDir == "" {
|
|
if cfg.OpenrestyPath != "" {
|
|
cfg.OpenrestyCertDir = cfg.CertDir
|
|
} else {
|
|
cfg.OpenrestyCertDir = defaultDockerOpenRestyCertDir
|
|
}
|
|
}
|
|
if cfg.LuaDir == "" {
|
|
cfg.LuaDir = joinManagedPath(cfg.DataDir, defaultLuaDirRelativePath)
|
|
}
|
|
if cfg.OpenrestyLuaDir == "" {
|
|
if cfg.OpenrestyPath != "" {
|
|
cfg.OpenrestyLuaDir = cfg.LuaDir
|
|
} else {
|
|
cfg.OpenrestyLuaDir = defaultDockerOpenRestyLuaDir
|
|
}
|
|
}
|
|
if cfg.OpenrestyObservabilityPort <= 0 {
|
|
cfg.OpenrestyObservabilityPort = defaultOpenRestyObservabilityPort
|
|
}
|
|
if cfg.ObservabilityBufferPath == "" {
|
|
cfg.ObservabilityBufferPath = joinManagedPath(cfg.DataDir, defaultObservabilityBufferRelativePath)
|
|
}
|
|
if cfg.ObservabilityReplayMinutes <= 0 {
|
|
cfg.ObservabilityReplayMinutes = defaultObservabilityReplayMinutes
|
|
}
|
|
if cfg.HeartbeatInterval <= 0 {
|
|
cfg.HeartbeatInterval = MillisecondDuration(10 * time.Second)
|
|
}
|
|
if cfg.RequestTimeout <= 0 {
|
|
cfg.RequestTimeout = MillisecondDuration(10 * time.Second)
|
|
}
|
|
normalizeManagedPaths(cfg)
|
|
}
|
|
|
|
func normalizeManagedPaths(cfg *Config) {
|
|
if cfg == nil {
|
|
return
|
|
}
|
|
if usesSlashPath(cfg.DataDir) {
|
|
cfg.DataDir = filepath.ToSlash(cfg.DataDir)
|
|
}
|
|
if usesSlashPath(cfg.MainConfigPath) {
|
|
cfg.MainConfigPath = filepath.ToSlash(cfg.MainConfigPath)
|
|
}
|
|
if usesSlashPath(cfg.RouteConfigPath) {
|
|
cfg.RouteConfigPath = filepath.ToSlash(cfg.RouteConfigPath)
|
|
}
|
|
if usesSlashPath(cfg.CertDir) {
|
|
cfg.CertDir = filepath.ToSlash(cfg.CertDir)
|
|
}
|
|
if usesSlashPath(cfg.OpenrestyCertDir) {
|
|
cfg.OpenrestyCertDir = filepath.ToSlash(cfg.OpenrestyCertDir)
|
|
}
|
|
if usesSlashPath(cfg.LuaDir) {
|
|
cfg.LuaDir = filepath.ToSlash(cfg.LuaDir)
|
|
}
|
|
if usesSlashPath(cfg.OpenrestyLuaDir) {
|
|
cfg.OpenrestyLuaDir = filepath.ToSlash(cfg.OpenrestyLuaDir)
|
|
}
|
|
if usesSlashPath(cfg.StatePath) {
|
|
cfg.StatePath = filepath.ToSlash(cfg.StatePath)
|
|
}
|
|
if usesSlashPath(cfg.ObservabilityBufferPath) {
|
|
cfg.ObservabilityBufferPath = filepath.ToSlash(cfg.ObservabilityBufferPath)
|
|
}
|
|
}
|
|
|
|
func usesSlashPath(path string) bool {
|
|
return strings.HasPrefix(path, "/")
|
|
}
|
|
|
|
func joinManagedPath(base string, relative string) string {
|
|
if usesSlashPath(base) {
|
|
return pathpkg.Join(filepath.ToSlash(base), relative)
|
|
}
|
|
return filepath.Join(base, relative)
|
|
}
|
|
|
|
func validate(cfg *Config) error {
|
|
if cfg.ServerURL == "" {
|
|
return errors.New("server_url 不能为空")
|
|
}
|
|
if strings.TrimSpace(cfg.AgentToken) == "" && strings.TrimSpace(cfg.DiscoveryToken) == "" {
|
|
return errors.New("agent_token 和 discovery_token 不能同时为空")
|
|
}
|
|
if cfg.NodeName == "" {
|
|
return errors.New("node_name 不能为空")
|
|
}
|
|
if cfg.NodeIP == "" {
|
|
return errors.New("node_ip 不能为空")
|
|
}
|
|
if cfg.OpenrestyObservabilityPort <= 0 || cfg.OpenrestyObservabilityPort > 65535 {
|
|
return errors.New("openresty_observability_port 必须在 1-65535 之间")
|
|
}
|
|
if cfg.ObservabilityReplayMinutes <= 0 {
|
|
return errors.New("observability_replay_minutes 必须大于 0")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (cfg *Config) InitialAuthToken() string {
|
|
if cfg == nil {
|
|
return ""
|
|
}
|
|
if token := strings.TrimSpace(cfg.AgentToken); token != "" {
|
|
return token
|
|
}
|
|
return strings.TrimSpace(cfg.DiscoveryToken)
|
|
}
|
|
|
|
func (cfg *Config) Save() error {
|
|
if cfg == nil {
|
|
return errors.New("config 不能为空")
|
|
}
|
|
if cfg.configPath == "" {
|
|
return errors.New("config path 未初始化")
|
|
}
|
|
data, err := json.MarshalIndent(cfg, "", " ")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(cfg.configPath, data, 0o644)
|
|
}
|
|
|
|
func detectHostname() string {
|
|
host, err := os.Hostname()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return strings.TrimSpace(host)
|
|
}
|
|
|
|
func firstNonEmpty(values ...string) string {
|
|
for _, value := range values {
|
|
if strings.TrimSpace(value) != "" {
|
|
return value
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func detectNodeIP() string {
|
|
interfaces, err := net.Interfaces()
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
for _, iface := range interfaces {
|
|
if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 {
|
|
continue
|
|
}
|
|
addrs, err := iface.Addrs()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, addr := range addrs {
|
|
ipNet, ok := addr.(*net.IPNet)
|
|
if !ok || ipNet.IP == nil || ipNet.IP.IsLoopback() {
|
|
continue
|
|
}
|
|
ipv4 := ipNet.IP.To4()
|
|
if ipv4 != nil {
|
|
return ipv4.String()
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|