feat: add manual server binary upload and confirmation upgrade process

- Implemented UploadManualServerBinary endpoint for uploading server binaries and checking their versions. - Added ConfirmManualServerUpgrade endpoint to confirm the upgrade with the uploaded binary. - Updated API routes to include manual upload and upgrade confirmation. - Enhanced service layer to handle manual binary uploads, version detection, and upgrade execution. - Introduced new types for handling uploaded binary information. - Updated frontend components to support manual binary upload and confirmation, including UI feedback for users. - Modified documentation to reflect new manual upload and upgrade features.
2026-10-11 17:56:37 +08:00 · 2026-03-12 10:34:31 +08:00
parent 29a0c64ba3
commit 93e43fb3b0
12 changed files with 1004 additions and 28 deletions
@@ -7,10 +7,13 @@ import (
 	"bytes"
 	"encoding/json"
 	"io"
+	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
+	"runtime"
 	"strings"
 	"testing"
+	"time"

 	"github.com/gin-contrib/sessions"
 	"github.com/gin-contrib/sessions/cookie"
@@ -105,3 +108,194 @@ func TestLatestReleaseProxy(t *testing.T) {
 		t.Fatalf("unexpected current_version: %#v", data["current_version"])
 	}
 }
+
+func loginRootAndBuildEngine(t *testing.T) (*gin.Engine, []*http.Cookie) {
+	t.Helper()
+	gin.SetMode(gin.TestMode)
+	common.RedisEnabled = false
+	setupTestDB(t)
+
+	engine := gin.New()
+	engine.Use(sessions.Sessions("session", cookie.NewStore([]byte("test-secret"))))
+	router.SetApiRouter(engine)
+
+	loginBody, err := json.Marshal(map[string]string{
+		"username": "root",
+		"password": "123456",
+	})
+	if err != nil {
+		t.Fatalf("failed to marshal login body: %v", err)
+	}
+	loginReq := httptest.NewRequest(http.MethodPost, "/api/user/login", bytes.NewReader(loginBody))
+	loginReq.Header.Set("Content-Type", "application/json")
+	loginRecorder := httptest.NewRecorder()
+	engine.ServeHTTP(loginRecorder, loginReq)
+	if loginRecorder.Code != http.StatusOK {
+		t.Fatalf("unexpected login status code: %d", loginRecorder.Code)
+	}
+
+	return engine, loginRecorder.Result().Cookies()
+}
+
+func fakeManualServerBinary(version string) (string, []byte) {
+	if runtime.GOOS == "windows" {
+		return "atsflare-server-test.cmd", []byte("@echo off\r\necho " + version + "\r\n")
+	}
+	return "atsflare-server-test.sh", []byte("#!/bin/sh\necho " + version + "\n")
+}
+
+func TestManualUploadRoute(t *testing.T) {
+	originalVersion := common.Version
+	common.Version = "v0.4.0"
+	t.Cleanup(func() {
+		common.Version = originalVersion
+		service.SetServerBinaryUpgradeExecutorForTest(nil)
+		service.SetServerUpgradeDispatchDelayForTest(500 * time.Millisecond)
+	})
+
+	engine, cookies := loginRootAndBuildEngine(t)
+	fileName, content := fakeManualServerBinary("v0.5.0")
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("binary", fileName)
+	if err != nil {
+		t.Fatalf("failed to create form file: %v", err)
+	}
+	if _, err = part.Write(content); err != nil {
+		t.Fatalf("failed to write upload content: %v", err)
+	}
+	if err = writer.Close(); err != nil {
+		t.Fatalf("failed to close multipart writer: %v", err)
+	}
+
+	req := httptest.NewRequest(http.MethodPost, "/api/update/manual-upload", body)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	for _, cookieValue := range cookies {
+		req.AddCookie(cookieValue)
+	}
+
+	recorder := httptest.NewRecorder()
+	engine.ServeHTTP(recorder, req)
+	if recorder.Code != http.StatusOK {
+		t.Fatalf("unexpected status code: %d", recorder.Code)
+	}
+
+	var resp apiResponse
+	if err = json.Unmarshal(recorder.Body.Bytes(), &resp); err != nil {
+		t.Fatalf("failed to decode response: %v", err)
+	}
+	if !resp.Success {
+		t.Fatalf("expected success response, got message: %s", resp.Message)
+	}
+
+	var data map[string]any
+	if err = json.Unmarshal(resp.Data, &data); err != nil {
+		t.Fatalf("failed to decode response data: %v", err)
+	}
+	if data["detected_version"] != "v0.5.0" {
+		t.Fatalf("unexpected detected_version: %#v", data["detected_version"])
+	}
+	if data["ready_to_upgrade"] != true {
+		t.Fatalf("expected ready_to_upgrade to be true: %#v", data["ready_to_upgrade"])
+	}
+	if data["upload_token"] == "" {
+		t.Fatal("expected upload_token to be returned")
+	}
+}
+
+func TestManualUpgradeConfirmRoute(t *testing.T) {
+	originalVersion := common.Version
+	originalExecutor := service.ServerBinaryUpgradeExecutorForTest()
+	originalDelay := service.ServerUpgradeDispatchDelayForTest()
+	common.Version = "v0.4.0"
+	called := make(chan string, 1)
+	service.SetServerBinaryUpgradeExecutorForTest(func(execPath string, tempPath string) error {
+		called <- tempPath
+		return nil
+	})
+	service.SetServerUpgradeDispatchDelayForTest(0)
+	t.Cleanup(func() {
+		common.Version = originalVersion
+		service.SetServerBinaryUpgradeExecutorForTest(originalExecutor)
+		service.SetServerUpgradeDispatchDelayForTest(originalDelay)
+	})
+
+	engine, cookies := loginRootAndBuildEngine(t)
+	fileName, content := fakeManualServerBinary("v0.5.0")
+
+	body := &bytes.Buffer{}
+	writer := multipart.NewWriter(body)
+	part, err := writer.CreateFormFile("binary", fileName)
+	if err != nil {
+		t.Fatalf("failed to create form file: %v", err)
+	}
+	if _, err = part.Write(content); err != nil {
+		t.Fatalf("failed to write upload content: %v", err)
+	}
+	if err = writer.Close(); err != nil {
+		t.Fatalf("failed to close multipart writer: %v", err)
+	}
+
+	uploadReq := httptest.NewRequest(http.MethodPost, "/api/update/manual-upload", body)
+	uploadReq.Header.Set("Content-Type", writer.FormDataContentType())
+	for _, cookieValue := range cookies {
+		uploadReq.AddCookie(cookieValue)
+	}
+
+	uploadRecorder := httptest.NewRecorder()
+	engine.ServeHTTP(uploadRecorder, uploadReq)
+	if uploadRecorder.Code != http.StatusOK {
+		t.Fatalf("unexpected upload status code: %d", uploadRecorder.Code)
+	}
+
+	var uploadResp apiResponse
+	if err = json.Unmarshal(uploadRecorder.Body.Bytes(), &uploadResp); err != nil {
+		t.Fatalf("failed to decode upload response: %v", err)
+	}
+	if !uploadResp.Success {
+		t.Fatalf("expected upload success, got message: %s", uploadResp.Message)
+	}
+
+	var uploadData map[string]any
+	if err = json.Unmarshal(uploadResp.Data, &uploadData); err != nil {
+		t.Fatalf("failed to decode upload response data: %v", err)
+	}
+	uploadToken, _ := uploadData["upload_token"].(string)
+	if uploadToken == "" {
+		t.Fatal("expected upload token in upload response")
+	}
+
+	confirmBody, err := json.Marshal(map[string]string{"upload_token": uploadToken})
+	if err != nil {
+		t.Fatalf("failed to marshal confirm body: %v", err)
+	}
+	confirmReq := httptest.NewRequest(http.MethodPost, "/api/update/manual-upgrade", bytes.NewReader(confirmBody))
+	confirmReq.Header.Set("Content-Type", "application/json")
+	for _, cookieValue := range cookies {
+		confirmReq.AddCookie(cookieValue)
+	}
+
+	confirmRecorder := httptest.NewRecorder()
+	engine.ServeHTTP(confirmRecorder, confirmReq)
+	if confirmRecorder.Code != http.StatusOK {
+		t.Fatalf("unexpected confirm status code: %d", confirmRecorder.Code)
+	}
+
+	var confirmResp apiResponse
+	if err = json.Unmarshal(confirmRecorder.Body.Bytes(), &confirmResp); err != nil {
+		t.Fatalf("failed to decode confirm response: %v", err)
+	}
+	if !confirmResp.Success {
+		t.Fatalf("expected confirm success, got message: %s", confirmResp.Message)
+	}
+
+	select {
+	case tempPath := <-called:
+		if tempPath == "" {
+			t.Fatal("expected manual upgrade executor to receive temp path")
+		}
+	case <-time.After(time.Second):
+		t.Fatal("expected manual upgrade executor to be called")
+	}
+}