从Volcano-Engine-TTS迁移的原文件，后续将为其适配UI

2026-05-09 17:06:41 +08:00
commit 7c6e6af08a
6 changed files with 1080 additions and 0 deletions
@@ -0,0 +1,608 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/gorilla/mux"
+)
+
+// TTSServResponse response from backend srvs
+type TTSServResponse struct {
+	ReqID     string `json:"reqid"`
+	Code      int    `json:"code"`
+	Message   string `json:"Message"`
+	Operation string `json:"operation"`
+	Sequence  int    `json:"sequence"`
+	Data      string `json:"data"`
+}
+
+// OpenAI TTS API请求格式
+type OpenAITTSRequest struct {
+	Model          string  `json:"model"`
+	Input          string  `json:"input"`
+	Voice          string  `json:"voice"`
+	ResponseFormat string  `json:"response_format,omitempty"`
+	Speed          float64 `json:"speed,omitempty"`
+}
+
+// 字节跳动TTS配置
+type ByteDanceTTSConfig struct {
+	AppID       string
+	BearerToken string
+	Cluster     string
+	URL         string
+	VoiceType   string
+	Timeout     time.Duration
+}
+
+// API密钥配置
+var VALID_API_KEY string
+
+// 全局配置
+var ttsConfig ByteDanceTTSConfig
+
+// 初始化字节跳动TTS配置
+func initTTSConfig() {
+	missingVars := []string{}
+	
+	// 读取必须的环境变量
+	appID := os.Getenv("BYTEDANCE_TTS_APP_ID")
+	if appID == "" {
+		missingVars = append(missingVars, "BYTEDANCE_TTS_APP_ID")
+	}
+	
+bearerToken := os.Getenv("BYTEDANCE_TTS_BEARER_TOKEN")
+	if bearerToken == "" {
+		missingVars = append(missingVars, "BYTEDANCE_TTS_BEARER_TOKEN")
+	}
+	
+	cluster := os.Getenv("BYTEDANCE_TTS_CLUSTER")
+	if cluster == "" {
+		missingVars = append(missingVars, "BYTEDANCE_TTS_CLUSTER")
+	}
+	
+	voiceType := os.Getenv("BYTEDANCE_TTS_VOICE_TYPE")
+	if voiceType == "" {
+		missingVars = append(missingVars, "BYTEDANCE_TTS_VOICE_TYPE")
+	}
+	
+	// 如果有缺失的必须变量，输出错误信息并使用默认值继续运行（但可能会导致功能失败）
+	if len(missingVars) > 0 {
+		log.Printf("警告: 缺少以下必须的环境变量: %v", missingVars)
+		log.Printf("请设置这些环境变量以确保服务正常工作")
+		
+		// 使用默认值以便服务能够启动
+		if appID == "" {
+			appID = "8877631864"
+		}
+		if bearerToken == "" {
+			bearerToken = "IZFPVWC5rVIoR5vRYyc21BdJI0qNanse"
+		}
+		if cluster == "" {
+			cluster = "volcano_icl"
+		}
+		if voiceType == "" {
+			voiceType = "S_JuVo3sao1"
+		}
+	}
+	
+	// 读取可选的环境变量，使用默认值如果未设置
+	url := os.Getenv("BYTEDANCE_TTS_ENDPOINT")
+	if url == "" {
+		url = "https://openspeech.bytedance.com/api/v1/tts"
+	} else {
+		log.Printf("使用自定义字节跳动TTS端点: %s", url)
+	}
+		timeoutStr := os.Getenv("BYTEDANCE_TTS_TIMEOUT")
+	timeout := 30 * time.Second
+	if timeoutStr != "" {
+		if parsedTimeout, err := time.ParseDuration(timeoutStr); err == nil {
+			timeout = parsedTimeout
+			log.Printf("使用自定义超时设置: %v", timeout)
+		} else {
+			log.Printf("无效的超时设置 '%s'，使用默认值30s", timeoutStr)
+		}
+	}
+	
+	// 设置配置
+	ttsConfig = ByteDanceTTSConfig{
+		AppID:       appID,
+		BearerToken: bearerToken,
+		Cluster:     cluster,
+		URL:         url,
+		VoiceType:   voiceType,
+		Timeout:     timeout,
+	}
+}
+
+// 检查环境变量配置状态
+func checkEnvironmentVariables() map[string]interface{} {
+	// 检查必要的环境变量是否已设置
+	requiredVars := map[string]bool{
+		"BYTEDANCE_TTS_APP_ID":       os.Getenv("BYTEDANCE_TTS_APP_ID") != "",
+		"BYTEDANCE_TTS_BEARER_TOKEN": os.Getenv("BYTEDANCE_TTS_BEARER_TOKEN") != "",
+		"BYTEDANCE_TTS_CLUSTER":     os.Getenv("BYTEDANCE_TTS_CLUSTER") != "",
+		"BYTEDANCE_TTS_VOICE_TYPE":  os.Getenv("BYTEDANCE_TTS_VOICE_TYPE") != "",
+	}
+	
+	missingVars := []string{}
+	for varName, isSet := range requiredVars {
+		if !isSet {
+			missingVars = append(missingVars, varName)
+		}
+	}
+	
+	// 检查可选的环境变量是否已设置
+	optionalVars := map[string]bool{
+		"BYTEDANCE_TTS_ENDPOINT": os.Getenv("BYTEDANCE_TTS_ENDPOINT") != "",
+		"BYTEDANCE_TTS_TIMEOUT":  os.Getenv("BYTEDANCE_TTS_TIMEOUT") != "",
+		"OPENAI_TTS_API_KEY":     os.Getenv("OPENAI_TTS_API_KEY") != "",
+		"PORT":                   os.Getenv("PORT") != "",
+	}
+	
+	// 构建配置状态响应
+	return map[string]interface{}{
+		"all_required_vars_set": len(missingVars) == 0,
+		"missing_required_vars": missingVars,
+		"required_vars":        requiredVars, // 只显示是否设置，不显示具体值
+		"optional_vars":        optionalVars, // 只显示是否设置，不显示具体值
+	}
+}
+
+
+
+func httpPost(url string, headers map[string]string, body []byte, timeout time.Duration) ([]byte, error) {
+	client := &http.Client{
+		Timeout: timeout,
+	}
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(body))
+	if err != nil {
+		return nil, err
+	}
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	retBody, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	return retBody, err
+}
+
+func synthesis(text string, speed float64) ([]byte, error) {
+	reqID := uuid.NewString()
+	params := make(map[string]map[string]interface{})
+	params["app"] = make(map[string]interface{})
+	params["app"]["appid"] = ttsConfig.AppID
+	params["app"]["token"] = "access_token"
+	params["app"]["cluster"] = ttsConfig.Cluster
+
+	params["user"] = make(map[string]interface{})
+	params["user"]["uid"] = "uid"
+
+	params["audio"] = make(map[string]interface{})
+	params["audio"]["voice_type"] = ttsConfig.VoiceType
+	params["audio"]["encoding"] = "wav"
+
+	// 处理语速参数
+	if speed <= 0 {
+		speed = 1.0
+	}
+	params["audio"]["speed_ratio"] = speed
+	params["audio"]["volume_ratio"] = 1.0
+	params["audio"]["pitch_ratio"] = 1.0
+
+	params["request"] = make(map[string]interface{})
+	params["request"]["reqid"] = reqID
+	params["request"]["text"] = text
+	params["request"]["text_type"] = "plain"
+	params["request"]["operation"] = "query"
+
+	headers := make(map[string]string)
+	headers["Content-Type"] = "application/json"
+	headers["Authorization"] = fmt.Sprintf("Bearer;%s", ttsConfig.BearerToken)
+
+	bodyStr, _ := json.Marshal(params)
+	synResp, err := httpPost(ttsConfig.URL, headers, []byte(bodyStr), ttsConfig.Timeout)
+	if err != nil {
+		log.Printf("http post fail [err:%s]\n", err.Error())
+		return nil, err
+	}
+
+	var respJSON TTSServResponse
+	err = json.Unmarshal(synResp, &respJSON)
+	if err != nil {
+		log.Printf("unmarshal response fail [err:%s]\n", err.Error())
+		return nil, err
+	}
+
+	if respJSON.Code != 3000 {
+		log.Printf("code fail [code:%d, message:%s]\n", respJSON.Code, respJSON.Message)
+		return nil, fmt.Errorf("TTS service error: code %d, message: %s", respJSON.Code, respJSON.Message)
+	}
+
+	audio, err := base64.StdEncoding.DecodeString(respJSON.Data)
+	if err != nil {
+		log.Printf("base64 decode fail [err:%s]\n", err.Error())
+		return nil, err
+	}
+	return audio, nil
+}
+
+// 验证API密钥
+func validateAPIKey(r *http.Request) bool {
+	// 当VALID_API_KEY为空时，允许任何API密钥通过验证
+	if VALID_API_KEY == "" {
+		return true
+	}
+
+	// 从 Authorization header 中获取 Bearer token
+	authHeader := r.Header.Get("Authorization")
+	if authHeader == "" {
+		return false
+	}
+
+	// 检查是否以 "Bearer " 开头
+	if !strings.HasPrefix(authHeader, "Bearer ") {
+		return false
+	}
+
+	// 提取token
+	token := strings.TrimPrefix(authHeader, "Bearer ")
+	return token == VALID_API_KEY
+}
+
+// OpenAI TTS API兼容端点
+func openaiTTSHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// 验证API密钥
+	if !validateAPIKey(r) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusUnauthorized)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"error": map[string]interface{}{
+				"message": "Invalid API key provided.",
+				"type":    "invalid_request_error",
+				"code":    "invalid_api_key",
+			},
+		})
+		return
+	}
+
+	var req OpenAITTSRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid JSON", http.StatusBadRequest)
+		return
+	}
+
+	if req.Input == "" {
+		http.Error(w, "Input text is required", http.StatusBadRequest)
+		return
+	}
+
+	// 设置默认语速
+	speed := req.Speed
+	if speed <= 0 {
+		speed = 1.0
+	}
+
+	// 调用字节跳动TTS
+	ttsStart := time.Now()
+	audioData, err := synthesis(req.Input, speed)
+	// 记录TTS处理时间
+	_ = time.Since(ttsStart)
+
+	if err != nil {
+		log.Printf("TTS synthesis failed: %v", err)
+		http.Error(w, "TTS synthesis failed", http.StatusInternalServerError)
+		return
+	}
+
+	// 设置响应头
+	w.Header().Set("Content-Type", "audio/wav")
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(audioData)))
+
+	// 返回音频数据
+	w.WriteHeader(http.StatusOK)
+	w.Write(audioData)
+}
+
+// 统计数据结构体
+type Stats struct {
+	totalRequests       int64
+	successfulRequests  int64
+	failedRequests      int64
+	totalResponseTime   time.Duration
+	recentResponseTimes []float64
+	maxRecentResponses  int
+	lastErrors          []string
+	maxLastErrors       int
+	mutex               sync.RWMutex
+}
+
+// API调用统计
+var apiStats = &Stats{
+	recentResponseTimes: make([]float64, 0, 100),
+	maxRecentResponses:  100,
+	lastErrors:          make([]string, 0, 10),
+	maxLastErrors:       10,
+}
+
+// 添加请求统计
+func addRequestStats(success bool, responseTime time.Duration, errMsg string) {
+	apiStats.mutex.Lock()
+	defer apiStats.mutex.Unlock()
+
+	apiStats.totalRequests++
+	apiStats.totalResponseTime += responseTime
+
+	// 添加到最近响应时间数组
+	apiStats.recentResponseTimes = append(apiStats.recentResponseTimes, responseTime.Seconds()*1000) // 转换为毫秒
+	if len(apiStats.recentResponseTimes) > apiStats.maxRecentResponses {
+		apiStats.recentResponseTimes = apiStats.recentResponseTimes[1:]
+	}
+
+	if success {
+		apiStats.successfulRequests++
+	} else {
+		apiStats.failedRequests++
+		// 添加到最近错误数组
+		if errMsg != "" {
+			errInfo := fmt.Sprintf("%s: %s", time.Now().Format(time.RFC3339), errMsg)
+			apiStats.lastErrors = append(apiStats.lastErrors, errInfo)
+			if len(apiStats.lastErrors) > apiStats.maxLastErrors {
+				apiStats.lastErrors = apiStats.lastErrors[1:]
+			}
+		}
+	}
+}
+
+// 获取内存信息
+func getMemoryInfo() map[string]uint64 {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	return map[string]uint64{
+		"total":      m.Sys,
+		"allocated":  m.Alloc,
+		"available":  m.Sys - m.Alloc,
+		"goroutines": uint64(runtime.NumGoroutine()),
+	}
+}
+
+// 获取网络信息
+func getNetworkInfo() map[string]interface{} {
+	ifaces, err := net.Interfaces()
+	if err != nil {
+		return map[string]interface{}{
+			"error": err.Error(),
+		}
+	}
+
+	interfaces := make([]map[string]interface{}, 0, len(ifaces))
+	for _, iface := range ifaces {
+		addrs, _ := iface.Addrs()
+		addresses := make([]string, 0, len(addrs))
+		for _, addr := range addrs {
+			addresses = append(addresses, addr.String())
+		}
+		interfaces = append(interfaces, map[string]interface{}{
+			"name":      iface.Name,
+			"mac":       iface.HardwareAddr.String(),
+			"addresses": addresses,
+			"up":        (iface.Flags & net.FlagUp) != 0,
+		})
+	}
+
+	return map[string]interface{}{
+		"interfaces": interfaces,
+	}
+}
+
+// 健康检查端点
+func healthHandler(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+
+	// 收集统计数据
+	apiStats.mutex.RLock()
+	totalRequests := apiStats.totalRequests
+	successfulRequests := apiStats.successfulRequests
+	failedRequests := apiStats.failedRequests
+	totalResponseTime := apiStats.totalResponseTime
+	recentResponseTimes := make([]float64, len(apiStats.recentResponseTimes))
+	copy(recentResponseTimes, apiStats.recentResponseTimes)
+	lastErrors := make([]string, len(apiStats.lastErrors))
+	copy(lastErrors, apiStats.lastErrors)
+	apiStats.mutex.RUnlock()
+
+	// 计算错误率
+	var errorRate float64
+	if totalRequests > 0 {
+		errorRate = float64(failedRequests) / float64(totalRequests) * 100
+	}
+
+	// 计算平均响应时间
+	var avgResponseTime float64
+	if totalRequests > 0 {
+		avgResponseTime = totalResponseTime.Seconds() * 1000 / float64(totalRequests) // 毫秒
+	}
+
+	// 检查环境变量配置
+	envCheckStatus := checkEnvironmentVariables()
+	allEnvVarsSet := envCheckStatus["all_required_vars_set"].(bool)
+	
+	// 确定服务状态
+	status := "ok"
+	if !allEnvVarsSet {
+		status = "configuration_error"
+	}
+
+	// 构建响应
+	response := map[string]interface{}{
+		"status":     status,
+		"service":    "ByteDance TTS to OpenAI API Adapter",
+		"version":    "1.0.0",
+		"uptime":     fmt.Sprintf("%.0f seconds", time.Since(startTime).Seconds()),
+		"start_time": startTime.Format(time.RFC3339),
+		"pid":        os.Getpid(),
+		"memory":     getMemoryInfo(),
+		"network":    getNetworkInfo(),
+		"api_stats": map[string]interface{}{
+			"total_requests":           totalRequests,
+			"successful_requests":      successfulRequests,
+			"failed_requests":          failedRequests,
+			"error_rate":               fmt.Sprintf("%.2f%%", errorRate),
+			"avg_response_time_ms":     fmt.Sprintf("%.2f", avgResponseTime),
+			"recent_response_times_ms": recentResponseTimes,
+			"concurrent_requests":      runtime.NumGoroutine() - 1, // 减去健康检查本身的goroutine
+		},
+		"errors": map[string]interface{}{
+			"recent_errors": lastErrors,
+		},
+		"config_status": envCheckStatus,
+	}
+
+	json.NewEncoder(w).Encode(response)
+}
+
+var startTime time.Time
+
+// 自定义ResponseWriter以捕获状态码
+type statusRecorder struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (rec *statusRecorder) WriteHeader(code int) {
+	rec.statusCode = code
+	rec.ResponseWriter.WriteHeader(code)
+}
+
+func main() {
+	startTime = time.Now()
+
+	// 从环境变量读取API密钥，当环境变量未设置时，设为空字符串（允许任意key）
+	VALID_API_KEY = os.Getenv("OPENAI_TTS_API_KEY")
+	if VALID_API_KEY == "" {
+		log.Println("Warning: OPENAI_TTS_API_KEY environment variable not set. All API keys will be accepted.")
+	}
+	
+	// 初始化字节跳动TTS配置
+	initTTSConfig()
+
+	// 设置日志格式
+	log.SetFlags(log.LstdFlags | log.Lshortfile)
+	log.SetPrefix("[TTS-Server] ")
+
+	router := mux.NewRouter()
+
+	// 添加中间件：请求日志和统计
+	router.Use(func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			// 跳过健康检查的统计，避免递归
+			if r.URL.Path == "/health" {
+				start := time.Now()
+				next.ServeHTTP(w, r)
+				log.Printf("%s %s %s %v", r.Method, r.RequestURI, r.RemoteAddr, time.Since(start))
+				return
+			}
+
+			start := time.Now()
+			rec := &statusRecorder{ResponseWriter: w, statusCode: http.StatusOK}
+			next.ServeHTTP(rec, r)
+			duration := time.Since(start)
+
+			// 记录日志
+			log.Printf("%s %s %s %d %v", r.Method, r.RequestURI, r.RemoteAddr, rec.statusCode, duration)
+
+			// 更新统计
+			success := rec.statusCode >= 200 && rec.statusCode < 400
+			errMsg := ""
+			if !success {
+				errMsg = fmt.Sprintf("HTTP %d", rec.statusCode)
+			}
+			addRequestStats(success, duration, errMsg)
+		})
+	})
+
+	// OpenAI TTS API兼容端点
+	router.HandleFunc("/v1/audio/speech", openaiTTSHandler).Methods("POST")
+
+	// 健康检查
+	router.HandleFunc("/health", healthHandler).Methods("GET")
+
+	// 根路径重定向到健康检查
+	router.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		http.Redirect(w, r, "/health", http.StatusFound)
+	}).Methods("GET")
+
+	port := ":8080"
+	// 从环境变量获取端口配置
+	if envPort := os.Getenv("PORT"); envPort != "" {
+		port = ":" + envPort
+	}
+
+	server := &http.Server{
+		Addr:         port,
+		Handler:      router,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	// 创建一个通道来接收系统信号
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 在goroutine中启动服务器
+	go func() {
+		log.Printf("Starting ByteDance TTS to OpenAI API adapter server on port %s", port)
+		log.Printf("OpenAI TTS endpoint: http://localhost%s/v1/audio/speech", port)
+		log.Printf("Health check: http://localhost%s/health", port)
+		log.Printf("PID: %d", os.Getpid())
+
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("Server failed to start: %v", err)
+		}
+	}()
+
+	// 等待信号
+	<-quit
+	log.Println("Shutting down server...")
+
+	// 创建一个5秒的超时上下文
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	// 优雅关闭服务器
+	if err := server.Shutdown(ctx); err != nil {
+		log.Printf("Server forced to shutdown: %v", err)
+	} else {
+		log.Println("Server exited gracefully")
+	}
+}