feat: enhance Backup functionality to support datastore unwrapping and improve error handling

Author: randygrok

pkg/store/backup.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 
+	ds "github.com/ipfs/go-datastore"
 	badger4 "github.com/ipfs/go-ds-badger4"
 )
 
@@ -16,28 +17,51 @@ func (s *DefaultStore) Backup(ctx context.Context, writer io.Writer, since uint6
 		return 0, err
 	}
 
-	// Try to leverage a native backup implementation if the underlying datastore exposes one.
-	type backupable interface {
-		Backup(io.Writer, uint64) (uint64, error)
-	}
-	if dsBackup, ok := s.db.(backupable); ok {
-		version, err := dsBackup.Backup(writer, since)
-		if err != nil {
-			return 0, fmt.Errorf("datastore backup failed: %w", err)
-		}
-		return version, nil
-	}
-
-	// Default Badger datastore used across ev-node.
-	badgerDatastore, ok := s.db.(*badger4.Datastore)
+	visited := make(map[ds.Datastore]struct{})
+	current, ok := any(s.db).(ds.Datastore)
 	if !ok {
 		return 0, fmt.Errorf("backup is not supported by the configured datastore")
 	}
 
-	// `badger.DB.Backup` internally orchestrates a consistent snapshot without pausing writes.
-	version, err := badgerDatastore.DB.Backup(writer, since)
-	if err != nil {
-		return 0, fmt.Errorf("badger backup failed: %w", err)
+	for {
+		// Try to leverage a native backup implementation if the underlying datastore exposes one.
+		type backupable interface {
+			Backup(io.Writer, uint64) (uint64, error)
+		}
+		if dsBackup, ok := current.(backupable); ok {
+			version, err := dsBackup.Backup(writer, since)
+			if err != nil {
+				return 0, fmt.Errorf("datastore backup failed: %w", err)
+			}
+			return version, nil
+		}
+
+		// Default Badger datastore used across ev-node.
+		if badgerDatastore, ok := current.(*badger4.Datastore); ok {
+			// `badger.DB.Backup` internally orchestrates a consistent snapshot without pausing writes.
+			version, err := badgerDatastore.DB.Backup(writer, since)
+			if err != nil {
+				return 0, fmt.Errorf("badger backup failed: %w", err)
+			}
+			return version, nil
+		}
+
+		// Attempt to unwrap shimmed datastores (e.g., prefix or mutex wrappers) to reach the backing store.
+		if _, seen := visited[current]; seen {
+			break
+		}
+		visited[current] = struct{}{}
+
+		shim, ok := current.(ds.Shim)
+		if !ok {
+			break
+		}
+		children := shim.Children()
+		if len(children) == 0 {
+			break
+		}
+		current = children[0]
 	}
-	return version, nil
+
+	return 0, fmt.Errorf("backup is not supported by the configured datastore")
 }

scripts/reth-backup/README.md

@@ -38,3 +38,40 @@ Additional flags:
 
 The script outputs the height at the end so you can coordinate other backups
 with the same block number.
+
+## End-to-end workflow with `apps/evm/single`
+
+The `evm/single` docker-compose setup expects the backup image to reuse the
+`ghcr.io/evstack/ev-reth:latest` tag. To capture both the MDBX and ev-node
+Badger backups end-to-end:
+
+1. Build the helper image so `ev-reth` has the MDBX tooling preinstalled.
+   ```bash
+   docker build -t ghcr.io/evstack/ev-reth:latest scripts/reth-backup
+   ```
+2. Build the `ev-node-evm-single` image so it includes the latest CLI backup
+   command (optional if you already pushed the binary and re-tagged it).
+   ```bash
+   docker build -t ghcr.io/evstack/ev-node-evm-single:main -f apps/evm/single/Dockerfile .
+   ```
+3. Start the stack.
+   ```bash
+   (cd apps/evm/single && docker compose up -d)
+   ```
+4. Run the MDBX snapshot script (adjust the destination as needed).
+   ```bash
+   ./scripts/reth-backup/backup.sh backups/full-run/reth
+   ```
+5. Stream a Badger backup from the ev-node into the container filesystem and
+   copy it to the host.
+   ```bash
+   docker compose exec ev-node-evm-single \
+     evm-single backup --output /tmp/evnode-backup.badger --force
+   docker cp ev-node-evm-single:/tmp/evnode-backup.badger backups/full-run/ev-node/
+   ```
+6. When finished, tear the stack down.
+   ```bash
+   (cd apps/evm/single && docker compose down)
+   ```
+
+Both backups can then be found under `backups/full-run/`.