分块存储模型迁移：从单文件加密到目录分块存储

type ChunkMeta struct {
    Version      int    `json:"version"`      // 版本号
    Name         string `json:"name"`         // 原始文件名
    MimeType     string `json:"mimeType"`     // MIME 类型
    OriginalSize int64  `json:"originalSize"` // 原始大小
    ChunkSize    int    `json:"chunkSize"`    // 分块大小（固定 5MB）
    TotalChunks  int    `json:"totalChunks"`  // 总分块数
}

func (s *Server) uploadFile(c *gin.Context) {
    // 1. 生成文件 ID 和密钥
    fileID := uuid.New().String()
    fileKey := crypto.DeriveFileKey(s.masterKey, fileID)
    
    // 2. 计算分块信息
    chunkSize := s.encryptor.GetChunkSize() // 5MB
    totalChunks := int((header.Size + int64(chunkSize) - 1) / int64(chunkSize))
    
    // 3. 逐块读取、加密、上传
    buffer := make([]byte, chunkSize)
    for i := 0; i < totalChunks; i++ {
        n, _ := io.ReadFull(file, buffer)
        
        // 加密分块（无长度前缀）
        encrypted, _ := s.encryptor.EncryptChunkSimple(buffer[:n], fileKey)
        
        // 上传到独立的 S3 对象
        chunkKey := fmt.Sprintf("files/%s/chunks/%d.enc", fileID, i)
        s.s3.UploadBytes(ctx, chunkKey, encrypted, "application/octet-stream")
    }
    
    // 4. 创建并上传分块元数据
    chunkMeta := &crypto.ChunkMeta{
        Version:      crypto.Version,
        Name:         header.Filename,
        MimeType:     mimeType,
        OriginalSize: header.Size,
        ChunkSize:    chunkSize,
        TotalChunks:  totalChunks,
    }
    encryptedMeta, _ := s.encryptor.EncryptJSON(chunkMeta, fileKey)
    metaKey := fmt.Sprintf("files/%s/meta.enc", fileID)
    s.s3.UploadBytes(ctx, metaKey, encryptedMeta, "application/octet-stream")
    
    // 5. 更新元数据索引
    s.updateMetadataIndex(ctx, &metadata)
}

func (s *Server) downloadFile(c *gin.Context) {
    // 1. 加载分块元数据
    chunkMeta, _ := s.loadChunkMeta(ctx, fileID, fileKey)
    
    // 2. 逐块下载并解密
    var result bytes.Buffer
    for i := 0; i < chunkMeta.TotalChunks; i++ {
        chunkKey := fmt.Sprintf("files/%s/chunks/%d.enc", fileID, i)
        chunkData, _ := s.s3.DownloadBytes(ctx, chunkKey)
        
        decrypted, _ := s.encryptor.DecryptChunkSimple(chunkData, fileKey)
        result.Write(decrypted)
    }
    
    c.Data(http.StatusOK, chunkMeta.MimeType, result.Bytes())
}

func (s *Server) deleteFile(c *gin.Context) {
    // 使用前缀删除整个目录
    filePrefix := fmt.Sprintf("files/%s/", fileID)
    s.s3.DeletePrefix(ctx, filePrefix)
    
    // 更新元数据索引
    s.removeFromMetadataIndex(ctx, fileID)
}

func (s *Server) renameFile(c *gin.Context) {
    // 加载 ChunkMeta
    chunkMeta, _ := s.loadChunkMeta(ctx, fileID, fileKey)
    
    // 修改文件名
    chunkMeta.Name = req.Name
    chunkMeta.MimeType = detectMimeType(req.Name)
    
    // 重新加密并上传 ChunkMeta（分块数据不变）
    encryptedMeta, _ := s.encryptor.EncryptJSON(chunkMeta, fileKey)
    metaKey := fmt.Sprintf("files/%s/meta.enc", fileID)
    s.s3.UploadBytes(ctx, metaKey, encryptedMeta, "application/octet-stream")
}

func (s *Server) updateMetadataIndex(ctx context.Context, file *FileMetadata) error {
    meta, _ := s.loadMetadataIndex(ctx)   // 1. 读取
    meta.Files[file.ID] = file             // 2. 修改
    return s.saveMetadataIndex(ctx, meta)  // 3. 保存
}

type Server struct {
    metaUpdateChan chan *metaUpdateRequest
}
 
type metaUpdateRequest struct {
    file *FileMetadata
    done chan error
}
 
// 元数据批量写入 worker
func (s *Server) metaWriterWorker() {
    const (
        maxBatchSize = 20
        batchTimeout = 10 * time.Millisecond
    )
    
    var pending []*metaUpdateRequest
    var timer <-chan time.Time
    
    for {
        select {
        case req := <-s.metaUpdateChan:
            pending = append(pending, req)
            if len(pending) == 1 {
                timer = time.After(batchTimeout)
            }
            if len(pending) >= maxBatchSize {
                s.flushMetaUpdates(pending)
                pending = nil
                timer = nil
            }
        case <-timer:
            if len(pending) > 0 {
                s.flushMetaUpdates(pending)
                pending = nil
            }
            timer = nil
        }
    }
}
 
func (s *Server) flushMetaUpdates(requests []*metaUpdateRequest) {
    meta, _ := s.loadMetadataIndex(ctx)
    
    // 批量添加所有文件
    for _, req := range requests {
        meta.Files[req.file.ID] = req.file
    }
    
    err := s.saveMetadataIndex(ctx, meta)
    
    // 通知所有等待者
    for _, req := range requests {
        req.done <- err
    }
}