Go语言中构建可靠数据存储的原子性与持久化策略

// 确保目标目录存在，如果不存在则创建
if err := os.MkdirAll(document.FileDirectory(), 0600); err != nil {
    return "", err
}

// 创建一个临时文件
file, err := os.Create(document.TmpFile())
if err != nil {
    return "", err
}
defer file.Close() // 确保文件最终被关闭

// 将数据写入临时文件
file.Write(document.Data)

// 强制将文件数据和元数据同步到物理存储
if err := file.Sync(); err != nil {
    return "", err
}

// 关闭文件，释放资源
file.Close() // defer 语句在这里确保了文件关闭，但为了逻辑清晰，也可以显式关闭

// 将临时文件原子性重命名为最终文件
if err := os.Rename(document.TmpFile(), document.File()); err != nil {
    // 如果重命名失败，尝试删除临时文件以清理
    os.Remove(document.TmpFile()) // 忽略删除错误
    return "", err
}

package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io/ioutil"
    "os"
    "path/filepath"
)

// Document 结构体模拟存储的数据
type Document struct {
    ID   string
    Data []byte
    HashValue string // 存储数据的哈希值
    BaseDir string // 基础存储目录
}

// NewDocument 创建一个新的Document实例
func NewDocument(id string, data []byte, baseDir string) *Document {
    h := sha256.New()
    h.Write(data)
    hash := hex.EncodeToString(h.Sum(nil))
    return &Document{
        ID:   id,
        Data: data,
        HashValue: hash,
        BaseDir: baseDir,
    }
}

// FileDirectory 根据哈希值生成文件所在的目录路径
func (d Document) FileDirectory() string {
    if len(d.HashValue) < 4 {
        return filepath.Join(d.BaseDir, d.ID) // 如果哈希不够长，则直接使用ID
    }
    return filepath.Join(d.BaseDir, d.HashValue[0:2], d.HashValue[2:4])
}

// File 生成最终文件路径
func (d Document) File() string {
    if len(d.HashValue) < 4 {
        return filepath.Join(d.FileDirectory(), d.ID)
    }
    return filepath.Join(d.FileDirectory(), d.HashValue[4:])
}

// TmpFile 生成临时文件路径
func (d Document) TmpFile() string {
    return d.File() + ".tmp"
}

// Hash 返回文档数据的哈希值
func (d Document) Hash() string {
    return d.HashValue
}

// Save 方法实现原子性与持久化数据存储
func (d Document) Save() (hash string, err error) {
    // 1. 确保目标目录存在
    // 权限 0600 对目录来说不常见，通常是 0700 或 0755。这里沿用原始示例。
    if err := os.MkdirAll(d.FileDirectory(), 0600); err != nil {
        return "", fmt.Errorf("创建目录失败: %w", err)
    }

    // 2. 创建临时文件
    file, err := os.Create(d.TmpFile())
    if err != nil {
        return "", fmt.Errorf("创建临时文件失败: %w", err)
    }
    // 使用 defer 确保文件描述符最终被关闭，即使在函数中间返回
    // 但在文件同步后立即关闭更符合原子性操作的流程，这里选择显式关闭
    // defer file.Close()

    // 3. 写入数据
    if _, err := file.Write(d.Data); err != nil {
        file.Close() // 写入失败也要关闭文件
        os.Remove(d.TmpFile()) // 清理临时文件
        return "", fmt.Errorf("写入数据失败: %w", err)
    }

    // 4. 强制同步数据到物理存储
    if err := file.Sync(); err != nil {
        file.Close() // 同步失败也要关闭文件
        os.Remove(d.TmpFile()) // 清理临时文件
        return "", fmt.Errorf("同步文件失败: %w", err)
    }

    // 5. 关闭文件
    if err := file.Close(); err != nil {
        os.Remove(d.TmpFile()) // 关闭失败也要清理临时文件
        return "", fmt.Errorf("关闭文件失败: %w", err)
    }

    // 6. 原子性重命名临时文件为最终文件
    if err := os.Rename(d.TmpFile(), d.File()); err != nil {
        // 重命名失败时，尝试删除临时文件以清理，忽略删除错误
        _ = os.Remove(d.TmpFile())
        return "", fmt.Errorf("重命名文件失败: %w", err)
    }

    return d.Hash(), nil
}

func main() {
    baseStorageDir := "./data_store"
    doc1 := NewDocument("doc1", []byte("Hello, this is some important data for document 1."), baseStorageDir)
    doc2 := NewDocument("doc2", []byte("Another piece of data for document 2."), baseStorageDir)

    fmt.Printf("Saving document 1 (Hash: %s)...\n", doc1.Hash())
    hash1, err := doc1.Save()
    if err != nil {
        fmt.Printf("Error saving doc1: %v\n", err)
    } else {
        fmt.Printf("Document 1 saved successfully with hash: %s\n", hash1)
        // 验证文件是否存在
        finalPath := doc1.File()
        if _, err := os.Stat(finalPath); os.IsNotExist(err) {
            fmt.Printf("Error: Document 1 file not found at %s\n", finalPath)
        } else {
            fmt.Printf("Document 1 is at: %s\n", finalPath)
            content, _ := ioutil.ReadFile(finalPath)
            fmt.Printf("Content: %s\n", string(content))
        }
    }

    fmt.Printf("\nSaving document 2 (Hash: %s)...\n", doc2.Hash())
    hash2, err := doc2.Save()
    if err != nil {
        fmt.Printf("Error saving doc2: %v\n", err)
    } else {
        fmt.Printf("Document 2 saved successfully with hash: %s\n", hash2)
        finalPath := doc2.File()
        if _, err := os.Stat(finalPath); os.IsNotExist(err) {
            fmt.Printf("Error: Document 2 file not found at %s\n", finalPath)
        } else {
            fmt.Printf("Document 2 is at: %s\n", finalPath)
            content, _ := ioutil.ReadFile(finalPath)
            fmt.Printf("Content: %s\n", string(content))
        }
    }

    // 清理创建的目录和文件
    // os.RemoveAll(baseStorageDir)
    // fmt.Printf("\nCleaned up directory: %s\n", baseStorageDir)
}