210 lines
7.3 KiB
Go
210 lines
7.3 KiB
Go
package main
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"golang.org/x/sync/singleflight"
|
|
)
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// file-viewer CDN 资源本地缓存代理
|
|
//
|
|
// 前端 HTML 引用 /file-viewer/dist/flyfish-file-viewer-web-full.iife.js, 后端
|
|
// 先读本地缓存, 命中直接返回; 未命中从 unpkg 拉, 边写盘边流回客户端, 后续请求
|
|
// 全部走磁盘. vendor/ 资源同理按需拉取.
|
|
//
|
|
// 设计取舍:
|
|
// - 缓存键 = URL 相对路径 (如 dist/foo.js / vendor/libarchive/worker-bundle.js).
|
|
// 升级 library 版本需手动 -rm 缓存目录, 避免旧版资源污染.
|
|
// - 缓存目录不可写时降级为纯 CDN 透传, 不阻断预览功能.
|
|
// - 缓存关闭 (-file-viewer-cache="") 时完全走 CDN, 行为与改造前一致.
|
|
// -----------------------------------------------------------------------------
|
|
|
|
var (
|
|
fileViewerCDN = flag.String("file-viewer-cdn", "https://unpkg.com/@file-viewer/web-full@3.0.0", "file-viewer CDN base URL")
|
|
fileViewerCacheDir = flag.String("file-viewer-cache", "./data/file-viewer", "file-viewer 资源缓存目录 (空字符串 = 禁用缓存, 全部 CDN 透传)")
|
|
fileViewerCacheTTL = flag.Duration("file-viewer-ttl", 0, "缓存文件最大有效期 (0 = 永久, 仅在文件已存在时刷新 Content-Type)")
|
|
)
|
|
|
|
// 30 min 足够 330 KB 的 iife 与 vendor/ 下最大的 docx/pptx wasm (~50 MB) 在慢网下完成
|
|
var fileViewerHTTPClient = &http.Client{Timeout: 30 * time.Minute}
|
|
|
|
// fileViewerFetchGroup 按 cachePath 去重并发 fetch:
|
|
// 同 key 同一时刻只有一个 goroutine 真正去 CDN 拉, 其他并发请求阻塞等待,
|
|
// fetch 完成后从磁盘读 (文件已经落盘). 避免多个请求对同一文件重复上游拉取 + 写盘竞态.
|
|
var fileViewerFetchGroup singleflight.Group
|
|
|
|
// fileViewerProxy 处理 GET /file-viewer/*filepath.
|
|
// 1. 校验路径防 ../ 越界
|
|
// 2. 缓存命中 -> 直接读盘
|
|
// 3. 缓存未命中 -> 拉上游, 边写盘边流回
|
|
// 4. 缓存关闭 -> 直接透传到 CDN
|
|
func fileViewerProxy(c *gin.Context) {
|
|
raw := c.Param("filepath")
|
|
name, ok := validateFileViewerPath(raw)
|
|
if !ok {
|
|
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid path"})
|
|
return
|
|
}
|
|
|
|
if *fileViewerCacheDir == "" {
|
|
proxyFileViewer(c, name)
|
|
return
|
|
}
|
|
|
|
cachePath := filepath.Join(*fileViewerCacheDir, filepath.FromSlash(name))
|
|
|
|
// 命中: 直接读盘 (TTL > 0 且文件超过有效期则强制回源)
|
|
if info, err := os.Stat(cachePath); err == nil && !info.IsDir() {
|
|
if *fileViewerCacheTTL <= 0 || time.Since(info.ModTime()) < *fileViewerCacheTTL {
|
|
c.Header("Cache-Control", "public, max-age=31536000, immutable")
|
|
c.File(cachePath)
|
|
return
|
|
}
|
|
log.Printf("[file-viewer] cache expired, refetching %s", name)
|
|
}
|
|
|
|
// 未命中: 拉上游 + 边写盘边流回
|
|
fetchAndCache(c, cachePath, name)
|
|
}
|
|
|
|
// validateFileViewerPath 校验并清理 fileviewer 子路径, 防 ../ 越界.
|
|
// gin 的 *filepath wildcard 包含前导 '/', 先 strip 再清理.
|
|
// 先按 '/' 切分检查 `..` 分量 (path.Clean 会折叠中间 .., 仅靠它不够),
|
|
// 再 path.Clean 兜底处理 // / ./ 等冗余.
|
|
func validateFileViewerPath(raw string) (string, bool) {
|
|
raw = strings.TrimPrefix(raw, "/")
|
|
if raw == "" || strings.ContainsRune(raw, 0) {
|
|
return "", false
|
|
}
|
|
for part := range strings.SplitSeq(raw, "/") {
|
|
if part == ".." {
|
|
return "", false
|
|
}
|
|
}
|
|
clean := path.Clean(raw)
|
|
if clean == "." || clean == "" || strings.HasPrefix(clean, "..") || strings.HasPrefix(clean, "/") {
|
|
return "", false
|
|
}
|
|
return clean, true
|
|
}
|
|
|
|
// proxyFileViewer: 缓存关闭时直接透传到 CDN.
|
|
func proxyFileViewer(c *gin.Context, name string) {
|
|
upstream := upstreamURL(name)
|
|
resp, err := fileViewerHTTPClient.Get(upstream)
|
|
if err != nil {
|
|
log.Printf("[file-viewer] upstream fetch %s: %v", name, err)
|
|
c.JSON(http.StatusBadGateway, gin.H{"error": "upstream fetch failed"})
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if ct := resp.Header.Get("Content-Type"); ct != "" {
|
|
c.Header("Content-Type", ct)
|
|
}
|
|
c.Status(resp.StatusCode)
|
|
if _, err := io.Copy(c.Writer, resp.Body); err != nil {
|
|
log.Printf("[file-viewer] stream %s: %v", name, err)
|
|
}
|
|
}
|
|
|
|
// fetchAndCache: 通过 singleflight 按 cachePath 去重并发. 同一个 key 只有第一个
|
|
// 请求调 doFetchAndCache (拉 CDN + 边写盘边流回 writer 的 c.Writer); 其他并发
|
|
// 请求阻塞等待, 拿到结果后从磁盘读 (c.File).
|
|
//
|
|
// 注意: singleflight 的 shared=true 表示"结果被分享给多个 caller", 并不区分
|
|
// 首 caller 还是后续 caller. 这里用 closure 变量 isWriter 精确标识谁是写者:
|
|
// - closure 被执行 = 写者 (响应已流回本 c.Writer, 直接返回)
|
|
// - closure 未执行 = 等待者 (自己组装响应: 错误 -> 502, 成功 -> c.File)
|
|
func fetchAndCache(c *gin.Context, cachePath, name string) {
|
|
isWriter := false
|
|
_, err, _ := fileViewerFetchGroup.Do(cachePath, func() (interface{}, error) {
|
|
isWriter = true
|
|
return nil, doFetchAndCache(c, cachePath, name)
|
|
})
|
|
|
|
if isWriter {
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
|
|
return
|
|
}
|
|
c.Header("Cache-Control", "public, max-age=31536000, immutable")
|
|
c.File(cachePath)
|
|
}
|
|
|
|
// doFetchAndCache: writer 路径专属 — 拉上游, 边写盘边流回传入的 c.Writer.
|
|
// 任何错误都会写入 c.Writer (502), 并返回 error 让 singleflight 把结果传给 waiter.
|
|
func doFetchAndCache(c *gin.Context, cachePath, name string) error {
|
|
upstream := upstreamURL(name)
|
|
resp, err := fileViewerHTTPClient.Get(upstream)
|
|
if err != nil {
|
|
log.Printf("[file-viewer] upstream fetch %s: %v", name, err)
|
|
c.JSON(http.StatusBadGateway, gin.H{"error": "upstream fetch failed"})
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
log.Printf("[file-viewer] upstream %s returned %d", name, resp.StatusCode)
|
|
c.JSON(http.StatusBadGateway, gin.H{"error": "upstream returned " + resp.Status})
|
|
return fmt.Errorf("upstream returned %s", resp.Status)
|
|
}
|
|
|
|
if ct := resp.Header.Get("Content-Type"); ct != "" {
|
|
c.Header("Content-Type", ct)
|
|
}
|
|
c.Header("Cache-Control", "public, max-age=31536000, immutable")
|
|
c.Status(http.StatusOK)
|
|
|
|
// 目录/文件创建失败 -> 降级透传, 不缓存
|
|
if err := os.MkdirAll(filepath.Dir(cachePath), 0o755); err != nil {
|
|
log.Printf("[file-viewer] mkdir cache dir: %v", err)
|
|
_, _ = io.Copy(c.Writer, resp.Body)
|
|
return err
|
|
}
|
|
f, err := os.Create(cachePath)
|
|
if err != nil {
|
|
log.Printf("[file-viewer] create cache file: %v", err)
|
|
_, _ = io.Copy(c.Writer, resp.Body)
|
|
return err
|
|
}
|
|
|
|
// 关键: MultiWriter 让客户端拿到的同时落盘, 用户感知零等待
|
|
mw := io.MultiWriter(c.Writer, f)
|
|
written, copyErr := io.Copy(mw, resp.Body)
|
|
cErr := f.Close()
|
|
|
|
if copyErr != nil || cErr != nil {
|
|
_ = os.Remove(cachePath) // 写一半的文件清理掉, 下次重新拉
|
|
if copyErr != nil {
|
|
log.Printf("[file-viewer] copy %s: %v", name, copyErr)
|
|
}
|
|
if cErr != nil {
|
|
log.Printf("[file-viewer] close %s: %v", name, cErr)
|
|
}
|
|
if copyErr != nil {
|
|
return copyErr
|
|
}
|
|
return cErr
|
|
}
|
|
log.Printf("[file-viewer] cached %s (%d bytes)", name, written)
|
|
return nil
|
|
}
|
|
|
|
func upstreamURL(name string) string {
|
|
return strings.TrimRight(*fileViewerCDN, "/") + "/" + name
|
|
} |