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:
2026-11-01 18:04:01 +08:00
parent addadd7d15
commit f8cef413d6
57 changed files with 4222 additions and 101 deletions
+263
View File
@@ -0,0 +1,263 @@
package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"math"
"net/http"
"net/url"
"os"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"time"
)
func (a *App) managerGet(ctx context.Context, path string, target any) error {
req, err := http.NewRequestWithContext(ctx, "GET", strings.TrimRight(a.cfg.Manager, "/")+path, nil)
if err != nil {
return err
}
res, err := a.client.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode != 200 {
return fmt.Errorf("manager HTTP %d", res.StatusCode)
}
return json.NewDecoder(io.LimitReader(res.Body, 8<<20)).Decode(target)
}
func (a *App) sendCommand(ctx context.Context, name, action string) error {
if a.cfg.Worker == "" {
return errors.New("worker not configured")
}
data, _ := json.Marshal(map[string]any{"worker_id": a.cfg.Worker, "mirror_id": name, "cmd": action, "args": []string{}, "options": map[string]bool{}})
req, err := http.NewRequestWithContext(ctx, "POST", strings.TrimRight(a.cfg.Manager, "/")+"/cmd", bytes.NewReader(data))
if err != nil {
return err
}
req.Header.Set("Content-Type", "application/json")
res, err := a.client.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
io.Copy(io.Discard, io.LimitReader(res.Body, 1<<20))
if res.StatusCode < 200 || res.StatusCode >= 300 {
return fmt.Errorf("manager command HTTP %d", res.StatusCode)
}
return nil
}
func (a *App) cachedJobs() ([]Job, int64, string) {
a.jobsMu.RLock()
defer a.jobsMu.RUnlock()
jobs := append([]Job{}, a.jobs...)
return jobs, a.jobsUpdated, a.jobsError
}
func (a *App) loadCache() {
var raw string
var updated int64
if a.db.QueryRow("SELECT data,updated FROM cache WHERE key='jobs'").Scan(&raw, &updated) == nil {
var jobs []Job
if json.Unmarshal([]byte(raw), &jobs) == nil {
a.jobs = jobs
a.jobsUpdated = updated
a.jobsError = "TUNASYNC_UNAVAILABLE"
}
}
}
func (a *App) refresh(ctx context.Context) {
jobs := []Job{}
err := error(nil)
if a.cfg.Worker == "" {
err = errors.New("worker not configured")
} else {
err = a.managerGet(ctx, "/workers/"+url.PathEscape(a.cfg.Worker)+"/jobs", &jobs)
}
a.jobsMu.Lock()
if err != nil {
a.jobsError = "TUNASYNC_UNAVAILABLE"
a.jobsMu.Unlock()
a.logger.Printf("tunasync poll: %v", err)
return
}
a.jobs = jobs
a.jobsUpdated = time.Now().UnixMilli()
a.jobsError = ""
updated := a.jobsUpdated
a.jobsMu.Unlock()
raw, _ := json.Marshal(jobs)
if _, err = a.db.Exec("INSERT INTO cache(key,data,updated) VALUES('jobs',?,?) ON CONFLICT(key) DO UPDATE SET data=excluded.data,updated=excluded.updated", string(raw), updated); err != nil {
a.logger.Printf("cache: %v", err)
}
}
func (a *App) poll(ctx context.Context) {
a.refresh(ctx)
ticker := time.NewTicker(15 * time.Second)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
a.refresh(ctx)
}
}
}
func stamp(value time.Time) *int64 {
if value.IsZero() || value.Unix() <= 0 {
return nil
}
ms := value.UnixMilli()
return &ms
}
var humanSize = regexp.MustCompile(`(?i)^\s*(\d+(?:\.\d+)?)\s*([kmgtpe]?)(?:i?b)?\s*$`)
func parseSize(value string) *float64 {
parts := humanSize.FindStringSubmatch(value)
if parts == nil {
return nil
}
n, err := strconv.ParseFloat(parts[1], 64)
if err != nil || math.IsNaN(n) || math.IsInf(n, 0) {
return nil
}
power := strings.Index("kmgtpe", strings.ToLower(parts[2])) + 1
if parts[2] == "" {
power = 0
}
n *= math.Pow(1024, float64(power))
return &n
}
func redactURL(value string) string {
u, err := url.Parse(value)
if err != nil {
return ""
}
u.User = nil
u.RawQuery = ""
u.Fragment = ""
return u.String()
}
func publicMirror(job Job, meta MirrorMetadata) PublicMirror {
status := map[string]string{"success": "success", "syncing": "syncing", "pre-syncing": "waiting", "failed": "failed", "paused": "paused", "disabled": "paused", "none": "unknown"}[job.Status]
if status == "" {
status = "unknown"
}
return PublicMirror{Name: job.Name, Description: meta.Description, Help: meta.Help, Category: meta.Category, Status: status, LastSuccess: stamp(job.LastUpdate), LastAttempt: stamp(job.LastStarted), SyncStarted: stamp(job.LastStarted), NextSync: stamp(job.NextSchedule), Size: parseSize(job.Size), Website: meta.Website, Upstream: redactURL(job.Upstream), BrowseURL: "/mirrors/" + url.PathEscape(job.Name) + "/"}
}
func (a *App) command(w http.ResponseWriter, r *http.Request) {
s, ok := a.require(w, r, true)
if !ok {
return
}
name, action := r.PathValue("name"), r.PathValue("action")
if action != "start" && action != "stop" && action != "restart" && action != "disable" {
fail(w, 400, "INVALID_ACTION")
return
}
jobs, _, code := a.cachedJobs()
found := false
for _, job := range jobs {
if job.Name == name {
found = true
break
}
}
if !validName(name) || !found {
fail(w, 404, "NOT_FOUND")
return
}
if code != "" {
fail(w, 503, "TUNASYNC_UNAVAILABLE")
return
}
if err := a.sendCommand(r.Context(), name, action); err != nil {
a.audit(s, "job_"+action, name, "uncertain")
a.logger.Printf("command: %v", err)
fail(w, 502, "COMMAND_UNCERTAIN")
return
}
a.audit(s, "job_"+action, name, "submitted")
a.refresh(r.Context())
respond(w, 202, map[string]string{"status": "submitted"})
}
func (a *App) logs(w http.ResponseWriter, r *http.Request) {
if _, ok := a.require(w, r, true); !ok {
return
}
name := r.PathValue("name")
if a.cfg.Logs == "" {
fail(w, 503, "LOGS_UNAVAILABLE")
return
}
if !validName(name) {
fail(w, 400, "INVALID_INPUT")
return
}
base, baseErr := filepath.EvalSymlinks(a.cfg.Logs)
if baseErr != nil {
fail(w, 503, "LOGS_UNAVAILABLE")
return
}
root, err := filepath.EvalSymlinks(filepath.Join(base, name))
if err != nil {
fail(w, 404, "NOT_FOUND")
return
}
rootRel, err := filepath.Rel(base, root)
if err != nil || rootRel == ".." || strings.HasPrefix(rootRel, ".."+string(os.PathSeparator)) || filepath.IsAbs(rootRel) {
fail(w, 403, "FORBIDDEN")
return
}
path, err := filepath.EvalSymlinks(filepath.Join(root, "latest"))
if err != nil {
fail(w, 404, "NOT_FOUND")
return
}
rel, err := filepath.Rel(root, path)
if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) || filepath.IsAbs(rel) {
fail(w, 403, "FORBIDDEN")
return
}
f, err := os.Open(path)
if err != nil {
fail(w, 404, "NOT_FOUND")
return
}
defer f.Close()
info, err := f.Stat()
if err != nil || !info.Mode().IsRegular() {
fail(w, 400, "INVALID_INPUT")
return
}
truncated := info.Size() > 65536
if truncated {
if _, err = f.Seek(-65536, io.SeekEnd); err != nil {
a.internal(w, err)
return
}
}
content, err := io.ReadAll(io.LimitReader(f, 65536))
if err != nil {
a.internal(w, err)
return
}
respond(w, 200, map[string]any{"content": strings.ToValidUTF8(string(content), "�"), "truncated": truncated})
}
func sortedKeys[V any](m map[string]V) []string {
keys := make([]string, 0, len(m))
for key := range m {
keys = append(keys, key)
}
sort.Strings(keys)
return keys
}