fix: match cache restore-keys in creation reverse order

pkg/artifactcache/handler.go

@@ -9,6 +9,7 @@
 	"net/http"
 	"os"
 	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
 	"sync/atomic"
@@ -52,28 +53,28 @@
 	h.logger = logger
 
 	if dir == "" {
 		home, err := os.UserHomeDir()
 		if err != nil {
 			return nil, err
 		}
 		dir = filepath.Join(home, ".cache", "actcache")
 	}
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return nil, err
 	}
 
 	h.dir = dir
 
 	storage, err := NewStorage(filepath.Join(dir, "cache"))
 	if err != nil {
 		return nil, err
 	}
 	h.storage = storage
 
 	if outboundIP != "" {
 		h.outboundIP = outboundIP
 	} else if ip := common.GetOutboundIP(); ip == nil {
 		return nil, fmt.Errorf("unable to determine outbound IP address")
 	} else {
 		h.outboundIP = ip.String()
 	}
@@ -92,16 +93,16 @@
 
 	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", port)) // listen on all interfaces
 	if err != nil {
 		return nil, err
 	}
 	server := &http.Server{
 		ReadHeaderTimeout: 2 * time.Second,
 		Handler:           router,
 	}
 	go func() {
 		if err := server.Serve(listener); err != nil && errors.Is(err, net.ErrClosed) {
 			logger.Errorf("http serve: %v", err)
 		}
 	}()
 	h.listener = listener
 	h.server = server
@@ -118,14 +119,14 @@
 
 func (h *Handler) Close() error {
 	if h == nil {
 		return nil
 	}
 	var retErr error
 	if h.server != nil {
 		err := h.server.Close()
 		if err != nil {
 			retErr = err
 		}
 		h.server = nil
 	}
 	if h.listener != nil {
@@ -134,8 +135,8 @@
 			err = nil
 		}
 		if err != nil {
 			retErr = err
 		}
 		h.listener = nil
 	}
 	return retErr
