feat(update): 页面一键更新 + 守护启动脚本

系统配置页新增「版本与更新」卡片,顶栏版本号旁在有新版时亮出提示胶囊。
更新链路:下载发布包 → 比对 SHA256SUMS → -h 冒烟测试 → 暂存 artex.new
→ 以退出码 75 退出 → 守护脚本重新拉起并完成换装,页面轮询 /api/health
等版本号变化后自动刷新。

新增 start.sh / start.bat 作为正式启动入口,只按退出码决定是否重新拉起
(0 停止 / 75 应用新版 / 其余崩溃退避)。校验、冒烟、换装、回滚全部收在
selfupdate 包里而不写进脚本:这些逻辑在 sh 和 bat 上要写两套,而它们恰恰
最不能出错——换上跑不起来的二进制后守护进程会反复拉起它,只能上机器手工救。
Docker 的 ENTRYPOINT 一并改为该脚本,并由它转发 SIGTERM,否则 docker stop
只发给 PID 1,artex 做不了优雅关闭会被 SIGKILL 硬杀。

失败保护两道闸门互补:无法 exec 由换装前的冒烟挡住,能执行但初始化崩溃
由启动计数兜住(连续 3 次失败自动回滚 artex.old,坏的留作 artex.failed)。

GitHub 查询结果后端缓存 30 分钟(失败 2 分钟)。未认证 API 是每 IP 每小时
60 次,且这 60 次是服务器 IP 上所有用户共用的,顶栏每次整页加载都查一次,
不缓存会很快耗光配额导致真想更新时反而查不动。手动「检查更新」带 force=1
绕过缓存。

安全:只认 GitHub 域名且强制 HTTPS(逐跳校验重定向),发布源写死不可配置;
升级文件挂在可执行文件所在目录而非 CWD(服务化运行时 CWD 可能是 /);
开发构建版本号不可比较,禁用一键更新。

走完整 zip 而非裸二进制,因为现有 Release 的 SHA256SUMS 只覆盖 zip,
这样无需改 CI,也兼容已发布的历史版本。

已知限制:Docker 下只换程序不换镜像(工具链不同步、重建容器会退回镜像
版本);不同步发布包里的 skills/;更新即重启会中断运行中的任务。
This commit is contained in:
Autumn-27 committed 2026-09-11 12:39:59 -04:00
1 parent 557317491b
commit 44156a0a4c
22 files changed
+2619 -16

No files matched your search

