157 lines
3.9 KiB
Go
157 lines
3.9 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"time"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
const (
|
|
DefaultConfigPath = "/etc/media-node/config.yaml"
|
|
DefaultDataDir = "/var/lib/media-node"
|
|
DefaultCredentialsPath = "/etc/media-node/credentials/credentials.json"
|
|
DefaultListen = "0.0.0.0:8080"
|
|
)
|
|
|
|
type Config struct {
|
|
Node NodeConfig `yaml:"node"`
|
|
Master MasterConfig `yaml:"master"`
|
|
Stream StreamConfig `yaml:"stream"`
|
|
Media MediaConfig `yaml:"media"`
|
|
Scanner ScannerConfig `yaml:"scanner"`
|
|
Security SecurityConfig `yaml:"security"`
|
|
}
|
|
|
|
type NodeConfig struct {
|
|
ID string `yaml:"id"`
|
|
Name string `yaml:"name"`
|
|
}
|
|
|
|
type MasterConfig struct {
|
|
URL string `yaml:"url"`
|
|
}
|
|
|
|
type StreamConfig struct {
|
|
Listen string `yaml:"listen"`
|
|
PublicURL string `yaml:"public_url"`
|
|
}
|
|
|
|
type MediaConfig struct {
|
|
Movies []string `yaml:"movies"`
|
|
Series []string `yaml:"series"`
|
|
}
|
|
|
|
type ScannerConfig struct {
|
|
FullScanInterval string `yaml:"full_scan_interval"`
|
|
}
|
|
|
|
type SecurityConfig struct {
|
|
SessionIdleTimeout string `yaml:"session_idle_timeout"`
|
|
MaxConcurrentPerIP int `yaml:"max_concurrent_per_ip"`
|
|
}
|
|
|
|
type Credentials struct {
|
|
NodeID string `json:"nodeId"`
|
|
APIKey string `json:"apiKey"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
func Load(path string) (*Config, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
if os.IsNotExist(err) {
|
|
cfg, envErr := FromEnv()
|
|
if envErr != nil {
|
|
return nil, fmt.Errorf("read config: %w (and env incomplete: %v)", err, envErr)
|
|
}
|
|
if saveErr := Save(path, cfg); saveErr != nil {
|
|
// Still usable in-memory when the path is not writable.
|
|
return applyDefaults(cfg), nil
|
|
}
|
|
return applyDefaults(cfg), nil
|
|
}
|
|
return nil, fmt.Errorf("read config: %w", err)
|
|
}
|
|
var cfg Config
|
|
if err := yaml.Unmarshal(data, &cfg); err != nil {
|
|
return nil, fmt.Errorf("parse config: %w", err)
|
|
}
|
|
return applyDefaults(&cfg), nil
|
|
}
|
|
|
|
// FromEnv builds config from MEDIA_NODE_* environment variables (Docker/Unraid).
|
|
func FromEnv() (*Config, error) {
|
|
name := strings.TrimSpace(os.Getenv("MEDIA_NODE_NAME"))
|
|
master := strings.TrimRight(strings.TrimSpace(os.Getenv("MEDIA_NODE_MASTER_URL")), "/")
|
|
publicURL := strings.TrimRight(strings.TrimSpace(os.Getenv("MEDIA_NODE_PUBLIC_URL")), "/")
|
|
if name == "" || master == "" || publicURL == "" {
|
|
return nil, fmt.Errorf("MEDIA_NODE_NAME, MEDIA_NODE_MASTER_URL and MEDIA_NODE_PUBLIC_URL are required")
|
|
}
|
|
listen := strings.TrimSpace(os.Getenv("MEDIA_NODE_LISTEN"))
|
|
if listen == "" {
|
|
listen = DefaultListen
|
|
}
|
|
return &Config{
|
|
Node: NodeConfig{Name: name},
|
|
Master: MasterConfig{URL: master},
|
|
Stream: StreamConfig{Listen: listen, PublicURL: publicURL},
|
|
Media: MediaConfig{
|
|
Movies: splitPaths(os.Getenv("MEDIA_NODE_MOVIES")),
|
|
Series: splitPaths(os.Getenv("MEDIA_NODE_SERIES")),
|
|
},
|
|
Scanner: ScannerConfig{FullScanInterval: "6h"},
|
|
Security: SecurityConfig{SessionIdleTimeout: "20m", MaxConcurrentPerIP: 8},
|
|
}, nil
|
|
}
|
|
|
|
func applyDefaults(cfg *Config) *Config {
|
|
if cfg.Stream.Listen == "" {
|
|
cfg.Stream.Listen = DefaultListen
|
|
}
|
|
if cfg.Scanner.FullScanInterval == "" {
|
|
cfg.Scanner.FullScanInterval = "6h"
|
|
}
|
|
if cfg.Security.SessionIdleTimeout == "" {
|
|
cfg.Security.SessionIdleTimeout = "20m"
|
|
}
|
|
if cfg.Security.MaxConcurrentPerIP == 0 {
|
|
cfg.Security.MaxConcurrentPerIP = 8
|
|
}
|
|
return cfg
|
|
}
|
|
|
|
func splitPaths(raw string) []string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return nil
|
|
}
|
|
var out []string
|
|
for _, part := range strings.FieldsFunc(raw, func(r rune) bool {
|
|
return r == ',' || r == ';' || r == '\n'
|
|
}) {
|
|
p := strings.TrimSpace(part)
|
|
if p != "" {
|
|
out = append(out, p)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (c *Config) FullScanDuration() time.Duration {
|
|
d, err := time.ParseDuration(c.Scanner.FullScanInterval)
|
|
if err != nil {
|
|
return 6 * time.Hour
|
|
}
|
|
return d
|
|
}
|
|
|
|
func Save(path string, cfg *Config) error {
|
|
data, err := yaml.Marshal(cfg)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(path, data, 0o600)
|
|
}
|