@@ -164,29 +165,29 @@
 
 	db, err := h.openDB()
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	defer db.Close()
 
 	cache, err := h.findCache(db, keys, version)
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	if cache == nil {
 		h.responseJSON(w, r, 204)
 		return
 	}
 
 	if ok, err := h.storage.Exist(cache.ID); err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	} else if !ok {
 		_ = db.Delete(cache.ID, cache)
 		h.responseJSON(w, r, 204)
 		return
 	}
 	h.responseJSON(w, r, 200, map[string]any{
 		"result":          "hit",
 		"archiveLocation": fmt.Sprintf("%s%s/artifacts/%d", h.ExternalURL(), urlBase, cache.ID),
@@ -208,15 +209,15 @@
 	cache.FillKeyVersionHash()
 	db, err := h.openDB()
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	defer db.Close()
 	if err := db.FindOne(cache, bolthold.Where("KeyVersionHash").Eq(cache.KeyVersionHash)); err != nil {
 		if !errors.Is(err, bolthold.ErrNotFound) {
 			h.responseJSON(w, r, 500, err)
 			return
 		}
 	} else {
 		h.responseJSON(w, r, 400, fmt.Errorf("already exist"))
 		return
@@ -226,14 +227,14 @@
 	cache.CreatedAt = now
 	cache.UsedAt = now
 	if err := db.Insert(bolthold.NextSequence(), cache); err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	// write back id to db
 	if err := db.Update(cache.ID, cache); err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	h.responseJSON(w, r, 200, map[string]any{
 		"cacheId": cache.ID,
 	})
@@ -250,17 +251,17 @@
 	cache := &Cache{}
 	db, err := h.openDB()
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	defer db.Close()
 	if err := db.Get(id, cache); err != nil {
 		if errors.Is(err, bolthold.ErrNotFound) {
 			h.responseJSON(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
 			return
 		}
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 
 	if cache.Complete {
@@ -274,8 +275,8 @@
 		return
 	}
 	if err := h.storage.Write(cache.ID, start, r.Body); err != nil {
 		h.responseJSON(w, r, 500, err)
 	}
 	h.useCache(id)
 	h.responseJSON(w, r, 200)
 }
@@ -291,17 +292,17 @@
 	cache := &Cache{}
 	db, err := h.openDB()
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	defer db.Close()
 	if err := db.Get(id, cache); err != nil {
 		if errors.Is(err, bolthold.ErrNotFound) {
 			h.responseJSON(w, r, 400, fmt.Errorf("cache %d: not reserved", id))
 			return
 		}
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 
 	if cache.Complete {
@@ -321,16 +322,16 @@
 
 	db, err = h.openDB()
 	if err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 	defer db.Close()
 
 	cache.Complete = true
 	if err := db.Update(cache.ID, cache); err != nil {
 		h.responseJSON(w, r, 500, err)
 		return
 	}
 
 	h.responseJSON(w, r, 200)
 }
@@ -365,8 +366,8 @@
 // if not found, return (nil, nil) instead of an error.
 func (h *Handler) findCache(db *bolthold.Store, keys []string, version string) (*Cache, error) {
 	if len(keys) == 0 {
 		return nil, nil
 	}
 	key := keys[0] // the first key is for exact match.
 
 	cache := &Cache{
@@ -377,8 +378,8 @@
 
 	if err := db.FindOne(cache, bolthold.Where("KeyVersionHash").Eq(cache.KeyVersionHash)); err != nil {
 		if !errors.Is(err, bolthold.ErrNotFound) {
 			return nil, err
 		}
 	} else if cache.Complete {
 		return cache, nil
 	}
@@ -386,20 +387,25 @@
 
 	for _, prefix := range keys[1:] {
 		found := false
-		if err := db.ForEach(bolthold.Where("Key").Ge(prefix).And("Version").Eq(version).SortBy("Key"), func(v *Cache) error {
+		prefixPattern := fmt.Sprintf("^%s", regexp.QuoteMeta(prefix))
+		re, err := regexp.Compile(prefixPattern)
+		if err != nil {
+			continue
+		}
+		if err := db.ForEach(bolthold.Where("Key").RegExp(re).And("Version").Eq(version).SortBy("CreatedAt").Reverse(), func(v *Cache) error {
 			if !strings.HasPrefix(v.Key, prefix) {
 				return stop
 			}
 			if v.Complete {
 				cache = v
 				found = true
 				return stop
 			}
 			return nil
 		}); err != nil {
 			if !errors.Is(err, stop) {
 				return nil, err
 			}
 		}
 		if found {
 			return cache, nil
@@ -411,8 +417,8 @@
 func (h *Handler) useCache(id int64) {
 	db, err := h.openDB()
 	if err != nil {
 		return
 	}
 	defer db.Close()
 	cache := &Cache{}
 	if err := db.Get(id, cache); err != nil {
@@ -424,11 +430,11 @@
 
 func (h *Handler) gcCache() {
 	if atomic.LoadInt32(&h.gcing) != 0 {
 		return
 	}
 	if !atomic.CompareAndSwapInt32(&h.gcing, 0, 1) {
 		return
 	}
 	defer atomic.StoreInt32(&h.gcing, 0)
 
 	if time.Since(h.gcAt) < time.Hour {
@@ -446,52 +452,52 @@
 
 	db, err := h.openDB()
 	if err != nil {
 		return
 	}
 	defer db.Close()
 
 	var caches []*Cache
 	if err := db.Find(&caches, bolthold.Where("UsedAt").Lt(time.Now().Add(-keepTemp).Unix())); err != nil {
 		h.logger.Warnf("find caches: %v", err)
 	} else {
 		for _, cache := range caches {
 			if cache.Complete {
 				continue
 			}
 			h.storage.Remove(cache.ID)
 			if err := db.Delete(cache.ID, cache); err != nil {
 				h.logger.Warnf("delete cache: %v", err)
 				continue
 			}
 			h.logger.Infof("deleted cache: %+v", cache)
 		}
 	}
 
 	caches = caches[:0]
 	if err := db.Find(&caches, bolthold.Where("UsedAt").Lt(time.Now().Add(-keepUnused).Unix())); err != nil {
 		h.logger.Warnf("find caches: %v", err)
 	} else {
 		for _, cache := range caches {
 			h.storage.Remove(cache.ID)
 			if err := db.Delete(cache.ID, cache); err != nil {
 				h.logger.Warnf("delete cache: %v", err)
 				continue
 			}
 			h.logger.Infof("deleted cache: %+v", cache)
 		}
 	}
 
 	caches = caches[:0]
 	if err := db.Find(&caches, bolthold.Where("CreatedAt").Lt(time.Now().Add(-keepUsed).Unix())); err != nil {
 		h.logger.Warnf("find caches: %v", err)
 	} else {
 		for _, cache := range caches {
 			h.storage.Remove(cache.ID)
 			if err := db.Delete(cache.ID, cache); err != nil {
 				h.logger.Warnf("delete cache: %v", err)
 				continue
 			}
 			h.logger.Infof("deleted cache: %+v", cache)
 		}
 	}
 }
@@ -524,7 +530,7 @@
 	}
 	stop, err := strconv.ParseInt(s2, 10, 64)
 	if err != nil {
 		return 0, 0, fmt.Errorf("parse %q: %w", s, err)
 	}
 	return start, stop, nil
 }