修复重启确认响应中断并补齐迁移恢复实机验收

This commit is contained in:
xuans committed 2026-09-21 05:28:46 +08:00
1 parent a585e5f61f
commit 3fab99bb09
7 files changed
+243 -4

No files matched your search

+2 -2
View File
@@ -27,8 +27,8 @@ func HttpStop() {
httpServerMu.Lock()
defer httpServerMu.Unlock()
if httpServer != nil {
if err := httpServer.Close(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.WithError(err).Warn("close HTTP server failed")
if err := shutdownWebServer(httpServer, webShutdownTimeout); err != nil {
log.WithError(err).Warn("HTTP 请求未能在停服期限内排空,已强制关闭连接")
}
httpServer = nil
}
+2 -2
View File
@@ -127,8 +127,8 @@ func HttpsStop() {
httpsServerMu.Lock()
defer httpsServerMu.Unlock()
if httpsServer != nil {
if err := httpsServer.Close(); err != nil && !errors.Is(err, http.ErrServerClosed) {
log.WithError(err).Warn("close HTTPS server failed")
if err := shutdownWebServer(httpsServer, webShutdownTimeout); err != nil {
log.WithError(err).Warn("HTTPS 请求未能在停服期限内排空,已强制关闭连接")
}
httpsServer = nil
}
+23
View File
@@ -0,0 +1,23 @@
package http_server
import (
"context"
"errors"
"net/http"
"time"
)
const webShutdownTimeout = 10 * time.Second
// 先停止监听并等待在途响应及会话提交,超时才强制断开,避免重启接口丢失确认响应。
func shutdownWebServer(server *http.Server, timeout time.Duration) error {
if server == nil {
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
return errors.Join(err, server.Close())
}
return nil
}
+123
View File
@@ -0,0 +1,123 @@
package http_server
import (
"context"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
)
func TestWebShutdownTimeoutClosesActiveConnection(t *testing.T) {
entered, canceled, release := make(chan struct{}), make(chan struct{}), make(chan struct{})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_, _ = io.Copy(io.Discard, r.Body)
close(entered)
select {
case <-r.Context().Done():
close(canceled)
case <-release:
}
}))
t.Cleanup(func() { close(release); server.Close() })
client := server.Client()
client.Timeout = 3 * time.Second
requestDone := make(chan error, 1)
go func() {
result, err := client.Post(server.URL, "application/json", strings.NewReader("{}"))
if result != nil {
_ = result.Body.Close()
}
requestDone <- err
}()
select {
case <-entered:
case <-time.After(3 * time.Second):
t.Fatal("request did not enter handler")
}
if err := shutdownWebServer(server.Config, 25*time.Millisecond); !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("expected shutdown deadline error, got %v", err)
}
select {
case <-canceled:
case <-time.After(3 * time.Second):
t.Fatal("shutdown timeout did not close active connection")
}
if err := <-requestDone; err == nil {
t.Fatal("timed-out request unexpectedly succeeded")
}
}
func TestWebShutdownNilServer(t *testing.T) {
if err := shutdownWebServer(nil, time.Second); err != nil {
t.Fatal(err)
}
}
// 真实连接仍在处理响应时停止服务,不能通过提前关闭客户端伪装成重启成功。
func TestWebStopPreservesActiveResponse(t *testing.T) {
for _, secure := range []bool{false, true} {
t.Run(fmt.Sprintf("tls=%v", secure), func(t *testing.T) {
entered, release := make(chan struct{}), make(chan struct{})
var releaseOnce sync.Once
finish := func() { releaseOnce.Do(func() { close(release) }) }
server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
close(entered)
<-release
w.Header().Set("Content-Type", "application/json")
_, _ = io.WriteString(w, `{"status":"accepted"}`)
}))
var stop func()
if secure {
server.StartTLS()
httpsServer, stop = server.Config, HttpsStop
} else {
server.Start()
httpServer, stop = server.Config, HttpStop
}
t.Cleanup(func() { finish(); stop(); server.Close() })
client := server.Client()
client.Timeout = 3 * time.Second
response := make(chan error, 1)
go func() {
result, err := client.Post(server.URL, "application/json", strings.NewReader("{}"))
if err != nil {
response <- err
return
}
defer result.Body.Close()
body, err := io.ReadAll(result.Body)
if err == nil && (result.StatusCode != http.StatusOK || string(body) != `{"status":"accepted"}`) {
err = fmt.Errorf("unexpected response: status=%d body=%q", result.StatusCode, body)
}
response <- err
}()
select {
case <-entered:
case <-time.After(3 * time.Second):
t.Fatal("request did not enter handler")
}
stopped := make(chan struct{})
go func() { stop(); close(stopped) }()
select {
case <-stopped:
t.Error("server stop returned before active response was completed")
case <-time.After(75 * time.Millisecond):
}
finish()
if err := <-response; err != nil {
t.Errorf("active response was lost: %v", err)
}
select {
case <-stopped:
case <-time.After(3 * time.Second):
t.Fatal("server did not stop after response completed")
}
})
}
}