+155
View File
@@ -0,0 +1,155 @@
package server
import (
"context"
"errors"
"net/http"
"testing"
"time"
"github.com/Autumn-27/artex/selfupdate"
)
// releaseCache 是保护 GitHub 配额的那一层:未认证的 API 只有 60 次/小时/IP,
// 而顶栏的"有新版本"提示每次整页加载都会查一次。缓存一旦失效,用户多开几个
// 标签页就会把配额耗光,之后真想更新反而查不动。
func newTestCache(fetch func(context.Context, *http.Client) (*selfupdate.Release, error)) *releaseCache {
return &releaseCache{fetch: fetch}
}
func TestReleaseCacheServesFromCache(t *testing.T) {
calls := 0
c := newTestCache(func(context.Context, *http.Client) (*selfupdate.Release, error) {
calls++
return &selfupdate.Release{TagName: "v0.3.8"}, nil
})
for range 5 {
rel, err := c.get(t.Context(), nil, false)
if err != nil {
t.Fatalf("get: %v", err)
}
if rel.TagName != "v0.3.8" {
t.Fatalf("TagName = %q", rel.TagName)
}
}
if calls != 1 {
t.Errorf("5 次查询只应回源 1 次,实际 %d 次", calls)
}
}
func TestReleaseCacheForceBypasses(t *testing.T) {
calls := 0
c := newTestCache(func(context.Context, *http.Client) (*selfupdate.Release, error) {
calls++
return &selfupdate.Release{TagName: "v0.3.8"}, nil
})
if _, err := c.get(t.Context(), nil, false); err != nil {
t.Fatal(err)
}
// 用户点「检查更新」必须拿到实时结果,否则刚发布的版本要等缓存过期才看得见。
if _, err := c.get(t.Context(), nil, true); err != nil {
t.Fatal(err)
}
if calls != 2 {
t.Errorf("force 应绕过缓存,期望回源 2 次,实际 %d 次", calls)
}
}
func TestReleaseCacheExpiresAfterTTL(t *testing.T) {
calls := 0
c := newTestCache(func(context.Context, *http.Client) (*selfupdate.Release, error) {
calls++
return &selfupdate.Release{TagName: "v0.3.8"}, nil
})
if _, err := c.get(t.Context(), nil, false); err != nil {
t.Fatal(err)
}
// 把落库时间往前拨到刚过期,模拟 TTL 到点。
c.at = time.Now().Add(-releaseTTL - time.Second)
if _, err := c.get(t.Context(), nil, false); err != nil {
t.Fatal(err)
}
if calls != 2 {
t.Errorf("TTL 过期后应重新回源,期望 2 次,实际 %d 次", calls)
}
}
func TestReleaseCacheUsesShorterTTLForErrors(t *testing.T) {
calls := 0
c := newTestCache(func(context.Context, *http.Client) (*selfupdate.Release, error) {
calls++
return nil, errors.New("github 不可达")
})
if _, err := c.get(t.Context(), nil, false); err == nil {
t.Fatal("期望返回错误")
}
// 失败结果也要缓存一会儿,否则 GitHub 不可达时每次页面加载都白等一次超时。
if _, err := c.get(t.Context(), nil, false); err == nil {
t.Fatal("期望返回错误")
}
if calls != 1 {
t.Errorf("错误应短时缓存,期望回源 1 次,实际 %d 次", calls)
}
// 但错误的 TTL 必须明显短于成功的,网络恢复后要能很快自愈。
if releaseErrTTL >= releaseTTL {
t.Fatalf("错误 TTL(%v) 必须短于成功 TTL(%v)", releaseErrTTL, releaseTTL)
}
c.at = time.Now().Add(-releaseErrTTL - time.Second)
if _, err := c.get(t.Context(), nil, false); err == nil {
t.Fatal("期望返回错误")
}
if calls != 2 {
t.Errorf("错误 TTL 过期后应重试,期望 2 次,实际 %d 次", calls)
}
}
func TestReleaseCacheDoesNotPoisonOnCallerCancel(t *testing.T) {
good := &selfupdate.Release{TagName: "v0.3.8"}
c := newTestCache(func(ctx context.Context, _ *http.Client) (*selfupdate.Release, error) {
return good, nil
})
if _, err := c.get(t.Context(), nil, false); err != nil {
t.Fatal(err)
}
// 访客关掉标签页会取消请求。那不代表 GitHub 有问题,绝不能把"已取消"
// 写进缓存——否则接下来 30 分钟内每个访客都会收到一条莫名其妙的错误。
c.fetch = func(ctx context.Context, _ *http.Client) (*selfupdate.Release, error) {
return nil, ctx.Err()
}
c.at = time.Now().Add(-releaseTTL - time.Second) // 让缓存过期,逼它回源
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := c.get(ctx, nil, false); err == nil {
t.Fatal("调用方已取消时应把错误透传给它")
}
// 关键不变量:被取消的那一次不留下任何痕迹——缓存里既没有"已取消"这个错误,
// 也还保着上一次的好结果。
if c.err != nil {
t.Fatalf("取消错误不应写进缓存,得到 %v", c.err)
}
if c.rel == nil || c.rel.TagName != "v0.3.8" {
t.Fatalf("缓存应保留上一次的好结果,得到 %+v", c.rel)
}
// 那次取消没换来任何新数据,所以下一个访客理应重新回源——而且能正常拿到结果,
// 不会被上一次的取消连累。
c.fetch = func(context.Context, *http.Client) (*selfupdate.Release, error) {
return good, nil
}
rel, err := c.get(t.Context(), nil, false)
if err != nil {
t.Fatalf("取消之后的正常请求不应报错: %v", err)
}
if rel == nil || rel.TagName != "v0.3.8" {
t.Fatalf("应拿到正常结果,得到 %+v", rel)
}
}