Golang实现的SDFS - 符号链接分布式文件系统

这是一个非常有意思的项目！SDFS的设计理念确实解决了分布式文件系统扩展性和维护复杂性的关键问题。以下是技术层面的分析：

架构优势分析

符号链接方式的分布式文件系统有几个显著优势：

1. 无缝扩展 - 新存储节点可以随时加入，只需更新符号链接映射
2. 数据迁移简单 - 文件移动只需更新元数据，无需物理复制
3. 故障恢复快速 - 单点故障不影响其他节点的数据访问

核心实现示例

基于你的设计思路，这里是一个简化的SDFS元数据管理实现：

package sdfs

import (
    "encoding/json"
    "sync"
    "path/filepath"
)

type StorageNode struct {
    ID       string `json:"id"`
    Host     string `json:"host"`
    Port     int    `json:"port"`
    Capacity int64  `json:"capacity"`
    Used     int64  `json:"used"`
}

type FileMetadata struct {
    FileName    string `json:"file_name"`
    LogicalPath string `json:"logical_path"`
    ActualPath  string `json:"actual_path"` // 符号链接指向的实际路径
    NodeID      string `json:"node_id"`
    Size        int64  `json:"size"`
    Checksum    string `json:"checksum"`
}

type MetadataManager struct {
    mu        sync.RWMutex
    nodes     map[string]*StorageNode
    fileMap   map[string]*FileMetadata
    nodeIndex map[string][]string // nodeID -> []filePaths
}

func (m *MetadataManager) AddStorageNode(node *StorageNode) error {
    m.mu.Lock()
    defer m.mu.Unlock()
    
    m.nodes[node.ID] = node
    m.nodeIndex[node.ID] = make([]string, 0)
    return nil
}

func (m *MetadataManager) StoreFile(logicalPath string, nodeID string, actualPath string, size int64) error {
    m.mu.Lock()
    defer m.mu.Unlock()
    
    metadata := &FileMetadata{
        FileName:    filepath.Base(logicalPath),
        LogicalPath: logicalPath,
        ActualPath:  actualPath,
        NodeID:      nodeID,
        Size:        size,
    }
    
    m.fileMap[logicalPath] = metadata
    m.nodeIndex[nodeID] = append(m.nodeIndex[nodeID], logicalPath)
    
    // 更新节点使用量
    if node, exists := m.nodes[nodeID]; exists {
        node.Used += size
    }
    
    return nil
}

func (m *MetadataManager) ResolvePath(logicalPath string) (*FileMetadata, error) {
    m.mu.RLock()
    defer m.mu.RUnlock()
    
    if metadata, exists := m.fileMap[logicalPath]; exists {
        return metadata, nil
    }
    return nil, ErrFileNotFound
}

符号链接管理示例

package sdfs

import (
    "os"
    "path/filepath"
)

type SymbolicLinkManager struct {
    baseLogicalPath string
}

func (s *SymbolicLinkManager) CreateSymbolicLink(logicalPath, actualPath string) error {
    fullLogicalPath := filepath.Join(s.baseLogicalPath, logicalPath)
    
    // 确保目录存在
    if err := os.MkdirAll(filepath.Dir(fullLogicalPath), 0755); err != nil {
        return err
    }
    
    // 创建符号链接
    return os.Symlink(actualPath, fullLogicalPath)
}

func (s *SymbolicLinkManager) ResolveSymbolicLink(logicalPath string) (string, error) {
    fullPath := filepath.Join(s.baseLogicalPath, logicalPath)
    return os.Readlink(fullPath)
}

客户端API示例

package sdfs

import (
    "context"
    "io"
)

type SDFSClient struct {
    metadataManager *MetadataManager
    linkManager     *SymbolicLinkManager
}

func (c *SDFSClient) UploadFile(ctx context.Context, logicalPath string, data io.Reader) error {
    // 选择存储节点（基于负载均衡策略）
    targetNode := c.selectStorageNode()
    
    // 实际存储文件到目标节点
    actualPath, err := c.storeToNode(ctx, targetNode.ID, data)
    if err != nil {
        return err
    }
    
    // 更新元数据
    if err := c.metadataManager.StoreFile(logicalPath, targetNode.ID, actualPath, 0); err != nil {
        return err
    }
    
    // 创建符号链接
    return c.linkManager.CreateSymbolicLink(logicalPath, actualPath)
}

func (c *SDFSClient) DownloadFile(ctx context.Context, logicalPath string) (io.ReadCloser, error) {
    // 解析符号链接获取实际路径
    metadata, err := c.metadataManager.ResolvePath(logicalPath)
    if err != nil {
        return nil, err
    }
    
    // 从实际存储节点读取文件
    return c.retrieveFromNode(ctx, metadata.NodeID, metadata.ActualPath)
}

这个架构通过符号链接抽象了物理存储位置，实现了你提到的三个设计目标。项目的扩展性主要体现在元数据管理和节点发现机制上，期待看到更多技术实现的细节！