BlueGit

timfa bluegit

Files

bluegit / cmd / bluegit-runner / connect.go

connect.go

connect.go 9.1 KiB Download Raw
1package main
2
3import (
4 "bytes"
5 "crypto/hmac"
6 "encoding/json"
7 "html/template"
8 "net/http"
9 "os"
10 "strings"
11
12 "gitlab.com/Timfa/bluegit/internal/i18n"
13)
14
15func mountConnect(u *webUI, c *client, relisten func(string) error) {
16 h := u.h
17 h.ExtraTop = func(r *http.Request) template.HTML { return u.connectHTML(r, c) }
18 u.mux.HandleFunc("POST /connect", u.guardWrite(func(w http.ResponseWriter, r *http.Request) {
19 _ = r.ParseForm()
20 cur := c.snapshot()
21 m := machineFrom(cur)
22 if v := strings.TrimSpace(r.FormValue("url")); v != "" {
23 m.URL = strings.TrimRight(v, "/")
24 }
25 if v := strings.TrimSpace(r.FormValue("name")); v != "" {
26 m.Name = v
27 }
28 if v := strings.TrimSpace(r.FormValue("docker")); v != "" {
29 m.Docker = v
30 }
31 if v := strings.TrimSpace(r.FormValue("git")); v != "" {
32 m.Git = v
33 }
34 if v := strings.TrimSpace(r.FormValue("network")); v != "" {
35 m.Network = v
36 }
37 if v := strings.TrimSpace(r.FormValue("ui_listen")); v != "" {
38 m.UIListen = v
39 }
40 if v := strings.TrimSpace(r.FormValue("language")); v != "" {
41 m.Language = v
42 }
43 oldListen := cur.UIListen
44 if err := c.setMachine(m); err != nil {
45 http.Redirect(w, r, "/?err=rui.connect.err.save", http.StatusSeeOther)
46 return
47 }
48 if m.UIListen != "" && m.UIListen != oldListen && m.UIListen != "off" && relisten != nil {
49 if err := relisten(m.UIListen); err != nil {
50 http.Redirect(w, r, "/?err=rui.connect.err.listen", http.StatusSeeOther)
51 return
52 }
53 }
54 http.Redirect(w, r, "/?ok=rui.connect.ok", http.StatusSeeOther)
55 }))
56 u.mux.HandleFunc("POST /register", u.guardWrite(func(w http.ResponseWriter, r *http.Request) {
57 _ = r.ParseForm()
58 url := strings.TrimRight(strings.TrimSpace(r.FormValue("url")), "/")
59 tok := strings.TrimSpace(r.FormValue("registration_token"))
60 name := strings.TrimSpace(r.FormValue("name"))
61 if url == "" || tok == "" {
62 http.Redirect(w, r, "/?err=rui.connect.err.register", http.StatusSeeOther)
63 return
64 }
65 if err := registerAndSave(c, url, tok, name); err != nil {
66 http.Redirect(w, r, "/?err=rui.connect.err.register", http.StatusSeeOther)
67 return
68 }
69 http.Redirect(w, r, "/?ok=rui.connect.registered", http.StatusSeeOther)
70 }))
71 u.mux.HandleFunc("GET /api/connection", func(w http.ResponseWriter, r *http.Request) {
72 if !u.authed(r) {
73 http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
74 return
75 }
76 writeConnJSON(w, c.snapshot())
77 })
78 u.mux.HandleFunc("PUT /api/connection", func(w http.ResponseWriter, r *http.Request) {
79 if !u.authed(r) {
80 http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
81 return
82 }
83 var in machineSettings
84 if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
85 http.Error(w, `{"error":"bad json"}`, http.StatusBadRequest)
86 return
87 }
88 // Leeg token = ongewijzigd.
89 if strings.TrimSpace(in.Token) == "" {
90 in.Token = c.snapshot().Token
91 }
92 old := c.snapshot().UIListen
93 if err := c.setMachine(in); err != nil {
94 http.Error(w, `{"error":"save"}`, http.StatusInternalServerError)
95 return
96 }
97 if in.UIListen != "" && in.UIListen != old && in.UIListen != "off" && relisten != nil {
98 if err := relisten(in.UIListen); err != nil {
99 http.Error(w, `{"error":"listen"}`, http.StatusBadRequest)
100 return
101 }
102 }
103 writeConnJSON(w, c.snapshot())
104 })
105 u.mux.HandleFunc("POST /api/register", func(w http.ResponseWriter, r *http.Request) {
106 if !u.authed(r) {
107 http.Error(w, `{"error":"unauthorized"}`, http.StatusUnauthorized)
108 return
109 }
110 var in struct {
111 URL string `json:"url"`
112 Token string `json:"token"`
113 Name string `json:"name"`
114 }
115 if err := json.NewDecoder(r.Body).Decode(&in); err != nil || strings.TrimSpace(in.URL) == "" || strings.TrimSpace(in.Token) == "" {
116 http.Error(w, `{"error":"url and token are required"}`, http.StatusBadRequest)
117 return
118 }
119 if err := registerAndSave(c, strings.TrimRight(strings.TrimSpace(in.URL), "/"), strings.TrimSpace(in.Token), strings.TrimSpace(in.Name)); err != nil {
120 w.Header().Set("Content-Type", "application/json")
121 w.WriteHeader(http.StatusBadRequest)
122 _ = json.NewEncoder(w).Encode(map[string]string{"error": err.Error()})
123 return
124 }
125 writeConnJSON(w, c.snapshot())
126 })
127}
128
129func writeConnJSON(w http.ResponseWriter, cfg Config) {
130 w.Header().Set("Content-Type", "application/json")
131 _ = json.NewEncoder(w).Encode(map[string]any{
132 "url": cfg.URL, "name": cfg.Name, "docker": cfg.Docker, "git": cfg.Git,
133 "network": cfg.Network, "concurrency": cfg.Concurrency, "ui_listen": cfg.UIListen,
134 "language": cfg.Language, "work_dir": cfg.WorkDir, "token_set": strings.TrimSpace(cfg.Token) != "",
135 "registered": registered(cfg),
136 })
137}
138
139func (u *webUI) guardWrite(fn http.HandlerFunc) http.HandlerFunc {
140 return func(w http.ResponseWriter, r *http.Request) {
141 if !u.authed(r) {
142 http.Redirect(w, r, "/login", http.StatusSeeOther)
143 return
144 }
145 if !u.csrfOK(r) {
146 http.Error(w, "csrf", http.StatusForbidden)
147 return
148 }
149 fn(w, r)
150 }
151}
152
153func (u *webUI) csrfOK(r *http.Request) bool {
154 if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer ") {
155 return true
156 }
157 _ = r.ParseForm()
158 return hmac.Equal([]byte(r.FormValue("csrf")), []byte(u.mac("csrf")))
159}
160
161func (u *webUI) connectHTML(r *http.Request, c *client) template.HTML {
162 lang := u.lang(r)
163 cfg := c.snapshot()
164 csrf := u.mac("csrf")
165 var b bytes.Buffer
166 _ = connectTmpl.Execute(&b, map[string]any{
167 "T": func(k string, a ...any) string { return i18n.T(lang, k, a...) },
168 "CSRF": csrf,
169 "URL": cfg.URL,
170 "Name": cfg.Name,
171 "Docker": cfg.Docker,
172 "Git": cfg.Git,
173 "Network": cfg.Network,
174 "UIListen": cfg.UIListen,
175 "Language": cfg.Language,
176 "WorkDir": cfg.WorkDir,
177 "Registered": registered(cfg),
178 })
179 return template.HTML(b.String())
180}
181
182var connectTmpl = template.Must(template.New("connect").Parse(`
183<section class="panel" id="connect">
184 <h2>{{call .T "rui.connect.title"}}</h2>
185 <p class="muted">{{call .T "rui.connect.lead"}}</p>
186 {{if not .Registered}}
187 <form method="post" action="/register" class="rui-form">
188 <input type="hidden" name="csrf" value="{{.CSRF}}">
189 <label><span class="rui-lbl">{{call .T "rui.connect.url"}}</span><input name="url" value="{{.URL}}" placeholder="https://git.example.com" required></label>
190 <label><span class="rui-lbl">{{call .T "rui.connect.regToken"}}</span><input name="registration_token" type="password" autocomplete="off" required></label>
191 <label><span class="rui-lbl">{{call .T "rui.connect.name"}}</span><input name="name" value="{{.Name}}"></label>
192 <button type="submit">{{call .T "rui.connect.register"}}</button>
193 </form>
194 {{else}}
195 <p class="rui-safe ok">✓ {{call .T "rui.connect.linked"}}</p>
196 {{end}}
197 <form method="post" action="/connect" class="rui-form">
198 <input type="hidden" name="csrf" value="{{.CSRF}}">
199 <label><span class="rui-lbl">{{call .T "rui.connect.url"}}</span><input name="url" value="{{.URL}}" placeholder="https://git.example.com"></label>
200 <label><span class="rui-lbl">{{call .T "rui.connect.name"}}</span><input name="name" value="{{.Name}}"></label>
201 <label><span class="rui-lbl">{{call .T "rui.connect.docker"}}</span><input name="docker" value="{{.Docker}}"></label>
202 <label><span class="rui-lbl">{{call .T "rui.connect.git"}}</span><input name="git" value="{{.Git}}"></label>
203 <label><span class="rui-lbl">{{call .T "rui.connect.network"}}</span><input name="network" value="{{.Network}}"></label>
204 <label><span class="rui-lbl">{{call .T "rui.connect.uiListen"}}</span><input name="ui_listen" value="{{.UIListen}}"></label>
205 <label><span class="rui-lbl">{{call .T "rui.connect.language"}}</span><input name="language" value="{{.Language}}" placeholder="en"></label>
206 <label><span class="rui-lbl">{{call .T "rui.connect.workDir"}}</span><input value="{{.WorkDir}}" readonly></label>
207 <p class="muted">{{call .T "rui.connect.workDirWhy"}}</p>
208 <button type="submit">{{call .T "action.save"}}</button>
209 </form>
210</section>
211`))
212
213func registerAndSave(c *client, url, token, name string) error {
214 cur := c.snapshot()
215 id, outName, runnerTok, err := postRegister(url, token, name, version)
216 if err != nil {
217 return err
218 }
219 _ = id
220 m := machineFrom(cur)
221 m.URL, m.Token, m.Name = url, runnerTok, outName
222 return c.setMachine(m)
223}
224
225func postRegister(baseURL, token, name, ver string) (id int64, outName, runnerTok string, err error) {
226 if name == "" {
227 name, _ = os.Hostname()
228 }
229 body, _ := json.Marshal(map[string]string{"token": token, "name": name, "version": ver})
230 resp, err := http.Post(strings.TrimRight(baseURL, "/")+"/api/v1/runners/register", "application/json", bytes.NewReader(body))
231 if err != nil {
232 return 0, "", "", err
233 }
234 defer resp.Body.Close()
235 var out struct {
236 ID int64 `json:"id"`
237 Name string `json:"name"`
238 Token string `json:"token"`
239 Message string `json:"message"`
240 }
241 _ = json.NewDecoder(resp.Body).Decode(&out)
242 if resp.StatusCode != http.StatusCreated || out.Token == "" {
243 return 0, "", "", fmtRegister(resp.StatusCode, out.Message)
244 }
245 return out.ID, out.Name, out.Token, nil
246}
247
248func fmtRegister(code int, msg string) error {
249 if msg == "" {
250 msg = http.StatusText(code)
251 }
252 return &regError{code: code, msg: msg}
253}
254
255type regError struct {
256 code int
257 msg string
258}
259
260func (e *regError) Error() string { return e.msg }