This commit is contained in:
truewhile
2026-10-29 23:47:18 +08:00
parent d820214abc
commit 623d87f12b
16 changed files with 1088 additions and 165 deletions
+248 -21
View File
@@ -1,15 +1,18 @@
package reader
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"os"
"path/filepath"
"sort"
"strconv"
"strings"
"sync"
"time"
@@ -29,6 +32,18 @@ const (
audioMediaMaxBytes = 2 << 30 // 2GiB:超出后按 mtime 淘汰最旧的
audioMediaPrunePeriod = 10 * time.Minute
audioMediaPruneKeepPct = 90
// audioPartialSuffix 未下完的音轨分片后缀。
//
// 分片跨请求保留:首播失败后用户再点一次、或播放器重连,都能用 Range 接着下,
// 不必从第 0 字节重来。分片名带 .part 后缀,不会被 OpenCachedRemoteAudio 当成
// 完整音轨下发。
audioPartialSuffix = ".part"
// audioMediaObjectMaxBytes 单个音频对象的落盘上限。有声书一章约 3–5MB,
// 给到 64MB 足够容纳长章节,也能挡住误当成音频的超大对象。
audioMediaObjectMaxBytes = 64 << 20
// audioDownloadRetryDelay 断点续传重试的退避基数,实际等待为 (attempt-1) 倍。
audioDownloadRetryDelay = 500 * time.Millisecond
)
var (
@@ -132,41 +147,253 @@ func (s *ReaderService) OpenCachedRemoteAudio(bookID, mediaURL string) (*os.File
return f, info, true
}
// StoreCachedRemoteAudio 把一段音源原子写入缓存,fill 负责把内容写进 writer。
// 返回最终文件路径;内容为空或写入失败时不留下半成品。
func (s *ReaderService) StoreCachedRemoteAudio(bookID, mediaURL string, fill func(io.Writer) error) (string, error) {
// errAudioObjectTooLarge 上游对象超过单章缓存上限(不是可重试的错误)。
var errAudioObjectTooLarge = errors.New("音源超过缓存上限")
// NoRetryError 标记「换着花样再试也不会有进展」的失败(例如上游正成批拒绝
// 签名票、书源根本给不出新票)。带断点续传的下载器收到它会立刻停止,并把
// Err 原样交给调用方——继续重试只会让播放器多等十几秒,还会让对方更坚定地
// 拒绝我们。
type NoRetryError struct{ Err error }
func (e *NoRetryError) Error() string { return e.Err.Error() }
func (e *NoRetryError) Unwrap() error { return e.Err }
// AudioRangeFetcher 取一次上游音轨响应。
//
// rangeHeader 为空表示整段请求;否则形如 "bytes=N-",用于从断点续传。
// head 是调用方已经嗅探读过、必须补写回文件的前缀(只有整段请求才有)。
// 调用方负责在内部完成换票;这里只看状态码和字节。
type AudioRangeFetcher func(rangeHeader string) (resp *http.Response, head []byte, err error)
// DownloadRemoteAudio 带断点续传地把整段音轨写进缓存,返回最终文件路径。
//
// 为什么需要续传:腾讯 CDN 的跨境边缘常在传输中途 RST,旧实现每次重试都从
// 第 0 字节重下,一章 3MB 白下几次就把首播拖到几十秒。这里把已写入的字节留在
// <cache>.part 里,下一次用 Range: bytes=N- 续上;分片跨请求保留,用户点重试
// 或播放器重连都能接着下。
//
// 上游忽略 Range 直接回 200、或分片区间对不上时,丢弃分片从头重来。
// 下载过程中的失败不会留下「看起来完整」的缓存文件:只有字节数与上游声明的
// 总长一致才会原子改名到正式路径。
func (s *ReaderService) DownloadRemoteAudio(
ctx context.Context,
bookID, mediaURL string,
attempts int,
fetch AudioRangeFetcher,
) (string, error) {
path := s.RemoteAudioCachePath(bookID, mediaURL)
if path == "" {
return "", errors.New("音频缓存目录未配置")
}
if fetch == nil {
return "", errors.New("音频下载器未配置")
}
if attempts <= 0 {
attempts = 1
}
if err := os.MkdirAll(filepath.Dir(path), 0o750); err != nil {
return "", fmt.Errorf("创建音频缓存目录失败: %w", err)
}
tmp, err := os.CreateTemp(filepath.Dir(path), ".audio-*")
partPath := path + audioPartialSuffix
var offset int64
if info, statErr := os.Stat(partPath); statErr == nil && info.Mode().IsRegular() {
offset = info.Size()
// 分片太旧或超过上限:续传没有意义,直接丢掉重下。
if offset > audioMediaObjectMaxBytes || info.ModTime().Add(audioMediaTTL).Before(time.Now()) {
_ = os.Remove(partPath)
offset = 0
}
}
file, err := os.OpenFile(partPath, os.O_CREATE|os.O_WRONLY, 0o640)
if err != nil {
return "", fmt.Errorf("创建音频缓存文件失败: %w", err)
}
tmpName := tmp.Name()
fillErr := fill(tmp)
closeErr := tmp.Close()
if fillErr != nil || closeErr != nil {
_ = os.Remove(tmpName)
if fillErr != nil {
return "", fillErr
var lastErr error
for attempt := 1; attempt <= attempts; attempt++ {
if attempt > 1 {
select {
case <-ctx.Done():
_ = file.Close()
return "", ctx.Err()
case <-time.After(audioDownloadRetryDelay * time.Duration(attempt-1)):
}
}
return "", closeErr
rangeHeader := ""
if offset > 0 {
rangeHeader = fmt.Sprintf("bytes=%d-", offset)
}
resp, head, fetchErr := fetch(rangeHeader)
if fetchErr != nil {
var noRetry *NoRetryError
if errors.As(fetchErr, &noRetry) {
_ = file.Close()
// 已经写下的分片留着:上游恢复后用户再点一次能接着续。
if offset == 0 {
_ = os.Remove(partPath)
}
return "", noRetry.Err
}
lastErr = fetchErr
continue
}
if resp == nil {
lastErr = errors.New("音源响应为空")
continue
}
expected := int64(-1)
switch resp.StatusCode {
case http.StatusPartialContent:
start, total, ok := parseContentRange(resp.Header.Get("Content-Range"))
if !ok || offset == 0 || start != offset {
drainAndClose(resp.Body)
offset = 0
_ = file.Truncate(0)
lastErr = fmt.Errorf("音源返回的分片区间不可用(%q)", resp.Header.Get("Content-Range"))
continue
}
expected = total
case http.StatusOK:
// 上游忽略了 Range(或者本来就是整段请求):只能从第 0 字节写。
if offset > 0 {
offset = 0
if truncErr := file.Truncate(0); truncErr != nil {
drainAndClose(resp.Body)
lastErr = fmt.Errorf("重置音频缓存失败: %w", truncErr)
continue
}
}
expected = resp.ContentLength
case http.StatusRequestedRangeNotSatisfiable:
// 分片比上游对象还长(对象换过):丢掉分片重来。
drainAndClose(resp.Body)
offset = 0
_ = file.Truncate(0)
lastErr = fmt.Errorf("音源分片已失效(%d)", resp.StatusCode)
continue
default:
drainAndClose(resp.Body)
lastErr = fmt.Errorf("音源返回 %d", resp.StatusCode)
continue
}
if _, seekErr := file.Seek(offset, io.SeekStart); seekErr != nil {
drainAndClose(resp.Body)
lastErr = fmt.Errorf("音频缓存定位失败: %w", seekErr)
continue
}
written, writeErr := writeAudioChunk(file, head, resp.Body, audioMediaObjectMaxBytes-offset)
_ = resp.Body.Close()
offset += written
if errors.Is(writeErr, errAudioObjectTooLarge) {
_ = file.Close()
_ = os.Remove(partPath)
return "", fmt.Errorf("已重试 %d 次: %w", attempts, writeErr)
}
if writeErr != nil {
// 已写入的字节保留在分片里,下一轮从新的断点续传。
lastErr = writeErr
continue
}
if expected >= 0 && offset != expected {
lastErr = fmt.Errorf("音频写入不完整(%d/%d 字节)", offset, expected)
continue
}
if offset == 0 {
lastErr = errors.New("音源内容为空")
continue
}
if truncErr := file.Truncate(offset); truncErr != nil {
_ = file.Close()
return "", fmt.Errorf("写入音频缓存失败: %w", truncErr)
}
if closeErr := file.Close(); closeErr != nil {
return "", fmt.Errorf("写入音频缓存失败: %w", closeErr)
}
if renameErr := os.Rename(partPath, path); renameErr != nil {
return "", fmt.Errorf("写入音频缓存失败: %w", renameErr)
}
s.pruneAudioMediaCache()
return path, nil
}
info, statErr := os.Stat(tmpName)
if statErr != nil || info.Size() == 0 {
_ = os.Remove(tmpName)
return "", errors.New("音源内容为空")
_ = file.Close()
if lastErr == nil {
lastErr = errors.New("音源拉取失败")
}
if err := os.Rename(tmpName, path); err != nil {
_ = os.Remove(tmpName)
return "", fmt.Errorf("写入音频缓存失败: %w", err)
if offset > 0 {
return "", fmt.Errorf("已重试 %d 次: %w(已缓存 %d 字节,重试可续传)", attempts, lastErr, offset)
}
s.pruneAudioMediaCache()
return path, nil
return "", fmt.Errorf("已重试 %d 次: %w", attempts, lastErr)
}
// writeAudioChunk 先把已读前缀补写回文件,再把响应体写到 limit 字节为止。
// 返回本次实际写入的字节数(出错时也包含已写成功的部分)。
func writeAudioChunk(w io.Writer, head []byte, body io.Reader, limit int64) (int64, error) {
var total int64
if len(head) > 0 {
n, err := w.Write(head)
total += int64(n)
if err != nil {
return total, err
}
}
if limit <= 0 {
return total, errAudioObjectTooLarge
}
n, err := io.Copy(w, io.LimitReader(body, limit-total+1))
total += n
if err != nil {
return total, err
}
if total > limit {
return total, errAudioObjectTooLarge
}
return total, nil
}
// parseContentRange 解析 "bytes 100-199/1234" 的起点与总长度。
// 总长度未知("*")时 total 为 -1。
func parseContentRange(v string) (start, total int64, ok bool) {
v = strings.TrimSpace(v)
const prefix = "bytes "
if len(v) <= len(prefix) || !strings.EqualFold(v[:len(prefix)], prefix) {
return 0, -1, false
}
v = strings.TrimSpace(v[len(prefix):])
slash := strings.IndexByte(v, '/')
if slash < 0 {
return 0, -1, false
}
span, size := v[:slash], strings.TrimSpace(v[slash+1:])
dash := strings.IndexByte(span, '-')
if dash <= 0 {
return 0, -1, false
}
start, err := strconv.ParseInt(strings.TrimSpace(span[:dash]), 10, 64)
if err != nil || start < 0 {
return 0, -1, false
}
if size == "" || size == "*" {
return start, -1, true
}
total, err = strconv.ParseInt(size, 10, 64)
if err != nil || total <= 0 {
return start, -1, true
}
return start, total, true
}
// drainAndClose 丢弃剩余响应体并关闭连接(尽量让上游把连接收回去)。
func drainAndClose(body io.ReadCloser) {
if body == nil {
return
}
_, _ = io.Copy(io.Discard, io.LimitReader(body, 64<<10))
_ = body.Close()
}
// pruneAudioMediaCache 低频清理:删过期文件,超容量时按 mtime 淘汰最旧的。