replicator/replicator/filetree.go

package replicator

import (
	"context"
	"fmt"
	"io"
	"io/fs"
	"io/ioutil"
	"net/url"
	"os"
	"path"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

type FileTree string

func NewFileTree(spec url.URL) (FileTree, error) {
	p := spec.Path
	if spec.Host != "" {
		p = path.Join(spec.Host, p)
	}
	return FileTree(p), nil
}

func (tree FileTree) Keys(ctx context.Context) (chan Key, *error) {
	result := make(chan Key)
	var final error
	go func() {
		defer close(result)
		if err := filepath.Walk(path.Dir(tree.realpath(Key{})), func(p string, info fs.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if info.IsDir() {
				return ctx.Err()
			}
			key := tree.toKey(p)
			select {
			case result <- key:
			case <-ctx.Done():
			}
			return ctx.Err()
		}); err != nil && !os.IsNotExist(err) {
			final = err
		}
	}()
	return result, &final
}

func (tree FileTree) Get(ctx context.Context, key Key) (Value, error) {
	version, err := tree.getVersion(key)
	if version == nil {
		return Value{}, err
	}

	f, err := os.Open(tree.realpath(key))
	if err != nil {
		return Value{}, err
	}
	defer f.Close()
	b, _ := io.ReadAll(f)

	return Value{
		Value:   b,
		Version: version,
	}, nil
}

func (tree FileTree) Set(ctx context.Context, key Key, value Value) error {
	version, err := tree.fromVersion(value.Version)
	if err != nil {
		return err
	}

	f2, err := ioutil.TempFile(os.TempDir(), "*.*")
	if err != nil {
		return err
	}
	defer os.Remove(f2.Name())

	if n, err := f2.Write(value.Value); err != nil {
		return err
	} else if n != len(value.Value) {
		return fmt.Errorf("truncated write")
	}

	if err := f2.Close(); err != nil {
		return err
	}

	if err := os.Chtimes(f2.Name(), time.Time{}, version); err != nil {
		return err
	}

	os.MkdirAll(path.Dir(tree.realpath(key)), os.ModePerm)
	return os.Rename(f2.Name(), tree.realpath(key))
}

func (tree FileTree) Del(ctx context.Context, key Key) error {
	if _, err := os.Stat(tree.realpath(key)); os.IsNotExist(err) {
		return nil
	} else if err != nil {
		return err
	}
	return os.Remove(tree.realpath(key))
}

func (tree FileTree) realpath(key Key) string {
	namespace := ""
	tmp := path.Clean("/" + key.Namespace)
	for path.Dir(tmp) != tmp {
		_, base := path.Split(tmp)
		namespace = path.Join(base+".d", namespace)
		tmp = path.Dir(tmp)
	}
	return path.Join(string(tree), namespace, key.Key+".bin")
}

func (tree FileTree) getVersion(key Key) ([]byte, error) {
	info, err := os.Stat(tree.realpath(key))
	if os.IsNotExist(err) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	return []byte(strconv.FormatInt(info.ModTime().UnixNano(), 10)), nil
}

func (tree FileTree) fromVersion(v []byte) (time.Time, error) {
	if len(v) == 0 {
		return time.Time{}, nil
	}
	n, err := strconv.ParseInt(string(v), 10, 64)
	if err != nil {
		return time.Time{}, err
	}
	return time.Unix(0, n), nil
}

func (tree FileTree) toKey(p string) Key {
	p = path.Clean(p)
	p = strings.TrimPrefix(p, path.Clean(string(tree)))
	p = strings.TrimPrefix(p, "/")
	p = strings.TrimSuffix(p, ".bin")
	p = strings.ReplaceAll(p, ".d/", "/")
	namespace := path.Dir(p)
	if namespace == "/" || namespace == "." {
		namespace = ""
	}
	key := path.Base(p)
	if key == "" {
		key = namespace
		namespace = ""
	}
	return Key{
		Namespace: namespace,
		Key:       key,
	}
}