fix: make cache ops independent of parent context (#4423)

pkg/retrieval/retrieval.go

@@ -418,8 +418,8 @@ func (s *Service) closestPeer(addr swarm.Address, skipPeers []swarm.Address, all
 	return closest, nil
 }
 
-func (s *Service) handler(ctx context.Context, p p2p.Peer, stream p2p.Stream) (err error) {
-	ctx, cancel := context.WithTimeout(ctx, retrieveChunkTimeout)
+func (s *Service) handler(p2pctx context.Context, p p2p.Peer, stream p2p.Stream) (err error) {
+	ctx, cancel := context.WithTimeout(p2pctx, retrieveChunkTimeout)
 	defer cancel()
 
 	w, r := protobuf.NewWriterAndReader(stream)
@@ -486,11 +486,11 @@ func (s *Service) handler(ctx context.Context, p p2p.Peer, stream p2p.Stream) (e
 
 	// cache the request last, so that putting to the localstore does not slow down the request flow
 	if s.caching && forwarded {
-		err = s.storer.Cache().Put(ctx, chunk)
-		if err != nil {
-			return fmt.Errorf("retrieve cache put: %w", err)
+		if err := s.storer.Cache().Put(p2pctx, chunk); err != nil {
+			s.logger.Debug("retrieve cache put", "error", err)
 		}
 	}
+
 	return nil
 }
 

pkg/storer/compact_test.go

@@ -64,6 +64,8 @@ func TestCompact(t *testing.T) {
 	t.Cleanup(unsub)
 	<-c
 
+	time.Sleep(time.Second)
+
 	if err := st.Close(); err != nil {
 		t.Fatal(err)
 	}

pkg/storer/internal/cache/cache.go

@@ -376,7 +376,16 @@ func (c *Cache) MoveFromReserve(
 	ctx context.Context,
 	store internal.Storage,
 	addrs ...swarm.Address,
-) error {
+) (err error) {
+
+	defer func() {
+		if err != nil {
+			for _, addr := range addrs {
+				err = errors.Join(store.ChunkStore().Delete(context.Background(), addr))
+			}
+		}
+	}()
+
 	batch, err := store.IndexStore().Batch(ctx)
 	if err != nil {
 		return fmt.Errorf("failed creating batch: %w", err)

pkg/storer/internal/reserve/reserve.go

@@ -363,15 +363,16 @@ func (r *Reserve) EvictBatchBin(
 			if err := batch.Commit(); err != nil {
 				return err
 			}
-			if err := r.cacheCb(ctx, store, moveToCache...); err != nil {
-				r.logger.Error(err, "evict and move to cache")
-				for _, rItem := range moveToCache {
-					err = store.ChunkStore().Delete(ctx, rItem)
-					if err != nil {
-						return err
+
+			go func(addrs []swarm.Address) {
+				_ = txExecutor.Execute(ctx, func(store internal.Storage) error {
+					if err := r.cacheCb(ctx, store, addrs...); err != nil {
+						r.logger.Error(err, "evict and move to cache")
 					}
-				}
-			}
+					return nil
+				})
+			}(moveToCache)
+
 			return nil
 		})
 		if err != nil {
@@ -405,7 +406,7 @@ func (r *Reserve) DeleteChunk(
 	}
 	if err := r.cacheCb(ctx, store, item.Address); err != nil {
 		r.logger.Error(err, "delete and move to cache")
-		return store.ChunkStore().Delete(ctx, item.Address)
+		return err
 	}
 	return nil
 }

pkg/storer/internal/reserve/reserve_test.go

@@ -10,6 +10,7 @@ import (
 	"errors"
 	"math/rand"
 	"testing"
+	"time"
 
 	"github.com/ethersphere/bee/pkg/log"
 	"github.com/ethersphere/bee/pkg/postage"
@@ -275,6 +276,8 @@ func TestEvict(t *testing.T) {
 		t.Fatalf("got %d, want %d", totalEvicted, chunksPerBatch)
 	}
 
+	time.Sleep(time.Second)
+
 	for i, ch := range chunks {
 		binID := i%chunksPerBatch + 1
 		b := swarm.Proximity(baseAddr.Bytes(), ch.Address().Bytes())