Add a best-effort accepted-artifact filesystem cache

This commit is contained in:
2026-11-22 01:52:21 +00:00
parent 37e0753472
commit 3ef55b1cf0
5 changed files with 477 additions and 0 deletions

View File

@@ -0,0 +1,111 @@
// Package artifactcache stores accepted producer artifacts without execution or
// provenance envelopes. Cache I/O is best effort at the calling operation.
package artifactcache
import (
"context"
"encoding/json"
"fmt"
"os"
"path/filepath"
"strings"
"gitea.maximumdirect.net/eric/notarius/internal/core/fileio"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
// FilesystemStore is safe for concurrent operations. Construction and lookup do
// not create directories; only storing a newly accepted result can do so.
type FilesystemStore struct {
root string
}
var _ contracts.ArtifactCache = (*FilesystemStore)(nil)
func NewFilesystemStore(root string) (*FilesystemStore, error) {
if strings.TrimSpace(root) == "" || strings.ContainsRune(root, '\x00') {
return nil, fmt.Errorf("artifact cache root must be a nonempty path without NUL")
}
absolute, err := filepath.Abs(root)
if err != nil {
return nil, fmt.Errorf("resolve artifact cache root: %w", err)
}
// Retain the exact selected directory, including literal trailing spaces,
// when passing it through the common confined-path helper.
return &FilesystemStore{root: absolute + string(filepath.Separator)}, nil
}
func (store *FilesystemStore) Lookup(ctx context.Context, mode contracts.CacheMode, hash string) ([]byte, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
switch mode {
case contracts.CacheBypass, contracts.CacheRefresh:
return nil, nil
case contracts.CacheAuto, "":
default:
return nil, fmt.Errorf("unknown artifact cache mode %q", mode)
}
name, err := cacheName(hash)
if err != nil {
return nil, err
}
target, err := fileio.SafePath(store.root, name)
if err != nil {
return nil, fmt.Errorf("locate artifact cache entry %q: %w", hash, err)
}
info, err := os.Lstat(target)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("inspect artifact cache entry %q: %w", hash, err)
}
if !info.Mode().IsRegular() {
return nil, fmt.Errorf("artifact cache entry %q is not a regular file", hash)
}
content, err := os.ReadFile(target)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, fmt.Errorf("read artifact cache entry %q: %w", hash, err)
}
if !json.Valid(content) {
return nil, fmt.Errorf("artifact cache entry %q contains malformed JSON", hash)
}
return content, nil
}
func (store *FilesystemStore) Store(ctx context.Context, mode contracts.CacheMode, hash string, content []byte) error {
if err := ctx.Err(); err != nil {
return err
}
switch mode {
case contracts.CacheBypass:
return nil
case contracts.CacheAuto, contracts.CacheRefresh, "":
default:
return fmt.Errorf("unknown artifact cache mode %q", mode)
}
name, err := cacheName(hash)
if err != nil {
return err
}
if !json.Valid(content) {
return fmt.Errorf("artifact cache entry %q is not valid JSON", hash)
}
if err := fileio.WriteBytesWithProcessPermissions(store.root, name, content); err != nil {
return fmt.Errorf("store artifact cache entry %q: %w", hash, err)
}
return nil
}
func cacheName(hash string) (string, error) {
// The native hash is opaque: do not strip a prefix, recalculate it, encode
// it, or enforce a particular digest format. It must identify one filename.
if hash == "" || strings.ContainsAny(hash, "/\\") {
return "", fmt.Errorf("artifact cache hash must be a nonempty filename component")
}
return hash + ".json", nil
}