debug: allow debug from remote cache config

Signed-off-by: Tonis Tiigi <[email protected]>

Author: tonistiigi

cache/remotecache/v1/cachestorage.go

@@ -106,7 +106,12 @@ func (cs *cacheKeyStorage) Exists(id string) bool {
 	return ok
 }
 
-func (cs *cacheKeyStorage) Walk(func(id string) error) error {
+func (cs *cacheKeyStorage) Walk(cb func(id string) error) error {
+	for id := range cs.byID {
+		if err := cb(id); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
@@ -142,6 +147,26 @@ func (cs *cacheKeyStorage) Release(resultID string) error {
 func (cs *cacheKeyStorage) AddLink(id string, link solver.CacheInfoLink, target string) error {
 	return nil
 }
+
+func (cs *cacheKeyStorage) WalkLinksAll(id string, fn func(id string, link solver.CacheInfoLink) error) error {
+	it, ok := cs.byID[id]
+	if !ok {
+		return nil
+	}
+	for nl, ids := range it.links {
+		for _, id2 := range ids {
+			if err := fn(id2, solver.CacheInfoLink{
+				Input:    solver.Index(nl.input),
+				Selector: digest.Digest(nl.selector),
+				Digest:   nl.dgst,
+			}); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 func (cs *cacheKeyStorage) WalkLinks(id string, link solver.CacheInfoLink, fn func(id string) error) error {
 	it, ok := cs.byID[id]
 	if !ok {

cmd/buildkitd/debug.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"encoding/binary"
 	"encoding/json"
 	"expvar"
 	"fmt"
@@ -15,6 +16,7 @@ import (
 	"strings"
 	"time"
 
+	cacheimport "github.com/moby/buildkit/cache/remotecache/v1"
 	"github.com/moby/buildkit/solver"
 	"github.com/moby/buildkit/util/bklog"
 	"github.com/moby/buildkit/util/cachedigest"
@@ -40,6 +42,7 @@ func setupDebugHandlers(addr string) error {
 	m.Handle("/debug/cache/all", http.HandlerFunc(handleCacheAll))
 	m.Handle("/debug/cache/lookup", http.HandlerFunc(handleCacheLookup))
 	m.Handle("/debug/cache/store", http.HandlerFunc(handleDebugCacheStore))
+	m.Handle("POST /debug/cache/load", http.HandlerFunc(handleCacheLoad))
 
 	m.Handle("/debug/gc", http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
 		runtime.GC()
@@ -139,9 +142,13 @@ func printCacheRecord(record *cachedigest.Record, w io.Writer) {
 		case cachedigest.FrameIDData:
 			w.Write([]byte("  " + frame.ID.String() + ": " + string(frame.Data) + "\n"))
 		case cachedigest.FrameIDSkip:
-			w.Write([]byte("  skipping " + string(frame.Data) + " bytes\n"))
+			fmt.Fprintf(w, "  skipping %d bytes\n", binary.LittleEndian.Uint32(frame.Data))
 		}
 	}
+	for _, subRec := range record.SubRecords {
+		w.Write([]byte("\n"))
+		printCacheRecord(subRec, w)
+	}
 }
 
 func cacheRecordLookup(ctx context.Context, dgst digest.Digest) (*cachedigest.Record, error) {
@@ -216,18 +223,70 @@ func loadCacheAll(ctx context.Context) ([]*cachedigest.Record, error) {
 	return records, nil
 }
 
+func handleCacheLoad(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPost {
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	if r.Body == nil {
+		http.Error(w, "body is required", http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	recs, err := loadCacheFromReader(r.Context(), r.Body)
+	if err != nil {
+		http.Error(w, "failed to load cache: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	writeCacheRecordsResponse(w, r, recs)
+}
+
+func loadCacheFromReader(ctx context.Context, rdr io.Reader) ([]*recordWithDebug, error) {
+	dt, err := io.ReadAll(rdr)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read body")
+	}
+
+	allLayers := cacheimport.DescriptorProvider{}
+	cc := cacheimport.NewCacheChains()
+	if err := cacheimport.Parse(dt, allLayers, cc); err != nil {
+		return nil, err
+	}
+
+	keyStorage, _, err := cacheimport.NewCacheKeyStorage(cc, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	recs, err := debugCacheStore(ctx, keyStorage)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to debug cache store")
+	}
+
+	return recs, nil
+}
+
 func handleDebugCacheStore(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
 		return
 	}
 
-	recs, err := debugCacheStore(r.Context())
+	store := cacheStoreForDebug
+	if store == nil {
+		http.Error(w, "Cache store is not initialized for debug", http.StatusInternalServerError)
+	}
+
+	recs, err := debugCacheStore(r.Context(), store)
 	if err != nil {
 		http.Error(w, "Failed to debug cache store: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+	writeCacheRecordsResponse(w, r, recs)
+}
 
+func writeCacheRecordsResponse(w http.ResponseWriter, r *http.Request, recs []*recordWithDebug) {
 	w.WriteHeader(http.StatusOK)
 
 	switch r.Header.Get("Accept") {
@@ -287,12 +346,7 @@ type recordWithDebug struct {
 	Debug []*cachedigest.Record `json:"debug,omitempty"`
 }
 
-func debugCacheStore(ctx context.Context) ([]*recordWithDebug, error) {
-	store := cacheStoreForDebug
-	if store == nil {
-		return nil, errors.New("cache store is not initialized for debug")
-	}
-
+func debugCacheStore(ctx context.Context, store solver.CacheKeyStorage) ([]*recordWithDebug, error) {
 	recs, err := cachestore.Records(ctx, store)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to get cache records")

util/cachedigest/digest.go

@@ -67,11 +67,11 @@ func (h *Hash) WriteNoDebug(p []byte) (n int, err error) {
 	if n > 0 && h.db != nil {
 		if len(h.frames) > 0 && h.frames[len(h.frames)-1].ID == FrameIDSkip {
 			last := &h.frames[len(h.frames)-1]
-			prevLen := binary.BigEndian.Uint32(last.Data)
-			binary.BigEndian.PutUint32(last.Data, prevLen+uint32(n))
+			prevLen := binary.LittleEndian.Uint32(last.Data)
+			binary.LittleEndian.PutUint32(last.Data, prevLen+uint32(n))
 		} else {
 			lenBytes := make([]byte, 4)
-			binary.BigEndian.PutUint32(lenBytes, uint32(n))
+			binary.LittleEndian.PutUint32(lenBytes, uint32(n))
 			h.frames = append(h.frames, Frame{ID: FrameIDSkip, Data: lenBytes})
 		}
 	}
@@ -94,7 +94,7 @@ type Record struct {
 	Digest     digest.Digest `json:"digest"`
 	Type       Type          `json:"type"`
 	Data       []Frame       `json:"data,omitempty"`
-	SubRecords []Record      `json:"subRecords,omitempty"`
+	SubRecords []*Record     `json:"subRecords,omitempty"`
 }
 
 var shaRegexpOnce = sync.OnceValue(func() *regexp.Regexp {
@@ -149,11 +149,16 @@ func (r *Record) LoadSubRecords(loader func(d digest.Digest) (Type, []Frame, err
 			bklog.L.Warnf("failed to load sub-record for %s: %v", dgst, err)
 			continue
 		}
-		r.SubRecords = append(r.SubRecords, Record{
+		rr := &Record{
 			Digest: digest.Digest(dgst),
 			Type:   typ,
 			Data:   frames,
-		})
+		}
+		if err := rr.LoadSubRecords(loader); err != nil {
+			return err
+		}
+
+		r.SubRecords = append(r.SubRecords, rr)
 	}
 	return nil
 }

util/cachestore/store.go

@@ -35,7 +35,7 @@ type storeWithLinks interface {
 func Records(ctx context.Context, store solver.CacheKeyStorage) ([]*Record, error) {
 	swl, ok := store.(storeWithLinks)
 	if !ok {
-		return nil, errors.New("cache store does not support walkin all links")
+		return nil, errors.New("cache store does not support walking all links")
 	}
 
 	roots := []string{}