609 lines
16 KiB
Go
609 lines
16 KiB
Go
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")
|
|
}
|
|
}
|