chore(init): 初始化解忧商行项目并完成 Phase 0 基座
This commit is contained in:
yml2213
@@ -0,0 +1,20 @@
|
||||
package file
|
||||
|
||||
type UploadDTO struct {
|
||||
ObjectKey string `json:"object_key"`
|
||||
URL string `json:"url"`
|
||||
ThumbnailURL string `json:"thumbnail_url,omitempty"`
|
||||
MediumURL string `json:"medium_url,omitempty"`
|
||||
Filename string `json:"filename"`
|
||||
ContentType string `json:"content_type"`
|
||||
Size int64 `json:"size"`
|
||||
objectKeys []string
|
||||
}
|
||||
|
||||
// ObjectKeys 返回上传产生的全部对象键，包含图片缩略图与中图变体。
|
||||
func (d *UploadDTO) ObjectKeys() []string {
|
||||
if d == nil {
|
||||
return nil
|
||||
}
|
||||
return append([]string(nil), d.objectKeys...)
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
package file
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"hfb_sys/backend/internal/logging"
|
||||
"hfb_sys/backend/pkg/response"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"go.uber.org/zap"
|
||||
)
|
||||
|
||||
type Handler struct {
|
||||
service *Service
|
||||
storage *Storage
|
||||
objectAuthorizer ObjectAuthorizer
|
||||
uploadOwnerRecorder UploadOwnerRecorder
|
||||
}
|
||||
|
||||
// ObjectAuthorizer 校验用户是否可读取指定私有对象。
|
||||
type ObjectAuthorizer func(ctx context.Context, userID uint64, key string) (bool, error)
|
||||
|
||||
// UploadOwnerRecorder 保存用户上传私有文件的归属。
|
||||
type UploadOwnerRecorder func(ctx context.Context, userID uint64, objectKeys []string) error
|
||||
|
||||
func NewHandler(service *Service, storage *Storage, objectAuthorizer ObjectAuthorizer, uploadOwnerRecorder UploadOwnerRecorder) *Handler {
|
||||
return &Handler{
|
||||
service: service,
|
||||
storage: storage,
|
||||
objectAuthorizer: objectAuthorizer,
|
||||
uploadOwnerRecorder: uploadOwnerRecorder,
|
||||
}
|
||||
}
|
||||
|
||||
func (h *Handler) Upload(c *gin.Context) {
|
||||
header, err := c.FormFile("file")
|
||||
if err != nil {
|
||||
response.BadRequest(c, "请选择要上传的文件")
|
||||
return
|
||||
}
|
||||
reader, err := header.Open()
|
||||
if err != nil {
|
||||
response.BadRequest(c, "文件读取失败")
|
||||
return
|
||||
}
|
||||
defer func() {
|
||||
_ = reader.Close()
|
||||
}()
|
||||
item, err := h.service.Upload(uploadRequest{
|
||||
Context: c.Request.Context(),
|
||||
Scene: c.PostForm("scene"),
|
||||
Header: header,
|
||||
Reader: reader,
|
||||
ContentType: header.Header.Get("Content-Type"),
|
||||
})
|
||||
if err != nil {
|
||||
writeFileError(c, err)
|
||||
return
|
||||
}
|
||||
if userID, ok := c.Get("user_id"); ok && h.uploadOwnerRecorder != nil {
|
||||
id, valid := userID.(uint64)
|
||||
if !valid || h.uploadOwnerRecorder(c.Request.Context(), id, item.ObjectKeys()) != nil {
|
||||
// 归属记录失败时补偿删除刚写入的对象，避免用户重试产生孤儿文件。
|
||||
if h.storage != nil {
|
||||
if removeErr := h.storage.RemoveObjects(c.Request.Context(), item.ObjectKeys()); removeErr != nil {
|
||||
logging.FromContext(c.Request.Context()).Warn("补偿删除上传对象失败", zap.Error(removeErr))
|
||||
}
|
||||
}
|
||||
response.ServiceUnavailable(c, "文件归属记录失败")
|
||||
return
|
||||
}
|
||||
}
|
||||
response.Created(c, item)
|
||||
}
|
||||
|
||||
func (h *Handler) Object(c *gin.Context) {
|
||||
h.writeObject(c, false)
|
||||
}
|
||||
|
||||
func (h *Handler) PublicObject(c *gin.Context) {
|
||||
h.writeObject(c, true)
|
||||
}
|
||||
|
||||
func (h *Handler) writeObject(c *gin.Context, publicOnly bool) {
|
||||
if h.storage == nil {
|
||||
response.ServiceUnavailable(c, "文件存储未连接")
|
||||
return
|
||||
}
|
||||
key := strings.TrimSpace(c.Query("key"))
|
||||
if key == "" || strings.Contains(key, "..") {
|
||||
response.BadRequest(c, "文件 key 不正确")
|
||||
return
|
||||
}
|
||||
if publicOnly &&
|
||||
!strings.HasPrefix(key, "home-banner/") &&
|
||||
!strings.HasPrefix(key, "avatar/") &&
|
||||
!strings.HasPrefix(key, "announcement/") &&
|
||||
!strings.HasPrefix(key, "mohong/") &&
|
||||
!strings.HasPrefix(key, "crash/") &&
|
||||
!strings.HasPrefix(key, "aw-recycle/") &&
|
||||
!strings.HasPrefix(key, "cooperation-feedback/") &&
|
||||
!strings.HasPrefix(key, "support-qrcode/") {
|
||||
response.Error(c, http.StatusNotFound, "not_found", "文件不存在或暂不可访问")
|
||||
return
|
||||
}
|
||||
if !publicOnly {
|
||||
if _, isAdmin := c.Get("admin_id"); !isAdmin {
|
||||
userID, ok := c.Get("user_id")
|
||||
if !ok {
|
||||
response.Unauthorized(c, "缺少用户上下文")
|
||||
return
|
||||
}
|
||||
id, ok := userID.(uint64)
|
||||
if !ok || h.objectAuthorizer == nil {
|
||||
response.Error(c, http.StatusForbidden, "forbidden", "无权访问该文件")
|
||||
return
|
||||
}
|
||||
allowed, err := h.objectAuthorizer(c.Request.Context(), id, key)
|
||||
if err != nil {
|
||||
response.ServiceUnavailable(c, "文件权限校验失败")
|
||||
return
|
||||
}
|
||||
if !allowed {
|
||||
response.Error(c, http.StatusForbidden, "forbidden", "无权访问该文件")
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
object, err := h.storage.Get(c.Request.Context(), key)
|
||||
if err != nil {
|
||||
response.Error(c, http.StatusNotFound, "not_found", "文件不存在或暂不可访问")
|
||||
return
|
||||
}
|
||||
defer func() {
|
||||
_ = object.Reader.Close()
|
||||
}()
|
||||
contentType := object.ContentType
|
||||
if contentType == "" {
|
||||
contentType = "application/octet-stream"
|
||||
}
|
||||
c.Header("Content-Type", contentType)
|
||||
c.Header("Cache-Control", "private, max-age=300")
|
||||
c.DataFromReader(http.StatusOK, object.Size, contentType, object.Reader, nil)
|
||||
}
|
||||
|
||||
func writeFileError(c *gin.Context, err error) {
|
||||
response.RecordError(c, err)
|
||||
switch {
|
||||
case errors.Is(err, ErrDependencyUnavailable):
|
||||
response.ServiceUnavailable(c, "文件存储未连接")
|
||||
case errors.Is(err, ErrInvalidFile):
|
||||
response.BadRequest(c, "文件不符合规则，仅支持 10MB 内的 JPG、PNG、WebP 或 PDF")
|
||||
default:
|
||||
response.Error(c, http.StatusInternalServerError, "internal_error", "文件服务暂时不可用")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package file
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"image"
|
||||
"image/color"
|
||||
"image/draw"
|
||||
"image/jpeg"
|
||||
_ "image/png"
|
||||
"math"
|
||||
"path"
|
||||
"strings"
|
||||
|
||||
xdraw "golang.org/x/image/draw"
|
||||
_ "golang.org/x/image/webp"
|
||||
)
|
||||
|
||||
const (
|
||||
ImageVariantThumb = "thumb"
|
||||
ImageVariantMedium = "medium"
|
||||
)
|
||||
|
||||
const (
|
||||
thumbMaxSide = 480
|
||||
mediumMaxSide = 1280
|
||||
)
|
||||
|
||||
type generatedImageVariant struct {
|
||||
Key string
|
||||
Content []byte
|
||||
ContentType string
|
||||
}
|
||||
|
||||
type imageVariantConfig struct {
|
||||
Name string
|
||||
MaxSide int
|
||||
Quality int
|
||||
}
|
||||
|
||||
var imageVariantConfigs = []imageVariantConfig{
|
||||
{Name: ImageVariantThumb, MaxSide: thumbMaxSide, Quality: 76},
|
||||
{Name: ImageVariantMedium, MaxSide: mediumMaxSide, Quality: 82},
|
||||
}
|
||||
|
||||
func ImageVariantKey(key string, variant string) string {
|
||||
ext := path.Ext(key)
|
||||
base := strings.TrimSuffix(key, ext)
|
||||
if base == "" {
|
||||
base = key
|
||||
}
|
||||
return base + "." + variant + ".jpg"
|
||||
}
|
||||
|
||||
func ImageVariantFallbackKeys(key string, variant string) []string {
|
||||
if key == "" {
|
||||
return nil
|
||||
}
|
||||
keys := []string{ImageVariantKey(key, variant)}
|
||||
if strings.HasSuffix(key, ".medium.jpg") && variant == ImageVariantThumb {
|
||||
keys = append(keys, strings.TrimSuffix(key, ".medium.jpg")+"."+ImageVariantThumb+".jpg")
|
||||
}
|
||||
keys = append(keys, key)
|
||||
return dedupeKeys(keys)
|
||||
}
|
||||
|
||||
func generateImageVariants(key string, data []byte, contentType string) []generatedImageVariant {
|
||||
if !strings.HasPrefix(contentType, "image/") || contentType == "image/svg+xml" {
|
||||
return nil
|
||||
}
|
||||
source, _, err := image.Decode(bytes.NewReader(data))
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
var variants []generatedImageVariant
|
||||
for _, config := range imageVariantConfigs {
|
||||
rendered := resizeForVariant(source, config.MaxSide)
|
||||
encoded, err := encodeJPEG(rendered, config.Quality)
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
variants = append(variants, generatedImageVariant{
|
||||
Key: ImageVariantKey(key, config.Name),
|
||||
Content: encoded,
|
||||
ContentType: "image/jpeg",
|
||||
})
|
||||
}
|
||||
return variants
|
||||
}
|
||||
|
||||
func resizeForVariant(source image.Image, maxSide int) image.Image {
|
||||
bounds := source.Bounds()
|
||||
width := bounds.Dx()
|
||||
height := bounds.Dy()
|
||||
if width <= 0 || height <= 0 || maxSide <= 0 {
|
||||
return source
|
||||
}
|
||||
scale := math.Min(float64(maxSide)/float64(width), float64(maxSide)/float64(height))
|
||||
if scale > 1 {
|
||||
scale = 1
|
||||
}
|
||||
targetWidth := max(1, int(math.Round(float64(width)*scale)))
|
||||
targetHeight := max(1, int(math.Round(float64(height)*scale)))
|
||||
target := image.NewRGBA(image.Rect(0, 0, targetWidth, targetHeight))
|
||||
draw.Draw(target, target.Bounds(), &image.Uniform{C: color.White}, image.Point{}, draw.Src)
|
||||
xdraw.ApproxBiLinear.Scale(target, target.Bounds(), source, bounds, draw.Over, nil)
|
||||
return target
|
||||
}
|
||||
|
||||
func encodeJPEG(source image.Image, quality int) ([]byte, error) {
|
||||
var buffer bytes.Buffer
|
||||
err := jpeg.Encode(&buffer, source, &jpeg.Options{Quality: quality})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return buffer.Bytes(), nil
|
||||
}
|
||||
|
||||
func dedupeKeys(keys []string) []string {
|
||||
seen := make(map[string]struct{}, len(keys))
|
||||
result := make([]string, 0, len(keys))
|
||||
for _, key := range keys {
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
if _, ok := seen[key]; ok {
|
||||
continue
|
||||
}
|
||||
seen[key] = struct{}{}
|
||||
result = append(result, key)
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
package file
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime/multipart"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strings"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrDependencyUnavailable = errors.New("dependency unavailable")
|
||||
ErrInvalidFile = errors.New("invalid file")
|
||||
)
|
||||
|
||||
const maxUploadSize = 10 * 1024 * 1024
|
||||
|
||||
var allowedContentTypes = map[string]bool{
|
||||
"image/jpeg": true,
|
||||
"image/png": true,
|
||||
"image/webp": true,
|
||||
"application/pdf": true,
|
||||
}
|
||||
|
||||
type Service struct {
|
||||
storage *Storage
|
||||
}
|
||||
|
||||
func NewService(storage *Storage) *Service {
|
||||
return &Service{storage: storage}
|
||||
}
|
||||
|
||||
func (s *Service) Upload(req uploadRequest) (*UploadDTO, error) {
|
||||
if s.storage == nil {
|
||||
return nil, ErrDependencyUnavailable
|
||||
}
|
||||
if req.Header == nil || req.Reader == nil || req.Header.Size <= 0 {
|
||||
return nil, ErrInvalidFile
|
||||
}
|
||||
data, err := readUploadData(req.Reader)
|
||||
if err != nil || len(data) == 0 || len(data) > maxUploadSize {
|
||||
return nil, ErrInvalidFile
|
||||
}
|
||||
contentType := normalizeContentType(req.ContentType, data)
|
||||
scene := normalizeScene(req.Scene)
|
||||
if !allowedContentTypes[contentType] || (scene == "chat" && !strings.HasPrefix(contentType, "image/")) {
|
||||
return nil, ErrInvalidFile
|
||||
}
|
||||
key, err := newObjectKey(scene, req.Header.Filename)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := s.storage.PutObject(req.Context, key, bytes.NewReader(data), int64(len(data)), contentType, map[string]string{
|
||||
"original-filename": req.Header.Filename,
|
||||
}); err != nil {
|
||||
return nil, fmt.Errorf("%w: %v", ErrDependencyUnavailable, err)
|
||||
}
|
||||
var thumbnailURL string
|
||||
var mediumURL string
|
||||
objectKeys := []string{key}
|
||||
for _, variant := range generateImageVariants(key, data, contentType) {
|
||||
err := s.storage.PutObject(req.Context, variant.Key, bytes.NewReader(variant.Content), int64(len(variant.Content)), variant.ContentType, map[string]string{
|
||||
"source-object": key,
|
||||
})
|
||||
if err != nil {
|
||||
continue
|
||||
}
|
||||
objectKeys = append(objectKeys, variant.Key)
|
||||
if strings.Contains(variant.Key, "."+ImageVariantThumb+".") {
|
||||
thumbnailURL = fileURLForScene(scene, variant.Key)
|
||||
}
|
||||
if strings.Contains(variant.Key, "."+ImageVariantMedium+".") {
|
||||
mediumURL = fileURLForScene(scene, variant.Key)
|
||||
}
|
||||
}
|
||||
fileURL := fileURLForScene(scene, key)
|
||||
return &UploadDTO{
|
||||
ObjectKey: key,
|
||||
URL: fileURL,
|
||||
ThumbnailURL: thumbnailURL,
|
||||
MediumURL: mediumURL,
|
||||
Filename: req.Header.Filename,
|
||||
ContentType: contentType,
|
||||
Size: int64(len(data)),
|
||||
objectKeys: objectKeys,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func readUploadData(reader multipart.File) ([]byte, error) {
|
||||
limited := io.LimitReader(reader, maxUploadSize+1)
|
||||
return io.ReadAll(limited)
|
||||
}
|
||||
|
||||
func normalizeContentType(contentType string, data []byte) string {
|
||||
contentType = strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
|
||||
if allowedContentTypes[contentType] {
|
||||
return contentType
|
||||
}
|
||||
detected := strings.ToLower(strings.TrimSpace(strings.Split(http.DetectContentType(data), ";")[0]))
|
||||
if allowedContentTypes[detected] {
|
||||
return detected
|
||||
}
|
||||
return contentType
|
||||
}
|
||||
|
||||
func fileURLForScene(scene string, key string) string {
|
||||
fileURL := "/api/files/object?key=" + url.QueryEscape(key)
|
||||
if scene == "home-banner" || scene == "avatar" || scene == "announcement" || scene == "mohong" || scene == "crash" || scene == "aw-recycle" || scene == "cooperation-feedback" || scene == "support-qrcode" {
|
||||
fileURL = "/api/public/files/object?key=" + url.QueryEscape(key)
|
||||
}
|
||||
return fileURL
|
||||
}
|
||||
|
||||
func normalizeScene(scene string) string {
|
||||
scene = strings.TrimSpace(strings.ToLower(scene))
|
||||
switch scene {
|
||||
case "listing", "handoff", "dispute", "realname", "avatar", "home-banner", "chat", "payment-cert", "announcement", "qrcode", "support-qrcode", "mohong", "crash", "aw-recycle", "cooperation-feedback", "manual-disbursement", "operating-expense":
|
||||
return scene
|
||||
case "listing_screenshot", "listing-screenshot":
|
||||
return "listing"
|
||||
case "operating_expense":
|
||||
return "operating-expense"
|
||||
default:
|
||||
return "misc"
|
||||
}
|
||||
}
|
||||
|
||||
type uploadRequest struct {
|
||||
Context context.Context
|
||||
Scene string
|
||||
Header *multipart.FileHeader
|
||||
Reader multipart.File
|
||||
ContentType string
|
||||
}
|
||||
@@ -0,0 +1,283 @@
|
||||
package file
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"crypto/rand"
|
||||
"encoding/hex"
|
||||
"fmt"
|
||||
"io"
|
||||
"mime/multipart"
|
||||
"net/url"
|
||||
"path"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"hfb_sys/backend/internal/config"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
"github.com/minio/minio-go/v7/pkg/credentials"
|
||||
)
|
||||
|
||||
type Storage struct {
|
||||
client *minio.Client
|
||||
bucket string
|
||||
bucketMu sync.Mutex
|
||||
bucketReady bool
|
||||
mirror *Storage
|
||||
mirrorErr error
|
||||
}
|
||||
|
||||
type Object struct {
|
||||
Reader io.ReadCloser
|
||||
ContentType string
|
||||
Size int64
|
||||
}
|
||||
|
||||
func NewStorage(cfg config.StorageConfig) (*Storage, error) {
|
||||
client, err := NewStorageClient(cfg)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
storage := &Storage{client: client, bucket: cfg.Bucket}
|
||||
if err := storage.ensureBucket(context.Background()); err != nil {
|
||||
return storage, err
|
||||
}
|
||||
return storage, nil
|
||||
}
|
||||
|
||||
// NewStorageClient 根据项目存储配置创建 S3 兼容客户端，供迁移工具复用。
|
||||
func NewStorageClient(cfg config.StorageConfig) (*minio.Client, error) {
|
||||
endpoint, secure, err := normalizeEndpoint(cfg.Endpoint)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lookup, err := parseBucketLookup(cfg.BucketLookup)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return minio.New(endpoint, &minio.Options{
|
||||
Creds: credentials.NewStaticV4(cfg.AccessKeyID, cfg.SecretAccessKey, ""),
|
||||
Secure: secure,
|
||||
Region: cfg.Region,
|
||||
BucketLookup: lookup,
|
||||
})
|
||||
}
|
||||
|
||||
func parseBucketLookup(raw string) (minio.BucketLookupType, error) {
|
||||
switch strings.ToLower(strings.TrimSpace(raw)) {
|
||||
case "", "auto":
|
||||
return minio.BucketLookupAuto, nil
|
||||
case "dns":
|
||||
return minio.BucketLookupDNS, nil
|
||||
case "path":
|
||||
return minio.BucketLookupPath, nil
|
||||
default:
|
||||
return minio.BucketLookupAuto, fmt.Errorf("unsupported storage bucket lookup: %s", raw)
|
||||
}
|
||||
}
|
||||
|
||||
// SetMirror 启用迁移期间的同步双写。镜像端不可用时上传会失败，避免出现未同步的业务文件。
|
||||
func (s *Storage) SetMirror(mirror *Storage, err error) {
|
||||
s.mirror = mirror
|
||||
s.mirrorErr = err
|
||||
}
|
||||
|
||||
func (s *Storage) Put(ctx context.Context, scene string, header *multipart.FileHeader, reader io.Reader, contentType string) (string, error) {
|
||||
key, err := newObjectKey(scene, header.Filename)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
if err := s.PutObject(ctx, key, reader, header.Size, contentType, map[string]string{
|
||||
"original-filename": header.Filename,
|
||||
}); err != nil {
|
||||
return "", err
|
||||
}
|
||||
return key, nil
|
||||
}
|
||||
|
||||
func (s *Storage) PutObject(ctx context.Context, key string, reader io.Reader, size int64, contentType string, metadata map[string]string) error {
|
||||
if s.mirrorErr != nil {
|
||||
return fmt.Errorf("storage mirror unavailable: %w", s.mirrorErr)
|
||||
}
|
||||
if s.mirror == nil {
|
||||
return s.putObject(ctx, key, reader, size, contentType, metadata)
|
||||
}
|
||||
|
||||
// 当前文件上传大小被限制在 10MB；镜像写入前缓存在内存中，确保两个端点得到完全相同的字节流。
|
||||
data, err := io.ReadAll(reader)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.putObject(ctx, key, bytes.NewReader(data), int64(len(data)), contentType, metadata); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := s.mirror.putObject(ctx, key, bytes.NewReader(data), int64(len(data)), contentType, metadata); err != nil {
|
||||
return fmt.Errorf("storage mirror upload failed: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Storage) putObject(ctx context.Context, key string, reader io.Reader, size int64, contentType string, metadata map[string]string) error {
|
||||
if err := s.ensureBucketReady(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := s.client.PutObject(ctx, s.bucket, key, reader, size, minio.PutObjectOptions{
|
||||
ContentType: contentType,
|
||||
UserMetadata: sanitizeObjectMetadata(metadata),
|
||||
})
|
||||
if isNoSuchBucketError(err) && rewindReader(reader) == nil {
|
||||
s.markBucketNotReady()
|
||||
if readyErr := s.ensureBucketReady(ctx); readyErr != nil {
|
||||
return readyErr
|
||||
}
|
||||
_, err = s.client.PutObject(ctx, s.bucket, key, reader, size, minio.PutObjectOptions{
|
||||
ContentType: contentType,
|
||||
UserMetadata: sanitizeObjectMetadata(metadata),
|
||||
})
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Storage) Get(ctx context.Context, key string) (*Object, error) {
|
||||
object, err := s.client.GetObject(ctx, s.bucket, key, minio.GetObjectOptions{})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
info, err := object.Stat()
|
||||
if err != nil {
|
||||
_ = object.Close()
|
||||
return nil, err
|
||||
}
|
||||
return &Object{
|
||||
Reader: object,
|
||||
ContentType: info.ContentType,
|
||||
Size: info.Size,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// RemoveObjects 删除主存储与镜像中的对象，返回第一个错误；对象不存在视为成功。
|
||||
func (s *Storage) RemoveObjects(ctx context.Context, keys []string) error {
|
||||
var firstErr error
|
||||
for _, key := range keys {
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
if err := s.removeObject(ctx, key); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
if s.mirror != nil {
|
||||
if err := s.mirror.removeObject(ctx, key); err != nil && firstErr == nil {
|
||||
firstErr = err
|
||||
}
|
||||
}
|
||||
}
|
||||
return firstErr
|
||||
}
|
||||
|
||||
func (s *Storage) removeObject(ctx context.Context, key string) error {
|
||||
if err := s.ensureBucketReady(ctx); err != nil {
|
||||
return err
|
||||
}
|
||||
err := s.client.RemoveObject(ctx, s.bucket, key, minio.RemoveObjectOptions{})
|
||||
if minio.ToErrorResponse(err).Code == "NoSuchKey" {
|
||||
return nil
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Storage) ensureBucket(ctx context.Context) error {
|
||||
exists, err := s.client.BucketExists(ctx, s.bucket)
|
||||
if err != nil {
|
||||
errResp := minio.ToErrorResponse(err)
|
||||
if errResp.Code != "NoSuchBucket" && !strings.Contains(strings.ToLower(err.Error()), "bucket does not exist") {
|
||||
return err
|
||||
}
|
||||
}
|
||||
if exists {
|
||||
s.bucketReady = true
|
||||
return nil
|
||||
}
|
||||
if err := s.client.MakeBucket(ctx, s.bucket, minio.MakeBucketOptions{}); err != nil {
|
||||
return err
|
||||
}
|
||||
s.bucketReady = true
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Storage) ensureBucketReady(ctx context.Context) error {
|
||||
s.bucketMu.Lock()
|
||||
defer s.bucketMu.Unlock()
|
||||
if s.bucketReady {
|
||||
return nil
|
||||
}
|
||||
return s.ensureBucket(ctx)
|
||||
}
|
||||
|
||||
func (s *Storage) markBucketNotReady() {
|
||||
s.bucketMu.Lock()
|
||||
defer s.bucketMu.Unlock()
|
||||
s.bucketReady = false
|
||||
}
|
||||
|
||||
func isNoSuchBucketError(err error) bool {
|
||||
if err == nil {
|
||||
return false
|
||||
}
|
||||
errResp := minio.ToErrorResponse(err)
|
||||
if errResp.Code == "NoSuchBucket" {
|
||||
return true
|
||||
}
|
||||
return strings.Contains(strings.ToLower(err.Error()), "bucket does not exist")
|
||||
}
|
||||
|
||||
func rewindReader(reader io.Reader) error {
|
||||
seeker, ok := reader.(io.Seeker)
|
||||
if !ok {
|
||||
return fmt.Errorf("reader cannot rewind")
|
||||
}
|
||||
_, err := seeker.Seek(0, io.SeekStart)
|
||||
return err
|
||||
}
|
||||
|
||||
func sanitizeObjectMetadata(metadata map[string]string) map[string]string {
|
||||
if len(metadata) == 0 {
|
||||
return nil
|
||||
}
|
||||
sanitized := make(map[string]string, len(metadata))
|
||||
for key, value := range metadata {
|
||||
key = strings.TrimSpace(key)
|
||||
if key == "" {
|
||||
continue
|
||||
}
|
||||
// MinIO/S3 用户元数据会作为 HTTP header 发送，值统一转义为 ASCII，避免中文文件名导致上传失败。
|
||||
sanitized[key] = url.QueryEscape(value)
|
||||
}
|
||||
return sanitized
|
||||
}
|
||||
|
||||
func normalizeEndpoint(raw string) (string, bool, error) {
|
||||
parsed, err := url.Parse(raw)
|
||||
if err != nil {
|
||||
return "", false, err
|
||||
}
|
||||
if parsed.Scheme == "" {
|
||||
return raw, false, nil
|
||||
}
|
||||
return parsed.Host, parsed.Scheme == "https", nil
|
||||
}
|
||||
|
||||
func newObjectKey(scene string, filename string) (string, error) {
|
||||
if scene == "" {
|
||||
scene = "misc"
|
||||
}
|
||||
scene = strings.ToLower(scene)
|
||||
now := time.Now()
|
||||
token := make([]byte, 12)
|
||||
if _, err := rand.Read(token); err != nil {
|
||||
return "", err
|
||||
}
|
||||
ext := strings.ToLower(path.Ext(filename))
|
||||
return fmt.Sprintf("%s/%04d/%02d/%02d/%s%s", scene, now.Year(), now.Month(), now.Day(), hex.EncodeToString(token), ext), nil
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package file
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/minio/minio-go/v7"
|
||||
)
|
||||
|
||||
func TestSanitizeObjectMetadataEscapesNonASCII(t *testing.T) {
|
||||
got := sanitizeObjectMetadata(map[string]string{
|
||||
"original-filename": "游戏ID截图 1.png",
|
||||
})
|
||||
|
||||
if got["original-filename"] != "%E6%B8%B8%E6%88%8FID%E6%88%AA%E5%9B%BE+1.png" {
|
||||
t.Fatalf("metadata filename = %q", got["original-filename"])
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseBucketLookup(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
raw string
|
||||
want minio.BucketLookupType
|
||||
}{
|
||||
{name: "auto", raw: "auto", want: minio.BucketLookupAuto},
|
||||
{name: "dns", raw: "dns", want: minio.BucketLookupDNS},
|
||||
{name: "path", raw: "path", want: minio.BucketLookupPath},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got, err := parseBucketLookup(tt.raw)
|
||||
if err != nil || got != tt.want {
|
||||
t.Fatalf("parseBucketLookup(%q) = %v, %v", tt.raw, got, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
if _, err := parseBucketLookup("invalid"); err == nil {
|
||||
t.Fatal("invalid bucket lookup should fail")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAnnouncementSceneUsesPublicFileURL(t *testing.T) {
|
||||
key := "announcement/2026/06/15/example.webp"
|
||||
got := fileURLForScene("announcement", key)
|
||||
|
||||
if !strings.HasPrefix(got, "/api/public/files/object?") {
|
||||
t.Fatalf("announcement file url = %q, want public file endpoint", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeSceneAllowsAnnouncement(t *testing.T) {
|
||||
if got := normalizeScene("announcement"); got != "announcement" {
|
||||
t.Fatalf("normalize announcement scene = %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAWRecycleSceneUsesPublicFileURL(t *testing.T) {
|
||||
if got := normalizeScene("aw-recycle"); got != "aw-recycle" {
|
||||
t.Fatalf("normalize aw-recycle scene = %q", got)
|
||||
}
|
||||
key := "aw-recycle/2026/07/19/example.webp"
|
||||
got := fileURLForScene("aw-recycle", key)
|
||||
if !strings.HasPrefix(got, "/api/public/files/object?") {
|
||||
t.Fatalf("aw-recycle file url = %q, want public file endpoint", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCooperationFeedbackSceneUsesPublicFileURL(t *testing.T) {
|
||||
if got := normalizeScene("cooperation-feedback"); got != "cooperation-feedback" {
|
||||
t.Fatalf("normalize cooperation-feedback scene = %q", got)
|
||||
}
|
||||
key := "cooperation-feedback/2026/07/19/example.webp"
|
||||
got := fileURLForScene("cooperation-feedback", key)
|
||||
if !strings.HasPrefix(got, "/api/public/files/object?") {
|
||||
t.Fatalf("cooperation-feedback file url = %q, want public file endpoint", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSupportQrcodeSceneUsesPublicFileURL(t *testing.T) {
|
||||
if got := normalizeScene("support-qrcode"); got != "support-qrcode" {
|
||||
t.Fatalf("normalize support-qrcode scene = %q", got)
|
||||
}
|
||||
got := fileURLForScene("support-qrcode", "support-qrcode/2026/09/25/example.png")
|
||||
if !strings.HasPrefix(got, "/api/public/files/object?") {
|
||||
t.Fatalf("support-qrcode file url = %q, want public file endpoint", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeSceneListingScreenshotAndOperatingExpense(t *testing.T) {
|
||||
if got := normalizeScene("listing_screenshot"); got != "listing" {
|
||||
t.Fatalf("normalize listing_screenshot scene = %q, want listing", got)
|
||||
}
|
||||
if got := normalizeScene("listing-screenshot"); got != "listing" {
|
||||
t.Fatalf("normalize listing-screenshot scene = %q, want listing", got)
|
||||
}
|
||||
if got := normalizeScene("operating-expense"); got != "operating-expense" {
|
||||
t.Fatalf("normalize operating-expense scene = %q, want operating-expense", got)
|
||||
}
|
||||
if got := normalizeScene("operating_expense"); got != "operating-expense" {
|
||||
t.Fatalf("normalize operating_expense scene = %q, want operating-expense", got)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user