feat: add backend, admin console and live monitoring
Integrate tunasync management, SQLite authentication and content settings, real monitoring and per-repository pull speeds. Add Chinese-only announcements and mirror help, editable related links, admin layout updates, deployment tools and tests.
This commit is contained in:
@@ -0,0 +1,518 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"net"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/BurntSushi/toml"
|
||||
)
|
||||
|
||||
type ConfigNumbers struct {
|
||||
Concurrent int `json:"concurrent"`
|
||||
Interval int `json:"interval"`
|
||||
Retry int `json:"retry"`
|
||||
Timeout int `json:"timeout"`
|
||||
}
|
||||
type ConfigMirror struct {
|
||||
Name string `json:"name"`
|
||||
Provider string `json:"provider"`
|
||||
Upstream string `json:"upstream"`
|
||||
Interval int `json:"interval"`
|
||||
Retry int `json:"retry"`
|
||||
Timeout int `json:"timeout"`
|
||||
Source string `json:"source,omitempty"`
|
||||
}
|
||||
type configFile struct {
|
||||
raw string
|
||||
doc map[string]any
|
||||
}
|
||||
type loadedConfig struct {
|
||||
files map[string]configFile
|
||||
mirrors []ConfigMirror
|
||||
global ConfigNumbers
|
||||
hash string
|
||||
includeDir string
|
||||
}
|
||||
type fileChange struct {
|
||||
Before *string `json:"before"`
|
||||
After *string `json:"after"`
|
||||
}
|
||||
type configDraft struct {
|
||||
ID string `json:"id"`
|
||||
Files map[string]fileChange `json:"files"`
|
||||
BaseHash string `json:"baseHash"`
|
||||
Status string `json:"status"`
|
||||
Created int64 `json:"created"`
|
||||
Username string `json:"username"`
|
||||
}
|
||||
|
||||
func asMap(value any) map[string]any {
|
||||
if m, ok := value.(map[string]any); ok {
|
||||
return m
|
||||
}
|
||||
return map[string]any{}
|
||||
}
|
||||
func asTables(value any) []map[string]any {
|
||||
switch v := value.(type) {
|
||||
case []map[string]any:
|
||||
return v
|
||||
case []any:
|
||||
out := []map[string]any{}
|
||||
for _, entry := range v {
|
||||
out = append(out, asMap(entry))
|
||||
}
|
||||
return out
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func integer(value any, fallback int) int {
|
||||
switch n := value.(type) {
|
||||
case int64:
|
||||
return int(n)
|
||||
case int:
|
||||
return n
|
||||
case float64:
|
||||
return int(n)
|
||||
}
|
||||
return fallback
|
||||
}
|
||||
func text(value any) string { s, _ := value.(string); return s }
|
||||
func (a *App) loadConfig() (loadedConfig, error) {
|
||||
c := loadedConfig{files: map[string]configFile{}, mirrors: []ConfigMirror{}}
|
||||
if a.cfg.WorkerConfig == "" {
|
||||
return c, errors.New("CONFIG_UNAVAILABLE")
|
||||
}
|
||||
read := func(path string) error {
|
||||
raw, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
var doc map[string]any
|
||||
if _, err = toml.Decode(string(raw), &doc); err != nil {
|
||||
return err
|
||||
}
|
||||
c.files[path] = configFile{string(raw), doc}
|
||||
return nil
|
||||
}
|
||||
if err := read(a.cfg.WorkerConfig); err != nil {
|
||||
return c, err
|
||||
}
|
||||
main := c.files[a.cfg.WorkerConfig].doc
|
||||
g := asMap(main["global"])
|
||||
c.global = ConfigNumbers{integer(g["concurrent"], 1), integer(g["interval"], 1440), integer(g["retry"], 0), integer(g["timeout"], 86400)}
|
||||
pattern := text(asMap(main["include"])["include_mirrors"])
|
||||
if pattern != "" {
|
||||
paths, err := filepath.Glob(pattern)
|
||||
if err != nil {
|
||||
return c, err
|
||||
}
|
||||
for _, path := range paths {
|
||||
if err = read(path); err != nil {
|
||||
return c, err
|
||||
}
|
||||
}
|
||||
if filepath.Base(pattern) == "*.conf" {
|
||||
c.includeDir = filepath.Dir(pattern)
|
||||
}
|
||||
}
|
||||
seen := map[string]bool{}
|
||||
var signature strings.Builder
|
||||
for _, path := range sortedKeys(c.files) {
|
||||
f := c.files[path]
|
||||
fmt.Fprintf(&signature, "%d:%s%d:%s", len(path), path, len(f.raw), f.raw)
|
||||
for _, m := range asTables(f.doc["mirrors"]) {
|
||||
name := text(m["name"])
|
||||
if !validName(name) || seen[name] {
|
||||
return c, errors.New("invalid or duplicate mirror name")
|
||||
}
|
||||
seen[name] = true
|
||||
c.mirrors = append(c.mirrors, ConfigMirror{name, text(m["provider"]), text(m["upstream"]), integer(m["interval"], c.global.Interval), integer(m["retry"], c.global.Retry), integer(m["timeout"], c.global.Timeout), path})
|
||||
}
|
||||
}
|
||||
c.hash = tokenHash(signature.String())
|
||||
return c, nil
|
||||
}
|
||||
func (a *App) configView(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := a.require(w, r, true); !ok {
|
||||
return
|
||||
}
|
||||
a.configMu.Lock()
|
||||
defer a.configMu.Unlock()
|
||||
c, err := a.loadConfig()
|
||||
if err != nil {
|
||||
a.logger.Printf("read config: %v", err)
|
||||
fail(w, 503, "CONFIG_UNAVAILABLE")
|
||||
return
|
||||
}
|
||||
respond(w, 200, map[string]any{"worker": a.cfg.Worker, "baseHash": c.hash, "global": c.global, "mirrors": c.mirrors, "canAdd": c.includeDir != ""})
|
||||
}
|
||||
func validNumbers(interval, retry, timeout int) bool {
|
||||
return interval >= 1 && interval <= 525600 && retry >= 0 && retry <= 20 && timeout >= 30 && timeout <= 1209600
|
||||
}
|
||||
func validUpstream(value string) bool {
|
||||
u, err := url.Parse(value)
|
||||
return err == nil && (u.Scheme == "rsync" || u.Scheme == "https" || u.Scheme == "http") && u.Host != "" && u.User == nil && !strings.ContainsAny(value, "\r\n\t `;$|<>\\\"'") && len(value) < 2048
|
||||
}
|
||||
func (a *App) configPreview(w http.ResponseWriter, r *http.Request) {
|
||||
s, ok := a.require(w, r, true)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
BaseHash string `json:"baseHash"`
|
||||
Global *ConfigNumbers `json:"global"`
|
||||
Mirror *ConfigMirror `json:"mirror"`
|
||||
}
|
||||
if !readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
a.configMu.Lock()
|
||||
defer a.configMu.Unlock()
|
||||
c, err := a.loadConfig()
|
||||
if err != nil {
|
||||
fail(w, 503, "CONFIG_UNAVAILABLE")
|
||||
return
|
||||
}
|
||||
if body.BaseHash != c.hash {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
changed := map[string]bool{}
|
||||
if body.Global != nil {
|
||||
g := body.Global
|
||||
if g.Concurrent < 1 || g.Concurrent > 64 || !validNumbers(g.Interval, g.Retry, g.Timeout) {
|
||||
fail(w, 400, "INVALID_INPUT")
|
||||
return
|
||||
}
|
||||
if *g != c.global {
|
||||
f := c.files[a.cfg.WorkerConfig]
|
||||
m := asMap(f.doc["global"])
|
||||
m["concurrent"], m["interval"], m["retry"], m["timeout"] = g.Concurrent, g.Interval, g.Retry, g.Timeout
|
||||
f.doc["global"] = m
|
||||
changed[a.cfg.WorkerConfig] = true
|
||||
}
|
||||
}
|
||||
if body.Mirror != nil {
|
||||
m := body.Mirror
|
||||
if !validName(m.Name) || !validUpstream(m.Upstream) || !validNumbers(m.Interval, m.Retry, m.Timeout) {
|
||||
fail(w, 400, "INVALID_INPUT")
|
||||
return
|
||||
}
|
||||
var current *ConfigMirror
|
||||
for _, entry := range c.mirrors {
|
||||
if entry.Name == m.Name {
|
||||
copy := entry
|
||||
current = ©
|
||||
break
|
||||
}
|
||||
}
|
||||
if current != nil {
|
||||
if current.Provider != m.Provider {
|
||||
fail(w, 400, "INVALID_INPUT")
|
||||
return
|
||||
}
|
||||
if current.Upstream != m.Upstream || current.Interval != m.Interval || current.Retry != m.Retry || current.Timeout != m.Timeout {
|
||||
f := c.files[current.Source]
|
||||
for _, table := range asTables(f.doc["mirrors"]) {
|
||||
if text(table["name"]) == m.Name {
|
||||
table["upstream"], table["interval"], table["retry"], table["timeout"] = m.Upstream, m.Interval, m.Retry, m.Timeout
|
||||
}
|
||||
}
|
||||
changed[current.Source] = true
|
||||
}
|
||||
} else {
|
||||
if c.includeDir == "" || (m.Provider != "rsync" && m.Provider != "two-stage-rsync") {
|
||||
fail(w, 400, "INVALID_INPUT")
|
||||
return
|
||||
}
|
||||
path := filepath.Join(c.includeDir, "mirrorouc-"+m.Name+".conf")
|
||||
if _, err = os.Lstat(path); !os.IsNotExist(err) {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
entry := map[string]any{"name": m.Name, "provider": m.Provider, "upstream": m.Upstream, "interval": m.Interval, "retry": m.Retry, "timeout": m.Timeout}
|
||||
if m.Provider == "two-stage-rsync" {
|
||||
entry["stage1_profile"] = "debian"
|
||||
}
|
||||
c.files[path] = configFile{"", map[string]any{"mirrors": []map[string]any{entry}}}
|
||||
changed[path] = true
|
||||
}
|
||||
}
|
||||
if len(changed) == 0 {
|
||||
fail(w, 400, "NO_CHANGES")
|
||||
return
|
||||
}
|
||||
files := map[string]fileChange{}
|
||||
for path := range changed {
|
||||
f := c.files[path]
|
||||
var b bytes.Buffer
|
||||
if err = toml.NewEncoder(&b).Encode(f.doc); err != nil {
|
||||
a.internal(w, err)
|
||||
return
|
||||
}
|
||||
after := b.String()
|
||||
var before *string
|
||||
if _, err = os.Stat(path); err == nil {
|
||||
old := f.raw
|
||||
before = &old
|
||||
}
|
||||
files[path] = fileChange{before, &after}
|
||||
}
|
||||
id := tokenHash(randomToken())[:24]
|
||||
raw, _ := json.Marshal(files)
|
||||
now := time.Now().UnixMilli()
|
||||
_, err = a.db.Exec("INSERT INTO config_versions(id,files,base_hash,status,created,username) VALUES(?,?,?,'draft',?,?)", id, string(raw), c.hash, now, s.Username)
|
||||
if err != nil {
|
||||
a.internal(w, err)
|
||||
return
|
||||
}
|
||||
a.audit(s, "config_preview", id, "draft")
|
||||
respond(w, 201, configDraft{id, files, c.hash, "draft", now, s.Username})
|
||||
}
|
||||
func atomicFile(path string, content *string) error {
|
||||
if content == nil {
|
||||
return os.Remove(path)
|
||||
}
|
||||
mode := os.FileMode(0660)
|
||||
if info, err := os.Stat(path); err == nil {
|
||||
mode = info.Mode().Perm()
|
||||
}
|
||||
f, err := os.CreateTemp(filepath.Dir(path), ".mirrorouc-*.tmp")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
tmp := f.Name()
|
||||
defer os.Remove(tmp)
|
||||
if err = f.Chmod(mode); err == nil {
|
||||
_, err = f.WriteString(*content)
|
||||
}
|
||||
if err == nil {
|
||||
err = f.Sync()
|
||||
}
|
||||
if e := f.Close(); err == nil {
|
||||
err = e
|
||||
}
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.Rename(tmp, path)
|
||||
}
|
||||
func (a *App) readVersion(id string) (configDraft, error) {
|
||||
var v configDraft
|
||||
var raw string
|
||||
v.ID = id
|
||||
err := a.db.QueryRow("SELECT files,base_hash,status,created,username FROM config_versions WHERE id=?", id).Scan(&raw, &v.BaseHash, &v.Status, &v.Created, &v.Username)
|
||||
if err != nil {
|
||||
return v, err
|
||||
}
|
||||
err = json.Unmarshal([]byte(raw), &v.Files)
|
||||
return v, err
|
||||
}
|
||||
func (a *App) applyVersion(r *http.Request, v configDraft, s Session) (string, error) {
|
||||
c, err := a.loadConfig()
|
||||
if err != nil {
|
||||
return "CONFIG_UNAVAILABLE", err
|
||||
}
|
||||
if c.hash != v.BaseHash {
|
||||
return "CONFLICT", errConflict
|
||||
}
|
||||
for path, change := range v.Files {
|
||||
raw, e := os.ReadFile(path)
|
||||
if change.Before == nil {
|
||||
if !os.IsNotExist(e) {
|
||||
return "CONFLICT", errConflict
|
||||
}
|
||||
} else if e != nil || string(raw) != *change.Before {
|
||||
return "CONFLICT", errConflict
|
||||
}
|
||||
}
|
||||
if a.cfg.ConfigSocket != "" {
|
||||
conn, err := net.DialTimeout("unix", a.cfg.ConfigSocket, 5*time.Second)
|
||||
if err != nil {
|
||||
return "CONFIG_UNAVAILABLE", err
|
||||
}
|
||||
defer conn.Close()
|
||||
conn.SetDeadline(time.Now().Add(28 * time.Second))
|
||||
if err = json.NewEncoder(conn).Encode(v); err != nil {
|
||||
return "CONFIG_STATE_UNCERTAIN", err
|
||||
}
|
||||
var result struct {
|
||||
Code string `json:"code"`
|
||||
}
|
||||
if err = json.NewDecoder(bufio.NewReader(conn)).Decode(&result); err != nil {
|
||||
return "CONFIG_STATE_UNCERTAIN", err
|
||||
}
|
||||
if result.Code != "" {
|
||||
a.db.Exec("UPDATE config_versions SET status='failed' WHERE id=?", v.ID)
|
||||
return result.Code, errors.New(result.Code)
|
||||
}
|
||||
if _, err = a.db.Exec("UPDATE config_versions SET status='applied' WHERE id=?", v.ID); err != nil {
|
||||
return "CONFIG_STATE_UNCERTAIN", err
|
||||
}
|
||||
a.audit(s, "config_apply", v.ID, "submitted")
|
||||
return "", nil
|
||||
}
|
||||
written := []string{}
|
||||
restore := func() error {
|
||||
var result error
|
||||
for i := len(written) - 1; i >= 0; i-- {
|
||||
path := written[i]
|
||||
if e := atomicFile(path, v.Files[path].Before); e != nil {
|
||||
result = e
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
for _, path := range sortedKeys(v.Files) {
|
||||
if err = atomicFile(path, v.Files[path].After); err != nil {
|
||||
if e := restore(); e != nil {
|
||||
return "CONFIG_ROLLBACK_FAILED", e
|
||||
}
|
||||
return "CONFIG_APPLY_FAILED", err
|
||||
}
|
||||
written = append(written, path)
|
||||
}
|
||||
if _, err = a.loadConfig(); err == nil {
|
||||
err = a.sendCommand(r.Context(), "", "reload")
|
||||
}
|
||||
if err != nil {
|
||||
restoreErr := restore()
|
||||
if restoreErr == nil {
|
||||
restoreErr = a.sendCommand(r.Context(), "", "reload")
|
||||
}
|
||||
a.db.Exec("UPDATE config_versions SET status='failed' WHERE id=?", v.ID)
|
||||
if restoreErr != nil {
|
||||
return "CONFIG_ROLLBACK_FAILED", restoreErr
|
||||
}
|
||||
return "CONFIG_APPLY_FAILED", err
|
||||
}
|
||||
if _, err = a.db.Exec("UPDATE config_versions SET status='applied' WHERE id=?", v.ID); err != nil {
|
||||
return "CONFIG_STATE_UNCERTAIN", err
|
||||
}
|
||||
a.audit(s, "config_apply", v.ID, "submitted")
|
||||
return "", nil
|
||||
}
|
||||
func (a *App) configApply(w http.ResponseWriter, r *http.Request) {
|
||||
s, ok := a.require(w, r, true)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if !readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
a.configMu.Lock()
|
||||
defer a.configMu.Unlock()
|
||||
v, err := a.readVersion(body.ID)
|
||||
if err != nil {
|
||||
fail(w, 404, "NOT_FOUND")
|
||||
return
|
||||
}
|
||||
if v.Status != "draft" {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
code, err := a.applyVersion(r, v, s)
|
||||
if err != nil {
|
||||
a.logger.Printf("config apply: %v", err)
|
||||
a.audit(s, "config_apply", v.ID, code)
|
||||
status := 502
|
||||
if code == "CONFLICT" {
|
||||
status = 409
|
||||
}
|
||||
fail(w, status, code)
|
||||
return
|
||||
}
|
||||
respond(w, 202, map[string]string{"status": "submitted"})
|
||||
}
|
||||
func (a *App) configVersions(w http.ResponseWriter, r *http.Request) {
|
||||
if _, ok := a.require(w, r, true); !ok {
|
||||
return
|
||||
}
|
||||
rows, err := a.db.Query("SELECT id,base_hash,status,created,username FROM config_versions ORDER BY created DESC LIMIT 50")
|
||||
if err != nil {
|
||||
a.internal(w, err)
|
||||
return
|
||||
}
|
||||
defer rows.Close()
|
||||
out := []configDraft{}
|
||||
for rows.Next() {
|
||||
var v configDraft
|
||||
if err = rows.Scan(&v.ID, &v.BaseHash, &v.Status, &v.Created, &v.Username); err != nil {
|
||||
a.internal(w, err)
|
||||
return
|
||||
}
|
||||
out = append(out, v)
|
||||
}
|
||||
respond(w, 200, out)
|
||||
}
|
||||
func (a *App) configRollback(w http.ResponseWriter, r *http.Request) {
|
||||
s, ok := a.require(w, r, true)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
var body struct {
|
||||
ID string `json:"id"`
|
||||
}
|
||||
if !readJSON(w, r, &body) {
|
||||
return
|
||||
}
|
||||
a.configMu.Lock()
|
||||
defer a.configMu.Unlock()
|
||||
old, err := a.readVersion(body.ID)
|
||||
if err != nil {
|
||||
fail(w, 404, "NOT_FOUND")
|
||||
return
|
||||
}
|
||||
if old.Status != "applied" {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
c, err := a.loadConfig()
|
||||
if err != nil {
|
||||
fail(w, 503, "CONFIG_UNAVAILABLE")
|
||||
return
|
||||
}
|
||||
reverse := map[string]fileChange{}
|
||||
for path, change := range old.Files {
|
||||
raw, e := os.ReadFile(path)
|
||||
if change.After == nil {
|
||||
if !os.IsNotExist(e) {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
} else if e != nil || string(raw) != *change.After {
|
||||
fail(w, 409, "CONFLICT")
|
||||
return
|
||||
}
|
||||
reverse[path] = fileChange{change.After, change.Before}
|
||||
}
|
||||
id := tokenHash(randomToken())[:24]
|
||||
now := time.Now().UnixMilli()
|
||||
raw, _ := json.Marshal(reverse)
|
||||
v := configDraft{id, reverse, c.hash, "draft", now, s.Username}
|
||||
if _, err = a.db.Exec("INSERT INTO config_versions(id,files,base_hash,status,created,username) VALUES(?,?,?,'draft',?,?)", id, string(raw), c.hash, now, s.Username); err != nil {
|
||||
a.internal(w, err)
|
||||
return
|
||||
}
|
||||
code, err := a.applyVersion(r, v, s)
|
||||
if err != nil {
|
||||
a.audit(s, "config_rollback", old.ID, code)
|
||||
fail(w, 502, code)
|
||||
return
|
||||
}
|
||||
a.audit(s, "config_rollback", old.ID, "submitted")
|
||||
respond(w, 202, map[string]string{"status": "submitted"})
|
||||
}
|
||||
Reference in New Issue
Block a user