eclipse/lib/gitcache/gitcache.go

// Copyright (C) 2024  Umorpha Systems
// SPDX-License-Identifier: AGPL-3.0-or-later

package gitcache

import (
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"sync"
	"time"
)

const (
	tsDir  = "x-gitcache-ts"
	tmpDir = "x-gitcache-tmp"
)

type Cache struct {
	Dir       string
	MinPeriod time.Duration

	initOnce sync.Once
	initErr  error
}

// "ll" stands for "low level" /////////////////////////////////////////////////

func (cache *Cache) llInit(stderr io.Writer) error {
	fmt.Fprintf(stderr, "[gitcache] Initializing cache...\n")
	cmd := exec.Command("git", "-c", "init.defaultBranch=main", "init", "--bare", cache.Dir)
	cmd.Stderr = stderr
	if err := cmd.Run(); err != nil {
		return err
	}
	if err := mkdirAllowExisting(filepath.Join(cache.Dir, tsDir)); err != nil {
		return err
	}
	return nil
}

func (cache *Cache) llFetch(stderr io.Writer, namespace, url string) error {
	fmt.Fprintf(stderr, "[gitcache] Fetching %q...\n", url)
	cmd := exec.Command("git",
		"fetch",
		"--no-write-fetch-head",
		"--no-recurse-submodules",
		"--no-tags",
		"--prune",
		"--force",
		"--",
		url, "*:refs/namespaces/"+namespace+"/*")
	cmd.Dir = cache.Dir
	cmd.Stderr = stderr
	return cmd.Run()
}

////////////////////////////////////////////////////////////////////////////////

func (cache *Cache) init(stderr io.Writer) error {
	cache.initOnce.Do(func() {
		cache.initErr = cache.llInit(stderr)
	})
	if err := mkdirAllowExisting(filepath.Join(cache.Dir, tmpDir)); err != nil {
		return err
	}
	return cache.initErr
}

func (cache *Cache) Fetch(stderr io.Writer, url string) error {
	if err := cache.init(stderr); err != nil {
		return err
	}
	namespace := URL2NS(url)
	tsFile := filepath.Join(cache.Dir, tsDir, namespace)
	if cache.MinPeriod != 0 {
		ts, err := mtime(tsFile)
		if err == nil && ts.Add(cache.MinPeriod).After(time.Now()) {
			return nil
		}
	}
	if err := cache.llFetch(stderr, namespace, url); err != nil {
		return err
	}
	return touch(tsFile)
}

func (cache *Cache) Clone(stderr io.Writer, url, dir string, flags ...string) error {
	if err := cache.init(stderr); err != nil {
		return err
	}

	namespace := URL2NS(url)
	if _, err := mtime(filepath.Join(cache.Dir, tsDir, namespace)); err != nil {
		return fmt.Errorf("repo does not exist: %q", url)
	}

	cacheDir, err := filepath.Abs(cache.Dir)
	if err != nil {
		return err
	}
	cacheURL := "ext::git --namespace " + namespace + " %s " + cacheDir

	fmt.Fprintf(stderr, "[gitcache] Cloning %q to %q...\n", url, dir)
	cmd := exec.Command("git", append(append([]string{
		"-c", "protocol.ext.allow=user",
		"-c", "url." + cacheURL + ".insteadOf=" + url,
		"clone",
	}, flags...), "--", url, dir)...)
	cmd.Stderr = stderr
	if err := cmd.Run(); err != nil {
		return err
	}

	return nil
}

func (cache *Cache) RevParse(stderr io.Writer, url string, revs ...string) (_ []string, err error) {
	maybeSetErr := func(_err error) {
		if err == nil && _err != nil {
			err = _err
		}
	}

	if err := cache.init(stderr); err != nil {
		return nil, err
	}

	namespace := URL2NS(url)
	if _, err := mtime(filepath.Join(cache.Dir, tsDir, namespace)); err != nil {
		return nil, fmt.Errorf("repo does not exist: %q", url)
	}

	if len(revs) == 0 {
		return nil, nil
	}

	// `git rev-parse` doesn't obey `--namespace`, so we have to
	// create a temporary clone to do this :(
	//
	// Don't use .Clone(), so we can use hardlinks to reduce the
	// cost of this.
	fmt.Fprintf(stderr, "[gitcache] Creating temporary view of %q...\n", url)
	tmpdir, err := os.MkdirTemp(filepath.Join(cache.Dir, tmpDir), "*.git")
	if err != nil {
		return nil, err
	}
	defer func() { maybeSetErr(os.RemoveAll(tmpdir)) }()
	cmd := exec.Command("git", "--namespace="+namespace, "clone", "--mirror", cache.Dir, tmpdir)
	cmd.Stderr = stderr
	if err := cmd.Run(); err != nil {
		return nil, err
	}

	ret := make([]string, len(revs))
	for i, rev := range revs {
		cmd = exec.Command("git", "rev-parse", "--verify", rev)
		cmd.Dir = tmpdir
		out, err := cmd.Output()
		if err != nil {
			var eErr *exec.ExitError
			if errors.As(err, &eErr) {
				if eErr.ExitCode() == 128 {
					continue
				}
				if len(eErr.Stderr) > 0 {
					err = fmt.Errorf("%w: %s", err, eErr.Stderr)
				}
			}
			return nil, fmt.Errorf("resolving: %q: %w", rev, err)
		}
		ret[i] = string(out[:len(out)-1])
	}
	return ret, nil
}

func (cache *Cache) GC(stderr io.Writer, flags ...string) error {
	fmt.Fprintf(stderr, "[gitcache] Collecting garbage...\n")
	cmd := exec.Command("git", append([]string{"gc"}, flags...)...)
	cmd.Dir = cache.Dir
	cmd.Stderr = stderr
	return cmd.Run()
}