用 Go 实现配置中心 Part 2

// pkg/storage/storage.go
// 底层存储接口
type Storage interface {
    // 切换命名空间, 类似于 MySQL 中的 use
	Use(ctx context.Context, namespace string) (err error)
    // 读取文件内容
	Read(path string) (content string, err error)
}

// pkg/storage/storage.go
// Provider 底层存储接口
type Provider interface {
	// Provide 提供 namespace 对应的只读文件系统
	Provide(ctx context.Context, namespace string) (fs ReadonlyFs, err error)
}

// ReadonlyFs 只读文件系统
type ReadonlyFs interface {
	io.Closer

	// Open 返回一个以 O_RDONLY 模式打开的文件.
	Open(name string) (ReadonlyFile, error)
}

// ReadonlyFile 只读文件
type ReadonlyFile interface {
	io.ReadCloser
}

.             # 工作目录
├── .git      # 本地数据库
└── README.md # 工作目录中的文件

# 首先, 克隆远程仓库但是不检出任何分支.
git clone --no-checkout https://github.com/github/gitignore.git && cd gitignore

# 在 master 目录下检出 master 分支
mkdir master && git --work-tree=master checkout -f master

# 在 ghfw 目录下检出 ghfw 分支
mkdir ghfw && git --work-tree=ghfw checkout -f ghfw

# 目录结构
ls -a
# .  ..  .git  ghfw  master

// pkg/storage/git.go
// ...
func (g *Git) Provide(ctx context.Context, namespace string) (fs ReadonlyFs, err error) {
	// 检查 fetch 缓存, 在必要时执行 fetch
    if !g.skipFetch() {
		if err = g.fetch(ctx); err != nil {
			return
		}
	}

    // 查找 namespace 对应的 branch, 若不存在则返回 error
	var branch plumbing.ReferenceName
	if branch, err = g.findBranch(namespace); err != nil {
		return
	}

    // 检查 checkout 缓存, 在必要时执行 checkout
	if !g.skipCheckout(branch) {
		if err = g.checkout(branch); err != nil {
			return
		}
	}
	return g.infos[branch].fs, nil
}
// ...

// pkg/storage/git.go
// ...
// Git 是一个基于 Git 的多命名空间文件系统
type Git struct {
	URL      string                              // 远程仓库地址
	Auth     transport.AuthMethod                // 身份验证信息
	FetchTTL time.Duration                       // Fetch TTL

	store    storage.Storer                      // .git 对象
	remote   *Remote                             // 远程仓库对象
	lock     sync.Locker                         // 锁
	syncTime time.Time                           // 最后一次 fetch 的时间
	infos    map[plumbing.ReferenceName]info     // 分支信息
}

func NewGit(URL string) *Git {
	store := memory.NewStorage() // 我们将 .git 保存在内存中
	remote := NewRemote(store, &config.RemoteConfig{
		Name:  "origin",
		URLs:  []string{URL},
		Fetch: []config.RefSpec{"refs/heads/*:refs/heads/*"}, // 只拉取 branch, 忽略 tag
	})

	return &Git{
		URL:      URL,
		FetchTTL: DefaultFetchTTL,
		lock:     &sync.Mutex{},
		store:    store,
		remote:   remote,
		infos:    make(map[plumbing.ReferenceName]info),
	}
}
// ...

// pkg/storage/git.go
// ...
func (g *Git) fetch(ctx context.Context) (err error) {
	g.lock.Lock()
	defer g.lock.Unlock()

	if err = g.remote.FetchContext(ctx, &FetchOptions{
		RefSpecs: g.remote.Config().Fetch,
		Auth:     g.Auth,
		Force:    true,      // 强制覆盖本地文件, 避免冲突
		Progress: os.Stderr, // 输出调试信息
	}); errors.Is(err, NoErrAlreadyUpToDate) ||
		errors.Is(err, transport.ErrEmptyUploadPackRequest) {
		// 如果远程仓库没有变化, 或者本地仓库没有变化 go-git 会返回 error,
		// 这里我们忽略它
		err = nil
	} else if err != nil {
		return
	}

	// 检出后没有自动设置 HEAD, 需要手工设置一下
	ref := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.Master)
	if err = g.store.SetReference(ref); err != nil {
		return
	}
	// 更新本地缓存信息
	if err = g.updateRefs(); err != nil {
		return
	}

	log.Println("Fetch: OK")
	return
}
// ...

// pkg/storage/git.go
// ...
func (g *Git) checkout(branch plumbing.ReferenceName) (err error) {
	g.lock.Lock()
	defer g.lock.Unlock()

	var (
		repo *Repository               // Git 仓库
		wt   *Worktree                 // 工作目录
		head *plumbing.Reference       // 当前分支的 head
		fs   internalFs                // 只读文件系统 (适配 billy.FileSystem)
	)
	fs.Filesystem = memfs.New()        // 工作目录也在内存中

	// 打开 Git 仓库
    if repo, err = Open(g.store, fs.Filesystem); err != nil {
		return
	}
    // 获取工作目录, 实际上就是 fs.Filesystem
	if wt, err = repo.Worktree(); err != nil {
		return
	}
	// 强制检出目标分支到内存文件系统
	if err = wt.Checkout(&CheckoutOptions{
		Branch: branch,
		Force:  true,
	}); err != nil {
		return
	}
	// 获取当前分支 HEAD, 用于缓存
	if head, err = repo.Head(); err != nil {
		return
	}
	// 更新缓存信息
	old := g.infos[branch]
	g.infos[branch] = info{
		remote: old.remote,
		local:  head.Hash(),
		fs:     fs,
	}

	log.Println("Checkout: OK")
	return
}
// ...

// pkg/storage/git.go
// ...
// info 记录了分支信息
type info struct {
	remote plumbing.Hash  // 远程分支的 HEAD, git fetch 时更新
	local  plumbing.Hash  // 本地分支的 HEAD, git checkout 时更新
	fs     internalFs     // 工作目录, 只读文件系统
}

// SameHash 当本地和远程 HEAD 相同时返回 true
func (i info) SameHash() bool {
	return i.local == i.remote
}

type Git struct {
    // ...
	syncTime time.Time                       // 最后一次成功 fetch 的时间
	infos    map[plumbing.ReferenceName]info // 分支信息缓存
}
// ...

// pkg/storage/git.go
// ...
// skipFetch 当上次 fetch 时间距今小于 TTL 时返回 true
func (g *Git) skipFetch() bool { return time.Since(g.syncTime) < g.FetchTTL }

// skipCheckout 当 branch 本地与远程 HEAD 相同时返回 true
func (g *Git) skipCheckout(branch plumbing.ReferenceName) bool { return g.infos[branch].SameHash() }
// ...