BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-runner / runtime.go

runtime.go

runtime.go 4.5 KiB Download Raw
1package main
2
3import (
4 "fmt"
5 "io"
6 "log/slog"
7 "os"
8 "path/filepath"
9 "strings"
10
11 "gopkg.in/yaml.v3"
12
13 "gitlab.com/Timfa/bluegit/internal/apppaths"
14)
15
16const (
17 connectionFile = "connection.yml"
18 connectionMark = "config.yml.imported"
19 defaultWorkDir = "/var/lib/bluegit-runner"
20 defaultWindows = "BlueGit-runner"
21)
22
23// machineSettings is het deel van de runnerconfig dat in de webinterface hoort.
24type machineSettings struct {
25 URL string `yaml:"url,omitempty"`
26 Token string `yaml:"token,omitempty"`
27 Name string `yaml:"name,omitempty"`
28 Docker string `yaml:"docker,omitempty"`
29 Git string `yaml:"git,omitempty"`
30 Network string `yaml:"network,omitempty"`
31 Concurrency int `yaml:"concurrency,omitempty"`
32 UIListen string `yaml:"ui_listen,omitempty"`
33 Language string `yaml:"language,omitempty"`
34}
35
36func defaultWorkDirPath() string {
37 return apppaths.DataDir(defaultWorkDir, defaultWindows)
38}
39
40func resolveWorkDir(flagDir, cfgPath string, file Config) string {
41 if d := strings.TrimSpace(flagDir); d != "" {
42 return d
43 }
44 if d := strings.TrimSpace(os.Getenv("BLUEGIT_RUNNER_WORK_DIR")); d != "" {
45 return d
46 }
47 if d := strings.TrimSpace(file.WorkDir); d != "" {
48 return d
49 }
50 return defaultWorkDirPath()
51}
52
53func loadFileConfig(path string) (Config, error) {
54 var c Config
55 b, err := os.ReadFile(path)
56 if err != nil {
57 if os.IsNotExist(err) {
58 return c, nil
59 }
60 return c, err
61 }
62 if err := yaml.Unmarshal(b, &c); err != nil {
63 return c, err
64 }
65 return c, nil
66}
67
68func loadConnection(workDir string) (machineSettings, error) {
69 var m machineSettings
70 b, err := os.ReadFile(filepath.Join(workDir, connectionFile))
71 if err != nil {
72 if os.IsNotExist(err) {
73 return m, nil
74 }
75 return m, err
76 }
77 err = yaml.Unmarshal(b, &m)
78 return m, err
79}
80
81func saveConnection(workDir string, m machineSettings) error {
82 if err := os.MkdirAll(workDir, 0o750); err != nil {
83 return err
84 }
85 b, err := yaml.Marshal(m)
86 if err != nil {
87 return err
88 }
89 path := filepath.Join(workDir, connectionFile)
90 tmp := path + ".tmp"
91 if err := os.WriteFile(tmp, b, 0o600); err != nil {
92 return err
93 }
94 return os.Rename(tmp, path)
95}
96
97func applyMachine(c *Config, m machineSettings) {
98 if m.URL != "" {
99 c.URL = strings.TrimRight(m.URL, "/")
100 }
101 if m.Token != "" {
102 c.Token = m.Token
103 }
104 if m.Name != "" {
105 c.Name = m.Name
106 }
107 if m.Docker != "" {
108 c.Docker = m.Docker
109 }
110 if m.Git != "" {
111 c.Git = m.Git
112 }
113 if m.Network != "" {
114 c.Network = m.Network
115 }
116 if m.Concurrency > 0 {
117 c.Concurrency = m.Concurrency
118 }
119 if m.UIListen != "" {
120 c.UIListen = m.UIListen
121 }
122 if m.Language != "" {
123 c.Language = m.Language
124 }
125}
126
127func machineFrom(c Config) machineSettings {
128 return machineSettings{
129 URL: c.URL, Token: c.Token, Name: c.Name, Docker: c.Docker, Git: c.Git,
130 Network: c.Network, Concurrency: c.Concurrency, UIListen: c.UIListen, Language: c.Language,
131 }
132}
133
134func importRunnerLegacy(workDir, cfgPath string, file Config, log *slog.Logger) {
135 if workDir == "" {
136 return
137 }
138 _ = os.MkdirAll(workDir, 0o750)
139 set := filepath.Join(workDir, connectionFile)
140 mark := filepath.Join(workDir, connectionMark)
141 if _, err := os.Stat(set); err == nil {
142 _ = os.WriteFile(mark, nil, 0o640)
143 return
144 }
145 if _, err := os.Stat(mark); err == nil {
146 return
147 }
148 if cfgPath == "" {
149 return
150 }
151 if _, err := os.Stat(cfgPath); err != nil {
152 return
153 }
154 if err := saveConnection(workDir, machineFrom(file)); err != nil {
155 if log != nil {
156 log.Error("config.yml-import naar connection.yml mislukt; bestaande config blijft gelden", "err", err)
157 }
158 return
159 }
160 _ = os.WriteFile(mark, nil, 0o640)
161 if log != nil {
162 log.Info("config.yml eenmalig overgenomen in connection.yml; daarna wint de webinterface", "config", cfgPath, "settings", set)
163 }
164}
165
166// loadRuntime leest optioneel config.yml, importeert eenmaal, en overlays
167// connection.yml. url en token mogen leeg zijn (registratie via de UI).
168func loadRuntime(cfgPath, workDirFlag string, log *slog.Logger) (Config, error) {
169 if log == nil {
170 log = slog.New(slog.NewTextHandler(io.Discard, nil))
171 }
172 file, err := loadFileConfig(cfgPath)
173 if err != nil {
174 return Config{}, fmt.Errorf("config: %w", err)
175 }
176 work := resolveWorkDir(workDirFlag, cfgPath, file)
177 importRunnerLegacy(work, cfgPath, file, log)
178 c := file
179 c.WorkDir = work
180 if m, err := loadConnection(work); err != nil {
181 log.Error("connection.yml onleesbaar; val terug op config.yml", "err", err)
182 } else {
183 applyMachine(&c, m)
184 }
185 c.WorkDir = work
186 c.defaults()
187 return c, nil
188}
189
190func registered(c Config) bool {
191 return strings.TrimSpace(c.URL) != "" && strings.TrimSpace(c.Token) != ""
192}