mirror of
https://github.com/Wei-Shaw/sub2api.git
synced 2026-11-20 15:06:36 +00:00
P0 fixes: - StorageType: UploadFromURL now returns actual storageType, fixing GDrive tasks being incorrectly recorded as "s3" - Concurrency: selectAccount returns ReleaseFunc to caller, fixing premature slot release before task creation - Race condition: applyRecoveredToken uses copy-on-write for account.Credentials map to prevent concurrent write panic - GetCameoStatus: use direct HTTP call to populate missing fields (StatusMessage, InstructionSetHint, InstructionSet) - Frontend: progress bar uses reactive now.value instead of non-reactive Date.now() P1 fixes: - EditImage: pass req.Image through to CreateImageRequest - ListPending: add LIMIT 200 to prevent unbounded queries - Worker encapsulation: add ListPendingTasks/UpdateTask proxy methods to SoraTaskService, worker no longer accesses repo directly - Frontend polling: add retry counter (3 attempts) before giving up P2-P3 fixes: - QuotaBar: handle both quota_source and source field names - i18n: replace hardcoded Chinese labels in SoraPromptBar and example prompts in SoraGeneratePage with i18n keys - Fix regenrate → regenerate i18n typo - SoraMediaPreview: skip Escape handler when not visible - SoraGeneratePage: void handleGenerate promise in handleRetry Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
434 lines
12 KiB
Go
434 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"golang.org/x/oauth2"
|
|
"golang.org/x/oauth2/google"
|
|
"google.golang.org/api/drive/v3"
|
|
"google.golang.org/api/option"
|
|
|
|
"github.com/Wei-Shaw/sub2api/internal/pkg/logger"
|
|
)
|
|
|
|
// SoraGDriveStorage 负责 Sora 媒体文件的 Google Drive 存储操作。
|
|
type SoraGDriveStorage struct {
|
|
settingService *SettingService
|
|
|
|
mu sync.RWMutex
|
|
srv *drive.Service
|
|
cfg *SoraS3Profile // 缓存当前 GDrive 配置
|
|
healthCheckedAt time.Time
|
|
healthErr error
|
|
healthTTL time.Duration
|
|
}
|
|
|
|
const defaultGDriveHealthTTL = 30 * time.Second
|
|
|
|
// NewSoraGDriveStorage 创建 Google Drive 存储服务实例。
|
|
func NewSoraGDriveStorage(settingService *SettingService) *SoraGDriveStorage {
|
|
return &SoraGDriveStorage{
|
|
settingService: settingService,
|
|
healthTTL: defaultGDriveHealthTTL,
|
|
}
|
|
}
|
|
|
|
// StorageType 返回存储类型标识。
|
|
func (s *SoraGDriveStorage) StorageType() string {
|
|
return SoraStorageTypeGDrive
|
|
}
|
|
|
|
// Enabled 返回 Google Drive 存储是否已启用。
|
|
func (s *SoraGDriveStorage) Enabled(ctx context.Context) bool {
|
|
profile := s.getActiveGDriveProfile(ctx)
|
|
if profile == nil {
|
|
return false
|
|
}
|
|
return profile.Enabled && s.hasValidCredentials(profile)
|
|
}
|
|
|
|
// getActiveGDriveProfile 获取当前激活的 GDrive 配置。
|
|
func (s *SoraGDriveStorage) getActiveGDriveProfile(ctx context.Context) *SoraS3Profile {
|
|
if s.settingService == nil {
|
|
return nil
|
|
}
|
|
profile, err := s.settingService.GetActiveStorageProfile(ctx)
|
|
if err != nil || profile == nil {
|
|
return nil
|
|
}
|
|
if profile.GetProvider() != SoraStorageTypeGDrive {
|
|
return nil
|
|
}
|
|
return profile
|
|
}
|
|
|
|
// hasValidCredentials 检查 GDrive 配置是否有有效凭证。
|
|
func (s *SoraGDriveStorage) hasValidCredentials(profile *SoraS3Profile) bool {
|
|
switch profile.AuthType {
|
|
case "oauth2":
|
|
return profile.ClientID != "" && profile.ClientSecret != "" && profile.RefreshToken != ""
|
|
case "service_account":
|
|
return profile.ServiceAccountJSON != ""
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// getService 获取或初始化 Drive 服务(带缓存)。
|
|
func (s *SoraGDriveStorage) getService(ctx context.Context) (*drive.Service, *SoraS3Profile, error) {
|
|
s.mu.RLock()
|
|
if s.srv != nil && s.cfg != nil {
|
|
srv, cfg := s.srv, s.cfg
|
|
s.mu.RUnlock()
|
|
return srv, cfg, nil
|
|
}
|
|
s.mu.RUnlock()
|
|
|
|
return s.initService(ctx)
|
|
}
|
|
|
|
func (s *SoraGDriveStorage) initService(ctx context.Context) (*drive.Service, *SoraS3Profile, error) {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
// 双重检查
|
|
if s.srv != nil && s.cfg != nil {
|
|
return s.srv, s.cfg, nil
|
|
}
|
|
|
|
profile := s.getActiveGDriveProfile(ctx)
|
|
if profile == nil {
|
|
return nil, nil, fmt.Errorf("no active gdrive profile found")
|
|
}
|
|
if !profile.Enabled {
|
|
return nil, nil, fmt.Errorf("gdrive storage is disabled")
|
|
}
|
|
|
|
srv, err := s.buildDriveService(ctx, profile)
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("build gdrive service: %w", err)
|
|
}
|
|
|
|
s.srv = srv
|
|
s.cfg = profile
|
|
logger.LegacyPrintf("service.sora_gdrive", "[SoraGDrive] 客户端已初始化 auth_type=%s folder_id=%s", profile.AuthType, profile.FolderID)
|
|
return srv, profile, nil
|
|
}
|
|
|
|
// buildDriveService 根据认证类型创建 Google Drive 服务。
|
|
func (s *SoraGDriveStorage) buildDriveService(ctx context.Context, profile *SoraS3Profile) (*drive.Service, error) {
|
|
switch profile.AuthType {
|
|
case "oauth2":
|
|
return s.buildOAuth2Service(ctx, profile)
|
|
case "service_account":
|
|
return s.buildServiceAccountService(ctx, profile)
|
|
default:
|
|
return nil, fmt.Errorf("unsupported auth_type: %s", profile.AuthType)
|
|
}
|
|
}
|
|
|
|
func (s *SoraGDriveStorage) buildOAuth2Service(ctx context.Context, profile *SoraS3Profile) (*drive.Service, error) {
|
|
config := &oauth2.Config{
|
|
ClientID: profile.ClientID,
|
|
ClientSecret: profile.ClientSecret,
|
|
Endpoint: google.Endpoint,
|
|
Scopes: []string{drive.DriveFileScope},
|
|
}
|
|
token := &oauth2.Token{
|
|
RefreshToken: profile.RefreshToken,
|
|
}
|
|
tokenSource := config.TokenSource(ctx, token)
|
|
srv, err := drive.NewService(ctx, option.WithTokenSource(tokenSource))
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create gdrive oauth2 service: %w", err)
|
|
}
|
|
return srv, nil
|
|
}
|
|
|
|
func (s *SoraGDriveStorage) buildServiceAccountService(ctx context.Context, profile *SoraS3Profile) (*drive.Service, error) {
|
|
srv, err := drive.NewService(ctx, option.WithCredentialsJSON([]byte(profile.ServiceAccountJSON))) //nolint:staticcheck // SA1019: admin-controlled service account JSON, safe to use
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create gdrive service account service: %w", err)
|
|
}
|
|
return srv, nil
|
|
}
|
|
|
|
// RefreshClient 清除缓存的 Drive 客户端。
|
|
func (s *SoraGDriveStorage) RefreshClient() {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.srv = nil
|
|
s.cfg = nil
|
|
s.healthCheckedAt = time.Time{}
|
|
s.healthErr = nil
|
|
logger.LegacyPrintf("service.sora_gdrive", "[SoraGDrive] 客户端缓存已清除")
|
|
}
|
|
|
|
// GDriveQuotaInfo 包含 Google Drive 配额信息。
|
|
type GDriveQuotaInfo struct {
|
|
LimitBytes int64 `json:"limit_bytes"`
|
|
UsedBytes int64 `json:"used_bytes"`
|
|
}
|
|
|
|
// TestConnection 测试 Google Drive 连接。
|
|
func (s *SoraGDriveStorage) TestConnection(ctx context.Context) error {
|
|
srv, _, err := s.getService(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = srv.About.Get().Fields("storageQuota").Context(ctx).Do()
|
|
if err != nil {
|
|
return fmt.Errorf("gdrive About.Get failed: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// GetQuotaInfo 获取 Google Drive 配额信息(总量和已用量)。
|
|
func (s *SoraGDriveStorage) GetQuotaInfo(ctx context.Context) (*GDriveQuotaInfo, error) {
|
|
srv, _, err := s.getService(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
about, err := srv.About.Get().Fields("storageQuota").Context(ctx).Do()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("gdrive About.Get failed: %w", err)
|
|
}
|
|
if about.StorageQuota == nil {
|
|
return nil, fmt.Errorf("storageQuota not available")
|
|
}
|
|
return &GDriveQuotaInfo{
|
|
LimitBytes: about.StorageQuota.Limit,
|
|
UsedBytes: about.StorageQuota.Usage,
|
|
}, nil
|
|
}
|
|
|
|
// TestFullCycle 执行完整的上传→获取链接→删除测试。
|
|
func (s *SoraGDriveStorage) TestFullCycle(ctx context.Context) (map[string]any, error) {
|
|
srv, cfg, err := s.getService(ctx)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("init client: %w", err)
|
|
}
|
|
|
|
result := map[string]any{}
|
|
|
|
// 1. 测试 API 连接
|
|
about, err := srv.About.Get().Fields("storageQuota").Context(ctx).Do()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("API connection failed: %w", err)
|
|
}
|
|
if about.StorageQuota != nil {
|
|
result["quota_limit_bytes"] = about.StorageQuota.Limit
|
|
result["quota_used_bytes"] = about.StorageQuota.Usage
|
|
}
|
|
|
|
// 2. 上传测试文件
|
|
testContent := "sub2api GDrive test file - " + time.Now().Format(time.RFC3339)
|
|
fileMeta := &drive.File{
|
|
Name: "sub2api_test_" + uuid.NewString()[:8] + ".txt",
|
|
MimeType: "text/plain",
|
|
}
|
|
if cfg.FolderID != "" {
|
|
fileMeta.Parents = []string{cfg.FolderID}
|
|
}
|
|
uploaded, err := srv.Files.Create(fileMeta).
|
|
Media(strings.NewReader(testContent)).
|
|
Fields("id,name,size,webViewLink").
|
|
Context(ctx).Do()
|
|
if err != nil {
|
|
return nil, fmt.Errorf("upload test file failed: %w", err)
|
|
}
|
|
result["uploaded_file_id"] = uploaded.Id
|
|
result["uploaded_file_name"] = uploaded.Name
|
|
result["uploaded_file_size"] = uploaded.Size
|
|
result["web_view_link"] = uploaded.WebViewLink
|
|
|
|
// 3. 获取访问链接
|
|
accessURL, err := s.GetAccessURL(ctx, uploaded.Id)
|
|
if err != nil {
|
|
// 即使获取链接失败,仍尝试清理
|
|
_ = srv.Files.Delete(uploaded.Id).Context(ctx).Do()
|
|
return nil, fmt.Errorf("get access URL failed: %w", err)
|
|
}
|
|
result["access_url"] = accessURL
|
|
|
|
// 4. 删除测试文件
|
|
if err := srv.Files.Delete(uploaded.Id).Context(ctx).Do(); err != nil {
|
|
result["delete_warning"] = fmt.Sprintf("delete failed (manual cleanup needed): %v", err)
|
|
} else {
|
|
result["deleted"] = true
|
|
}
|
|
|
|
result["status"] = "ok"
|
|
return result, nil
|
|
}
|
|
|
|
// IsHealthy 返回 Google Drive 健康状态(带短缓存)。
|
|
func (s *SoraGDriveStorage) IsHealthy(ctx context.Context) bool {
|
|
if s == nil {
|
|
return false
|
|
}
|
|
now := time.Now()
|
|
s.mu.RLock()
|
|
lastCheck := s.healthCheckedAt
|
|
lastErr := s.healthErr
|
|
ttl := s.healthTTL
|
|
s.mu.RUnlock()
|
|
|
|
if ttl <= 0 {
|
|
ttl = defaultGDriveHealthTTL
|
|
}
|
|
if !lastCheck.IsZero() && now.Sub(lastCheck) < ttl {
|
|
return lastErr == nil
|
|
}
|
|
|
|
err := s.TestConnection(ctx)
|
|
s.mu.Lock()
|
|
s.healthCheckedAt = time.Now()
|
|
s.healthErr = err
|
|
s.mu.Unlock()
|
|
return err == nil
|
|
}
|
|
|
|
// UploadFromURL 从上游 URL 下载并上传到 Google Drive。
|
|
// 返回 Google Drive 文件 ID 作为 objectKey、文件大小、存储类型。
|
|
func (s *SoraGDriveStorage) UploadFromURL(ctx context.Context, userID int64, sourceURL string) (string, int64, string, error) {
|
|
srv, cfg, err := s.getService(ctx)
|
|
if err != nil {
|
|
return "", 0, "", err
|
|
}
|
|
|
|
// 下载源文件
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, sourceURL, nil)
|
|
if err != nil {
|
|
return "", 0, "", fmt.Errorf("create download request: %w", err)
|
|
}
|
|
httpClient := &http.Client{Timeout: 5 * time.Minute}
|
|
resp, err := httpClient.Do(req)
|
|
if err != nil {
|
|
return "", 0, "", fmt.Errorf("download from upstream: %w", err)
|
|
}
|
|
defer func() {
|
|
_ = resp.Body.Close()
|
|
}()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return "", 0, "", &UpstreamDownloadError{StatusCode: resp.StatusCode}
|
|
}
|
|
|
|
// 推断文件扩展名和 MIME
|
|
ext := fileExtFromURL(sourceURL)
|
|
if ext == "" {
|
|
ext = fileExtFromContentType(resp.Header.Get("Content-Type"))
|
|
}
|
|
if ext == "" {
|
|
ext = ".bin"
|
|
}
|
|
contentType := resp.Header.Get("Content-Type")
|
|
if contentType == "" {
|
|
contentType = "application/octet-stream"
|
|
}
|
|
|
|
// 生成文件名
|
|
datePath := time.Now().Format("2006-01-02")
|
|
fileName := fmt.Sprintf("sora_%d_%s_%s%s", userID, datePath, uuid.NewString()[:8], ext)
|
|
|
|
// 创建文件元数据
|
|
fileMeta := &drive.File{
|
|
Name: fileName,
|
|
MimeType: contentType,
|
|
}
|
|
if cfg.FolderID != "" {
|
|
fileMeta.Parents = []string{cfg.FolderID}
|
|
}
|
|
|
|
// 使用 CountingReader 统计大小
|
|
cr := &countingReader{Reader: resp.Body}
|
|
|
|
// 上传到 Google Drive
|
|
created, err := srv.Files.Create(fileMeta).
|
|
Media(cr).
|
|
Fields("id, size").
|
|
Context(ctx).
|
|
Do()
|
|
if err != nil {
|
|
return "", 0, "", fmt.Errorf("gdrive upload: %w", err)
|
|
}
|
|
|
|
fileSize := cr.BytesRead
|
|
if created.Size > 0 {
|
|
fileSize = created.Size
|
|
}
|
|
|
|
// 根据 access_mode 设置权限
|
|
if cfg.AccessMode == "" || cfg.AccessMode == "direct" {
|
|
// 设为任何人可读
|
|
_, permErr := srv.Permissions.Create(created.Id, &drive.Permission{
|
|
Type: "anyone",
|
|
Role: "reader",
|
|
}).Context(ctx).Do()
|
|
if permErr != nil {
|
|
logger.LegacyPrintf("service.sora_gdrive", "[SoraGDrive] 设置公开权限失败 fileID=%s err=%v", created.Id, permErr)
|
|
}
|
|
}
|
|
|
|
logger.LegacyPrintf("service.sora_gdrive", "[SoraGDrive] 上传完成 fileID=%s size=%d", created.Id, fileSize)
|
|
return created.Id, fileSize, SoraStorageTypeGDrive, nil
|
|
}
|
|
|
|
// DeleteObjects 删除一组 Google Drive 文件。
|
|
func (s *SoraGDriveStorage) DeleteObjects(ctx context.Context, objectKeys []string) error {
|
|
if len(objectKeys) == 0 {
|
|
return nil
|
|
}
|
|
|
|
srv, _, err := s.getService(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var lastErr error
|
|
for _, fileID := range objectKeys {
|
|
if err := srv.Files.Delete(fileID).Context(ctx).Do(); err != nil {
|
|
logger.LegacyPrintf("service.sora_gdrive", "[SoraGDrive] 删除失败 fileID=%s err=%v", fileID, err)
|
|
lastErr = err
|
|
}
|
|
}
|
|
return lastErr
|
|
}
|
|
|
|
// GetAccessURL 获取 Google Drive 文件的访问 URL。
|
|
func (s *SoraGDriveStorage) GetAccessURL(ctx context.Context, objectKey string) (string, error) {
|
|
_, cfg, err := s.getService(ctx)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// CDN URL 优先
|
|
if cfg.CDNURL != "" {
|
|
cdnBase := strings.TrimRight(cfg.CDNURL, "/")
|
|
return cdnBase + "/" + objectKey, nil
|
|
}
|
|
|
|
// 默认使用 Google Drive 直链
|
|
return fmt.Sprintf("https://drive.google.com/uc?export=download&id=%s", objectKey), nil
|
|
}
|
|
|
|
// countingReader 包装 io.Reader 以统计读取的字节数。
|
|
type countingReader struct {
|
|
Reader io.Reader
|
|
BytesRead int64
|
|
}
|
|
|
|
func (r *countingReader) Read(p []byte) (int, error) {
|
|
n, err := r.Reader.Read(p)
|
|
r.BytesRead += int64(n)
|
|
return n, err
|
|
}
|