779 lines
21 KiB
Go
779 lines
21 KiB
Go
// Package proxy 高性能OpenAI多密钥代理服务器
|
||
// @author OpenAI Proxy Team
|
||
// @version 2.0.0
|
||
package proxy
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"net/url"
|
||
"strings"
|
||
"sync/atomic"
|
||
"time"
|
||
|
||
"openai-multi-key-proxy/internal/config"
|
||
"openai-multi-key-proxy/internal/keymanager"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/sirupsen/logrus"
|
||
)
|
||
|
||
// RetryError 重试过程中的错误信息
|
||
type RetryError struct {
|
||
StatusCode int `json:"status_code"`
|
||
ErrorMessage string `json:"error_message"`
|
||
KeyIndex int `json:"key_index"`
|
||
Attempt int `json:"attempt"`
|
||
}
|
||
|
||
// ProxyServer 代理服务器
|
||
type ProxyServer struct {
|
||
keyManager *keymanager.KeyManager
|
||
httpClient *http.Client
|
||
streamClient *http.Client // 专门用于流式传输的客户端
|
||
upstreamURL *url.URL
|
||
requestCount int64
|
||
startTime time.Time
|
||
}
|
||
|
||
// NewProxyServer 创建新的代理服务器
|
||
func NewProxyServer() (*ProxyServer, error) {
|
||
// 解析上游URL
|
||
upstreamURL, err := url.Parse(config.AppConfig.OpenAI.BaseURL)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("解析上游URL失败: %w", err)
|
||
}
|
||
|
||
// 创建密钥管理器
|
||
keyManager := keymanager.NewKeyManager(config.AppConfig.Keys.FilePath)
|
||
if err := keyManager.LoadKeys(); err != nil {
|
||
return nil, fmt.Errorf("加载密钥失败: %w", err)
|
||
}
|
||
|
||
// 创建高性能HTTP客户端
|
||
transport := &http.Transport{
|
||
MaxIdleConns: config.AppConfig.Performance.MaxSockets,
|
||
MaxIdleConnsPerHost: config.AppConfig.Performance.MaxFreeSockets,
|
||
MaxConnsPerHost: 0, // 无限制，避免连接池瓶颈
|
||
IdleConnTimeout: 90 * time.Second,
|
||
TLSHandshakeTimeout: 10 * time.Second,
|
||
ExpectContinueTimeout: 1 * time.Second,
|
||
DisableCompression: config.AppConfig.Performance.DisableCompression,
|
||
ForceAttemptHTTP2: true,
|
||
WriteBufferSize: config.AppConfig.Performance.BufferSize,
|
||
ReadBufferSize: config.AppConfig.Performance.BufferSize,
|
||
}
|
||
|
||
// 创建专门用于流式传输的transport，优化TCP参数
|
||
streamTransport := &http.Transport{
|
||
MaxIdleConns: config.AppConfig.Performance.MaxSockets * 2,
|
||
MaxIdleConnsPerHost: config.AppConfig.Performance.MaxFreeSockets * 2,
|
||
MaxConnsPerHost: 0,
|
||
IdleConnTimeout: 300 * time.Second, // 流式连接保持更长时间
|
||
TLSHandshakeTimeout: 10 * time.Second,
|
||
ExpectContinueTimeout: 1 * time.Second,
|
||
DisableCompression: true, // 流式传输始终禁用压缩
|
||
ForceAttemptHTTP2: true,
|
||
WriteBufferSize: config.AppConfig.Performance.StreamBufferSize,
|
||
ReadBufferSize: config.AppConfig.Performance.StreamBufferSize,
|
||
ResponseHeaderTimeout: time.Duration(config.AppConfig.Performance.StreamHeaderTimeout) * time.Millisecond,
|
||
}
|
||
|
||
// 配置 Keep-Alive
|
||
if !config.AppConfig.Performance.EnableKeepAlive {
|
||
transport.DisableKeepAlives = true
|
||
streamTransport.DisableKeepAlives = true
|
||
}
|
||
|
||
httpClient := &http.Client{
|
||
Transport: transport,
|
||
// 移除全局超时，使用更细粒度的超时控制
|
||
// Timeout: time.Duration(config.AppConfig.OpenAI.Timeout) * time.Millisecond,
|
||
}
|
||
|
||
// 流式客户端不设置整体超时
|
||
streamClient := &http.Client{
|
||
Transport: streamTransport,
|
||
}
|
||
|
||
return &ProxyServer{
|
||
keyManager: keyManager,
|
||
httpClient: httpClient,
|
||
streamClient: streamClient,
|
||
upstreamURL: upstreamURL,
|
||
startTime: time.Now(),
|
||
}, nil
|
||
}
|
||
|
||
// SetupRoutes 设置路由
|
||
func (ps *ProxyServer) SetupRoutes() *gin.Engine {
|
||
// 设置Gin模式
|
||
gin.SetMode(gin.ReleaseMode)
|
||
|
||
router := gin.New()
|
||
|
||
// 自定义日志中间件
|
||
router.Use(ps.loggerMiddleware())
|
||
|
||
// 恢复中间件
|
||
router.Use(gin.Recovery())
|
||
|
||
// CORS中间件
|
||
if config.AppConfig.CORS.Enabled {
|
||
router.Use(ps.corsMiddleware())
|
||
}
|
||
|
||
// 认证中间件（如果启用）
|
||
if config.AppConfig.Auth.Enabled {
|
||
router.Use(ps.authMiddleware())
|
||
}
|
||
|
||
// 管理端点
|
||
router.GET("/health", ps.handleHealth)
|
||
router.GET("/stats", ps.handleStats)
|
||
router.GET("/blacklist", ps.handleBlacklist)
|
||
router.GET("/reset-keys", ps.handleResetKeys)
|
||
|
||
// 代理所有其他请求
|
||
router.NoRoute(ps.handleProxy)
|
||
|
||
return router
|
||
}
|
||
|
||
// corsMiddleware CORS中间件
|
||
func (ps *ProxyServer) corsMiddleware() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
origin := "*"
|
||
if len(config.AppConfig.CORS.AllowedOrigins) > 0 && config.AppConfig.CORS.AllowedOrigins[0] != "*" {
|
||
origin = strings.Join(config.AppConfig.CORS.AllowedOrigins, ",")
|
||
}
|
||
|
||
c.Header("Access-Control-Allow-Origin", origin)
|
||
c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
|
||
c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
|
||
c.Header("Access-Control-Max-Age", "86400")
|
||
|
||
if c.Request.Method == "OPTIONS" {
|
||
c.AbortWithStatus(http.StatusOK)
|
||
return
|
||
}
|
||
|
||
c.Next()
|
||
}
|
||
}
|
||
|
||
// authMiddleware 认证中间件
|
||
func (ps *ProxyServer) authMiddleware() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
// 管理端点不需要认证
|
||
if strings.HasPrefix(c.Request.URL.Path, "/health") ||
|
||
strings.HasPrefix(c.Request.URL.Path, "/stats") ||
|
||
strings.HasPrefix(c.Request.URL.Path, "/blacklist") ||
|
||
strings.HasPrefix(c.Request.URL.Path, "/reset-keys") {
|
||
c.Next()
|
||
return
|
||
}
|
||
|
||
authHeader := c.GetHeader("Authorization")
|
||
if authHeader == "" {
|
||
c.JSON(http.StatusUnauthorized, gin.H{
|
||
"error": gin.H{
|
||
"message": "未提供认证信息",
|
||
"type": "authentication_error",
|
||
"code": "missing_authorization",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
c.Abort()
|
||
return
|
||
}
|
||
|
||
if !strings.HasPrefix(authHeader, "Bearer ") {
|
||
c.JSON(http.StatusUnauthorized, gin.H{
|
||
"error": gin.H{
|
||
"message": "认证格式错误",
|
||
"type": "authentication_error",
|
||
"code": "invalid_authorization_format",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
c.Abort()
|
||
return
|
||
}
|
||
|
||
token := authHeader[7:] // 移除 "Bearer " 前缀
|
||
if token != config.AppConfig.Auth.Key {
|
||
c.JSON(http.StatusUnauthorized, gin.H{
|
||
"error": gin.H{
|
||
"message": "认证失败",
|
||
"type": "authentication_error",
|
||
"code": "invalid_authorization",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
c.Abort()
|
||
return
|
||
}
|
||
|
||
c.Next()
|
||
}
|
||
}
|
||
|
||
// loggerMiddleware 高性能日志中间件
|
||
func (ps *ProxyServer) loggerMiddleware() gin.HandlerFunc {
|
||
return func(c *gin.Context) {
|
||
// 检查是否启用请求日志
|
||
if !config.AppConfig.Log.EnableRequest {
|
||
// 不记录请求日志，只处理请求
|
||
c.Next()
|
||
// 只记录错误
|
||
if c.Writer.Status() >= 400 {
|
||
logrus.Errorf("Error %d: %s %s", c.Writer.Status(), c.Request.Method, c.Request.URL.Path)
|
||
}
|
||
return
|
||
}
|
||
|
||
start := time.Now()
|
||
path := c.Request.URL.Path
|
||
raw := c.Request.URL.RawQuery
|
||
|
||
// 处理请求
|
||
c.Next()
|
||
|
||
// 计算响应时间
|
||
latency := time.Since(start)
|
||
|
||
// 获取基本信息
|
||
method := c.Request.Method
|
||
statusCode := c.Writer.Status()
|
||
|
||
// 构建完整路径（避免字符串拼接）
|
||
fullPath := path
|
||
if raw != "" {
|
||
fullPath = path + "?" + raw
|
||
}
|
||
|
||
// 获取密钥信息（如果存在）
|
||
keyInfo := ""
|
||
if keyIndex, exists := c.Get("keyIndex"); exists {
|
||
if keyPreview, exists := c.Get("keyPreview"); exists {
|
||
keyInfo = fmt.Sprintf(" - Key[%v] %v", keyIndex, keyPreview)
|
||
}
|
||
}
|
||
|
||
// 获取重试信息（如果存在）
|
||
retryInfo := ""
|
||
if retryCount, exists := c.Get("retryCount"); exists {
|
||
retryInfo = fmt.Sprintf(" - Retry[%d]", retryCount)
|
||
}
|
||
|
||
// 过滤健康检查日志
|
||
if path == "/health" {
|
||
return
|
||
}
|
||
|
||
// 根据状态码选择日志级别
|
||
if statusCode >= 500 {
|
||
logrus.Errorf("%s %s - %d - %v%s%s", method, fullPath, statusCode, latency, keyInfo, retryInfo)
|
||
} else if statusCode >= 400 {
|
||
logrus.Warnf("%s %s - %d - %v%s%s", method, fullPath, statusCode, latency, keyInfo, retryInfo)
|
||
} else {
|
||
logrus.Infof("%s %s - %d - %v%s%s", method, fullPath, statusCode, latency, keyInfo, retryInfo)
|
||
}
|
||
}
|
||
}
|
||
|
||
// handleHealth 健康检查处理器
|
||
func (ps *ProxyServer) handleHealth(c *gin.Context) {
|
||
uptime := time.Since(ps.startTime)
|
||
stats := ps.keyManager.GetStats()
|
||
requestCount := atomic.LoadInt64(&ps.requestCount)
|
||
|
||
response := gin.H{
|
||
"status": "healthy",
|
||
"uptime": fmt.Sprintf("%.0fs", uptime.Seconds()),
|
||
"requestCount": requestCount,
|
||
"keysStatus": gin.H{
|
||
"total": stats.TotalKeys,
|
||
"healthy": stats.HealthyKeys,
|
||
"blacklisted": stats.BlacklistedKeys,
|
||
},
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
}
|
||
|
||
c.JSON(http.StatusOK, response)
|
||
}
|
||
|
||
// handleStats 统计信息处理器
|
||
func (ps *ProxyServer) handleStats(c *gin.Context) {
|
||
uptime := time.Since(ps.startTime)
|
||
stats := ps.keyManager.GetStats()
|
||
requestCount := atomic.LoadInt64(&ps.requestCount)
|
||
|
||
response := gin.H{
|
||
"server": gin.H{
|
||
"uptime": fmt.Sprintf("%.0fs", uptime.Seconds()),
|
||
"requestCount": requestCount,
|
||
"startTime": ps.startTime.Format(time.RFC3339),
|
||
"version": "2.0.0",
|
||
},
|
||
"keys": stats,
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
}
|
||
|
||
c.JSON(http.StatusOK, response)
|
||
}
|
||
|
||
// handleBlacklist 黑名单处理器
|
||
func (ps *ProxyServer) handleBlacklist(c *gin.Context) {
|
||
blacklistInfo := ps.keyManager.GetBlacklistDetails()
|
||
c.JSON(http.StatusOK, blacklistInfo)
|
||
}
|
||
|
||
// handleResetKeys 重置密钥处理器
|
||
func (ps *ProxyServer) handleResetKeys(c *gin.Context) {
|
||
result := ps.keyManager.ResetKeys()
|
||
c.JSON(http.StatusOK, result)
|
||
}
|
||
|
||
// handleProxy 代理请求处理器
|
||
func (ps *ProxyServer) handleProxy(c *gin.Context) {
|
||
startTime := time.Now()
|
||
|
||
// 增加请求计数
|
||
atomic.AddInt64(&ps.requestCount, 1)
|
||
|
||
// 统一入口，提前缓存所有请求体
|
||
var bodyBytes []byte
|
||
if c.Request.Body != nil {
|
||
var err error
|
||
bodyBytes, err = io.ReadAll(c.Request.Body)
|
||
if err != nil {
|
||
logrus.Errorf("读取请求体失败: %v", err)
|
||
c.JSON(http.StatusBadRequest, gin.H{
|
||
"error": gin.H{
|
||
"message": "读取请求体失败",
|
||
"type": "request_error",
|
||
"code": "invalid_request_body",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
return
|
||
}
|
||
}
|
||
|
||
// 使用缓存后的数据判断请求类型
|
||
isStreamRequest := ps.isStreamRequest(bodyBytes, c)
|
||
|
||
// 执行带重试的请求
|
||
ps.executeRequestWithRetry(c, startTime, bodyBytes, isStreamRequest, 0, nil)
|
||
}
|
||
|
||
// isStreamRequest 判断是否为流式请求
|
||
func (ps *ProxyServer) isStreamRequest(bodyBytes []byte, c *gin.Context) bool {
|
||
// 检查 Accept header
|
||
if strings.Contains(c.GetHeader("Accept"), "text/event-stream") {
|
||
return true
|
||
}
|
||
|
||
// 检查 URL 查询参数
|
||
if c.Query("stream") == "true" {
|
||
return true
|
||
}
|
||
|
||
// 检查请求体中的 stream 参数
|
||
if len(bodyBytes) > 0 {
|
||
if strings.Contains(string(bodyBytes), `"stream":true`) ||
|
||
strings.Contains(string(bodyBytes), `"stream": true`) {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
// executeRequestWithRetry 执行带重试的请求
|
||
func (ps *ProxyServer) executeRequestWithRetry(c *gin.Context, startTime time.Time, bodyBytes []byte, isStreamRequest bool, retryCount int, retryErrors []RetryError) {
|
||
// 获取密钥信息
|
||
keyInfo, err := ps.keyManager.GetNextKey()
|
||
if err != nil {
|
||
logrus.Errorf("获取密钥失败: %v", err)
|
||
c.JSON(http.StatusInternalServerError, gin.H{
|
||
"error": gin.H{
|
||
"message": "服务器内部错误: " + err.Error(),
|
||
"type": "server_error",
|
||
"code": "no_keys_available",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
return
|
||
}
|
||
|
||
// 设置密钥信息到上下文（用于日志）
|
||
c.Set("keyIndex", keyInfo.Index)
|
||
c.Set("keyPreview", keyInfo.Preview)
|
||
|
||
// 设置重试信息到上下文
|
||
if retryCount > 0 {
|
||
c.Set("retryCount", retryCount)
|
||
}
|
||
|
||
// 构建上游请求URL
|
||
targetURL := *ps.upstreamURL
|
||
// 正确拼接路径，而不是替换路径
|
||
if strings.HasSuffix(targetURL.Path, "/") {
|
||
targetURL.Path = targetURL.Path + strings.TrimPrefix(c.Request.URL.Path, "/")
|
||
} else {
|
||
targetURL.Path = targetURL.Path + c.Request.URL.Path
|
||
}
|
||
targetURL.RawQuery = c.Request.URL.RawQuery
|
||
|
||
// 为流式和非流式请求使用不同的超时策略
|
||
var ctx context.Context
|
||
var cancel context.CancelFunc
|
||
|
||
if isStreamRequest {
|
||
// 流式请求只设置响应头超时，不设置整体超时
|
||
ctx, cancel = context.WithCancel(c.Request.Context())
|
||
} else {
|
||
// 非流式请求使用配置的超时
|
||
timeout := time.Duration(config.AppConfig.OpenAI.Timeout) * time.Millisecond
|
||
ctx, cancel = context.WithTimeout(c.Request.Context(), timeout)
|
||
}
|
||
defer cancel()
|
||
|
||
// 统一使用缓存的 bodyBytes 创建请求
|
||
req, err := http.NewRequestWithContext(
|
||
ctx,
|
||
c.Request.Method,
|
||
targetURL.String(),
|
||
bytes.NewReader(bodyBytes),
|
||
)
|
||
if err != nil {
|
||
logrus.Errorf("创建上游请求失败: %v", err)
|
||
c.JSON(http.StatusInternalServerError, gin.H{
|
||
"error": gin.H{
|
||
"message": "创建上游请求失败",
|
||
"type": "proxy_error",
|
||
"code": "request_creation_failed",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
},
|
||
})
|
||
return
|
||
}
|
||
req.ContentLength = int64(len(bodyBytes))
|
||
|
||
// 复制请求头
|
||
for key, values := range c.Request.Header {
|
||
if key != "Host" {
|
||
for _, value := range values {
|
||
req.Header.Add(key, value)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 设置认证头
|
||
req.Header.Set("Authorization", "Bearer "+keyInfo.Key)
|
||
|
||
// 根据请求类型选择合适的客户端
|
||
var client *http.Client
|
||
if isStreamRequest {
|
||
client = ps.streamClient
|
||
// 添加禁用nginx缓冲的头
|
||
req.Header.Set("X-Accel-Buffering", "no")
|
||
} else {
|
||
client = ps.httpClient
|
||
}
|
||
|
||
// 发送请求
|
||
resp, err := client.Do(req)
|
||
if err != nil {
|
||
responseTime := time.Since(startTime)
|
||
|
||
// 记录失败日志
|
||
if retryCount > 0 {
|
||
logrus.Debugf("重试请求失败 (第 %d 次): %v (响应时间: %v)", retryCount, err, responseTime)
|
||
} else {
|
||
logrus.Debugf("首次请求失败: %v (响应时间: %v)", err, responseTime)
|
||
}
|
||
|
||
// 异步记录失败
|
||
go ps.keyManager.RecordFailure(keyInfo.Key, err)
|
||
|
||
// 记录重试错误信息
|
||
if retryErrors == nil {
|
||
retryErrors = make([]RetryError, 0)
|
||
}
|
||
retryErrors = append(retryErrors, RetryError{
|
||
StatusCode: 0, // 网络错误，没有HTTP状态码
|
||
ErrorMessage: err.Error(),
|
||
KeyIndex: keyInfo.Index,
|
||
Attempt: retryCount + 1,
|
||
})
|
||
|
||
// 检查是否可以重试
|
||
if retryCount < config.AppConfig.Keys.MaxRetries {
|
||
logrus.Debugf("准备重试请求 (第 %d/%d 次)", retryCount+1, config.AppConfig.Keys.MaxRetries)
|
||
ps.executeRequestWithRetry(c, startTime, bodyBytes, isStreamRequest, retryCount+1, retryErrors)
|
||
return
|
||
}
|
||
|
||
// 达到最大重试次数，记录最终失败并返回详细的重试信息
|
||
logrus.Infof("请求最终失败，已重试 %d 次，总响应时间: %v", retryCount, responseTime)
|
||
ps.returnRetryFailureResponse(c, retryCount, retryErrors)
|
||
return
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
responseTime := time.Since(startTime)
|
||
|
||
// 检查HTTP状态码是否需要重试
|
||
// 429 (Too Many Requests) 和 5xx 服务器错误都需要重试
|
||
if resp.StatusCode == 429 || resp.StatusCode >= 500 {
|
||
// 记录失败日志
|
||
if retryCount > 0 {
|
||
logrus.Debugf("重试请求返回错误 %d (第 %d 次) (响应时间: %v)", resp.StatusCode, retryCount, responseTime)
|
||
} else {
|
||
logrus.Debugf("首次请求返回错误 %d (响应时间: %v)", resp.StatusCode, responseTime)
|
||
}
|
||
|
||
// 读取响应体以获取错误信息
|
||
var errorMessage string
|
||
if bodyBytes, err := io.ReadAll(resp.Body); err == nil {
|
||
errorMessage = string(bodyBytes)
|
||
} else {
|
||
errorMessage = fmt.Sprintf("HTTP %d", resp.StatusCode)
|
||
}
|
||
|
||
// 异步记录失败
|
||
go ps.keyManager.RecordFailure(keyInfo.Key, fmt.Errorf("HTTP %d", resp.StatusCode))
|
||
|
||
// 记录重试错误信息
|
||
if retryErrors == nil {
|
||
retryErrors = make([]RetryError, 0)
|
||
}
|
||
retryErrors = append(retryErrors, RetryError{
|
||
StatusCode: resp.StatusCode,
|
||
ErrorMessage: errorMessage,
|
||
KeyIndex: keyInfo.Index,
|
||
Attempt: retryCount + 1,
|
||
})
|
||
|
||
// 关闭当前响应
|
||
resp.Body.Close()
|
||
|
||
// 检查是否可以重试
|
||
if retryCount < config.AppConfig.Keys.MaxRetries {
|
||
logrus.Debugf("准备重试请求 (第 %d/%d 次)", retryCount+1, config.AppConfig.Keys.MaxRetries)
|
||
ps.executeRequestWithRetry(c, startTime, bodyBytes, isStreamRequest, retryCount+1, retryErrors)
|
||
return
|
||
}
|
||
|
||
// 达到最大重试次数，记录最终失败并返回详细的重试信息
|
||
logrus.Infof("请求最终失败，已重试 %d 次，最后状态码: %d，总响应时间: %v", retryCount, resp.StatusCode, responseTime)
|
||
ps.returnRetryFailureResponse(c, retryCount, retryErrors)
|
||
return
|
||
}
|
||
|
||
// 记录最终成功的日志
|
||
if len(retryErrors) > 0 {
|
||
logrus.Debugf("请求最终成功，经过 %d 次重试，状态码: %d，总响应时间: %v", len(retryErrors), resp.StatusCode, responseTime)
|
||
}
|
||
|
||
// 异步记录统计信息（不阻塞响应）
|
||
go func() {
|
||
if resp.StatusCode >= 200 && resp.StatusCode < 400 {
|
||
ps.keyManager.RecordSuccess(keyInfo.Key)
|
||
} else if resp.StatusCode >= 400 {
|
||
ps.keyManager.RecordFailure(keyInfo.Key, fmt.Errorf("HTTP %d", resp.StatusCode))
|
||
}
|
||
}()
|
||
|
||
// 复制响应头
|
||
for key, values := range resp.Header {
|
||
for _, value := range values {
|
||
c.Header(key, value)
|
||
}
|
||
}
|
||
|
||
// 流式响应添加禁用缓冲的头
|
||
if isStreamRequest {
|
||
c.Header("Cache-Control", "no-cache")
|
||
c.Header("Connection", "keep-alive")
|
||
c.Header("X-Accel-Buffering", "no")
|
||
}
|
||
|
||
// 设置状态码
|
||
c.Status(resp.StatusCode)
|
||
|
||
// 优化流式响应传输
|
||
if isStreamRequest {
|
||
ps.handleStreamResponse(c, resp.Body)
|
||
} else {
|
||
// 非流式响应：使用标准零拷贝
|
||
_, err = io.Copy(c.Writer, resp.Body)
|
||
if err != nil {
|
||
logrus.Errorf("复制响应体失败: %v (响应时间: %v)", err, responseTime)
|
||
}
|
||
}
|
||
}
|
||
|
||
// returnRetryFailureResponse 返回重试失败的详细响应
|
||
func (ps *ProxyServer) returnRetryFailureResponse(c *gin.Context, retryCount int, retryErrors []RetryError) {
|
||
// 获取最后一次错误作为主要错误
|
||
var lastError RetryError
|
||
var lastStatusCode int = http.StatusBadGateway
|
||
|
||
if len(retryErrors) > 0 {
|
||
lastError = retryErrors[len(retryErrors)-1]
|
||
if lastError.StatusCode > 0 {
|
||
lastStatusCode = lastError.StatusCode
|
||
}
|
||
}
|
||
|
||
// 构建详细的错误响应
|
||
errorResponse := gin.H{
|
||
"error": gin.H{
|
||
"message": fmt.Sprintf("请求失败，已重试 %d 次", retryCount),
|
||
"type": "proxy_error",
|
||
"code": "max_retries_exceeded",
|
||
"timestamp": time.Now().Format(time.RFC3339),
|
||
"retry_count": retryCount,
|
||
"retry_details": retryErrors,
|
||
},
|
||
}
|
||
|
||
// 如果最后一次错误有具体的错误信息，尝试解析并包含
|
||
if lastError.ErrorMessage != "" && lastError.StatusCode > 0 {
|
||
// 尝试解析上游的JSON错误响应
|
||
if strings.Contains(lastError.ErrorMessage, "{") {
|
||
errorResponse["upstream_error"] = lastError.ErrorMessage
|
||
} else {
|
||
errorResponse["upstream_message"] = lastError.ErrorMessage
|
||
}
|
||
}
|
||
|
||
c.JSON(lastStatusCode, errorResponse)
|
||
}
|
||
|
||
// handleStreamResponse 处理流式响应
|
||
func (ps *ProxyServer) handleStreamResponse(c *gin.Context, body io.ReadCloser) {
|
||
defer body.Close()
|
||
|
||
flusher, ok := c.Writer.(http.Flusher)
|
||
if !ok {
|
||
// 降级到标准复制
|
||
_, err := io.Copy(c.Writer, body)
|
||
if err != nil {
|
||
logrus.Errorf("复制流式响应失败: %v", err)
|
||
}
|
||
return
|
||
}
|
||
|
||
// 实现零缓存、实时转发
|
||
copyDone := make(chan bool)
|
||
|
||
// 检查客户端连接状态
|
||
ctx := c.Request.Context()
|
||
|
||
// 在一个独立的goroutine中定期flush，确保数据被立即发送
|
||
go func() {
|
||
defer func() {
|
||
// 防止panic
|
||
if r := recover(); r != nil {
|
||
logrus.Errorf("Flush goroutine panic: %v", r)
|
||
}
|
||
}()
|
||
|
||
ticker := time.NewTicker(50 * time.Millisecond)
|
||
defer ticker.Stop()
|
||
|
||
for {
|
||
select {
|
||
case <-copyDone:
|
||
// io.Copy完成后，执行最后一次flush并退出
|
||
ps.safeFlush(flusher)
|
||
return
|
||
case <-ctx.Done():
|
||
// 客户端断开连接，停止flush
|
||
return
|
||
case <-ticker.C:
|
||
ps.safeFlush(flusher)
|
||
}
|
||
}
|
||
}()
|
||
|
||
// 使用io.Copy进行高效的数据复制
|
||
_, err := io.Copy(c.Writer, body)
|
||
|
||
// 安全地关闭channel
|
||
select {
|
||
case <-copyDone:
|
||
// channel已经关闭
|
||
default:
|
||
close(copyDone) // 通知flush的goroutine可以停止了
|
||
}
|
||
|
||
if err != nil && err != io.EOF {
|
||
// 检查是否是连接断开导致的错误
|
||
if ps.isConnectionError(err) {
|
||
logrus.Debugf("客户端连接断开: %v", err)
|
||
} else {
|
||
logrus.Errorf("复制流式响应失败: %v", err)
|
||
}
|
||
}
|
||
}
|
||
|
||
// safeFlush 安全地执行flush操作
|
||
func (ps *ProxyServer) safeFlush(flusher http.Flusher) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
// 忽略flush时的panic，通常是因为连接已断开
|
||
logrus.Debugf("Flush panic (connection likely closed): %v", r)
|
||
}
|
||
}()
|
||
|
||
if flusher != nil {
|
||
flusher.Flush()
|
||
}
|
||
}
|
||
|
||
// isConnectionError 检查是否是连接相关的错误
|
||
func (ps *ProxyServer) isConnectionError(err error) bool {
|
||
if err == nil {
|
||
return false
|
||
}
|
||
|
||
errStr := err.Error()
|
||
// 常见的连接断开错误
|
||
connectionErrors := []string{
|
||
"broken pipe",
|
||
"connection reset by peer",
|
||
"connection aborted",
|
||
"client disconnected",
|
||
"write: broken pipe",
|
||
"use of closed network connection",
|
||
"context canceled",
|
||
"short write",
|
||
"context deadline exceeded",
|
||
}
|
||
|
||
for _, connErr := range connectionErrors {
|
||
if strings.Contains(errStr, connErr) {
|
||
return true
|
||
}
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
// Close 关闭代理服务器
|
||
func (ps *ProxyServer) Close() {
|
||
if ps.keyManager != nil {
|
||
ps.keyManager.Close()
|
||
}
|
||
}
|