package config import ( "fmt" "os" "path/filepath" "strings" "gopkg.in/yaml.v3" ) // Persisted is het deel van de machineconfiguratie dat in settings.yml // staat. Pointers onderscheiden "niet gezet" (terugval op config.yml) van // een expliciete waarde, inclusief een lege lijst of false. // state_path hoort hier niet in: die bepaalt waar dit bestand ligt. type Persisted struct { BaseURL *string `yaml:"base_url,omitempty"` Listen *string `yaml:"listen,omitempty"` TrustedProxies *[]string `yaml:"trusted_proxies,omitempty"` Auth *PersistedAuth `yaml:"auth,omitempty"` Git *PersistedGit `yaml:"git,omitempty"` SSH *PersistedSSH `yaml:"ssh,omitempty"` Runner *PersistedRunner `yaml:"runner,omitempty"` CI *PersistedCI `yaml:"ci,omitempty"` } // PersistedAuth is het auth-blok in settings.yml. type PersistedAuth struct { Mode *string `yaml:"mode,omitempty"` BaseURL *string `yaml:"base_url,omitempty"` ClientID *string `yaml:"client_id,omitempty"` ClientSecret *string `yaml:"client_secret,omitempty"` ClientSecretFile *string `yaml:"client_secret_file,omitempty"` RedirectPath *string `yaml:"redirect_path,omitempty"` UserAgent *string `yaml:"user_agent,omitempty"` DevUser *string `yaml:"dev_user,omitempty"` DevAuthID *int64 `yaml:"dev_auth_id,omitempty"` TenantID *string `yaml:"tenant_id,omitempty"` Issuer *string `yaml:"issuer,omitempty"` } // PersistedGit is het git-blok in settings.yml. type PersistedGit struct { Binary *string `yaml:"binary,omitempty"` DefaultBranch *string `yaml:"default_branch,omitempty"` HookBinary *string `yaml:"hook_binary,omitempty"` MaintenanceInterval *string `yaml:"maintenance_interval,omitempty"` } // PersistedSSH is het ssh-blok in settings.yml. type PersistedSSH struct { Enabled *bool `yaml:"enabled,omitempty"` Listen *string `yaml:"listen,omitempty"` PublicHost *string `yaml:"public_host,omitempty"` PublicPort *int `yaml:"public_port,omitempty"` } // PersistedRunner is het runner-blok in settings.yml. type PersistedRunner struct { Name *string `yaml:"name,omitempty"` } // PersistedCI is het ci-blok in settings.yml. Presets blijven in // config.yml / de runner-UI (runner-settings.json); die zitten hier // expres niet, om geen tweede bron te maken. type PersistedCI struct { Enabled *bool `yaml:"enabled,omitempty"` Docker *string `yaml:"docker_binary,omitempty"` Concurrency *int `yaml:"concurrency,omitempty"` Network *string `yaml:"network,omitempty"` TimeoutSec *int `yaml:"timeout_seconds,omitempty"` UpdateMaxWaitMin *int `yaml:"update_max_wait_minutes,omitempty"` } // LoadSettings leest settings.yml. (nil, nil) als het bestand er niet is. func LoadSettings(statePath string) (*Persisted, error) { path := filepath.Join(statePath, SettingsFile) b, err := os.ReadFile(path) if err != nil { if os.IsNotExist(err) { return nil, nil } return nil, err } var p Persisted if err := yaml.Unmarshal(b, &p); err != nil { return nil, fmt.Errorf("%s: %w", path, err) } return &p, nil } // SaveSettings schrijft settings.yml atomair met mode 0600. func SaveSettings(statePath string, p Persisted) error { b, err := yaml.Marshal(p) if err != nil { return err } return atomicWrite(filepath.Join(statePath, SettingsFile), b, 0o600) } func ptr[T any](v T) *T { return &v } // SettingsFrom maakt de opgeslagen vorm van de huidige configuratie. func SettingsFrom(c Config) Persisted { return persistFrom(c) } func persistFrom(c Config) Persisted { proxies := append([]string(nil), c.TrustedProxies...) auth := PersistedAuth{ Mode: ptr(c.Auth.Mode), BaseURL: ptr(c.Auth.BaseURL), ClientID: ptr(c.Auth.ClientID), RedirectPath: ptr(c.Auth.RedirectPath), UserAgent: ptr(c.Auth.UserAgent), DevUser: ptr(c.Auth.DevUser), DevAuthID: ptr(c.Auth.DevAuthID), TenantID: ptr(c.Auth.TenantID), Issuer: ptr(c.Auth.Issuer), ClientSecretFile: ptr(c.Auth.ClientSecretFile), } if strings.TrimSpace(c.Auth.ClientSecret) != "" { auth.ClientSecret = ptr(c.Auth.ClientSecret) } return Persisted{ BaseURL: ptr(c.BaseURL), Listen: ptr(c.Listen), TrustedProxies: &proxies, Auth: &auth, Git: &PersistedGit{ Binary: ptr(c.Git.Binary), DefaultBranch: ptr(c.Git.DefaultBranch), HookBinary: ptr(c.Git.HookBinary), MaintenanceInterval: ptr(c.Git.MaintenanceInterval), }, SSH: &PersistedSSH{ Enabled: ptr(c.SSH.Enabled), Listen: ptr(c.SSH.Listen), PublicHost: ptr(c.SSH.PublicHost), PublicPort: ptr(c.SSH.PublicPort), }, Runner: &PersistedRunner{Name: ptr(c.Runner.Name)}, CI: &PersistedCI{ Enabled: ptr(c.CI.Enabled), Docker: ptr(c.CI.Docker), Concurrency: ptr(c.CI.Concurrency), Network: ptr(c.CI.Network), TimeoutSec: ptr(c.CI.TimeoutSec), UpdateMaxWaitMin: ptr(c.CI.UpdateMaxWaitMin), }, } } func applyPersisted(c *Config, p *Persisted) { if p == nil { return } if p.BaseURL != nil { c.BaseURL = strings.TrimRight(*p.BaseURL, "/") } if p.Listen != nil { c.Listen = *p.Listen } if p.TrustedProxies != nil { c.TrustedProxies = append([]string(nil), *p.TrustedProxies...) } if a := p.Auth; a != nil { if a.Mode != nil { c.Auth.Mode = *a.Mode } if a.BaseURL != nil { c.Auth.BaseURL = strings.TrimRight(*a.BaseURL, "/") } if a.ClientID != nil { c.Auth.ClientID = *a.ClientID } if a.ClientSecret != nil && strings.TrimSpace(*a.ClientSecret) != "" { c.Auth.ClientSecret = *a.ClientSecret } if a.ClientSecretFile != nil { c.Auth.ClientSecretFile = *a.ClientSecretFile } if a.RedirectPath != nil { c.Auth.RedirectPath = *a.RedirectPath } if a.UserAgent != nil { c.Auth.UserAgent = *a.UserAgent } if a.DevUser != nil { c.Auth.DevUser = *a.DevUser } if a.DevAuthID != nil { c.Auth.DevAuthID = *a.DevAuthID } if a.TenantID != nil { c.Auth.TenantID = strings.TrimSpace(*a.TenantID) } if a.Issuer != nil { c.Auth.Issuer = strings.TrimRight(strings.TrimSpace(*a.Issuer), "/") } } if g := p.Git; g != nil { if g.Binary != nil { c.Git.Binary = *g.Binary } if g.DefaultBranch != nil { c.Git.DefaultBranch = *g.DefaultBranch } if g.HookBinary != nil { c.Git.HookBinary = *g.HookBinary } if g.MaintenanceInterval != nil { c.Git.MaintenanceInterval = *g.MaintenanceInterval } } if s := p.SSH; s != nil { if s.Enabled != nil { c.SSH.Enabled = *s.Enabled } if s.Listen != nil { c.SSH.Listen = *s.Listen } if s.PublicHost != nil { c.SSH.PublicHost = *s.PublicHost } if s.PublicPort != nil { c.SSH.PublicPort = *s.PublicPort } } if r := p.Runner; r != nil && r.Name != nil { c.Runner.Name = strings.TrimSpace(*r.Name) } if ci := p.CI; ci != nil { if ci.Enabled != nil { c.CI.Enabled = *ci.Enabled } if ci.Docker != nil { c.CI.Docker = *ci.Docker } if ci.Concurrency != nil { c.CI.Concurrency = *ci.Concurrency } if ci.Network != nil { c.CI.Network = *ci.Network } if ci.TimeoutSec != nil { c.CI.TimeoutSec = *ci.TimeoutSec } if ci.UpdateMaxWaitMin != nil { c.CI.UpdateMaxWaitMin = *ci.UpdateMaxWaitMin } } } // MergeUpdate past een wijziging uit de UI/API toe op de huidige config // en bouwt de nieuwe Persisted-staat (leeg gelaten geheim blijft behouden). func MergeUpdate(cur Config, patch Persisted) (Config, Persisted) { next := cur // Een leeg nieuw geheim betekent "ongewijzigd". if patch.Auth != nil && patch.Auth.ClientSecret != nil && strings.TrimSpace(*patch.Auth.ClientSecret) == "" { patch.Auth.ClientSecret = nil } applyPersisted(&next, &patch) next.applyDefaults() saved := persistFrom(next) return next, saved }