feat: git clone commits and docker data dirs to work with zfs/overlayfs (#77)

Author: skylenet

Dockerfile

@@ -25,7 +25,7 @@ RUN CGO_ENABLED=0 GOOS=linux go build \
 # Final stage
 FROM alpine:3.21
 
-RUN apk add --no-cache ca-certificates tzdata git
+RUN apk add --no-cache ca-certificates tzdata git zfs fuse-overlayfs
 
 WORKDIR /app
 

action.yaml

@@ -135,19 +135,72 @@ runs:
         CONFIGEOF
         fi
 
+        # Extract unique filesystem mount points from datadir source_dir values
+        DATADIR_MOUNT_POINTS=""
+        CONFIG_FILES=()
+        for cfg in "${{ runner.temp }}"/benchmarkoor-config-url-*.yaml; do
+          [ -f "$cfg" ] && CONFIG_FILES+=("$cfg")
+        done
+        if [ -f "${{ runner.temp }}/benchmarkoor-config-inline.yaml" ]; then
+          CONFIG_FILES+=("${{ runner.temp }}/benchmarkoor-config-inline.yaml")
+        fi
+
+        if [ ${#CONFIG_FILES[@]} -gt 0 ]; then
+          ALL_SOURCE_DIRS=""
+          for cfg in "${CONFIG_FILES[@]}"; do
+            # Extract source_dir from client.datadirs map values and client.instances[].datadir
+            DIRS=$(yq -r '
+              [
+                (.client.datadirs // {} | .[].source_dir // empty),
+                (.client.instances // [] | .[].datadir.source_dir // empty)
+              ] | .[]
+            ' "$cfg" 2>/dev/null || true)
+            if [ -n "$DIRS" ]; then
+              ALL_SOURCE_DIRS="${ALL_SOURCE_DIRS}${DIRS}"$'\n'
+            fi
+          done
+
+          # Resolve each source_dir to its filesystem mountpoint, deduplicate
+          if [ -n "$ALL_SOURCE_DIRS" ]; then
+            DATADIR_MOUNT_POINTS=$(echo "$ALL_SOURCE_DIRS" | while IFS= read -r dir; do
+              dir=$(echo "$dir" | xargs)
+              [ -z "$dir" ] && continue
+              if [ -d "$dir" ]; then
+                stat --format=%m "$dir" 2>/dev/null || true
+              else
+                echo "Warning: datadir source_dir '$dir' does not exist, skipping"
+              fi
+            done | sort -u)
+          fi
+        fi
+
+        if [ -n "$DATADIR_MOUNT_POINTS" ]; then
+          echo "Detected datadir filesystem mount points for rshared propagation:"
+          echo "$DATADIR_MOUNT_POINTS"
+        fi
+
         # Build docker run command
         DOCKER_CMD="docker run --network=host --rm --name=benchmarkoor-run"
         DOCKER_CMD="$DOCKER_CMD -v /var/run/docker.sock:/var/run/docker.sock"
         DOCKER_CMD="$DOCKER_CMD -v ${{ runner.temp }}/results:/app/results"
         DOCKER_CMD="$DOCKER_CMD -v ${{ runner.temp }}:/app/configs"
-        DOCKER_CMD="$DOCKER_CMD -v /tmp:/tmp"
-        DOCKER_CMD="$DOCKER_CMD --cap-add=SYS_ADMIN"
+        DOCKER_CMD="$DOCKER_CMD --mount type=bind,source=/tmp,target=/tmp,bind-propagation=rshared"
+        DOCKER_CMD="$DOCKER_CMD --privileged"
         DOCKER_CMD="$DOCKER_CMD -v /proc/sys/vm/drop_caches:/host_drop_caches"
         DOCKER_CMD="$DOCKER_CMD -v /sys/devices/system/cpu:/host_sys_cpu"
         DOCKER_CMD="$DOCKER_CMD -e BENCHMARKOOR_GLOBAL_DROP_CACHES_PATH=/host_drop_caches"
         DOCKER_CMD="$DOCKER_CMD -e BENCHMARKOOR_GLOBAL_CPU_SYSFS_PATH=/host_sys_cpu"
         DOCKER_CMD="$DOCKER_CMD -e BENCHMARKOOR_BENCHMARK_RESULTS_DIR=/app/results"
         DOCKER_CMD="$DOCKER_CMD -e BENCHMARKOOR_BENCHMARK_RESULTS_OWNER=$(id -u):$(id -g)"
+
+        # Add rshared mounts for datadir filesystem mount points (ZFS/overlayfs)
+        if [ -n "$DATADIR_MOUNT_POINTS" ]; then
+          while IFS= read -r mp; do
+            [ -z "$mp" ] && continue
+            DOCKER_CMD="$DOCKER_CMD --mount type=bind,source=${mp},target=${mp},bind-propagation=rshared"
+          done <<< "$DATADIR_MOUNT_POINTS"
+        fi
+
         DOCKER_CMD="$DOCKER_CMD ${IMAGE}"
         DOCKER_CMD="$DOCKER_CMD run"
 

docker-compose.yaml

@@ -4,9 +4,8 @@ services:
     build:
       context: .
       dockerfile: Dockerfile
-    cap_add:
-     # Required for dropping memory caches between tests (config.yaml#client.config.drop_memory_caches)
-      - SYS_ADMIN
+    # Required for dropping memory caches, ZFS/overlayfs datadir methods, etc.
+    privileged: true
     environment:
       - BENCHMARKOOR_GLOBAL_DROP_CACHES_PATH=/host_drop_caches
       - BENCHMARKOOR_GLOBAL_CPU_SYSFS_PATH=/host_sys_cpu
@@ -25,7 +24,18 @@ services:
       # Config file
       - ./${BENCHMARKOOR_CONFIG:-config.example.docker.yaml}:/app/config.yaml:ro
       # Temp directory (For fetching temporary files and node data dirs)
-      - ${PWD}/tmp:${PWD}/tmp
+      # rshared propagation ensures overlay mounts are visible to sibling containers
+      - type: bind
+        source: ${PWD}/tmp
+        target: ${PWD}/tmp
+        bind:
+          propagation: rshared
+      # For ZFS datadir methods, mount your ZFS data path with rshared propagation:
+      #- type: bind
+      #  source: /data-zfs
+      #  target: /data-zfs
+      #  bind:
+      #    propagation: rshared
       # Results directory
       - ./results:/app/results
     working_dir: /app

pkg/executor/source.go

@@ -206,17 +206,24 @@ func (s *GitSource) prepareRepo(ctx context.Context) (string, error) {
 			return "", fmt.Errorf("creating cache directory: %w", err)
 		}
 
-		// Shallow clone with specific branch/tag.
-		cmd := exec.CommandContext(ctx, "git", "clone",
-			"--depth=1",
-			"--branch", s.cfg.Version,
-			"--single-branch",
-			s.cfg.Repo, localPath)
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-
-		if err := cmd.Run(); err != nil {
-			return "", fmt.Errorf("cloning repository: %w", err)
+		if looksLikeCommitHash(s.cfg.Version) {
+			// Commit hashes can't be used with --branch, so we init + fetch instead.
+			if err := s.cloneByCommitHash(ctx, localPath); err != nil {
+				return "", err
+			}
+		} else {
+			// Shallow clone with specific branch/tag.
+			cmd := exec.CommandContext(ctx, "git", "clone",
+				"--depth=1",
+				"--branch", s.cfg.Version,
+				"--single-branch",
+				s.cfg.Repo, localPath)
+			cmd.Stdout = os.Stdout
+			cmd.Stderr = os.Stderr
+
+			if err := cmd.Run(); err != nil {
+				return "", fmt.Errorf("cloning repository: %w", err)
+			}
 		}
 	} else {
 		log.Info("Updating cached repository")
@@ -279,6 +286,66 @@ func (s *GitSource) GetSourceInfo() (*SuiteSource, error) {
 	return &SuiteSource{Git: git}, nil
 }
 
+// cloneByCommitHash initializes a repo and fetches a specific commit hash.
+func (s *GitSource) cloneByCommitHash(ctx context.Context, localPath string) error {
+	// git init
+	cmd := exec.CommandContext(ctx, "git", "init", localPath)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("initializing repository: %w", err)
+	}
+
+	// git remote add origin <repo>
+	cmd = exec.CommandContext(ctx, "git", "-C", localPath,
+		"remote", "add", "origin", s.cfg.Repo)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("adding remote: %w", err)
+	}
+
+	// git fetch --depth=1 origin <hash>
+	cmd = exec.CommandContext(ctx, "git", "-C", localPath,
+		"fetch", "--depth=1", "origin", s.cfg.Version)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("fetching commit %s: %w", s.cfg.Version, err)
+	}
+
+	// git checkout FETCH_HEAD
+	cmd = exec.CommandContext(ctx, "git", "-C", localPath,
+		"checkout", "FETCH_HEAD")
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("checking out commit %s: %w", s.cfg.Version, err)
+	}
+
+	return nil
+}
+
+// looksLikeCommitHash returns true if s looks like a git commit hash
+// (7-40 lowercase/uppercase hex characters).
+func looksLikeCommitHash(s string) bool {
+	if len(s) < 7 || len(s) > 40 {
+		return false
+	}
+
+	for _, c := range s {
+		if (c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F') {
+			return false
+		}
+	}
+
+	return true
+}
+
 // hashRepoURL creates a hash of the repository URL for caching.
 func hashRepoURL(url string) string {
 	hash := sha256.Sum256([]byte(url))

pkg/executor/source_test.go

@@ -56,3 +56,31 @@ func TestDiscoverTestsFromConfig_PreRunStepsNotFiltered(t *testing.T) {
 	assert.Len(t, result.Tests, 1, "only bn128 test should match filter")
 	assert.Contains(t, result.Tests[0].Name, "bn128")
 }
+
+func TestLooksLikeCommitHash(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected bool
+	}{
+		{name: "full sha1", input: "e5011aa5f75d7a1722481f25408347fadfb7fd3c", expected: true},
+		{name: "short hash 7 chars", input: "e5011aa", expected: true},
+		{name: "short hash 8 chars", input: "e5011aa5", expected: true},
+		{name: "uppercase hex", input: "E5011AA5F75D7A17", expected: true},
+		{name: "mixed case hex", input: "e5011AA5f75d", expected: true},
+		{name: "branch name", input: "main", expected: false},
+		{name: "branch with slash", input: "feature/foo", expected: false},
+		{name: "tag semver", input: "v1.0.0", expected: false},
+		{name: "too short 6 chars", input: "e5011a", expected: false},
+		{name: "too long 41 chars", input: "e5011aa5f75d7a1722481f25408347fadfb7fd3c0", expected: false},
+		{name: "empty string", input: "", expected: false},
+		{name: "hex with non-hex char", input: "e5011gg", expected: false},
+		{name: "7 char all digits", input: "1234567", expected: true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assert.Equal(t, tt.expected, looksLikeCommitHash(tt.input))
+		})
+	}
+}