| 1 | package main |
| 2 | |
| 3 | import ( |
| 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 | |
| 15 | func 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 | |
| 129 | func 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 | |
| 139 | func (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 | |
| 153 | func (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 | |
| 161 | func (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 | |
| 182 | var 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 | |
| 213 | func 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 | |
| 225 | func 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 | |
| 248 | func fmtRegister(code int, msg string) error { |
| 249 | if msg == "" { |
| 250 | msg = http.StatusText(code) |
| 251 | } |
| 252 | return ®Error{code: code, msg: msg} |
| 253 | } |
| 254 | |
| 255 | type regError struct { |
| 256 | code int |
| 257 | msg string |
| 258 | } |
| 259 | |
| 260 | func (e *regError) Error() string { return e.msg } |