chore(deps): Bump github/codeql-action from 3.29.7 to 3.29.8 (#1282)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 3.29.7 to 3.29.8.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](51f77329af...76621b61de)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 3.29.8
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+rustflags = ["--cfg", "tokio_unstable"]

.github/auto_assign.yml

@@ -0,0 +1,16 @@
+# Set to true to add reviewers to pull requests
+addReviewers: true
+
+# Set to true to add assignees to pull requests
+addAssignees: author
+
+# A list of reviewers to be added to pull requests (GitHub user name)
+reviewers:
+  - gaius-qi
+  - yxxhero
+  - chlins
+  - CormickKneey
+  - xujihui1985
+
+# A number of reviewers added to the pull request
+numberOfReviewers: 3

.github/workflows/auto-assign.yml

@@ -0,0 +1,11 @@
+name: "Auto Assign"
+
+on:
+  pull_request_target:
+    types: [opened, reopened, ready_for_review]
+
+jobs:
+  add-assignee:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: kentaro-m/auto-assign-action@9f6dbe84a80c6e7639d1b9698048b201052a2a94

.github/workflows/ci.yml

@@ -26,6 +26,8 @@ jobs:
 
       - name: Install Protoc
         uses: arduino/setup-protoc@v2
+        with:
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -55,6 +57,8 @@ jobs:
 
       - name: Install Protoc
         uses: arduino/setup-protoc@v2
+        with:
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -74,7 +78,7 @@ jobs:
         run: cargo llvm-cov --all-features --workspace --lcov --output-path lcov.info
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4
+        uses: codecov/codecov-action@v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           files: lcov.info

.github/workflows/docker.yml

@@ -22,9 +22,10 @@ jobs:
         id: get_version
         run: |
           VERSION=${GITHUB_REF#refs/tags/}
-          if [[ ${GITHUB_REF} == "refs/heads/main" ]]; then
+          if [[ ${GITHUB_REF} == "refs/heads/main" || ${GITHUB_REF} =~ refs/pull/([0-9]+)/merge ]]; then
             VERSION=latest
           fi
+
           echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
 
       - name: Get Git Revision
@@ -35,7 +36,7 @@ jobs:
 
       - name: PrepareReg Names
         run: |
-           echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+          echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
 
       - name: Setup QEMU
         uses: docker/setup-qemu-action@v3
@@ -80,10 +81,118 @@ jobs:
           tags: |
             dragonflyoss/client:${{ steps.get_version.outputs.VERSION }}
             ghcr.io/${{ env.IMAGE_REPOSITORY }}:${{ steps.get_version.outputs.VERSION }}
-          push: true
+          push: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/') }}
           cache-from: type=local,src=/tmp/.buildx-cache
           cache-to: type=local,dest=/tmp/.buildx-cache-new
 
+      - name: Run Trivy vulnerability scanner in tarball mode
+        uses: aquasecurity/trivy-action@dc5a429b52fcf669ce959baa2c2dd26090d2a6c4
+        with:
+          image-ref: dragonflyoss/client:${{ steps.get_version.outputs.VERSION }}
+          severity: 'CRITICAL,HIGH'
+          format: 'sarif'
+          output: 'trivy-results.sarif'
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@76621b61decf072c1cee8dd1ce2d2a82d33c17ed
+        with:
+          sarif_file: 'trivy-results.sarif'
+
+      - name: Move cache
+        run: |
+          rm -rf /tmp/.buildx-cache
+          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+  push_client_debug_image_to_registry:
+    name: Push Client Debug Image
+    runs-on: [self-hosted, Linux, X64]
+    timeout-minutes: 600
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Get Version
+        id: get_version
+        run: |
+          VERSION=${GITHUB_REF#refs/tags/}
+          if [[ ${GITHUB_REF} == "refs/heads/main" || ${GITHUB_REF} =~ refs/pull/([0-9]+)/merge ]]; then
+            VERSION=latest
+          fi
+
+          echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
+
+      - name: Get Git Revision
+        id: vars
+        shell: bash
+        run: |
+          echo "git_revision=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+      - name: PrepareReg Names
+        run: |
+          echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+
+      - name: Setup QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Setup Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Cache Docker layers
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-debug-${{ github.sha }}
+          restore-keys: |
+            ${{ runner.os }}-buildx-debug-
+
+      - name: Login Docker Hub
+        uses: docker/login-action@v3
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Push to Registry
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ci/Dockerfile.debug
+          platforms: linux/amd64,linux/arm64
+          labels: |-
+            org.opencontainers.image.source=https://github.com/${{ github.repository }}
+            org.opencontainers.image.revision=${{ github.sha }}
+          build-args: |
+            GITVERSION=git-${{ steps.vars.outputs.git_revision }}
+            VERSION=${{ steps.get_version.outputs.VERSION }}-debug
+          tags: |
+            dragonflyoss/client:${{ steps.get_version.outputs.VERSION }}-debug
+            ghcr.io/${{ env.IMAGE_REPOSITORY }}:${{ steps.get_version.outputs.VERSION }}-debug
+          push: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/') }}
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new
+
+      - name: Run Trivy vulnerability scanner in tarball mode
+        uses: aquasecurity/trivy-action@dc5a429b52fcf669ce959baa2c2dd26090d2a6c4
+        with:
+          image-ref: dragonflyoss/client:${{ steps.get_version.outputs.VERSION }}-debug
+          severity: 'CRITICAL,HIGH'
+          format: 'sarif'
+          output: 'trivy-results.sarif'
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@76621b61decf072c1cee8dd1ce2d2a82d33c17ed
+        with:
+          sarif_file: 'trivy-results.sarif'
+
       - name: Move cache
         run: |
           rm -rf /tmp/.buildx-cache
@@ -103,9 +212,10 @@ jobs:
         id: get_version
         run: |
           VERSION=${GITHUB_REF#refs/tags/}
-          if [[ ${GITHUB_REF} == "refs/heads/main" ]]; then
+          if [[ ${GITHUB_REF} == "refs/heads/main" || ${GITHUB_REF} =~ refs/pull/([0-9]+)/merge ]]; then
             VERSION=latest
           fi
+
           echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
 
       - name: Get Git Revision
@@ -116,7 +226,7 @@ jobs:
 
       - name: PrepareReg Names
         run: |
-           echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
+          echo IMAGE_REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
 
       - name: Setup QEMU
         uses: docker/setup-qemu-action@v3
@@ -161,10 +271,23 @@ jobs:
           tags: |
             dragonflyoss/dfinit:${{ steps.get_version.outputs.VERSION }}
             ghcr.io/${{ env.IMAGE_REPOSITORY }}/dfinit:${{ steps.get_version.outputs.VERSION }}
-          push: true
+          push: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/') }}
           cache-from: type=local,src=/tmp/.buildx-cache
           cache-to: type=local,dest=/tmp/.buildx-cache-new
 
+      - name: Run Trivy vulnerability scanner in tarball mode
+        uses: aquasecurity/trivy-action@dc5a429b52fcf669ce959baa2c2dd26090d2a6c4
+        with:
+          image-ref: dragonflyoss/dfinit:${{ steps.get_version.outputs.VERSION }}
+          severity: 'CRITICAL,HIGH'
+          format: 'sarif'
+          output: 'trivy-results.sarif'
+
+      - name: Upload Trivy scan results to GitHub Security tab
+        uses: github/codeql-action/upload-sarif@76621b61decf072c1cee8dd1ce2d2a82d33c17ed
+        with:
+          sarif_file: 'trivy-results.sarif'
+
       - name: Move cache
         run: |
           rm -rf /tmp/.buildx-cache

.github/workflows/lint.yml

@@ -15,18 +15,21 @@ jobs:
       - name: Checkout code
         uses: actions/checkout@v4
 
-      - name: Rust cache 
+      - name: Rust cache
         uses: Swatinem/rust-cache@v2
         with:
           cache-on-failure: true
 
       - name: Install Protoc
         uses: arduino/setup-protoc@v2
+        with:
+          repo-token: ${{ secrets.GH_TOKEN }}
 
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: rustfmt, clippy
+          toolchain: 1.85.0
 
       - name: Set up Clang
         uses: egor-tensin/setup-clang@v1

.github/workflows/pr-labels.yml

@@ -0,0 +1,20 @@
+name: PR Label
+
+on:
+  pull_request:
+    types: [opened, labeled, unlabeled, synchronize]
+
+permissions:
+  contents: read
+
+jobs:
+  classify:
+    name: Classify PR
+    runs-on: ubuntu-latest
+    steps:
+      - name: PR impact specified
+        uses: mheap/github-action-required-labels@8afbe8ae6ab7647d0c9f0cfa7c2f939650d22509 # v5.5
+        with:
+          mode: exactly
+          count: 1
+          labels: 'bug, enhancement, documentation, dependencies'

.github/workflows/release.yml

@@ -52,12 +52,13 @@ jobs:
           target: ${{ matrix.target }}
 
       - name: Install cargo-deb
-        uses: taiki-e/cache-cargo-install-action@v2
+        uses: taiki-e/cache-cargo-install-action@b33c63d3b3c85540f4eba8a4f71a5cc0ce030855
         with:
-          tool: cargo-deb
+          # Don't upgrade cargo-deb, refer to https://github.com/kornelski/cargo-deb/issues/169.
+          tool: cargo-deb@2.10.0
 
       - name: Install cargo-generate-rpm
-        uses: taiki-e/install-action@v2
+        uses: taiki-e/install-action@daa3c1f1f9a9d46f686d9fc2f65773d0c293688b
         with:
           tool: cargo-generate-rpm
           
@@ -69,33 +70,32 @@ jobs:
       - name: Build binaries
         shell: bash
         run: |
-            cargo build --release --bins --target ${{ matrix.target }}
+            cargo build --release --bins --workspace --exclude hdfs --target ${{ matrix.target }}
 
       - name: Build archive client(DEB)
         shell: bash
         run: |
-          binary_name="client"
+          binary_name="dragonfly-client"
           dirname="$binary_name-${{ env.VERSION }}-${{ matrix.target }}"
-          cargo deb -p dragonfly-client --target ${{ matrix.target }} --variant ${{ matrix.target }} --output $dirname.deb
+          cargo deb -p dragonfly-client --no-build --target ${{ matrix.target }} --variant ${{ matrix.target }} --compress-type gzip --output $dirname.deb
           echo "CLIENT_DEB_ASSET=$dirname.deb" >> $GITHUB_ENV
 
       - name: Build archive client(RPM)
         shell: bash
         run: |
-          binary_name="client"
+          binary_name="dragonfly-client"
           dirname="$binary_name-${{ env.VERSION }}-${{ matrix.target }}"
-          cargo generate-rpm -p dragonfly-client --target ${{ matrix.target }} --variant ${{ matrix.target }} --output $dirname.rpm
+          cargo generate-rpm -p dragonfly-client --target ${{ matrix.target }} --variant ${{ matrix.target }} --payload-compress none --output $dirname.rpm
           echo "CLIENT_RPM_ASSET=$dirname.rpm" >> $GITHUB_ENV
 
       - name: Build archive client(TAR)
         shell: bash
         run: |
-          binary_name="client"
+          binary_name="dragonfly-client"
           dirname="$binary_name-${{ env.VERSION }}-${{ matrix.target }}"
           mkdir -p "$dirname"
           mv "target/${{ matrix.target }}/release/dfget" "$dirname"
           mv "target/${{ matrix.target }}/release/dfdaemon" "$dirname"
-          mv "target/${{ matrix.target }}/release/dfstore" "$dirname"
           mv "target/${{ matrix.target }}/release/dfcache" "$dirname"
           mv "target/${{ matrix.target }}/release/dfinit" "$dirname"
           mv CONTRIBUTING.md LICENSE README.md "$dirname"
@@ -119,7 +119,7 @@ jobs:
       contents: write
     steps:
       - name: Download Release Artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@v5
         with:
           path: releases
           pattern: release-*
@@ -153,6 +153,8 @@ jobs:
 
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: 1.85.0
 
       - name: Install dependencies
         run: |
@@ -163,3 +165,4 @@ jobs:
         with:
            registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}
            ignore-unpublished-changes: true
+           args: --locked

.github/workflows/stale.yml

@@ -0,0 +1,31 @@
+name: Close stale issues and PRs
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: "0 0 * * *"
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
+        id: stale
+        with:
+          delete-branch: true
+          days-before-close: 7
+          days-before-stale: 90
+          days-before-pr-close: 7
+          days-before-pr-stale: 120
+          stale-issue-label: "stale"
+          exempt-issue-labels: bug,wip,on-hold
+          exempt-pr-labels: bug,wip,on-hold
+          exempt-all-milestones: true
+          stale-issue-message: 'This issue is stale because it has been open 90 days with no activity.'
+          close-issue-message: 'This issue was closed because it has been stalled for 7 days with no activity.'
+          stale-pr-message: 'This PR is stale because it has been open 120 days with no activity.'
+          close-pr-message: 'This PR was closed because it has been stalled for 7 days with no activity.'

.gitignore

@@ -50,3 +50,6 @@ Temporary Items
 
 # Ignore unuseful files
 scripts/certs
+
+# Ignore .vscode folder
+.vscode

Cargo.toml

@@ -12,7 +12,7 @@ members = [
 ]
 
 [workspace.package]
-version = "0.1.113"
+version = "1.0.10"
 authors = ["The Dragonfly Developers"]
 homepage = "https://d7y.io/"
 repository = "https://github.com/dragonflyoss/client.git"
@@ -22,19 +22,31 @@ readme = "README.md"
 edition = "2021"
 
 [workspace.dependencies]
-dragonfly-client = { path = "dragonfly-client", version = "0.1.113" }
-dragonfly-client-core = { path = "dragonfly-client-core", version = "0.1.113" }
-dragonfly-client-config = { path = "dragonfly-client-config", version = "0.1.113" }
-dragonfly-client-storage = { path = "dragonfly-client-storage", version = "0.1.113" }
-dragonfly-client-backend = { path = "dragonfly-client-backend", version = "0.1.113" }
-dragonfly-client-util = { path = "dragonfly-client-util", version = "0.1.113" }
-dragonfly-client-init = { path = "dragonfly-client-init", version = "0.1.113" }
-thiserror = "1.0"
-dragonfly-api = "=2.0.167"
-reqwest = { version = "0.12.4", features = ["stream", "native-tls", "default-tls", "rustls-tls"] }
+dragonfly-client = { path = "dragonfly-client", version = "1.0.10" }
+dragonfly-client-core = { path = "dragonfly-client-core", version = "1.0.10" }
+dragonfly-client-config = { path = "dragonfly-client-config", version = "1.0.10" }
+dragonfly-client-storage = { path = "dragonfly-client-storage", version = "1.0.10" }
+dragonfly-client-backend = { path = "dragonfly-client-backend", version = "1.0.10" }
+dragonfly-client-util = { path = "dragonfly-client-util", version = "1.0.10" }
+dragonfly-client-init = { path = "dragonfly-client-init", version = "1.0.10" }
+dragonfly-api = "2.1.57"
+thiserror = "2.0"
+futures = "0.3.31"
+reqwest = { version = "0.12.4", features = [
+    "stream",
+    "native-tls",
+    "default-tls",
+    "rustls-tls",
+    "gzip",
+    "brotli",
+    "zstd",
+    "deflate",
+    "blocking",
+] }
+reqwest-middleware = "0.4"
 rcgen = { version = "0.12.1", features = ["x509-parser"] }
-hyper = { version = "1.4", features = ["full"] }
-hyper-util = { version = "0.1.9", features = [
+hyper = { version = "1.6", features = ["full"] }
+hyper-util = { version = "0.1.16", features = [
     "client",
     "client-legacy",
     "tokio",
@@ -43,32 +55,32 @@ hyper-util = { version = "0.1.9", features = [
     "http2",
 ] }
 hyper-rustls = { version = "0.26", features = ["http1", "http2", "logging"] }
-http-range-header = "0.4.1"
+http-range-header = "0.4.2"
 tracing = "0.1"
-url = "2.5.2"
+url = "2.5.4"
 rustls = { version = "0.22.4", features = ["tls12"] }
-rustls-pki-types = "1.9.0"
-rustls-pemfile = "2.1.3"
+rustls-pki-types = "1.12.0"
+rustls-pemfile = "2.2.0"
 sha2 = "0.10"
-blake3 = "1.5.4"
-crc32fast = "1.4.2"
-uuid = { version = "1.10", features = ["v4"] }
+crc32fast = "1.5.0"
+uuid = { version = "1.16", features = ["v4"] }
 hex = "0.4"
 rocksdb = "0.22.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.9"
 http = "1"
-tonic = { version = "0.12.2", features = ["zstd", "tls"] }
-tokio = { version = "1.39.2", features = ["full"] }
-tokio-util = { version = "0.7.12", features = ["full"] }
-tokio-stream = "0.1.16"
+tonic = { version = "0.12.2", features = ["tls"] }
+tonic-reflection = "0.12.3"
+tokio = { version = "1.47.1", features = ["full", "tracing"] }
+tokio-util = { version = "0.7.16", features = ["full"] }
+tokio-stream = "0.1.17"
 validator = { version = "0.16", features = ["derive"] }
 warp = "0.3.5"
-headers = "0.4.0"
-regex = "1.11.0"
+headers = "0.4.1"
+regex = "1.11.1"
 humantime = "2.1.0"
 prost-wkt-types = "0.6"
-chrono = { version = "0.4.35", features = ["serde", "clock"] }
+chrono = { version = "0.4.41", features = ["serde", "clock"] }
 openssl = { version = "0.10", features = ["vendored"] }
 opendal = { version = "0.48.0", features = [
     "services-s3",
@@ -77,25 +89,37 @@ opendal = { version = "0.48.0", features = [
     "services-oss",
     "services-obs",
     "services-cos",
+    "services-webhdfs",
 ] }
-clap = { version = "4.5.20", features = ["derive"] }
-anyhow = "1.0.89"
-toml_edit = "0.22.22"
-toml = "0.8.19"
-base16ct = { version = "0.2", features = ["alloc"] }
-bytesize = { version = "1.2.0", features = ["serde"] }
+clap = { version = "4.5.45", features = ["derive"] }
+anyhow = "1.0.98"
+toml_edit = "0.22.26"
+toml = "0.8.23"
+bytesize = { version = "1.3.3", features = ["serde"] }
 bytesize-serde = "0.2.1"
 percent-encoding = "2.3.1"
-tempfile = "3.13.0"
-lazy_static = "1.5"
+tempfile = "3.20.0"
 tokio-rustls = "0.25.0-alpha.4"
+serde_json = "1.0.142"
+lru = "0.12.5"
+fs2 = "0.4.3"
+lazy_static = "1.5"
+bytes = "1.10"
+local-ip-address = "0.6.5"
+sysinfo = { version = "0.32.1", default-features = false, features = ["component", "disk", "network", "system", "user"] }
 
 [profile.release]
-opt-level = "z"
-lto = true
+opt-level = 3
+lto = "thin"
 codegen-units = 1
 panic = "abort"
 strip = "symbols"
 
+[profile.dev]
+opt-level = 0
+debug = true
+incremental = true
+strip = false
+
 [profile.bench]
 debug = true

README.md

@@ -4,9 +4,9 @@
 [![CI](https://github.com/dragonflyoss/client/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/dragonflyoss/client/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/dragonflyoss/client/branch/main/graph/badge.svg)](https://codecov.io/gh/dragonflyoss/dfdaemon)
 [![Open Source Helpers](https://www.codetriage.com/dragonflyoss/client/badges/users.svg)](https://www.codetriage.com/dragonflyoss/client)
-[![Discussions](https://img.shields.io/badge/discussions-on%20github-blue?style=flat-square)](https://github.com/dragonflyoss/Dragonfly2/discussions)
+[![Discussions](https://img.shields.io/badge/discussions-on%20github-blue?style=flat-square)](https://github.com/dragonflyoss/dragonfly/discussions)
 [![Twitter](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Ftwitter.com%2Fdragonfly_oss)](https://twitter.com/dragonfly_oss)
-[![LICENSE](https://img.shields.io/github/license/dragonflyoss/Dragonfly2.svg?style=flat-square)](https://github.com/dragonflyoss/Dragonfly2/blob/main/LICENSE)
+[![LICENSE](https://img.shields.io/github/license/dragonflyoss/dragonfly.svg?style=flat-square)](https://github.com/dragonflyoss/dragonfly/blob/main/LICENSE)
 [![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdragonflyoss%2Fclient.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdragonflyoss%2Fclient?ref=badge_shield)
 
 Dragonfly client written in Rust. It can serve as both a peer and a seed peer.
@@ -20,9 +20,9 @@ You can find the full documentation on the [d7y.io](https://d7y.io).
 Join the conversation and help the community.
 
 - **Slack Channel**: [#dragonfly](https://cloud-native.slack.com/messages/dragonfly/) on [CNCF Slack](https://slack.cncf.io/)
-- **Discussion Group**: <dragonfly-discuss@googlegroups.com>
+- **Github Discussions**: [Dragonfly Discussion Forum](https://github.com/dragonflyoss/dragonfly/discussions)
 - **Developer Group**: <dragonfly-developers@googlegroups.com>
-- **Github Discussions**: [Dragonfly Discussion Forum](https://github.com/dragonflyoss/Dragonfly2/discussions)
+- **Maintainer Group**: <dragonfly-maintainers@googlegroups.com>
 - **Twitter**: [@dragonfly_oss](https://twitter.com/dragonfly_oss)
 - **DingTalk**: [22880028764](https://qr.dingtalk.com/action/joingroup?code=v1,k1,pkV9IbsSyDusFQdByPSK3HfCG61ZCLeb8b/lpQ3uUqI=&_dt_no_comment=1&origin=11)
 
@@ -30,7 +30,3 @@ Join the conversation and help the community.
 
 You should check out our
 [CONTRIBUTING](./CONTRIBUTING.md) and develop the project together.
-
-
-## License
-[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fdragonflyoss%2Fclient.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Fdragonflyoss%2Fclient?ref=badge_large)

ci/Dockerfile

@@ -1,12 +1,13 @@
-FROM rust:1.80.0 AS builder
+FROM public.ecr.aws/docker/library/rust:1.85.0 AS builder
 
 WORKDIR /app/client
 
 RUN apt-get update && apt-get install -y \
-      openssl libclang-dev pkg-config protobuf-compiler git \
-      && rm -rf /var/lib/apt/lists/*
+    openssl libclang-dev pkg-config protobuf-compiler git \
+    && rm -rf /var/lib/apt/lists/*
 
 COPY Cargo.toml Cargo.lock ./
+COPY .cargo ./cargo
 
 COPY dragonfly-client/Cargo.toml ./dragonfly-client/Cargo.toml
 COPY dragonfly-client/src ./dragonfly-client/src
@@ -20,6 +21,7 @@ COPY dragonfly-client-config/build.rs ./dragonfly-client-config/build.rs
 
 COPY dragonfly-client-storage/Cargo.toml ./dragonfly-client-storage/Cargo.toml
 COPY dragonfly-client-storage/src ./dragonfly-client-storage/src
+COPY dragonfly-client-storage/benches ./dragonfly-client-storage/benches
 
 COPY dragonfly-client-backend/Cargo.toml ./dragonfly-client-backend/Cargo.toml
 COPY dragonfly-client-backend/src ./dragonfly-client-backend/src
@@ -33,9 +35,15 @@ COPY dragonfly-client-util/src ./dragonfly-client-util/src
 COPY dragonfly-client-init/Cargo.toml ./dragonfly-client-init/Cargo.toml
 COPY dragonfly-client-init/src ./dragonfly-client-init/src
 
-RUN cargo build --release --verbose --bin dfget --bin dfdaemon --bin dfstore --bin dfcache
+ARG TARGETPLATFORM
+RUN case "${TARGETPLATFORM}" in \
+  "linux/arm64") export JEMALLOC_SYS_WITH_LG_PAGE=16;; \
+  esac && \
+  cargo build --release --verbose --bin dfget --bin dfdaemon --bin dfcache
 
-FROM alpine:3.20 AS health
+RUN cargo install tokio-console --locked --root /usr/local
+
+FROM public.ecr.aws/docker/library/alpine:3.20 AS health
 
 ENV GRPC_HEALTH_PROBE_VERSION=v0.4.24
 
@@ -48,22 +56,24 @@ RUN if [ "$(uname -m)" = "ppc64le" ]; then \
     fi && \
     chmod +x /bin/grpc_health_probe
 
-FROM golang:1.23.0-alpine3.20 AS pprof
+FROM public.ecr.aws/docker/library/golang:1.23.0-alpine3.20 AS pprof
 
 RUN go install github.com/google/pprof@latest
+RUN go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
 
-FROM debian:bookworm-slim
+FROM public.ecr.aws/debian/debian:bookworm-slim
 
-RUN apt-get update && apt-get install -y --no-install-recommends wget curl \
-    bash-completion procps apache2-utils ca-certificates binutils bpfcc-tools \
-    dnsutils iputils-ping vim linux-perf llvm graphviz \
+RUN apt-get update && apt-get install -y --no-install-recommends iperf3 fio curl \
+    iotop sysstat bash-completion procps apache2-utils ca-certificates binutils \
+    dnsutils iputils-ping llvm graphviz lsof strace dstat net-tools \
     && rm -rf /var/lib/apt/lists/*
 
 COPY --from=builder /app/client/target/release/dfget /usr/local/bin/dfget
 COPY --from=builder /app/client/target/release/dfdaemon /usr/local/bin/dfdaemon
-COPY --from=builder /app/client/target/release/dfstore /usr/local/bin/dfstore
 COPY --from=builder /app/client/target/release/dfcache /usr/local/bin/dfcache
-COPY --from=health /bin/grpc_health_probe /bin/grpc_health_probe
+COPY --from=builder /usr/local/bin/tokio-console /usr/local/bin/
 COPY --from=pprof /go/bin/pprof /bin/pprof
+COPY --from=pprof /go/bin/grpcurl /bin/grpcurl
+COPY --from=health /bin/grpc_health_probe /bin/grpc_health_probe
 
 ENTRYPOINT ["/usr/local/bin/dfdaemon"]

ci/Dockerfile.debug

@@ -0,0 +1,83 @@
+FROM public.ecr.aws/docker/library/rust:1.85.0 AS builder
+
+WORKDIR /app/client
+
+RUN apt-get update && apt-get install -y \
+    openssl libclang-dev pkg-config protobuf-compiler git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY Cargo.toml Cargo.lock ./
+COPY .cargo ./cargo
+
+COPY dragonfly-client/Cargo.toml ./dragonfly-client/Cargo.toml
+COPY dragonfly-client/src ./dragonfly-client/src
+
+COPY dragonfly-client-core/Cargo.toml ./dragonfly-client-core/Cargo.toml
+COPY dragonfly-client-core/src ./dragonfly-client-core/src
+
+COPY dragonfly-client-config/Cargo.toml ./dragonfly-client-config/Cargo.toml
+COPY dragonfly-client-config/src ./dragonfly-client-config/src
+COPY dragonfly-client-config/build.rs ./dragonfly-client-config/build.rs
+
+COPY dragonfly-client-storage/Cargo.toml ./dragonfly-client-storage/Cargo.toml
+COPY dragonfly-client-storage/src ./dragonfly-client-storage/src
+COPY dragonfly-client-storage/benches ./dragonfly-client-storage/benches
+
+COPY dragonfly-client-backend/Cargo.toml ./dragonfly-client-backend/Cargo.toml
+COPY dragonfly-client-backend/src ./dragonfly-client-backend/src
+
+COPY dragonfly-client-backend/examples/plugin/Cargo.toml ./dragonfly-client-backend/examples/plugin/Cargo.toml
+COPY dragonfly-client-backend/examples/plugin/src ./dragonfly-client-backend/examples/plugin/src
+
+COPY dragonfly-client-util/Cargo.toml ./dragonfly-client-util/Cargo.toml
+COPY dragonfly-client-util/src ./dragonfly-client-util/src
+
+COPY dragonfly-client-init/Cargo.toml ./dragonfly-client-init/Cargo.toml
+COPY dragonfly-client-init/src ./dragonfly-client-init/src
+
+ARG TARGETPLATFORM
+RUN case "${TARGETPLATFORM}" in \
+  "linux/arm64") export JEMALLOC_SYS_WITH_LG_PAGE=16;; \
+  esac && \
+  cargo build --verbose --bin dfget --bin dfdaemon --bin dfcache
+
+RUN cargo install flamegraph --root /usr/local
+RUN cargo install bottom --locked --root /usr/local
+RUN cargo install tokio-console --locked --root /usr/local
+
+FROM public.ecr.aws/docker/library/alpine:3.20 AS health
+
+ENV GRPC_HEALTH_PROBE_VERSION=v0.4.24
+
+RUN if [ "$(uname -m)" = "ppc64le" ]; then \
+    wget -qO/bin/grpc_health_probe https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/${GRPC_HEALTH_PROBE_VERSION}/grpc_health_probe-linux-ppc64le; \
+    elif [ "$(uname -m)" = "aarch64" ]; then \
+    wget -qO/bin/grpc_health_probe https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/${GRPC_HEALTH_PROBE_VERSION}/grpc_health_probe-linux-arm64; \
+    else \
+    wget -qO/bin/grpc_health_probe https://github.com/grpc-ecosystem/grpc-health-probe/releases/download/${GRPC_HEALTH_PROBE_VERSION}/grpc_health_probe-linux-amd64; \
+    fi && \
+    chmod +x /bin/grpc_health_probe
+
+FROM public.ecr.aws/docker/library/golang:1.23.0-alpine3.20 AS pprof
+
+RUN go install github.com/google/pprof@latest
+RUN go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
+
+FROM public.ecr.aws/debian/debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends iperf3 fio curl infiniband-diags ibverbs-utils \
+    iotop sysstat bash-completion procps apache2-utils ca-certificates binutils bpfcc-tools \
+    dnsutils iputils-ping vim linux-perf llvm lsof socat strace dstat net-tools \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/client/target/debug/dfget /usr/local/bin/dfget
+COPY --from=builder /app/client/target/debug/dfdaemon /usr/local/bin/dfdaemon
+COPY --from=builder /app/client/target/debug/dfcache /usr/local/bin/dfcache
+COPY --from=builder /usr/local/bin/flamegraph /usr/local/bin/
+COPY --from=builder /usr/local/bin/btm /usr/local/bin/
+COPY --from=builder /usr/local/bin/tokio-console /usr/local/bin/
+COPY --from=pprof /go/bin/pprof /bin/pprof
+COPY --from=pprof /go/bin/grpcurl /bin/grpcurl
+COPY --from=health /bin/grpc_health_probe /bin/grpc_health_probe
+
+ENTRYPOINT ["/usr/local/bin/dfdaemon"]

ci/Dockerfile.dfinit

@@ -1,12 +1,13 @@
-FROM rust:1.80.0 AS builder
+FROM public.ecr.aws/docker/library/rust:1.85.0 AS builder
 
 RUN apt-get update && apt-get install -y \
-      openssl libclang-dev pkg-config protobuf-compiler \
-      && rm -rf /var/lib/apt/lists/*
+    openssl libclang-dev pkg-config protobuf-compiler \
+    && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app/client
 
 COPY Cargo.toml Cargo.lock ./
+COPY .cargo ./cargo
 
 COPY dragonfly-client/Cargo.toml ./dragonfly-client/Cargo.toml
 COPY dragonfly-client/src ./dragonfly-client/src
@@ -20,6 +21,7 @@ COPY dragonfly-client-config/build.rs ./dragonfly-client-config/build.rs
 
 COPY dragonfly-client-storage/Cargo.toml ./dragonfly-client-storage/Cargo.toml
 COPY dragonfly-client-storage/src ./dragonfly-client-storage/src
+COPY dragonfly-client-storage/benches ./dragonfly-client-storage/benches
 
 COPY dragonfly-client-backend/Cargo.toml ./dragonfly-client-backend/Cargo.toml
 COPY dragonfly-client-backend/src ./dragonfly-client-backend/src
@@ -33,9 +35,13 @@ COPY dragonfly-client-util/src ./dragonfly-client-util/src
 COPY dragonfly-client-init/Cargo.toml ./dragonfly-client-init/Cargo.toml
 COPY dragonfly-client-init/src ./dragonfly-client-init/src
 
-RUN cargo build --release --verbose --bin dfinit
+ARG TARGETPLATFORM
+RUN case "${TARGETPLATFORM}" in \
+  "linux/arm64") export JEMALLOC_SYS_WITH_LG_PAGE=16;; \
+  esac && \
+  cargo build --release --verbose --bin dfinit
 
-FROM debian:bookworm-slim
+FROM public.ecr.aws/debian/debian:bookworm-slim
 
 RUN apt-get update && apt-get install -y --no-install-recommends wget \
     && rm -rf /var/lib/apt/lists/*

ci/dfdaemon.service

@@ -5,7 +5,7 @@ After=network-online.target
 After=network.target
 
 [Service]
-ExecStart=/usr/bin/dfdaemon --config /etc/dragonfly/dfdaemon.yaml --verbose
+ExecStart=/usr/bin/dfdaemon --config /etc/dragonfly/dfdaemon.yaml --console
 
 Type=simple
 Environment=HOME=/root

ci/dfdaemon.yaml

@@ -1,153 +0,0 @@
-# bose prints log.
-verbose: true
-log:
-  # Specify the logging level [trace, debug, info, warn, error]
-  level: info
-# host is the host configuration for dfdaemon.
-host:
-  ## idc is the idc of the host.
-  idc: ''
-  ## location is the location of the host.
-  location: ''
-  ## hostname is the hostname of the host.
-  # hostname: ""
-  ## ip is the advertise ip of the host.
-  # ip: ""
-server:
-  # pluginDir is the directory to store plugins.
-  pluginDir: /var/lib/dragonfly/plugins/dfdaemon/
-  # cacheDir is the directory to store cache files.
-  cacheDir: /var/cache/dragonfly/dfdaemon/
-download:
-  server:
-    # -- socketPath is the unix socket path for dfdaemon GRPC service.
-    socketPath: /var/run/dragonfly/dfdaemon.sock
-  # -- rateLimit is the default rate limit of the download speed in KiB/MiB/GiB per second, default is 10GiB/s.
-  rateLimit: 10GiB
-  # --   pieceTimeout is the timeout for downloading a piece from source.
-  pieceTimeout: 30s
-  # -- concurrentPieceCount is the number of concurrent pieces to download.
-  concurrentPieceCount: 10
-upload:
-  server:
-    # -- port is the port to the grpc server.
-    port: 4000
-    ## ip is the listen ip of the grpc server.
-    # ip: ""
-  # -- rateLimit is the default rate limit of the upload speed in KiB/MiB/GiB per second, default is 10GiB/s.
-  rateLimit: 10GiB
-manager:
-  # addrs is manager addresses.
-  addrs: []
-scheduler:
-  # announceInterval is the interval to announce peer to the scheduler.
-  # Announcer will provide the scheduler with peer information for scheduling,
-  # peer information includes cpu, memory, etc.
-  announceInterval: 1m
-  # scheduleTimeout is the timeout for scheduling. If the scheduling timesout, dfdaemon will back-to-source
-  # download if enableBackToSource is true, otherwise dfdaemon will return download failed.
-  scheduleTimeout: 30s
-  # maxScheduleCount is the max count of schedule.
-  maxScheduleCount: 5
-  # enableBackToSource indicates whether enable back-to-source download, when the scheduling failed.
-  enableBackToSource: true
-seedPeer:
-  # enable indicates whether enable seed peer.
-  enable: true
-  # type is the type of seed peer.
-  type: super
-  # clusterID is the cluster id of the seed peer cluster.
-  clusterID: 1
-  # keepaliveInterval is the interval to keep alive with manager.
-  keepaliveInterval: 15s
-dynconfig:
-  # refreshInterval is the interval to refresh dynamic configuration from manager.
-  refreshInterval: 1m
-storage:
-  # dir is the directory to store task's metadata and content.
-  dir: /var/lib/dragonfly/
-  # keep indicates whether keep the task's metadata and content when the dfdaemon restarts.
-  keep: true
-  # writeBufferSize is the buffer size for writing piece to disk, default is 128KB.
-  writeBufferSize: 131072
-  # readBufferSize is the buffer size for reading piece from disk, default is 128KB.
-  readBufferSize: 131072
-gc:
-  # interval is the interval to do gc.
-  interval: 900s
-  policy:
-    # taskTTL is the ttl of the task.
-    taskTTL: 21600s
-    # distHighThresholdPercent is the high threshold percent of the disk usage.
-    # If the disk usage is greater than the threshold, dfdaemon will do gc.
-    distHighThresholdPercent: 80
-    # distLowThresholdPercent is the low threshold percent of the disk usage.
-    # If the disk usage is less than the threshold, dfdaemon will stop gc.
-    distLowThresholdPercent: 60
-proxy:
-  server:
-    # port is the port to the proxy server.
-    port: 4001
-    ## ip is the listen ip of the proxy server.
-    # ip: ""
-    ## caCert is the root CA cert path with PEM format for the proxy server to generate the server cert.
-    ## If ca_cert is empty, proxy will generate a smaple CA cert by rcgen::generate_simple_self_signed.
-    ## When client requests via the proxy, the client should not verify the server cert and set
-    ## insecure to true. If ca_cert is not empty, proxy will sign the server cert with the CA cert. If openssl is installed,
-    ## you can use openssl to generate the root CA cert and make the system trust the root CA cert.
-    ## Then set the ca_cert and ca_key to the root CA cert and key path. Dfdaemon generates the server cert
-    ## and key, and signs the server cert with the root CA cert. When client requests via the proxy,
-    ## the proxy can intercept the request by the server cert.
-    # caCert: ""
-    ## caKey is the root CA key path with PEM format for the proxy server to generate the server cert.
-    ## If ca_key is empty, proxy will generate a smaple CA key by rcgen::generate_simple_self_signed.
-    ## When client requests via the proxy, the client should not verify the server cert and set
-    ## insecure to true. If ca_key is not empty, proxy will sign the server cert with the CA cert. If openssl is installed,
-    ## you can use openssl to generate the root CA cert and make the system trust the root CA cert.
-    ## Then set the ca_cert and ca_key to the root CA cert and key path. Dfdaemon generates the server cert
-    ## and key, and signs the server cert with the root CA cert. When client requests via the proxy,
-    ## the proxy can intercept the request by the server cert.
-    # caKey: ""
-  # rules is the list of rules for the proxy server.
-  # regex is the regex of the request url.
-  # useTLS indicates whether use tls for the proxy backend.
-  # redirect is the redirect url.
-  # filteredQueryParams is the filtered query params to generate the task id.
-  # When filter is ["Signature", "Expires", "ns"], for example:
-  # http://example.com/xyz?Expires=e1&Signature=s1&ns=docker.io and http://example.com/xyz?Expires=e2&Signature=s2&ns=docker.io
-  # will generate the same task id.
-  # Default value includes the filtered query params of s3, gcs, oss, obs, cos.
-  rules:
-    - regex: 'blobs/sha256.*'
-      # useTLS: false
-      # redirect: ""
-      # filteredQueryParams: []
-  registryMirror:
-    # addr is the default address of the registry mirror. Proxy will start a registry mirror service for the
-    # client to pull the image. The client can use the default address of the registry mirror in
-    # configuration to pull the image. The `X-Dragonfly-Registry` header can instead of the default address
-    # of registry mirror.
-    addr: https://index.docker.io
-    ## certs is the client certs path with PEM format for the registry.
-    ## If registry use self-signed cert, the client should set the
-    ## cert for the registry mirror.
-    # certs: ""
-  # disableBackToSource indicates whether disable to download back-to-source when download failed.
-  disableBackToSource: false
-  # prefetch pre-downloads full of the task when download with range request.
-  prefetch: false
-  # -- readBufferSize is the buffer size for reading piece from disk, default is 32KB.
-  readBufferSize: 32768
-security:
-  # enable indicates whether enable security.
-  enable: false
-metrics:
-  server:
-    # port is the port to the metrics server.
-    port: 4002
-    ## ip is the listen ip of the metrics server.
-    # ip: ""
-## tracing is the tracing configuration for dfdaemon.
-# tracing:
-## addr is the address to report tracing log.
-# addr: ""

docs/performance-optimization.md

@@ -0,0 +1,98 @@
+# Performance Optimization Guidance
+
+This is a reference benchmark process document designed to
+assist in performance analysis and optimization for **client**.
+This document provides as general a testing framework as possible,
+allowing developers with needs to adjust it
+according to their specific circumstances across various platform.
+
+## Flow
+
+![architecture](images/performance-testing-arch.png)
+
+## Preparation
+
+### Step 1: Setup Dragonfly
+
+- Please refer to [official doc](https://d7y.io/docs/next/getting-started/installation/helm-charts/).
+
+### Step 2: Start a file server
+
+- Start with docker:
+
+```bash
+export FILE_SERVER_PORT=12345
+docker run -d  --rm -p ${FILE_SERVER_PORT}:80 --name dragonfly-fs dragonflyoss/file-server:latest
+```
+
+- Check the file server is ready:
+
+```bash
+# return success if ready
+curl -s -o /dev/null \
+     -w "%{http_code}" \
+     http://localhost:12345/nano \
+| grep -q "200" \
+&& echo "Success" \
+|| echo "Failed"
+```
+
+- Optional:
+
+> you can build your own image, take a reference from [**Dockerfile**](https://github.com/dragonflyoss/perf-tests/blob/main/tools/file-server/Dockerfile).
+
+### Step 3: Install test tools
+
+- Request Generator: [**oha**](https://github.com/hatoo/oha)
+
+```bash
+brew install oha
+```
+
+- Profiling: [**flamegraph**](https://github.com/flamegraph-rs/flamegraph)
+
+```bash
+cargo install flamegraph
+```
+
+### Step 4: Setup Dragonfly Peer
+
+> Document: [Install with binary](https://d7y.io/docs/next/getting-started/installation/binaries/).
+
+- Compile the target binary
+
+```bash
+cargo build --release --bin dfdaemon
+```
+
+- Connect to Dragonfly
+
+```bash
+# prepare client.yaml by yourself.
+./target/release/dfdaemon --config client.yaml -l info --console
+```
+
+## FlameGraph
+
+Now, let's start benchmark with the following params:
+
+- $FILE_SERVER_ADDRESS
+- $CLIENT_PROXY_ADDRESS
+
+### Collect Flamegraph
+
+- Capture the flamegraph:
+
+```bash
+## stop after all requests done.
+sudo flamegraph -o my_flamegraph.svg --pid 3442
+```
+
+- Make the request:
+
+```bash
+oha -c 1000 \
+    -n 100 \
+    --rand-regex-url $FILE_SERVER_ADDRESS/\(nano\|micro\|small\|medium\|large\) \
+    -x $CLIENT_PROXY_ADDRESS
+```

dragonfly-client-backend/Cargo.toml

@@ -14,6 +14,7 @@ dragonfly-client-core.workspace = true
 dragonfly-client-util.workspace = true
 dragonfly-api.workspace = true
 reqwest.workspace = true
+reqwest-middleware.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true
 rustls.workspace = true
@@ -23,12 +24,14 @@ url.workspace = true
 tracing.workspace = true
 opendal.workspace = true
 percent-encoding.workspace = true
-futures = "0.3.28"
-libloading = "0.8.5"
+futures.workspace = true
+reqwest-retry = "0.7"
+reqwest-tracing = "0.5"
+libloading = "0.8.8"
 
 [dev-dependencies]
 tempfile.workspace = true
-wiremock = "0.6.2"
+wiremock = "0.6.4"
 rustls-pki-types.workspace = true
 rustls-pemfile.workspace = true
 hyper.workspace = true

dragonfly-client-backend/examples/plugin/README.md

@@ -14,7 +14,7 @@ cargo build --all && mv target/debug/libhdfs.so {plugin_dir}/backend/libhdfs.so
 ## Run Client with Plugin
 
 ```shell
-$ cargo run --bin dfdaemon -- --config {config_dir}/config.yaml -l info --verbose
+$ cargo run --bin dfdaemon -- --config {config_dir}/config.yaml -l info --console
 INFO  load [http]  builtin backend
 INFO  load [https] builtin backend
 INFO  load [hdfs]  plugin backend

dragonfly-client-backend/src/hdfs.rs

@@ -0,0 +1,272 @@
+/*
+ *     Copyright 2024 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use dragonfly_api::common;
+use dragonfly_client_core::error::BackendError;
+use dragonfly_client_core::{Error as ClientError, Result as ClientResult};
+use opendal::{layers::TimeoutLayer, Metakey, Operator};
+use percent_encoding::percent_decode_str;
+use std::time::Duration;
+use tokio_util::io::StreamReader;
+use tracing::{error, info, instrument};
+use url::Url;
+
+/// HDFS_SCHEME is the scheme of the HDFS.
+pub const HDFS_SCHEME: &str = "hdfs";
+
+/// DEFAULT_NAMENODE_PORT is the default port of the HDFS namenode.
+const DEFAULT_NAMENODE_PORT: u16 = 9870;
+
+/// Hdfs is a struct that implements the Backend trait.
+#[derive(Default)]
+pub struct Hdfs {
+    /// scheme is the scheme of the HDFS.
+    scheme: String,
+}
+
+/// Hdfs implements the Backend trait.
+impl Hdfs {
+    /// new returns a new HDFS backend.
+    pub fn new() -> Self {
+        Self {
+            scheme: HDFS_SCHEME.to_string(),
+        }
+    }
+
+    /// operator initializes the operator with the parsed URL and HDFS config.
+    pub fn operator(
+        &self,
+        url: Url,
+        config: Option<common::v2::Hdfs>,
+        timeout: Duration,
+    ) -> ClientResult<Operator> {
+        // Get the host and port from the URL.
+        let host = url
+            .host_str()
+            .ok_or_else(|| ClientError::InvalidURI(url.to_string()))?
+            .to_string();
+        let port = url.port().unwrap_or(DEFAULT_NAMENODE_PORT);
+
+        // Initialize the HDFS operator.
+        let mut builder = opendal::services::Webhdfs::default();
+        builder = builder
+            .root("/")
+            .endpoint(format!("http://{}:{}", host, port).as_str());
+
+        // If HDFS config is not None, set the config for builder.
+        if let Some(config) = config {
+            if let Some(delegation_token) = &config.delegation_token {
+                builder = builder.delegation(delegation_token.as_str());
+            }
+        }
+
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
+    }
+}
+
+/// Implement the Backend trait for Hdfs.
+#[tonic::async_trait]
+impl super::Backend for Hdfs {
+    /// scheme returns the scheme of the HDFS backend.
+    fn scheme(&self) -> String {
+        self.scheme.clone()
+    }
+
+    /// head gets the header of the request.
+    #[instrument(skip_all)]
+    async fn head(&self, request: super::HeadRequest) -> ClientResult<super::HeadResponse> {
+        info!(
+            "head request {} {}: {:?}",
+            request.task_id, request.url, request.http_header
+        );
+
+        // Parse the URL.
+        let url = Url::parse(request.url.as_ref())
+            .map_err(|_| ClientError::InvalidURI(request.url.clone()))?;
+        let decoded_path = percent_decode_str(url.path())
+            .decode_utf8_lossy()
+            .to_string();
+
+        // Initialize the operator with the parsed URL and HDFS config.
+        let operator = self.operator(url.clone(), request.hdfs, request.timeout)?;
+
+        // Get the entries if url point to a directory.
+        let entries = if url.path().ends_with('/') {
+            operator
+                .list_with(decoded_path.as_str())
+                .recursive(true)
+                .metakey(Metakey::ContentLength | Metakey::Mode)
+                .await // Do the list op here.
+                .map_err(|err| {
+                    error!(
+                        "list request failed {} {}: {}",
+                        request.task_id, request.url, err
+                    );
+                    ClientError::BackendError(Box::new(BackendError {
+                        message: err.to_string(),
+                        status_code: None,
+                        header: None,
+                    }))
+                })?
+                .into_iter()
+                .map(|entry| {
+                    let metadata = entry.metadata();
+                    let mut url = url.clone();
+                    url.set_path(entry.path());
+                    super::DirEntry {
+                        url: url.to_string(),
+                        content_length: metadata.content_length() as usize,
+                        is_dir: metadata.is_dir(),
+                    }
+                })
+                .collect()
+        } else {
+            Vec::new()
+        };
+
+        // Stat the path to get the response from HDFS operator.
+        let response = operator
+            .stat_with(decoded_path.as_str())
+            .await
+            .map_err(|err| {
+                error!(
+                    "stat request failed {} {}: {}",
+                    request.task_id, request.url, err
+                );
+                ClientError::BackendError(Box::new(BackendError {
+                    message: err.to_string(),
+                    status_code: None,
+                    header: None,
+                }))
+            })?;
+
+        info!(
+            "head response {} {}: {}",
+            request.task_id,
+            request.url,
+            response.content_length()
+        );
+
+        Ok(super::HeadResponse {
+            success: true,
+            content_length: Some(response.content_length()),
+            http_header: None,
+            http_status_code: None,
+            error_message: None,
+            entries,
+        })
+    }
+
+    /// get returns content of requested file.
+    #[instrument(skip_all)]
+    async fn get(
+        &self,
+        request: super::GetRequest,
+    ) -> ClientResult<super::GetResponse<super::Body>> {
+        info!(
+            "get request {} {}: {:?}",
+            request.piece_id, request.url, request.http_header
+        );
+
+        // Parse the URL.
+        let url = Url::parse(request.url.as_ref())
+            .map_err(|_| ClientError::InvalidURI(request.url.clone()))?;
+        let decoded_path = percent_decode_str(url.path())
+            .decode_utf8_lossy()
+            .to_string();
+
+        // Initialize the operator with the parsed URL and HDFS config.
+        let operator_reader = self
+            .operator(url.clone(), request.hdfs, request.timeout)?
+            .reader(decoded_path.as_ref())
+            .await
+            .map_err(|err| {
+                error!(
+                    "get request failed {} {}: {}",
+                    request.piece_id, request.url, err
+                );
+                ClientError::BackendError(Box::new(BackendError {
+                    message: err.to_string(),
+                    status_code: None,
+                    header: None,
+                }))
+            })?;
+
+        let stream = match request.range {
+            Some(range) => operator_reader
+                .into_bytes_stream(range.start..range.start + range.length)
+                .await
+                .map_err(|err| {
+                    error!(
+                        "get request failed {} {}: {}",
+                        request.piece_id, request.url, err
+                    );
+                    ClientError::BackendError(Box::new(BackendError {
+                        message: err.to_string(),
+                        status_code: None,
+                        header: None,
+                    }))
+                })?,
+            None => operator_reader.into_bytes_stream(..).await.map_err(|err| {
+                error!(
+                    "get request failed {} {}: {}",
+                    request.piece_id, request.url, err
+                );
+                ClientError::BackendError(Box::new(BackendError {
+                    message: err.to_string(),
+                    status_code: None,
+                    header: None,
+                }))
+            })?,
+        };
+
+        Ok(crate::GetResponse {
+            success: true,
+            http_header: None,
+            http_status_code: Some(reqwest::StatusCode::OK),
+            reader: Box::new(StreamReader::new(stream)),
+            error_message: None,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn should_get_operator() {
+        let url: Url = Url::parse("hdfs://127.0.0.1:9870/file").unwrap();
+        let operator = Hdfs::new().operator(url, None, Duration::from_secs(10));
+
+        assert!(
+            operator.is_ok(),
+            "can not get hdfs operator, due to: {}",
+            operator.unwrap_err()
+        );
+    }
+
+    #[test]
+    fn should_return_error_when_url_not_valid() {
+        let url: Url = Url::parse("hdfs:/127.0.0.1:9870/file").unwrap();
+        let result = Hdfs::new().operator(url, None, Duration::from_secs(10));
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), ClientError::InvalidURI(..)));
+    }
+}

dragonfly-client-backend/src/http.rs

@@ -17,51 +17,119 @@
 use dragonfly_client_core::{Error, Result};
 use dragonfly_client_util::tls::NoVerifier;
 use futures::TryStreamExt;
+use reqwest_middleware::{ClientBuilder, ClientWithMiddleware};
+use reqwest_retry::{policies::ExponentialBackoff, RetryTransientMiddleware};
+use reqwest_tracing::TracingMiddleware;
 use rustls_pki_types::CertificateDer;
 use std::io::{Error as IOError, ErrorKind};
 use tokio_util::io::StreamReader;
-use tracing::{error, info, instrument};
+use tracing::{debug, error, instrument};
+
+/// HTTP_SCHEME is the HTTP scheme.
+pub const HTTP_SCHEME: &str = "http";
+
+/// HTTPS_SCHEME is the HTTPS scheme.
+pub const HTTPS_SCHEME: &str = "https";
 
 /// HTTP is the HTTP backend.
 pub struct HTTP {
     /// scheme is the scheme of the HTTP backend.
     scheme: String,
+
+    /// client is the reqwest client.
+    client: ClientWithMiddleware,
 }
 
 /// HTTP implements the http interface.
 impl HTTP {
     /// new returns a new HTTP.
-    #[instrument(skip_all)]
-    pub fn new(scheme: &str) -> HTTP {
-        Self {
+    pub fn new(scheme: &str) -> Result<HTTP> {
+        // Default TLS client config with no validation.
+        let client_config_builder = rustls::ClientConfig::builder()
+            .dangerous()
+            .with_custom_certificate_verifier(NoVerifier::new())
+            .with_no_client_auth();
+
+        // Disable automatic compression to prevent double-decompression issues.
+        //
+        // Problem scenario:
+        // 1. Origin server supports gzip and returns "content-encoding: gzip" header.
+        // 2. Backend decompresses the response and stores uncompressed content to disk.
+        // 3. When user's client downloads via dfdaemon proxy, the original "content-encoding: gzip".
+        //    header is forwarded to it.
+        // 4. User's client attempts to decompress the already-decompressed content, causing errors.
+        //
+        // Solution: Disable all compression formats (gzip, brotli, zstd, deflate) to ensure
+        // we receive and store uncompressed content, eliminating the double-decompression issue.
+        let client = reqwest::Client::builder()
+            .no_gzip()
+            .no_brotli()
+            .no_zstd()
+            .no_deflate()
+            .use_preconfigured_tls(client_config_builder)
+            .pool_max_idle_per_host(super::POOL_MAX_IDLE_PER_HOST)
+            .tcp_keepalive(super::KEEP_ALIVE_INTERVAL)
+            .build()?;
+
+        let retry_policy =
+            ExponentialBackoff::builder().build_with_max_retries(super::MAX_RETRY_TIMES);
+        let client = ClientBuilder::new(client)
+            .with(TracingMiddleware::default())
+            .with(RetryTransientMiddleware::new_with_policy(retry_policy))
+            .build();
+
+        Ok(Self {
             scheme: scheme.to_string(),
-        }
+            client,
+        })
     }
 
     /// client returns a new reqwest client.
-    #[instrument(skip_all)]
-    fn client(&self, client_cert: Option<Vec<CertificateDer<'static>>>) -> Result<reqwest::Client> {
-        let client_config_builder = match client_cert.as_ref() {
+    fn client(
+        &self,
+        client_cert: Option<Vec<CertificateDer<'static>>>,
+    ) -> Result<ClientWithMiddleware> {
+        match client_cert.as_ref() {
             Some(client_cert) => {
                 let mut root_cert_store = rustls::RootCertStore::empty();
                 root_cert_store.add_parsable_certificates(client_cert.to_owned());
 
                 // TLS client config using the custom CA store for lookups.
-                rustls::ClientConfig::builder()
+                let client_config_builder = rustls::ClientConfig::builder()
                     .with_root_certificates(root_cert_store)
-                    .with_no_client_auth()
-            }
-            // Default TLS client config with native roots.
-            None => rustls::ClientConfig::builder()
-                .dangerous()
-                .with_custom_certificate_verifier(NoVerifier::new())
-                .with_no_client_auth(),
-        };
+                    .with_no_client_auth();
 
-        let client = reqwest::Client::builder()
-            .use_preconfigured_tls(client_config_builder)
-            .build()?;
-        Ok(client)
+                // Disable automatic compression to prevent double-decompression issues.
+                //
+                // Problem scenario:
+                // 1. Origin server supports gzip and returns "content-encoding: gzip" header.
+                // 2. Backend decompresses the response and stores uncompressed content to disk.
+                // 3. When user's client downloads via dfdaemon proxy, the original "content-encoding: gzip".
+                //    header is forwarded to it.
+                // 4. User's client attempts to decompress the already-decompressed content, causing errors.
+                //
+                // Solution: Disable all compression formats (gzip, brotli, zstd, deflate) to ensure
+                // we receive and store uncompressed content, eliminating the double-decompression issue.
+                let client = reqwest::Client::builder()
+                    .no_gzip()
+                    .no_brotli()
+                    .no_zstd()
+                    .no_deflate()
+                    .use_preconfigured_tls(client_config_builder)
+                    .build()?;
+
+                let retry_policy =
+                    ExponentialBackoff::builder().build_with_max_retries(super::MAX_RETRY_TIMES);
+                let client = ClientBuilder::new(client)
+                    .with(TracingMiddleware::default())
+                    .with(RetryTransientMiddleware::new_with_policy(retry_policy))
+                    .build();
+
+                Ok(client)
+            }
+            // Default TLS client config with no validation.
+            None => Ok(self.client.clone()),
+        }
     }
 }
 
@@ -69,7 +137,6 @@ impl HTTP {
 #[tonic::async_trait]
 impl super::Backend for HTTP {
     /// scheme returns the scheme of the HTTP backend.
-    #[instrument(skip_all)]
     fn scheme(&self) -> String {
         self.scheme.clone()
     }
@@ -77,7 +144,7 @@ impl super::Backend for HTTP {
     /// head gets the header of the request.
     #[instrument(skip_all)]
     async fn head(&self, request: super::HeadRequest) -> Result<super::HeadResponse> {
-        info!(
+        debug!(
             "head request {} {}: {:?}",
             request.task_id, request.url, request.http_header
         );
@@ -93,27 +160,37 @@ impl super::Backend for HTTP {
             .client(request.client_cert)?
             .get(&request.url)
             .headers(header)
+            // Add Range header to ensure Content-Length is returned in response headers.
+            // Some servers (especially when using Transfer-Encoding: chunked,
+            // refer to https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Transfer-Encoding.) may not
+            // include Content-Length in HEAD requests. Using "bytes=0-" requests the
+            // entire file starting from byte 0, forcing the server to include file size
+            // information in the response headers.
+            .header(reqwest::header::RANGE, "bytes=0-")
             .timeout(request.timeout)
             .send()
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 error!(
                     "head request failed {} {}: {}",
                     request.task_id, request.url, err
                 );
-                err
             })?;
 
         let header = response.headers().clone();
         let status_code = response.status();
-        info!(
-            "head response {} {}: {:?} {:?}",
-            request.task_id, request.url, status_code, header
+        let content_length = response.content_length();
+        debug!(
+            "head response {} {}: {:?} {:?} {:?}",
+            request.task_id, request.url, status_code, content_length, header
         );
 
+        // Drop the response body to avoid reading it.
+        drop(response);
+
         Ok(super::HeadResponse {
             success: status_code.is_success(),
-            content_length: response.content_length(),
+            content_length,
             http_header: Some(header),
             http_status_code: Some(status_code),
             error_message: Some(status_code.to_string()),
@@ -124,7 +201,7 @@ impl super::Backend for HTTP {
     /// get gets the content of the request.
     #[instrument(skip_all)]
     async fn get(&self, request: super::GetRequest) -> Result<super::GetResponse<super::Body>> {
-        info!(
+        debug!(
             "get request {} {} {}: {:?}",
             request.task_id, request.piece_id, request.url, request.http_header
         );
@@ -138,12 +215,11 @@ impl super::Backend for HTTP {
             .timeout(request.timeout)
             .send()
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 error!(
                     "get request failed {} {} {}: {}",
                     request.task_id, request.piece_id, request.url, err
                 );
-                err
             })?;
 
         let header = response.headers().clone();
@@ -153,7 +229,8 @@ impl super::Backend for HTTP {
                 .bytes_stream()
                 .map_err(|err| IOError::new(ErrorKind::Other, err)),
         ));
-        info!(
+
+        debug!(
             "get response {} {}: {:?} {:?}",
             request.task_id, request.piece_id, status_code, header
         );
@@ -168,17 +245,12 @@ impl super::Backend for HTTP {
     }
 }
 
-/// Default implements the Default trait.
-impl Default for HTTP {
-    /// default returns a new default HTTP.
-    fn default() -> Self {
-        Self::new("http")
-    }
-}
-
 #[cfg(test)]
 mod tests {
-    use crate::{http::HTTP, Backend, GetRequest, HeadRequest};
+    use crate::{
+        http::{HTTP, HTTPS_SCHEME, HTTP_SCHEME},
+        Backend, GetRequest, HeadRequest,
+    };
     use dragonfly_client_util::tls::{load_certs_from_pem, load_key_from_pem};
     use hyper_util::rt::{TokioExecutor, TokioIo};
     use reqwest::{header::HeaderMap, StatusCode};
@@ -347,7 +419,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
             .mount(&server)
             .await;
 
-        let resp = HTTP::new("http")
+        let resp = HTTP::new(HTTP_SCHEME)
+            .unwrap()
             .head(HeadRequest {
                 task_id: "test".to_string(),
                 url: format!("{}/head", server.uri()),
@@ -355,6 +428,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: None,
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();
@@ -374,7 +448,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
             .mount(&server)
             .await;
 
-        let resp = HTTP::new("http")
+        let resp = HTTP::new(HTTP_SCHEME)
+            .unwrap()
             .head(HeadRequest {
                 task_id: "test".to_string(),
                 url: format!("{}/head", server.uri()),
@@ -382,6 +457,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: None,
                 object_storage: None,
+                hdfs: None,
             })
             .await;
 
@@ -401,7 +477,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
             .mount(&server)
             .await;
 
-        let mut resp = HTTP::new("http")
+        let mut resp = HTTP::new(HTTP_SCHEME)
+            .unwrap()
             .get(GetRequest {
                 task_id: "test".to_string(),
                 piece_id: "test".to_string(),
@@ -411,6 +488,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: None,
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();
@@ -422,7 +500,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_get_head_response_with_self_signed_cert() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let resp = HTTP::new("https")
+        let resp = HTTP::new(HTTPS_SCHEME)
+            .unwrap()
             .head(HeadRequest {
                 task_id: "test".to_string(),
                 url: server_addr,
@@ -430,6 +509,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: Duration::from_secs(5),
                 client_cert: Some(load_certs_from_pem(CA_CERT).unwrap()),
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();
@@ -440,7 +520,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_return_error_response_when_head_with_wrong_cert() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let resp = HTTP::new("https")
+        let resp = HTTP::new(HTTPS_SCHEME)
+            .unwrap()
             .head(HeadRequest {
                 task_id: "test".to_string(),
                 url: server_addr,
@@ -448,6 +529,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: Duration::from_secs(5),
                 client_cert: Some(load_certs_from_pem(WRONG_CA_CERT).unwrap()),
                 object_storage: None,
+                hdfs: None,
             })
             .await;
 
@@ -457,7 +539,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_get_response_with_self_signed_cert() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let mut resp = HTTP::new("https")
+        let mut resp = HTTP::new(HTTPS_SCHEME)
+            .unwrap()
             .get(GetRequest {
                 task_id: "test".to_string(),
                 piece_id: "test".to_string(),
@@ -467,6 +550,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: Some(load_certs_from_pem(CA_CERT).unwrap()),
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();
@@ -478,7 +562,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_return_error_response_when_get_with_wrong_cert() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let resp = HTTP::new("https")
+        let resp = HTTP::new(HTTPS_SCHEME)
+            .unwrap()
             .get(GetRequest {
                 task_id: "test".to_string(),
                 piece_id: "test".to_string(),
@@ -488,6 +573,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: Some(load_certs_from_pem(WRONG_CA_CERT).unwrap()),
                 object_storage: None,
+                hdfs: None,
             })
             .await;
 
@@ -497,7 +583,8 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_get_head_response_with_no_verifier() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let resp = HTTP::new("https")
+        let resp = HTTP::new(HTTPS_SCHEME)
+            .unwrap()
             .head(HeadRequest {
                 task_id: "test".to_string(),
                 url: server_addr,
@@ -505,6 +592,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: Duration::from_secs(5),
                 client_cert: None,
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();
@@ -515,8 +603,9 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
     #[tokio::test]
     async fn should_get_response_with_no_verifier() {
         let server_addr = start_https_server(SERVER_CERT, SERVER_KEY).await;
-        let http_backend = HTTP::new("https");
+        let http_backend = HTTP::new(HTTPS_SCHEME);
         let mut resp = http_backend
+            .unwrap()
             .get(GetRequest {
                 task_id: "test".to_string(),
                 piece_id: "test".to_string(),
@@ -526,6 +615,7 @@ TrIVG3cErZoBC6zqBs/Ibe9q3gdHGqS3QLAKy/k=
                 timeout: std::time::Duration::from_secs(5),
                 client_cert: None,
                 object_storage: None,
+                hdfs: None,
             })
             .await
             .unwrap();

dragonfly-client-backend/src/lib.rs

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-use dragonfly_api::common::v2::{ObjectStorage, Range};
+use dragonfly_api::common::v2::{Hdfs, ObjectStorage, Range};
 use dragonfly_client_core::{
     error::{ErrorType, OrErr},
     Error, Result,
@@ -26,12 +26,28 @@ use std::path::Path;
 use std::{collections::HashMap, pin::Pin, time::Duration};
 use std::{fmt::Debug, fs};
 use tokio::io::{AsyncRead, AsyncReadExt};
-use tracing::{error, info, instrument, warn};
+use tracing::{error, info, warn};
 use url::Url;
 
+pub mod hdfs;
 pub mod http;
 pub mod object_storage;
 
+/// POOL_MAX_IDLE_PER_HOST is the max idle connections per host.
+const POOL_MAX_IDLE_PER_HOST: usize = 1024;
+
+/// KEEP_ALIVE_INTERVAL is the keep alive interval for TCP connection.
+const KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(60);
+
+/// HTTP2_KEEP_ALIVE_INTERVAL is the interval for HTTP2 keep alive.
+const HTTP2_KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(300);
+
+/// HTTP2_KEEP_ALIVE_TIMEOUT is the timeout for HTTP2 keep alive.
+const HTTP2_KEEP_ALIVE_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// MAX_RETRY_TIMES is the max retry times for the request.
+const MAX_RETRY_TIMES: u32 = 1;
+
 /// NAME is the name of the package.
 pub const NAME: &str = "backend";
 
@@ -57,6 +73,9 @@ pub struct HeadRequest {
 
     /// object_storage is the object storage related information.
     pub object_storage: Option<ObjectStorage>,
+
+    /// hdfs is the hdfs related information.
+    pub hdfs: Option<Hdfs>,
 }
 
 /// HeadResponse is the head response for backend.
@@ -106,6 +125,9 @@ pub struct GetRequest {
 
     /// the object storage related information.
     pub object_storage: Option<ObjectStorage>,
+
+    /// hdfs is the hdfs related information.
+    pub hdfs: Option<Hdfs>,
 }
 
 /// GetResponse is the get response for backend.
@@ -144,7 +166,7 @@ where
 }
 
 /// The File Entry of a directory, including some relevant file metadata.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct DirEntry {
     /// url is the url of the entry.
     pub url: String,
@@ -175,7 +197,7 @@ pub struct BackendFactory {
     /// backends is the backends of the factory, including the plugin backends and
     /// the builtin backends.
     backends: HashMap<String, Box<dyn Backend + Send + Sync>>,
-    /// libraries is used to store the plugin's dynamic library, because when not saving the `Library`,
+    /// libraries are used to store the plugin's dynamic library, because when not saving the `Library`,
     /// it will drop when out of scope, resulting in the null pointer error.
     libraries: Vec<Library>,
 }
@@ -183,7 +205,7 @@ pub struct BackendFactory {
 /// BackendFactory implements the factory of the backend. It supports loading builtin
 /// backends and plugin backends.
 ///
-/// The builtin backends are http, https, etc, which are implemented
+/// The builtin backends are http, https, etc., which are implemented
 /// by the HTTP struct.
 ///
 /// The plugin backends are shared libraries, which are loaded
@@ -204,24 +226,26 @@ pub struct BackendFactory {
 /// https://github.com/dragonflyoss/client/tree/main/dragonfly-client-backend/examples/plugin/.
 impl BackendFactory {
     /// new returns a new BackendFactory.
-    #[instrument(skip_all)]
     pub fn new(plugin_dir: Option<&Path>) -> Result<Self> {
         let mut backend_factory = Self::default();
-        backend_factory.load_builtin_backends();
+        backend_factory.load_builtin_backends()?;
         if let Some(plugin_dir) = plugin_dir {
             backend_factory
                 .load_plugin_backends(plugin_dir)
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("failed to load plugin backends: {}", err);
-                    err
                 })?;
         }
 
         Ok(backend_factory)
     }
 
+    /// unsupported_download_directory returns whether the scheme does not support directory download.
+    pub fn unsupported_download_directory(scheme: &str) -> bool {
+        scheme == http::HTTP_SCHEME || scheme == http::HTTPS_SCHEME
+    }
+
     /// build returns the backend by the scheme of the url.
-    #[instrument(skip_all)]
     pub fn build(&self, url: &str) -> Result<&(dyn Backend + Send + Sync)> {
         let url = Url::parse(url).or_err(ErrorType::ParseError)?;
         let scheme = url.scheme();
@@ -232,21 +256,24 @@ impl BackendFactory {
     }
 
     /// load_builtin_backends loads the builtin backends.
-    #[instrument(skip_all)]
-    fn load_builtin_backends(&mut self) {
-        self.backends
-            .insert("http".to_string(), Box::new(http::HTTP::new("http")));
+    fn load_builtin_backends(&mut self) -> Result<()> {
+        self.backends.insert(
+            "http".to_string(),
+            Box::new(http::HTTP::new(http::HTTP_SCHEME)?),
+        );
         info!("load [http] builtin backend");
 
-        self.backends
-            .insert("https".to_string(), Box::new(http::HTTP::new("https")));
-        info!("load [https] builtin backend ");
+        self.backends.insert(
+            "https".to_string(),
+            Box::new(http::HTTP::new(http::HTTPS_SCHEME)?),
+        );
+        info!("load [https] builtin backend");
 
         self.backends.insert(
             "s3".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::S3,
-            )),
+            )?),
         );
         info!("load [s3] builtin backend");
 
@@ -254,7 +281,7 @@ impl BackendFactory {
             "gs".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::GCS,
-            )),
+            )?),
         );
         info!("load [gcs] builtin backend");
 
@@ -262,7 +289,7 @@ impl BackendFactory {
             "abs".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::ABS,
-            )),
+            )?),
         );
         info!("load [abs] builtin backend");
 
@@ -270,15 +297,15 @@ impl BackendFactory {
             "oss".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::OSS,
-            )),
+            )?),
         );
-        info!("load [oss] builtin backend ");
+        info!("load [oss] builtin backend");
 
         self.backends.insert(
             "obs".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::OBS,
-            )),
+            )?),
         );
         info!("load [obs] builtin backend");
 
@@ -286,19 +313,24 @@ impl BackendFactory {
             "cos".to_string(),
             Box::new(object_storage::ObjectStorage::new(
                 object_storage::Scheme::COS,
-            )),
+            )?),
         );
         info!("load [cos] builtin backend");
+
+        self.backends
+            .insert("hdfs".to_string(), Box::new(hdfs::Hdfs::new()));
+        info!("load [hdfs] builtin backend");
+
+        Ok(())
     }
 
     /// load_plugin_backends loads the plugin backends.
-    #[instrument(skip_all)]
     fn load_plugin_backends(&mut self, plugin_dir: &Path) -> Result<()> {
         let backend_plugin_dir = plugin_dir.join(NAME);
         if !backend_plugin_dir.exists() {
             warn!(
                 "skip loading plugin backends, because the plugin directory {} does not exist",
-                plugin_dir.display()
+                backend_plugin_dir.display()
             );
             return Ok(());
         }
@@ -347,7 +379,9 @@ mod tests {
     #[test]
     fn should_load_builtin_backends() {
         let factory = BackendFactory::new(None).unwrap();
-        let expected_backends = vec!["http", "https", "s3", "gs", "abs", "oss", "obs", "cos"];
+        let expected_backends = vec![
+            "http", "https", "s3", "gs", "abs", "oss", "obs", "cos", "hdfs",
+        ];
         for backend in expected_backends {
             assert!(factory.backends.contains_key(backend));
         }
@@ -378,7 +412,7 @@ mod tests {
         let plugin_dir = dir.path().join("non_existent_plugin_dir");
 
         let factory = BackendFactory::new(Some(&plugin_dir)).unwrap();
-        assert_eq!(factory.backends.len(), 8);
+        assert_eq!(factory.backends.len(), 9);
     }
 
     #[test]
@@ -396,9 +430,15 @@ mod tests {
 
         let result = BackendFactory::new(Some(&plugin_dir));
         assert!(result.is_err());
-        assert_eq!(
-            format!("{}", result.err().unwrap()),
-            format!("PluginError cause: {}: file too short", lib_path.display()),
+        let err_msg = format!("{}", result.err().unwrap());
+
+        assert!(
+            err_msg.starts_with("PluginError cause:"),
+            "error message should start with 'PluginError cause:'"
+        );
+        assert!(
+            err_msg.contains(&lib_path.display().to_string()),
+            "error message should contain library path"
         );
     }
 

dragonfly-client-backend/src/object_storage.rs

@@ -17,14 +17,14 @@
 use dragonfly_api::common;
 use dragonfly_client_core::error::BackendError;
 use dragonfly_client_core::{Error as ClientError, Result as ClientResult};
-use opendal::{raw::HttpClient, Metakey, Operator};
+use opendal::{layers::TimeoutLayer, raw::HttpClient, Metakey, Operator};
 use percent_encoding::percent_decode_str;
 use std::fmt;
 use std::result::Result;
 use std::str::FromStr;
 use std::time::Duration;
 use tokio_util::io::StreamReader;
-use tracing::{error, info, instrument};
+use tracing::{debug, error, instrument};
 use url::Url;
 
 /// Scheme is the scheme of the object storage.
@@ -68,7 +68,7 @@ impl fmt::Display for Scheme {
 impl FromStr for Scheme {
     type Err = String;
 
-    /// from_str parses an scheme string.
+    /// from_str parses a scheme string.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "s3" => Ok(Scheme::S3),
@@ -169,18 +169,32 @@ macro_rules! make_need_fields_message {
 pub struct ObjectStorage {
     /// scheme is the scheme of the object storage.
     scheme: Scheme,
+
+    /// client is the reqwest client.
+    client: reqwest::Client,
 }
 
 /// ObjectStorage implements the ObjectStorage trait.
 impl ObjectStorage {
     /// Returns ObjectStorage that implements the Backend trait.
-    #[instrument(skip_all)]
-    pub fn new(scheme: Scheme) -> ObjectStorage {
-        Self { scheme }
+    pub fn new(scheme: Scheme) -> ClientResult<ObjectStorage> {
+        // Initialize the reqwest client.
+        let client = reqwest::Client::builder()
+            .gzip(true)
+            .brotli(true)
+            .zstd(true)
+            .deflate(true)
+            .pool_max_idle_per_host(super::POOL_MAX_IDLE_PER_HOST)
+            .tcp_keepalive(super::KEEP_ALIVE_INTERVAL)
+            .http2_keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
+            .http2_keep_alive_interval(super::HTTP2_KEEP_ALIVE_INTERVAL)
+            .http2_keep_alive_while_idle(true)
+            .build()?;
+
+        Ok(Self { scheme, client })
     }
 
     /// operator initializes the operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
@@ -189,11 +203,11 @@ impl ObjectStorage {
     ) -> ClientResult<Operator> {
         // If download backend is object storage, object_storage parameter is required.
         let Some(object_storage) = object_storage else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!("{} need object_storage parameter", self.scheme),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         match self.scheme {
@@ -207,23 +221,19 @@ impl ObjectStorage {
     }
 
     /// s3_operator initializes the S3 operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn s3_operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // S3 requires the access key id and the secret access key.
         let (Some(access_key_id), Some(access_key_secret), Some(region)) = (
             &object_storage.access_key_id,
             &object_storage.access_key_secret,
             &object_storage.region,
         ) else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!(
                     "{} {}",
                     self.scheme,
@@ -235,7 +245,7 @@ impl ObjectStorage {
                 ),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         // Initialize the S3 operator with the object storage.
@@ -243,7 +253,7 @@ impl ObjectStorage {
         builder = builder
             .access_key_id(access_key_id)
             .secret_access_key(access_key_secret)
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .bucket(&parsed_url.bucket)
             .region(region);
 
@@ -257,27 +267,25 @@ impl ObjectStorage {
             builder = builder.session_token(session_token);
         }
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 
     /// gcs_operator initializes the GCS operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn gcs_operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // Initialize the GCS operator with the object storage.
         let mut builder = opendal::services::Gcs::default();
         builder = builder
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .bucket(&parsed_url.bucket);
 
-        // Configure the credentials using the local path to the crendential file if provided.
+        // Configure the credentials using the local path to the credential file if provided.
         // Otherwise, configure using the Application Default Credentials (ADC).
         if let Some(credential_path) = object_storage.credential_path.as_deref() {
             builder = builder.credential_path(credential_path);
@@ -293,27 +301,25 @@ impl ObjectStorage {
             builder = builder.predefined_acl(predefined_acl);
         }
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 
     /// abs_operator initializes the ABS operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn abs_operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // ABS requires the account name and the account key.
         let (Some(access_key_id), Some(access_key_secret), Some(endpoint)) = (
             &object_storage.access_key_id,
             &object_storage.access_key_secret,
             &object_storage.endpoint,
         ) else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!(
                     "{} {}",
                     self.scheme,
@@ -325,7 +331,7 @@ impl ObjectStorage {
                 ),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         // Initialize the ABS operator with the object storage.
@@ -333,31 +339,29 @@ impl ObjectStorage {
         builder = builder
             .account_name(access_key_id)
             .account_key(access_key_secret)
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .container(&parsed_url.bucket)
             .endpoint(endpoint);
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 
     /// oss_operator initializes the OSS operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn oss_operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // OSS requires the access key id, access key secret, and endpoint.
         let (Some(access_key_id), Some(access_key_secret), Some(endpoint)) = (
             &object_storage.access_key_id,
             &object_storage.access_key_secret,
             &object_storage.endpoint,
         ) else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!(
                     "{} {}",
                     self.scheme,
@@ -369,7 +373,7 @@ impl ObjectStorage {
                 ),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         // Initialize the OSS operator with the object storage.
@@ -378,31 +382,29 @@ impl ObjectStorage {
             .access_key_id(access_key_id)
             .access_key_secret(access_key_secret)
             .endpoint(endpoint)
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .root("/")
             .bucket(&parsed_url.bucket);
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 
     /// obs_operator initializes the OBS operator with the parsed URL and object storage.
-    #[instrument(skip_all)]
     pub fn obs_operator(
         &self,
         parsed_url: &super::object_storage::ParsedURL,
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // OBS requires the endpoint, access key id, and access key secret.
         let (Some(access_key_id), Some(access_key_secret), Some(endpoint)) = (
             &object_storage.access_key_id,
             &object_storage.access_key_secret,
             &object_storage.endpoint,
         ) else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!(
                     "{} {}",
                     self.scheme,
@@ -414,7 +416,7 @@ impl ObjectStorage {
                 ),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         // Initialize the OBS operator with the object storage.
@@ -423,10 +425,12 @@ impl ObjectStorage {
             .access_key_id(access_key_id)
             .secret_access_key(access_key_secret)
             .endpoint(endpoint)
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .bucket(&parsed_url.bucket);
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 
     /// cos_operator initializes the COS operator with the parsed URL and object storage.
@@ -436,16 +440,13 @@ impl ObjectStorage {
         object_storage: common::v2::ObjectStorage,
         timeout: Duration,
     ) -> ClientResult<Operator> {
-        // Create a reqwest http client.
-        let client = reqwest::Client::builder().timeout(timeout).build()?;
-
         // COS requires the access key id, the access key secret, and the endpoint.
         let (Some(access_key_id), Some(access_key_secret), Some(endpoint)) = (
             &object_storage.access_key_id,
             &object_storage.access_key_secret,
             &object_storage.endpoint,
         ) else {
-            return Err(ClientError::BackendError(BackendError {
+            return Err(ClientError::BackendError(Box::new(BackendError {
                 message: format!(
                     "{} {}",
                     self.scheme,
@@ -457,7 +458,7 @@ impl ObjectStorage {
                 ),
                 status_code: None,
                 header: None,
-            }));
+            })));
         };
 
         // Initialize the COS operator with the object storage.
@@ -466,10 +467,12 @@ impl ObjectStorage {
             .secret_id(access_key_id)
             .secret_key(access_key_secret)
             .endpoint(endpoint)
-            .http_client(HttpClient::with(client))
+            .http_client(HttpClient::with(self.client.clone()))
             .bucket(&parsed_url.bucket);
 
-        Ok(Operator::new(builder)?.finish())
+        Ok(Operator::new(builder)?
+            .finish()
+            .layer(TimeoutLayer::new().with_timeout(timeout)))
     }
 }
 
@@ -477,7 +480,6 @@ impl ObjectStorage {
 #[tonic::async_trait]
 impl crate::Backend for ObjectStorage {
     /// scheme returns the scheme of the object storage.
-    #[instrument(skip_all)]
     fn scheme(&self) -> String {
         self.scheme.to_string()
     }
@@ -485,7 +487,7 @@ impl crate::Backend for ObjectStorage {
     /// head gets the header of the request.
     #[instrument(skip_all)]
     async fn head(&self, request: super::HeadRequest) -> ClientResult<super::HeadResponse> {
-        info!(
+        debug!(
             "head request {} {}: {:?}",
             request.task_id, request.url, request.http_header
         );
@@ -495,12 +497,11 @@ impl crate::Backend for ObjectStorage {
             .url
             .parse()
             .map_err(|_| ClientError::InvalidURI(request.url.clone()))?;
-        let parsed_url: super::object_storage::ParsedURL = url.try_into().map_err(|err| {
+        let parsed_url: super::object_storage::ParsedURL = url.try_into().inspect_err(|err| {
             error!(
                 "parse head request url failed {} {}: {}",
                 request.task_id, request.url, err
             );
-            err
         })?;
 
         // Initialize the operator with the parsed URL, object storage, and timeout.
@@ -518,11 +519,11 @@ impl crate::Backend for ObjectStorage {
                         "list request failed {} {}: {}",
                         request.task_id, request.url, err
                     );
-                    ClientError::BackendError(BackendError {
+                    ClientError::BackendError(Box::new(BackendError {
                         message: err.to_string(),
                         status_code: None,
                         header: None,
-                    })
+                    }))
                 })?
                 .into_iter()
                 .map(|entry| {
@@ -544,14 +545,14 @@ impl crate::Backend for ObjectStorage {
                 "stat request failed {} {}: {}",
                 request.task_id, request.url, err
             );
-            ClientError::BackendError(BackendError {
+            ClientError::BackendError(Box::new(BackendError {
                 message: err.to_string(),
                 status_code: None,
                 header: None,
-            })
+            }))
         })?;
 
-        info!(
+        debug!(
             "head response {} {}: {}",
             request.task_id,
             request.url,
@@ -568,13 +569,13 @@ impl crate::Backend for ObjectStorage {
         })
     }
 
-    /// Returns content of requested file.
+    /// get returns content of requested file.
     #[instrument(skip_all)]
     async fn get(
         &self,
         request: super::GetRequest,
     ) -> ClientResult<super::GetResponse<super::Body>> {
-        info!(
+        debug!(
             "get request {} {}: {:?}",
             request.piece_id, request.url, request.http_header
         );
@@ -584,12 +585,11 @@ impl crate::Backend for ObjectStorage {
             .url
             .parse()
             .map_err(|_| ClientError::InvalidURI(request.url.clone()))?;
-        let parsed_url: super::object_storage::ParsedURL = url.try_into().map_err(|err| {
+        let parsed_url: super::object_storage::ParsedURL = url.try_into().inspect_err(|err| {
             error!(
                 "parse get request url failed {} {}: {}",
                 request.piece_id, request.url, err
             );
-            err
         })?;
 
         // Initialize the operator with the parsed URL, object storage, and timeout.
@@ -602,11 +602,11 @@ impl crate::Backend for ObjectStorage {
                     "get request failed {} {}: {}",
                     request.piece_id, request.url, err
                 );
-                ClientError::BackendError(BackendError {
+                ClientError::BackendError(Box::new(BackendError {
                     message: err.to_string(),
                     status_code: None,
                     header: None,
-                })
+                }))
             })?;
 
         let stream = match request.range {
@@ -618,22 +618,22 @@ impl crate::Backend for ObjectStorage {
                         "get request failed {} {}: {}",
                         request.piece_id, request.url, err
                     );
-                    ClientError::BackendError(BackendError {
+                    ClientError::BackendError(Box::new(BackendError {
                         message: err.to_string(),
                         status_code: None,
                         header: None,
-                    })
+                    }))
                 })?,
             None => operator_reader.into_bytes_stream(..).await.map_err(|err| {
                 error!(
                     "get request failed {} {}: {}",
                     request.piece_id, request.url, err
                 );
-                ClientError::BackendError(BackendError {
+                ClientError::BackendError(Box::new(BackendError {
                     message: err.to_string(),
                     status_code: None,
                     header: None,
-                })
+                }))
             })?,
         };
 
@@ -798,7 +798,7 @@ mod tests {
             let url: Url = format!("{}://test-bucket/file", scheme).parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(scheme).operator(
+            let result = ObjectStorage::new(scheme).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -847,7 +847,7 @@ mod tests {
             let url: Url = "s3://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::S3).operator(
+            let result = ObjectStorage::new(Scheme::S3).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -900,7 +900,7 @@ mod tests {
             let url: Url = "gs://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::GCS).operator(
+            let result = ObjectStorage::new(Scheme::GCS).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -916,8 +916,11 @@ mod tests {
         let url: Url = "s3://test-bucket/file".parse().unwrap();
         let parsed_url: ParsedURL = url.try_into().unwrap();
 
-        let result =
-            ObjectStorage::new(Scheme::S3).operator(&parsed_url, None, Duration::from_secs(3));
+        let result = ObjectStorage::new(Scheme::S3).unwrap().operator(
+            &parsed_url,
+            None,
+            Duration::from_secs(3),
+        );
 
         assert!(result.is_err());
         assert_eq!(
@@ -984,7 +987,7 @@ mod tests {
             let url: Url = "s3://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::S3).operator(
+            let result = ObjectStorage::new(Scheme::S3).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -1053,7 +1056,7 @@ mod tests {
             let url: Url = "abs://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::ABS).operator(
+            let result = ObjectStorage::new(Scheme::ABS).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -1122,7 +1125,7 @@ mod tests {
             let url: Url = "oss://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::OSS).operator(
+            let result = ObjectStorage::new(Scheme::OSS).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -1191,7 +1194,7 @@ mod tests {
             let url: Url = "obs://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::OBS).operator(
+            let result = ObjectStorage::new(Scheme::OBS).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),
@@ -1260,7 +1263,7 @@ mod tests {
             let url: Url = "cos://test-bucket/file".parse().unwrap();
             let parsed_url: ParsedURL = url.try_into().unwrap();
 
-            let result = ObjectStorage::new(Scheme::COS).operator(
+            let result = ObjectStorage::new(Scheme::COS).unwrap().operator(
                 &parsed_url,
                 Some(object_storage),
                 Duration::from_secs(3),

dragonfly-client-config/Cargo.toml

@@ -13,6 +13,7 @@ build = "build.rs"
 [dependencies]
 dragonfly-client-core.workspace = true
 dragonfly-client-util.workspace = true
+local-ip-address.workspace = true
 clap.workspace = true
 regex.workspace = true
 serde.workspace = true
@@ -21,14 +22,16 @@ validator.workspace = true
 humantime.workspace = true
 serde_yaml.workspace = true
 tokio.workspace = true
+tempfile.workspace = true
+serde_json.workspace = true
 bytesize.workspace = true
 bytesize-serde.workspace = true
-lazy_static.workspace = true
 tonic.workspace = true
 rustls-pki-types.workspace = true
 rcgen.workspace = true
-home = "0.5.4"
-local-ip-address = "0.6.3"
+reqwest.workspace = true
+home = "0.5.11"
 hostname = "^0.4"
 humantime-serde = "1.1.1"
 serde_regex = "1.1.0"
+http-serde = "2.1.1"

dragonfly-client-config/build.rs

@@ -61,9 +61,8 @@ fn get_commit_from_git() -> Option<Commit> {
 
 fn main() {
     // Set the environment variables for the build platform.
-    if let Ok(target) = env::var("TARGET") {
-        println!("cargo:rustc-env=BUILD_PLATFORM={}", target);
-    }
+    let target = env::var("TARGET").unwrap_or_default();
+    println!("cargo:rustc-env=BUILD_PLATFORM={}", target);
 
     // Set the environment variables for the build time.
     if let Ok(build_time) = SystemTime::now().duration_since(UNIX_EPOCH) {

dragonfly-client-config/src/dfcache.rs

@@ -19,6 +19,10 @@ use std::path::PathBuf;
 /// NAME is the name of dfcache.
 pub const NAME: &str = "dfcache";
 
+// DEFAULT_OUTPUT_FILE_MODE defines the default file mode for output files when downloading with dfcache
+// using the `--transfer-from-dfdaemon=true` option.
+pub const DEFAULT_OUTPUT_FILE_MODE: u32 = 0o644;
+
 /// default_dfcache_log_dir is the default log directory for dfcache.
 #[inline]
 pub fn default_dfcache_log_dir() -> PathBuf {

dragonfly-client-config/src/dfget.rs

@@ -19,6 +19,10 @@ use std::path::PathBuf;
 /// NAME is the name of dfget.
 pub const NAME: &str = "dfget";
 
+// DEFAULT_OUTPUT_FILE_MODE defines the default file mode for output files when downloading with dfget
+// using the `--transfer-from-dfdaemon=true` option.
+pub const DEFAULT_OUTPUT_FILE_MODE: u32 = 0o644;
+
 /// default_dfget_log_dir is the default log directory for dfget.
 pub fn default_dfget_log_dir() -> PathBuf {
     crate::default_log_dir().join(NAME)

dragonfly-client-config/src/dfinit.rs

@@ -56,6 +56,12 @@ fn default_container_runtime_crio_config_path() -> PathBuf {
     PathBuf::from("/etc/containers/registries.conf")
 }
 
+/// default_container_runtime_podman_config_path is the default podman configuration path.
+#[inline]
+fn default_container_runtime_podman_config_path() -> PathBuf {
+    PathBuf::from("/etc/containers/registries.conf")
+}
+
 /// default_container_runtime_crio_unqualified_search_registries is the default unqualified search registries of cri-o,
 /// refer to https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#global-settings.
 #[inline]
@@ -67,6 +73,17 @@ fn default_container_runtime_crio_unqualified_search_registries() -> Vec<String>
     ]
 }
 
+/// default_container_runtime_podman_unqualified_search_registries is the default unqualified search registries of cri-o,
+/// refer to https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#global-settings.
+#[inline]
+fn default_container_runtime_podman_unqualified_search_registries() -> Vec<String> {
+    vec![
+        "registry.fedoraproject.org".to_string(),
+        "registry.access.redhat.com".to_string(),
+        "docker.io".to_string(),
+    ]
+}
+
 /// default_proxy_addr is the default proxy address of dfdaemon.
 #[inline]
 fn default_proxy_addr() -> String {
@@ -156,6 +173,37 @@ pub struct CRIO {
     pub registries: Vec<CRIORegistry>,
 }
 
+/// PodmanRegistry is the registry configuration for podman.
+#[derive(Debug, Clone, Default, Validate, Deserialize, Serialize, PartialEq, Eq)]
+#[serde(default, rename_all = "camelCase")]
+pub struct PodmanRegistry {
+    /// prefix is the prefix of the user-specified image name, refer to
+    /// https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#choosing-a-registry-toml-table.
+    pub prefix: String,
+
+    /// location accepts the same format as the prefix field, and specifies the physical location of the prefix-rooted namespace,
+    /// refer to https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#remapping-and-mirroring-registries.
+    pub location: String,
+}
+
+/// Podman is the podman configuration for dfinit.
+#[derive(Debug, Clone, Default, Validate, Deserialize, Serialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Podman {
+    /// config_path is the path of cri-o registries's configuration file.
+    #[serde(default = "default_container_runtime_podman_config_path")]
+    pub config_path: PathBuf,
+
+    /// unqualified_search_registries is an array of host[:port] registries to try when pulling an unqualified image, in order.
+    /// Refer to https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#global-settings.
+    #[serde(default = "default_container_runtime_podman_unqualified_search_registries")]
+    pub unqualified_search_registries: Vec<String>,
+
+    /// registries is the list of cri-o registries, refer to
+    /// https://github.com/containers/image/blob/main/docs/containers-registries.conf.5.md#namespaced-registry-settings.
+    pub registries: Vec<PodmanRegistry>,
+}
+
 /// Docker is the docker configuration for dfinit.
 #[derive(Debug, Clone, Default, Validate, Deserialize, Serialize)]
 #[serde(default, rename_all = "camelCase")]
@@ -179,6 +227,7 @@ pub enum ContainerRuntimeConfig {
     Containerd(Containerd),
     Docker(Docker),
     CRIO(CRIO),
+    Podman(Podman),
 }
 
 /// Serialize is the implementation of the Serialize trait for ContainerRuntimeConfig.
@@ -203,6 +252,11 @@ impl Serialize for ContainerRuntimeConfig {
                 state.serialize_field("crio", &cfg)?;
                 state.end()
             }
+            ContainerRuntimeConfig::Podman(ref cfg) => {
+                let mut state = serializer.serialize_struct("podman", 1)?;
+                state.serialize_field("podman", &cfg)?;
+                state.end()
+            }
         }
     }
 }
@@ -218,6 +272,7 @@ impl<'de> Deserialize<'de> for ContainerRuntimeConfig {
             containerd: Option<Containerd>,
             docker: Option<Docker>,
             crio: Option<CRIO>,
+            podman: Option<Podman>,
         }
 
         let helper = ContainerRuntimeHelper::deserialize(deserializer)?;
@@ -233,9 +288,15 @@ impl<'de> Deserialize<'de> for ContainerRuntimeConfig {
             ContainerRuntimeHelper {
                 crio: Some(crio), ..
             } => Ok(ContainerRuntimeConfig::CRIO(crio)),
+            ContainerRuntimeHelper {
+                podman: Some(podman),
+                ..
+            } => Ok(ContainerRuntimeConfig::Podman(podman)),
             _ => {
                 use serde::de::Error;
-                Err(D::Error::custom("expected containerd or docker or crio"))
+                Err(D::Error::custom(
+                    "expected containerd or docker or crio or podman",
+                ))
             }
         }
     }
@@ -291,6 +352,62 @@ impl Config {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::path::Path;
+
+    #[test]
+    fn test_default_dfinit_config_path() {
+        let expected = crate::default_config_dir().join("dfinit.yaml");
+        assert_eq!(default_dfinit_config_path(), expected);
+    }
+
+    #[test]
+    fn test_default_dfinit_log_dir() {
+        let expected = crate::default_log_dir().join(NAME);
+        assert_eq!(default_dfinit_log_dir(), expected);
+    }
+
+    #[test]
+    fn test_container_runtime_default_paths() {
+        assert_eq!(
+            default_container_runtime_containerd_config_path(),
+            Path::new("/etc/containerd/config.toml")
+        );
+        assert_eq!(
+            default_container_runtime_docker_config_path(),
+            Path::new("/etc/docker/daemon.json")
+        );
+        assert_eq!(
+            default_container_runtime_crio_config_path(),
+            Path::new("/etc/containers/registries.conf")
+        );
+        assert_eq!(
+            default_container_runtime_podman_config_path(),
+            Path::new("/etc/containers/registries.conf")
+        );
+    }
+
+    #[test]
+    fn test_default_unqualified_search_registries() {
+        let crio_registries = default_container_runtime_crio_unqualified_search_registries();
+        assert_eq!(
+            crio_registries,
+            vec![
+                "registry.fedoraproject.org",
+                "registry.access.redhat.com",
+                "docker.io"
+            ]
+        );
+
+        let podman_registries = default_container_runtime_podman_unqualified_search_registries();
+        assert_eq!(
+            podman_registries,
+            vec![
+                "registry.fedoraproject.org",
+                "registry.access.redhat.com",
+                "docker.io"
+            ]
+        );
+    }
 
     #[test]
     fn serialize_container_runtime() {
@@ -412,4 +529,43 @@ containerRuntime:
             panic!("failed to deserialize");
         }
     }
+
+    #[test]
+    fn deserialize_container_runtime_podman_correctly() {
+        let raw_data = r#"
+            proxy: 
+                addr: "hello"
+            containerRuntime:
+                podman:
+                    configPath: "test_path"
+                    unqualifiedSearchRegistries:
+                        - "reg1"
+                        - "reg2"
+                    registries:
+                        - prefix: "prefix1"
+                          location: "location1"
+                        - prefix: "prefix2"
+                          location: "location2"
+        "#;
+        let cfg: Config = serde_yaml::from_str(raw_data).expect("failed to deserialize");
+        if let Some(ContainerRuntimeConfig::Podman(c)) = cfg.container_runtime.config {
+            assert_eq!(PathBuf::from("test_path"), c.config_path);
+            assert_eq!(vec!["reg1", "reg2"], c.unqualified_search_registries);
+            assert_eq!(
+                vec![
+                    PodmanRegistry {
+                        location: "location1".to_string(),
+                        prefix: "prefix1".to_string()
+                    },
+                    PodmanRegistry {
+                        location: "location2".to_string(),
+                        prefix: "prefix2".to_string()
+                    },
+                ],
+                c.registries
+            );
+        } else {
+            panic!("failed to deserialize");
+        }
+    }
 }

dragonfly-client-config/src/dfstore.rs

@@ -1,25 +0,0 @@
-/*
- *     Copyright 2024 The Dragonfly Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use std::path::PathBuf;
-
-/// NAME is the name of dfstore.
-pub const NAME: &str = "dfstore";
-
-/// default_dfstore_log_dir is the default log directory for dfstore.
-pub fn default_dfstore_log_dir() -> PathBuf {
-    crate::default_log_dir().join(NAME)
-}

dragonfly-client-config/src/lib.rs

@@ -15,14 +15,12 @@
  */
 
 use clap::{Arg, Command};
-use lazy_static::lazy_static;
 use std::path::PathBuf;
 
 pub mod dfcache;
 pub mod dfdaemon;
 pub mod dfget;
 pub mod dfinit;
-pub mod dfstore;
 
 /// SERVICE_NAME is the name of the service.
 pub const SERVICE_NAME: &str = "dragonfly";
@@ -42,17 +40,21 @@ pub const BUILD_PLATFORM: &str = env!("BUILD_PLATFORM");
 // BUILD_TIMESTAMP is the timestamp of the build.
 pub const BUILD_TIMESTAMP: &str = env!("BUILD_TIMESTAMP");
 
-lazy_static! {
-    /// GIT_COMMIT_SHORT_HASH is the short git commit hash of the package.
-    pub static ref GIT_COMMIT_SHORT_HASH: &'static str = {
-        option_env!("GIT_COMMIT_SHORT_HASH").unwrap_or("unknown")
-    };
+/// GIT_COMMIT_SHORT_HASH is the short git commit hash of the package.
+pub const GIT_COMMIT_SHORT_HASH: &str = {
+    match option_env!("GIT_COMMIT_SHORT_HASH") {
+        Some(hash) => hash,
+        None => "unknown",
+    }
+};
 
-    /// GIT_COMMIT_DATE is the git commit date of the package.
-    pub static ref GIT_COMMIT_DATE: &'static str = {
-        option_env!("GIT_COMMIT_DATE").unwrap_or("unknown")
-    };
-}
+/// GIT_COMMIT_DATE is the git commit date of the package.
+pub const GIT_COMMIT_DATE: &str = {
+    match option_env!("GIT_COMMIT_DATE") {
+        Some(hash) => hash,
+        None => "unknown",
+    }
+};
 
 /// default_root_dir is the default root directory for client.
 pub fn default_root_dir() -> PathBuf {
@@ -102,7 +104,7 @@ pub fn default_lock_dir() -> PathBuf {
 /// default_plugin_dir is the default plugin directory for client.
 pub fn default_plugin_dir() -> PathBuf {
     #[cfg(target_os = "linux")]
-    return PathBuf::from("/var/lib/dragonfly/plugins/");
+    return PathBuf::from("/usr/local/lib/dragonfly/plugins/");
 
     #[cfg(target_os = "macos")]
     return home::home_dir().unwrap().join(".dragonfly").join("plugins");
@@ -136,8 +138,8 @@ impl clap::builder::TypedValueParser for VersionValueParser {
                 "{} {} ({}, {})",
                 cmd.get_name(),
                 cmd.get_version().unwrap_or("unknown"),
-                *GIT_COMMIT_SHORT_HASH,
-                *GIT_COMMIT_DATE,
+                GIT_COMMIT_SHORT_HASH,
+                GIT_COMMIT_DATE,
             );
 
             std::process::exit(0);
@@ -146,3 +148,20 @@ impl clap::builder::TypedValueParser for VersionValueParser {
         Ok(false)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::{builder::TypedValueParser, Command};
+    use std::ffi::OsStr;
+
+    #[test]
+    fn version_value_parser_references_non_real_values() {
+        let parser = VersionValueParser;
+        let cmd = Command::new("test_app");
+        let value = OsStr::new("false");
+        let result = parser.parse_ref(&cmd, None, value);
+        assert!(result.is_ok());
+        assert!(!result.unwrap());
+    }
+}

dragonfly-client-core/Cargo.toml

@@ -11,8 +11,10 @@ edition.workspace = true
 
 [dependencies]
 reqwest.workspace = true
+reqwest-middleware.workspace = true
 thiserror.workspace = true
 tonic.workspace = true
+tonic-reflection.workspace = true
 tokio.workspace = true
 tokio-stream.workspace = true
 hyper.workspace = true
@@ -20,4 +22,3 @@ hyper-util.workspace = true
 opendal.workspace = true
 url.workspace = true
 headers.workspace = true
-libloading = "0.8.5"

dragonfly-client-core/src/error/errors.rs

@@ -171,10 +171,10 @@ pub struct BackendError {
     pub header: Option<reqwest::header::HeaderMap>,
 }
 
-/// DownloadFromRemotePeerFailed is the error when the download from remote peer is failed.
+/// DownloadFromParentFailed is the error when the download from parent is failed.
 #[derive(Debug, thiserror::Error)]
-#[error("download piece {piece_number} from remote peer {parent_id} failed")]
-pub struct DownloadFromRemotePeerFailed {
+#[error("download piece {piece_number} from parent {parent_id} failed")]
+pub struct DownloadFromParentFailed {
     /// piece_number is the number of the piece.
     pub piece_number: u32,
 

dragonfly-client-core/src/error/mod.rs

@@ -21,7 +21,7 @@ pub use errors::ErrorType;
 pub use errors::ExternalError;
 
 pub use errors::OrErr;
-pub use errors::{BackendError, DownloadFromRemotePeerFailed};
+pub use errors::{BackendError, DownloadFromParentFailed};
 
 /// DFError is the error for dragonfly.
 #[derive(thiserror::Error, Debug)]
@@ -42,6 +42,10 @@ pub enum DFError {
     #[error{"hashring {0} is failed"}]
     HashRing(String),
 
+    /// NoSpace is the error when there is no space left on device.
+    #[error("no space left on device: {0}")]
+    NoSpace(String),
+
     /// HostNotFound is the error when the host is not found.
     #[error{"host {0} not found"}]
     HostNotFound(String),
@@ -58,6 +62,10 @@ pub enum DFError {
     #[error{"piece {0} state is failed"}]
     PieceStateIsFailed(String),
 
+    /// DownloadPieceFinished is the error when the download piece finished timeout.
+    #[error{"download piece {0} finished timeout"}]
+    DownloadPieceFinished(String),
+
     /// WaitForPieceFinishedTimeout is the error when the wait for piece finished timeout.
     #[error{"wait for piece {0} finished timeout"}]
     WaitForPieceFinishedTimeout(String),
@@ -70,9 +78,9 @@ pub enum DFError {
     #[error{"available schedulers not found"}]
     AvailableSchedulersNotFound,
 
-    /// DownloadFromRemotePeerFailed is the error when the download from remote peer is failed.
+    /// DownloadFromParentFailed is the error when the download from parent is failed.
     #[error(transparent)]
-    DownloadFromRemotePeerFailed(DownloadFromRemotePeerFailed),
+    DownloadFromParentFailed(DownloadFromParentFailed),
 
     /// ColumnFamilyNotFound is the error when the column family is not found.
     #[error{"column family {0} not found"}]
@@ -126,6 +134,11 @@ pub enum DFError {
     #[error("invalid parameter")]
     InvalidParameter,
 
+    /// Infallible is the error for infallible.
+    #[error(transparent)]
+    Infallible(#[from] std::convert::Infallible),
+
+    /// Utf8 is the error for utf8.
     #[error(transparent)]
     Utf8(#[from] std::str::Utf8Error),
 
@@ -153,6 +166,10 @@ pub enum DFError {
     #[error(transparent)]
     TonicTransportError(#[from] tonic::transport::Error),
 
+    /// TonicReflectionServerError is the error for tonic reflection server.
+    #[error(transparent)]
+    TonicReflectionServerError(#[from] tonic_reflection::server::Error),
+
     /// TonicStreamElapsed is the error for tonic stream elapsed.
     #[error(transparent)]
     TokioStreamElapsed(#[from] tokio_stream::Elapsed),
@@ -169,6 +186,10 @@ pub enum DFError {
     #[error(transparent)]
     ReqwestError(#[from] reqwest::Error),
 
+    /// ReqwestMiddlewareError is the error for reqwest middleware.
+    #[error(transparent)]
+    ReqwestMiddlewareError(#[from] reqwest_middleware::Error),
+
     /// OpenDALError is the error for opendal.
     #[error(transparent)]
     OpenDALError(#[from] opendal::Error),
@@ -179,7 +200,7 @@ pub enum DFError {
 
     /// BackendError is the error for backend.
     #[error(transparent)]
-    BackendError(BackendError),
+    BackendError(Box<BackendError>),
 
     /// HyperUtilClientLegacyError is the error for hyper util client legacy.
     #[error(transparent)]

dragonfly-client-init/Cargo.toml

@@ -23,5 +23,6 @@ tokio.workspace = true
 anyhow.workspace = true
 tracing.workspace = true
 toml_edit.workspace = true
-toml.workspace = true
 url.workspace = true
+tempfile.workspace = true
+serde_json.workspace = true

dragonfly-client-init/src/bin/main.rs

@@ -64,12 +64,8 @@ struct Args {
     )]
     log_max_files: usize,
 
-    #[arg(
-        long = "verbose",
-        default_value_t = false,
-        help = "Specify whether to print log"
-    )]
-    verbose: bool,
+    #[arg(long, default_value_t = false, help = "Specify whether to print log")]
+    console: bool,
 
     #[arg(
         short = 'V',
@@ -94,22 +90,23 @@ async fn main() -> Result<(), anyhow::Error> {
         args.log_level,
         args.log_max_files,
         None,
+        None,
+        None,
+        None,
+        None,
         false,
-        false,
-        args.verbose,
+        args.console,
     );
 
     // Load config.
-    let config = dfinit::Config::load(&args.config).map_err(|err| {
+    let config = dfinit::Config::load(&args.config).inspect_err(|err| {
         error!("failed to load config: {}", err);
-        err
     })?;
 
     // Handle features of the container runtime.
     let container_runtime = container_runtime::ContainerRuntime::new(&config);
-    container_runtime.run().await.map_err(|err| {
+    container_runtime.run().await.inspect_err(|err| {
         error!("failed to run container runtime: {}", err);
-        err
     })?;
 
     Ok(())

dragonfly-client-init/src/container_runtime/containerd.rs

@@ -66,6 +66,9 @@ impl Containerd {
             .and_then(|config_path| config_path.as_str())
             .filter(|config_path| !config_path.is_empty())
         {
+            // Rebind config_path to the first entry if multiple paths are present
+            let config_path = config_path.split(':').next().unwrap_or(config_path);
+
             info!(
                 "containerd supports config_path mode, config_path: {}",
                 config_path.to_string()
@@ -176,3 +179,74 @@ impl Containerd {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+    use tokio::fs;
+
+    #[tokio::test]
+    async fn test_containerd_config_with_existing_config_path() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+        let certs_dir = temp_dir.path().join("certs.d");
+        let certs_dir_str = certs_dir.to_str().unwrap();
+
+        // Create initial containerd config with config_path
+        let initial_config = format!(
+            r#"
+[plugins]
+  [plugins."io.containerd.grpc.v1.cri"]
+    [plugins."io.containerd.grpc.v1.cri".registry]
+      config_path = "{}"
+"#,
+            certs_dir_str
+        );
+        fs::write(&config_path, initial_config).await.unwrap();
+
+        // Create Containerd instance
+        let containerd = Containerd::new(
+            dfinit::Containerd {
+                config_path: config_path.clone(),
+                registries: vec![ContainerdRegistry {
+                    host_namespace: "docker.io".into(),
+                    server_addr: "https://registry.example.com".into(),
+                    skip_verify: Some(true),
+                    ca: Some(vec!["test-ca-cert".into()]),
+                    capabilities: vec!["pull".into(), "resolve".into()],
+                }],
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:65001".into(),
+            },
+        );
+
+        // Run containerd configuration
+        let result = containerd.run().await;
+        if let Err(e) = &result {
+            println!("Error: {:?}", e);
+            if let Ok(contents) = fs::read_to_string(&config_path).await {
+                println!("Current config file contents:\n{}", contents);
+            }
+        }
+        assert!(result.is_ok());
+
+        // Verify the hosts.toml file content
+        let hosts_file_path = certs_dir.join("docker.io").join("hosts.toml");
+        let contents = fs::read_to_string(&hosts_file_path).await.unwrap();
+
+        let expected_contents = r#"server = "https://registry.example.com"
+
+[host."http://127.0.0.1:65001"]
+capabilities = ["pull", "resolve"]
+skip_verify = true
+ca = ["test-ca-cert"]
+
+[host."http://127.0.0.1:65001".header]
+X-Dragonfly-Registry = "https://registry.example.com"
+"#;
+
+        assert_eq!(contents.trim(), expected_contents.trim());
+    }
+}

dragonfly-client-init/src/container_runtime/crio.rs

@@ -111,3 +111,54 @@ impl CRIO {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_crio_config() {
+        use tempfile::NamedTempFile;
+
+        let crio_config_file = NamedTempFile::new().unwrap();
+
+        let crio = CRIO::new(
+            dfinit::CRIO {
+                config_path: crio_config_file.path().to_path_buf(),
+                registries: vec![dfinit::CRIORegistry {
+                    prefix: "registry.example.com".into(),
+                    location: "registry.example.com".into(),
+                }],
+                unqualified_search_registries: vec!["registry.example.com".into()],
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:65001".into(),
+            },
+        );
+        let result = crio.run().await;
+
+        assert!(result.is_ok());
+
+        // get the contents of the file
+        let contents = fs::read_to_string(crio_config_file.path().to_path_buf())
+            .await
+            .unwrap();
+        let expected_contents = r#"unqualified-search-registries = ["registry.example.com"]
+
+[[registry]]
+prefix = "registry.example.com"
+location = "registry.example.com"
+
+[[registry.mirror]]
+insecure = true
+location = "127.0.0.1:65001"
+"#;
+        // assert that the contents of the file are as expected
+        assert_eq!(contents, expected_contents);
+
+        // clean up
+        fs::remove_file(crio_config_file.path().to_path_buf())
+            .await
+            .unwrap();
+    }
+}

dragonfly-client-init/src/container_runtime/docker.rs

@@ -15,8 +15,14 @@
  */
 
 use dragonfly_client_config::dfinit;
-use dragonfly_client_core::{Error, Result};
+use dragonfly_client_core::{
+    error::{ErrorType, OrErr},
+    Error, Result,
+};
+use serde_json::{json, Value};
+use tokio::{self, fs};
 use tracing::{info, instrument};
+use url::Url;
 
 /// Docker represents the docker runtime manager.
 #[derive(Debug, Clone)]
@@ -40,8 +46,6 @@ impl Docker {
         }
     }
 
-    /// TODO: Implement the run method for Docker.
-    ///
     /// run runs the docker runtime to initialize
     /// runtime environment for the dfdaemon.
     #[instrument(skip_all)]
@@ -50,6 +54,200 @@ impl Docker {
             "docker feature is enabled, proxy_addr: {}, config_path: {:?}",
             self.proxy_config.addr, self.config.config_path,
         );
-        Err(Error::Unimplemented)
+
+        // Parse proxy address to get host and port.
+        let proxy_url = Url::parse(&self.proxy_config.addr).or_err(ErrorType::ParseError)?;
+        let proxy_host = proxy_url
+            .host_str()
+            .ok_or(Error::Unknown("host not found".to_string()))?;
+        let proxy_port = proxy_url
+            .port_or_known_default()
+            .ok_or(Error::Unknown("port not found".to_string()))?;
+        let proxy_location = format!("{}:{}", proxy_host, proxy_port);
+
+        // Prepare proxies configuration.
+        let mut proxies_map = serde_json::Map::new();
+        proxies_map.insert(
+            "http-proxy".to_string(),
+            json!(format!("http://{}", proxy_location)),
+        );
+        proxies_map.insert(
+            "https-proxy".to_string(),
+            json!(format!("http://{}", proxy_location)),
+        );
+
+        let config_path = &self.config.config_path;
+        let mut docker_config: serde_json::Map<String, Value> = if config_path.exists() {
+            let contents = fs::read_to_string(config_path).await?;
+            if contents.trim().is_empty() {
+                serde_json::Map::new()
+            } else {
+                serde_json::from_str(&contents).or_err(ErrorType::ParseError)?
+            }
+        } else {
+            serde_json::Map::new()
+        };
+
+        // Insert or update proxies configuration.
+        docker_config.insert("proxies".to_string(), Value::Object(proxies_map));
+
+        // Create config directory if it doesn't exist.
+        let config_dir = config_path
+            .parent()
+            .ok_or(Error::Unknown("invalid config path".to_string()))?;
+        fs::create_dir_all(config_dir).await?;
+
+        // Write configuration to file.
+        fs::write(
+            config_path,
+            serde_json::to_string_pretty(&Value::Object(docker_config))
+                .or_err(ErrorType::SerializeError)?,
+        )
+        .await?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::NamedTempFile;
+    use tokio::fs;
+
+    #[tokio::test]
+    async fn test_docker_config_empty() {
+        let docker_config_file = NamedTempFile::new().unwrap();
+        let docker = Docker::new(
+            dfinit::Docker {
+                config_path: docker_config_file.path().to_path_buf(),
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:5000".into(),
+            },
+        );
+
+        let result = docker.run().await;
+        println!("{:?}", result);
+        assert!(result.is_ok());
+
+        // Read and verify configuration.
+        let contents = fs::read_to_string(docker_config_file.path()).await.unwrap();
+        let config: serde_json::Value = serde_json::from_str(&contents).unwrap();
+
+        // Verify proxies configuration.
+        assert_eq!(config["proxies"]["http-proxy"], "http://127.0.0.1:5000");
+        assert_eq!(config["proxies"]["https-proxy"], "http://127.0.0.1:5000");
+    }
+
+    #[tokio::test]
+    async fn test_docker_config_existing() {
+        let docker_config_file = NamedTempFile::new().unwrap();
+        let initial_config = r#"
+        {
+            "log-driver": "json-file",
+            "experimental": true
+        }
+        "#;
+        fs::write(docker_config_file.path(), initial_config)
+            .await
+            .unwrap();
+
+        let docker = Docker::new(
+            dfinit::Docker {
+                config_path: docker_config_file.path().to_path_buf(),
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:5000".into(),
+            },
+        );
+
+        let result = docker.run().await;
+        assert!(result.is_ok());
+
+        // Read and verify configuration.
+        let contents = fs::read_to_string(docker_config_file.path()).await.unwrap();
+        let config: serde_json::Value = serde_json::from_str(&contents).unwrap();
+
+        // Verify existing configurations.
+        assert_eq!(config["log-driver"], "json-file");
+        assert_eq!(config["experimental"], true);
+
+        // Verify proxies configuration.
+        assert_eq!(config["proxies"]["http-proxy"], "http://127.0.0.1:5000");
+        assert_eq!(config["proxies"]["https-proxy"], "http://127.0.0.1:5000");
+    }
+
+    #[tokio::test]
+    async fn test_docker_config_invalid_json() {
+        let docker_config_file = NamedTempFile::new().unwrap();
+        let invalid_config = r#"
+        {
+            "log-driver": "json-file",
+            "experimental": true,
+        }
+        "#;
+        fs::write(docker_config_file.path(), invalid_config)
+            .await
+            .unwrap();
+
+        let docker = Docker::new(
+            dfinit::Docker {
+                config_path: docker_config_file.path().to_path_buf(),
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:5000".into(),
+            },
+        );
+
+        let result = docker.run().await;
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                format!("{}", e),
+                "ParseError cause: trailing comma at line 5 column 9"
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_docker_config_proxies_existing() {
+        let docker_config_file = NamedTempFile::new().unwrap();
+        let existing_proxies = r#"
+        {
+            "proxies": {
+                "http-proxy": "http://old-proxy:3128",
+                "https-proxy": "https://old-proxy:3129",
+                "no-proxy": "old-no-proxy"
+            },
+            "log-driver": "json-file"
+        }
+        "#;
+        fs::write(docker_config_file.path(), existing_proxies)
+            .await
+            .unwrap();
+
+        let docker = Docker::new(
+            dfinit::Docker {
+                config_path: docker_config_file.path().to_path_buf(),
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:5000".into(),
+            },
+        );
+
+        let result = docker.run().await;
+        assert!(result.is_ok());
+
+        // Read and verify configuration.
+        let contents = fs::read_to_string(docker_config_file.path()).await.unwrap();
+        let config: serde_json::Value = serde_json::from_str(&contents).unwrap();
+
+        // Verify existing configurations.
+        assert_eq!(config["log-driver"], "json-file");
+
+        // Verify proxies configuration.
+        assert_eq!(config["proxies"]["http-proxy"], "http://127.0.0.1:5000");
+        assert_eq!(config["proxies"]["https-proxy"], "http://127.0.0.1:5000");
     }
 }

dragonfly-client-init/src/container_runtime/mod.rs

@@ -21,6 +21,7 @@ use tracing::{info, instrument};
 pub mod containerd;
 pub mod crio;
 pub mod docker;
+pub mod podman;
 
 /// Engine represents config of the container runtime engine.
 #[derive(Debug, Clone)]
@@ -28,6 +29,7 @@ enum Engine {
     Containerd(containerd::Containerd),
     Docker(docker::Docker),
     Crio(crio::CRIO),
+    Podman(podman::Podman),
 }
 
 /// ContainerRuntime represents the container runtime manager.
@@ -48,13 +50,12 @@ impl ContainerRuntime {
     /// run runs the container runtime to initialize runtime environment for the dfdaemon.
     #[instrument(skip_all)]
     pub async fn run(&self) -> Result<()> {
-        // If containerd is enabled, override the default containerd
-        // configuration.
         match &self.engine {
             None => Ok(()),
             Some(Engine::Containerd(containerd)) => containerd.run().await,
             Some(Engine::Docker(docker)) => docker.run().await,
             Some(Engine::Crio(crio)) => crio.run().await,
+            Some(Engine::Podman(podman)) => podman.run().await,
         }
     }
 
@@ -72,6 +73,9 @@ impl ContainerRuntime {
                 ContainerRuntimeConfig::CRIO(crio) => {
                     Engine::Crio(crio::CRIO::new(crio.clone(), config.proxy.clone()))
                 }
+                ContainerRuntimeConfig::Podman(podman) => {
+                    Engine::Podman(podman::Podman::new(podman.clone(), config.proxy.clone()))
+                }
             };
 
             info!("container runtime engine is {:?}", engine);

dragonfly-client-init/src/container_runtime/podman.rs

@@ -0,0 +1,163 @@
+/*
+ *     Copyright 2024 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use dragonfly_client_config::dfinit;
+use dragonfly_client_core::{
+    error::{ErrorType, OrErr},
+    Error, Result,
+};
+use tokio::{self, fs};
+use toml_edit::{value, Array, ArrayOfTables, Item, Table, Value};
+use tracing::{info, instrument};
+use url::Url;
+
+/// Podman represents the podman runtime manager.
+#[derive(Debug, Clone)]
+pub struct Podman {
+    /// config is the configuration for initializing
+    /// runtime environment for the dfdaemon.
+    config: dfinit::Podman,
+
+    /// proxy_config is the configuration for the dfdaemon's proxy server.
+    proxy_config: dfinit::Proxy,
+}
+
+/// Podman implements the podman runtime manager.
+impl Podman {
+    /// new creates a new podman runtime manager.
+    #[instrument(skip_all)]
+    pub fn new(config: dfinit::Podman, proxy_config: dfinit::Proxy) -> Self {
+        Self {
+            config,
+            proxy_config,
+        }
+    }
+
+    /// run runs the podman runtime to initialize
+    /// runtime environment for the dfdaemon.
+    #[instrument(skip_all)]
+    pub async fn run(&self) -> Result<()> {
+        let mut registries_config_table = toml_edit::DocumentMut::new();
+        registries_config_table.set_implicit(true);
+
+        // Add unqualified-search-registries to registries config.
+        let mut unqualified_search_registries = Array::default();
+        for unqualified_search_registry in self.config.unqualified_search_registries.clone() {
+            unqualified_search_registries.push(Value::from(unqualified_search_registry));
+        }
+        registries_config_table.insert(
+            "unqualified-search-registries",
+            value(unqualified_search_registries),
+        );
+
+        // Parse proxy address to get host and port.
+        let proxy_url =
+            Url::parse(self.proxy_config.addr.as_str()).or_err(ErrorType::ParseError)?;
+        let proxy_host = proxy_url
+            .host_str()
+            .ok_or(Error::Unknown("host not found".to_string()))?;
+        let proxy_port = proxy_url
+            .port_or_known_default()
+            .ok_or(Error::Unknown("port not found".to_string()))?;
+        let proxy_location = format!("{}:{}", proxy_host, proxy_port);
+
+        // Add registries to the registries config.
+        let mut registries_table = ArrayOfTables::new();
+        for registry in self.config.registries.clone() {
+            info!("add registry: {:?}", registry);
+            let mut registry_mirror_table = Table::new();
+            registry_mirror_table.set_implicit(true);
+            registry_mirror_table.insert("insecure", value(true));
+            registry_mirror_table.insert("location", value(proxy_location.as_str()));
+
+            let mut registry_mirrors_table = ArrayOfTables::new();
+            registry_mirrors_table.push(registry_mirror_table);
+
+            let mut registry_table = Table::new();
+            registry_table.set_implicit(true);
+            registry_table.insert("prefix", value(registry.prefix));
+            registry_table.insert("location", value(registry.location));
+            registry_table.insert("mirror", Item::ArrayOfTables(registry_mirrors_table));
+
+            registries_table.push(registry_table);
+        }
+        registries_config_table.insert("registry", Item::ArrayOfTables(registries_table));
+
+        let registries_config_dir = self
+            .config
+            .config_path
+            .parent()
+            .ok_or(Error::Unknown("invalid config path".to_string()))?;
+        fs::create_dir_all(registries_config_dir.as_os_str()).await?;
+        fs::write(
+            self.config.config_path.as_os_str(),
+            registries_config_table.to_string().as_bytes(),
+        )
+        .await?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_podman_config() {
+        use tempfile::NamedTempFile;
+
+        let podman_config_file = NamedTempFile::new().unwrap();
+        let podman = Podman::new(
+            dfinit::Podman {
+                config_path: podman_config_file.path().to_path_buf(),
+                registries: vec![dfinit::PodmanRegistry {
+                    prefix: "registry.example.com".into(),
+                    location: "registry.example.com".into(),
+                }],
+                unqualified_search_registries: vec!["registry.example.com".into()],
+            },
+            dfinit::Proxy {
+                addr: "http://127.0.0.1:5000".into(),
+            },
+        );
+        let result = podman.run().await;
+
+        assert!(result.is_ok());
+
+        // get the contents of the file
+        let contents = fs::read_to_string(podman_config_file.path().to_path_buf())
+            .await
+            .unwrap();
+        let expected_contents = r#"unqualified-search-registries = ["registry.example.com"]
+
+[[registry]]
+prefix = "registry.example.com"
+location = "registry.example.com"
+
+[[registry.mirror]]
+insecure = true
+location = "127.0.0.1:5000"
+"#;
+        // assert that the contents of the file are as expected
+        assert_eq!(contents, expected_contents);
+
+        // clean up
+        fs::remove_file(podman_config_file.path().to_path_buf())
+            .await
+            .unwrap();
+    }
+}

dragonfly-client-storage/Cargo.toml

@@ -22,12 +22,22 @@ tracing.workspace = true
 prost-wkt-types.workspace = true
 tokio.workspace = true
 tokio-util.workspace = true
-sha2.workspace = true
 crc32fast.workspace = true
-base16ct.workspace = true
-num_cpus = "1.0"
+fs2.workspace = true
+bytes.workspace = true
+bytesize.workspace = true
+num_cpus = "1.17"
 bincode = "1.3.3"
-rayon = "1.10.0"
+walkdir = "2.5.0"
 
 [dev-dependencies]
-tempdir = "0.3"
+tempfile.workspace = true
+criterion = "0.5"
+
+[[bench]]
+name = "cache"
+harness = false
+
+[[bench]]
+name = "lru_cache"
+harness = false

dragonfly-client-storage/benches/cache.rs

@@ -0,0 +1,468 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use bytes::Bytes;
+use bytesize::ByteSize;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use dragonfly_client_config::dfdaemon::{Config, Storage};
+use dragonfly_client_storage::{cache::Cache, metadata::Piece};
+use std::sync::Arc;
+use tokio::io::AsyncReadExt;
+use tokio::runtime::Runtime;
+
+// Number of pieces to write/read in each benchmark.
+const PIECE_COUNT: usize = 100;
+
+fn create_config(capacity: ByteSize) -> Config {
+    Config {
+        storage: Storage {
+            cache_capacity: capacity,
+            ..Default::default()
+        },
+        ..Default::default()
+    }
+}
+
+fn create_piece(length: u64) -> Piece {
+    Piece {
+        number: 0,
+        offset: 0,
+        length,
+        digest: String::new(),
+        parent_id: None,
+        uploading_count: 0,
+        uploaded_count: 0,
+        updated_at: chrono::Utc::now().naive_utc(),
+        created_at: chrono::Utc::now().naive_utc(),
+        finished_at: None,
+    }
+}
+
+pub fn put_task(c: &mut Criterion) {
+    let rt: Runtime = Runtime::new().unwrap();
+    let mut group = c.benchmark_group("Put Task");
+
+    group.bench_with_input(
+        BenchmarkId::new("Put Task", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) }),
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Put Task", "100MB"),
+        &ByteSize::mb(100),
+        |b, size| {
+            b.iter_batched(
+                || rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) }),
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Put Task", "1GB"),
+        &ByteSize::gb(1),
+        |b, size| {
+            b.iter_batched(
+                || rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) }),
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn delete_task(c: &mut Criterion) {
+    let rt: Runtime = Runtime::new().unwrap();
+    let mut group = c.benchmark_group("Delete Task");
+
+    group.bench_with_input(
+        BenchmarkId::new("Delete Task", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache =
+                        rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) });
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                    cache
+                },
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.delete_task("task").await.unwrap();
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Delete Task", "100MB"),
+        &ByteSize::mb(100),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache =
+                        rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) });
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                    cache
+                },
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.delete_task("task").await.unwrap();
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Delete Task", "1GB"),
+        &ByteSize::gb(1),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache =
+                        rt.block_on(async { Cache::new(Arc::new(create_config(ByteSize::gb(2)))) });
+                    rt.block_on(async {
+                        cache.put_task("task", black_box(size.as_u64())).await;
+                    });
+                    cache
+                },
+                |mut cache| {
+                    rt.block_on(async {
+                        cache.delete_task("task").await.unwrap();
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn write_piece(c: &mut Criterion) {
+    let rt = Runtime::new().unwrap();
+    let mut group = c.benchmark_group("Write Piece");
+
+    group.bench_with_input(
+        BenchmarkId::new("Write Piece", "4MB"),
+        &vec![1u8; ByteSize::mb(4).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(4) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(4) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Write Piece", "10MB"),
+        &vec![1u8; ByteSize::mb(10).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(10) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(10) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Write Piece", "16MB"),
+        &vec![1u8; ByteSize::mb(16).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(16) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(16) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn read_piece(c: &mut Criterion) {
+    let rt = Runtime::new().unwrap();
+    let mut group = c.benchmark_group("Read Piece");
+
+    group.bench_with_input(
+        BenchmarkId::new("Read Piece", "4MB"),
+        &vec![1u8; ByteSize::mb(4).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(4) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(4) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            let mut reader = cache
+                                .read_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    create_piece(data.len() as u64),
+                                    None,
+                                )
+                                .await
+                                .unwrap();
+                            let mut buffer = Vec::new();
+                            reader.read_to_end(&mut buffer).await.unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Read Piece", "10MB"),
+        &vec![1u8; ByteSize::mb(10).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(10) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(10) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            let mut reader = cache
+                                .read_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    create_piece(data.len() as u64),
+                                    None,
+                                )
+                                .await
+                                .unwrap();
+                            let mut buffer = Vec::new();
+                            reader.read_to_end(&mut buffer).await.unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Read Piece", "16MB"),
+        &vec![1u8; ByteSize::mb(16).as_u64() as usize],
+        |b, data| {
+            b.iter_batched(
+                || {
+                    let mut cache = rt.block_on(async {
+                        Cache::new(Arc::new(create_config(
+                            ByteSize::mb(16) * PIECE_COUNT as u64,
+                        )))
+                    });
+
+                    rt.block_on(async {
+                        cache
+                            .put_task("task", (ByteSize::mb(16) * PIECE_COUNT as u64).as_u64())
+                            .await;
+                        for i in 0..PIECE_COUNT {
+                            cache
+                                .write_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    Bytes::copy_from_slice(data),
+                                )
+                                .await
+                                .unwrap();
+                        }
+                    });
+                    cache
+                },
+                |cache| {
+                    rt.block_on(async {
+                        for i in 0..PIECE_COUNT {
+                            let mut reader = cache
+                                .read_piece(
+                                    "task",
+                                    &format!("piece{}", i),
+                                    create_piece(data.len() as u64),
+                                    None,
+                                )
+                                .await
+                                .unwrap();
+                            let mut buffer = Vec::new();
+                            reader.read_to_end(&mut buffer).await.unwrap();
+                        }
+                    });
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+criterion_group!(benches, put_task, delete_task, write_piece, read_piece,);
+
+criterion_main!(benches);

dragonfly-client-storage/benches/lru_cache.rs

@@ -0,0 +1,448 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use bytesize::ByteSize;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use dragonfly_client_storage::cache::lru_cache::LruCache;
+
+// Number of operations to perform in each benchmark
+const OPERATION_COUNT: usize = 1000;
+
+pub fn lru_cache_put(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Put");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Put", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || LruCache::new(OPERATION_COUNT),
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Put", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || LruCache::new(OPERATION_COUNT),
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Put", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || LruCache::new(OPERATION_COUNT),
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn lru_cache_get(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Get");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Get", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.get(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Get", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.get(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Get", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.get(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn lru_cache_peek(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Peek");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Peek", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.peek(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Peek", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.peek(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Peek", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.peek(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn lru_cache_contains(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Contains");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Contains", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.contains(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Contains", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.contains(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Contains", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.contains(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn lru_cache_pop(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Pop");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.pop(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.pop(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    for i in 0..OPERATION_COUNT {
+                        black_box(cache.pop(&format!("key{}", i)));
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+pub fn lru_cache_pop_lru(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Lru Cache Pop Lru");
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop Lru", "4MB"),
+        &ByteSize::mb(4),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    while !cache.is_empty() {
+                        black_box(cache.pop_lru());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop Lru", "10MB"),
+        &ByteSize::mb(10),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    while !cache.is_empty() {
+                        black_box(cache.pop_lru());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.bench_with_input(
+        BenchmarkId::new("Lru Cache Pop Lru", "16MB"),
+        &ByteSize::mb(16),
+        |b, size| {
+            b.iter_batched(
+                || {
+                    let mut cache = LruCache::new(OPERATION_COUNT);
+                    for i in 0..OPERATION_COUNT {
+                        cache.put(format!("key{}", i), size.as_u64());
+                    }
+                    cache
+                },
+                |mut cache| {
+                    while !cache.is_empty() {
+                        black_box(cache.pop_lru());
+                    }
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        },
+    );
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    lru_cache_put,
+    lru_cache_get,
+    lru_cache_peek,
+    lru_cache_contains,
+    lru_cache_pop,
+    lru_cache_pop_lru,
+);
+
+criterion_main!(benches);

dragonfly-client-storage/src/cache/lru_cache.rs

@@ -0,0 +1,509 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use std::{borrow::Borrow, collections::HashMap, hash::Hash, hash::Hasher};
+
+/// KeyRef is a reference to the key.
+#[derive(Debug, Clone, Copy)]
+struct KeyRef<K> {
+    k: *const K,
+}
+
+/// KeyRef implements Hash for KeyRef.
+impl<K: Hash> Hash for KeyRef<K> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        unsafe {
+            let key = &*self.k;
+            key.hash(state)
+        }
+    }
+}
+
+/// KeyRef implements PartialEq for KeyRef.
+impl<K: PartialEq> PartialEq for KeyRef<K> {
+    fn eq(&self, other: &Self) -> bool {
+        unsafe {
+            let key1 = &*self.k;
+            let key2 = &*other.k;
+            key1.eq(key2)
+        }
+    }
+}
+
+/// KeyRef implements Eq for KeyRef.
+impl<K: Eq> Eq for KeyRef<K> {}
+
+/// KeyWrapper is a wrapper for the key.
+#[repr(transparent)]
+struct KeyWrapper<K: ?Sized>(K);
+
+/// KeyWrapper implements reference conversion.
+impl<K: ?Sized> KeyWrapper<K> {
+    /// from_ref creates a new KeyWrapper from a reference to the key.
+    fn from_ref(key: &K) -> &Self {
+        unsafe { &*(key as *const K as *const KeyWrapper<K>) }
+    }
+}
+
+/// KeyWrapper implements Hash for KeyWrapper.
+impl<K: ?Sized + Hash> Hash for KeyWrapper<K> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash(state)
+    }
+}
+
+/// KeyWrapper implements PartialEq for KeyWrapper.
+impl<K: ?Sized + PartialEq> PartialEq for KeyWrapper<K> {
+    #![allow(unknown_lints)]
+    #[allow(clippy::unconditional_recursion)]
+    fn eq(&self, other: &Self) -> bool {
+        self.0.eq(&other.0)
+    }
+}
+
+/// KeyWrapper implements Eq for KeyWrapper.
+impl<K: ?Sized + Eq> Eq for KeyWrapper<K> {}
+
+/// KeyWrapper implements Borrow for KeyWrapper.
+impl<K, Q> Borrow<KeyWrapper<Q>> for KeyRef<K>
+where
+    K: Borrow<Q>,
+    Q: ?Sized,
+{
+    /// borrow borrows the key.
+    fn borrow(&self) -> &KeyWrapper<Q> {
+        unsafe {
+            let key = &*self.k;
+            KeyWrapper::from_ref(key.borrow())
+        }
+    }
+}
+
+/// Entry is a cache entry.
+struct Entry<K, V> {
+    key: K,
+    value: V,
+    prev: Option<*mut Entry<K, V>>,
+    next: Option<*mut Entry<K, V>>,
+}
+
+/// Entry implements Drop for Entry.
+impl<K, V> Entry<K, V> {
+    /// new creates a new Entry.
+    fn new(key: K, value: V) -> Self {
+        Self {
+            key,
+            value,
+            prev: None,
+            next: None,
+        }
+    }
+}
+
+/// LruCache is a least recently used cache.
+pub struct LruCache<K, V> {
+    capacity: usize,
+    map: HashMap<KeyRef<K>, Box<Entry<K, V>>>,
+    head: Option<*mut Entry<K, V>>,
+    tail: Option<*mut Entry<K, V>>,
+    _marker: std::marker::PhantomData<K>,
+}
+
+/// LruCache implements LruCache.
+impl<K: Hash + Eq, V> LruCache<K, V> {
+    /// new creates a new LruCache.
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            capacity,
+            map: HashMap::new(),
+            head: None,
+            tail: None,
+            _marker: std::marker::PhantomData,
+        }
+    }
+
+    /// get gets the value of the key.
+    pub fn get<'a, Q>(&'a mut self, k: &Q) -> Option<&'a V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        if let Some(entry) = self.map.get_mut(KeyWrapper::from_ref(k)) {
+            let entry_ptr: *mut Entry<K, V> = &mut **entry;
+
+            self.detach(entry_ptr);
+            self.attach(entry_ptr);
+            Some(&unsafe { &*entry_ptr }.value)
+        } else {
+            None
+        }
+    }
+
+    /// put puts the key and value into the cache.
+    pub fn put(&mut self, key: K, mut value: V) -> Option<V> {
+        if let Some(existing_entry) = self.map.get_mut(KeyWrapper::from_ref(&key)) {
+            let entry = existing_entry.as_mut();
+            std::mem::swap(&mut entry.value, &mut value);
+
+            let entry_ptr: *mut Entry<K, V> = entry;
+            self.detach(entry_ptr);
+            self.attach(entry_ptr);
+            return Some(value);
+        }
+
+        let mut evicted_value = None;
+        if self.map.len() >= self.capacity {
+            if let Some(tail) = self.tail {
+                self.detach(tail);
+
+                unsafe {
+                    if let Some(entry) = self.map.remove(KeyWrapper::from_ref(&(*tail).key)) {
+                        evicted_value = Some(entry.value);
+                    }
+                }
+            }
+        }
+
+        let new_entry = Box::new(Entry::new(key, value));
+        let key_ptr: *const K = &new_entry.key;
+        let entry_ptr = Box::into_raw(new_entry);
+
+        unsafe {
+            self.attach(entry_ptr);
+            self.map
+                .insert(KeyRef { k: key_ptr }, Box::from_raw(entry_ptr));
+        }
+
+        evicted_value
+    }
+
+    /// detach detaches the entry from the cache.
+    fn detach(&mut self, entry: *mut Entry<K, V>) {
+        unsafe {
+            let prev = (*entry).prev;
+            let next = (*entry).next;
+
+            match prev {
+                Some(prev) => (*prev).next = next,
+                None => self.head = next,
+            }
+
+            match next {
+                Some(next) => (*next).prev = prev,
+                None => self.tail = prev,
+            }
+
+            (*entry).prev = None;
+            (*entry).next = None;
+        }
+    }
+
+    /// attach attaches the entry to the cache.
+    fn attach(&mut self, entry: *mut Entry<K, V>) {
+        match self.head {
+            Some(head) => {
+                unsafe {
+                    (*entry).next = Some(head);
+                    (*head).prev = Some(entry);
+                }
+
+                self.head = Some(entry);
+            }
+            None => {
+                self.head = Some(entry);
+                self.tail = Some(entry);
+            }
+        }
+    }
+
+    /// contains checks whether the key exists in the cache.
+    pub fn contains<Q>(&self, k: &Q) -> bool
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        self.map.contains_key(KeyWrapper::from_ref(k))
+    }
+
+    /// peek peeks the value of the key. It does not move the key to the front of the cache.
+    pub fn peek<'a, Q>(&'a self, k: &Q) -> Option<&'a V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        self.map
+            .get(KeyWrapper::from_ref(k))
+            .map(|entry| &entry.value)
+    }
+
+    /// pop_lru pops the least recently used value from the cache.
+    pub fn pop_lru(&mut self) -> Option<(K, V)> {
+        if self.is_empty() {
+            return None;
+        }
+
+        let tail = self.tail?;
+        self.detach(tail);
+
+        unsafe {
+            self.map
+                .remove(KeyWrapper::from_ref(&(*tail).key))
+                .map(|entry| (entry.key, entry.value))
+        }
+    }
+
+    /// pop removes and returns the value for a given key, if it does not exist, it returns None.
+    pub fn pop<Q>(&mut self, k: &Q) -> Option<(K, V)>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        match self.map.remove(KeyWrapper::from_ref(k)) {
+            None => None,
+            Some(entry) => {
+                let entry_ptr = Box::into_raw(entry);
+                self.detach(entry_ptr);
+
+                unsafe {
+                    let entry = Box::from_raw(entry_ptr);
+                    Some((entry.key, entry.value))
+                }
+            }
+        }
+    }
+
+    /// is_empty checks whether the cache is empty.
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+}
+
+unsafe impl<K: Send, V: Send> Send for LruCache<K, V> {}
+unsafe impl<K: Sync, V: Sync> Sync for LruCache<K, V> {}
+
+impl<K, V> Drop for LruCache<K, V> {
+    fn drop(&mut self) {
+        self.map.clear();
+        self.head = None;
+        self.tail = None;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new() {
+        let test_cases = vec![
+            // Normal capacity.
+            (5, 5),
+            // Minimum meaningful capacity.
+            (1, 1),
+            // Zero capacity.
+            (0, 0),
+            // Maximum capacity.
+            (usize::MAX, usize::MAX),
+        ];
+
+        for (capacity, expected_capacity) in test_cases {
+            let cache: LruCache<String, i32> = LruCache::new(capacity);
+            assert!(cache.is_empty());
+            assert_eq!(cache.capacity, expected_capacity);
+        }
+    }
+
+    #[test]
+    fn test_get() {
+        let mut cache: LruCache<String, i32> = LruCache::new(3);
+        let test_cases = vec![
+            // Initial insertions.
+            ("key1", 1, None),
+            ("key2", 2, None),
+            ("key3", 3, None),
+            // Update existing key.
+            ("key2", 22, Some(2)),
+            // Eviction of oldest key.
+            ("key4", 4, Some(1)),
+        ];
+
+        for (key, value, expected_result) in test_cases {
+            let result = cache.put(key.to_string(), value);
+            assert_eq!(result, expected_result);
+        }
+
+        // Verify final cache state.
+        assert_eq!(cache.get(&"key1".to_string()), None);
+        assert_eq!(cache.get(&"key2".to_string()).copied(), Some(22));
+        assert_eq!(cache.get(&"key3".to_string()).copied(), Some(3));
+        assert_eq!(cache.get(&"key4".to_string()).copied(), Some(4));
+    }
+
+    #[test]
+    fn test_get_after_evction() {
+        let mut cache = LruCache::new(3);
+        assert_eq!(cache.get(&"nonexistent".to_string()), None);
+
+        // Prepare cache with initial values.
+        for (key, value) in [("key1", 1), ("key2", 2), ("key3", 3)] {
+            cache.put(key.to_string(), value);
+        }
+
+        let test_cases = vec![
+            ("key1", Some(1)),
+            ("nonexistent", None),
+            ("key1", Some(1)),
+            ("key3", Some(3)),
+        ];
+
+        for (key, expected_value) in test_cases {
+            assert_eq!(cache.get(&key.to_string()).copied(), expected_value);
+        }
+
+        // Test eviction after getting.
+        cache.put("key4".to_string(), 4);
+        assert_eq!(cache.get(&"key1".to_string()).copied(), Some(1));
+        assert_eq!(cache.get(&"key2".to_string()), None);
+        assert_eq!(cache.get(&"key3".to_string()).copied(), Some(3));
+        assert_eq!(cache.get(&"key4".to_string()).copied(), Some(4));
+    }
+
+    #[test]
+    fn test_put() {
+        let mut cache = LruCache::new(3);
+        let test_cases = vec![
+            // Initial insertions within capacity.
+            ("key1", 1, None),
+            ("key2", 2, None),
+            ("key3", 3, None),
+            // Overflow capacity, should evict oldest.
+            ("key4", 4, Some(1)),
+            ("key5", 5, Some(2)),
+            // Update existing key.
+            ("key4", 44, Some(4)),
+        ];
+
+        for (key, value, expected_result) in test_cases {
+            let result = cache.put(key.to_string(), value);
+            assert_eq!(result, expected_result);
+        }
+
+        // Verify final cache state.
+        assert_eq!(cache.get(&"key1".to_string()), None);
+        assert_eq!(cache.get(&"key2".to_string()), None);
+        assert_eq!(cache.get(&"key3".to_string()).copied(), Some(3));
+        assert_eq!(cache.get(&"key4".to_string()).copied(), Some(44));
+        assert_eq!(cache.get(&"key5".to_string()).copied(), Some(5));
+    }
+
+    #[test]
+    fn test_peek() {
+        let mut cache: LruCache<String, i32> = LruCache::new(3);
+        assert_eq!(cache.peek(&"nonexistent".to_string()), None);
+
+        // Prepare cache with initial values.
+        for (key, value) in [("key1", 1), ("key2", 2), ("key3", 3)] {
+            cache.put(key.to_string(), value);
+        }
+
+        let test_cases = vec![
+            ("nonexistent", None),
+            ("key1", Some(1)),
+            ("key2", Some(2)),
+            ("key3", Some(3)),
+        ];
+
+        for (key, expected_value) in test_cases {
+            assert_eq!(cache.peek(&key.to_string()).copied(), expected_value);
+        }
+
+        // Test eviction after peeking.
+        cache.put("key4".to_string(), 4);
+        assert_eq!(cache.peek(&"key1".to_string()), None);
+        assert_eq!(cache.peek(&"key2".to_string()).copied(), Some(2));
+        assert_eq!(cache.peek(&"key3".to_string()).copied(), Some(3));
+        assert_eq!(cache.peek(&"key4".to_string()).copied(), Some(4));
+    }
+
+    #[test]
+    fn test_contains() {
+        let mut cache: LruCache<String, i32> = LruCache::new(3);
+        assert!(!cache.contains(&"nonexistent".to_string()));
+
+        // Prepare cache with initial values.
+        for (key, value) in [("key1", 1), ("key2", 2), ("key3", 3)] {
+            cache.put(key.to_string(), value);
+        }
+
+        let test_cases = vec![
+            ("nonexistent", false),
+            ("key1", true),
+            ("key2", true),
+            ("key3", true),
+        ];
+
+        for (key, expected_result) in test_cases {
+            assert_eq!(cache.contains(&key.to_string()), expected_result);
+        }
+
+        // Test eviction after contains.
+        cache.put("key4".to_string(), 4);
+        assert!(!cache.contains(&"key1".to_string()));
+        assert!(cache.contains(&"key2".to_string()));
+        assert!(cache.contains(&"key3".to_string()));
+        assert!(cache.contains(&"key4".to_string()));
+    }
+
+    #[test]
+    fn test_pop_lru() {
+        let mut cache: LruCache<String, i32> = LruCache::new(3);
+        assert_eq!(cache.pop_lru(), None);
+
+        for (key, value) in [("key1", 1), ("key2", 2), ("key3", 3)] {
+            cache.put(key.to_string(), value);
+        }
+
+        assert_eq!(cache.pop_lru(), Some(("key1".to_string(), 1)));
+        assert_eq!(cache.pop_lru(), Some(("key2".to_string(), 2)));
+        assert_eq!(cache.pop_lru(), Some(("key3".to_string(), 3)));
+        assert_eq!(cache.pop_lru(), None);
+        assert!(cache.is_empty());
+    }
+
+    #[test]
+    fn test_pop() {
+        let mut cache: LruCache<String, i32> = LruCache::new(3);
+
+        let test_cases = vec![
+            ("key1".to_string(), Some(("key1".to_string(), 1))),
+            ("key2".to_string(), Some(("key2".to_string(), 2))),
+            ("key3".to_string(), Some(("key3".to_string(), 3))),
+            ("key1".to_string(), None),
+            ("key2".to_string(), None),
+            ("key3".to_string(), None),
+        ];
+
+        cache.put("key1".to_string(), 1);
+        cache.put("key2".to_string(), 2);
+        cache.put("key3".to_string(), 3);
+
+        for (key, expected) in test_cases {
+            assert_eq!(cache.pop(&key), expected);
+        }
+
+        assert!(cache.is_empty());
+    }
+}

dragonfly-client-storage/src/cache/mod.rs

@@ -0,0 +1,989 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use bytes::Bytes;
+use dragonfly_api::common::v2::Range;
+use dragonfly_client_config::dfdaemon::Config;
+use dragonfly_client_core::{Error, Result};
+use lru_cache::LruCache;
+use std::cmp::{max, min};
+use std::collections::HashMap;
+use std::io::Cursor;
+use std::sync::Arc;
+use tokio::io::{AsyncRead, BufReader};
+use tokio::sync::RwLock;
+use tracing::info;
+
+pub mod lru_cache;
+
+/// Task is the task content in the cache.
+#[derive(Clone, Debug)]
+struct Task {
+    /// content_length is the length of the task content.
+    content_length: u64,
+
+    /// pieces is the pieces content of the task.
+    pieces: Arc<RwLock<HashMap<String, Bytes>>>,
+}
+
+/// Task implements the task content in the cache.
+impl Task {
+    /// new creates a new task.
+    fn new(content_length: u64) -> Self {
+        Self {
+            content_length,
+            pieces: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    /// write_piece writes the piece content to the task.
+    async fn write_piece(&self, id: &str, piece: Bytes) {
+        let mut pieces = self.pieces.write().await;
+        pieces.insert(id.to_string(), piece);
+    }
+
+    /// read_piece reads the piece content from the task.
+    async fn read_piece(&self, id: &str) -> Option<Bytes> {
+        let pieces = self.pieces.read().await;
+        pieces.get(id).cloned()
+    }
+
+    /// contains checks whether the piece exists in the task.
+    async fn contains(&self, id: &str) -> bool {
+        let pieces = self.pieces.read().await;
+        pieces.contains_key(id)
+    }
+
+    /// content_length returns the content length of the task.
+    fn content_length(&self) -> u64 {
+        self.content_length
+    }
+}
+
+/// Cache is the cache for storing piece content by LRU algorithm.
+///
+/// Cache storage:
+/// 1. Users can preheat task by caching to memory (via CacheTask) or to disk (via Task).
+///    For more details, refer to https://github.com/dragonflyoss/api/blob/main/proto/dfdaemon.proto#L174.
+/// 2. If the download hits the memory cache, it will be faster than reading from the disk, because there is no
+///    page cache for the first read.
+///
+///```text
+///                    +--------+
+///                    │ Source │
+///                    +--------+
+///                       ^ ^                Preheat
+///                       │ │                   |
+/// +-----------------+   │ │    +----------------------------+
+/// │   Other Peers   │   │ │    │  Peer        |             │
+/// │                 │   │ │    │              v             │
+/// │  +----------+   │   │ │    │        +----------+        │
+/// │  │  Cache   |<--|----------|<-Miss--|  Cache   |--Hit-->|<----Download CacheTask
+/// │  +----------+   │     │    │        +----------+        │
+/// │                 │     │    │                            │
+/// │  +----------+   │     │    │        +----------+        │
+/// │  │   Disk   |<--|----------|<-Miss--|   Disk   |--Hit-->|<----Download Task
+/// │  +----------+   │          │        +----------+        │
+/// │                 │          │              ^             │
+/// │                 │          │              |             │
+/// +-----------------+          +----------------------------+
+///                                             |
+///                                          Preheat
+///```    
+/// Task is the metadata of the task.
+#[derive(Clone)]
+pub struct Cache {
+    /// config is the configuration of the dfdaemon.
+    config: Arc<Config>,
+
+    /// size is the size of the cache in bytes.
+    size: u64,
+
+    /// capacity is the maximum capacity of the cache in bytes.
+    capacity: u64,
+
+    /// tasks stores the tasks with their task id.
+    tasks: Arc<RwLock<LruCache<String, Task>>>,
+}
+
+/// Cache implements the cache for storing piece content by LRU algorithm.
+impl Cache {
+    /// new creates a new cache with the specified capacity.
+    pub fn new(config: Arc<Config>) -> Self {
+        Cache {
+            config: config.clone(),
+            size: 0,
+            capacity: config.storage.cache_capacity.as_u64(),
+            // LRU cache capacity is set to usize::MAX to avoid evicting tasks. LRU cache will evict tasks
+            // by cache capacity(cache size) itself, and used pop_lru to evict the least recently
+            // used task.
+            tasks: Arc::new(RwLock::new(LruCache::new(usize::MAX))),
+        }
+    }
+
+    /// read_piece reads the piece from the cache.
+    pub async fn read_piece(
+        &self,
+        task_id: &str,
+        piece_id: &str,
+        piece: super::metadata::Piece,
+        range: Option<Range>,
+    ) -> Result<impl AsyncRead> {
+        let mut tasks = self.tasks.write().await;
+        let Some(task) = tasks.get(task_id) else {
+            return Err(Error::TaskNotFound(task_id.to_string()));
+        };
+
+        let Some(piece_content) = task.read_piece(piece_id).await else {
+            return Err(Error::PieceNotFound(piece_id.to_string()));
+        };
+        drop(tasks);
+
+        // Calculate the range of bytes to return based on the range provided.
+        let (target_offset, target_length) = if let Some(range) = range {
+            let target_offset = max(piece.offset, range.start) - piece.offset;
+            let target_length = min(
+                piece.offset + piece.length - 1,
+                range.start + range.length - 1,
+            ) - target_offset
+                - piece.offset
+                + 1;
+            (target_offset as usize, target_length as usize)
+        } else {
+            (0, piece.length as usize)
+        };
+
+        // Check if the target range is valid.
+        let begin = target_offset;
+        let end = target_offset + target_length;
+        if begin >= piece_content.len() || end > piece_content.len() {
+            return Err(Error::InvalidParameter);
+        }
+
+        let content = piece_content.slice(begin..end);
+        let reader =
+            BufReader::with_capacity(self.config.storage.read_buffer_size, Cursor::new(content));
+        Ok(reader)
+    }
+
+    /// write_piece writes the piece content to the cache.
+    pub async fn write_piece(&self, task_id: &str, piece_id: &str, content: Bytes) -> Result<()> {
+        let mut tasks = self.tasks.write().await;
+        let Some(task) = tasks.get(task_id) else {
+            return Err(Error::TaskNotFound(task_id.to_string()));
+        };
+
+        if task.contains(piece_id).await {
+            return Ok(());
+        }
+
+        task.write_piece(piece_id, content).await;
+        Ok(())
+    }
+
+    /// put_task puts a new task into the cache, constrained by the capacity of the cache.
+    pub async fn put_task(&mut self, task_id: &str, content_length: u64) {
+        // If the content length is 0, we don't cache the task.
+        if content_length == 0 {
+            return;
+        }
+
+        // If the content length is larger than the cache capacity and the task cannot be cached.
+        if content_length > self.capacity {
+            info!(
+                "task {} is too large and cannot be cached: {}",
+                task_id, content_length
+            );
+
+            return;
+        }
+
+        let mut tasks = self.tasks.write().await;
+        while self.size + content_length > self.capacity {
+            match tasks.pop_lru() {
+                Some((_, task)) => {
+                    self.size -= task.content_length();
+                }
+                None => {
+                    break;
+                }
+            }
+        }
+
+        let task = Task::new(content_length);
+        tasks.put(task_id.to_string(), task);
+        self.size += content_length;
+    }
+
+    pub async fn delete_task(&mut self, task_id: &str) -> Result<()> {
+        let mut tasks = self.tasks.write().await;
+        let Some((_, task)) = tasks.pop(task_id) else {
+            return Err(Error::TaskNotFound(task_id.to_string()));
+        };
+
+        self.size -= task.content_length();
+        Ok(())
+    }
+
+    /// contains_task checks whether the task exists in the cache.
+    pub async fn contains_task(&self, id: &str) -> bool {
+        let tasks = self.tasks.read().await;
+        tasks.contains(id)
+    }
+
+    /// contains_piece checks whether the piece exists in the specified task.
+    pub async fn contains_piece(&self, task_id: &str, piece_id: &str) -> bool {
+        let tasks = self.tasks.read().await;
+        if let Some(task) = tasks.peek(task_id) {
+            task.contains(piece_id).await
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::metadata::Piece;
+    use super::*;
+    use bytesize::ByteSize;
+    use dragonfly_api::common::v2::Range;
+    use dragonfly_client_config::dfdaemon::Storage;
+    use tokio::io::AsyncReadExt;
+
+    #[tokio::test]
+    async fn test_new() {
+        let test_cases = vec![
+            // Default configuration with 64MiB capacity.
+            (Config::default(), 0, ByteSize::mib(64).as_u64()),
+            // Custom configuration with 100MiB capacity.
+            (
+                Config {
+                    storage: Storage {
+                        cache_capacity: ByteSize::mib(100),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                0,
+                ByteSize::mib(100).as_u64(),
+            ),
+            // Zero capacity configuration.
+            (
+                Config {
+                    storage: Storage {
+                        cache_capacity: ByteSize::b(0),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+                0,
+                0,
+            ),
+        ];
+
+        for (config, expected_size, expected_capacity) in test_cases {
+            let cache = Cache::new(Arc::new(config));
+            assert_eq!(cache.size, expected_size);
+            assert_eq!(cache.capacity, expected_capacity);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_contains_task() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let cache = Cache::new(Arc::new(config));
+
+        let test_cases = vec![
+            // Test non-existent task.
+            ("check", "non_existent", 0, false),
+            // Add and verify task.
+            ("add", "task1", ByteSize::mib(1).as_u64(), true),
+            ("check", "task1", 0, true),
+            // Remove and verify task.
+            ("remove", "task1", 0, false),
+            ("check", "task1", 0, false),
+            // Test multiple tasks.
+            ("add", "task1", ByteSize::mib(1).as_u64(), true),
+            ("add", "task2", ByteSize::mib(2).as_u64(), true),
+            ("check", "task1", 0, true),
+            ("check", "task2", 0, true),
+            ("check", "task3", 0, false),
+        ];
+
+        for (operation, task_id, content_length, expected_result) in test_cases {
+            match operation {
+                "check" => {
+                    assert_eq!(cache.contains_task(task_id).await, expected_result);
+                }
+                "add" => {
+                    let task = Task::new(content_length);
+                    cache.tasks.write().await.put(task_id.to_string(), task);
+                    assert_eq!(cache.contains_task(task_id).await, expected_result);
+                }
+                "remove" => {
+                    cache.tasks.write().await.pop_lru();
+                    assert_eq!(cache.contains_task(task_id).await, expected_result);
+                }
+                _ => panic!("Unknown operation."),
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_put_task() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        let test_cases = vec![
+            // Empty task should not be cached.
+            ("empty_task", 0, false),
+            // Task equal to capacity should not be cached.
+            ("equal_capacity", ByteSize::mib(10).as_u64(), true),
+            // Task exceeding capacity should not be cached.
+            ("exceed_capacity", ByteSize::mib(10).as_u64() + 1, false),
+            // Normal sized task should be cached.
+            ("normal_task", ByteSize::mib(1).as_u64(), true),
+        ];
+
+        for (task_id, size, should_exist) in test_cases {
+            if size > 0 {
+                cache.put_task(task_id, size).await;
+            }
+
+            assert_eq!(cache.contains_task(task_id).await, should_exist);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_put_task_lru() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(5),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        let test_cases = vec![
+            // Add tasks until eviction triggers.
+            ("lru_task_1", ByteSize::mib(2).as_u64(), true),
+            ("lru_task_2", ByteSize::mib(2).as_u64(), true),
+            // Third task triggers eviction.
+            ("lru_task_3", ByteSize::mib(2).as_u64(), true),
+            // Verify eviction results.
+            ("lru_task_1", 0, false),
+            ("lru_task_2", 0, true),
+            ("lru_task_3", 0, true),
+        ];
+
+        for (task_id, size, should_exist) in test_cases {
+            if size > 0 {
+                cache.put_task(task_id, size).await;
+            }
+            assert_eq!(cache.contains_task(task_id).await, should_exist);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_delete_task() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        cache.put_task("task1", ByteSize::mib(1).as_u64()).await;
+        cache.put_task("task2", ByteSize::mib(1).as_u64()).await;
+        cache.put_task("task3", ByteSize::mib(1).as_u64()).await;
+
+        let test_cases = vec![
+            ("task1", true),
+            ("task2", true),
+            ("task3", true),
+            ("nonexistent", false),
+            ("", false),
+            ("large_task", false),
+        ];
+
+        for (task_id, exists) in test_cases {
+            assert_eq!(cache.contains_task(task_id).await, exists);
+
+            let result = cache.delete_task(task_id).await;
+            if exists {
+                assert!(result.is_ok());
+            } else {
+                assert!(result.is_err());
+            }
+
+            assert!(!cache.contains_task(task_id).await);
+        }
+
+        assert!(!cache.contains_task("task1").await);
+        assert!(!cache.contains_task("task2").await);
+        assert!(!cache.contains_task("task3").await);
+        assert!(!cache.contains_task("nonexistent").await);
+        assert!(!cache.contains_task("").await);
+        assert!(!cache.contains_task("large_task").await);
+    }
+
+    #[tokio::test]
+    async fn test_contains_piece() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        let test_cases = vec![
+            // Check non-existent task.
+            ("check", "non_existent", "piece1", "", false),
+            // Check empty piece ID in non-existent task.
+            ("check", "non_existent", "", "", false),
+            // Add task and verify empty task behavior.
+            ("add_task", "task1", "", "", true),
+            ("check", "task1", "piece1", "", false),
+            // Add piece and verify existence.
+            ("add_piece", "task1", "piece1", "test data", true),
+            ("check", "task1", "piece1", "", true),
+            // Check empty piece ID in existing task.
+            ("check", "task1", "", "", false),
+            // Check non-existent piece in existing task.
+            ("check", "task1", "non_existent_piece", "", false),
+            // Test piece ID with special characters.
+            ("add_piece", "task1", "piece#$%^&*", "test data", true),
+            ("check", "task1", "piece#$%^&*", "", true),
+        ];
+
+        for (operation, task_id, piece_id, content, expected_result) in test_cases {
+            match operation {
+                "check" => {
+                    assert_eq!(
+                        cache.contains_piece(task_id, piece_id).await,
+                        expected_result
+                    );
+                }
+                "add_task" => {
+                    cache.put_task(task_id, 1000).await;
+                    assert!(cache.contains_task(task_id).await);
+                }
+                "add_piece" => {
+                    cache
+                        .write_piece(task_id, piece_id, Bytes::from(content))
+                        .await
+                        .unwrap();
+                    assert_eq!(
+                        cache.contains_piece(task_id, piece_id).await,
+                        expected_result
+                    );
+                }
+                _ => panic!("Unknown operation."),
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_write_piece() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        // Test writing to non-existent task.
+        let test_data = b"test data".to_vec();
+        let result = cache
+            .write_piece("non_existent", "piece1", Bytes::from(test_data))
+            .await;
+        assert!(matches!(result, Err(Error::TaskNotFound(_))));
+
+        // Create a task for testing.
+        cache.put_task("task1", ByteSize::mib(1).as_u64()).await;
+        assert!(cache.contains_task("task1").await);
+
+        let test_cases = vec![
+            ("piece1", b"hello world".to_vec()),
+            ("piece2", b"rust programming".to_vec()),
+            ("piece3", b"dragonfly cache".to_vec()),
+            ("piece4", b"unit testing".to_vec()),
+            ("piece5", b"async await".to_vec()),
+            ("piece6", b"error handling".to_vec()),
+            ("piece7", vec![0u8; 1024]),
+            ("piece8", vec![1u8; 2048]),
+        ];
+
+        for (piece_id, content) in &test_cases {
+            let result = cache
+                .write_piece("task1", piece_id, Bytes::copy_from_slice(content))
+                .await;
+            assert!(result.is_ok());
+            assert!(cache.contains_piece("task1", piece_id).await);
+
+            let piece = Piece {
+                number: 0,
+                offset: 0,
+                length: content.len() as u64,
+                digest: "".to_string(),
+                parent_id: None,
+                uploading_count: 0,
+                uploaded_count: 0,
+                updated_at: chrono::Utc::now().naive_utc(),
+                created_at: chrono::Utc::now().naive_utc(),
+                finished_at: None,
+            };
+
+            let mut reader = cache
+                .read_piece("task1", piece_id, piece, None)
+                .await
+                .unwrap();
+
+            let mut buffer = Vec::new();
+            reader.read_to_end(&mut buffer).await.unwrap();
+            assert_eq!(buffer, *content);
+        }
+
+        // Test attempting to overwrite existing pieces.
+        // The write should succeed (return Ok) but content should not change.
+        for (piece_id, original_content) in &test_cases {
+            let new_content = format!("updated content for {}", piece_id);
+            let result = cache
+                .write_piece("task1", piece_id, Bytes::from(new_content))
+                .await;
+            assert!(result.is_ok());
+
+            // Verify content remains unchanged.
+            let piece = Piece {
+                number: 0,
+                offset: 0,
+                length: original_content.len() as u64,
+                digest: "".to_string(),
+                parent_id: None,
+                uploading_count: 0,
+                uploaded_count: 0,
+                updated_at: chrono::Utc::now().naive_utc(),
+                created_at: chrono::Utc::now().naive_utc(),
+                finished_at: None,
+            };
+
+            let mut reader = cache
+                .read_piece("task1", piece_id, piece, None)
+                .await
+                .unwrap();
+
+            let mut buffer = Vec::new();
+            reader.read_to_end(&mut buffer).await.unwrap();
+            assert_eq!(buffer, *original_content);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_read_piece() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(100),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+
+        let piece = Piece {
+            number: 0,
+            offset: 0,
+            length: 11,
+            digest: "".to_string(),
+            parent_id: None,
+            uploading_count: 0,
+            uploaded_count: 0,
+            updated_at: chrono::Utc::now().naive_utc(),
+            created_at: chrono::Utc::now().naive_utc(),
+            finished_at: None,
+        };
+
+        let result = cache
+            .read_piece("non_existent", "piece1", piece.clone(), None)
+            .await;
+        assert!(matches!(result, Err(Error::TaskNotFound(_))));
+
+        cache.put_task("task1", ByteSize::mib(50).as_u64()).await;
+        let result = cache
+            .read_piece("task1", "non_existent", piece.clone(), None)
+            .await;
+        assert!(matches!(result, Err(Error::PieceNotFound(_))));
+
+        let test_pieces = vec![
+            // Small pieces for basic functionality testing.
+            (
+                "piece1",
+                b"hello world".to_vec(),
+                Piece {
+                    number: 0,
+                    offset: 0,
+                    length: 11,
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                },
+                vec![
+                    (None, b"hello world".to_vec()),
+                    (
+                        Some(Range {
+                            start: 0,
+                            length: 5,
+                        }),
+                        b"hello".to_vec(),
+                    ),
+                ],
+            ),
+            (
+                "piece2",
+                b"rust lang".to_vec(),
+                Piece {
+                    number: 1,
+                    offset: 11,
+                    length: 9,
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                },
+                vec![
+                    (None, b"rust lang".to_vec()),
+                    (
+                        Some(Range {
+                            start: 11,
+                            length: 4,
+                        }),
+                        b"rust".to_vec(),
+                    ),
+                ],
+            ),
+            (
+                "piece3",
+                b"unit test".to_vec(),
+                Piece {
+                    number: 2,
+                    offset: 20,
+                    length: 9,
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                },
+                vec![
+                    (None, b"unit test".to_vec()),
+                    (
+                        Some(Range {
+                            start: 20,
+                            length: 4,
+                        }),
+                        b"unit".to_vec(),
+                    ),
+                ],
+            ),
+            // Large piece for boundary testing.
+            (
+                "large_piece",
+                {
+                    let size = ByteSize::mib(50).as_u64();
+                    (0..size).map(|i| (i % 256) as u8).collect()
+                },
+                Piece {
+                    number: 2,
+                    offset: 0,
+                    length: ByteSize::mib(50).as_u64(),
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                },
+                vec![
+                    // Full read.
+                    (
+                        None,
+                        (0..ByteSize::mib(50).as_u64())
+                            .map(|i| (i % 256) as u8)
+                            .collect(),
+                    ),
+                    // Read first 1MiB.
+                    (
+                        Some(Range {
+                            start: 0,
+                            length: ByteSize::mib(1).as_u64(),
+                        }),
+                        (0..ByteSize::mib(1).as_u64())
+                            .map(|i| (i % 256) as u8)
+                            .collect(),
+                    ),
+                    // Read last 1MiB.
+                    (
+                        Some(Range {
+                            start: ByteSize::mib(49).as_u64(),
+                            length: ByteSize::mib(1).as_u64(),
+                        }),
+                        (ByteSize::mib(49).as_u64()..ByteSize::mib(50).as_u64())
+                            .map(|i| (i % 256) as u8)
+                            .collect(),
+                    ),
+                ],
+            ),
+        ];
+
+        // Write all pieces.
+        for (id, content, _, _) in &test_pieces {
+            cache
+                .write_piece("task1", id, Bytes::copy_from_slice(content))
+                .await
+                .unwrap();
+        }
+
+        // Test all pieces with their read ranges.
+        for (id, _, piece, ranges) in &test_pieces {
+            for (range, expected_content) in ranges {
+                let mut reader = cache
+                    .read_piece("task1", id, piece.clone(), *range)
+                    .await
+                    .unwrap();
+
+                let mut buffer = Vec::new();
+                reader.read_to_end(&mut buffer).await.unwrap();
+                assert_eq!(&buffer, expected_content);
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_concurrent_read_same_piece() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+        cache.put_task("task1", ByteSize::mib(1).as_u64()).await;
+
+        let content = b"test data for concurrent read".to_vec();
+        cache
+            .write_piece("task1", "piece1", Bytes::from(content.clone()))
+            .await
+            .unwrap();
+
+        let cache_arc = Arc::new(cache);
+        let mut join_set = tokio::task::JoinSet::new();
+
+        // Spawn concurrent readers.
+        for i in 0..50 {
+            let cache_clone = cache_arc.clone();
+            let expected_content = content.clone();
+
+            join_set.spawn(async move {
+                let piece = Piece {
+                    number: 0,
+                    offset: 0,
+                    length: expected_content.len() as u64,
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                };
+
+                let range = if i % 2 == 0 {
+                    None
+                } else {
+                    Some(Range {
+                        start: 0,
+                        length: 5,
+                    })
+                };
+
+                let mut reader = cache_clone
+                    .read_piece("task1", "piece1", piece, range)
+                    .await
+                    .unwrap_or_else(|e| panic!("Reader {} failed: {:?}.", i, e));
+
+                let mut buffer = Vec::new();
+                reader.read_to_end(&mut buffer).await.unwrap();
+
+                if let Some(range) = range {
+                    assert_eq!(buffer, &expected_content[..range.length as usize]);
+                } else {
+                    assert_eq!(buffer, expected_content);
+                }
+            });
+        }
+
+        while let Some(result) = join_set.join_next().await {
+            assert!(result.is_ok());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_concurrent_write_different_pieces() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+        cache.put_task("task1", ByteSize::mib(1).as_u64()).await;
+
+        let cache_arc = Arc::new(cache);
+        let mut join_set = tokio::task::JoinSet::new();
+
+        // Spawn concurrent writers.
+        for i in 0..50 {
+            let cache_clone = cache_arc.clone();
+            let content = format!("content for piece {}", i).into_bytes();
+
+            join_set.spawn(async move {
+                let piece_id = format!("piece{}", i);
+                let result = cache_clone
+                    .write_piece("task1", &piece_id, Bytes::from(content.clone()))
+                    .await;
+                assert!(result.is_ok());
+
+                let piece = Piece {
+                    number: 0,
+                    offset: 0,
+                    length: content.len() as u64,
+                    digest: "".to_string(),
+                    parent_id: None,
+                    uploading_count: 0,
+                    uploaded_count: 0,
+                    updated_at: chrono::Utc::now().naive_utc(),
+                    created_at: chrono::Utc::now().naive_utc(),
+                    finished_at: None,
+                };
+
+                let mut reader = cache_clone
+                    .read_piece("task1", &piece_id, piece, None)
+                    .await
+                    .unwrap();
+
+                let mut buffer = Vec::new();
+                reader.read_to_end(&mut buffer).await.unwrap();
+                assert_eq!(buffer, content);
+            });
+        }
+
+        while let Some(result) = join_set.join_next().await {
+            assert!(result.is_ok());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_concurrent_write_same_piece() {
+        let config = Config {
+            storage: Storage {
+                cache_capacity: ByteSize::mib(10),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        let mut cache = Cache::new(Arc::new(config));
+        cache.put_task("task1", ByteSize::mib(1).as_u64()).await;
+
+        let original_content = b"original content".to_vec();
+        cache
+            .write_piece("task1", "piece1", Bytes::from(original_content.clone()))
+            .await
+            .unwrap();
+
+        let cache_arc = Arc::new(cache);
+        let mut join_set = tokio::task::JoinSet::new();
+
+        // Spawn concurrent writers.
+        for i in 0..50 {
+            let cache_clone = cache_arc.clone();
+            let new_content = format!("new content from writer {}", i).into_bytes();
+
+            join_set.spawn(async move {
+                let result = cache_clone
+                    .write_piece("task1", "piece1", Bytes::from(new_content))
+                    .await;
+                assert!(result.is_ok());
+            });
+        }
+
+        while let Some(result) = join_set.join_next().await {
+            assert!(result.is_ok());
+        }
+
+        let piece = Piece {
+            number: 0,
+            offset: 0,
+            length: original_content.len() as u64,
+            digest: "".to_string(),
+            parent_id: None,
+            uploading_count: 0,
+            uploaded_count: 0,
+            updated_at: chrono::Utc::now().naive_utc(),
+            created_at: chrono::Utc::now().naive_utc(),
+            finished_at: None,
+        };
+
+        let mut reader = cache_arc
+            .read_piece("task1", "piece1", piece, None)
+            .await
+            .unwrap();
+
+        let mut buffer = Vec::new();
+        reader.read_to_end(&mut buffer).await.unwrap();
+        assert_eq!(buffer, original_content);
+    }
+}

dragonfly-client-storage/src/lib.rs

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+use chrono::NaiveDateTime;
 use dragonfly_api::common::v2::Range;
 use dragonfly_client_config::dfdaemon::Config;
 use dragonfly_client_core::{Error, Result};
@@ -24,14 +25,17 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::io::AsyncRead;
-use tracing::{error, info, instrument};
+use tokio::time::sleep;
+use tokio_util::either::Either;
+use tracing::{debug, error, info, instrument, warn};
 
+pub mod cache;
 pub mod content;
 pub mod metadata;
 pub mod storage_engine;
 
 /// DEFAULT_WAIT_FOR_PIECE_FINISHED_INTERVAL is the default interval for waiting for the piece to be finished.
-pub const DEFAULT_WAIT_FOR_PIECE_FINISHED_INTERVAL: Duration = Duration::from_millis(500);
+pub const DEFAULT_WAIT_FOR_PIECE_FINISHED_INTERVAL: Duration = Duration::from_millis(100);
 
 /// Storage is the storage of the task.
 pub struct Storage {
@@ -43,54 +47,84 @@ pub struct Storage {
 
     /// content implements the content storage.
     content: content::Content,
+
+    /// cache implements the cache storage.
+    cache: cache::Cache,
 }
 
 /// Storage implements the storage.
 impl Storage {
     /// new returns a new storage.
-    #[instrument(skip_all)]
     pub async fn new(config: Arc<Config>, dir: &Path, log_dir: PathBuf) -> Result<Self> {
         let metadata = metadata::Metadata::new(config.clone(), dir, &log_dir)?;
         let content = content::Content::new(config.clone(), dir).await?;
+        let cache = cache::Cache::new(config.clone());
+
         Ok(Storage {
             config,
             metadata,
             content,
+            cache,
         })
     }
 
-    /// hard_link_or_copy_task hard links or copies the task content to the destination.
-    #[instrument(skip_all)]
-    pub async fn hard_link_or_copy_task(
-        &self,
-        task: metadata::Task,
-        to: &Path,
-        range: Option<Range>,
-    ) -> Result<()> {
-        self.content.hard_link_or_copy_task(task, to, range).await
+    /// total_space returns the total space of the disk.
+    pub fn total_space(&self) -> Result<u64> {
+        self.content.total_space()
     }
 
-    /// read_task_by_range returns the reader of the task by range.
-    #[instrument(skip_all)]
-    pub async fn read_task_by_range(
-        &self,
-        task_id: &str,
-        range: Range,
-    ) -> Result<impl AsyncRead + 'static> {
-        self.content.read_task_by_range(task_id, range).await
+    /// available_space returns the available space of the disk.
+    pub fn available_space(&self) -> Result<u64> {
+        self.content.available_space()
     }
 
-    /// download_task_started updates the metadata of the task when the task downloads started.
+    /// has_enough_space checks if the storage has enough space to store the content.
+    pub fn has_enough_space(&self, content_length: u64) -> Result<bool> {
+        self.content.has_enough_space(content_length)
+    }
+
+    /// hard_link_task hard links the task content to the destination.
     #[instrument(skip_all)]
-    pub fn download_task_started(
+    pub async fn hard_link_task(&self, task_id: &str, to: &Path) -> Result<()> {
+        self.content.hard_link_task(task_id, to).await
+    }
+
+    /// copy_task copies the task content to the destination.
+    #[instrument(skip_all)]
+    pub async fn copy_task(&self, id: &str, to: &Path) -> Result<()> {
+        self.content.copy_task(id, to).await
+    }
+
+    /// is_same_dev_inode_as_task checks if the task content is on the same device inode as the
+    /// destination.
+    pub async fn is_same_dev_inode_as_task(&self, id: &str, to: &Path) -> Result<bool> {
+        self.content.is_same_dev_inode_as_task(id, to).await
+    }
+
+    /// prepare_download_task_started prepares the metadata of the task when the task downloads
+    /// started.
+    pub async fn prepare_download_task_started(&self, id: &str) -> Result<metadata::Task> {
+        self.metadata.download_task_started(id, None, None, None)
+    }
+
+    /// download_task_started updates the metadata of the task and create task content
+    /// when the task downloads started.
+    #[instrument(skip_all)]
+    pub async fn download_task_started(
         &self,
         id: &str,
-        piece_length: Option<u64>,
-        content_length: Option<u64>,
+        piece_length: u64,
+        content_length: u64,
         response_header: Option<HeaderMap>,
     ) -> Result<metadata::Task> {
-        self.metadata
-            .download_task_started(id, piece_length, content_length, response_header)
+        self.content.create_task(id, content_length).await?;
+
+        self.metadata.download_task_started(
+            id,
+            Some(piece_length),
+            Some(content_length),
+            response_header,
+        )
     }
 
     /// download_task_finished updates the metadata of the task when the task downloads finished.
@@ -129,6 +163,12 @@ impl Storage {
         self.metadata.get_task(id)
     }
 
+    /// is_task_exists returns whether the task exists.
+    #[instrument(skip_all)]
+    pub fn is_task_exists(&self, id: &str) -> Result<bool> {
+        self.metadata.is_task_exists(id)
+    }
+
     /// get_tasks returns the task metadatas.
     #[instrument(skip_all)]
     pub fn get_tasks(&self) -> Result<Vec<metadata::Task>> {
@@ -149,66 +189,103 @@ impl Storage {
         self.content.delete_task(id).await.unwrap_or_else(|err| {
             error!("delete task content failed: {}", err);
         });
+
+        let mut cache = self.cache.clone();
+        cache.delete_task(id).await.unwrap_or_else(|err| {
+            info!("delete task from cache failed: {}", err);
+        });
     }
 
-    /// hard_link_or_copy_persistent_cache_task hard links or copies the persistent cache task content to the destination.
+    /// hard_link_persistent_cache_task hard links the persistent cache task content to the destination.
     #[instrument(skip_all)]
-    pub async fn hard_link_or_copy_persistent_cache_task(
-        &self,
-        task: metadata::PersistentCacheTask,
-        to: &Path,
-    ) -> Result<()> {
+    pub async fn hard_link_persistent_cache_task(&self, task_id: &str, to: &Path) -> Result<()> {
         self.content
-            .hard_link_or_copy_persistent_cache_task(task, to)
+            .hard_link_persistent_cache_task(task_id, to)
             .await
     }
 
-    /// create_persistent_persistent_cache_task creates a new persistent cache task.
+    /// copy_taskcopy_persistent_cache_taskcopies the persistent cache task content to the destination.
     #[instrument(skip_all)]
-    pub async fn create_persistent_persistent_cache_task(
+    pub async fn copy_persistent_cache_task(&self, id: &str, to: &Path) -> Result<()> {
+        self.content.copy_persistent_cache_task(id, to).await
+    }
+
+    /// is_same_dev_inode_as_persistent_cache_task checks if the persistent cache task content is on the same device inode as the
+    /// destination.
+    pub async fn is_same_dev_inode_as_persistent_cache_task(
+        &self,
+        id: &str,
+        to: &Path,
+    ) -> Result<bool> {
+        self.content
+            .is_same_dev_inode_as_persistent_cache_task(id, to)
+            .await
+    }
+
+    /// create_persistent_cache_task_started creates a new persistent cache task.
+    #[instrument(skip_all)]
+    pub async fn create_persistent_cache_task_started(
         &self,
         id: &str,
         ttl: Duration,
-        path: &Path,
         piece_length: u64,
         content_length: u64,
-        expected_digest: &str,
     ) -> Result<metadata::PersistentCacheTask> {
-        let response = self.content.write_persistent_cache_task(id, path).await?;
-        let digest = Digest::new(Algorithm::Crc32, response.hash);
-        if expected_digest != digest.to_string() {
-            return Err(Error::DigestMismatch(
-                expected_digest.to_string(),
-                digest.to_string(),
-            ));
-        }
-
-        self.metadata.create_persistent_persistent_cache_task(
+        let metadata = self.metadata.create_persistent_cache_task_started(
             id,
             ttl,
             piece_length,
             content_length,
-            digest.to_string().as_str(),
-        )
+        )?;
+
+        self.content
+            .create_persistent_cache_task(id, content_length)
+            .await?;
+        Ok(metadata)
     }
 
-    /// download_persistent_cache_task_started updates the metadata of the persistent cache task when the persistent cache task downloads started.
+    /// create_persistent_cache_task_finished updates the metadata of the persistent cache task
+    /// when the persistent cache task creates finished.
     #[instrument(skip_all)]
-    pub fn download_persistent_cache_task_started(
+    pub async fn create_persistent_cache_task_finished(
+        &self,
+        id: &str,
+    ) -> Result<metadata::PersistentCacheTask> {
+        self.metadata.create_persistent_cache_task_finished(id)
+    }
+
+    /// create_persistent_cache_task_failed deletes the persistent cache task when
+    /// the persistent cache task creates failed.
+    #[instrument(skip_all)]
+    pub async fn create_persistent_cache_task_failed(&self, id: &str) {
+        self.delete_persistent_cache_task(id).await;
+    }
+
+    /// download_persistent_cache_task_started updates the metadata of the persistent cache task
+    /// and creates the persistent cache task content when the persistent cache task downloads started.
+    #[instrument(skip_all)]
+    pub async fn download_persistent_cache_task_started(
         &self,
         id: &str,
         ttl: Duration,
         persistent: bool,
         piece_length: u64,
         content_length: u64,
+        created_at: NaiveDateTime,
     ) -> Result<metadata::PersistentCacheTask> {
-        self.metadata.download_persistent_cache_task_started(
+        let metadata = self.metadata.download_persistent_cache_task_started(
             id,
             ttl,
             persistent,
             piece_length,
             content_length,
-        )
+            created_at,
+        )?;
+
+        self.content
+            .create_persistent_cache_task(id, content_length)
+            .await?;
+        Ok(metadata)
     }
 
     /// download_persistent_cache_task_finished updates the metadata of the persistent cache task when the persistent cache task downloads finished.
@@ -247,6 +324,18 @@ impl Storage {
         self.metadata.get_persistent_cache_task(id)
     }
 
+    /// persist_persistent_cache_task persists the persistent cache task metadata.
+    #[instrument(skip_all)]
+    pub fn persist_persistent_cache_task(&self, id: &str) -> Result<metadata::PersistentCacheTask> {
+        self.metadata.persist_persistent_cache_task(id)
+    }
+
+    /// is_persistent_cache_task_exists returns whether the persistent cache task exists.
+    #[instrument(skip_all)]
+    pub fn is_persistent_cache_task_exists(&self, id: &str) -> Result<bool> {
+        self.metadata.is_persistent_cache_task_exists(id)
+    }
+
     /// get_tasks returns the task metadatas.
     #[instrument(skip_all)]
     pub fn get_persistent_cache_tasks(&self) -> Result<Vec<metadata::PersistentCacheTask>> {
@@ -262,6 +351,10 @@ impl Storage {
                 error!("delete persistent cache task metadata failed: {}", err);
             });
 
+        self.metadata.delete_pieces(id).unwrap_or_else(|err| {
+            error!("delete persistent cache piece metadatas failed: {}", err);
+        });
+
         self.content
             .delete_persistent_cache_task(id)
             .await
@@ -270,57 +363,137 @@ impl Storage {
             });
     }
 
-    /// download_piece_started updates the metadata of the piece and writes
-    /// the data of piece to file when the piece downloads started.
+    /// create_persistent_cache_piece creates a new persistent cache piece.
     #[instrument(skip_all)]
-    pub async fn download_piece_started(
-        &self,
-        task_id: &str,
-        number: u32,
-    ) -> Result<metadata::Piece> {
-        // Wait for the piece to be finished.
-        match self.wait_for_piece_finished(task_id, number).await {
-            Ok(piece) => Ok(piece),
-            // If piece is not found or wait timeout, create piece metadata.
-            Err(_) => self.metadata.download_piece_started(task_id, number),
-        }
-    }
-
-    /// download_piece_from_source_finished is used for downloading piece from source.
-    #[instrument(skip_all)]
-    pub async fn download_piece_from_source_finished<R: AsyncRead + Unpin + ?Sized>(
+    pub async fn create_persistent_cache_piece<R: AsyncRead + Unpin + ?Sized>(
         &self,
+        piece_id: &str,
         task_id: &str,
         number: u32,
         offset: u64,
         length: u64,
         reader: &mut R,
     ) -> Result<metadata::Piece> {
-        let response = self.content.write_piece(task_id, offset, reader).await?;
+        let response = self
+            .content
+            .write_persistent_cache_piece(task_id, offset, length, reader)
+            .await?;
         let digest = Digest::new(Algorithm::Crc32, response.hash);
 
-        self.metadata.download_piece_finished(
-            task_id,
+        self.metadata.create_persistent_cache_piece(
+            piece_id,
             number,
             offset,
             length,
             digest.to_string().as_str(),
+        )
+    }
+
+    /// download_piece_started updates the metadata of the piece and writes
+    /// the data of piece to file when the piece downloads started.
+    #[instrument(skip_all)]
+    pub async fn download_piece_started(
+        &self,
+        piece_id: &str,
+        number: u32,
+    ) -> Result<metadata::Piece> {
+        // Wait for the piece to be finished.
+        match self.wait_for_piece_finished(piece_id).await {
+            Ok(piece) => Ok(piece),
+            // If piece is not found or wait timeout, create piece metadata.
+            Err(_) => self.metadata.download_piece_started(piece_id, number),
+        }
+    }
+
+    /// download_piece_from_source_finished is used for downloading piece from source.
+    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
+    pub async fn download_piece_from_source_finished<R: AsyncRead + Unpin + ?Sized>(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        offset: u64,
+        length: u64,
+        reader: &mut R,
+        timeout: Duration,
+    ) -> Result<metadata::Piece> {
+        tokio::select! {
+            piece = self.handle_downloaded_from_source_finished(piece_id, task_id, offset, length, reader) => {
+                piece
+            }
+            _ = sleep(timeout) => {
+                Err(Error::DownloadPieceFinished(piece_id.to_string()))
+            }
+        }
+    }
+
+    // handle_downloaded_from_source_finished handles the downloaded piece from source.
+    #[instrument(skip_all)]
+    async fn handle_downloaded_from_source_finished<R: AsyncRead + Unpin + ?Sized>(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        offset: u64,
+        length: u64,
+        reader: &mut R,
+    ) -> Result<metadata::Piece> {
+        let response = self
+            .content
+            .write_piece(task_id, offset, length, reader)
+            .await?;
+
+        let digest = Digest::new(Algorithm::Crc32, response.hash);
+        self.metadata.download_piece_finished(
+            piece_id,
+            offset,
+            length,
+            digest.to_string().as_str(),
             None,
         )
     }
 
-    /// download_piece_from_remote_peer_finished is used for downloading piece from remote peer.
+    /// download_piece_from_parent_finished is used for downloading piece from parent.
+    #[allow(clippy::too_many_arguments)]
     #[instrument(skip_all)]
-    pub async fn download_piece_from_remote_peer_finished<R: AsyncRead + Unpin + ?Sized>(
+    pub async fn download_piece_from_parent_finished<R: AsyncRead + Unpin + ?Sized>(
         &self,
+        piece_id: &str,
         task_id: &str,
-        number: u32,
         offset: u64,
+        length: u64,
+        expected_digest: &str,
+        parent_id: &str,
+        reader: &mut R,
+        timeout: Duration,
+    ) -> Result<metadata::Piece> {
+        tokio::select! {
+            piece = self.handle_downloaded_piece_from_parent_finished(piece_id, task_id, offset, length, expected_digest, parent_id, reader) => {
+                piece
+            }
+            _ = sleep(timeout) => {
+                Err(Error::DownloadPieceFinished(piece_id.to_string()))
+            }
+        }
+    }
+
+    // handle_downloaded_piece_from_parent_finished handles the downloaded piece from parent.
+    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
+    async fn handle_downloaded_piece_from_parent_finished<R: AsyncRead + Unpin + ?Sized>(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        offset: u64,
+        length: u64,
         expected_digest: &str,
         parent_id: &str,
         reader: &mut R,
     ) -> Result<metadata::Piece> {
-        let response = self.content.write_piece(task_id, offset, reader).await?;
+        let response = self
+            .content
+            .write_piece(task_id, offset, length, reader)
+            .await?;
+
         let length = response.length;
         let digest = Digest::new(Algorithm::Crc32, response.hash);
 
@@ -333,8 +506,7 @@ impl Storage {
         }
 
         self.metadata.download_piece_finished(
-            task_id,
-            number,
+            piece_id,
             offset,
             length,
             digest.to_string().as_str(),
@@ -344,8 +516,8 @@ impl Storage {
 
     /// download_piece_failed updates the metadata of the piece when the piece downloads failed.
     #[instrument(skip_all)]
-    pub fn download_piece_failed(&self, task_id: &str, number: u32) -> Result<()> {
-        self.metadata.download_piece_failed(task_id, number)
+    pub fn download_piece_failed(&self, piece_id: &str) -> Result<()> {
+        self.metadata.download_piece_failed(piece_id)
     }
 
     /// upload_piece updates the metadata of the piece and
@@ -353,26 +525,37 @@ impl Storage {
     #[instrument(skip_all)]
     pub async fn upload_piece(
         &self,
+        piece_id: &str,
         task_id: &str,
-        number: u32,
         range: Option<Range>,
     ) -> Result<impl AsyncRead> {
         // Wait for the piece to be finished.
-        self.wait_for_piece_finished(task_id, number).await?;
+        self.wait_for_piece_finished(piece_id).await?;
 
         // Start uploading the task.
         self.metadata.upload_task_started(task_id)?;
 
-        // Start uploading the piece.
-        if let Err(err) = self.metadata.upload_piece_started(task_id, number) {
-            // Failed uploading the task.
-            self.metadata.upload_task_failed(task_id)?;
-            return Err(err);
-        }
-
         // Get the piece metadata and return the content of the piece.
-        match self.metadata.get_piece(task_id, number) {
+        match self.metadata.get_piece(piece_id) {
             Ok(Some(piece)) => {
+                if self.cache.contains_piece(task_id, piece_id).await {
+                    match self
+                        .cache
+                        .read_piece(task_id, piece_id, piece.clone(), range)
+                        .await
+                    {
+                        Ok(reader) => {
+                            // Finish uploading the task.
+                            self.metadata.upload_task_finished(task_id)?;
+                            debug!("get piece from cache: {}", piece_id);
+                            return Ok(Either::Left(reader));
+                        }
+                        Err(err) => {
+                            return Err(err);
+                        }
+                    }
+                }
+
                 match self
                     .content
                     .read_piece(task_id, piece.offset, piece.length, range)
@@ -381,17 +564,11 @@ impl Storage {
                     Ok(reader) => {
                         // Finish uploading the task.
                         self.metadata.upload_task_finished(task_id)?;
-
-                        // Finish uploading the piece.
-                        self.metadata.upload_piece_finished(task_id, number)?;
-                        Ok(reader)
+                        Ok(Either::Right(reader))
                     }
                     Err(err) => {
                         // Failed uploading the task.
                         self.metadata.upload_task_failed(task_id)?;
-
-                        // Failed uploading the piece.
-                        self.metadata.upload_piece_failed(task_id, number)?;
                         Err(err)
                     }
                 }
@@ -399,70 +576,238 @@ impl Storage {
             Ok(None) => {
                 // Failed uploading the task.
                 self.metadata.upload_task_failed(task_id)?;
-
-                // Failed uploading the piece.
-                self.metadata.upload_piece_failed(task_id, number)?;
-                Err(Error::PieceNotFound(self.piece_id(task_id, number)))
+                Err(Error::PieceNotFound(piece_id.to_string()))
             }
             Err(err) => {
                 // Failed uploading the task.
                 self.metadata.upload_task_failed(task_id)?;
-
-                // Failed uploading the piece.
-                self.metadata.upload_piece_failed(task_id, number)?;
                 Err(err)
             }
         }
     }
 
     /// get_piece returns the piece metadata.
+    pub fn get_piece(&self, piece_id: &str) -> Result<Option<metadata::Piece>> {
+        self.metadata.get_piece(piece_id)
+    }
+
+    /// is_piece_exists returns whether the piece exists.
     #[instrument(skip_all)]
-    pub fn get_piece(&self, task_id: &str, number: u32) -> Result<Option<metadata::Piece>> {
-        self.metadata.get_piece(task_id, number)
+    pub fn is_piece_exists(&self, piece_id: &str) -> Result<bool> {
+        self.metadata.is_piece_exists(piece_id)
     }
 
     /// get_pieces returns the piece metadatas.
+    #[instrument(skip_all)]
     pub fn get_pieces(&self, task_id: &str) -> Result<Vec<metadata::Piece>> {
         self.metadata.get_pieces(task_id)
     }
 
     /// piece_id returns the piece id.
-    #[instrument(skip_all)]
+    #[inline]
     pub fn piece_id(&self, task_id: &str, number: u32) -> String {
         self.metadata.piece_id(task_id, number)
     }
 
+    /// download_persistent_cache_piece_started updates the metadata of the persistent cache piece and writes
+    /// the data of piece to file when the persistent cache piece downloads started.
+    #[instrument(skip_all)]
+    pub async fn download_persistent_cache_piece_started(
+        &self,
+        piece_id: &str,
+        number: u32,
+    ) -> Result<metadata::Piece> {
+        // Wait for the piece to be finished.
+        match self
+            .wait_for_persistent_cache_piece_finished(piece_id)
+            .await
+        {
+            Ok(piece) => Ok(piece),
+            // If piece is not found or wait timeout, create piece metadata.
+            Err(_) => self.metadata.download_piece_started(piece_id, number),
+        }
+    }
+
+    /// download_persistent_cache_piece_from_parent_finished is used for downloading persistent cache piece from parent.
+    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
+    pub async fn download_persistent_cache_piece_from_parent_finished<
+        R: AsyncRead + Unpin + ?Sized,
+    >(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        offset: u64,
+        length: u64,
+        expected_digest: &str,
+        parent_id: &str,
+        reader: &mut R,
+    ) -> Result<metadata::Piece> {
+        let response = self
+            .content
+            .write_persistent_cache_piece(task_id, offset, length, reader)
+            .await?;
+
+        let length = response.length;
+        let digest = Digest::new(Algorithm::Crc32, response.hash);
+
+        // Check the digest of the piece.
+        if expected_digest != digest.to_string() {
+            return Err(Error::DigestMismatch(
+                expected_digest.to_string(),
+                digest.to_string(),
+            ));
+        }
+
+        self.metadata.download_piece_finished(
+            piece_id,
+            offset,
+            length,
+            digest.to_string().as_str(),
+            Some(parent_id.to_string()),
+        )
+    }
+
+    /// download_persistent_cache_piece_failed updates the metadata of the persistent cache piece when the persistent cache piece downloads failed.
+    #[instrument(skip_all)]
+    pub fn download_persistent_cache_piece_failed(&self, piece_id: &str) -> Result<()> {
+        self.metadata.download_piece_failed(piece_id)
+    }
+
+    /// upload_persistent_cache_piece updates the metadata of the piece and_then
+    /// returns the data of the piece.
+    #[instrument(skip_all)]
+    pub async fn upload_persistent_cache_piece(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        range: Option<Range>,
+    ) -> Result<impl AsyncRead> {
+        // Wait for the persistent cache piece to be finished.
+        self.wait_for_persistent_cache_piece_finished(piece_id)
+            .await?;
+
+        // Start uploading the persistent cache task.
+        self.metadata
+            .upload_persistent_cache_task_started(task_id)?;
+
+        // Get the persistent cache piece metadata and return the content of the persistent cache piece.
+        match self.metadata.get_piece(piece_id) {
+            Ok(Some(piece)) => {
+                match self
+                    .content
+                    .read_persistent_cache_piece(task_id, piece.offset, piece.length, range)
+                    .await
+                {
+                    Ok(reader) => {
+                        // Finish uploading the persistent cache task.
+                        self.metadata
+                            .upload_persistent_cache_task_finished(task_id)?;
+                        Ok(reader)
+                    }
+                    Err(err) => {
+                        // Failed uploading the persistent cache task.
+                        self.metadata.upload_persistent_cache_task_failed(task_id)?;
+                        Err(err)
+                    }
+                }
+            }
+            Ok(None) => {
+                // Failed uploading the persistent cache task.
+                self.metadata.upload_persistent_cache_task_failed(task_id)?;
+                Err(Error::PieceNotFound(piece_id.to_string()))
+            }
+            Err(err) => {
+                // Failed uploading the persistent cache task.
+                self.metadata.upload_persistent_cache_task_failed(task_id)?;
+                Err(err)
+            }
+        }
+    }
+
+    /// get_persistent_cache_piece returns the persistent cache piece metadata.
+    #[instrument(skip_all)]
+    pub fn get_persistent_cache_piece(&self, piece_id: &str) -> Result<Option<metadata::Piece>> {
+        self.metadata.get_piece(piece_id)
+    }
+
+    /// is_persistent_cache_piece_exists returns whether the persistent cache piece exists.
+    #[instrument(skip_all)]
+    pub fn is_persistent_cache_piece_exists(&self, piece_id: &str) -> Result<bool> {
+        self.metadata.is_piece_exists(piece_id)
+    }
+
+    /// get_persistent_cache_pieces returns the persistent cache piece metadatas.
+    pub fn get_persistent_cache_pieces(&self, task_id: &str) -> Result<Vec<metadata::Piece>> {
+        self.metadata.get_pieces(task_id)
+    }
+
+    /// persistent_cache_piece_id returns the persistent cache piece id.
+    #[inline]
+    pub fn persistent_cache_piece_id(&self, task_id: &str, number: u32) -> String {
+        self.metadata.piece_id(task_id, number)
+    }
+
     /// wait_for_piece_finished waits for the piece to be finished.
     #[instrument(skip_all)]
-    async fn wait_for_piece_finished(&self, task_id: &str, number: u32) -> Result<metadata::Piece> {
-        // Initialize the timeout of piece.
-        let piece_timeout = tokio::time::sleep(self.config.download.piece_timeout);
-        tokio::pin!(piece_timeout);
+    async fn wait_for_piece_finished(&self, piece_id: &str) -> Result<metadata::Piece> {
+        // Total timeout for downloading a piece, combining the download time and the time to write to storage.
+        let wait_timeout = tokio::time::sleep(
+            self.config.download.piece_timeout + self.config.storage.write_piece_timeout,
+        );
+        tokio::pin!(wait_timeout);
 
-        // Initialize the interval of piece.
-        let mut wait_for_piece_count = 0;
         let mut interval = tokio::time::interval(DEFAULT_WAIT_FOR_PIECE_FINISHED_INTERVAL);
         loop {
             tokio::select! {
                 _ = interval.tick() => {
                     let piece = self
-                        .get_piece(task_id, number)?
-                        .ok_or_else(|| Error::PieceNotFound(self.piece_id(task_id, number)))?;
+                        .get_piece(piece_id)?
+                        .ok_or_else(|| Error::PieceNotFound(piece_id.to_string()))?;
 
                     // If the piece is finished, return.
                     if piece.is_finished() {
-                        info!("wait piece finished success");
+                        debug!("wait piece finished success");
                         return Ok(piece);
                     }
-
-                    if wait_for_piece_count > 0 {
-                        info!("wait piece finished");
-                    }
-                    wait_for_piece_count += 1;
                 }
-                _ = &mut piece_timeout => {
-                    self.metadata.wait_for_piece_finished_failed(task_id, number).unwrap_or_else(|err| error!("delete piece metadata failed: {}", err));
-                    return Err(Error::WaitForPieceFinishedTimeout(self.piece_id(task_id, number)));
+                _ = &mut wait_timeout => {
+                    self.metadata.wait_for_piece_finished_failed(piece_id).unwrap_or_else(|err| error!("delete piece metadata failed: {}", err));
+                    return Err(Error::WaitForPieceFinishedTimeout(piece_id.to_string()));
+                }
+            }
+        }
+    }
+
+    /// wait_for_persistent_cache_piece_finished waits for the persistent cache piece to be finished.
+    #[instrument(skip_all)]
+    async fn wait_for_persistent_cache_piece_finished(
+        &self,
+        piece_id: &str,
+    ) -> Result<metadata::Piece> {
+        // Total timeout for downloading a piece, combining the download time and the time to write to storage.
+        let wait_timeout = tokio::time::sleep(
+            self.config.download.piece_timeout + self.config.storage.write_piece_timeout,
+        );
+        tokio::pin!(wait_timeout);
+
+        let mut interval = tokio::time::interval(DEFAULT_WAIT_FOR_PIECE_FINISHED_INTERVAL);
+        loop {
+            tokio::select! {
+                _ = interval.tick() => {
+                    let piece = self
+                        .get_persistent_cache_piece(piece_id)?
+                        .ok_or_else(|| Error::PieceNotFound(piece_id.to_string()))?;
+
+                    // If the piece is finished, return.
+                    if piece.is_finished() {
+                        debug!("wait piece finished success");
+                        return Ok(piece);
+                    }
+                }
+                _ = &mut wait_timeout => {
+                    self.metadata.wait_for_piece_finished_failed(piece_id).unwrap_or_else(|err| error!("delete piece metadata failed: {}", err));
+                    return Err(Error::WaitForPieceFinishedTimeout(piece_id.to_string()));
                 }
             }
         }

dragonfly-client-storage/src/metadata.rs

@@ -17,8 +17,7 @@
 use chrono::{NaiveDateTime, Utc};
 use dragonfly_client_config::dfdaemon::Config;
 use dragonfly_client_core::{Error, Result};
-use dragonfly_client_util::http::reqwest_headermap_to_hashmap;
-use rayon::prelude::*;
+use dragonfly_client_util::{digest, http::headermap_to_hashmap};
 use reqwest::header::HeaderMap;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -46,7 +45,7 @@ pub struct Task {
     pub response_header: HashMap<String, String>,
 
     /// uploading_count is the count of the task being uploaded by other peers.
-    pub uploading_count: u64,
+    pub uploading_count: i64,
 
     /// uploaded_count is the count of the task has been uploaded by other peers.
     pub uploaded_count: u64,
@@ -81,7 +80,7 @@ impl Task {
         self.finished_at.is_none()
     }
 
-    /// is_downloading returns whether the task is downloading.
+    /// is_uploading returns whether the task is uploading.
     pub fn is_uploading(&self) -> bool {
         self.uploading_count > 0
     }
@@ -108,13 +107,10 @@ impl Task {
 
     /// is_empty returns whether the task is empty.
     pub fn is_empty(&self) -> bool {
-        if let Some(content_length) = self.content_length() {
-            if content_length == 0 {
-                return true;
-            }
+        match self.content_length() {
+            Some(content_length) => content_length == 0,
+            None => false,
         }
-
-        false
     }
 
     /// piece_length returns the piece length of the task.
@@ -142,9 +138,6 @@ pub struct PersistentCacheTask {
     /// ttl is the time to live of the persistent cache task.
     pub ttl: Duration,
 
-    /// digests is the digests of the persistent cache task.
-    pub digest: String,
-
     /// piece_length is the length of the piece.
     pub piece_length: u64,
 
@@ -184,17 +177,14 @@ impl PersistentCacheTask {
         self.finished_at.is_none()
     }
 
-    /// is_downloading returns whether the persistent cache task is downloading.
+    /// is_uploading returns whether the persistent cache task is uploading.
     pub fn is_uploading(&self) -> bool {
         self.uploading_count > 0
     }
 
     /// is_expired returns whether the persistent cache task is expired.
     pub fn is_expired(&self) -> bool {
-        // When scheduler runs garbage collection, it will trigger dfdaemon to evict the persistent cache task.
-        // But sometimes the dfdaemon may not evict the persistent cache task in time, so we select the ttl * 1.2
-        // as the expired time to force evict the persistent cache task.
-        self.created_at + self.ttl * 2 < Utc::now().naive_utc()
+        self.created_at + self.ttl < Utc::now().naive_utc()
     }
 
     /// is_failed returns whether the persistent cache task downloads failed.
@@ -209,11 +199,7 @@ impl PersistentCacheTask {
 
     /// is_empty returns whether the persistent cache task is empty.
     pub fn is_empty(&self) -> bool {
-        if self.content_length == 0 {
-            return true;
-        }
-
-        false
+        self.content_length == 0
     }
 
     /// is_persistent returns whether the persistent cache task is persistent.
@@ -250,14 +236,13 @@ pub struct Piece {
     /// parent_id is the parent id of the piece.
     pub parent_id: Option<String>,
 
-    /// uploading_count is the count of the piece being uploaded by other peers.
-    pub uploading_count: u64,
+    /// DEPRECATED: uploading_count is the count of the piece being uploaded by other peers.
+    pub uploading_count: i64,
 
-    /// uploaded_count is the count of the piece has been uploaded by other peers.
+    /// DEPRECATED: uploaded_count is the count of the piece has been uploaded by other peers.
     pub uploaded_count: u64,
 
-    /// updated_at is the time when the piece metadata is updated. If the piece is downloaded
-    /// by other peers, it will also update updated_at.
+    /// updated_at is the time when the piece metadata is updated.
     pub updated_at: NaiveDateTime,
 
     /// created_at is the time when the piece metadata is created.
@@ -315,6 +300,20 @@ impl Piece {
             None => None,
         }
     }
+
+    /// calculate_digest return the digest of the piece metadata, including the piece number,
+    /// offset, length and content digest. The digest is used to check the integrity of the
+    /// piece metadata.
+    pub fn calculate_digest(&self) -> String {
+        let mut hasher = crc32fast::Hasher::new();
+        hasher.update(&self.number.to_be_bytes());
+        hasher.update(&self.offset.to_be_bytes());
+        hasher.update(&self.length.to_be_bytes());
+        hasher.update(self.digest.as_bytes());
+
+        let encoded = hasher.finalize().to_string();
+        digest::Digest::new(digest::Algorithm::Crc32, encoded).to_string()
+    }
 }
 
 /// Metadata manages the metadata of [Task], [Piece] and [PersistentCacheTask].
@@ -339,7 +338,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
         // Convert the response header to hashmap.
         let response_header = response_header
             .as_ref()
-            .map(reqwest_headermap_to_hashmap)
+            .map(headermap_to_hashmap)
             .unwrap_or_default();
 
         let task = match self.db.get::<Task>(id.as_bytes())? {
@@ -508,6 +507,12 @@ impl<E: StorageEngineOwned> Metadata<E> {
         self.db.get(id.as_bytes())
     }
 
+    /// is_task_exists checks if the task exists.
+    #[instrument(skip_all)]
+    pub fn is_task_exists(&self, id: &str) -> Result<bool> {
+        self.db.is_exist::<Task>(id.as_bytes())
+    }
+
     /// get_tasks gets the task metadatas.
     #[instrument(skip_all)]
     pub fn get_tasks(&self) -> Result<Vec<Task>> {
@@ -521,7 +526,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
             .collect::<Result<Vec<Box<[u8]>>>>()?;
 
         tasks
-            .par_iter()
+            .iter()
             .map(|task| Task::deserialize_from(task))
             .collect()
     }
@@ -533,17 +538,14 @@ impl<E: StorageEngineOwned> Metadata<E> {
         self.db.delete::<Task>(id.as_bytes())
     }
 
-    /// create_persistent_persistent_cache_task creates a new persistent cache task.
-    /// If the persistent cache task imports the content to the dfdaemon finished,
-    /// the dfdaemon will create a persistent cache task metadata.
+    /// create_persistent_cache_task creates a new persistent cache task.
     #[instrument(skip_all)]
-    pub fn create_persistent_persistent_cache_task(
+    pub fn create_persistent_cache_task_started(
         &self,
         id: &str,
         ttl: Duration,
         piece_length: u64,
         content_length: u64,
-        digest: &str,
     ) -> Result<PersistentCacheTask> {
         let task = PersistentCacheTask {
             id: id.to_string(),
@@ -551,10 +553,8 @@ impl<E: StorageEngineOwned> Metadata<E> {
             ttl,
             piece_length,
             content_length,
-            digest: digest.to_string(),
             updated_at: Utc::now().naive_utc(),
             created_at: Utc::now().naive_utc(),
-            finished_at: Some(Utc::now().naive_utc()),
             ..Default::default()
         };
 
@@ -562,6 +562,29 @@ impl<E: StorageEngineOwned> Metadata<E> {
         Ok(task)
     }
 
+    /// create_persistent_cache_task_finished updates the metadata of the persistent cache task
+    /// when the persistent cache task finished.
+    #[instrument(skip_all)]
+    pub fn create_persistent_cache_task_finished(&self, id: &str) -> Result<PersistentCacheTask> {
+        let task = match self.db.get::<PersistentCacheTask>(id.as_bytes())? {
+            Some(mut task) => {
+                task.updated_at = Utc::now().naive_utc();
+                task.failed_at = None;
+
+                // If the persistent cache task is created by user, the finished_at has been set.
+                if task.finished_at.is_none() {
+                    task.finished_at = Some(Utc::now().naive_utc());
+                }
+
+                task
+            }
+            None => return Err(Error::TaskNotFound(id.to_string())),
+        };
+
+        self.db.put(id.as_bytes(), &task)?;
+        Ok(task)
+    }
+
     /// download_persistent_cache_task_started updates the metadata of the persistent cache task when
     /// the persistent cache task downloads started. If the persistent cache task downloaded by scheduler
     /// to create persistent cache task, the persistent should be set to true.
@@ -573,10 +596,14 @@ impl<E: StorageEngineOwned> Metadata<E> {
         persistent: bool,
         piece_length: u64,
         content_length: u64,
+        created_at: NaiveDateTime,
     ) -> Result<PersistentCacheTask> {
         let task = match self.db.get::<PersistentCacheTask>(id.as_bytes())? {
             Some(mut task) => {
                 // If the task exists, update the task metadata.
+                task.ttl = ttl;
+                task.persistent = persistent;
+                task.piece_length = piece_length;
                 task.updated_at = Utc::now().naive_utc();
                 task.failed_at = None;
                 task
@@ -588,7 +615,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
                 piece_length,
                 content_length,
                 updated_at: Utc::now().naive_utc(),
-                created_at: Utc::now().naive_utc(),
+                created_at,
                 ..Default::default()
             },
         };
@@ -684,12 +711,34 @@ impl<E: StorageEngineOwned> Metadata<E> {
         Ok(task)
     }
 
+    /// persist_persistent_cache_task persists the persistent cache task metadata.
+    #[instrument(skip_all)]
+    pub fn persist_persistent_cache_task(&self, id: &str) -> Result<PersistentCacheTask> {
+        let task = match self.db.get::<PersistentCacheTask>(id.as_bytes())? {
+            Some(mut task) => {
+                task.persistent = true;
+                task.updated_at = Utc::now().naive_utc();
+                task
+            }
+            None => return Err(Error::TaskNotFound(id.to_string())),
+        };
+
+        self.db.put(id.as_bytes(), &task)?;
+        Ok(task)
+    }
+
     /// get_persistent_cache_task gets the persistent cache task metadata.
     #[instrument(skip_all)]
     pub fn get_persistent_cache_task(&self, id: &str) -> Result<Option<PersistentCacheTask>> {
         self.db.get(id.as_bytes())
     }
 
+    /// is_persistent_cache_task_exists checks if the persistent cache task exists.
+    #[instrument(skip_all)]
+    pub fn is_persistent_cache_task_exists(&self, id: &str) -> Result<bool> {
+        self.db.is_exist::<PersistentCacheTask>(id.as_bytes())
+    }
+
     /// get_persistent_cache_tasks gets the persistent cache task metadatas.
     #[instrument(skip_all)]
     pub fn get_persistent_cache_tasks(&self) -> Result<Vec<PersistentCacheTask>> {
@@ -704,9 +753,40 @@ impl<E: StorageEngineOwned> Metadata<E> {
         self.db.delete::<PersistentCacheTask>(id.as_bytes())
     }
 
+    /// create_persistent_cache_piece creates a new persistent cache piece, which is imported by
+    /// local.
+    #[instrument(skip_all)]
+    pub fn create_persistent_cache_piece(
+        &self,
+        piece_id: &str,
+        number: u32,
+        offset: u64,
+        length: u64,
+        digest: &str,
+    ) -> Result<Piece> {
+        // Construct the piece metadata.
+        let piece = Piece {
+            number,
+            offset,
+            length,
+            digest: digest.to_string(),
+            // Persistent cache piece does not have parent id, because the piece content is
+            // imported by local.
+            parent_id: None,
+            updated_at: Utc::now().naive_utc(),
+            created_at: Utc::now().naive_utc(),
+            finished_at: Some(Utc::now().naive_utc()),
+            ..Default::default()
+        };
+
+        // Put the piece metadata.
+        self.db.put(piece_id.as_bytes(), &piece)?;
+        Ok(piece)
+    }
+
     /// download_piece_started updates the metadata of the piece when the piece downloads started.
     #[instrument(skip_all)]
-    pub fn download_piece_started(&self, task_id: &str, number: u32) -> Result<Piece> {
+    pub fn download_piece_started(&self, piece_id: &str, number: u32) -> Result<Piece> {
         // Construct the piece metadata.
         let piece = Piece {
             number,
@@ -716,8 +796,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
         };
 
         // Put the piece metadata.
-        self.db
-            .put(self.piece_id(task_id, number).as_bytes(), &piece)?;
+        self.db.put(piece_id.as_bytes(), &piece)?;
         Ok(piece)
     }
 
@@ -725,16 +804,13 @@ impl<E: StorageEngineOwned> Metadata<E> {
     #[instrument(skip_all)]
     pub fn download_piece_finished(
         &self,
-        task_id: &str,
-        number: u32,
+        piece_id: &str,
         offset: u64,
         length: u64,
         digest: &str,
         parent_id: Option<String>,
     ) -> Result<Piece> {
-        // Get the piece id.
-        let id = self.piece_id(task_id, number);
-        let piece = match self.db.get::<Piece>(id.as_bytes())? {
+        let piece = match self.db.get::<Piece>(piece_id.as_bytes())? {
             Some(mut piece) => {
                 piece.offset = offset;
                 piece.length = length;
@@ -744,87 +820,38 @@ impl<E: StorageEngineOwned> Metadata<E> {
                 piece.finished_at = Some(Utc::now().naive_utc());
                 piece
             }
-            None => return Err(Error::PieceNotFound(id)),
+            None => return Err(Error::PieceNotFound(piece_id.to_string())),
         };
 
-        self.db.put(id.as_bytes(), &piece)?;
+        self.db.put(piece_id.as_bytes(), &piece)?;
         Ok(piece)
     }
 
     /// download_piece_failed updates the metadata of the piece when the piece downloads failed.
     #[instrument(skip_all)]
-    pub fn download_piece_failed(&self, task_id: &str, number: u32) -> Result<()> {
-        self.delete_piece(task_id, number)
+    pub fn download_piece_failed(&self, piece_id: &str) -> Result<()> {
+        self.delete_piece(piece_id)
     }
 
     /// wait_for_piece_finished_failed waits for the piece to be finished or failed.
     #[instrument(skip_all)]
-    pub fn wait_for_piece_finished_failed(&self, task_id: &str, number: u32) -> Result<()> {
-        self.delete_piece(task_id, number)
-    }
-
-    /// upload_piece_started updates the metadata of the piece when piece uploads started.
-    #[instrument(skip_all)]
-    pub fn upload_piece_started(&self, task_id: &str, number: u32) -> Result<Piece> {
-        // Get the piece id.
-        let id = self.piece_id(task_id, number);
-        let piece = match self.db.get::<Piece>(id.as_bytes())? {
-            Some(mut piece) => {
-                piece.uploading_count += 1;
-                piece.updated_at = Utc::now().naive_utc();
-                piece
-            }
-            None => return Err(Error::PieceNotFound(id)),
-        };
-
-        self.db.put(id.as_bytes(), &piece)?;
-        Ok(piece)
-    }
-
-    /// upload_piece_finished updates the metadata of the piece when piece uploads finished.
-    #[instrument(skip_all)]
-    pub fn upload_piece_finished(&self, task_id: &str, number: u32) -> Result<Piece> {
-        // Get the piece id.
-        let id = self.piece_id(task_id, number);
-        let piece = match self.db.get::<Piece>(id.as_bytes())? {
-            Some(mut piece) => {
-                piece.uploading_count -= 1;
-                piece.uploaded_count += 1;
-                piece.updated_at = Utc::now().naive_utc();
-                piece
-            }
-            None => return Err(Error::PieceNotFound(id)),
-        };
-
-        self.db.put(id.as_bytes(), &piece)?;
-        Ok(piece)
-    }
-
-    /// upload_piece_failed updates the metadata of the piece when the piece uploads failed.
-    #[instrument(skip_all)]
-    pub fn upload_piece_failed(&self, task_id: &str, number: u32) -> Result<Piece> {
-        // Get the piece id.
-        let id = self.piece_id(task_id, number);
-        let piece = match self.db.get::<Piece>(id.as_bytes())? {
-            Some(mut piece) => {
-                piece.uploading_count -= 1;
-                piece.updated_at = Utc::now().naive_utc();
-                piece
-            }
-            None => return Err(Error::PieceNotFound(id)),
-        };
-
-        self.db.put(id.as_bytes(), &piece)?;
-        Ok(piece)
+    pub fn wait_for_piece_finished_failed(&self, piece_id: &str) -> Result<()> {
+        self.delete_piece(piece_id)
     }
 
     /// get_piece gets the piece metadata.
+    pub fn get_piece(&self, piece_id: &str) -> Result<Option<Piece>> {
+        self.db.get(piece_id.as_bytes())
+    }
+
+    /// is_piece_exists checks if the piece exists.
     #[instrument(skip_all)]
-    pub fn get_piece(&self, task_id: &str, number: u32) -> Result<Option<Piece>> {
-        self.db.get(self.piece_id(task_id, number).as_bytes())
+    pub fn is_piece_exists(&self, piece_id: &str) -> Result<bool> {
+        self.db.is_exist::<Piece>(piece_id.as_bytes())
     }
 
     /// get_pieces gets the piece metadatas.
+    #[instrument(skip_all)]
     pub fn get_pieces(&self, task_id: &str) -> Result<Vec<Piece>> {
         let pieces = self
             .db
@@ -836,17 +863,16 @@ impl<E: StorageEngineOwned> Metadata<E> {
             .collect::<Result<Vec<Box<[u8]>>>>()?;
 
         pieces
-            .par_iter()
+            .iter()
             .map(|piece| Piece::deserialize_from(piece))
             .collect()
     }
 
     /// delete_piece deletes the piece metadata.
     #[instrument(skip_all)]
-    pub fn delete_piece(&self, task_id: &str, number: u32) -> Result<()> {
-        info!("delete piece metadata {}", self.piece_id(task_id, number));
-        self.db
-            .delete::<Piece>(self.piece_id(task_id, number).as_bytes())
+    pub fn delete_piece(&self, piece_id: &str) -> Result<()> {
+        info!("delete piece metadata {}", piece_id);
+        self.db.delete::<Piece>(piece_id.as_bytes())
     }
 
     /// delete_pieces deletes the piece metadatas.
@@ -862,7 +888,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
             .collect::<Result<Vec<Box<[u8]>>>>()?;
 
         let piece_ids_refs = piece_ids
-            .par_iter()
+            .iter()
             .map(|id| {
                 let id_ref = id.as_ref();
                 info!(
@@ -879,7 +905,7 @@ impl<E: StorageEngineOwned> Metadata<E> {
     }
 
     /// piece_id returns the piece id.
-    #[instrument(skip_all)]
+    #[inline]
     pub fn piece_id(&self, task_id: &str, number: u32) -> String {
         format!("{}-{}", task_id, number)
     }
@@ -912,11 +938,25 @@ impl Metadata<RocksdbStorageEngine> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use tempdir::TempDir;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_calculate_digest() {
+        let piece = Piece {
+            number: 1,
+            offset: 0,
+            length: 1024,
+            digest: "crc32:1929153120".to_string(),
+            ..Default::default()
+        };
+
+        let digest = piece.calculate_digest();
+        assert_eq!(digest, "crc32:3299754941");
+    }
 
     #[test]
     fn should_create_metadata() {
-        let dir = TempDir::new("metadata").unwrap();
+        let dir = tempdir().unwrap();
         let log_dir = dir.path().join("log");
         let metadata = Metadata::new(Arc::new(Config::default()), dir.path(), &log_dir).unwrap();
         assert!(metadata.get_tasks().unwrap().is_empty());
@@ -928,7 +968,7 @@ mod tests {
 
     #[test]
     fn test_task_lifecycle() {
-        let dir = TempDir::new("metadata").unwrap();
+        let dir = tempdir().unwrap();
         let log_dir = dir.path().join("log");
         let metadata = Metadata::new(Arc::new(Config::default()), dir.path(), &log_dir).unwrap();
         let task_id = "d3c4e940ad06c47fc36ac67801e6f8e36cb400e2391708620bc7e865b102062c";
@@ -947,47 +987,30 @@ mod tests {
         assert!(task.response_header.is_empty());
         assert_eq!(task.uploading_count, 0);
         assert_eq!(task.uploaded_count, 0);
+        assert!(!task.is_finished());
 
         // Test download_task_finished.
         metadata.download_task_finished(task_id).unwrap();
         let task = metadata.get_task(task_id).unwrap().unwrap();
-        assert!(
-            task.is_finished(),
-            "task should be finished after download_task_finished"
-        );
+        assert!(task.is_finished());
 
         // Test upload_task_started.
         metadata.upload_task_started(task_id).unwrap();
         let task = metadata.get_task(task_id).unwrap().unwrap();
-        assert_eq!(
-            task.uploading_count, 1,
-            "uploading_count should be increased by 1 after upload_task_started"
-        );
+        assert_eq!(task.uploading_count, 1);
 
         // Test upload_task_finished.
         metadata.upload_task_finished(task_id).unwrap();
         let task = metadata.get_task(task_id).unwrap().unwrap();
-        assert_eq!(
-            task.uploading_count, 0,
-            "uploading_count should be decreased by 1 after upload_task_finished"
-        );
-        assert_eq!(
-            task.uploaded_count, 1,
-            "uploaded_count should be increased by 1 after upload_task_finished"
-        );
+        assert_eq!(task.uploading_count, 0);
+        assert_eq!(task.uploaded_count, 1);
 
         // Test upload_task_failed.
         let task = metadata.upload_task_started(task_id).unwrap();
         assert_eq!(task.uploading_count, 1);
         let task = metadata.upload_task_failed(task_id).unwrap();
-        assert_eq!(
-            task.uploading_count, 0,
-            "uploading_count should be decreased by 1 after upload_task_failed"
-        );
-        assert_eq!(
-            task.uploaded_count, 1,
-            "uploaded_count should not be changed after upload_task_failed"
-        );
+        assert_eq!(task.uploading_count, 0);
+        assert_eq!(task.uploaded_count, 1);
 
         // Test get_tasks.
         let task_id = "a535b115f18d96870f0422ac891f91dd162f2f391e4778fb84279701fcd02dd1";
@@ -995,91 +1018,62 @@ mod tests {
             .download_task_started(task_id, Some(1024), None, None)
             .unwrap();
         let tasks = metadata.get_tasks().unwrap();
-        assert_eq!(tasks.len(), 2, "should get 2 tasks in total");
+        assert_eq!(tasks.len(), 2);
 
         // Test delete_task.
         metadata.delete_task(task_id).unwrap();
         let task = metadata.get_task(task_id).unwrap();
-        assert!(task.is_none(), "task should be deleted after delete_task");
+        assert!(task.is_none());
     }
 
     #[test]
     fn test_piece_lifecycle() {
-        let dir = TempDir::new("metadata").unwrap();
+        let dir = tempdir().unwrap();
         let log_dir = dir.path().join("log");
         let metadata = Metadata::new(Arc::new(Config::default()), dir.path(), &log_dir).unwrap();
         let task_id = "d3c4e940ad06c47fc36ac67801e6f8e36cb400e2391708620bc7e865b102062c";
+        let piece_id = metadata.piece_id(task_id, 1);
 
         // Test download_piece_started.
-        metadata.download_piece_started(task_id, 1).unwrap();
-        let piece = metadata.get_piece(task_id, 1).unwrap().unwrap();
-        assert_eq!(
-            piece.number, 1,
-            "should get newly created piece with number specified"
-        );
+        metadata
+            .download_piece_started(piece_id.as_str(), 1)
+            .unwrap();
+        let piece = metadata.get_piece(piece_id.as_str()).unwrap().unwrap();
+        assert_eq!(piece.number, 1);
 
         // Test download_piece_finished.
         metadata
-            .download_piece_finished(task_id, 1, 0, 1024, "digest1", None)
+            .download_piece_finished(piece_id.as_str(), 0, 1024, "digest1", None)
             .unwrap();
-        let piece = metadata.get_piece(task_id, 1).unwrap().unwrap();
-        assert_eq!(
-            piece.length, 1024,
-            "piece should be updated after download_piece_finished"
-        );
-        assert_eq!(
-            piece.digest, "digest1",
-            "piece should be updated after download_piece_finished"
-        );
+        let piece = metadata.get_piece(piece_id.as_str()).unwrap().unwrap();
+        assert_eq!(piece.length, 1024);
+        assert_eq!(piece.digest, "digest1");
 
         // Test get_pieces.
-        metadata.download_piece_started(task_id, 2).unwrap();
-        metadata.download_piece_started(task_id, 3).unwrap();
+        metadata
+            .download_piece_started(metadata.piece_id(task_id, 2).as_str(), 2)
+            .unwrap();
+        metadata
+            .download_piece_started(metadata.piece_id(task_id, 3).as_str(), 3)
+            .unwrap();
         let pieces = metadata.get_pieces(task_id).unwrap();
-        assert_eq!(pieces.len(), 3, "should get 3 pieces in total");
+        assert_eq!(pieces.len(), 3);
 
         // Test download_piece_failed.
-        metadata.download_piece_started(task_id, 2).unwrap();
-        metadata.download_piece_started(task_id, 3).unwrap();
-        metadata.download_piece_failed(task_id, 2).unwrap();
-        let piece = metadata.get_piece(task_id, 2).unwrap();
-        assert!(
-            piece.is_none(),
-            "piece should be deleted after download_piece_failed"
-        );
-
-        // Test upload_piece_started.
-        metadata.upload_piece_started(task_id, 3).unwrap();
-        let piece = metadata.get_piece(task_id, 3).unwrap().unwrap();
-        assert_eq!(
-            piece.uploading_count, 1,
-            "piece should be updated after upload_piece_started"
-        );
-
-        // Test upload_piece_finished.
-        metadata.upload_piece_finished(task_id, 3).unwrap();
-        let piece = metadata.get_piece(task_id, 3).unwrap().unwrap();
-        assert_eq!(
-            piece.uploading_count, 0,
-            "piece should be updated after upload_piece_finished"
-        );
-        assert_eq!(
-            piece.uploaded_count, 1,
-            "piece should be updated after upload_piece_finished"
-        );
-
-        // Test upload_piece_failed.
-        metadata.upload_piece_started(task_id, 3).unwrap();
-        metadata.upload_piece_failed(task_id, 3).unwrap();
-        let piece = metadata.get_piece(task_id, 3).unwrap().unwrap();
-        assert_eq!(
-            piece.uploading_count, 0,
-            "piece should be updated after upload_piece_failed"
-        );
+        let piece_id = metadata.piece_id(task_id, 2);
+        metadata
+            .download_piece_started(piece_id.as_str(), 2)
+            .unwrap();
+        metadata
+            .download_piece_started(metadata.piece_id(task_id, 3).as_str(), 3)
+            .unwrap();
+        metadata.download_piece_failed(piece_id.as_str()).unwrap();
+        let piece = metadata.get_piece(piece_id.as_str()).unwrap();
+        assert!(piece.is_none());
 
         // Test delete_pieces.
         metadata.delete_pieces(task_id).unwrap();
         let pieces = metadata.get_pieces(task_id).unwrap();
-        assert!(pieces.is_empty(), "should get 0 pieces after delete_pieces");
+        assert!(pieces.is_empty());
     }
 }

dragonfly-client-storage/src/storage_engine/mod.rs

@@ -52,6 +52,9 @@ pub trait Operations {
     /// get gets the object by key.
     fn get<O: DatabaseObject>(&self, key: &[u8]) -> Result<Option<O>>;
 
+    /// is_exist checks if the object exists by key.
+    fn is_exist<O: DatabaseObject>(&self, key: &[u8]) -> Result<bool>;
+
     /// put puts the object by key.
     fn put<O: DatabaseObject>(&self, key: &[u8], value: &O) -> Result<()>;
 
@@ -62,6 +65,7 @@ pub trait Operations {
     fn iter<O: DatabaseObject>(&self) -> Result<impl Iterator<Item = Result<(Box<[u8]>, O)>>>;
 
     /// iter_raw iterates all objects without serialization.
+    #[allow(clippy::type_complexity)]
     fn iter_raw<O: DatabaseObject>(
         &self,
     ) -> Result<impl Iterator<Item = Result<(Box<[u8]>, Box<[u8]>)>>>;
@@ -73,6 +77,7 @@ pub trait Operations {
     ) -> Result<impl Iterator<Item = Result<(Box<[u8]>, O)>>>;
 
     /// prefix_iter_raw iterates all objects with prefix without serialization.
+    #[allow(clippy::type_complexity)]
     fn prefix_iter_raw<O: DatabaseObject>(
         &self,
         prefix: &[u8],

dragonfly-client-storage/src/storage_engine/rocksdb.rs

@@ -19,12 +19,12 @@ use dragonfly_client_core::{
     error::{ErrorType, OrErr},
     Error, Result,
 };
-use rocksdb::{ReadOptions, WriteOptions};
+use rocksdb::WriteOptions;
 use std::{
     ops::Deref,
     path::{Path, PathBuf},
 };
-use tracing::{info, instrument, warn};
+use tracing::{info, warn};
 
 /// RocksdbStorageEngine is a storage engine based on rocksdb.
 pub struct RocksdbStorageEngine {
@@ -54,11 +54,11 @@ impl RocksdbStorageEngine {
     // DEFAULT_MAX_BACKGROUND_JOBS is the default max background jobs for rocksdb, default is 2.
     const DEFAULT_MAX_BACKGROUND_JOBS: i32 = 2;
 
-    /// DEFAULT_BLOCK_SIZE is the default block size for rocksdb, default is 128KB.
-    const DEFAULT_BLOCK_SIZE: usize = 128 * 1024;
+    /// DEFAULT_BLOCK_SIZE is the default block size for rocksdb, default is 64KB.
+    const DEFAULT_BLOCK_SIZE: usize = 64 * 1024;
 
-    /// DEFAULT_CACHE_SIZE is the default cache size for rocksdb, default is 512MB.
-    const DEFAULT_CACHE_SIZE: usize = 512 * 1024 * 1024;
+    /// DEFAULT_CACHE_SIZE is the default cache size for rocksdb, default is 1GB.
+    const DEFAULT_CACHE_SIZE: usize = 1024 * 1024 * 1024;
 
     /// DEFAULT_LOG_MAX_SIZE is the default max log size for rocksdb, default is 64MB.
     const DEFAULT_LOG_MAX_SIZE: usize = 64 * 1024 * 1024;
@@ -67,23 +67,27 @@ impl RocksdbStorageEngine {
     const DEFAULT_LOG_MAX_FILES: usize = 10;
 
     /// open opens a rocksdb storage engine with the given directory and column families.
-    #[instrument(skip_all)]
     pub fn open(dir: &Path, log_dir: &PathBuf, cf_names: &[&str], keep: bool) -> Result<Self> {
         info!("initializing metadata directory: {:?} {:?}", dir, cf_names);
         // Initialize rocksdb options.
         let mut options = rocksdb::Options::default();
         options.create_if_missing(true);
         options.create_missing_column_families(true);
-        options.increase_parallelism(num_cpus::get() as i32);
+
+        // Optimize compression.
         options.set_compression_type(rocksdb::DBCompressionType::Lz4);
+        options.set_bottommost_compression_type(rocksdb::DBCompressionType::Zstd);
+
+        // Improved parallelism.
+        options.increase_parallelism(num_cpus::get() as i32);
         options.set_max_background_jobs(std::cmp::max(
-            num_cpus::get() as i32 / 2,
+            num_cpus::get() as i32,
             Self::DEFAULT_MAX_BACKGROUND_JOBS,
         ));
 
         // Set rocksdb log options.
         options.set_db_log_dir(log_dir);
-        options.set_log_level(rocksdb::LogLevel::Debug);
+        options.set_log_level(rocksdb::LogLevel::Info);
         options.set_max_log_file_size(Self::DEFAULT_LOG_MAX_SIZE);
         options.set_keep_log_file_num(Self::DEFAULT_LOG_MAX_FILES);
 
@@ -91,12 +95,14 @@ impl RocksdbStorageEngine {
         let mut block_options = rocksdb::BlockBasedOptions::default();
         block_options.set_block_cache(&rocksdb::Cache::new_lru_cache(Self::DEFAULT_CACHE_SIZE));
         block_options.set_block_size(Self::DEFAULT_BLOCK_SIZE);
+        block_options.set_cache_index_and_filter_blocks(true);
+        block_options.set_pin_l0_filter_and_index_blocks_in_cache(true);
         options.set_block_based_table_factory(&block_options);
 
         // Initialize column family options.
         let mut cf_options = rocksdb::Options::default();
         cf_options.set_prefix_extractor(rocksdb::SliceTransform::create_fixed_prefix(64));
-        cf_options.set_memtable_prefix_bloom_ratio(0.2);
+        cf_options.set_memtable_prefix_bloom_ratio(0.25);
         cf_options.optimize_level_style_compaction(Self::DEFAULT_MEMTABLE_MEMORY_BUDGET);
 
         // Initialize column families.
@@ -110,9 +116,7 @@ impl RocksdbStorageEngine {
 
         // If the storage is kept, open the db and drop the unused column families.
         // Otherwise, destroy the db.
-        if keep {
-            drop_unused_cfs(&dir);
-        } else {
+        if !keep {
             rocksdb::DB::destroy(&options, &dir).unwrap_or_else(|err| {
                 warn!("destroy {:?} failed: {}", dir, err);
             });
@@ -130,36 +134,33 @@ impl RocksdbStorageEngine {
 /// RocksdbStorageEngine implements the storage engine operations.
 impl Operations for RocksdbStorageEngine {
     /// get gets the object by key.
-    #[instrument(skip_all)]
     fn get<O: DatabaseObject>(&self, key: &[u8]) -> Result<Option<O>> {
         let cf = cf_handle::<O>(self)?;
-        let mut options = ReadOptions::default();
-        options.fill_cache(false);
-
-        let value = self
-            .get_cf_opt(cf, key, &options)
-            .or_err(ErrorType::StorageError)?;
+        let value = self.get_cf(cf, key).or_err(ErrorType::StorageError)?;
         match value {
             Some(value) => Ok(Some(O::deserialize_from(&value)?)),
             None => Ok(None),
         }
     }
 
+    /// is_exist checks if the object exists by key.
+    fn is_exist<O: DatabaseObject>(&self, key: &[u8]) -> Result<bool> {
+        let cf = cf_handle::<O>(self)?;
+        Ok(self
+            .get_cf(cf, key)
+            .or_err(ErrorType::StorageError)?
+            .is_some())
+    }
+
     /// put puts the object by key.
-    #[instrument(skip_all)]
     fn put<O: DatabaseObject>(&self, key: &[u8], value: &O) -> Result<()> {
         let cf = cf_handle::<O>(self)?;
-        let serialized = value.serialized()?;
-        let mut options = WriteOptions::default();
-        options.set_sync(true);
-
-        self.put_cf_opt(cf, key, serialized, &options)
+        self.put_cf(cf, key, value.serialized()?)
             .or_err(ErrorType::StorageError)?;
         Ok(())
     }
 
     /// delete deletes the object by key.
-    #[instrument(skip_all)]
     fn delete<O: DatabaseObject>(&self, key: &[u8]) -> Result<()> {
         let cf = cf_handle::<O>(self)?;
         let mut options = WriteOptions::default();
@@ -171,7 +172,6 @@ impl Operations for RocksdbStorageEngine {
     }
 
     /// iter iterates all objects.
-    #[instrument(skip_all)]
     fn iter<O: DatabaseObject>(&self) -> Result<impl Iterator<Item = Result<(Box<[u8]>, O)>>> {
         let cf = cf_handle::<O>(self)?;
         let iter = self.iterator_cf(cf, rocksdb::IteratorMode::Start);
@@ -182,7 +182,6 @@ impl Operations for RocksdbStorageEngine {
     }
 
     /// iter_raw iterates all objects without serialization.
-    #[instrument(skip_all)]
     fn iter_raw<O: DatabaseObject>(
         &self,
     ) -> Result<impl Iterator<Item = Result<(Box<[u8]>, Box<[u8]>)>>> {
@@ -196,7 +195,6 @@ impl Operations for RocksdbStorageEngine {
     }
 
     /// prefix_iter iterates all objects with prefix.
-    #[instrument(skip_all)]
     fn prefix_iter<O: DatabaseObject>(
         &self,
         prefix: &[u8],
@@ -210,7 +208,6 @@ impl Operations for RocksdbStorageEngine {
     }
 
     /// prefix_iter_raw iterates all objects with prefix without serialization.
-    #[instrument(skip_all)]
     fn prefix_iter_raw<O: DatabaseObject>(
         &self,
         prefix: &[u8],
@@ -223,7 +220,6 @@ impl Operations for RocksdbStorageEngine {
     }
 
     /// batch_delete deletes objects by keys.
-    #[instrument(skip_all)]
     fn batch_delete<O: DatabaseObject>(&self, keys: Vec<&[u8]>) -> Result<()> {
         let cf = cf_handle::<O>(self)?;
         let mut batch = rocksdb::WriteBatch::default();
@@ -240,7 +236,7 @@ impl Operations for RocksdbStorageEngine {
 }
 
 /// RocksdbStorageEngine implements the rocksdb of the storage engine.
-impl<'db> StorageEngine<'db> for RocksdbStorageEngine {}
+impl StorageEngine<'_> for RocksdbStorageEngine {}
 
 /// cf_handle returns the column family handle for the given object.
 fn cf_handle<T>(db: &rocksdb::DB) -> Result<&rocksdb::ColumnFamily>
@@ -252,23 +248,398 @@ where
         .ok_or_else(|| Error::ColumnFamilyNotFound(cf_name.to_string()))
 }
 
-/// drop_unused_cfs drops the unused column families.
-fn drop_unused_cfs(dir: &Path) {
-    let old_cf_names = vec!["task", "piece", "cache_task"];
-    let unused_cf_names = vec!["cache_task"];
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde::{Deserialize, Serialize};
+    use tempfile::tempdir;
 
-    let mut db = match rocksdb::DB::open_cf(&rocksdb::Options::default(), dir, old_cf_names) {
-        Ok(db) => db,
-        Err(err) => {
-            warn!("open cf failed: {}", err);
-            return;
+    #[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
+    struct Object {
+        id: String,
+        value: i32,
+    }
+
+    impl DatabaseObject for Object {
+        const NAMESPACE: &'static str = "object";
+    }
+
+    fn create_test_engine() -> RocksdbStorageEngine {
+        let temp_dir = tempdir().unwrap();
+        let log_dir = temp_dir.path().to_path_buf();
+        RocksdbStorageEngine::open(temp_dir.path(), &log_dir, &[Object::NAMESPACE], false).unwrap()
+    }
+
+    #[test]
+    fn test_put_and_get() {
+        let engine = create_test_engine();
+
+        let object = Object {
+            id: "1".to_string(),
+            value: 42,
+        };
+
+        engine.put::<Object>(object.id.as_bytes(), &object).unwrap();
+        let retrieved_object = engine.get::<Object>(object.id.as_bytes()).unwrap().unwrap();
+        assert_eq!(object, retrieved_object);
+    }
+
+    #[test]
+    fn test_is_exist() {
+        let engine = create_test_engine();
+
+        let object = Object {
+            id: "2".to_string(),
+            value: 100,
+        };
+
+        assert!(!engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
+        engine.put::<Object>(object.id.as_bytes(), &object).unwrap();
+        assert!(engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
+    }
+
+    #[test]
+    fn test_delete() {
+        let engine = create_test_engine();
+
+        let object = Object {
+            id: "3".to_string(),
+            value: 200,
+        };
+
+        engine.put::<Object>(object.id.as_bytes(), &object).unwrap();
+        assert!(engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
+
+        engine.delete::<Object>(object.id.as_bytes()).unwrap();
+        assert!(!engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
+    }
+
+    #[test]
+    fn test_batch_delete() {
+        let engine = create_test_engine();
+
+        let objects = vec![
+            Object {
+                id: "1".to_string(),
+                value: 1,
+            },
+            Object {
+                id: "2".to_string(),
+                value: 2,
+            },
+            Object {
+                id: "3".to_string(),
+                value: 3,
+            },
+        ];
+
+        for object in &objects {
+            engine.put::<Object>(object.id.as_bytes(), object).unwrap();
+            assert!(engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
         }
-    };
 
-    for cf_name in unused_cf_names {
-        match db.drop_cf(cf_name) {
-            Ok(_) => info!("drop cf [{}] success", cf_name),
-            Err(err) => warn!("drop cf [{}] failed: {}", cf_name, err),
+        let ids: Vec<&[u8]> = objects.iter().map(|object| object.id.as_bytes()).collect();
+        engine.batch_delete::<Object>(ids).unwrap();
+
+        for object in &objects {
+            assert!(!engine.is_exist::<Object>(object.id.as_bytes()).unwrap());
+        }
+    }
+
+    #[test]
+    fn test_iter() {
+        let engine = create_test_engine();
+
+        let objects = vec![
+            Object {
+                id: "1".to_string(),
+                value: 10,
+            },
+            Object {
+                id: "2".to_string(),
+                value: 20,
+            },
+            Object {
+                id: "3".to_string(),
+                value: 30,
+            },
+        ];
+
+        for object in &objects {
+            engine.put::<Object>(object.id.as_bytes(), object).unwrap();
+        }
+
+        let retrieved_objects = engine
+            .iter::<Object>()
+            .unwrap()
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(retrieved_objects.len(), objects.len());
+        for object in &objects {
+            let found = retrieved_objects
+                .iter()
+                .any(|(_, v)| v.id == object.id && v.value == object.value);
+            assert!(found, "could not find object with id {:?}", object.id);
+        }
+    }
+
+    #[test]
+    fn test_prefix_iter() {
+        let engine = create_test_engine();
+
+        // RocksDB prefix extractor is configured with fixed_prefix(64) in the open method.
+        let prefix_a = [b'a'; 64];
+        let prefix_b = [b'b'; 64];
+
+        // Create test keys with 64-byte identical prefixes.
+        let key_a1 = [&prefix_a[..], b"_suffix1"].concat();
+        let key_a2 = [&prefix_a[..], b"_suffix2"].concat();
+
+        let key_b1 = [&prefix_b[..], b"_suffix1"].concat();
+        let key_b2 = [&prefix_b[..], b"_suffix2"].concat();
+
+        let objects_with_prefix_a = vec![
+            (
+                key_a1.clone(),
+                Object {
+                    id: "prefix_id_a1".to_string(),
+                    value: 100,
+                },
+            ),
+            (
+                key_a2.clone(),
+                Object {
+                    id: "prefix_id_a2".to_string(),
+                    value: 200,
+                },
+            ),
+        ];
+
+        let objects_with_prefix_b = vec![
+            (
+                key_b1.clone(),
+                Object {
+                    id: "prefix_id_b1".to_string(),
+                    value: 300,
+                },
+            ),
+            (
+                key_b2.clone(),
+                Object {
+                    id: "prefix_id_b2".to_string(),
+                    value: 400,
+                },
+            ),
+        ];
+
+        for (key, obj) in &objects_with_prefix_a {
+            engine.put::<Object>(key, obj).unwrap();
+        }
+
+        for (key, obj) in &objects_with_prefix_b {
+            engine.put::<Object>(key, obj).unwrap();
+        }
+
+        let retrieved_objects = engine
+            .prefix_iter::<Object>(&prefix_a)
+            .unwrap()
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            retrieved_objects.len(),
+            objects_with_prefix_a.len(),
+            "expected {} objects with prefix 'a', but got {}",
+            objects_with_prefix_a.len(),
+            retrieved_objects.len()
+        );
+
+        // Verify each object with prefix is correctly retrieved.
+        for (key, object) in &objects_with_prefix_a {
+            let found = retrieved_objects
+                .iter()
+                .any(|(_, v)| v.id == object.id && v.value == object.value);
+            assert!(found, "could not find object with key {:?}", key);
+        }
+
+        // Verify objects with different prefix are not retrieved.
+        for (key, object) in &objects_with_prefix_b {
+            let found = retrieved_objects
+                .iter()
+                .any(|(_, v)| v.id == object.id && v.value == object.value);
+            assert!(!found, "found object with different prefix: {:?}", key);
+        }
+    }
+
+    #[test]
+    fn test_iter_raw() {
+        let engine = create_test_engine();
+
+        let objects = vec![
+            Object {
+                id: "1".to_string(),
+                value: 10,
+            },
+            Object {
+                id: "2".to_string(),
+                value: 20,
+            },
+            Object {
+                id: "3".to_string(),
+                value: 30,
+            },
+        ];
+
+        for object in &objects {
+            engine.put::<Object>(object.id.as_bytes(), object).unwrap();
+        }
+
+        let retrieved_objects = engine
+            .iter_raw::<Object>()
+            .unwrap()
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(retrieved_objects.len(), objects.len());
+
+        // Verify each object can be deserialized from the raw bytes.
+        for object in &objects {
+            let found = retrieved_objects
+                .iter()
+                .any(|(_, v)| match Object::deserialize_from(v) {
+                    Ok(deserialized) => {
+                        deserialized.id == object.id && deserialized.value == object.value
+                    }
+                    Err(_) => false,
+                });
+
+            assert!(
+                found,
+                "could not find or deserialize object with key {:?}",
+                object.id
+            );
+        }
+    }
+
+    #[test]
+    fn test_prefix_iter_raw() {
+        let engine = create_test_engine();
+
+        // RocksDB prefix extractor is configured with fixed_prefix(64) in the open method.
+        let prefix_a = [b'a'; 64];
+        let prefix_b = [b'b'; 64];
+
+        // Create test keys with 64-byte identical prefixes.
+        let key_a1 = [&prefix_a[..], b"_raw_suffix1"].concat();
+        let key_a2 = [&prefix_a[..], b"_raw_suffix2"].concat();
+
+        let key_b1 = [&prefix_b[..], b"_raw_suffix1"].concat();
+        let key_b2 = [&prefix_b[..], b"_raw_suffix2"].concat();
+
+        let objects_with_prefix_a = vec![
+            (
+                key_a1.clone(),
+                Object {
+                    id: "raw_prefix_id_a1".to_string(),
+                    value: 100,
+                },
+            ),
+            (
+                key_a2.clone(),
+                Object {
+                    id: "raw_prefix_id_a2".to_string(),
+                    value: 200,
+                },
+            ),
+        ];
+
+        let objects_with_prefix_b = vec![
+            (
+                key_b1.clone(),
+                Object {
+                    id: "raw_prefix_id_b1".to_string(),
+                    value: 300,
+                },
+            ),
+            (
+                key_b2.clone(),
+                Object {
+                    id: "raw_prefix_id_b2".to_string(),
+                    value: 400,
+                },
+            ),
+        ];
+
+        for (key, obj) in &objects_with_prefix_a {
+            engine.put::<Object>(key, obj).unwrap();
+        }
+
+        for (key, obj) in &objects_with_prefix_b {
+            engine.put::<Object>(key, obj).unwrap();
+        }
+
+        let retrieved_objects = engine
+            .prefix_iter_raw::<Object>(&prefix_a)
+            .unwrap()
+            .collect::<Result<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(
+            retrieved_objects.len(),
+            objects_with_prefix_a.len(),
+            "expected {} raw objects with prefix 'a', but got {}",
+            objects_with_prefix_a.len(),
+            retrieved_objects.len()
+        );
+
+        // Verify each object with prefix can be deserialized from raw bytes.
+        for (_, object) in &objects_with_prefix_a {
+            let found = retrieved_objects
+                .iter()
+                .any(|(_, v)| match Object::deserialize_from(v) {
+                    Ok(deserialized) => {
+                        deserialized.id == object.id && deserialized.value == object.value
+                    }
+                    Err(_) => false,
+                });
+
+            assert!(
+                found,
+                "could not find or deserialize object with key {:?}",
+                object.id
+            );
+        }
+
+        // Verify objects with different prefix are not retrieved.
+        for (key, _) in &objects_with_prefix_b {
+            let found = retrieved_objects
+                .iter()
+                .any(|(k, _)| k.as_ref() == key.as_slice());
+            assert!(!found, "found object with different prefix: {:?}", key);
+        }
+    }
+
+    #[test]
+    fn test_column_family_not_found() {
+        let engine = create_test_engine();
+
+        // Define a new type with a different namespace that hasn't been registered.
+        #[derive(Debug, Serialize, Deserialize, PartialEq)]
+        struct UnregisteredObject {
+            data: String,
+        }
+
+        impl DatabaseObject for UnregisteredObject {
+            const NAMESPACE: &'static str = "unregistered";
+        }
+
+        let key = b"unregistered";
+        let result = engine.get::<UnregisteredObject>(key);
+
+        assert!(result.is_err());
+        if let Err(err) = result {
+            assert!(format!("{:?}", err).contains("ColumnFamilyNotFound"));
         }
     }
 }

dragonfly-client-util/Cargo.toml

@@ -13,7 +13,6 @@ edition.workspace = true
 dragonfly-client-core.workspace = true
 dragonfly-api.workspace = true
 reqwest.workspace = true
-hyper.workspace = true
 http-range-header.workspace = true
 http.workspace = true
 tracing.workspace = true
@@ -24,12 +23,17 @@ rustls-pki-types.workspace = true
 rustls-pemfile.workspace = true
 sha2.workspace = true
 uuid.workspace = true
+sysinfo.workspace = true
 hex.workspace = true
-openssl.workspace = true
-blake3.workspace = true
 crc32fast.workspace = true
-base16ct.workspace = true
+openssl.workspace = true
+lazy_static.workspace = true
+bytesize.workspace = true
+lru.workspace = true
+tokio.workspace = true
+rustix = { version = "1.0.8", features = ["fs"] }
 base64 = "0.22.1"
+pnet = "0.35.0"
 
 [dev-dependencies]
 tempfile.workspace = true

dragonfly-client-util/src/digest/mod.rs

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-use dragonfly_client_core::Result as ClientResult;
+use dragonfly_client_core::{Error as ClientError, Result as ClientResult};
 use sha2::Digest as Sha2Digest;
 use std::fmt;
-use std::io::Read;
+use std::io::{self, Read};
 use std::path::Path;
 use std::str::FromStr;
 use tracing::instrument;
@@ -31,9 +31,6 @@ pub enum Algorithm {
     /// Crc32 is crc32 algorithm for generate digest.
     Crc32,
 
-    /// Blake3 is blake3 algorithm for generate digest.
-    Blake3,
-
     /// Sha256 is sha256 algorithm for generate digest.
     Sha256,
 
@@ -47,7 +44,6 @@ impl fmt::Display for Algorithm {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Algorithm::Crc32 => write!(f, "crc32"),
-            Algorithm::Blake3 => write!(f, "blake3"),
             Algorithm::Sha256 => write!(f, "sha256"),
             Algorithm::Sha512 => write!(f, "sha512"),
         }
@@ -62,7 +58,6 @@ impl FromStr for Algorithm {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "crc32" => Ok(Algorithm::Crc32),
-            "blake3" => Ok(Algorithm::Blake3),
             "sha256" => Ok(Algorithm::Sha256),
             "sha512" => Ok(Algorithm::Sha512),
             _ => Err(format!("invalid digest algorithm: {}", s)),
@@ -117,10 +112,36 @@ impl FromStr for Digest {
         }
 
         let algorithm = match parts[0] {
-            "crc32" => Algorithm::Crc32,
-            "blake3" => Algorithm::Blake3,
-            "sha256" => Algorithm::Sha256,
-            "sha512" => Algorithm::Sha512,
+            "crc32" => {
+                if parts[1].len() != 10 {
+                    return Err(format!(
+                        "invalid crc32 digest length: {}, expected 10",
+                        parts[1].len()
+                    ));
+                }
+
+                Algorithm::Crc32
+            }
+            "sha256" => {
+                if parts[1].len() != 64 {
+                    return Err(format!(
+                        "invalid sha256 digest length: {}, expected 64",
+                        parts[1].len()
+                    ));
+                }
+
+                Algorithm::Sha256
+            }
+            "sha512" => {
+                if parts[1].len() != 128 {
+                    return Err(format!(
+                        "invalid sha512 digest length: {}, expected 128",
+                        parts[1].len()
+                    ));
+                }
+
+                Algorithm::Sha512
+            }
             _ => return Err(format!("invalid digest algorithm: {}", parts[0])),
         };
 
@@ -128,48 +149,58 @@ impl FromStr for Digest {
     }
 }
 
-/// calculate_file_hash calculates the hash of a file.
+/// calculate_file_digest calculates the digest of a file.
 #[instrument(skip_all)]
-pub fn calculate_file_hash(algorithm: Algorithm, path: &Path) -> ClientResult<Digest> {
+pub fn calculate_file_digest(algorithm: Algorithm, path: &Path) -> ClientResult<Digest> {
     let f = std::fs::File::open(path)?;
-    let mut reader = std::io::BufReader::new(f);
+    let mut reader = io::BufReader::new(f);
     match algorithm {
         Algorithm::Crc32 => {
-            let mut hasher = crc32fast::Hasher::new();
             let mut buffer = [0; 4096];
+            let mut hasher = crc32fast::Hasher::new();
             loop {
-                let count = reader.read(&mut buffer)?;
-                if count == 0 {
-                    break;
-                }
-                hasher.update(&buffer[..count]);
+                match reader.read(&mut buffer) {
+                    Ok(0) => break,
+                    Ok(n) => hasher.update(&buffer[..n]),
+                    Err(ref err) if err.kind() == io::ErrorKind::Interrupted => continue,
+                    Err(err) => return Err(err.into()),
+                };
             }
-            Ok(Digest::new(
-                algorithm,
-                base16ct::lower::encode_string(&hasher.finalize().to_be_bytes()),
-            ))
-        }
-        Algorithm::Blake3 => {
-            let mut hasher = blake3::Hasher::new();
-            std::io::copy(&mut reader, &mut hasher)?;
-            Ok(Digest::new(
-                algorithm,
-                base16ct::lower::encode_string(hasher.finalize().as_bytes()),
-            ))
+
+            Ok(Digest::new(algorithm, hasher.finalize().to_string()))
         }
         Algorithm::Sha256 => {
             let mut hasher = sha2::Sha256::new();
-            std::io::copy(&mut reader, &mut hasher)?;
+            io::copy(&mut reader, &mut hasher)?;
             Ok(Digest::new(algorithm, hex::encode(hasher.finalize())))
         }
         Algorithm::Sha512 => {
             let mut hasher = sha2::Sha512::new();
-            std::io::copy(&mut reader, &mut hasher)?;
+            io::copy(&mut reader, &mut hasher)?;
             Ok(Digest::new(algorithm, hex::encode(hasher.finalize())))
         }
     }
 }
 
+/// verify_file_digest verifies the digest of a file against an expected digest.
+pub fn verify_file_digest(expected_digest: Digest, file_path: &Path) -> ClientResult<()> {
+    let digest = match calculate_file_digest(expected_digest.algorithm(), file_path) {
+        Ok(digest) => digest,
+        Err(err) => {
+            return Err(err);
+        }
+    };
+
+    if digest.to_string() != expected_digest.to_string() {
+        return Err(ClientError::DigestMismatch(
+            expected_digest.to_string(),
+            digest.to_string(),
+        ));
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -179,7 +210,6 @@ mod tests {
     #[test]
     fn test_algorithm_display() {
         assert_eq!(Algorithm::Crc32.to_string(), "crc32");
-        assert_eq!(Algorithm::Blake3.to_string(), "blake3");
         assert_eq!(Algorithm::Sha256.to_string(), "sha256");
         assert_eq!(Algorithm::Sha512.to_string(), "sha512");
     }
@@ -187,7 +217,6 @@ mod tests {
     #[test]
     fn test_algorithm_from_str() {
         assert_eq!("crc32".parse::<Algorithm>(), Ok(Algorithm::Crc32));
-        assert_eq!("blake3".parse::<Algorithm>(), Ok(Algorithm::Blake3));
         assert_eq!("sha256".parse::<Algorithm>(), Ok(Algorithm::Sha256));
         assert_eq!("sha512".parse::<Algorithm>(), Ok(Algorithm::Sha512));
         assert!("invalid".parse::<Algorithm>().is_err());
@@ -200,31 +229,50 @@ mod tests {
     }
 
     #[test]
-    fn test_calculate_file_hash() {
+    fn test_calculate_file_digest() {
         let content = b"test content";
         let temp_file = tempfile::NamedTempFile::new().expect("failed to create temp file");
         let path = temp_file.path();
         let mut file = File::create(path).expect("failed to create file");
         file.write_all(content).expect("failed to write to file");
 
-        let expected_blake3 = "ead3df8af4aece7792496936f83b6b6d191a7f256585ce6b6028db161278017e";
-        let digest =
-            calculate_file_hash(Algorithm::Blake3, path).expect("failed to calculate Blake3 hash");
-        assert_eq!(digest.encoded(), expected_blake3);
-
         let expected_sha256 = "6ae8a75555209fd6c44157c0aed8016e763ff435a19cf186f76863140143ff72";
-        let digest =
-            calculate_file_hash(Algorithm::Sha256, path).expect("failed to calculate Sha256 hash");
+        let digest = calculate_file_digest(Algorithm::Sha256, path)
+            .expect("failed to calculate Sha256 hash");
         assert_eq!(digest.encoded(), expected_sha256);
 
         let expected_sha512 = "0cbf4caef38047bba9a24e621a961484e5d2a92176a859e7eb27df343dd34eb98d538a6c5f4da1ce302ec250b821cc001e46cc97a704988297185a4df7e99602";
-        let digest =
-            calculate_file_hash(Algorithm::Sha512, path).expect("failed to calculate Sha512 hash");
+        let digest = calculate_file_digest(Algorithm::Sha512, path)
+            .expect("failed to calculate Sha512 hash");
         assert_eq!(digest.encoded(), expected_sha512);
 
-        let expected_crc32 = "57f4675d";
+        let expected_crc32 = "1475635037";
         let digest =
-            calculate_file_hash(Algorithm::Crc32, path).expect("failed to calculate Sha512 hash");
+            calculate_file_digest(Algorithm::Crc32, path).expect("failed to calculate Crc32 hash");
         assert_eq!(digest.encoded(), expected_crc32);
     }
+
+    #[test]
+    fn test_verify_file_digest() {
+        let content = b"test content";
+        let temp_file = tempfile::NamedTempFile::new().expect("failed to create temp file");
+        let path = temp_file.path();
+        let mut file = File::create(path).expect("failed to create file");
+        file.write_all(content).expect("failed to write to file");
+
+        let expected_sha256_digest = Digest::new(
+            Algorithm::Sha256,
+            "6ae8a75555209fd6c44157c0aed8016e763ff435a19cf186f76863140143ff72".to_string(),
+        );
+        assert!(verify_file_digest(expected_sha256_digest, path).is_ok());
+
+        let expected_sha512_digest = Digest::new(
+            Algorithm::Sha512,
+            "0cbf4caef38047bba9a24e621a961484e5d2a92176a859e7eb27df343dd34eb98d538a6c5f4da1ce302ec250b821cc001e46cc97a704988297185a4df7e99602".to_string(),
+        );
+        assert!(verify_file_digest(expected_sha512_digest, path).is_ok());
+
+        let expected_crc32_digest = Digest::new(Algorithm::Crc32, "1475635037".to_string());
+        assert!(verify_file_digest(expected_crc32_digest, path).is_ok());
+    }
 }

dragonfly-client-util/src/fs/mod.rs

@@ -0,0 +1,54 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use dragonfly_client_core::Result;
+use tokio::fs;
+
+/// fallocate allocates the space for the file and fills it with zero, only on Linux.
+#[allow(unused_variables)]
+pub async fn fallocate(f: &fs::File, length: u64) -> Result<()> {
+    // No allocation needed for zero length. Avoids potential fallocate errors.
+    if length == 0 {
+        return Ok(());
+    }
+
+    #[cfg(target_os = "linux")]
+    {
+        use dragonfly_client_core::Error;
+        use rustix::fs::{fallocate, FallocateFlags};
+        use std::os::unix::io::AsFd;
+        use tokio::io;
+
+        // Set length (potential truncation).
+        f.set_len(length).await?;
+        let fd = f.as_fd();
+        let offset = 0;
+        let flags = FallocateFlags::KEEP_SIZE;
+
+        loop {
+            match fallocate(fd, flags, offset, length) {
+                Ok(_) => return Ok(()),
+                Err(rustix::io::Errno::INTR) => continue,
+                Err(err) => {
+                    return Err(Error::IO(io::Error::from_raw_os_error(err.raw_os_error())))
+                }
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    Ok(())
+}

dragonfly-client-util/src/http/basic_auth.rs

@@ -20,7 +20,6 @@ use dragonfly_client_core::{
     Error, Result,
 };
 use http::header::{self, HeaderMap};
-use tracing::instrument;
 
 /// Credentials is the credentials for the basic auth.
 pub struct Credentials {
@@ -34,7 +33,6 @@ pub struct Credentials {
 /// Credentials is the basic auth.
 impl Credentials {
     /// new returns a new Credentials.
-    #[instrument(skip_all)]
     pub fn new(username: &str, password: &str) -> Credentials {
         Self {
             username: username.to_string(),
@@ -79,3 +77,100 @@ impl Credentials {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use http::header::HeaderValue;
+
+    #[test]
+    fn test_verify_no_auth_header() {
+        let credentials = Credentials::new("user", "pass");
+        let header = HeaderMap::new();
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::Unauthorized));
+    }
+
+    #[test]
+    fn test_verify_invalid_auth_type() {
+        let credentials = Credentials::new("user", "pass");
+        let mut header = HeaderMap::new();
+        header.insert(
+            header::AUTHORIZATION,
+            HeaderValue::from_static("Bearer some_token"),
+        );
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::Unauthorized));
+    }
+
+    #[test]
+    fn test_verify_invalid_base64() {
+        let credentials = Credentials::new("user", "pass");
+        let mut header = HeaderMap::new();
+        header.insert(
+            header::AUTHORIZATION,
+            HeaderValue::from_static("Basic invalid_base64"),
+        );
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_err());
+        assert_eq!(
+            format!("{}", result.err().unwrap()),
+            format!(
+                "{:?} cause: Invalid symbol 95, offset 7.",
+                ErrorType::ParseError
+            ),
+        );
+    }
+
+    #[test]
+    fn test_verify_invalid_format() {
+        let credentials = Credentials::new("user", "pass");
+        let mut header = HeaderMap::new();
+        header.insert(
+            header::AUTHORIZATION,
+            HeaderValue::from_static("Basic dXNlcg=="), // "user" in Base64
+        );
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::Unauthorized));
+    }
+
+    #[test]
+    fn test_verify_incorrect_credentials() {
+        let credentials = Credentials::new("user", "pass");
+        let mut header = HeaderMap::new();
+        header.insert(
+            header::AUTHORIZATION,
+            HeaderValue::from_static("Basic dXNlcjpwYXNzX2Vycm9y"), // "user:pass_error" in Base64
+        );
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), Error::Unauthorized));
+    }
+
+    #[test]
+    fn test_verify_correct_credentials() {
+        let credentials = Credentials::new("user", "pass");
+        let mut header = HeaderMap::new();
+        header.insert(
+            header::AUTHORIZATION,
+            HeaderValue::from_static("Basic dXNlcjpwYXNz"), // "user:pass" in Base64
+        );
+
+        let result = credentials.verify(&header);
+
+        assert!(result.is_ok());
+    }
+}

dragonfly-client-util/src/http/mod.rs

@@ -19,108 +19,53 @@ use dragonfly_client_core::{
     error::{ErrorType, OrErr},
     Error, Result,
 };
-use reqwest::header::{HeaderMap, HeaderValue};
+use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 use std::collections::HashMap;
-use tracing::{error, instrument};
 
 pub mod basic_auth;
 
-/// reqwest_headermap_to_hashmap converts a reqwest headermap to a hashmap.
-#[instrument(skip_all)]
-pub fn reqwest_headermap_to_hashmap(header: &HeaderMap<HeaderValue>) -> HashMap<String, String> {
-    let mut hashmap: HashMap<String, String> = HashMap::new();
+/// headermap_to_hashmap converts a headermap to a hashmap.
+pub fn headermap_to_hashmap(header: &HeaderMap<HeaderValue>) -> HashMap<String, String> {
+    let mut hashmap: HashMap<String, String> = HashMap::with_capacity(header.len());
     for (k, v) in header {
-        let Some(v) = v.to_str().ok() else {
-            continue;
-        };
-
-        hashmap.entry(k.to_string()).or_insert(v.to_string());
+        if let Ok(v) = v.to_str() {
+            hashmap.insert(k.to_string(), v.to_string());
+        }
     }
 
     hashmap
 }
 
-/// hashmap_to_reqwest_headermap converts a hashmap to a reqwest headermap.
-#[instrument(skip_all)]
-pub fn hashmap_to_reqwest_headermap(
-    header: &HashMap<String, String>,
-) -> Result<HeaderMap<HeaderValue>> {
-    let header: HeaderMap = (header).try_into().or_err(ErrorType::ParseError)?;
-    Ok(header)
-}
-
-/// hashmap_to_hyper_header_map converts a hashmap to a hyper header map.
-#[instrument(skip_all)]
-pub fn hashmap_to_hyper_header_map(
-    header: &HashMap<String, String>,
-) -> Result<hyper::header::HeaderMap> {
-    let header: hyper::header::HeaderMap = (header).try_into().or_err(ErrorType::ParseError)?;
-    Ok(header)
-}
-
-/// TODO: Remove the conversion after the http crate version is the same.
-/// Convert the Reqwest header to the Hyper header, because of the http crate
-/// version is different. Reqwest header depends on the http crate
-/// version 0.2, but the Hyper header depends on the http crate version 0.1.
-#[instrument(skip_all)]
-pub fn hyper_headermap_to_reqwest_headermap(
-    hyper_header: &hyper::header::HeaderMap,
-) -> reqwest::header::HeaderMap {
-    let mut reqwest_header = reqwest::header::HeaderMap::new();
-    for (hyper_header_key, hyper_header_value) in hyper_header.iter() {
-        let reqwest_header_name: reqwest::header::HeaderName =
-            match hyper_header_key.to_string().parse() {
-                Ok(reqwest_header_name) => reqwest_header_name,
-                Err(err) => {
-                    error!("parse header name error: {}", err);
-                    continue;
-                }
-            };
-
-        let reqwest_header_value: reqwest::header::HeaderValue = match hyper_header_value.to_str() {
-            Ok(reqwest_header_value) => match reqwest_header_value.parse() {
-                Ok(reqwest_header_value) => reqwest_header_value,
-                Err(err) => {
-                    error!("parse header value error: {}", err);
-                    continue;
-                }
-            },
-            Err(err) => {
-                error!("parse header value error: {}", err);
-                continue;
-            }
-        };
-
-        reqwest_header.insert(reqwest_header_name, reqwest_header_value);
+/// hashmap_to_headermap converts a hashmap to a headermap.
+pub fn hashmap_to_headermap(header: &HashMap<String, String>) -> Result<HeaderMap<HeaderValue>> {
+    let mut headermap = HeaderMap::with_capacity(header.len());
+    for (k, v) in header {
+        let name = HeaderName::from_bytes(k.as_bytes()).or_err(ErrorType::ParseError)?;
+        let value = HeaderValue::from_bytes(v.as_bytes()).or_err(ErrorType::ParseError)?;
+        headermap.insert(name, value);
     }
 
-    reqwest_header
+    Ok(headermap)
 }
 
 /// header_vec_to_hashmap converts a vector of header string to a hashmap.
-#[instrument(skip_all)]
 pub fn header_vec_to_hashmap(raw_header: Vec<String>) -> Result<HashMap<String, String>> {
-    let mut header = HashMap::new();
+    let mut header = HashMap::with_capacity(raw_header.len());
     for h in raw_header {
-        let mut parts = h.splitn(2, ':');
-        let key = parts.next().unwrap().trim();
-        let value = parts.next().unwrap().trim();
-        header.insert(key.to_string(), value.to_string());
+        if let Some((k, v)) = h.split_once(':') {
+            header.insert(k.trim().to_string(), v.trim().to_string());
+        }
     }
 
     Ok(header)
 }
 
-/// header_vec_to_reqwest_headermap converts a vector of header string to a reqwest headermap.
-#[instrument(skip_all)]
-pub fn header_vec_to_reqwest_headermap(
-    raw_header: Vec<String>,
-) -> Result<reqwest::header::HeaderMap> {
-    hashmap_to_reqwest_headermap(&header_vec_to_hashmap(raw_header)?)
+/// header_vec_to_headermap converts a vector of header string to a reqwest headermap.
+pub fn header_vec_to_headermap(raw_header: Vec<String>) -> Result<HeaderMap> {
+    hashmap_to_headermap(&header_vec_to_hashmap(raw_header)?)
 }
 
 /// get_range gets the range from http header.
-#[instrument(skip_all)]
 pub fn get_range(header: &HeaderMap, content_length: u64) -> Result<Option<Range>> {
     match header.get(reqwest::header::RANGE) {
         Some(range) => {
@@ -134,7 +79,6 @@ pub fn get_range(header: &HeaderMap, content_length: u64) -> Result<Option<Range
 /// parse_range_header parses a Range header string as per RFC 7233,
 /// supported Range Header: "Range": "bytes=100-200", "Range": "bytes=-50",
 /// "Range": "bytes=150-", "Range": "bytes=0-0,-1".
-#[instrument(skip_all)]
 pub fn parse_range_header(range_header_value: &str, content_length: u64) -> Result<Range> {
     let parsed_ranges =
         http_range_header::parse_range_header(range_header_value).or_err(ErrorType::ParseError)?;
@@ -151,3 +95,76 @@ pub fn parse_range_header(range_header_value: &str, content_length: u64) -> Resu
     let length = valid_range.end() - start + 1;
     Ok(Range { start, length })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reqwest::header::{HeaderMap, HeaderValue};
+
+    #[test]
+    fn test_headermap_to_hashmap() {
+        let mut header = HeaderMap::new();
+        header.insert("Content-Type", HeaderValue::from_static("application/json"));
+        header.insert("Authorization", HeaderValue::from_static("Bearer token"));
+
+        let hashmap = headermap_to_hashmap(&header);
+        assert_eq!(hashmap.get("content-type").unwrap(), "application/json");
+        assert_eq!(hashmap.get("authorization").unwrap(), "Bearer token");
+        assert_eq!(hashmap.get("foo"), None);
+    }
+
+    #[test]
+    fn test_hashmap_to_headermap() {
+        let mut hashmap = HashMap::new();
+        hashmap.insert("Content-Type".to_string(), "application/json".to_string());
+        hashmap.insert("Authorization".to_string(), "Bearer token".to_string());
+
+        let header = hashmap_to_headermap(&hashmap).unwrap();
+        assert_eq!(header.get("Content-Type").unwrap(), "application/json");
+        assert_eq!(header.get("Authorization").unwrap(), "Bearer token");
+    }
+
+    #[test]
+    fn test_header_vec_to_hashmap() {
+        let raw_header = vec![
+            "Content-Type: application/json".to_string(),
+            "Authorization: Bearer token".to_string(),
+        ];
+
+        let hashmap = header_vec_to_hashmap(raw_header).unwrap();
+        assert_eq!(hashmap.get("Content-Type").unwrap(), "application/json");
+        assert_eq!(hashmap.get("Authorization").unwrap(), "Bearer token");
+    }
+
+    #[test]
+    fn test_header_vec_to_headermap() {
+        let raw_header = vec![
+            "Content-Type: application/json".to_string(),
+            "Authorization: Bearer token".to_string(),
+        ];
+
+        let header = header_vec_to_headermap(raw_header).unwrap();
+        assert_eq!(header.get("Content-Type").unwrap(), "application/json");
+        assert_eq!(header.get("Authorization").unwrap(), "Bearer token");
+    }
+
+    #[test]
+    fn test_get_range() {
+        let mut header = HeaderMap::new();
+        header.insert(
+            reqwest::header::RANGE,
+            HeaderValue::from_static("bytes=0-100"),
+        );
+
+        let range = get_range(&header, 200).unwrap().unwrap();
+        assert_eq!(range.start, 0);
+        assert_eq!(range.length, 101);
+    }
+
+    #[test]
+    fn test_parse_range_header() {
+        let range = parse_range_header("bytes=0-100", 200).unwrap();
+        assert_eq!(range.start, 0);
+        assert_eq!(range.length, 101);
+    }
+}

dragonfly-client-util/src/id_generator/mod.rs

@@ -20,8 +20,8 @@ use dragonfly_client_core::{
     Result,
 };
 use sha2::{Digest, Sha256};
+use std::io::{self, Read};
 use std::path::PathBuf;
-use tracing::instrument;
 use url::Url;
 use uuid::Uuid;
 
@@ -31,6 +31,34 @@ const SEED_PEER_SUFFIX: &str = "seed";
 /// PERSISTENT_CACHE_TASK_SUFFIX is the suffix of the persistent cache task.
 const PERSISTENT_CACHE_TASK_SUFFIX: &str = "persistent-cache-task";
 
+/// TaskIDParameter is the parameter of the task id.
+pub enum TaskIDParameter {
+    /// Content uses the content to generate the task id.
+    Content(String),
+    /// URLBased uses the url, piece_length, tag, application and filtered_query_params to generate
+    /// the task id.
+    URLBased {
+        url: String,
+        piece_length: Option<u64>,
+        tag: Option<String>,
+        application: Option<String>,
+        filtered_query_params: Vec<String>,
+    },
+}
+
+/// PersistentCacheTaskIDParameter is the parameter of the persistent cache task id.
+pub enum PersistentCacheTaskIDParameter {
+    /// Content uses the content to generate the persistent cache task id.
+    Content(String),
+    /// FileContentBased uses the file path, piece_length, tag and application to generate the persistent cache task id.
+    FileContentBased {
+        path: PathBuf,
+        piece_length: Option<u64>,
+        tag: Option<String>,
+        application: Option<String>,
+    },
+}
+
 /// IDGenerator is used to generate the id for the resources.
 #[derive(Debug)]
 pub struct IDGenerator {
@@ -47,7 +75,6 @@ pub struct IDGenerator {
 /// IDGenerator implements the IDGenerator.
 impl IDGenerator {
     /// new creates a new IDGenerator.
-    #[instrument(skip_all)]
     pub fn new(ip: String, hostname: String, is_seed_peer: bool) -> Self {
         IDGenerator {
             ip,
@@ -57,7 +84,7 @@ impl IDGenerator {
     }
 
     /// host_id generates the host id.
-    #[instrument(skip_all)]
+    #[inline]
     pub fn host_id(&self) -> String {
         if self.is_seed_peer {
             return format!("{}-{}-{}", self.ip, self.hostname, "seed");
@@ -67,80 +94,125 @@ impl IDGenerator {
     }
 
     /// task_id generates the task id.
-    #[instrument(skip_all)]
-    pub fn task_id(
-        &self,
-        url: &str,
-        digest: Option<&str>,
-        tag: Option<&str>,
-        application: Option<&str>,
-        filtered_query_params: Vec<String>,
-    ) -> Result<String> {
-        // Filter the query parameters.
-        let url = Url::parse(url).or_err(ErrorType::ParseError)?;
-        let query = url
-            .query_pairs()
-            .filter(|(k, _)| !filtered_query_params.contains(&k.to_string()));
+    #[inline]
+    pub fn task_id(&self, parameter: TaskIDParameter) -> Result<String> {
+        match parameter {
+            TaskIDParameter::Content(content) => {
+                Ok(hex::encode(Sha256::digest(content.as_bytes())))
+            }
+            TaskIDParameter::URLBased {
+                url,
+                piece_length,
+                tag,
+                application,
+                filtered_query_params,
+            } => {
+                // Filter the query parameters.
+                let url = Url::parse(url.as_str()).or_err(ErrorType::ParseError)?;
+                let query = url
+                    .query_pairs()
+                    .filter(|(k, _)| !filtered_query_params.contains(&k.to_string()));
 
-        let mut artifact_url = url.clone();
-        artifact_url.query_pairs_mut().clear().extend_pairs(query);
+                let mut artifact_url = url.clone();
+                if query.clone().count() == 0 {
+                    artifact_url.set_query(None);
+                } else {
+                    artifact_url.query_pairs_mut().clear().extend_pairs(query);
+                }
 
-        // Initialize the hasher.
-        let mut hasher = Sha256::new();
+                let artifact_url_str = artifact_url.to_string();
+                let final_url = if artifact_url_str.ends_with('/') && artifact_url.path() == "/" {
+                    artifact_url_str.trim_end_matches('/').to_string()
+                } else {
+                    artifact_url_str
+                };
 
-        // Add the url to generate the task id.
-        hasher.update(artifact_url.to_string());
+                // Initialize the hasher.
+                let mut hasher = Sha256::new();
 
-        // Add the digest to generate the task id.
-        if let Some(digest) = digest {
-            hasher.update(digest);
+                // Add the url to generate the task id.
+                hasher.update(final_url);
+
+                // Add the tag to generate the task id.
+                if let Some(tag) = tag {
+                    hasher.update(tag);
+                }
+
+                // Add the application to generate the task id.
+                if let Some(application) = application {
+                    hasher.update(application);
+                }
+
+                // Add the piece length to generate the task id.
+                if let Some(piece_length) = piece_length {
+                    hasher.update(piece_length.to_string());
+                }
+
+                hasher.update(TaskType::Standard.as_str_name().as_bytes());
+
+                // Generate the task id.
+                Ok(hex::encode(hasher.finalize()))
+            }
         }
-
-        // Add the tag to generate the task id.
-        if let Some(tag) = tag {
-            hasher.update(tag);
-        }
-
-        // Add the application to generate the task id.
-        if let Some(application) = application {
-            hasher.update(application);
-        }
-
-        // Generate the task id.
-        Ok(hex::encode(hasher.finalize()))
     }
 
     /// persistent_cache_task_id generates the persistent cache task id.
-    #[instrument(skip_all)]
+    #[inline]
     pub fn persistent_cache_task_id(
         &self,
-        path: &PathBuf,
-        tag: Option<&str>,
-        application: Option<&str>,
+        parameter: PersistentCacheTaskIDParameter,
     ) -> Result<String> {
-        // Initialize the hasher.
-        let mut hasher = blake3::Hasher::new();
+        let mut hasher = crc32fast::Hasher::new();
 
-        // Calculate the hash of the file.
-        let mut f = std::fs::File::open(path)?;
-        std::io::copy(&mut f, &mut hasher)?;
+        match parameter {
+            PersistentCacheTaskIDParameter::Content(content) => {
+                hasher.update(content.as_bytes());
+                Ok(hasher.finalize().to_string())
+            }
+            PersistentCacheTaskIDParameter::FileContentBased {
+                path,
+                piece_length,
+                tag,
+                application,
+            } => {
+                // Calculate the hash of the file.
+                let f = std::fs::File::open(path)?;
+                let mut buffer = [0; 4096];
+                let mut reader = io::BufReader::with_capacity(buffer.len(), f);
+                loop {
+                    match reader.read(&mut buffer) {
+                        Ok(0) => break,
+                        Ok(n) => hasher.update(&buffer[..n]),
+                        Err(ref err) if err.kind() == io::ErrorKind::Interrupted => continue,
+                        Err(err) => return Err(err.into()),
+                    };
+                }
 
-        // Add the tag to generate the persistent cache task id.
-        if let Some(tag) = tag {
-            hasher.update(tag.as_bytes());
+                // Add the tag to generate the persistent cache task id.
+                if let Some(tag) = tag {
+                    hasher.update(tag.as_bytes());
+                }
+
+                // Add the application to generate the persistent cache task id.
+                if let Some(application) = application {
+                    hasher.update(application.as_bytes());
+                }
+
+                // Add the piece length to generate the persistent cache task id.
+                if let Some(piece_length) = piece_length {
+                    hasher.update(piece_length.to_string().as_bytes());
+                }
+
+                hasher.update(TaskType::PersistentCache.as_str_name().as_bytes());
+
+                // Generate the task id by crc32.
+                Ok(hasher.finalize().to_string())
+            }
         }
-
-        // Add the application to generate the persistent cache task id.
-        if let Some(application) = application {
-            hasher.update(application.as_bytes());
-        }
-
-        // Generate the persistent cache task id.
-        Ok(hasher.finalize().to_hex().to_string())
     }
 
     /// peer_id generates the peer id.
-    #[instrument(skip_all)]
+    #[inline]
     pub fn peer_id(&self) -> String {
         if self.is_seed_peer {
             return format!(
@@ -156,7 +228,6 @@ impl IDGenerator {
     }
 
     /// task_type generates the task type by the task id.
-    #[instrument(skip_all)]
     pub fn task_type(&self, id: &str) -> TaskType {
         if id.ends_with(PERSISTENT_CACHE_TASK_SUFFIX) {
             return TaskType::PersistentCache;
@@ -165,3 +236,210 @@ impl IDGenerator {
         TaskType::Standard
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs::File;
+    use std::io::Write;
+    use tempfile::tempdir;
+
+    #[test]
+    fn should_generate_host_id() {
+        let test_cases = vec![
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                "127.0.0.1-localhost",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), true),
+                "127.0.0.1-localhost-seed",
+            ),
+        ];
+
+        for (generator, expected) in test_cases {
+            assert_eq!(generator.host_id(), expected);
+        }
+    }
+
+    #[test]
+    fn should_generate_task_id() {
+        let test_cases = vec![
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com".to_string(),
+                    piece_length: Some(1024_u64),
+                    tag: Some("foo".to_string()),
+                    application: Some("bar".to_string()),
+                    filtered_query_params: vec![],
+                },
+                "27554d06dfc788c2c2c60e01960152ffbd4b145fc103fcb80b432b4dc238a6fe",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com".to_string(),
+                    piece_length: None,
+                    tag: Some("foo".to_string()),
+                    application: Some("bar".to_string()),
+                    filtered_query_params: vec![],
+                },
+                "06408fbf247ddaca478f8cb9565fe5591c28efd0994b8fea80a6a87d3203c5ca",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com".to_string(),
+                    piece_length: None,
+                    tag: Some("foo".to_string()),
+                    application: None,
+                    filtered_query_params: vec![],
+                },
+                "3c3f230ef9f191dd2821510346a7bc138e4894bee9aee184ba250a3040701d2a",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com".to_string(),
+                    piece_length: None,
+                    tag: None,
+                    application: Some("bar".to_string()),
+                    filtered_query_params: vec![],
+                },
+                "c9f9261b7305c24371244f9f149f5d4589ed601348fdf22d7f6f4b10658fdba2",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com".to_string(),
+                    piece_length: Some(1024_u64),
+                    tag: None,
+                    application: None,
+                    filtered_query_params: vec![],
+                },
+                "9f7c9aafbc6f30f8f41a96ca77eeae80c5b60964b3034b0ee43ccf7b2f9e52b8",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::URLBased {
+                    url: "https://example.com?foo=foo&bar=bar".to_string(),
+                    piece_length: None,
+                    tag: None,
+                    application: None,
+                    filtered_query_params: vec!["foo".to_string(), "bar".to_string()],
+                },
+                "457b4328cde278e422c9e243f7bfd1e97f511fec43a80f535cf6b0ef6b086776",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                TaskIDParameter::Content("This is a test file".to_string()),
+                "e2d0fe1585a63ec6009c8016ff8dda8b17719a637405a4e23c0ff81339148249",
+            ),
+        ];
+
+        for (generator, parameter, expected_id) in test_cases {
+            let task_id = generator.task_id(parameter).unwrap();
+            assert_eq!(task_id, expected_id);
+        }
+    }
+
+    #[test]
+    fn should_generate_persistent_cache_task_id() {
+        let dir = tempdir().unwrap();
+        let file_path = dir.path().join("testfile");
+        let mut f = File::create(&file_path).unwrap();
+        f.write_all("This is a test file".as_bytes()).unwrap();
+
+        let test_cases = vec![
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                PersistentCacheTaskIDParameter::FileContentBased {
+                    path: file_path.clone(),
+                    piece_length: Some(1024_u64),
+                    tag: Some("tag1".to_string()),
+                    application: Some("app1".to_string()),
+                },
+                "3490958009",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                PersistentCacheTaskIDParameter::FileContentBased {
+                    path: file_path.clone(),
+                    piece_length: None,
+                    tag: None,
+                    application: Some("app1".to_string()),
+                },
+                "735741469",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                PersistentCacheTaskIDParameter::FileContentBased {
+                    path: file_path.clone(),
+                    piece_length: None,
+                    tag: Some("tag1".to_string()),
+                    application: None,
+                },
+                "3954905097",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                PersistentCacheTaskIDParameter::FileContentBased {
+                    path: file_path.clone(),
+                    piece_length: Some(1024_u64),
+                    tag: None,
+                    application: None,
+                },
+                "4162557545",
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                PersistentCacheTaskIDParameter::Content("This is a test file".to_string()),
+                "107352521",
+            ),
+        ];
+
+        for (generator, parameter, expected_id) in test_cases {
+            let task_id = generator.persistent_cache_task_id(parameter).unwrap();
+            assert_eq!(task_id, expected_id);
+        }
+    }
+
+    #[test]
+    fn should_generate_peer_id() {
+        let test_cases = vec![
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false),
+                false,
+            ),
+            (
+                IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), true),
+                true,
+            ),
+        ];
+
+        for (generator, is_seed_peer) in test_cases {
+            let peer_id = generator.peer_id();
+            assert!(peer_id.starts_with("127.0.0.1-localhost-"));
+            if is_seed_peer {
+                assert!(peer_id.ends_with("-seed"));
+            }
+        }
+    }
+
+    #[test]
+    fn should_generate_task_type() {
+        let test_cases = vec![
+            ("some-task-id", TaskType::Standard),
+            (
+                "some-task-id-persistent-cache-task",
+                TaskType::PersistentCache,
+            ),
+        ];
+
+        let generator = IDGenerator::new("127.0.0.1".to_string(), "localhost".to_string(), false);
+        for (id, expected_type) in test_cases {
+            assert_eq!(generator.task_type(id), expected_type);
+        }
+    }
+}

dragonfly-client-util/src/lib.rs

@@ -15,6 +15,8 @@
  */
 
 pub mod digest;
+pub mod fs;
 pub mod http;
 pub mod id_generator;
+pub mod net;
 pub mod tls;

dragonfly-client-util/src/net/mod.rs

@@ -0,0 +1,230 @@
+/*
+ *     Copyright 2025 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use bytesize::ByteSize;
+use pnet::datalink::{self, NetworkInterface};
+use std::cmp::min;
+use std::net::IpAddr;
+use std::sync::Arc;
+use std::time::Duration;
+use sysinfo::Networks;
+use tokio::sync::Mutex;
+use tracing::{info, warn};
+
+/// Interface represents a network interface with its information.
+#[derive(Debug, Clone, Default)]
+pub struct Interface {
+    /// name is the name of the network interface.
+    pub name: String,
+
+    /// bandwidth is the bandwidth of the network interface in bps.
+    pub bandwidth: u64,
+
+    // network_data_mutex is a mutex to protect access to network data.
+    network_data_mutex: Arc<Mutex<()>>,
+}
+
+/// NetworkData represents the network data for a specific interface,
+#[derive(Debug, Clone, Default)]
+pub struct NetworkData {
+    /// max_rx_bandwidth is the maximum receive bandwidth of the interface in bps.
+    pub max_rx_bandwidth: u64,
+
+    /// rx_bandwidth is the current receive bandwidth of the interface in bps.
+    pub rx_bandwidth: Option<u64>,
+
+    /// max_tx_bandwidth is the maximum transmit bandwidth of the interface in bps.
+    pub max_tx_bandwidth: u64,
+
+    /// tx_bandwidth is the current transmit bandwidth of the interface in bps.
+    pub tx_bandwidth: Option<u64>,
+}
+
+/// Interface methods provide functionality to get network interface information.
+impl Interface {
+    /// DEFAULT_NETWORKS_REFRESH_INTERVAL is the default interval for refreshing network data.
+    const DEFAULT_NETWORKS_REFRESH_INTERVAL: Duration = Duration::from_secs(2);
+
+    /// new creates a new Interface instance based on the provided IP address and rate limit.
+    pub fn new(ip: IpAddr, rate_limit: ByteSize) -> Interface {
+        let rate_limit = Self::byte_size_to_bits(rate_limit); // convert to bps
+        let Some(interface) = Self::get_network_interface_by_ip(ip) else {
+            warn!(
+            "can not find interface for IP address {}, network interface unknown with bandwidth {} bps",
+            ip, rate_limit
+        );
+            return Interface {
+                name: "unknown".to_string(),
+                bandwidth: rate_limit,
+                network_data_mutex: Arc::new(Mutex::new(())),
+            };
+        };
+
+        match Self::get_speed(&interface.name) {
+            Some(speed) => {
+                let bandwidth = min(Self::megabits_to_bits(speed), rate_limit);
+                info!(
+                    "network interface {} with bandwidth {} bps",
+                    interface.name, bandwidth
+                );
+
+                Interface {
+                    name: interface.name,
+                    bandwidth,
+                    network_data_mutex: Arc::new(Mutex::new(())),
+                }
+            }
+            None => {
+                warn!(
+                    "can not get speed, network interface {} with bandwidth {} bps",
+                    interface.name, rate_limit
+                );
+
+                Interface {
+                    name: interface.name,
+                    bandwidth: rate_limit,
+                    network_data_mutex: Arc::new(Mutex::new(())),
+                }
+            }
+        }
+    }
+
+    /// get_network_data retrieves the network data for the interface.
+    pub async fn get_network_data(&self) -> NetworkData {
+        // Lock the mutex to ensure exclusive access to network data.
+        let _guard = self.network_data_mutex.lock().await;
+
+        // Initialize sysinfo network.
+        let mut networks = Networks::new_with_refreshed_list();
+
+        // Sleep to calculate the network traffic difference over
+        // the DEFAULT_NETWORKS_REFRESH_INTERVAL.
+        tokio::time::sleep(Self::DEFAULT_NETWORKS_REFRESH_INTERVAL).await;
+
+        // Refresh network information.
+        networks.refresh();
+        let Some(network_data) = networks.get(self.name.as_str()) else {
+            warn!("can not find network data for interface {}", self.name);
+            return NetworkData {
+                max_rx_bandwidth: self.bandwidth,
+                max_tx_bandwidth: self.bandwidth,
+                ..Default::default()
+            };
+        };
+
+        // Calculate the receive and transmit bandwidth in bits per second.
+        let rx_bandwidth = (Self::bytes_to_bits(network_data.received()) as f64
+            / Self::DEFAULT_NETWORKS_REFRESH_INTERVAL.as_secs_f64())
+        .round() as u64;
+
+        // Calculate the transmit bandwidth in bits per second.
+        let tx_bandwidth = (Self::bytes_to_bits(network_data.transmitted()) as f64
+            / Self::DEFAULT_NETWORKS_REFRESH_INTERVAL.as_secs_f64())
+        .round() as u64;
+
+        NetworkData {
+            max_rx_bandwidth: self.bandwidth,
+            rx_bandwidth: Some(rx_bandwidth),
+            max_tx_bandwidth: self.bandwidth,
+            tx_bandwidth: Some(tx_bandwidth),
+        }
+    }
+
+    /// get_speed returns the speed of the network interface in Mbps.
+    pub fn get_speed(name: &str) -> Option<u64> {
+        #[cfg(target_os = "linux")]
+        {
+            let speed_path = format!("/sys/class/net/{}/speed", name);
+            std::fs::read_to_string(&speed_path)
+                .ok()
+                .and_then(|speed_str| speed_str.trim().parse::<u64>().ok())
+        }
+
+        #[cfg(not(target_os = "linux"))]
+        {
+            warn!("can not get interface {} speed on non-linux platform", name);
+            None
+        }
+    }
+
+    /// get_network_interface_by_ip returns the network interface that has the specified
+    /// IP address.
+    pub fn get_network_interface_by_ip(ip: IpAddr) -> Option<NetworkInterface> {
+        datalink::interfaces()
+            .into_iter()
+            .find(|interface| interface.ips.iter().any(|ip_net| ip_net.ip() == ip))
+    }
+
+    /// byte_size_to_bits converts a ByteSize to bits.
+    pub fn byte_size_to_bits(size: ByteSize) -> u64 {
+        size.as_u64() * 8
+    }
+
+    /// megabits_to_bit converts megabits to bits.
+    pub fn megabits_to_bits(size: u64) -> u64 {
+        size * 1_000_000 // 1 Mbit = 1,000,000 bits
+    }
+
+    /// bytes_to_bits converts bytes to bits.
+    pub fn bytes_to_bits(size: u64) -> u64 {
+        size * 8 // 1 byte = 8 bits
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytesize::ByteSize;
+
+    #[test]
+    fn test_byte_size_to_bits() {
+        let test_cases = vec![
+            (ByteSize::kb(1), 8_000u64),
+            (ByteSize::mb(1), 8_000_000u64),
+            (ByteSize::gb(1), 8_000_000_000u64),
+            (ByteSize::b(0), 0u64),
+        ];
+
+        for (input, expected) in test_cases {
+            let result = Interface::byte_size_to_bits(input);
+            assert_eq!(result, expected);
+        }
+    }
+
+    #[test]
+    fn test_megabits_to_bits() {
+        let test_cases = vec![
+            (1u64, 1_000_000u64),
+            (1000u64, 1_000_000_000u64),
+            (0u64, 0u64),
+        ];
+
+        for (input, expected) in test_cases {
+            let result = Interface::megabits_to_bits(input);
+            assert_eq!(result, expected);
+        }
+    }
+
+    #[test]
+    fn test_bytes_to_bits() {
+        let test_cases = vec![(1u64, 8u64), (1000u64, 8_000u64), (0u64, 0u64)];
+
+        for (input, expected) in test_cases {
+            let result = Interface::bytes_to_bits(input);
+            assert_eq!(result, expected);
+        }
+    }
+}

dragonfly-client-util/src/tls/mod.rs

@@ -16,14 +16,35 @@
 
 use dragonfly_client_core::error::{ErrorType, OrErr};
 use dragonfly_client_core::{Error as ClientError, Result as ClientResult};
+use lazy_static::lazy_static;
+use lru::LruCache;
 use rcgen::{Certificate, CertificateParams, KeyPair};
 use rustls_pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime};
+use std::num::NonZeroUsize;
 use std::path::PathBuf;
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::vec::Vec;
 use std::{fs, io};
 use tracing::instrument;
 
+/// DEFAULT_CERTS_CACHE_CAPACITY is the default capacity of the certificates cache.
+const DEFAULT_CERTS_CACHE_CAPACITY: usize = 1000;
+
+/// CertKeyPair is the type of the certificate and private key pair.
+type CertKeyPair = (Vec<CertificateDer<'static>>, PrivateKeyDer<'static>);
+
+lazy_static! {
+    /// SELF_SIGNED_CERTS is a map that stores the self-signed certificates to avoid
+    /// generating the same certificates multiple times.
+    static ref SELF_SIGNED_CERTS: Arc<Mutex<LruCache<String, CertKeyPair>>> =
+        Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(DEFAULT_CERTS_CACHE_CAPACITY).unwrap())));
+
+    /// SIMPLE_SELF_SIGNED_CERTS is a map that stores the simple self-signed certificates to avoid
+    /// generating the same certificates multiple times.
+    static ref SIMPLE_SELF_SIGNED_CERTS: Arc<Mutex<LruCache<String, CertKeyPair>>> =
+        Arc::new(Mutex::new(LruCache::new(NonZeroUsize::new(DEFAULT_CERTS_CACHE_CAPACITY).unwrap())));
+}
+
 /// NoVerifier is a verifier that does not verify the server certificate.
 /// It is used for testing and should not be used in production.
 #[derive(Debug)]
@@ -124,8 +145,15 @@ pub fn generate_cert_from_pem(cert_path: &PathBuf) -> ClientResult<Vec<Certifica
 #[instrument(skip_all)]
 pub fn generate_self_signed_certs_by_ca_cert(
     ca_cert: &Certificate,
+    host: &str,
     subject_alt_names: Vec<String>,
 ) -> ClientResult<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
+    let mut cache = SELF_SIGNED_CERTS.lock().unwrap();
+    if let Some((certs, key)) = cache.get(host) {
+        return Ok((certs.clone(), key.clone_key()));
+    };
+    drop(cache);
+
     // Sign certificate with CA certificate by given subject alternative names.
     let params = CertificateParams::new(subject_alt_names);
     let cert = Certificate::from_params(params).or_err(ErrorType::CertificateError)?;
@@ -143,14 +171,23 @@ pub fn generate_self_signed_certs_by_ca_cert(
     let key = rustls_pemfile::private_key(&mut key_pem_reader)?
         .ok_or_else(|| ClientError::Unknown("failed to load private key".to_string()))?;
 
+    let mut cache = SELF_SIGNED_CERTS.lock().unwrap();
+    cache.push(host.to_string(), (certs.clone(), key.clone_key()));
     Ok((certs, key))
 }
 
 /// generate_simple_self_signed_certs generates a simple self-signed certificates
 #[instrument(skip_all)]
 pub fn generate_simple_self_signed_certs(
+    host: &str,
     subject_alt_names: impl Into<Vec<String>>,
 ) -> ClientResult<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
+    let mut cache = SIMPLE_SELF_SIGNED_CERTS.lock().unwrap();
+    if let Some((certs, key)) = cache.get(host) {
+        return Ok((certs.clone(), key.clone_key()));
+    };
+    drop(cache);
+
     let cert = rcgen::generate_simple_self_signed(subject_alt_names)
         .or_err(ErrorType::CertificateError)?;
     let key = rustls_pki_types::PrivateKeyDer::Pkcs8(cert.serialize_private_key_der().into());
@@ -159,6 +196,8 @@ pub fn generate_simple_self_signed_certs(
         .or_err(ErrorType::CertificateError)?
         .into()];
 
+    let mut cache = SIMPLE_SELF_SIGNED_CERTS.lock().unwrap();
+    cache.push(host.to_string(), (certs.clone(), key.clone_key()));
     Ok((certs, key))
 }
 
@@ -181,7 +220,8 @@ pub fn raw_certs_to_certs(raw_certs: Vec<Vec<u8>>) -> Vec<CertificateDer<'static
 #[instrument(skip_all)]
 pub fn load_certs_from_pem(cert_pem: &str) -> ClientResult<Vec<CertificateDer<'static>>> {
     let certs = rustls_pemfile::certs(&mut cert_pem.as_bytes()).collect::<Result<Vec<_>, _>>()?;
-    return Ok(certs);
+
+    Ok(certs)
 }
 
 /// load_key_from_pem loads private key from PEM format string.
@@ -189,5 +229,197 @@ pub fn load_certs_from_pem(cert_pem: &str) -> ClientResult<Vec<CertificateDer<'s
 pub fn load_key_from_pem(key_pem: &str) -> ClientResult<PrivateKeyDer<'static>> {
     let key = rustls_pemfile::private_key(&mut key_pem.as_bytes())?
         .ok_or_else(|| ClientError::Unknown("failed to load private key".to_string()))?;
-    return Ok(key);
+
+    Ok(key)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rustls::client::danger::ServerCertVerifier;
+    use rustls_pki_types::{CertificateDer, ServerName, UnixTime};
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    // Generate the certificate and private key by script(`scripts/generate_certs.sh`).
+    const SERVER_CERT: &str = r#"""
+-----BEGIN CERTIFICATE-----
+MIIDsDCCApigAwIBAgIUWuckNOpaPERz+QMACyqCqFJwYIYwDQYJKoZIhvcNAQEL
+BQAwYjELMAkGA1UEBhMCQ04xEDAOBgNVBAgMB0JlaWppbmcxEDAOBgNVBAcMB0Jl
+aWppbmcxEDAOBgNVBAoMB1Rlc3QgQ0ExCzAJBgNVBAsMAklUMRAwDgYDVQQDDAdU
+ZXN0IENBMB4XDTI0MTAxMTEyMTEwN1oXDTI2MDIyMzEyMTEwN1owaDELMAkGA1UE
+BhMCQ04xEDAOBgNVBAgMB0JlaWppbmcxEDAOBgNVBAcMB0JlaWppbmcxFDASBgNV
+BAoMC1Rlc3QgU2VydmVyMQswCQYDVQQLDAJJVDESMBAGA1UEAwwJbG9jYWxob3N0
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAiA9wEge3Jq8qw8Ix9z6t
+ss7ttK/49TMddhnQuqoYrFKjYliuvfbRZOU1nBP7+5XSAliPDCRNPS17JSwsXJk2
+bstc69fruDpYmthualSTsUYSwJJqzJjy5mlwSPtBsombcSHrUasMce5C4iXJX8Wx
+1O8ZCwuI5LUKxLujt+ZWnYfp5lzDcDhgD6wIzcMk67jv2edcWhqGkKmQbbmmK3Ve
+DJRa56NCh0F2U1SW0KCXTzoC1YU/bbB4UCfvHouMzCRNTr3VcrfL5aBIn/z/f6Xt
+atQkqFa/T1/lOQ0miMqNyBW58NxkPsTaJm2kVZ21hF2Dvo8MU/8Ras0J0aL8sc4n
+LwIDAQABo1gwVjAUBgNVHREEDTALgglsb2NhbGhvc3QwHQYDVR0OBBYEFJP+jy8a
+tCfnu6nekyZugvq8XT2gMB8GA1UdIwQYMBaAFOwXKq7J6STkwLUWC1xKwq1Psy63
+MA0GCSqGSIb3DQEBCwUAA4IBAQCu8nqnuzNn3E9dNC8ptV7ga1zb7cGdL3ZT5W3d
+10gmPo3YijWoCj4snattX9zxI8ThAY7uX6jrR0/HRXGJIw5JnlBmykdgyrQYEDzU
+FUL0GGabJNxZ+zDV77P+3WdgCx3F7wLQk+x+etMPvYuWC8RMse7W6dB1INyMT/l6
+k1rV73KTupSNJrYhqw0RnmNHIctkwiZLLpzLFj91BHjK5ero7VV4s7vnx+gtO/zQ
+FnIyiyfYYcSpVMhhaNkeCtWOfgVYU/m4XXn5bwEOhMN6q0JcdBPnT6kd2otLhiIo
+/WeyWEUeZ4rQhS7C1i31AYtNtVnnvI7BrsI4czYdcJcj3CM+
+-----END CERTIFICATE-----
+"""#;
+
+    const SERVER_KEY: &str = r#"""
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCID3ASB7cmryrD
+wjH3Pq2yzu20r/j1Mx12GdC6qhisUqNiWK699tFk5TWcE/v7ldICWI8MJE09LXsl
+LCxcmTZuy1zr1+u4Olia2G5qVJOxRhLAkmrMmPLmaXBI+0GyiZtxIetRqwxx7kLi
+JclfxbHU7xkLC4jktQrEu6O35ladh+nmXMNwOGAPrAjNwyTruO/Z51xaGoaQqZBt
+uaYrdV4MlFrno0KHQXZTVJbQoJdPOgLVhT9tsHhQJ+8ei4zMJE1OvdVyt8vloEif
+/P9/pe1q1CSoVr9PX+U5DSaIyo3IFbnw3GQ+xNombaRVnbWEXYO+jwxT/xFqzQnR
+ovyxzicvAgMBAAECggEABqHVkTfe1p+PBGx34tG/4nQxwIRxLJG31no+jeAdYOLF
+AEeulqezbmIroyTMA0uQKWscy0V/gXUi3avHOOktp72Vv9fxy98F/fyBPx3YEvLa
+69DMnl0qPl06CvLlTey6km8RKxUrRq9S2NoTydD+m1fC9jCIhvHkrNExIXjtaewU
+PvAHJy4ho+hVLo40udmQ4i1gnEWYUtjkr65ujuOAlWrlScHGvOrATbrfcaufPi/S
+5A/h8UlfahBstmh3a2tBLZlNl82s5ZKsVM1Oq1Vk9hAX5DP2JBAmuZKgX/xSDdpR
+62VUQGqp1WLgble5vR6ZUFo5+Jiw1uxe9jmNUg9mMQKBgQC8giG3DeeU6+rX9LVz
+cklF4jioU5LMdYutwXbtuGIWgXeJo8r0fzrgBtBVGRn7anS7YnYA+67h+A8SC6MO
+SXvktpHIC3Egge2Q9dRrWA4YCpkIxlOQ5ofCqovvCg9kq9sYqGz6lMr3RrzOWkUW
++0hF1CHCV0+KGFeIvTYVIKSsJwKBgQC4xiTsaShmwJ6HdR59jOmij+ccCPQTt2IO
+eGcniY2cHIoX9I7nn7Yah6JbMT0c8j75KA+pfCrK3FpRNrb71cI1iqBHedZXpRaV
+eshJztmw3AKtxQPNwRYrKYpY/M0ShAduppELeshZz1kubQU3sD4adrhcGCDXkctb
+dP44IpipuQKBgC+W5q4Q65L0ECCe3aQciRUEbGtKVfgaAL5H5h9TeifWXXg5Coa5
+DAL8lWG2aZHIKVoZHFNZNqhDeIKEv5BeytFNqfYHtXKQeoorFYpX+47kNgg6EWS2
+XjWt2o/pSUOQA0rxUjnckHTmvcmWjnSj0XYXfMJUSndBd+/EXL/ussPnAoGAGE5Q
+Wxz2KJYcBHuemCtqLG07nI988/8Ckh66ixPoIeoLLF2KUuPKg7Dl5ZMTk/Q13nar
+oMLpqifUZayJ45TZ6EslDGH1lS/tSZqOME9aiY5Xd95bwrwsm17qiQwwOchOZfrZ
+R6ZOJqpE8/t5XTr84GRPmiW+ZD0UgCJisqWyaVkCgYEAtupQDst0hmZ0KnJSIZ5U
+R6skHABhmwNU5lOPUBIzHVorbAaKDKd4iFbBI5wnBuWxXY0SANl2HYX3gZaPccH4
+wzvR3jZ1B4UlEBXl2V+VRbrXyPTN4uUF42AkSGuOsK4O878wW8noX+ZZTk7gydTN
+Z+yQ5jhu/fmSBNhqO/8Lp+Y=
+-----END PRIVATE KEY-----
+"""#;
+
+    #[test]
+    fn test_no_verifier() {
+        let verifier = NoVerifier::new();
+
+        // Test verify_server_cert
+        let result = verifier.verify_server_cert(
+            &CertificateDer::from(vec![]),
+            &[],
+            &ServerName::DnsName("d7y.io".try_into().unwrap()),
+            &[],
+            UnixTime::now(),
+        );
+        assert!(result.is_ok());
+
+        // Test supported_verify_schemes
+        let schemes = verifier.supported_verify_schemes();
+        assert!(!schemes.is_empty());
+    }
+
+    #[test]
+    fn test_generate_ca_cert_from_pem() {
+        let ca_cert_file = NamedTempFile::new().unwrap();
+        let ca_key_file = NamedTempFile::new().unwrap();
+
+        ca_cert_file
+            .as_file()
+            .write_all(SERVER_CERT.as_bytes())
+            .unwrap();
+        ca_key_file
+            .as_file()
+            .write_all(SERVER_KEY.as_bytes())
+            .unwrap();
+
+        let result = generate_ca_cert_from_pem(
+            &ca_cert_file.path().to_path_buf(),
+            &ca_key_file.path().to_path_buf(),
+        );
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_generate_cert_from_pem() {
+        let cert_file = NamedTempFile::new().unwrap();
+        cert_file
+            .as_file()
+            .write_all(SERVER_CERT.as_bytes())
+            .unwrap();
+
+        let result = generate_cert_from_pem(&cert_file.path().to_path_buf());
+        assert!(result.is_ok());
+        assert!(!result.unwrap().is_empty());
+    }
+
+    #[test]
+    fn test_generate_self_signed_certs_by_ca_cert() {
+        let ca_cert_file = NamedTempFile::new().unwrap();
+        let ca_key_file = NamedTempFile::new().unwrap();
+
+        ca_cert_file
+            .as_file()
+            .write_all(SERVER_CERT.as_bytes())
+            .unwrap();
+        ca_key_file
+            .as_file()
+            .write_all(SERVER_KEY.as_bytes())
+            .unwrap();
+
+        let ca_cert = generate_ca_cert_from_pem(
+            &ca_cert_file.path().to_path_buf(),
+            &ca_key_file.path().to_path_buf(),
+        )
+        .unwrap();
+        let host = "example.com";
+        let subject_alt_names = vec![host.to_string()];
+
+        let result = generate_self_signed_certs_by_ca_cert(&ca_cert, host, subject_alt_names);
+        assert!(result.is_ok());
+        let (certs, key) = result.unwrap();
+        assert!(!certs.is_empty());
+        assert!(matches!(key, PrivateKeyDer::Pkcs8(_)));
+    }
+
+    #[test]
+    fn test_certs_to_raw_certs() {
+        let cert_file = NamedTempFile::new().unwrap();
+        cert_file
+            .as_file()
+            .write_all(SERVER_CERT.as_bytes())
+            .unwrap();
+
+        let certs = generate_cert_from_pem(&cert_file.path().to_path_buf()).unwrap();
+
+        let raw_certs = certs_to_raw_certs(certs);
+        assert!(!raw_certs.is_empty());
+    }
+
+    #[test]
+    fn test_raw_certs_to_certs() {
+        let cert_file = NamedTempFile::new().unwrap();
+        cert_file
+            .as_file()
+            .write_all(SERVER_CERT.as_bytes())
+            .unwrap();
+
+        let certs = generate_cert_from_pem(&cert_file.path().to_path_buf()).unwrap();
+        let raw_certs = certs_to_raw_certs(certs);
+
+        let certs = raw_certs_to_certs(raw_certs);
+        assert!(!certs.is_empty());
+    }
+
+    #[test]
+    fn test_load_certs_from_pem() {
+        let result = load_certs_from_pem(SERVER_CERT);
+        assert!(result.is_ok());
+        assert!(!result.unwrap().is_empty());
+    }
+
+    #[test]
+    fn test_load_key_from_pem() {
+        let result = load_key_from_pem(SERVER_KEY);
+        assert!(result.is_ok());
+        assert!(matches!(result.unwrap(), PrivateKeyDer::Pkcs8(_)));
+    }
 }

dragonfly-client/Cargo.toml

@@ -18,10 +18,6 @@ path = "src/bin/dfdaemon/main.rs"
 name = "dfget"
 path = "src/bin/dfget/main.rs"
 
-[[bin]]
-name = "dfstore"
-path = "src/bin/dfstore/main.rs"
-
 [[bin]]
 name = "dfcache"
 path = "src/bin/dfcache/main.rs"
@@ -38,8 +34,6 @@ hyper.workspace = true
 hyper-util.workspace = true
 hyper-rustls.workspace = true
 tracing.workspace = true
-validator.workspace = true
-humantime.workspace = true
 serde.workspace = true
 chrono.workspace = true
 prost-wkt-types.workspace = true
@@ -49,6 +43,7 @@ rustls.workspace = true
 rustls-pki-types.workspace = true
 warp.workspace = true
 tonic.workspace = true
+tonic-reflection.workspace = true
 tokio-stream.workspace = true
 reqwest.workspace = true
 url.workspace = true
@@ -56,40 +51,42 @@ http.workspace = true
 openssl.workspace = true
 clap.workspace = true
 anyhow.workspace = true
-blake3.workspace = true
+bytes.workspace = true
 bytesize.workspace = true
+humantime.workspace = true
 uuid.workspace = true
 percent-encoding.workspace = true
-lazy_static.workspace = true
 tokio-rustls.workspace = true
-serde_json = "1.0"
-tracing-log = "0.2"
-tracing-subscriber = { version = "0.3", features = ["env-filter", "time", "chrono"] }
+serde_json.workspace = true
+fs2.workspace = true
+lazy_static.workspace = true
+futures.workspace = true
+local-ip-address.workspace = true
+sysinfo.workspace = true
 tracing-appender = "0.2.3"
+tracing-subscriber = { version = "0.3", features = ["env-filter", "time", "chrono"] }
+tracing-panic = "0.1.2"
+tracing-opentelemetry = "0.30.0"
+opentelemetry = { version = "0.29.1", default-features = false, features = ["trace"] }
+opentelemetry-otlp = { version = "0.29.0", default-features = false, features = ["trace", "grpc-tonic", "http-proto", "reqwest-blocking-client"] }
+opentelemetry_sdk = { version = "0.29.0", default-features = false, features = ["trace", "rt-tokio"] }
+opentelemetry-semantic-conventions = { version = "0.30.0", features = ["semconv_experimental"] }
 rolling-file = "0.2.0"
-tracing-opentelemetry = "0.18.0"
-tracing-flame = "0.2.0"
-opentelemetry = { version = "0.18.0", default-features = false, features = ["trace", "rt-tokio"] }
-opentelemetry-jaeger = { version = "0.17.0", features = ["rt-tokio"] }
-pprof = { version = "0.13", features = ["flamegraph", "protobuf-codec"] }
+pprof = { version = "0.15", features = ["flamegraph", "protobuf-codec"] }
 prometheus = { version = "0.13", features = ["process"] }
 tonic-health = "0.12.3"
-tonic-reflection = "0.12.3"
-bytes = "1.7"
-sysinfo = "0.32.0"
-tower = "0.4.13"
-indicatif = "0.17.8"
-dashmap = "6.1.0"
-fs2 = "0.4.3"
+tower = { version = "0.4.13", features = ["limit", "load-shed", "buffer"] }
+indicatif = "0.18.0"
 hashring = "0.3.6"
-libc = "0.2"
-fslock = "0.2.1"
 leaky-bucket = "1.1.2"
-http-body-util = "0.1.2"
-futures-util = "0.3.30"
-termion = "4.0.3"
-tabled = "0.16.0"
+http-body-util = "0.1.3"
+termion = "4.0.5"
+tabled = "0.20.0"
 path-absolutize = "3.1.1"
+dashmap = "6.1.0"
+fastrand = "2.3.0"
+glob = "0.3.3"
+console-subscriber = "0.4.1"
 
 [dev-dependencies]
 tempfile.workspace = true
@@ -120,21 +117,11 @@ assets = [
     "usr/bin/dfcache",
     "755",
   ],
-  [
-    "../target/x86_64-unknown-linux-gnu/release/dfstore",
-    "usr/bin/dfstore",
-    "755",
-  ],
   [
     "../ci/dfdaemon.service",
     "lib/systemd/system/dfdaemon.service",
     "644",
   ],
-  [
-    "../ci/dfdaemon.yaml",
-    "etc/dragonfly/dfdaemon.yaml",
-    "644",
-  ],
   [
     "../CONTRIBUTING.md",
     "usr/share/doc/client/CONTRIBUTING.md",
@@ -172,21 +159,11 @@ assets = [
     "usr/bin/dfcache",
     "755",
   ],
-  [
-    "../target/x86_64-unknown-linux-musl/release/dfstore",
-    "usr/bin/dfstore",
-    "755",
-  ],
   [
     "../ci/dfdaemon.service",
     "lib/systemd/system/dfdaemon.service",
     "644",
   ],
-  [
-    "../ci/dfdaemon.yaml",
-    "etc/dragonfly/dfdaemon.yaml",
-    "644",
-  ],
   [
     "../CONTRIBUTING.md",
     "usr/share/doc/client/CONTRIBUTING.md",
@@ -224,21 +201,11 @@ assets = [
     "usr/bin/dfcache",
     "755",
   ],
-  [
-    "../target/aarch64-unknown-linux-gnu/release/dfstore",
-    "usr/bin/dfstore",
-    "755",
-  ],
   [
     "../ci/dfdaemon.service",
     "lib/systemd/system/dfdaemon.service",
     "644",
   ],
-  [
-    "../ci/dfdaemon.yaml",
-    "etc/dragonfly/dfdaemon.yaml",
-    "644",
-  ],
   [
     "../CONTRIBUTING.md",
     "usr/share/doc/client/CONTRIBUTING.md",
@@ -276,21 +243,11 @@ assets = [
     "usr/bin/dfcache",
     "755",
   ],
-  [
-    "../target/aarch64-unknown-linux-musl/release/dfstore",
-    "usr/bin/dfstore",
-    "755",
-  ],
   [
     "../ci/dfdaemon.service",
     "lib/systemd/system/dfdaemon.service",
     "644",
   ],
-  [
-    "../ci/dfdaemon.yaml",
-    "etc/dragonfly/dfdaemon.yaml",
-    "644",
-  ],
   [
     "../CONTRIBUTING.md",
     "usr/share/doc/client/CONTRIBUTING.md",
@@ -313,9 +270,7 @@ assets = [
   { source = "../target/x86_64-unknown-linux-gnu/release/dfget", dest = "/usr/bin/dfget", mode = "755" },
   { source = "../target/x86_64-unknown-linux-gnu/release/dfdaemon", dest = "/usr/bin/dfdaemon", mode = "755" },
   { source = "../target/x86_64-unknown-linux-gnu/release/dfcache", dest = "/usr/bin/dfcache", mode = "755" },
-  { source = "../target/x86_64-unknown-linux-gnu/release/dfstore", dest = "/usr/bin/dfstore", mode = "755" },
   { source = "../ci/dfdaemon.service", dest = "/lib/systemd/system/dfdaemon.service", config = true, mode = "644" },
-  { source = "../ci/dfdaemon.yaml", dest = "/etc/dragonfly/dfdaemon.yaml", mode = "644", config = true },
   { source = "../CONTRIBUTING.md", dest = "/usr/share/doc/client/CONTRIBUTING.md", mode = "644", doc = true },
   { source = "../LICENSE", dest = "/usr/share/doc/client/LICENSE.md", mode = "644", doc = true },
   { source = "../README.md", dest = "/usr/share/doc/client/README.md", mode = "644", doc = true },
@@ -326,22 +281,19 @@ assets = [
   { source = "../target/x86_64-unknown-linux-musl/release/dfget", dest = "/usr/bin/dfget", mode = "755" },
   { source = "../target/x86_64-unknown-linux-musl/release/dfdaemon", dest = "/usr/bin/dfdaemon", mode = "755" },
   { source = "../target/x86_64-unknown-linux-musl/release/dfcache", dest = "/usr/bin/dfcache", mode = "755" },
-  { source = "../target/x86_64-unknown-linux-musl/release/dfstore", dest = "/usr/bin/dfstore", mode = "755" },
   { source = "../ci/dfdaemon.service", dest = "/lib/systemd/system/dfdaemon.service", config = true, mode = "644" },
-  { source = "../ci/dfdaemon.yaml", dest = "/etc/dragonfly/dfdaemon.yaml", mode = "644", config = true },
   { source = "../CONTRIBUTING.md", dest = "/usr/share/doc/client/CONTRIBUTING.md", mode = "644", doc = true },
   { source = "../LICENSE", dest = "/usr/share/doc/client/LICENSE.md", mode = "644", doc = true },
   { source = "../README.md", dest = "/usr/share/doc/client/README.md", mode = "644", doc = true },
 ]
+auto-req = "no"
 
 [package.metadata.generate-rpm.variants.aarch64-unknown-linux-gnu]
 assets = [
   { source = "../target/aarch64-unknown-linux-gnu/release/dfget", dest = "/usr/bin/dfget", mode = "755" },
   { source = "../target/aarch64-unknown-linux-gnu/release/dfdaemon", dest = "/usr/bin/dfdaemon", mode = "755" },
   { source = "../target/aarch64-unknown-linux-gnu/release/dfcache", dest = "/usr/bin/dfcache", mode = "755" },
-  { source = "../target/aarch64-unknown-linux-gnu/release/dfstore", dest = "/usr/bin/dfstore", mode = "755" },
   { source = "../ci/dfdaemon.service", dest = "/lib/systemd/system/dfdaemon.service", config = true, mode = "644" },
-  { source = "../ci/dfdaemon.yaml", dest = "/etc/dragonfly/dfdaemon.yaml", mode = "644", config = true },
   { source = "../CONTRIBUTING.md", dest = "/usr/share/doc/client/CONTRIBUTING.md", mode = "644", doc = true },
   { source = "../LICENSE", dest = "/usr/share/doc/client/LICENSE.md", mode = "644", doc = true },
   { source = "../README.md", dest = "/usr/share/doc/client/README.md", mode = "644", doc = true },
@@ -352,10 +304,9 @@ assets = [
   { source = "../target/aarch64-unknown-linux-musl/release/dfget", dest = "/usr/bin/dfget", mode = "755" },
   { source = "../target/aarch64-unknown-linux-musl/release/dfdaemon", dest = "/usr/bin/dfdaemon", mode = "755" },
   { source = "../target/aarch64-unknown-linux-musl/release/dfcache", dest = "/usr/bin/dfcache", mode = "755" },
-  { source = "../target/aarch64-unknown-linux-musl/release/dfstore", dest = "/usr/bin/dfstore", mode = "755" },
   { source = "../ci/dfdaemon.service", dest = "/lib/systemd/system/dfdaemon.service", config = true, mode = "644" },
-  { source = "../ci/dfdaemon.yaml", dest = "/etc/dragonfly/dfdaemon.yaml", mode = "644", config = true },
   { source = "../CONTRIBUTING.md", dest = "/usr/share/doc/client/CONTRIBUTING.md", mode = "644", doc = true },
   { source = "../LICENSE", dest = "/usr/share/doc/client/LICENSE.md", mode = "644", doc = true },
   { source = "../README.md", dest = "/usr/share/doc/client/README.md", mode = "644", doc = true },
 ]
+auto-req = "no"

dragonfly-client/src/announcer/mod.rs

@@ -14,10 +14,9 @@
  * limitations under the License.
  */
 
-use crate::grpc::{manager::ManagerClient, scheduler::SchedulerClient};
+use crate::grpc::scheduler::SchedulerClient;
 use crate::shutdown;
 use dragonfly_api::common::v2::{Build, Cpu, Disk, Host, Memory, Network};
-use dragonfly_api::manager::v2::{DeleteSeedPeerRequest, SourceType, UpdateSeedPeerRequest};
 use dragonfly_api::scheduler::v2::{AnnounceHostRequest, DeleteHostRequest};
 use dragonfly_client_config::{
     dfdaemon::{Config, HostType},
@@ -25,90 +24,13 @@ use dragonfly_client_config::{
 };
 use dragonfly_client_core::error::{ErrorType, OrErr};
 use dragonfly_client_core::Result;
+use dragonfly_client_util::net::Interface;
 use std::env;
 use std::sync::Arc;
+use std::time::Duration;
 use sysinfo::System;
 use tokio::sync::mpsc;
-use tracing::{error, info, instrument};
-
-/// ManagerAnnouncer is used to announce the dfdaemon information to the manager.
-pub struct ManagerAnnouncer {
-    /// config is the configuration of the dfdaemon.
-    config: Arc<Config>,
-
-    /// manager_client is the grpc client of the manager.
-    manager_client: Arc<ManagerClient>,
-
-    /// shutdown is used to shutdown the announcer.
-    shutdown: shutdown::Shutdown,
-
-    /// _shutdown_complete is used to notify the announcer is shutdown.
-    _shutdown_complete: mpsc::UnboundedSender<()>,
-}
-
-/// ManagerAnnouncer implements the manager announcer of the dfdaemon.
-impl ManagerAnnouncer {
-    /// new creates a new manager announcer.
-    #[instrument(skip_all)]
-    pub fn new(
-        config: Arc<Config>,
-        manager_client: Arc<ManagerClient>,
-        shutdown: shutdown::Shutdown,
-        shutdown_complete_tx: mpsc::UnboundedSender<()>,
-    ) -> Self {
-        Self {
-            config,
-            manager_client,
-            shutdown,
-            _shutdown_complete: shutdown_complete_tx,
-        }
-    }
-
-    /// run announces the dfdaemon information to the manager.
-    #[instrument(skip_all)]
-    pub async fn run(&self) -> Result<()> {
-        // Clone the shutdown channel.
-        let mut shutdown = self.shutdown.clone();
-
-        // If the seed peer is enabled, we should announce the seed peer to the manager.
-        if self.config.seed_peer.enable {
-            // Register the seed peer to the manager.
-            self.manager_client
-                .update_seed_peer(UpdateSeedPeerRequest {
-                    source_type: SourceType::SeedPeerSource.into(),
-                    hostname: self.config.host.hostname.clone(),
-                    r#type: self.config.seed_peer.kind.to_string(),
-                    idc: self.config.host.idc.clone(),
-                    location: self.config.host.location.clone(),
-                    ip: self.config.host.ip.unwrap().to_string(),
-                    port: self.config.upload.server.port as i32,
-                    download_port: self.config.upload.server.port as i32,
-                    seed_peer_cluster_id: self.config.seed_peer.cluster_id,
-                })
-                .await?;
-
-            // Announce to scheduler shutting down with signals.
-            shutdown.recv().await;
-
-            // Delete the seed peer from the manager.
-            self.manager_client
-                .delete_seed_peer(DeleteSeedPeerRequest {
-                    source_type: SourceType::SeedPeerSource.into(),
-                    hostname: self.config.host.hostname.clone(),
-                    ip: self.config.host.ip.unwrap().to_string(),
-                    seed_peer_cluster_id: self.config.seed_peer.cluster_id,
-                })
-                .await?;
-
-            info!("announce to manager shutting down");
-        } else {
-            shutdown.recv().await;
-            info!("announce to manager shutting down");
-        }
-
-        Ok(())
-    }
-}
+use tracing::{debug, error, info, instrument};
 
 /// Announcer is used to announce the dfdaemon information to the manager and scheduler.
 pub struct SchedulerAnnouncer {
@@ -121,6 +43,9 @@ pub struct SchedulerAnnouncer {
     /// scheduler_client is the grpc client of the scheduler.
     scheduler_client: Arc<SchedulerClient>,
 
+    /// interface is the network interface.
+    interface: Arc<Interface>,
+
     /// shutdown is used to shutdown the announcer.
     shutdown: shutdown::Shutdown,
 
@@ -131,11 +56,11 @@ pub struct SchedulerAnnouncer {
 /// SchedulerAnnouncer implements the scheduler announcer of the dfdaemon.
 impl SchedulerAnnouncer {
     /// new creates a new scheduler announcer.
-    #[instrument(skip_all)]
     pub async fn new(
         config: Arc<Config>,
         host_id: String,
         scheduler_client: Arc<SchedulerClient>,
+        interface: Arc<Interface>,
         shutdown: shutdown::Shutdown,
         shutdown_complete_tx: mpsc::UnboundedSender<()>,
     ) -> Result<Self> {
@@ -143,6 +68,7 @@ impl SchedulerAnnouncer {
             config,
             host_id,
             scheduler_client,
+            interface,
             shutdown,
             _shutdown_complete: shutdown_complete_tx,
         };
@@ -150,13 +76,12 @@ impl SchedulerAnnouncer {
         // Initialize the scheduler announcer.
         announcer
             .scheduler_client
-            .init_announce_host(announcer.make_announce_host_request()?)
+            .init_announce_host(announcer.make_announce_host_request(Duration::ZERO).await?)
             .await?;
         Ok(announcer)
     }
 
     /// run announces the dfdaemon information to the scheduler.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();
@@ -166,7 +91,7 @@ impl SchedulerAnnouncer {
         loop {
             tokio::select! {
                 _ = interval.tick() => {
-                    let request = match self.make_announce_host_request() {
+                    let request = match self.make_announce_host_request(interval.period()).await {
                         Ok(request) => request,
                         Err(err) => {
                             error!("make announce host request failed: {}", err);
@@ -195,7 +120,7 @@ impl SchedulerAnnouncer {
 
     /// make_announce_host_request makes the announce host request.
     #[instrument(skip_all)]
-    fn make_announce_host_request(&self) -> Result<AnnounceHostRequest> {
+    async fn make_announce_host_request(&self, interval: Duration) -> Result<AnnounceHostRequest> {
         // If the seed peer is enabled, we should announce the seed peer to the scheduler.
         let host_type = if self.config.seed_peer.enable {
             self.config.seed_peer.kind
@@ -203,7 +128,7 @@ impl SchedulerAnnouncer {
             HostType::Normal
         };
 
-        // Get the system information.
+        // Refresh the system information.
         let mut sys = System::new_all();
         sys.refresh_all();
 
@@ -231,25 +156,25 @@ impl SchedulerAnnouncer {
             free: sys.free_memory(),
         };
 
+        // Wait for getting the network data.
+        let network_data = self.interface.get_network_data().await;
+        debug!(
+            "network data: rx bandwidth {}/{} bps, tx bandwidth {}/{} bps",
+            network_data.rx_bandwidth.unwrap_or(0),
+            network_data.max_rx_bandwidth,
+            network_data.tx_bandwidth.unwrap_or(0),
+            network_data.max_tx_bandwidth
+        );
+
         // Get the network information.
         let network = Network {
-            // TODO: Get the count of the tcp connection.
-            tcp_connection_count: 0,
-
-            // TODO: Get the count of the upload tcp connection.
-            upload_tcp_connection_count: 0,
             idc: self.config.host.idc.clone(),
             location: self.config.host.location.clone(),
-
-            // TODO: Get the network download rate, refer to
-            // https://docs.rs/sysinfo/latest/sysinfo/struct.NetworkData.html#method.received.
-            download_rate: 0,
-            download_rate_limit: self.config.download.rate_limit.as_u64(),
-
-            // TODO: Get the network download rate, refer to
-            // https://docs.rs/sysinfo/latest/sysinfo/struct.NetworkData.html#method.transmitted
-            upload_rate: 0,
-            upload_rate_limit: self.config.upload.rate_limit.as_u64(),
+            max_rx_bandwidth: network_data.max_rx_bandwidth,
+            rx_bandwidth: network_data.rx_bandwidth,
+            max_tx_bandwidth: network_data.max_tx_bandwidth,
+            tx_bandwidth: network_data.tx_bandwidth,
+            ..Default::default()
         };
 
         // Get the disk information.
@@ -259,11 +184,21 @@ impl SchedulerAnnouncer {
         let used_space = total_space - available_space;
         let used_percent = (used_space as f64 / (total_space) as f64) * 100.0;
 
+        let mut write_bandwidth = 0;
+        let mut read_bandwidth = 0;
+        if interval != Duration::ZERO {
+            let disk_usage = process.disk_usage();
+            write_bandwidth = disk_usage.written_bytes / interval.as_secs();
+            read_bandwidth = disk_usage.read_bytes / interval.as_secs();
+        };
+
         let disk = Disk {
             total: total_space,
             free: available_space,
             used: used_space,
             used_percent,
+            write_bandwidth,
+            read_bandwidth,
 
             // TODO: Get the disk inodes information.
             inodes_total: 0,

dragonfly-client/src/bin/dfcache/export.rs

@@ -23,13 +23,17 @@ use dragonfly_client_core::{
     error::{ErrorType, OrErr},
     Error, Result,
 };
+use dragonfly_client_util::fs::fallocate;
 use indicatif::{ProgressBar, ProgressState, ProgressStyle};
+use local_ip_address::local_ip;
 use path_absolutize::*;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use std::{cmp::min, fmt::Write};
 use termion::{color, style};
-use tracing::{error, info};
+use tokio::fs::{self, OpenOptions};
+use tokio::io::{AsyncSeekExt, AsyncWriteExt, SeekFrom};
+use tracing::{debug, error, info};
 
 use super::*;
 
@@ -39,6 +43,20 @@ pub struct ExportCommand {
     #[arg(help = "Specify the persistent cache task ID to export")]
     id: String,
 
+    #[arg(
+        long = "transfer-from-dfdaemon",
+        default_value_t = false,
+        help = "Specify whether to transfer the content of downloading file from dfdaemon's unix domain socket. If it is true, dfcache will call dfdaemon to download the file, and dfdaemon will return the content of downloading file to dfcache via unix domain socket, and dfcache will copy the content to the output path. If it is false, dfdaemon will download the file and hardlink or copy the file to the output path."
+    )]
+    transfer_from_dfdaemon: bool,
+
+    #[arg(
+        long = "force-hard-link",
+        default_value_t = false,
+        help = "Specify whether the download file must be hard linked to the output path. If hard link is failed, download will be failed. If it is false, dfdaemon will copy the file to the output path if hard link is failed."
+    )]
+    force_hard_link: bool,
+
     #[arg(
         long = "application",
         default_value = "",
@@ -67,15 +85,79 @@ pub struct ExportCommand {
         help = "Specify the timeout for exporting a file"
     )]
     timeout: Duration,
+
+    #[arg(
+        long = "digest",
+        required = false,
+        help = "Verify the integrity of the downloaded file using the specified digest, support sha256, sha512, crc32. If the digest is not specified, the downloaded file will not be verified. Format: <algorithm>:<digest>, e.g. sha256:1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef, crc32:12345678"
+    )]
+    digest: Option<String>,
+
+    #[arg(
+        short = 'e',
+        long = "endpoint",
+        default_value_os_t = dfdaemon::default_download_unix_socket_path(),
+        help = "Endpoint of dfdaemon's GRPC server"
+    )]
+    endpoint: PathBuf,
+
+    #[arg(
+        short = 'l',
+        long,
+        default_value = "info",
+        help = "Specify the logging level [trace, debug, info, warn, error]"
+    )]
+    log_level: Level,
+
+    #[arg(
+        long,
+        default_value_os_t = dfcache::default_dfcache_log_dir(),
+        help = "Specify the log directory"
+    )]
+    log_dir: PathBuf,
+
+    #[arg(
+        long,
+        default_value_t = 6,
+        help = "Specify the max number of log files"
+    )]
+    log_max_files: usize,
+
+    #[arg(long, default_value_t = false, help = "Specify whether to print log")]
+    console: bool,
 }
 
 /// Implement the execute for ExportCommand.
 impl ExportCommand {
-    /// execute executes the export command.
-    pub async fn execute(&self, endpoint: &Path) -> Result<()> {
+    /// Executes the export command with comprehensive validation and advanced error handling.
+    ///
+    /// This function serves as the main entry point for the dfcache export command execution.
+    /// It handles the complete workflow including argument parsing, validation, logging setup,
+    /// dfdaemon client connection, and export operation execution. The function provides
+    /// sophisticated error reporting with colored terminal output, including specialized
+    /// handling for backend errors with HTTP status codes and headers.
+    pub async fn execute(&self) -> Result<()> {
+        // Parse command line arguments.
+        Args::parse();
+
+        // Initialize tracing.
+        let _guards = init_tracing(
+            dfcache::NAME,
+            self.log_dir.clone(),
+            self.log_level,
+            self.log_max_files,
+            None,
+            None,
+            None,
+            None,
+            None,
+            false,
+            self.console,
+        );
+
         // Validate the command line arguments.
         if let Err(err) = self.validate_args() {
-            eprintln!(
+            println!(
                 "{}{}{}Validating Failed!{}",
                 color::Fg(color::Red),
                 style::Italic,
@@ -83,7 +165,7 @@ impl ExportCommand {
                 style::Reset
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}****************************************{}",
                 color::Fg(color::Black),
                 style::Italic,
@@ -91,7 +173,7 @@ impl ExportCommand {
                 style::Reset
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}Message:{} {}",
                 color::Fg(color::Cyan),
                 style::Italic,
@@ -100,7 +182,7 @@ impl ExportCommand {
                 err,
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}****************************************{}",
                 color::Fg(color::Black),
                 style::Italic,
@@ -113,10 +195,10 @@ impl ExportCommand {
 
         // Get dfdaemon download client.
         let dfdaemon_download_client =
-            match get_dfdaemon_download_client(endpoint.to_path_buf()).await {
+            match get_dfdaemon_download_client(self.endpoint.to_path_buf()).await {
                 Ok(client) => client,
                 Err(err) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Connect Dfdaemon Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -124,7 +206,7 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -132,17 +214,17 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{}, can not connect {}, please check the unix socket {}",
                         color::Fg(color::Cyan),
                         style::Italic,
                         style::Bold,
                         style::Reset,
                         err,
-                        endpoint.to_string_lossy(),
+                        self.endpoint.to_string_lossy(),
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -160,7 +242,7 @@ impl ExportCommand {
                 Error::TonicStatus(status) => {
                     let details = status.details();
                     if let Ok(backend_err) = serde_json::from_slice::<Backend>(details) {
-                        eprintln!(
+                        println!(
                             "{}{}{}Exporting Failed!{}",
                             color::Fg(color::Red),
                             style::Italic,
@@ -168,7 +250,7 @@ impl ExportCommand {
                             style::Reset
                         );
 
-                        eprintln!(
+                        println!(
                             "{}{}{}****************************************{}",
                             color::Fg(color::Black),
                             style::Italic,
@@ -177,7 +259,7 @@ impl ExportCommand {
                         );
 
                         if let Some(status_code) = backend_err.status_code {
-                            eprintln!(
+                            println!(
                                 "{}{}{}Bad Status Code:{} {}",
                                 color::Fg(color::Red),
                                 style::Italic,
@@ -187,7 +269,7 @@ impl ExportCommand {
                             );
                         }
 
-                        eprintln!(
+                        println!(
                             "{}{}{}Message:{} {}",
                             color::Fg(color::Cyan),
                             style::Italic,
@@ -197,7 +279,7 @@ impl ExportCommand {
                         );
 
                         if !backend_err.header.is_empty() {
-                            eprintln!(
+                            println!(
                                 "{}{}{}Header:{}",
                                 color::Fg(color::Cyan),
                                 style::Italic,
@@ -205,11 +287,11 @@ impl ExportCommand {
                                 style::Reset
                             );
                             for (key, value) in backend_err.header.iter() {
-                                eprintln!("  [{}]: {}", key.as_str(), value.as_str());
+                                println!("  [{}]: {}", key.as_str(), value.as_str());
                             }
                         }
 
-                        eprintln!(
+                        println!(
                             "{}{}{}****************************************{}",
                             color::Fg(color::Black),
                             style::Italic,
@@ -217,7 +299,7 @@ impl ExportCommand {
                             style::Reset
                         );
                     } else {
-                        eprintln!(
+                        println!(
                             "{}{}{}Exporting Failed!{}",
                             color::Fg(color::Red),
                             style::Italic,
@@ -225,7 +307,7 @@ impl ExportCommand {
                             style::Reset
                         );
 
-                        eprintln!(
+                        println!(
                             "{}{}{}*********************************{}",
                             color::Fg(color::Black),
                             style::Italic,
@@ -233,7 +315,7 @@ impl ExportCommand {
                             style::Reset
                         );
 
-                        eprintln!(
+                        println!(
                             "{}{}{}Bad Code:{} {}",
                             color::Fg(color::Red),
                             style::Italic,
@@ -242,7 +324,7 @@ impl ExportCommand {
                             status.code()
                         );
 
-                        eprintln!(
+                        println!(
                             "{}{}{}Message:{} {}",
                             color::Fg(color::Cyan),
                             style::Italic,
@@ -252,7 +334,7 @@ impl ExportCommand {
                         );
 
                         if !status.details().is_empty() {
-                            eprintln!(
+                            println!(
                                 "{}{}{}Details:{} {}",
                                 color::Fg(color::Cyan),
                                 style::Italic,
@@ -262,7 +344,7 @@ impl ExportCommand {
                             );
                         }
 
-                        eprintln!(
+                        println!(
                             "{}{}{}*********************************{}",
                             color::Fg(color::Black),
                             style::Italic,
@@ -272,7 +354,7 @@ impl ExportCommand {
                     }
                 }
                 Error::BackendError(err) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Exporting Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -280,7 +362,7 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -288,7 +370,7 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -298,7 +380,7 @@ impl ExportCommand {
                     );
 
                     if err.header.is_some() {
-                        eprintln!(
+                        println!(
                             "{}{}{}Header:{}",
                             color::Fg(color::Cyan),
                             style::Italic,
@@ -306,11 +388,11 @@ impl ExportCommand {
                             style::Reset
                         );
                         for (key, value) in err.header.unwrap_or_default().iter() {
-                            eprintln!("  [{}]: {}", key.as_str(), value.to_str().unwrap());
+                            println!("  [{}]: {}", key.as_str(), value.to_str().unwrap());
                         }
                     }
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -319,7 +401,7 @@ impl ExportCommand {
                     );
                 }
                 err => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Exporting Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -327,7 +409,7 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -335,7 +417,7 @@ impl ExportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -344,7 +426,7 @@ impl ExportCommand {
                         err
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -360,11 +442,24 @@ impl ExportCommand {
         Ok(())
     }
 
-    /// run runs the export command.
+    /// Executes the export operation to retrieve cached files from the persistent cache system.
+    ///
+    /// This function handles the core export functionality by downloading a cached file from the
+    /// dfdaemon persistent cache system. It supports two transfer modes: direct file transfer
+    /// by dfdaemon (hardlink/copy) or streaming piece content through the client for manual
+    /// file assembly. The operation provides real-time progress feedback and handles file
+    /// creation, directory setup, and efficient piece-by-piece writing with sparse file allocation.
     async fn run(&self, dfdaemon_download_client: DfdaemonDownloadClient) -> Result<()> {
-        // Get the absolute path of the output file.
-        let absolute_path = Path::new(&self.output).absolutize()?;
-        info!("download file to: {}", absolute_path.to_string_lossy());
+        // Dfcache needs to notify dfdaemon to transfer the piece content of downloading file via unix domain socket
+        // when the `transfer_from_dfdaemon` is true. Otherwise, dfdaemon will download the file and hardlink or
+        // copy the file to the output path.
+        let (output_path, need_piece_content) = if self.transfer_from_dfdaemon {
+            (None, true)
+        } else {
+            let absolute_path = Path::new(&self.output).absolutize()?;
+            info!("export file to: {}", absolute_path.to_string_lossy());
+            (Some(absolute_path.to_string_lossy().to_string()), false)
+        };
 
         // Create dfdaemon client.
         let response = dfdaemon_download_client
@@ -375,21 +470,50 @@ impl ExportCommand {
                 persistent: false,
                 tag: Some(self.tag.clone()),
                 application: Some(self.application.clone()),
-                output_path: absolute_path.to_string_lossy().to_string(),
+                output_path,
                 timeout: Some(
                     prost_wkt_types::Duration::try_from(self.timeout)
                         .or_err(ErrorType::ParseError)?,
                 ),
+                need_piece_content,
+                force_hard_link: self.force_hard_link,
+                digest: self.digest.clone(),
+                remote_ip: Some(local_ip().unwrap().to_string()),
             })
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 error!("download persistent cache task failed: {}", err);
-                err
             })?;
 
+        // If transfer_from_dfdaemon is true, then dfcache needs to create the output file and write the
+        // piece content to the output file.
+        let mut f = if self.transfer_from_dfdaemon {
+            if let Some(parent) = self.output.parent() {
+                if !parent.exists() {
+                    fs::create_dir_all(parent).await.inspect_err(|err| {
+                        error!("failed to create directory {:?}: {}", parent, err);
+                    })?;
+                }
+            }
+
+            let f = OpenOptions::new()
+                .create_new(true)
+                .write(true)
+                .mode(dfcache::DEFAULT_OUTPUT_FILE_MODE)
+                .open(&self.output)
+                .await
+                .inspect_err(|err| {
+                    error!("open file {:?} failed: {}", self.output, err);
+                })?;
+
+            Some(f)
+        } else {
+            None
+        };
+
         // Initialize progress bar.
-        let pb = ProgressBar::new(0);
-        pb.set_style(
+        let progress_bar = ProgressBar::new(0);
+        progress_bar.set_style(
             ProgressStyle::with_template(
                 "[{elapsed_precise}] [{wide_bar}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})",
             )
@@ -403,34 +527,62 @@ impl ExportCommand {
         //  Download file.
         let mut downloaded = 0;
         let mut out_stream = response.into_inner();
-        while let Some(message) = out_stream.message().await.map_err(|err| {
+        while let Some(message) = out_stream.message().await.inspect_err(|err| {
             error!("get message failed: {}", err);
-            err
         })? {
             match message.response {
                 Some(download_persistent_cache_task_response::Response::DownloadPersistentCacheTaskStartedResponse(
                     response,
                 )) => {
-                    pb.set_length(response.content_length);
+                    if let Some(f) = &f {
+                        fallocate(f, response.content_length)
+                            .await
+                            .inspect_err(|err| {
+                                error!("fallocate {:?} failed: {}", self.output, err);
+                            })?;
+                    }
+
+                    progress_bar.set_length(response.content_length);
                 }
                 Some(download_persistent_cache_task_response::Response::DownloadPieceFinishedResponse(
                     response,
                 )) => {
                     let piece = response.piece.ok_or(Error::InvalidParameter)?;
 
+                    // Dfcache needs to write the piece content to the output file.
+                    if let Some(f) = &mut f {
+                        f.seek(SeekFrom::Start(piece.offset))
+                            .await
+                            .inspect_err(|err| {
+                                error!("seek {:?} failed: {}", self.output, err);
+                            })?;
+
+                        let content = piece.content.ok_or(Error::InvalidParameter)?;
+                        f.write_all(&content).await.inspect_err(|err| {
+                            error!("write {:?} failed: {}", self.output, err);
+                        })?;
+
+                        debug!("copy piece {} to {:?} success", piece.number, self.output);
+                    };
+
                     downloaded += piece.length;
-                    let position = min(downloaded + piece.length, pb.length().unwrap_or(0));
-                    pb.set_position(position);
+                    let position = min(downloaded + piece.length, progress_bar.length().unwrap_or(0));
+                    progress_bar.set_position(position);
                 }
                 None => {}
             }
         }
 
-        pb.finish_with_message("downloaded");
+        progress_bar.finish_with_message("downloaded");
         Ok(())
     }
 
-    /// validate_args validates the command line arguments.
+    /// Validates command line arguments for the export operation to ensure safe file output.
+    ///
+    /// This function performs essential validation of the output path to prevent file conflicts
+    /// and ensure the target location is suitable for export operations. It checks parent
+    /// directory existence, prevents accidental file overwrites, and validates path accessibility
+    /// before allowing the export operation to proceed.
     fn validate_args(&self) -> Result<()> {
         let absolute_path = Path::new(&self.output).absolutize()?;
         match absolute_path.parent() {

dragonfly-client/src/bin/dfcache/import.rs

@@ -14,17 +14,22 @@
  * limitations under the License.
  */
 
+use bytesize::ByteSize;
 use clap::Parser;
 use dragonfly_api::dfdaemon::v2::UploadPersistentCacheTaskRequest;
+use dragonfly_client::resource::piece::MIN_PIECE_LENGTH;
 use dragonfly_client_config::dfcache::default_dfcache_persistent_replica_count;
 use dragonfly_client_core::{
     error::{ErrorType, OrErr},
     Error, Result,
 };
 use indicatif::{ProgressBar, ProgressStyle};
+use local_ip_address::local_ip;
+use path_absolutize::*;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use termion::{color, style};
+use tracing::info;
 
 use super::*;
 
@@ -37,6 +42,12 @@ pub struct ImportCommand {
     #[arg(help = "Specify the path of the file to import")]
     path: PathBuf,
 
+    #[arg(
+        long = "content-for-calculating-task-id",
+        help = "Specify the content used to calculate the persistent cache task ID. If it is set, use its value to calculate the task ID, Otherwise, calculate the persistent cache task ID based on url, piece-length, tag, application, and filtered-query-params."
+    )]
+    content_for_calculating_task_id: Option<String>,
+
     #[arg(
         long = "persistent-replica-count",
         default_value_t = default_dfcache_persistent_replica_count(),
@@ -44,10 +55,17 @@ pub struct ImportCommand {
     )]
     persistent_replica_count: u64,
 
+    #[arg(
+        long = "piece-length",
+        required = false,
+        help = "Specify the piece length for downloading file. If the piece length is not specified, the piece length will be calculated according to the file size. Different piece lengths will be divided into different persistent cache tasks. The value needs to be set with human readable format and needs to be greater than or equal to 4mib, for example: 4mib, 1gib"
+    )]
+    piece_length: Option<ByteSize>,
+
     #[arg(
         long = "application",
         required = false,
-        help = "Caller application which is used for statistics and access control"
+        help = "Different applications for the same url will be divided into different persistent cache tasks"
     )]
     application: Option<String>,
 
@@ -73,15 +91,72 @@ pub struct ImportCommand {
         help = "Specify the timeout for importing a file"
     )]
     timeout: Duration,
+
+    #[arg(
+        short = 'e',
+        long = "endpoint",
+        default_value_os_t = dfdaemon::default_download_unix_socket_path(),
+        help = "Endpoint of dfdaemon's GRPC server"
+    )]
+    endpoint: PathBuf,
+
+    #[arg(
+        short = 'l',
+        long,
+        default_value = "info",
+        help = "Specify the logging level [trace, debug, info, warn, error]"
+    )]
+    log_level: Level,
+
+    #[arg(
+        long,
+        default_value_os_t = dfcache::default_dfcache_log_dir(),
+        help = "Specify the log directory"
+    )]
+    log_dir: PathBuf,
+
+    #[arg(
+        long,
+        default_value_t = 6,
+        help = "Specify the max number of log files"
+    )]
+    log_max_files: usize,
+
+    #[arg(long, default_value_t = false, help = "Specify whether to print log")]
+    console: bool,
 }
 
 /// Implement the execute for ImportCommand.
 impl ImportCommand {
-    /// execute executes the import sub command.
-    pub async fn execute(&self, endpoint: &Path) -> Result<()> {
+    /// Executes the import sub command with comprehensive validation and error handling.
+    ///
+    /// This function serves as the main entry point for the dfcache import command execution.
+    /// It handles the complete workflow including argument parsing, validation, logging setup,
+    /// dfdaemon client connection, and import operation execution. The function provides
+    /// detailed error reporting with colored terminal output and follows a fail-fast approach
+    /// with immediate process termination on any critical failures.
+    pub async fn execute(&self) -> Result<()> {
+        // Parse command line arguments.
+        Args::parse();
+
+        // Initialize tracing.
+        let _guards = init_tracing(
+            dfcache::NAME,
+            self.log_dir.clone(),
+            self.log_level,
+            self.log_max_files,
+            None,
+            None,
+            None,
+            None,
+            None,
+            false,
+            self.console,
+        );
+
         // Validate the command line arguments.
         if let Err(err) = self.validate_args() {
-            eprintln!(
+            println!(
                 "{}{}{}Validating Failed!{}",
                 color::Fg(color::Red),
                 style::Italic,
@@ -89,7 +164,7 @@ impl ImportCommand {
                 style::Reset
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}****************************************{}",
                 color::Fg(color::Black),
                 style::Italic,
@@ -97,7 +172,7 @@ impl ImportCommand {
                 style::Reset
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}Message:{} {}",
                 color::Fg(color::Cyan),
                 style::Italic,
@@ -106,7 +181,7 @@ impl ImportCommand {
                 err,
             );
 
-            eprintln!(
+            println!(
                 "{}{}{}****************************************{}",
                 color::Fg(color::Black),
                 style::Italic,
@@ -119,10 +194,10 @@ impl ImportCommand {
 
         // Get dfdaemon download client.
         let dfdaemon_download_client =
-            match get_dfdaemon_download_client(endpoint.to_path_buf()).await {
+            match get_dfdaemon_download_client(self.endpoint.to_path_buf()).await {
                 Ok(client) => client,
                 Err(err) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Connect Dfdaemon Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -130,7 +205,7 @@ impl ImportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -138,17 +213,17 @@ impl ImportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{}, can not connect {}, please check the unix socket {}",
                         color::Fg(color::Cyan),
                         style::Italic,
                         style::Bold,
                         style::Reset,
                         err,
-                        endpoint.to_string_lossy(),
+                        self.endpoint.to_string_lossy(),
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -164,7 +239,7 @@ impl ImportCommand {
         if let Err(err) = self.run(dfdaemon_download_client).await {
             match err {
                 Error::TonicStatus(status) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Importing Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -172,7 +247,7 @@ impl ImportCommand {
                         style::Reset,
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}*********************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -180,7 +255,7 @@ impl ImportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Bad Code:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -189,7 +264,7 @@ impl ImportCommand {
                         status.code()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Cyan),
                         style::Italic,
@@ -198,7 +273,7 @@ impl ImportCommand {
                         status.message()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Details:{} {}",
                         color::Fg(color::Cyan),
                         style::Italic,
@@ -207,7 +282,7 @@ impl ImportCommand {
                         std::str::from_utf8(status.details()).unwrap()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}*********************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -216,7 +291,7 @@ impl ImportCommand {
                     );
                 }
                 err => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Importing Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -224,7 +299,7 @@ impl ImportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -232,7 +307,7 @@ impl ImportCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -241,7 +316,7 @@ impl ImportCommand {
                         err
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -257,23 +332,34 @@ impl ImportCommand {
         Ok(())
     }
 
-    /// run runs the import sub command.
+    /// Executes the cache import operation by uploading a file to the persistent cache system.
+    ///
+    /// This function handles the core import functionality by uploading a local file to the
+    /// dfdaemon persistent cache system. It provides visual feedback through a progress spinner,
+    /// converts the file path to absolute format, and configures the cache task with specified
+    /// parameters including TTL, replica count, and piece length. The operation is asynchronous
+    /// and provides completion feedback with the generated task ID.
     async fn run(&self, dfdaemon_download_client: DfdaemonDownloadClient) -> Result<()> {
-        let pb = ProgressBar::new_spinner();
-        pb.enable_steady_tick(DEFAULT_PROGRESS_BAR_STEADY_TICK_INTERVAL);
-        pb.set_style(
+        let absolute_path = Path::new(&self.path).absolutize()?;
+        info!("import file: {}", absolute_path.to_string_lossy());
+
+        let progress_bar = ProgressBar::new_spinner();
+        progress_bar.enable_steady_tick(DEFAULT_PROGRESS_BAR_STEADY_TICK_INTERVAL);
+        progress_bar.set_style(
             ProgressStyle::with_template("{spinner:.blue} {msg}")
                 .unwrap()
                 .tick_strings(&["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]),
         );
-        pb.set_message("Importing...");
+        progress_bar.set_message("Importing...");
 
-        dfdaemon_download_client
+        let persistent_cache_task = dfdaemon_download_client
             .upload_persistent_cache_task(UploadPersistentCacheTaskRequest {
-                path: self.path.clone().into_os_string().into_string().unwrap(),
+                content_for_calculating_task_id: self.content_for_calculating_task_id.clone(),
+                path: absolute_path.to_string_lossy().to_string(),
                 persistent_replica_count: self.persistent_replica_count,
                 tag: self.tag.clone(),
                 application: self.application.clone(),
+                piece_length: self.piece_length.map(|piece_length| piece_length.as_u64()),
                 ttl: Some(
                     prost_wkt_types::Duration::try_from(self.ttl).or_err(ErrorType::ParseError)?,
                 ),
@@ -281,15 +367,30 @@ impl ImportCommand {
                     prost_wkt_types::Duration::try_from(self.timeout)
                         .or_err(ErrorType::ParseError)?,
                 ),
+                remote_ip: Some(local_ip().unwrap().to_string()),
             })
             .await?;
 
-        pb.finish_with_message("Done");
+        progress_bar.finish_with_message(format!("Done: {}", persistent_cache_task.id));
         Ok(())
     }
 
-    /// validate_args validates the command line arguments.
+    /// Validates command line arguments for the import operation to ensure safe and correct execution.
+    ///
+    /// This function performs comprehensive validation of import-specific parameters to prevent
+    /// invalid operations and ensure the import request meets all system requirements. It validates
+    /// TTL boundaries, file existence and type, and piece length constraints before allowing the
+    /// import operation to proceed.
     fn validate_args(&self) -> Result<()> {
+        if self.ttl < Duration::from_secs(5 * 60)
+            || self.ttl > Duration::from_secs(7 * 24 * 60 * 60)
+        {
+            return Err(Error::ValidationError(format!(
+                "ttl must be between 5 minutes and 7 days, but got {}",
+                self.ttl.as_secs()
+            )));
+        }
+
         if self.path.is_dir() {
             return Err(Error::ValidationError(format!(
                 "path {} is a directory",
@@ -304,6 +405,16 @@ impl ImportCommand {
             )));
         }
 
+        if let Some(piece_length) = self.piece_length {
+            if piece_length.as_u64() < MIN_PIECE_LENGTH {
+                return Err(Error::ValidationError(format!(
+                    "piece length {} bytes is less than the minimum piece length {} bytes",
+                    piece_length.as_u64(),
+                    MIN_PIECE_LENGTH
+                )));
+            }
+        }
+
         Ok(())
     }
 }

dragonfly-client/src/bin/dfcache/main.rs

@@ -21,12 +21,11 @@ use dragonfly_client::tracing::init_tracing;
 use dragonfly_client_config::VersionValueParser;
 use dragonfly_client_config::{dfcache, dfdaemon};
 use dragonfly_client_core::Result;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use tracing::Level;
 
 pub mod export;
 pub mod import;
-pub mod remove;
 pub mod stat;
 
 #[derive(Debug, Parser)]
@@ -40,43 +39,6 @@ pub mod stat;
     disable_version_flag = true
 )]
 struct Args {
-    #[arg(
-        short = 'e',
-        long = "endpoint",
-        default_value_os_t = dfdaemon::default_download_unix_socket_path(),
-        help = "Endpoint of dfdaemon's GRPC server"
-    )]
-    endpoint: PathBuf,
-
-    #[arg(
-        short = 'l',
-        long,
-        default_value = "info",
-        help = "Specify the logging level [trace, debug, info, warn, error]"
-    )]
-    log_level: Level,
-
-    #[arg(
-        long,
-        default_value_os_t = dfcache::default_dfcache_log_dir(),
-        help = "Specify the log directory"
-    )]
-    log_dir: PathBuf,
-
-    #[arg(
-        long,
-        default_value_t = 6,
-        help = "Specify the max number of log files"
-    )]
-    log_max_files: usize,
-
-    #[arg(
-        long = "verbose",
-        default_value_t = false,
-        help = "Specify whether to print log"
-    )]
-    verbose: bool,
-
     #[arg(
         short = 'V',
         long = "version",
@@ -120,26 +82,16 @@ pub enum Command {
         long_about = "Stat a file in Dragonfly P2P network by task ID. If stat successfully, it will return the file information."
     )]
     Stat(stat::StatCommand),
-
-    #[command(
-        name = "rm",
-        author,
-        version,
-        about = "Remove a file from Dragonfly P2P network",
-        long_about = "Remove the P2P cache in Dragonfly P2P network by task ID."
-    )]
-    Remove(remove::RemoveCommand),
 }
 
 /// Implement the execute for Command.
 impl Command {
     #[allow(unused)]
-    pub async fn execute(self, endpoint: &Path) -> Result<()> {
+    pub async fn execute(self) -> Result<()> {
         match self {
-            Self::Import(cmd) => cmd.execute(endpoint).await,
-            Self::Export(cmd) => cmd.execute(endpoint).await,
-            Self::Stat(cmd) => cmd.execute(endpoint).await,
-            Self::Remove(cmd) => cmd.execute(endpoint).await,
+            Self::Import(cmd) => cmd.execute().await,
+            Self::Export(cmd) => cmd.execute().await,
+            Self::Stat(cmd) => cmd.execute().await,
         }
     }
 }
@@ -149,24 +101,17 @@ async fn main() -> anyhow::Result<()> {
     // Parse command line arguments.
     let args = Args::parse();
 
-    // Initialize tracing.
-    let _guards = init_tracing(
-        dfcache::NAME,
-        args.log_dir,
-        args.log_level,
-        args.log_max_files,
-        None,
-        false,
-        false,
-        args.verbose,
-    );
-
     // Execute the command.
-    args.command.execute(&args.endpoint).await?;
+    args.command.execute().await?;
     Ok(())
 }
 
-/// get_and_check_dfdaemon_download_client gets a dfdaemon download client and checks its health.
+/// Creates and validates a dfdaemon download client with health checking.
+///
+/// This function establishes a connection to the dfdaemon service via Unix domain socket
+/// and performs a health check to ensure the service is running and ready to handle
+/// download requests. Only after successful health verification does it return the
+/// download client for actual use.
 pub async fn get_dfdaemon_download_client(endpoint: PathBuf) -> Result<DfdaemonDownloadClient> {
     // Check dfdaemon's health.
     let health_client = HealthClient::new_unix(endpoint.clone()).await?;

dragonfly-client/src/bin/dfcache/remove.rs

@@ -1,201 +0,0 @@
-/*
- *     Copyright 2024 The Dragonfly Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use clap::Parser;
-use dragonfly_api::dfdaemon::v2::DeletePersistentCacheTaskRequest;
-use dragonfly_client_core::{Error, Result};
-use indicatif::{ProgressBar, ProgressStyle};
-use std::path::Path;
-use std::time::Duration;
-use termion::{color, style};
-
-use super::*;
-
-/// DEFAULT_PROGRESS_BAR_STEADY_TICK_INTERVAL is the default steady tick interval of progress bar.
-const DEFAULT_PROGRESS_BAR_STEADY_TICK_INTERVAL: Duration = Duration::from_millis(80);
-
-/// RemoveCommand is the subcommand of remove.
-#[derive(Debug, Clone, Parser)]
-pub struct RemoveCommand {
-    #[arg(help = "Specify the persistent cache task ID to remove")]
-    id: String,
-}
-
-/// Implement the execute for RemoveCommand.
-impl RemoveCommand {
-    /// execute executes the delete command.
-    pub async fn execute(&self, endpoint: &Path) -> Result<()> {
-        // Get dfdaemon download client.
-        let dfdaemon_download_client =
-            match get_dfdaemon_download_client(endpoint.to_path_buf()).await {
-                Ok(client) => client,
-                Err(err) => {
-                    eprintln!(
-                        "{}{}{}Connect Dfdaemon Failed!{}",
-                        color::Fg(color::Red),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    eprintln!(
-                        "{}{}{}****************************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    eprintln!(
-                        "{}{}{}Message:{}, can not connect {}, please check the unix socket {}",
-                        color::Fg(color::Cyan),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                        err,
-                        endpoint.to_string_lossy(),
-                    );
-
-                    eprintln!(
-                        "{}{}{}****************************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    std::process::exit(1);
-                }
-            };
-
-        // Run delete sub command.
-        if let Err(err) = self.run(dfdaemon_download_client).await {
-            match err {
-                Error::TonicStatus(status) => {
-                    eprintln!(
-                        "{}{}{}Removing Failed!{}",
-                        color::Fg(color::Red),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                    );
-
-                    eprintln!(
-                        "{}{}{}*********************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    eprintln!(
-                        "{}{}{}Bad Code:{} {}",
-                        color::Fg(color::Red),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                        status.code()
-                    );
-
-                    eprintln!(
-                        "{}{}{}Message:{} {}",
-                        color::Fg(color::Cyan),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                        status.message()
-                    );
-
-                    eprintln!(
-                        "{}{}{}Details:{} {}",
-                        color::Fg(color::Cyan),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                        std::str::from_utf8(status.details()).unwrap()
-                    );
-
-                    eprintln!(
-                        "{}{}{}*********************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-                }
-                err => {
-                    eprintln!(
-                        "{}{}{}Removing Failed!{}",
-                        color::Fg(color::Red),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    eprintln!(
-                        "{}{}{}****************************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-
-                    eprintln!(
-                        "{}{}{}Message:{} {}",
-                        color::Fg(color::Red),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset,
-                        err
-                    );
-
-                    eprintln!(
-                        "{}{}{}****************************************{}",
-                        color::Fg(color::Black),
-                        style::Italic,
-                        style::Bold,
-                        style::Reset
-                    );
-                }
-            }
-
-            std::process::exit(1);
-        }
-
-        Ok(())
-    }
-
-    /// run runs the delete command.
-    async fn run(&self, dfdaemon_download_client: DfdaemonDownloadClient) -> Result<()> {
-        let pb = ProgressBar::new_spinner();
-        pb.enable_steady_tick(DEFAULT_PROGRESS_BAR_STEADY_TICK_INTERVAL);
-        pb.set_style(
-            ProgressStyle::with_template("{spinner:.blue} {msg}")
-                .unwrap()
-                .tick_strings(&["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]),
-        );
-        pb.set_message("Removing...");
-
-        dfdaemon_download_client
-            .delete_persistent_cache_task(DeletePersistentCacheTaskRequest {
-                task_id: self.id.clone(),
-            })
-            .await?;
-
-        pb.finish_with_message("Done");
-        Ok(())
-    }
-}

dragonfly-client/src/bin/dfcache/stat.rs

@@ -22,7 +22,7 @@ use dragonfly_client_core::{
     Error, Result,
 };
 use humantime::format_duration;
-use std::path::Path;
+use local_ip_address::local_ip;
 use std::time::Duration;
 use tabled::{
     settings::{object::Rows, Alignment, Modify, Style},
@@ -37,18 +37,75 @@ use super::*;
 pub struct StatCommand {
     #[arg(help = "Specify the persistent cache task ID to stat")]
     id: String,
+
+    #[arg(
+        short = 'e',
+        long = "endpoint",
+        default_value_os_t = dfdaemon::default_download_unix_socket_path(),
+        help = "Endpoint of dfdaemon's GRPC server"
+    )]
+    endpoint: PathBuf,
+
+    #[arg(
+        short = 'l',
+        long,
+        default_value = "info",
+        help = "Specify the logging level [trace, debug, info, warn, error]"
+    )]
+    log_level: Level,
+
+    #[arg(
+        long,
+        default_value_os_t = dfcache::default_dfcache_log_dir(),
+        help = "Specify the log directory"
+    )]
+    log_dir: PathBuf,
+
+    #[arg(
+        long,
+        default_value_t = 6,
+        help = "Specify the max number of log files"
+    )]
+    log_max_files: usize,
+
+    #[arg(long, default_value_t = false, help = "Specify whether to print log")]
+    console: bool,
 }
 
 /// Implement the execute for StatCommand.
 impl StatCommand {
-    /// execute executes the stat command.
-    pub async fn execute(&self, endpoint: &Path) -> Result<()> {
+    /// Executes the stat command with comprehensive error handling and user feedback.
+    ///
+    /// This function serves as the main entry point for the dfcache stat command execution.
+    /// It handles the complete lifecycle including argument parsing, logging initialization,
+    /// dfdaemon client setup, and command execution with detailed error reporting. The
+    /// function provides colored terminal output for better user experience and exits
+    /// with appropriate status codes on failure.
+    pub async fn execute(&self) -> Result<()> {
+        // Parse command line arguments.
+        Args::parse();
+
+        // Initialize tracing.
+        let _guards = init_tracing(
+            dfcache::NAME,
+            self.log_dir.clone(),
+            self.log_level,
+            self.log_max_files,
+            None,
+            None,
+            None,
+            None,
+            None,
+            false,
+            self.console,
+        );
+
         // Get dfdaemon download client.
         let dfdaemon_download_client =
-            match get_dfdaemon_download_client(endpoint.to_path_buf()).await {
+            match get_dfdaemon_download_client(self.endpoint.to_path_buf()).await {
                 Ok(client) => client,
                 Err(err) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Connect Dfdaemon Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -56,7 +113,7 @@ impl StatCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -64,17 +121,17 @@ impl StatCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{}, can not connect {}, please check the unix socket {}",
                         color::Fg(color::Cyan),
                         style::Italic,
                         style::Bold,
                         style::Reset,
                         err,
-                        endpoint.to_string_lossy(),
+                        self.endpoint.to_string_lossy(),
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -90,7 +147,7 @@ impl StatCommand {
         if let Err(err) = self.run(dfdaemon_download_client).await {
             match err {
                 Error::TonicStatus(status) => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Stating Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -98,7 +155,7 @@ impl StatCommand {
                         style::Reset,
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}*********************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -106,7 +163,7 @@ impl StatCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Bad Code:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -115,7 +172,7 @@ impl StatCommand {
                         status.code()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Cyan),
                         style::Italic,
@@ -124,7 +181,7 @@ impl StatCommand {
                         status.message()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Details:{} {}",
                         color::Fg(color::Cyan),
                         style::Italic,
@@ -133,7 +190,7 @@ impl StatCommand {
                         std::str::from_utf8(status.details()).unwrap()
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}*********************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -142,7 +199,7 @@ impl StatCommand {
                     );
                 }
                 err => {
-                    eprintln!(
+                    println!(
                         "{}{}{}Stating Failed!{}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -150,7 +207,7 @@ impl StatCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -158,7 +215,7 @@ impl StatCommand {
                         style::Reset
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}Message:{} {}",
                         color::Fg(color::Red),
                         style::Italic,
@@ -167,7 +224,7 @@ impl StatCommand {
                         err
                     );
 
-                    eprintln!(
+                    println!(
                         "{}{}{}****************************************{}",
                         color::Fg(color::Black),
                         style::Italic,
@@ -183,11 +240,17 @@ impl StatCommand {
         Ok(())
     }
 
-    /// run runs the stat command.
+    /// Executes the stat command to retrieve and display persistent cache task information.
+    ///
+    /// This function queries the dfdaemon service for detailed information about a specific
+    /// persistent cache task and presents it in a formatted table for user consumption.
+    /// It handles data conversion from raw protocol buffer values to human-readable formats
+    /// including byte sizes, durations, and timestamps with proper timezone conversion.
     async fn run(&self, dfdaemon_download_client: DfdaemonDownloadClient) -> Result<()> {
         let task = dfdaemon_download_client
             .stat_persistent_cache_task(StatPersistentCacheTaskRequest {
                 task_id: self.id.clone(),
+                remote_ip: Some(local_ip().unwrap().to_string()),
             })
             .await?;
 
@@ -203,8 +266,6 @@ impl StatCommand {
             piece_length: String,
             #[tabled(rename = "PERSISTENT REPLICA COUNT")]
             persistent_replica_count: u64,
-            #[tabled(rename = "REPLICA COUNT")]
-            replica_count: u64,
             ttl: String,
             #[tabled(rename = "CREATED")]
             created_at: String,
@@ -220,7 +281,6 @@ impl StatCommand {
             // Convert piece_length to human readable format.
             piece_length: bytesize::to_string(task.piece_length, true),
             persistent_replica_count: task.persistent_replica_count,
-            replica_count: task.replica_count,
             ..Default::default()
         };
 

dragonfly-client/src/bin/dfdaemon/main.rs

@@ -15,7 +15,7 @@
  */
 
 use clap::Parser;
-use dragonfly_client::announcer::{ManagerAnnouncer, SchedulerAnnouncer};
+use dragonfly_client::announcer::SchedulerAnnouncer;
 use dragonfly_client::dynconfig::Dynconfig;
 use dragonfly_client::gc::GC;
 use dragonfly_client::grpc::{
@@ -30,14 +30,15 @@ use dragonfly_client::shutdown;
 use dragonfly_client::stats::Stats;
 use dragonfly_client::tracing::init_tracing;
 use dragonfly_client_backend::BackendFactory;
-use dragonfly_client_config::dfdaemon;
-use dragonfly_client_config::VersionValueParser;
+use dragonfly_client_config::{dfdaemon, VersionValueParser};
 use dragonfly_client_storage::Storage;
-use dragonfly_client_util::id_generator::IDGenerator;
+use dragonfly_client_util::{id_generator::IDGenerator, net::Interface};
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::Arc;
+use termion::{color, style};
 use tokio::sync::mpsc;
+use tokio::sync::Barrier;
 use tracing::{error, info, Level};
 
 #[cfg(not(target_env = "msvc"))]
@@ -90,12 +91,8 @@ struct Args {
     )]
     log_max_files: usize,
 
-    #[arg(
-        long = "verbose",
-        default_value_t = false,
-        help = "Specify whether to print log"
-    )]
-    verbose: bool,
+    #[arg(long, default_value_t = true, help = "Specify whether to print log")]
+    console: bool,
 
     #[arg(
         short = 'V',
@@ -114,7 +111,32 @@ async fn main() -> Result<(), anyhow::Error> {
     let args = Args::parse();
 
     // Load config.
-    let config = dfdaemon::Config::load(&args.config).await?;
+    let config = match dfdaemon::Config::load(&args.config).await {
+        Ok(config) => config,
+        Err(err) => {
+            println!(
+                "{}{}Load config {} error: {}{}\n",
+                color::Fg(color::Red),
+                style::Bold,
+                args.config.display(),
+                err,
+                style::Reset
+            );
+
+            println!(
+                "{}{}If the file does not exist, you need to new a default config file refer to: {}{}{}{}https://d7y.io/docs/next/reference/configuration/client/dfdaemon/{}",
+                color::Fg(color::Yellow),
+                style::Bold,
+                style::Reset,
+                color::Fg(color::Cyan),
+                style::Underline,
+                style::Italic,
+                style::Reset,
+            );
+            std::process::exit(1);
+        }
+    };
+
     let config = Arc::new(config);
 
     // Initialize tracing.
@@ -123,18 +145,20 @@ async fn main() -> Result<(), anyhow::Error> {
         args.log_dir.clone(),
         args.log_level,
         args.log_max_files,
-        config.tracing.addr.to_owned(),
-        config.tracing.flamegraph,
-        true,
-        args.verbose,
+        config.tracing.protocol.clone(),
+        config.tracing.endpoint.clone(),
+        config.tracing.path.clone(),
+        Some(config.tracing.headers.clone()),
+        Some(config.host.clone()),
+        config.seed_peer.enable,
+        args.console,
     );
 
     // Initialize storage.
     let storage = Storage::new(config.clone(), config.storage.dir.as_path(), args.log_dir)
         .await
-        .map_err(|err| {
+        .inspect_err(|err| {
             error!("initialize storage failed: {}", err);
-            err
         })?;
     let storage = Arc::new(storage);
 
@@ -149,9 +173,8 @@ async fn main() -> Result<(), anyhow::Error> {
     // Initialize manager client.
     let manager_client = ManagerClient::new(config.clone(), config.manager.addr.clone())
         .await
-        .map_err(|err| {
+        .inspect_err(|err| {
             error!("initialize manager client failed: {}", err);
-            err
         })?;
     let manager_client = Arc::new(manager_client);
 
@@ -167,25 +190,22 @@ async fn main() -> Result<(), anyhow::Error> {
         shutdown_complete_tx.clone(),
     )
     .await
-    .map_err(|err| {
+    .inspect_err(|err| {
         error!("initialize dynconfig server failed: {}", err);
-        err
     })?;
     let dynconfig = Arc::new(dynconfig);
 
     // Initialize scheduler client.
     let scheduler_client = SchedulerClient::new(config.clone(), dynconfig.clone())
         .await
-        .map_err(|err| {
+        .inspect_err(|err| {
             error!("initialize scheduler client failed: {}", err);
-            err
         })?;
     let scheduler_client = Arc::new(scheduler_client);
 
-    let backend_factory =
-        BackendFactory::new(Some(config.server.plugin_dir.as_path())).map_err(|err| {
+    let backend_factory = BackendFactory::new(Some(config.server.plugin_dir.as_path()))
+        .inspect_err(|err| {
             error!("initialize backend factory failed: {}", err);
-            err
         })?;
     let backend_factory = Arc::new(backend_factory);
 
@@ -196,7 +216,7 @@ async fn main() -> Result<(), anyhow::Error> {
         storage.clone(),
         scheduler_client.clone(),
         backend_factory.clone(),
-    );
+    )?;
     let task = Arc::new(task);
 
     // Initialize persistent cache task manager.
@@ -206,9 +226,12 @@ async fn main() -> Result<(), anyhow::Error> {
         storage.clone(),
         scheduler_client.clone(),
         backend_factory.clone(),
-    );
+    )?;
     let persistent_cache_task = Arc::new(persistent_cache_task);
 
+    let interface = Interface::new(config.host.ip.unwrap(), config.upload.rate_limit);
+    let interface = Arc::new(interface);
+
     // Initialize health server.
     let health = Health::new(
         SocketAddr::new(config.health.server.ip.unwrap(), config.health.server.port),
@@ -238,26 +261,18 @@ async fn main() -> Result<(), anyhow::Error> {
         shutdown_complete_tx.clone(),
     );
 
-    // Initialize manager announcer.
-    let manager_announcer = ManagerAnnouncer::new(
-        config.clone(),
-        manager_client.clone(),
-        shutdown.clone(),
-        shutdown_complete_tx.clone(),
-    );
-
     // Initialize scheduler announcer.
     let scheduler_announcer = SchedulerAnnouncer::new(
         config.clone(),
         id_generator.host_id(),
         scheduler_client.clone(),
+        interface.clone(),
         shutdown.clone(),
         shutdown_complete_tx.clone(),
     )
     .await
-    .map_err(|err| {
+    .inspect_err(|err| {
         error!("initialize scheduler announcer failed: {}", err);
-        err
     })?;
 
     // Initialize upload grpc server.
@@ -266,12 +281,14 @@ async fn main() -> Result<(), anyhow::Error> {
         SocketAddr::new(config.upload.server.ip.unwrap(), config.upload.server.port),
         task.clone(),
         persistent_cache_task.clone(),
+        interface.clone(),
         shutdown.clone(),
         shutdown_complete_tx.clone(),
     );
 
     // Initialize download grpc server.
     let mut dfdaemon_download_grpc = DfdaemonDownloadServer::new(
+        config.clone(),
         config.download.server.socket_path.clone(),
         task.clone(),
         persistent_cache_task.clone(),
@@ -292,6 +309,9 @@ async fn main() -> Result<(), anyhow::Error> {
     // Log dfdaemon started pid.
     info!("dfdaemon started at pid {}", std::process::id());
 
+    // grpc server started barrier.
+    let grpc_server_started_barrier = Arc::new(Barrier::new(3));
+
     // Wait for servers to exit or shutdown signal.
     tokio::select! {
         _ = tokio::spawn(async move { dynconfig.run().await }) => {
@@ -310,30 +330,41 @@ async fn main() -> Result<(), anyhow::Error> {
             info!("stats server exited");
         },
 
-        _ = tokio::spawn(async move { manager_announcer.run().await.unwrap_or_else(|err| error!("announcer manager failed: {}", err))}) => {
-            info!("announcer manager exited");
-        },
-
         _ = tokio::spawn(async move { scheduler_announcer.run().await }) => {
             info!("announcer scheduler exited");
         },
 
-        _ = tokio::spawn(async move { dfdaemon_upload_grpc.run().await }) => {
+        _ = tokio::spawn(async move { gc.run().await }) => {
+            info!("garbage collector exited");
+        },
+
+        _ = {
+            let barrier = grpc_server_started_barrier.clone();
+            tokio::spawn(async move {
+                dfdaemon_upload_grpc.run(barrier).await.unwrap_or_else(|err| error!("dfdaemon upload grpc server failed: {}", err));
+            })
+        } => {
             info!("dfdaemon upload grpc server exited");
         },
 
-        _ = tokio::spawn(async move { dfdaemon_download_grpc.run().await }) => {
+        _ = {
+            let barrier = grpc_server_started_barrier.clone();
+            tokio::spawn(async move {
+                dfdaemon_download_grpc.run(barrier).await.unwrap_or_else(|err| error!("dfdaemon download grpc server failed: {}", err));
+            })
+        } => {
             info!("dfdaemon download grpc unix server exited");
         },
 
-        _ = tokio::spawn(async move { proxy.run().await }) => {
+        _ = {
+            let barrier = grpc_server_started_barrier.clone();
+            tokio::spawn(async move {
+                proxy.run(barrier).await.unwrap_or_else(|err| error!("proxy server failed: {}", err));
+            })
+        } => {
             info!("proxy server exited");
         },
 
-        _ = tokio::spawn(async move { gc.run().await }) => {
-            info!("garbage collector exited");
-        },
-
         _ = shutdown::shutdown_signal() => {},
     }
 

dragonfly-client/src/bin/dfstore/main.rs

@@ -1,133 +0,0 @@
-/*
- *     Copyright 2023 The Dragonfly Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-use clap::{Parser, Subcommand};
-use dragonfly_client::tracing::init_tracing;
-use dragonfly_client_config::VersionValueParser;
-use dragonfly_client_config::{dfdaemon, dfstore};
-use std::path::PathBuf;
-use tracing::Level;
-
-#[derive(Debug, Parser)]
-#[command(
-    name = dfstore::NAME,
-    author,
-    version,
-    about = "dfstore is a storage command line based on P2P technology in Dragonfly.",
-    long_about = "A storage command line based on P2P technology in Dragonfly that can rely on different types of object storage, \
-    such as S3 or OSS, to provide stable object storage capabilities. It uses the entire P2P network as a cache when storing objects. \
-    Rely on S3 or OSS as the backend to ensure storage reliability. In the process of object storage, \
-    P2P cache is effectively used for fast read and write storage.",
-    disable_version_flag = true
-)]
-struct Args {
-    #[arg(
-        short = 'e',
-        long = "endpoint",
-        default_value_os_t = dfdaemon::default_download_unix_socket_path(),
-        help = "Endpoint of dfdaemon's GRPC server"
-    )]
-    endpoint: PathBuf,
-
-    #[arg(
-        short = 'l',
-        long,
-        default_value = "info",
-        help = "Specify the logging level [trace, debug, info, warn, error]"
-    )]
-    log_level: Level,
-
-    #[arg(
-        long,
-        default_value_os_t = dfstore::default_dfstore_log_dir(),
-        help = "Specify the log directory"
-    )]
-    log_dir: PathBuf,
-
-    #[arg(
-        long,
-        default_value_t = 6,
-        help = "Specify the max number of log files"
-    )]
-    log_max_files: usize,
-
-    #[arg(
-        long = "verbose",
-        default_value_t = false,
-        help = "Specify whether to print log"
-    )]
-    verbose: bool,
-
-    #[arg(
-        short = 'V',
-        long = "version",
-        help = "Print version information",
-        default_value_t = false,
-        action = clap::ArgAction::SetTrue,
-        value_parser = VersionValueParser
-    )]
-    version: bool,
-
-    #[command(subcommand)]
-    command: Command,
-}
-
-#[derive(Debug, Clone, Subcommand)]
-#[command()]
-pub enum Command {
-    #[command(
-        name = "cp",
-        author,
-        version,
-        about = "Download or upload files using object storage in Dragonfly",
-        long_about = "Download a file from object storage in Dragonfly or upload a local file to object storage in Dragonfly"
-    )]
-    Copy(CopyCommand),
-
-    #[command(
-        name = "rm",
-        author,
-        version,
-        about = "Remove a file from Dragonfly object storage",
-        long_about = "Remove the P2P cache in Dragonfly and remove the file stored in the object storage."
-    )]
-    Remove(RemoveCommand),
-}
-
-/// Download or upload files using object storage in Dragonfly.
-#[derive(Debug, Clone, Parser)]
-pub struct CopyCommand {}
-
-/// Remove a file from Dragonfly object storage.
-#[derive(Debug, Clone, Parser)]
-pub struct RemoveCommand {}
-
-fn main() {
-    // Parse command line arguments.
-    let args = Args::parse();
-
-    // Initialize tracing.
-    let _guards = init_tracing(
-        dfstore::NAME,
-        args.log_dir,
-        args.log_level,
-        args.log_max_files,
-        None,
-        false,
-        false,
-        args.verbose,
-    );
-}

dragonfly-client/src/dynconfig/mod.rs

@@ -25,7 +25,7 @@ use dragonfly_client_core::{Error, Result};
 use std::sync::Arc;
 use tokio::sync::{mpsc, Mutex, RwLock};
 use tonic_health::pb::health_check_response::ServingStatus;
-use tracing::{error, info, instrument};
+use tracing::{debug, error, info, instrument};
 use url::Url;
 
 /// Data is the dynamic configuration of the dfdaemon.
@@ -65,7 +65,6 @@ pub struct Dynconfig {
 /// Dynconfig is the implementation of Dynconfig.
 impl Dynconfig {
     /// new creates a new Dynconfig.
-    #[instrument(skip_all)]
     pub async fn new(
         config: Arc<Config>,
         manager_client: Arc<ManagerClient>,
@@ -88,7 +87,6 @@ impl Dynconfig {
     }
 
     /// run starts the dynconfig server.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();
@@ -98,9 +96,10 @@ impl Dynconfig {
         loop {
             tokio::select! {
                 _ = interval.tick() => {
-                    if let Err(err) = self.refresh().await {
-                        error!("refresh dynconfig failed: {}", err);
-                    };
+                    match self.refresh().await {
+                        Err(err) => error!("refresh dynconfig failed: {}", err),
+                        Ok(_) => debug!("refresh dynconfig success"),
+                    }
                 }
                 _ = shutdown.recv() => {
                     // Dynconfig server shutting down with signals.
@@ -163,6 +162,7 @@ impl Dynconfig {
                 location: self.config.host.location.clone(),
                 version: CARGO_PKG_VERSION.to_string(),
                 commit: GIT_COMMIT_SHORT_HASH.to_string(),
+                scheduler_cluster_id: self.config.host.scheduler_cluster_id.unwrap_or(0),
             })
             .await
     }

dragonfly-client/src/gc/mod.rs

@@ -16,17 +16,20 @@
 
 use crate::grpc::scheduler::SchedulerClient;
 use crate::shutdown;
-use dragonfly_api::scheduler::v2::{DeletePersistentCacheTaskRequest, DeleteTaskRequest};
+use chrono::Utc;
+use dragonfly_api::scheduler::v2::DeleteTaskRequest;
 use dragonfly_client_config::dfdaemon::Config;
 use dragonfly_client_core::Result;
-use dragonfly_client_storage::{
-    content::{DEFAULT_CONTENT_DIR, DEFAULT_PERSISTENT_CACHE_TASK_DIR, DEFAULT_TASK_DIR},
-    metadata, Storage,
-};
+use dragonfly_client_storage::{metadata, Storage};
 use std::sync::Arc;
+use std::time::Duration;
 use tokio::sync::mpsc;
 use tracing::{error, info, instrument};
 
+// DOWNLOAD_TASK_TIMEOUT is the timeout of downloading the task. If the task download timeout, the
+// task will be garbage collected by disk usage, default 2 hours.
+pub const DOWNLOAD_TASK_TIMEOUT: Duration = Duration::from_secs(2 * 60 * 60);
+
 /// GC is the garbage collector of dfdaemon.
 pub struct GC {
     /// config is the configuration of the dfdaemon.
@@ -50,7 +53,6 @@ pub struct GC {
 
 impl GC {
     /// new creates a new GC.
-    #[instrument(skip_all)]
     pub fn new(
         config: Arc<Config>,
         host_id: String,
@@ -70,7 +72,6 @@ impl GC {
     }
 
     /// run runs the garbage collector.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();
@@ -103,7 +104,7 @@ impl GC {
                 _ = shutdown.recv() => {
                     // Shutdown the garbage collector.
                     info!("garbage collector shutting down");
-                    return;
+                    return
                 }
             }
         }
@@ -124,22 +125,15 @@ impl GC {
             }
         }
 
+        info!("evict by task ttl done");
         Ok(())
     }
 
     /// evict_task_by_disk_usage evicts the task by disk usage.
     #[instrument(skip_all)]
     async fn evict_task_by_disk_usage(&self) -> Result<()> {
-        let stats = fs2::statvfs(
-            self.config
-                .storage
-                .dir
-                .join(DEFAULT_CONTENT_DIR)
-                .join(DEFAULT_TASK_DIR)
-                .as_path(),
-        )?;
-        let available_space = stats.available_space();
-        let total_space = stats.total_space();
+        let available_space = self.storage.available_space()?;
+        let total_space = self.storage.total_space()?;
 
         // Calculate the usage percent.
         let usage_percent = (100 - available_space * 100 / total_space) as u8;
@@ -158,6 +152,8 @@ impl GC {
             if let Err(err) = self.evict_task_space(need_evict_space as u64).await {
                 info!("failed to evict task by disk usage: {}", err);
             }
+
+            info!("evict task by disk usage done");
         }
 
         Ok(())
@@ -176,15 +172,35 @@ impl GC {
                 break;
             }
 
-            // If the task has no content length, skip it.
+            // If the task has downloaded finished, task has the content length, evicted space is the
+            // content length. If the task has started and did not download the data, and content
+            // length is 0, evicted space is 0.
             let task_space = match task.content_length() {
                 Some(content_length) => content_length,
                 None => {
-                    error!("task {} has no content length", task.id);
-                    continue;
+                    // If the task has no content length, skip it.
+                    if !task.is_failed() {
+                        error!("task {} has no content length", task.id);
+                        continue;
+                    }
+
+                    // If the task has started and did not download the data, and content length is 0.
+                    info!("task {} is failed, has no content length", task.id);
+                    0
                 }
             };
 
+            //  If the task is started and not finished, and the task download is not timeout,
+            //  skip it.
+            if task.is_started()
+                && !task.is_finished()
+                && !task.is_failed()
+                && (task.created_at + DOWNLOAD_TASK_TIMEOUT > Utc::now().naive_utc())
+            {
+                info!("task {} is started and not finished, skip it", task.id);
+                continue;
+            }
+
             // Evict the task.
             self.storage.delete_task(&task.id).await;
 
@@ -217,35 +233,24 @@ impl GC {
     /// evict_persistent_cache_task_by_ttl evicts the persistent cache task by ttl.
     #[instrument(skip_all)]
     async fn evict_persistent_cache_task_by_ttl(&self) -> Result<()> {
-        info!("start to evict by persistent cache task ttl * 2");
+        info!("start to evict by persistent cache task ttl");
         for task in self.storage.get_persistent_cache_tasks()? {
             // If the persistent cache task is expired and not uploading, evict the persistent cache task.
             if task.is_expired() {
                 self.storage.delete_persistent_cache_task(&task.id).await;
                 info!("evict persistent cache task {}", task.id);
-
-                self.delete_persistent_cache_task_from_scheduler(task.clone())
-                    .await;
-                info!("delete persistent cache task {} from scheduler", task.id);
             }
         }
 
+        info!("evict by persistent cache task ttl done");
         Ok(())
     }
 
     /// evict_persistent_cache_task_by_disk_usage evicts the persistent cache task by disk usage.
     #[instrument(skip_all)]
     async fn evict_persistent_cache_task_by_disk_usage(&self) -> Result<()> {
-        let stats = fs2::statvfs(
-            self.config
-                .storage
-                .dir
-                .join(DEFAULT_CONTENT_DIR)
-                .join(DEFAULT_PERSISTENT_CACHE_TASK_DIR)
-                .as_path(),
-        )?;
-        let available_space = stats.available_space();
-        let total_space = stats.total_space();
+        let available_space = self.storage.available_space()?;
+        let total_space = self.storage.total_space()?;
 
         // Calculate the usage percent.
         let usage_percent = (100 - available_space * 100 / total_space) as u8;
@@ -267,6 +272,8 @@ impl GC {
             {
                 info!("failed to evict task by disk usage: {}", err);
             }
+
+            info!("evict persistent cache task by disk usage done");
         }
 
         Ok(())
@@ -290,44 +297,33 @@ impl GC {
                 continue;
             }
 
-            let task_space = task.content_length();
+            //  If the task is started and not finished, and the task download is not timeout,
+            //  skip it.
+            if task.is_started()
+                && !task.is_finished()
+                && !task.is_failed()
+                && (task.created_at + DOWNLOAD_TASK_TIMEOUT > Utc::now().naive_utc())
+            {
+                info!(
+                    "persistent cache task {} is started and not finished, skip it",
+                    task.id
+                );
+                continue;
+            }
 
             // Evict the task.
-            self.storage.delete_task(&task.id).await;
+            self.storage.delete_persistent_cache_task(&task.id).await;
 
             // Update the evicted space.
+            let task_space = task.content_length();
             evicted_space += task_space;
             info!(
                 "evict persistent cache task {} size {}",
                 task.id, task_space
             );
-
-            self.delete_persistent_cache_task_from_scheduler(task.clone())
-                .await;
-            info!("delete persistent cache task {} from scheduler", task.id);
         }
 
         info!("evict total size {}", evicted_space);
         Ok(())
     }
-
-    /// delete_persistent_cache_task_from_scheduler deletes the persistent cache task from the scheduler.
-    #[instrument(skip_all)]
-    async fn delete_persistent_cache_task_from_scheduler(
-        &self,
-        task: metadata::PersistentCacheTask,
-    ) {
-        self.scheduler_client
-            .delete_persistent_cache_task(DeletePersistentCacheTaskRequest {
-                host_id: self.host_id.clone(),
-                task_id: task.id.clone(),
-            })
-            .await
-            .unwrap_or_else(|err| {
-                error!(
-                    "failed to delete persistent cache peer {}: {}",
-                    task.id, err
-                );
-            });
-    }
 }

dragonfly-client/src/grpc/health.rs

@@ -21,6 +21,7 @@ use dragonfly_client_core::{
 use hyper_util::rt::TokioIo;
 use std::path::PathBuf;
 use tokio::net::UnixStream;
+use tonic::service::interceptor::InterceptedService;
 use tonic::transport::ClientTlsConfig;
 use tonic::transport::{Channel, Endpoint, Uri};
 use tonic_health::pb::{
@@ -29,17 +30,18 @@ use tonic_health::pb::{
 use tower::service_fn;
 use tracing::{error, instrument};
 
+use super::interceptor::InjectTracingInterceptor;
+
 /// HealthClient is a wrapper of HealthGRPCClient.
 #[derive(Clone)]
 pub struct HealthClient {
     /// client is the grpc client of the certificate.
-    client: HealthGRPCClient<Channel>,
+    client: HealthGRPCClient<InterceptedService<Channel, InjectTracingInterceptor>>,
 }
 
 /// HealthClient implements the grpc client of the health.
 impl HealthClient {
     /// new creates a new HealthClient.
-    #[instrument(skip_all)]
     pub async fn new(addr: &str, client_tls_config: Option<ClientTlsConfig>) -> Result<Self> {
         let channel = match client_tls_config {
             Some(client_tls_config) => Channel::from_shared(addr.to_string())
@@ -52,9 +54,8 @@ impl HealthClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr, err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
             None => Channel::from_shared(addr.to_string())
@@ -66,21 +67,19 @@ impl HealthClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr, err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
         };
 
-        let client = HealthGRPCClient::new(channel)
+        let client = HealthGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
             .max_decoding_message_size(usize::MAX)
             .max_encoding_message_size(usize::MAX);
         Ok(Self { client })
     }
 
     /// new_unix creates a new HealthClient with unix domain socket.
-    #[instrument(skip_all)]
     pub async fn new_unix(socket_path: PathBuf) -> Result<Self> {
         // Ignore the uri because it is not used.
         let channel = Endpoint::try_from("http://[::]:50051")
@@ -94,12 +93,12 @@ impl HealthClient {
                 }
             }))
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 error!("connect failed: {}", err);
-                err
             })
             .or_err(ErrorType::ConnectError)?;
-        let client = HealthGRPCClient::new(channel)
+
+        let client = HealthGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
             .max_decoding_message_size(usize::MAX)
             .max_encoding_message_size(usize::MAX);
         Ok(Self { client })
@@ -138,7 +137,6 @@ impl HealthClient {
     }
 
     /// make_request creates a new request with timeout.
-    #[instrument(skip_all)]
     fn make_request<T>(request: T) -> tonic::Request<T> {
         let mut request = tonic::Request::new(request);
         request.set_timeout(super::REQUEST_TIMEOUT);

dragonfly-client/src/grpc/interceptor.rs

@@ -0,0 +1,86 @@
+/*
+ *     Copyright 2024 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use tonic::{metadata, service::Interceptor, Request, Status};
+use tracing_opentelemetry::OpenTelemetrySpanExt;
+
+/// MetadataMap is a tracing meda data map container for span context.
+struct MetadataMap<'a>(&'a mut metadata::MetadataMap);
+
+/// MetadataMap implements the otel tracing Extractor.
+impl opentelemetry::propagation::Extractor for MetadataMap<'_> {
+    /// Get a value for a key from the `MetadataMap`.  If the value can't be converted to &str, returns None
+    fn get(&self, key: &str) -> Option<&str> {
+        self.0.get(key).and_then(|metadata| metadata.to_str().ok())
+    }
+
+    /// Collect all the keys from the `MetadataMap`.
+    fn keys(&self) -> Vec<&str> {
+        self.0
+            .keys()
+            .map(|key| match key {
+                tonic::metadata::KeyRef::Ascii(v) => v.as_str(),
+                tonic::metadata::KeyRef::Binary(v) => v.as_str(),
+            })
+            .collect::<Vec<_>>()
+    }
+}
+
+/// MetadataMap implements the otel tracing Injector.
+impl opentelemetry::propagation::Injector for MetadataMap<'_> {
+    /// set a key-value pair to the injector.
+    fn set(&mut self, key: &str, value: String) {
+        if let Ok(key) = metadata::MetadataKey::from_bytes(key.as_bytes()) {
+            if let Ok(val) = metadata::MetadataValue::try_from(&value) {
+                self.0.insert(key, val);
+            }
+        }
+    }
+}
+
+/// InjectTracingInterceptor is a auto-inject tracing gRPC interceptor.
+#[derive(Clone)]
+pub struct InjectTracingInterceptor;
+
+/// InjectTracingInterceptor implements the tonic Interceptor interface.
+impl Interceptor for InjectTracingInterceptor {
+    /// call and inject tracing context into lgobal propagator.
+    fn call(&mut self, mut request: Request<()>) -> std::result::Result<Request<()>, Status> {
+        let context = tracing::Span::current().context();
+        opentelemetry::global::get_text_map_propagator(|prop| {
+            prop.inject_context(&context, &mut MetadataMap(request.metadata_mut()));
+        });
+
+        Ok(request)
+    }
+}
+
+/// ExtractTracingInterceptor is a auto-extract tracing gRPC interceptor.
+#[derive(Clone)]
+pub struct ExtractTracingInterceptor;
+
+/// ExtractTracingInterceptor implements the tonic Interceptor interface.
+impl Interceptor for ExtractTracingInterceptor {
+    /// call and inject tracing context into lgobal propagator.
+    fn call(&mut self, mut request: Request<()>) -> std::result::Result<Request<()>, Status> {
+        let parent_cx = opentelemetry::global::get_text_map_propagator(|prop| {
+            prop.extract(&MetadataMap(request.metadata_mut()))
+        });
+
+        request.extensions_mut().insert(parent_cx);
+        Ok(request)
+    }
+}

dragonfly-client/src/grpc/manager.rs

@@ -25,22 +25,23 @@ use dragonfly_client_core::{
     Error, Result,
 };
 use std::sync::Arc;
-use tonic::transport::Channel;
+use tonic::{service::interceptor::InterceptedService, transport::Channel};
 use tonic_health::pb::health_check_response::ServingStatus;
-use tracing::{error, instrument, warn};
+use tracing::{error, instrument};
 use url::Url;
 
+use super::interceptor::InjectTracingInterceptor;
+
 /// ManagerClient is a wrapper of ManagerGRPCClient.
 #[derive(Clone)]
 pub struct ManagerClient {
     /// client is the grpc client of the manager.
-    pub client: ManagerGRPCClient<Channel>,
+    pub client: ManagerGRPCClient<InterceptedService<Channel, InjectTracingInterceptor>>,
 }
 
 /// ManagerClient implements the grpc client of the manager.
 impl ManagerClient {
     /// new creates a new ManagerClient.
-    #[instrument(skip_all)]
     pub async fn new(config: Arc<Config>, addr: String) -> Result<Self> {
         let domain_name = Url::parse(addr.as_str())?
             .host_str()
@@ -77,9 +78,8 @@ impl ManagerClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr.to_string(), err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
             None => Channel::from_shared(addr.clone())
@@ -92,14 +92,13 @@ impl ManagerClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr.to_string(), err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
         };
 
-        let client = ManagerGRPCClient::new(channel)
+        let client = ManagerGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
             .max_decoding_message_size(usize::MAX)
             .max_encoding_message_size(usize::MAX);
         Ok(Self { client })
@@ -133,7 +132,6 @@ impl ManagerClient {
     }
 
     /// make_request creates a new request with timeout.
-    #[instrument(skip_all)]
     fn make_request<T>(request: T) -> tonic::Request<T> {
         let mut request = tonic::Request::new(request);
         request.set_timeout(super::REQUEST_TIMEOUT);

dragonfly-client/src/grpc/mod.rs

@@ -27,14 +27,19 @@ use tracing::{error, info, instrument, Instrument};
 pub mod dfdaemon_download;
 pub mod dfdaemon_upload;
 pub mod health;
+pub mod interceptor;
 pub mod manager;
 pub mod scheduler;
 
 /// CONNECT_TIMEOUT is the timeout for GRPC connection.
 pub const CONNECT_TIMEOUT: Duration = Duration::from_secs(2);
 
-/// REQUEST_TIMEOUT is the timeout for GRPC requests.
-pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
+/// REQUEST_TIMEOUT is the timeout for GRPC requests, default is 10 second.
+/// Note: This timeout is used for the whole request, including wait for scheduler
+/// scheduling, refer to https://d7y.io/docs/next/reference/configuration/scheduler/.
+/// Scheduler'configure `scheduler.retryInterval`, `scheduler.retryBackToSourceLimit` and `scheduler.retryLimit`
+/// is used for the scheduler to schedule the task.
+pub const REQUEST_TIMEOUT: Duration = Duration::from_secs(15);
 
 /// TCP_KEEPALIVE is the keepalive duration for TCP connection.
 pub const TCP_KEEPALIVE: Duration = Duration::from_secs(3600);
@@ -45,11 +50,11 @@ pub const HTTP2_KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(300);
 /// HTTP2_KEEP_ALIVE_TIMEOUT is the timeout for HTTP2 keep alive.
 pub const HTTP2_KEEP_ALIVE_TIMEOUT: Duration = Duration::from_secs(20);
 
-/// MAX_FRAME_SIZE is the max frame size for GRPC, default is 12MB.
-pub const MAX_FRAME_SIZE: u32 = 12 * 1024 * 1024;
+/// MAX_FRAME_SIZE is the max frame size for GRPC, default is 4MB.
+pub const MAX_FRAME_SIZE: u32 = 4 * 1024 * 1024;
 
-/// INITIAL_WINDOW_SIZE is the initial window size for GRPC, default is 12MB.
-pub const INITIAL_WINDOW_SIZE: u32 = 12 * 1024 * 1024;
+/// INITIAL_WINDOW_SIZE is the initial window size for GRPC, default is 512KB.
+pub const INITIAL_WINDOW_SIZE: u32 = 512 * 1024;
 
 /// BUFFER_SIZE is the buffer size for GRPC, default is 64KB.
 pub const BUFFER_SIZE: usize = 64 * 1024;
@@ -76,6 +81,9 @@ pub async fn prefetch_task(
     // Remove the prefetch flag for prevent the infinite loop.
     download.prefetch = false;
 
+    // Mark the is_prefetch flag as true to represents it is a prefetch request.
+    download.is_prefetch = true;
+
     // Remove the range header for download full task.
     download
         .request_header
@@ -91,9 +99,8 @@ pub async fn prefetch_task(
     let response = dfdaemon_download_client
         .download_task(request)
         .await
-        .map_err(|err| {
+        .inspect_err(|err| {
             error!("prefetch task failed: {}", err);
-            err
         })?;
 
     // Collect the prefetch task started metrics.

dragonfly-client/src/grpc/scheduler.rs

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-// use crate::dynconfig::Dynconfig;
 use crate::dynconfig::Dynconfig;
 use dragonfly_api::common::v2::{Peer, PersistentCachePeer, PersistentCacheTask, Task};
 use dragonfly_api::manager::v2::Scheduler;
@@ -36,10 +35,13 @@ use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use tokio::task::JoinSet;
+use tonic::service::interceptor::InterceptedService;
 use tonic::transport::Channel;
 use tracing::{error, info, instrument, Instrument};
 use url::Url;
 
+use super::interceptor::InjectTracingInterceptor;
+
 /// VNode is the virtual node of the hashring.
 #[derive(Debug, Copy, Clone, Hash, PartialEq)]
 struct VNode {
@@ -77,7 +79,6 @@ pub struct SchedulerClient {
 /// SchedulerClient implements the grpc client of the scheduler.
 impl SchedulerClient {
     /// new creates a new SchedulerClient.
-    #[instrument(skip_all)]
     pub async fn new(config: Arc<Config>, dynconfig: Arc<Dynconfig>) -> Result<Self> {
         let client = Self {
             config,
@@ -185,15 +186,15 @@ impl SchedulerClient {
                     .timeout(super::REQUEST_TIMEOUT)
                     .connect()
                     .await
-                    .map_err(|err| {
+                    .inspect_err(|err| {
                         error!("connect to {} failed: {}", addr.to_string(), err);
-                        err
                     })
                     .or_err(ErrorType::ConnectError)?;
 
-                let mut client = SchedulerGRPCClient::new(channel)
-                    .max_decoding_message_size(usize::MAX)
-                    .max_encoding_message_size(usize::MAX);
+                let mut client =
+                    SchedulerGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
+                        .max_decoding_message_size(usize::MAX)
+                        .max_encoding_message_size(usize::MAX);
                 client.announce_host(request).await?;
                 Ok(())
             }
@@ -239,15 +240,15 @@ impl SchedulerClient {
                     .timeout(super::REQUEST_TIMEOUT)
                     .connect()
                     .await
-                    .map_err(|err| {
+                    .inspect_err(|err| {
                         error!("connect to {} failed: {}", addr.to_string(), err);
-                        err
                     })
                     .or_err(ErrorType::ConnectError)?;
 
-                let mut client = SchedulerGRPCClient::new(channel)
-                    .max_decoding_message_size(usize::MAX)
-                    .max_encoding_message_size(usize::MAX);
+                let mut client =
+                    SchedulerGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
+                        .max_decoding_message_size(usize::MAX)
+                        .max_encoding_message_size(usize::MAX);
                 client.announce_host(request).await?;
                 Ok(())
             }
@@ -298,15 +299,15 @@ impl SchedulerClient {
                     .timeout(super::REQUEST_TIMEOUT)
                     .connect()
                     .await
-                    .map_err(|err| {
+                    .inspect_err(|err| {
                         error!("connect to {} failed: {}", addr.to_string(), err);
-                        err
                     })
                     .or_err(ErrorType::ConnectError)?;
 
-                let mut client = SchedulerGRPCClient::new(channel)
-                    .max_decoding_message_size(usize::MAX)
-                    .max_encoding_message_size(usize::MAX);
+                let mut client =
+                    SchedulerGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
+                        .max_decoding_message_size(usize::MAX)
+                        .max_encoding_message_size(usize::MAX);
                 client.delete_host(request).await?;
                 Ok(())
             }
@@ -458,7 +459,7 @@ impl SchedulerClient {
         &self,
         task_id: &str,
         peer_id: Option<&str>,
-    ) -> Result<SchedulerGRPCClient<Channel>> {
+    ) -> Result<SchedulerGRPCClient<InterceptedService<Channel, InjectTracingInterceptor>>> {
         // Update scheduler addresses of the client.
         self.update_available_scheduler_addrs().await?;
 
@@ -496,9 +497,8 @@ impl SchedulerClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr.to_string(), err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
             None => Channel::from_shared(addr.clone())
@@ -511,25 +511,27 @@ impl SchedulerClient {
                 .keep_alive_timeout(super::HTTP2_KEEP_ALIVE_TIMEOUT)
                 .connect()
                 .await
-                .map_err(|err| {
+                .inspect_err(|err| {
                     error!("connect to {} failed: {}", addr.to_string(), err);
-                    err
                 })
                 .or_err(ErrorType::ConnectError)?,
         };
 
-        Ok(SchedulerGRPCClient::new(channel)
-            .max_decoding_message_size(usize::MAX)
-            .max_encoding_message_size(usize::MAX))
+        Ok(
+            SchedulerGRPCClient::with_interceptor(channel, InjectTracingInterceptor)
+                .max_decoding_message_size(usize::MAX)
+                .max_encoding_message_size(usize::MAX),
+        )
     }
 
     /// update_available_scheduler_addrs updates the addresses of available schedulers.
     #[instrument(skip(self))]
     async fn update_available_scheduler_addrs(&self) -> Result<()> {
         // Get the endpoints of available schedulers.
-        let data = self.dynconfig.data.read().await;
-        let data_available_schedulers_clone = data.available_schedulers.clone();
-        drop(data);
+        let data_available_schedulers_clone = {
+            let data = self.dynconfig.data.read().await;
+            data.available_schedulers.clone()
+        };
 
         // Check if the available schedulers is empty.
         if data_available_schedulers_clone.is_empty() {
@@ -537,9 +539,10 @@ impl SchedulerClient {
         }
 
         // Get the available schedulers.
-        let available_schedulers = self.available_schedulers.read().await;
-        let available_schedulers_clone = available_schedulers.clone();
-        drop(available_schedulers);
+        let available_schedulers_clone = {
+            let available_schedulers = self.available_schedulers.read().await;
+            available_schedulers.clone()
+        };
 
         // Check if the available schedulers is not changed.
         if data_available_schedulers_clone.len() == available_schedulers_clone.len()
@@ -574,13 +577,11 @@ impl SchedulerClient {
             new_available_schedulers.push(available_scheduler.clone());
 
             // Add the scheduler address to the addresses of available schedulers.
-            new_available_scheduler_addrs
-                .push(SocketAddr::new(ip, available_scheduler.port as u16));
+            let socket_addr = SocketAddr::new(ip, available_scheduler.port as u16);
+            new_available_scheduler_addrs.push(socket_addr);
 
             // Add the scheduler to the hashring.
-            new_hashring.add(VNode {
-                addr: SocketAddr::new(ip, available_scheduler.port as u16),
-            });
+            new_hashring.add(VNode { addr: socket_addr });
         }
 
         // Update the available schedulers.
@@ -620,7 +621,6 @@ impl SchedulerClient {
     }
 
     /// make_request creates a new request with timeout.
-    #[instrument(skip_all)]
     fn make_request<T>(request: T) -> tonic::Request<T> {
         let mut request = tonic::Request::new(request);
         request.set_timeout(super::REQUEST_TIMEOUT);

dragonfly-client/src/health/mod.rs

@@ -36,7 +36,6 @@ pub struct Health {
 /// Health implements the health server.
 impl Health {
     /// new creates a new Health.
-    #[instrument(skip_all)]
     pub fn new(
         addr: SocketAddr,
         shutdown: shutdown::Shutdown,
@@ -50,7 +49,6 @@ impl Health {
     }
 
     /// run starts the health server.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();

dragonfly-client/src/metrics/mod.rs

@@ -177,6 +177,27 @@ lazy_static! {
             &[]
         ).expect("metric can be created");
 
+    /// PROXY_REQUEST_VIA_DFDAEMON_COUNT is used to count the number of proxy requset via dfdaemon.
+    pub static ref PROXY_REQUEST_VIA_DFDAEMON_COUNT: IntCounterVec =
+        IntCounterVec::new(
+            Opts::new("proxy_request_via_dfdaemon_total", "Counter of the number of the proxy request via dfdaemon.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
+            &[]
+        ).expect("metric can be created");
+
+    /// UPDATE_TASK_COUNT is used to count the number of update tasks.
+    pub static ref UPDATE_TASK_COUNT: IntCounterVec =
+        IntCounterVec::new(
+            Opts::new("update_task_total", "Counter of the number of the update task.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
+            &["type"]
+        ).expect("metric can be created");
+
+    /// UPDATE_TASK_FAILURE_COUNT is used to count the failed number of update tasks.
+    pub static ref UPDATE_TASK_FAILURE_COUNT: IntCounterVec =
+        IntCounterVec::new(
+            Opts::new("update_task_failure_total", "Counter of the number of failed of the update task.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
+            &["type"]
+        ).expect("metric can be created");
+
     /// STAT_TASK_COUNT is used to count the number of stat tasks.
     pub static ref STAT_TASK_COUNT: IntCounterVec =
         IntCounterVec::new(
@@ -191,7 +212,21 @@ lazy_static! {
             &["type"]
         ).expect("metric can be created");
 
-    /// DELETE_TASK_COUNT is used to count the number of delete tasks.
+    /// LIST_TASK_ENTRIES_COUNT is used to count the number of list task entries.
+    pub static ref LIST_TASK_ENTRIES_COUNT: IntCounterVec =
+        IntCounterVec::new(
+            Opts::new("list_task_entries_total", "Counter of the number of the list task entries.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
+            &["type"]
+        ).expect("metric can be created");
+
+    /// LIST_TASK_ENTRIES_FAILURE_COUNT is used to count the failed number of list task entries.
+    pub static ref LIST_TASK_ENTRIES_FAILURE_COUNT: IntCounterVec =
+        IntCounterVec::new(
+            Opts::new("list_task_entries_failure_total", "Counter of the number of failed of the list task entries.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
+            &["type"]
+        ).expect("metric can be created");
+
+        /// DELETE_TASK_COUNT is used to count the number of delete tasks.
     pub static ref DELETE_TASK_COUNT: IntCounterVec =
         IntCounterVec::new(
             Opts::new("delete_task_total", "Counter of the number of the delete task.").namespace(dragonfly_client_config::SERVICE_NAME).subsystem(dragonfly_client_config::NAME),
@@ -234,6 +269,153 @@ lazy_static! {
         ).expect("metric can be created");
 }
 
+/// register_custom_metrics registers all custom metrics.
+fn register_custom_metrics() {
+    REGISTRY
+        .register(Box::new(VERSION_GAUGE.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DOWNLOAD_TASK_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DOWNLOAD_TASK_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(PREFETCH_TASK_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(PREFETCH_TASK_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(CONCURRENT_DOWNLOAD_TASK_GAUGE.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(CONCURRENT_UPLOAD_PIECE_GAUGE.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DOWNLOAD_TRAFFIC.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(UPLOAD_TRAFFIC.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DOWNLOAD_TASK_DURATION.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(BACKEND_REQUEST_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(BACKEND_REQUEST_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(BACKEND_REQUEST_DURATION.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(PROXY_REQUEST_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(PROXY_REQUEST_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(PROXY_REQUEST_VIA_DFDAEMON_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(UPDATE_TASK_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(UPDATE_TASK_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(STAT_TASK_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(STAT_TASK_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(LIST_TASK_ENTRIES_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(LIST_TASK_ENTRIES_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DELETE_TASK_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DELETE_TASK_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DELETE_HOST_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DELETE_HOST_FAILURE_COUNT.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DISK_SPACE.clone()))
+        .expect("metric can be registered");
+
+    REGISTRY
+        .register(Box::new(DISK_USAGE_SPACE.clone()))
+        .expect("metric can be registered");
+}
+
+/// reset_custom_metrics resets all custom metrics.
+fn reset_custom_metrics() {
+    VERSION_GAUGE.reset();
+    DOWNLOAD_TASK_COUNT.reset();
+    DOWNLOAD_TASK_FAILURE_COUNT.reset();
+    PREFETCH_TASK_COUNT.reset();
+    PREFETCH_TASK_FAILURE_COUNT.reset();
+    CONCURRENT_DOWNLOAD_TASK_GAUGE.reset();
+    CONCURRENT_UPLOAD_PIECE_GAUGE.reset();
+    DOWNLOAD_TRAFFIC.reset();
+    UPLOAD_TRAFFIC.reset();
+    DOWNLOAD_TASK_DURATION.reset();
+    BACKEND_REQUEST_COUNT.reset();
+    BACKEND_REQUEST_FAILURE_COUNT.reset();
+    BACKEND_REQUEST_DURATION.reset();
+    PROXY_REQUEST_COUNT.reset();
+    PROXY_REQUEST_FAILURE_COUNT.reset();
+    PROXY_REQUEST_VIA_DFDAEMON_COUNT.reset();
+    UPDATE_TASK_COUNT.reset();
+    UPDATE_TASK_FAILURE_COUNT.reset();
+    STAT_TASK_COUNT.reset();
+    STAT_TASK_FAILURE_COUNT.reset();
+    LIST_TASK_ENTRIES_COUNT.reset();
+    LIST_TASK_ENTRIES_FAILURE_COUNT.reset();
+    DELETE_TASK_COUNT.reset();
+    DELETE_TASK_FAILURE_COUNT.reset();
+    DELETE_HOST_COUNT.reset();
+    DELETE_HOST_FAILURE_COUNT.reset();
+    DISK_SPACE.reset();
+    DISK_USAGE_SPACE.reset();
+}
+
 /// TaskSize represents the size of the task.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TaskSize {
@@ -363,12 +545,12 @@ impl TaskSize {
 
 /// collect_upload_task_started_metrics collects the upload task started metrics.
 pub fn collect_upload_task_started_metrics(typ: i32, tag: &str, app: &str) {
-    UPLOAD_TASK_COUNT
-        .with_label_values(&[typ.to_string().as_str(), tag, app])
-        .inc();
+    let typ = typ.to_string();
+
+    UPLOAD_TASK_COUNT.with_label_values(&[&typ, tag, app]).inc();
 
     CONCURRENT_UPLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app])
+        .with_label_values(&[&typ, tag, app])
         .inc();
 }
 
@@ -391,34 +573,41 @@ pub fn collect_upload_task_finished_metrics(
         );
     }
 
+    let typ = typ.to_string();
+    let task_size = task_size.to_string();
+
     UPLOAD_TASK_DURATION
-        .with_label_values(&[typ.to_string().as_str(), task_size.to_string().as_str()])
+        .with_label_values(&[&typ, &task_size])
         .observe(cost.as_millis() as f64);
 
     CONCURRENT_UPLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app])
+        .with_label_values(&[&typ, tag, app])
         .dec();
 }
 
 /// collect_upload_task_failure_metrics collects the upload task failure metrics.
 pub fn collect_upload_task_failure_metrics(typ: i32, tag: &str, app: &str) {
+    let typ = typ.to_string();
+
     UPLOAD_TASK_FAILURE_COUNT
-        .with_label_values(&[typ.to_string().as_str(), tag, app])
+        .with_label_values(&[&typ, tag, app])
         .inc();
 
     CONCURRENT_UPLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app])
+        .with_label_values(&[&typ, tag, app])
         .dec();
 }
 
 /// collect_download_task_started_metrics collects the download task started metrics.
 pub fn collect_download_task_started_metrics(typ: i32, tag: &str, app: &str, priority: &str) {
+    let typ = typ.to_string();
+
     DOWNLOAD_TASK_COUNT
-        .with_label_values(&[typ.to_string().as_str(), tag, app, priority])
+        .with_label_values(&[&typ, tag, app, priority])
         .inc();
 
     CONCURRENT_DOWNLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app, priority])
+        .with_label_values(&[&typ, tag, app, priority])
         .inc();
 }
 
@@ -449,23 +638,28 @@ pub fn collect_download_task_finished_metrics(
         );
     }
 
+    let typ = typ.to_string();
+    let task_size = task_size.to_string();
+
     DOWNLOAD_TASK_DURATION
-        .with_label_values(&[typ.to_string().as_str(), task_size.to_string().as_str()])
+        .with_label_values(&[&typ, &task_size])
         .observe(cost.as_millis() as f64);
 
     CONCURRENT_DOWNLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app, priority])
+        .with_label_values(&[&typ, tag, app, priority])
         .dec();
 }
 
 /// collect_download_task_failure_metrics collects the download task failure metrics.
 pub fn collect_download_task_failure_metrics(typ: i32, tag: &str, app: &str, priority: &str) {
+    let typ = typ.to_string();
+
     DOWNLOAD_TASK_FAILURE_COUNT
-        .with_label_values(&[typ.to_string().as_str(), tag, app, priority])
+        .with_label_values(&[&typ, tag, app, priority])
         .inc();
 
     CONCURRENT_DOWNLOAD_TASK_GAUGE
-        .with_label_values(&[typ.to_string().as_str(), tag, app, priority])
+        .with_label_values(&[&typ, tag, app, priority])
         .dec();
 }
 
@@ -543,6 +737,27 @@ pub fn collect_proxy_request_failure_metrics() {
     PROXY_REQUEST_FAILURE_COUNT.with_label_values(&[]).inc();
 }
 
+/// collect_proxy_request_via_dfdaemon_metrics collects the proxy request via dfdaemon metrics.
+pub fn collect_proxy_request_via_dfdaemon_metrics() {
+    PROXY_REQUEST_VIA_DFDAEMON_COUNT
+        .with_label_values(&[])
+        .inc();
+}
+
+/// collect_update_task_started_metrics collects the update task started metrics.
+pub fn collect_update_task_started_metrics(typ: i32) {
+    UPDATE_TASK_COUNT
+        .with_label_values(&[typ.to_string().as_str()])
+        .inc();
+}
+
+/// collect_update_task_failure_metrics collects the update task failure metrics.
+pub fn collect_update_task_failure_metrics(typ: i32) {
+    UPDATE_TASK_FAILURE_COUNT
+        .with_label_values(&[typ.to_string().as_str()])
+        .inc();
+}
+
 /// collect_stat_task_started_metrics collects the stat task started metrics.
 pub fn collect_stat_task_started_metrics(typ: i32) {
     STAT_TASK_COUNT
@@ -557,6 +772,20 @@ pub fn collect_stat_task_failure_metrics(typ: i32) {
         .inc();
 }
 
+/// collect_list_task_entries_started_metrics collects the list task entries started metrics.
+pub fn collect_list_task_entries_started_metrics(typ: i32) {
+    LIST_TASK_ENTRIES_COUNT
+        .with_label_values(&[typ.to_string().as_str()])
+        .inc();
+}
+
+/// collect_list_task_entries_failure_metrics collects the list task entries failure metrics.
+pub fn collect_list_task_entries_failure_metrics(typ: i32) {
+    LIST_TASK_ENTRIES_FAILURE_COUNT
+        .with_label_values(&[typ.to_string().as_str()])
+        .inc();
+}
+
 /// collect_delete_task_started_metrics collects the delete task started metrics.
 pub fn collect_delete_task_started_metrics(typ: i32) {
     DELETE_TASK_COUNT
@@ -581,8 +810,9 @@ pub fn collect_delete_host_failure_metrics() {
     DELETE_HOST_FAILURE_COUNT.with_label_values(&[]).inc();
 }
 
-/// collect_disk_space_metrics collects the disk space metrics.
-pub fn collect_disk_space_metrics(path: &Path) {
+/// collect_disk_metrics collects the disk metrics.
+pub fn collect_disk_metrics(path: &Path) {
+    // Collect disk space metrics.
     let stats = match fs2::statvfs(path) {
         Ok(stats) => stats,
         Err(err) => {
@@ -616,7 +846,6 @@ pub struct Metrics {
 /// Metrics implements the metrics server.
 impl Metrics {
     /// new creates a new Metrics.
-    #[instrument(skip_all)]
     pub fn new(
         config: Arc<Config>,
         shutdown: shutdown::Shutdown,
@@ -630,21 +859,20 @@ impl Metrics {
     }
 
     /// run starts the metrics server.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();
 
         // Register custom metrics.
-        self.register_custom_metrics();
+        register_custom_metrics();
 
         // VERSION_GAUGE sets the version info of the service.
         VERSION_GAUGE
             .get_metric_with_label_values(&[
                 CARGO_PKG_VERSION,
-                &GIT_COMMIT_SHORT_HASH,
+                GIT_COMMIT_SHORT_HASH,
                 BUILD_PLATFORM,
-                &GIT_COMMIT_DATE,
+                GIT_COMMIT_DATE,
             ])
             .unwrap()
             .set(1);
@@ -658,16 +886,23 @@ impl Metrics {
             self.config.metrics.server.port,
         );
 
-        // Create the metrics route.
-        let metrics_route = warp::path!("metrics")
+        // Get the metrics route.
+        let get_metrics_route = warp::path!("metrics")
             .and(warp::get())
             .and(warp::path::end())
-            .and_then(move || Self::metrics_handler(config.clone()));
+            .and_then(move || Self::get_metrics_handler(config.clone()));
+
+        // Delete the metrics route.
+        let delete_metrics_route = warp::path!("metrics")
+            .and(warp::delete())
+            .and(warp::path::end())
+            .and_then(Self::delete_metrics_handler);
+        let metrics_routes = get_metrics_route.or(delete_metrics_route);
 
         // Start the metrics server and wait for it to finish.
         info!("metrics server listening on {}", addr);
         tokio::select! {
-            _ = warp::serve(metrics_route).run(addr) => {
+            _ = warp::serve(metrics_routes).run(addr) => {
                 // Metrics server ended.
                 info!("metrics server ended");
             }
@@ -678,107 +913,11 @@ impl Metrics {
         }
     }
 
-    /// register_custom_metrics registers all custom metrics.
+    /// get_metrics_handler handles the metrics request of getting.
     #[instrument(skip_all)]
-    fn register_custom_metrics(&self) {
-        REGISTRY
-            .register(Box::new(VERSION_GAUGE.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DOWNLOAD_TASK_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DOWNLOAD_TASK_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(PREFETCH_TASK_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(PREFETCH_TASK_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(CONCURRENT_DOWNLOAD_TASK_GAUGE.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(CONCURRENT_UPLOAD_PIECE_GAUGE.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DOWNLOAD_TRAFFIC.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(UPLOAD_TRAFFIC.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DOWNLOAD_TASK_DURATION.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(BACKEND_REQUEST_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(BACKEND_REQUEST_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(BACKEND_REQUEST_DURATION.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(PROXY_REQUEST_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(PROXY_REQUEST_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(STAT_TASK_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(STAT_TASK_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DELETE_TASK_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DELETE_TASK_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DELETE_HOST_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DELETE_HOST_FAILURE_COUNT.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DISK_SPACE.clone()))
-            .expect("metric can be registered");
-
-        REGISTRY
-            .register(Box::new(DISK_USAGE_SPACE.clone()))
-            .expect("metric can be registered");
-    }
-
-    /// metrics_handler handles the metrics request.
-    #[instrument(skip_all)]
-    async fn metrics_handler(config: Arc<Config>) -> Result<impl Reply, Rejection> {
+    async fn get_metrics_handler(config: Arc<Config>) -> Result<impl Reply, Rejection> {
         // Collect the disk space metrics.
-        collect_disk_space_metrics(config.storage.dir.as_path());
+        collect_disk_metrics(config.storage.dir.as_path());
 
         // Encode custom metrics.
         let encoder = TextEncoder::new();
@@ -814,4 +953,11 @@ impl Metrics {
         res.push_str(&res_custom);
         Ok(res)
     }
+
+    /// delete_metrics_handler handles the metrics request of deleting.
+    #[instrument(skip_all)]
+    async fn delete_metrics_handler() -> Result<impl Reply, Rejection> {
+        reset_custom_metrics();
+        Ok(Vec::new())
+    }
 }

dragonfly-client/src/proxy/header.rs

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 
+use bytesize::ByteSize;
 use dragonfly_api::common::v2::Priority;
 use reqwest::header::HeaderMap;
-use tracing::{error, instrument};
+use tracing::error;
 
 /// DRAGONFLY_TAG_HEADER is the header key of tag in http request.
 pub const DRAGONFLY_TAG_HEADER: &str = "X-Dragonfly-Tag";
@@ -51,38 +52,59 @@ pub const DRAGONFLY_USE_P2P_HEADER: &str = "X-Dragonfly-Use-P2P";
 /// If the value is "false", the range request will fetch the range content.
 pub const DRAGONFLY_PREFETCH_HEADER: &str = "X-Dragonfly-Prefetch";
 
+/// DRAGONFLY_OUTPUT_PATH_HEADER is the header key of absolute output path in http request.
+///
+/// If `X-Dragonfly-Output-Path` is set, the downloaded file will be saved to the specified path.
+/// Dfdaemon will try to create hard link to the output path before starting the download. If hard link creation fails,
+/// it will copy the file to the output path after the download is completed.
+/// For more details refer to https://github.com/dragonflyoss/design/blob/main/systems-analysis/file-download-workflow-with-hard-link/README.md.
+pub const DRAGONFLY_OUTPUT_PATH_HEADER: &str = "X-Dragonfly-Output-Path";
+
+/// DRAGONFLY_FORCE_HARD_LINK_HEADER is the header key of force hard link in http request.
+///
+/// `X-Dragonfly-Force-Hard-Link` is the flag to indicate whether the download file must be hard linked to the output path.
+/// For more details refer to https://github.com/dragonflyoss/design/blob/main/systems-analysis/file-download-workflow-with-hard-link/README.md.
+pub const DRAGONFLY_FORCE_HARD_LINK_HEADER: &str = "X-Dragonfly-Force-Hard-Link";
+
+/// DRAGONFLY_PIECE_LENGTH_HEADER is the header key of piece length in http request.
+/// If the value is set, the piece length will be used to download the file.
+/// Different piece length will generate different task id. The value needs to
+/// be set with human readable format and needs to be greater than or equal
+/// to 4mib, for example: 4mib, 1gib
+pub const DRAGONFLY_PIECE_LENGTH_HEADER: &str = "X-Dragonfly-Piece-Length";
+
+/// DRAGONFLY_CONTENT_FOR_CALCULATING_TASK_ID_HEADER is the header key of content for calculating task id.
+/// If DRAGONFLY_CONTENT_FOR_CALCULATING_TASK_ID_HEADER is set, use its value to calculate the task ID.
+/// Otherwise, calculate the task ID based on `url`, `piece_length`, `tag`, `application`, and `filtered_query_params`.
+pub const DRAGONFLY_CONTENT_FOR_CALCULATING_TASK_ID_HEADER: &str =
+    "X-Dragonfly-Content-For-Calculating-Task-ID";
+
+/// DRAGONFLY_TASK_DOWNLOAD_FINISHED_HEADER is the response header key to indicate whether the task download finished.
+/// When the task download is finished, the response will include this header with the value `"true"`,
+/// indicating that the download hit the local cache.
+pub const DRAGONFLY_TASK_DOWNLOAD_FINISHED_HEADER: &str = "X-Dragonfly-Task-Download-Finished";
+
+/// DRAGONFLY_TASK_ID_HEADER is the response header key of task id. Client will calculate the task ID
+/// based on `url`, `piece_length`, `tag`, `application`, and `filtered_query_params`.
+pub const DRAGONFLY_TASK_ID_HEADER: &str = "X-Dragonfly-Task-ID";
+
 /// get_tag gets the tag from http header.
-#[instrument(skip_all)]
 pub fn get_tag(header: &HeaderMap) -> Option<String> {
-    match header.get(DRAGONFLY_TAG_HEADER) {
-        Some(tag) => match tag.to_str() {
-            Ok(tag) => Some(tag.to_string()),
-            Err(err) => {
-                error!("get tag from header failed: {}", err);
-                None
-            }
-        },
-        None => None,
-    }
+    header
+        .get(DRAGONFLY_TAG_HEADER)
+        .and_then(|tag| tag.to_str().ok())
+        .map(|tag| tag.to_string())
 }
 
 /// get_application gets the application from http header.
-#[instrument(skip_all)]
 pub fn get_application(header: &HeaderMap) -> Option<String> {
-    match header.get(DRAGONFLY_APPLICATION_HEADER) {
-        Some(application) => match application.to_str() {
-            Ok(application) => Some(application.to_string()),
-            Err(err) => {
-                error!("get application from header failed: {}", err);
-                None
-            }
-        },
-        None => None,
-    }
+    header
+        .get(DRAGONFLY_APPLICATION_HEADER)
+        .and_then(|application| application.to_str().ok())
+        .map(|application| application.to_string())
 }
 
 /// get_priority gets the priority from http header.
-#[instrument(skip_all)]
 pub fn get_priority(header: &HeaderMap) -> i32 {
     let default_priority = Priority::Level6 as i32;
     match header.get(DRAGONFLY_PRIORITY_HEADER) {
@@ -104,29 +126,21 @@ pub fn get_priority(header: &HeaderMap) -> i32 {
 }
 
 /// get_registry gets the custom address of container registry from http header.
-#[instrument(skip_all)]
 pub fn get_registry(header: &HeaderMap) -> Option<String> {
-    match header.get(DRAGONFLY_REGISTRY_HEADER) {
-        Some(registry) => match registry.to_str() {
-            Ok(registry) => Some(registry.to_string()),
-            Err(err) => {
-                error!("get registry from header failed: {}", err);
-                None
-            }
-        },
-        None => None,
-    }
+    header
+        .get(DRAGONFLY_REGISTRY_HEADER)
+        .and_then(|registry| registry.to_str().ok())
+        .map(|registry| registry.to_string())
 }
 
 /// get_filters gets the filters from http header.
-#[instrument(skip_all)]
 pub fn get_filtered_query_params(
     header: &HeaderMap,
     default_filtered_query_params: Vec<String>,
 ) -> Vec<String> {
     match header.get(DRAGONFLY_FILTERED_QUERY_PARAMS_HEADER) {
         Some(filters) => match filters.to_str() {
-            Ok(filters) => filters.split(',').map(|s| s.to_string()).collect(),
+            Ok(filters) => filters.split(',').map(|s| s.trim().to_string()).collect(),
             Err(err) => {
                 error!("get filters from header failed: {}", err);
                 default_filtered_query_params
@@ -137,7 +151,6 @@ pub fn get_filtered_query_params(
 }
 
 /// get_use_p2p gets the use p2p from http header.
-#[instrument(skip_all)]
 pub fn get_use_p2p(header: &HeaderMap) -> bool {
     match header.get(DRAGONFLY_USE_P2P_HEADER) {
         Some(value) => match value.to_str() {
@@ -152,7 +165,6 @@ pub fn get_use_p2p(header: &HeaderMap) -> bool {
 }
 
 /// get_prefetch gets the prefetch from http header.
-#[instrument(skip_all)]
 pub fn get_prefetch(header: &HeaderMap) -> Option<bool> {
     match header.get(DRAGONFLY_PREFETCH_HEADER) {
         Some(value) => match value.to_str() {
@@ -165,3 +177,229 @@ pub fn get_prefetch(header: &HeaderMap) -> Option<bool> {
         None => None,
     }
 }
+
+/// get_output_path gets the output path from http header.
+pub fn get_output_path(header: &HeaderMap) -> Option<String> {
+    header
+        .get(DRAGONFLY_OUTPUT_PATH_HEADER)
+        .and_then(|output_path| output_path.to_str().ok())
+        .map(|output_path| output_path.to_string())
+}
+
+/// get_force_hard_link gets the force hard link from http header.
+pub fn get_force_hard_link(header: &HeaderMap) -> bool {
+    match header.get(DRAGONFLY_FORCE_HARD_LINK_HEADER) {
+        Some(value) => match value.to_str() {
+            Ok(value) => value.eq_ignore_ascii_case("true"),
+            Err(err) => {
+                error!("get force hard link from header failed: {}", err);
+                false
+            }
+        },
+        None => false,
+    }
+}
+
+/// get_piece_length gets the piece length from http header.
+pub fn get_piece_length(header: &HeaderMap) -> Option<ByteSize> {
+    match header.get(DRAGONFLY_PIECE_LENGTH_HEADER) {
+        Some(piece_length) => match piece_length.to_str() {
+            Ok(piece_length) => match piece_length.parse::<ByteSize>() {
+                Ok(piece_length) => Some(piece_length),
+                Err(err) => {
+                    error!("parse piece length from header failed: {}", err);
+                    None
+                }
+            },
+            Err(err) => {
+                error!("get piece length from header failed: {}", err);
+                None
+            }
+        },
+        None => None,
+    }
+}
+
+/// get_content_for_calculating_task_id gets the content for calculating task id from http header.
+pub fn get_content_for_calculating_task_id(header: &HeaderMap) -> Option<String> {
+    header
+        .get(DRAGONFLY_CONTENT_FOR_CALCULATING_TASK_ID_HEADER)
+        .and_then(|content| content.to_str().ok())
+        .map(|content| content.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use reqwest::header::{HeaderMap, HeaderValue};
+
+    #[test]
+    fn test_get_tag() {
+        let mut headers = HeaderMap::new();
+        headers.insert(DRAGONFLY_TAG_HEADER, HeaderValue::from_static("test-tag"));
+        assert_eq!(get_tag(&headers), Some("test-tag".to_string()));
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_tag(&empty_headers), None);
+    }
+
+    #[test]
+    fn test_get_application() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_APPLICATION_HEADER,
+            HeaderValue::from_static("test-app"),
+        );
+        assert_eq!(get_application(&headers), Some("test-app".to_string()));
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_application(&empty_headers), None);
+    }
+
+    #[test]
+    fn test_get_priority() {
+        let mut headers = HeaderMap::new();
+        headers.insert(DRAGONFLY_PRIORITY_HEADER, HeaderValue::from_static("5"));
+        assert_eq!(get_priority(&headers), 5);
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_priority(&empty_headers), Priority::Level6 as i32);
+
+        headers.insert(
+            DRAGONFLY_PRIORITY_HEADER,
+            HeaderValue::from_static("invalid"),
+        );
+        assert_eq!(get_priority(&headers), Priority::Level6 as i32);
+    }
+
+    #[test]
+    fn test_get_registry() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_REGISTRY_HEADER,
+            HeaderValue::from_static("test-registry"),
+        );
+        assert_eq!(get_registry(&headers), Some("test-registry".to_string()));
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_registry(&empty_headers), None);
+    }
+
+    #[test]
+    fn test_get_filtered_query_params() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_FILTERED_QUERY_PARAMS_HEADER,
+            HeaderValue::from_static("param1,param2"),
+        );
+        assert_eq!(
+            get_filtered_query_params(&headers, vec!["default".to_string()]),
+            vec!["param1".to_string(), "param2".to_string()]
+        );
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(
+            get_filtered_query_params(&empty_headers, vec!["default".to_string()]),
+            vec!["default".to_string()]
+        );
+    }
+
+    #[test]
+    fn test_get_use_p2p() {
+        let mut headers = HeaderMap::new();
+        headers.insert(DRAGONFLY_USE_P2P_HEADER, HeaderValue::from_static("true"));
+        assert!(get_use_p2p(&headers));
+
+        headers.insert(DRAGONFLY_USE_P2P_HEADER, HeaderValue::from_static("false"));
+        assert!(!get_use_p2p(&headers));
+
+        let empty_headers = HeaderMap::new();
+        assert!(!get_use_p2p(&empty_headers));
+    }
+
+    #[test]
+    fn test_get_prefetch() {
+        let mut headers = HeaderMap::new();
+        headers.insert(DRAGONFLY_PREFETCH_HEADER, HeaderValue::from_static("true"));
+        assert_eq!(get_prefetch(&headers), Some(true));
+
+        headers.insert(DRAGONFLY_PREFETCH_HEADER, HeaderValue::from_static("false"));
+        assert_eq!(get_prefetch(&headers), Some(false));
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_prefetch(&empty_headers), None);
+    }
+
+    #[test]
+    fn test_get_output_path() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_OUTPUT_PATH_HEADER,
+            HeaderValue::from_static("/path/to/output"),
+        );
+        assert_eq!(
+            get_output_path(&headers),
+            Some("/path/to/output".to_string())
+        );
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_output_path(&empty_headers), None);
+    }
+
+    #[test]
+    fn test_get_force_hard_link() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_FORCE_HARD_LINK_HEADER,
+            HeaderValue::from_static("true"),
+        );
+        assert!(get_force_hard_link(&headers));
+
+        headers.insert(
+            DRAGONFLY_FORCE_HARD_LINK_HEADER,
+            HeaderValue::from_static("false"),
+        );
+        assert!(!get_force_hard_link(&headers));
+
+        let empty_headers = HeaderMap::new();
+        assert!(!get_force_hard_link(&empty_headers));
+    }
+
+    #[test]
+    fn test_get_piece_length() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_PIECE_LENGTH_HEADER,
+            HeaderValue::from_static("4mib"),
+        );
+        assert_eq!(get_piece_length(&headers), Some(ByteSize::mib(4)));
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_piece_length(&empty_headers), None);
+
+        headers.insert(
+            DRAGONFLY_PIECE_LENGTH_HEADER,
+            HeaderValue::from_static("invalid"),
+        );
+        assert_eq!(get_piece_length(&headers), None);
+
+        headers.insert(DRAGONFLY_PIECE_LENGTH_HEADER, HeaderValue::from_static("0"));
+        assert_eq!(get_piece_length(&headers), Some(ByteSize::b(0)));
+    }
+
+    #[test]
+    fn test_get_content_for_calculating_task_id() {
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            DRAGONFLY_CONTENT_FOR_CALCULATING_TASK_ID_HEADER,
+            HeaderValue::from_static("test-content"),
+        );
+        assert_eq!(
+            get_content_for_calculating_task_id(&headers),
+            Some("test-content".to_string())
+        );
+
+        let empty_headers = HeaderMap::new();
+        assert_eq!(get_registry(&empty_headers), None);
+    }
+}

dragonfly-client/src/resource/mod.rs

@@ -17,4 +17,5 @@
 pub mod persistent_cache_task;
 pub mod piece;
 pub mod piece_collector;
+pub mod piece_downloader;
 pub mod task;

dragonfly-client/src/resource/piece.rs

@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-use crate::grpc::dfdaemon_upload::DfdaemonUploadClient;
+use super::*;
 use crate::metrics::{
     collect_backend_request_failure_metrics, collect_backend_request_finished_metrics,
     collect_backend_request_started_metrics, collect_download_piece_traffic_metrics,
     collect_upload_piece_traffic_metrics,
 };
 use chrono::Utc;
-use dragonfly_api::common::v2::{ObjectStorage, Range, TrafficType};
-use dragonfly_api::dfdaemon::v2::DownloadPieceRequest;
+use dragonfly_api::common::v2::{Hdfs, ObjectStorage, Range, TrafficType};
 use dragonfly_client_backend::{BackendFactory, GetRequest};
 use dragonfly_client_config::dfdaemon::Config;
 use dragonfly_client_core::{error::BackendError, Error, Result};
@@ -31,29 +30,31 @@ use dragonfly_client_util::id_generator::IDGenerator;
 use leaky_bucket::RateLimiter;
 use reqwest::header::{self, HeaderMap};
 use std::collections::HashMap;
+use std::io::Cursor;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 use tokio::io::{AsyncRead, AsyncReadExt};
 use tracing::{error, info, instrument, Span};
 
-use super::*;
-
 /// MAX_PIECE_COUNT is the maximum piece count. If the piece count is upper
 /// than MAX_PIECE_COUNT, the piece length will be optimized by the file length.
-/// When piece length becames the MAX_PIECE_LENGTH, the piece piece count
+/// When piece length became the MAX_PIECE_LENGTH, the piece count
 /// probably will be upper than MAX_PIECE_COUNT.
-const MAX_PIECE_COUNT: u64 = 500;
+pub const MAX_PIECE_COUNT: u64 = 500;
 
 /// MIN_PIECE_LENGTH is the minimum piece length.
-const MIN_PIECE_LENGTH: u64 = 4 * 1024 * 1024;
+pub const MIN_PIECE_LENGTH: u64 = 4 * 1024 * 1024;
 
 /// MAX_PIECE_LENGTH is the maximum piece length.
-const MAX_PIECE_LENGTH: u64 = 16 * 1024 * 1024;
+pub const MAX_PIECE_LENGTH: u64 = 64 * 1024 * 1024;
 
 /// PieceLengthStrategy sets the optimization strategy of piece length.
 pub enum PieceLengthStrategy {
     /// OptimizeByFileLength optimizes the piece length by the file length.
-    OptimizeByFileLength,
+    OptimizeByFileLength(u64),
+
+    /// FixedPieceLength sets the fixed piece length.
+    FixedPieceLength(u64),
 }
 
 /// Piece represents a piece manager.
@@ -67,6 +68,9 @@ pub struct Piece {
     /// storage is the local storage.
     storage: Arc<Storage>,
 
+    /// downloader is the piece downloader.
+    downloader: Arc<dyn piece_downloader::Downloader>,
+
     /// backend_factory is the backend factory.
     backend_factory: Arc<BackendFactory>,
 
@@ -75,27 +79,35 @@ pub struct Piece {
 
     /// upload_rate_limiter is the rate limiter of the upload speed in bps(bytes per second).
     upload_rate_limiter: Arc<RateLimiter>,
+
+    /// prefetch_rate_limiter is the rate limiter of the prefetch speed in bps(bytes per second).
+    prefetch_rate_limiter: Arc<RateLimiter>,
 }
 
 /// Piece implements the piece manager.
 impl Piece {
     /// new returns a new Piece.
-    #[instrument(skip_all)]
     pub fn new(
         config: Arc<Config>,
         id_generator: Arc<IDGenerator>,
         storage: Arc<Storage>,
         backend_factory: Arc<BackendFactory>,
-    ) -> Self {
-        Self {
+    ) -> Result<Self> {
+        Ok(Self {
             config: config.clone(),
             id_generator,
             storage,
+            downloader: piece_downloader::DownloaderFactory::new(
+                config.storage.server.protocol.as_str(),
+                config.clone(),
+            )?
+            .build(),
             backend_factory,
             download_rate_limiter: Arc::new(
                 RateLimiter::builder()
                     .initial(config.download.rate_limit.as_u64() as usize)
                     .refill(config.download.rate_limit.as_u64() as usize)
+                    .max(config.download.rate_limit.as_u64() as usize)
                     .interval(Duration::from_secs(1))
                     .fair(false)
                     .build(),
@@ -104,16 +116,37 @@ impl Piece {
                 RateLimiter::builder()
                     .initial(config.upload.rate_limit.as_u64() as usize)
                     .refill(config.upload.rate_limit.as_u64() as usize)
+                    .max(config.upload.rate_limit.as_u64() as usize)
                     .interval(Duration::from_secs(1))
+                    .fair(false)
                     .build(),
             ),
-        }
+            prefetch_rate_limiter: Arc::new(
+                RateLimiter::builder()
+                    .initial(config.proxy.prefetch_rate_limit.as_u64() as usize)
+                    .refill(config.proxy.prefetch_rate_limit.as_u64() as usize)
+                    .max(config.proxy.prefetch_rate_limit.as_u64() as usize)
+                    .interval(Duration::from_secs(1))
+                    .fair(false)
+                    .build(),
+            ),
+        })
+    }
+
+    /// id generates a new piece id.
+    #[inline]
+    pub fn id(&self, task_id: &str, number: u32) -> String {
+        self.storage.piece_id(task_id, number)
     }
 
     /// get gets a piece from the local storage.
-    #[instrument(skip_all)]
-    pub fn get(&self, task_id: &str, number: u32) -> Result<Option<metadata::Piece>> {
-        self.storage.get_piece(task_id, number)
+    pub fn get(&self, piece_id: &str) -> Result<Option<metadata::Piece>> {
+        self.storage.get_piece(piece_id)
+    }
+
+    /// get_all gets all pieces of a task from the local storage.
+    pub fn get_all(&self, task_id: &str) -> Result<Vec<metadata::Piece>> {
+        self.storage.get_pieces(task_id)
     }
 
     /// calculate_interested calculates the interested pieces by content_length and range.
@@ -271,13 +304,9 @@ impl Piece {
     }
 
     /// calculate_piece_size calculates the piece size by content_length.
-    pub fn calculate_piece_length(
-        &self,
-        strategy: PieceLengthStrategy,
-        content_length: u64,
-    ) -> u64 {
+    pub fn calculate_piece_length(&self, strategy: PieceLengthStrategy) -> u64 {
         match strategy {
-            PieceLengthStrategy::OptimizeByFileLength => {
+            PieceLengthStrategy::OptimizeByFileLength(content_length) => {
                 let piece_length = (content_length as f64 / MAX_PIECE_COUNT as f64) as u64;
                 let actual_piece_length = piece_length.next_power_of_two();
 
@@ -290,21 +319,28 @@ impl Piece {
                     (false, _) => MIN_PIECE_LENGTH,
                 }
             }
+            PieceLengthStrategy::FixedPieceLength(piece_length) => piece_length,
         }
     }
 
-    /// upload_from_local_peer_into_async_read uploads a single piece from a local peer.
+    /// calculate_piece_count calculates the piece count by piece_length and content_length.
+    pub fn calculate_piece_count(&self, piece_length: u64, content_length: u64) -> u32 {
+        (content_length as f64 / piece_length as f64).ceil() as u32
+    }
+
+    /// upload_from_local_into_async_read uploads a single piece from local cache.
     #[instrument(skip_all, fields(piece_id))]
-    pub async fn upload_from_local_peer_into_async_read(
+    pub async fn upload_from_local_into_async_read(
         &self,
+        piece_id: &str,
         task_id: &str,
-        number: u32,
         length: u64,
         range: Option<Range>,
         disable_rate_limit: bool,
     ) -> Result<impl AsyncRead> {
         // Span record the piece_id.
-        Span::current().record("piece_id", self.storage.piece_id(task_id, number));
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
 
         // Acquire the upload rate limiter.
         if !disable_rate_limit {
@@ -313,43 +349,50 @@ impl Piece {
 
         // Upload the piece content.
         self.storage
-            .upload_piece(task_id, number, range)
+            .upload_piece(piece_id, task_id, range)
             .await
-            .map(|reader| {
+            .inspect(|_| {
                 collect_upload_piece_traffic_metrics(
                     self.id_generator.task_type(task_id) as i32,
                     length,
                 );
-                reader
             })
     }
 
-    /// download_from_local_peer_into_async_read downloads a single piece from a local peer.
+    /// download_from_local_into_async_read downloads a single piece from local cache.
     #[instrument(skip_all, fields(piece_id))]
-    pub async fn download_from_local_peer_into_async_read(
+    pub async fn download_from_local_into_async_read(
         &self,
+        piece_id: &str,
         task_id: &str,
-        number: u32,
         length: u64,
         range: Option<Range>,
         disable_rate_limit: bool,
+        is_prefetch: bool,
     ) -> Result<impl AsyncRead> {
         // Span record the piece_id.
-        Span::current().record("piece_id", self.storage.piece_id(task_id, number));
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
 
         // Acquire the download rate limiter.
         if !disable_rate_limit {
-            self.download_rate_limiter.acquire(length as usize).await;
+            if is_prefetch {
+                // Acquire the prefetch rate limiter.
+                self.prefetch_rate_limiter.acquire(length as usize).await;
+            } else {
+                // Acquire the download rate limiter.
+                self.download_rate_limiter.acquire(length as usize).await;
+            }
         }
 
         // Upload the piece content.
-        self.storage.upload_piece(task_id, number, range).await
+        self.storage.upload_piece(piece_id, task_id, range).await
     }
 
-    /// download_from_local_peer downloads a single piece from a local peer. Fake the download piece
-    /// from the local peer, just collect the metrics.
+    /// download_from_local downloads a single piece from local cache. Fake the download piece
+    /// from the local cache, just collect the metrics.
     #[instrument(skip_all)]
-    pub fn download_from_local_peer(&self, task_id: &str, length: u64) {
+    pub fn download_from_local(&self, task_id: &str, length: u64) {
         collect_download_piece_traffic_metrics(
             &TrafficType::LocalPeer,
             self.id_generator.task_type(task_id) as i32,
@@ -357,132 +400,104 @@ impl Piece {
         );
     }
 
-    /// download_from_remote_peer downloads a single piece from a remote peer.
+    /// download_from_parent downloads a single piece from a parent.
+    #[allow(clippy::too_many_arguments)]
     #[instrument(skip_all, fields(piece_id))]
-    pub async fn download_from_remote_peer(
+    pub async fn download_from_parent(
         &self,
+        piece_id: &str,
         host_id: &str,
         task_id: &str,
         number: u32,
         length: u64,
         parent: piece_collector::CollectedParent,
+        is_prefetch: bool,
     ) -> Result<metadata::Piece> {
         // Span record the piece_id.
-        Span::current().record("piece_id", self.storage.piece_id(task_id, number));
-
-        // Acquire the download rate limiter.
-        self.download_rate_limiter.acquire(length as usize).await;
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
 
         // Record the start of downloading piece.
-        let piece = self.storage.download_piece_started(task_id, number).await?;
+        let piece = self
+            .storage
+            .download_piece_started(piece_id, number)
+            .await?;
 
         // If the piece is downloaded by the other thread,
         // return the piece directly.
         if piece.is_finished() {
+            info!("finished piece {} from local", piece_id);
             return Ok(piece);
         }
 
+        if is_prefetch {
+            // Acquire the prefetch rate limiter.
+            self.prefetch_rate_limiter.acquire(length as usize).await;
+        } else {
+            // Acquire the download rate limiter.
+            self.download_rate_limiter.acquire(length as usize).await;
+        }
+
         // Create a dfdaemon client.
         let host = parent.host.clone().ok_or_else(|| {
             error!("peer host is empty");
-            if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
+            if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
                 error!("set piece metadata failed: {}", err)
             };
 
             Error::InvalidPeer(parent.id.clone())
         })?;
-        let dfdaemon_upload_client = DfdaemonUploadClient::new(
-            self.config.clone(),
-            format!("http://{}:{}", host.ip, host.port),
-        )
-        .await
-        .map_err(|err| {
-            error!(
-                "create dfdaemon upload client from {}:{} failed: {}",
-                host.ip, host.port, err
-            );
-            if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
-                error!("set piece metadata failed: {}", err)
-            };
 
-            err
-        })?;
-
-        // Send the interested pieces request.
-        let response = dfdaemon_upload_client
+        let (content, offset, digest) = self
+            .downloader
             .download_piece(
-                DownloadPieceRequest {
-                    host_id: host_id.to_string(),
-                    task_id: task_id.to_string(),
-                    piece_number: number,
-                },
-                self.config.download.piece_timeout,
+                format!("{}:{}", host.ip, host.port).as_str(),
+                number,
+                host_id,
+                task_id,
             )
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 error!("download piece failed: {}", err);
-                if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
+                if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
                     error!("set piece metadata failed: {}", err)
                 };
-
-                err
             })?;
-
-        let piece = response.piece.ok_or_else(|| {
-            error!("piece is empty");
-            if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
-                error!("set piece metadata failed: {}", err)
-            };
-
-            Error::InvalidParameter
-        })?;
-
-        // Get the piece content.
-        let content = piece.content.ok_or_else(|| {
-            error!("piece content is empty");
-            if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
-                error!("set piece metadata failed: {}", err)
-            };
-
-            Error::InvalidParameter
-        })?;
+        let mut reader = Cursor::new(content);
 
         // Record the finish of downloading piece.
-        self.storage
-            .download_piece_from_remote_peer_finished(
+        match self
+            .storage
+            .download_piece_from_parent_finished(
+                piece_id,
                 task_id,
-                number,
-                piece.offset,
-                piece.digest.as_str(),
+                offset,
+                length,
+                digest.as_str(),
                 parent.id.as_str(),
-                &mut content.as_slice(),
+                &mut reader,
+                self.config.storage.write_piece_timeout,
             )
             .await
-            .map_err(|err| {
-                // Record the failure of downloading piece,
-                // If storage fails to record piece.
-                error!("download piece finished: {}", err);
-                if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
-                    error!("set piece metadata failed: {}", err)
-                };
-
-                err
-            })?;
-
-        self.storage
-            .get_piece(task_id, number)?
-            .ok_or_else(|| {
-                error!("piece not found");
-                Error::PieceNotFound(number.to_string())
-            })
-            .map(|piece| {
+        {
+            Ok(piece) => {
                 collect_download_piece_traffic_metrics(
                     &TrafficType::RemotePeer,
                     self.id_generator.task_type(task_id) as i32,
                     length,
                 );
-                piece
-            })
+
+                Ok(piece)
+            }
+            Err(err) => {
+                error!("download piece finished: {}", err);
+                if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
+                    error!("set piece metadata failed: {}", err)
+                };
+
+                Err(err)
+            }
+        }
     }
 
     /// download_from_source downloads a single piece from the source.
@@ -490,29 +505,42 @@ impl Piece {
     #[instrument(skip_all, fields(piece_id))]
     pub async fn download_from_source(
         &self,
+        piece_id: &str,
         task_id: &str,
         number: u32,
         url: &str,
         offset: u64,
         length: u64,
         request_header: HeaderMap,
+        is_prefetch: bool,
         object_storage: Option<ObjectStorage>,
+        hdfs: Option<Hdfs>,
     ) -> Result<metadata::Piece> {
         // Span record the piece_id.
-        Span::current().record("piece_id", self.storage.piece_id(task_id, number));
-
-        // Acquire the download rate limiter.
-        self.download_rate_limiter.acquire(length as usize).await;
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
 
         // Record the start of downloading piece.
-        let piece = self.storage.download_piece_started(task_id, number).await?;
+        let piece = self
+            .storage
+            .download_piece_started(piece_id, number)
+            .await?;
 
         // If the piece is downloaded by the other thread,
         // return the piece directly.
         if piece.is_finished() {
+            info!("finished piece {} from local", piece_id);
             return Ok(piece);
         }
 
+        if is_prefetch {
+            // Acquire the prefetch rate limiter.
+            self.prefetch_rate_limiter.acquire(length as usize).await;
+        } else {
+            // Acquire the download rate limiter.
+            self.download_rate_limiter.acquire(length as usize).await;
+        }
+
         // Add range header to the request by offset and length.
         let mut request_header = request_header.clone();
         request_header.insert(
@@ -523,13 +551,11 @@ impl Piece {
         );
 
         // Download the piece from the source.
-        let backend = self.backend_factory.build(url).map_err(|err| {
+        let backend = self.backend_factory.build(url).inspect_err(|err| {
             error!("build backend failed: {}", err);
-            if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
+            if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
                 error!("set piece metadata failed: {}", err)
             };
-
-            err
         })?;
 
         // Record the start time.
@@ -543,7 +569,7 @@ impl Piece {
         let mut response = backend
             .get(GetRequest {
                 task_id: task_id.to_string(),
-                piece_id: self.storage.piece_id(task_id, number),
+                piece_id: piece_id.to_string(),
                 url: url.to_string(),
                 range: Some(Range {
                     start: offset,
@@ -553,9 +579,10 @@ impl Piece {
                 timeout: self.config.download.piece_timeout,
                 client_cert: None,
                 object_storage,
+                hdfs,
             })
             .await
-            .map_err(|err| {
+            .inspect_err(|err| {
                 // Collect the backend request failure metrics.
                 collect_backend_request_failure_metrics(
                     backend.scheme().as_str(),
@@ -564,11 +591,9 @@ impl Piece {
 
                 // if the request is failed.
                 error!("backend get failed: {}", err);
-                if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
+                if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
                     error!("set piece metadata failed: {}", err)
                 };
-
-                err
             })?;
 
         if !response.success {
@@ -589,12 +614,12 @@ impl Piece {
             let error_message = response.error_message.unwrap_or_default();
             error!("backend get failed: {} {}", error_message, buffer.as_str());
 
-            self.storage.download_piece_failed(task_id, number)?;
-            return Err(Error::BackendError(BackendError {
+            self.storage.download_piece_failed(piece_id)?;
+            return Err(Error::BackendError(Box::new(BackendError {
                 message: error_message,
                 status_code: Some(response.http_status_code.unwrap_or_default()),
                 header: Some(response.http_header.unwrap_or_default()),
-            }));
+            })));
         }
 
         // Collect the backend request finished metrics.
@@ -605,41 +630,247 @@ impl Piece {
         );
 
         // Record the finish of downloading piece.
-        self.storage
+        match self
+            .storage
             .download_piece_from_source_finished(
+                piece_id,
                 task_id,
-                number,
                 offset,
                 length,
                 &mut response.reader,
+                self.config.storage.write_piece_timeout,
             )
             .await
-            .map_err(|err| {
-                // Record the failure of downloading piece,
-                // If storage fails to record piece.
-                error!("download piece finished: {}", err);
-                if let Some(err) = self.storage.download_piece_failed(task_id, number).err() {
-                    error!("set piece metadata failed: {}", err)
-                };
-
-                err
-            })?;
-
-        self.storage
-            .get_piece(task_id, number)?
-            .ok_or_else(|| {
-                error!("piece not found");
-                Error::PieceNotFound(number.to_string())
-            })
-            .map(|piece| {
+        {
+            Ok(piece) => {
                 collect_download_piece_traffic_metrics(
                     &TrafficType::BackToSource,
                     self.id_generator.task_type(task_id) as i32,
                     length,
                 );
-                piece
+
+                Ok(piece)
+            }
+            Err(err) => {
+                error!("download piece finished: {}", err);
+                if let Some(err) = self.storage.download_piece_failed(piece_id).err() {
+                    error!("set piece metadata failed: {}", err)
+                };
+
+                Err(err)
+            }
+        }
+    }
+
+    /// persistent_cache_id generates a new persistent cache piece id.
+    #[inline]
+    pub fn persistent_cache_id(&self, task_id: &str, number: u32) -> String {
+        self.storage.persistent_cache_piece_id(task_id, number)
+    }
+
+    /// get_persistent_cache gets a persistent cache piece from the local storage.
+    #[instrument(skip_all)]
+    pub fn get_persistent_cache(&self, piece_id: &str) -> Result<Option<metadata::Piece>> {
+        self.storage.get_persistent_cache_piece(piece_id)
+    }
+
+    /// create_persistent_cache creates a new persistent cache piece.
+    #[instrument(skip_all)]
+    pub async fn create_persistent_cache<R: AsyncRead + Unpin + ?Sized>(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        number: u32,
+        offset: u64,
+        length: u64,
+        reader: &mut R,
+    ) -> Result<metadata::Piece> {
+        self.storage
+            .create_persistent_cache_piece(piece_id, task_id, number, offset, length, reader)
+            .await
+    }
+
+    /// upload_persistent_cache_from_local_into_async_read uploads a persistent cache piece from local cache.
+    #[instrument(skip_all, fields(piece_id))]
+    pub async fn upload_persistent_cache_from_local_into_async_read(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        length: u64,
+        range: Option<Range>,
+    ) -> Result<impl AsyncRead> {
+        // Span record the piece_id.
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
+
+        // Acquire the upload rate limiter.
+        self.upload_rate_limiter.acquire(length as usize).await;
+
+        // Upload the persistent cache piece content.
+        self.storage
+            .upload_persistent_cache_piece(piece_id, task_id, range)
+            .await
+            .inspect(|_| {
+                collect_upload_piece_traffic_metrics(
+                    self.id_generator.task_type(task_id) as i32,
+                    length,
+                );
             })
     }
+
+    /// download_persistent_cache_from_local_into_async_read downloads a persistent cache piece from local cache.
+    #[instrument(skip_all, fields(piece_id))]
+    pub async fn download_persistent_cache_from_local_into_async_read(
+        &self,
+        piece_id: &str,
+        task_id: &str,
+        length: u64,
+        range: Option<Range>,
+        disable_rate_limit: bool,
+        is_prefetch: bool,
+    ) -> Result<impl AsyncRead> {
+        // Span record the piece_id.
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
+
+        // Acquire the download rate limiter.
+        if !disable_rate_limit {
+            if is_prefetch {
+                // Acquire the prefetch rate limiter.
+                self.prefetch_rate_limiter.acquire(length as usize).await;
+            } else {
+                // Acquire the download rate limiter.
+                self.download_rate_limiter.acquire(length as usize).await;
+            }
+        }
+
+        // Upload the piece content.
+        self.storage
+            .upload_persistent_cache_piece(piece_id, task_id, range)
+            .await
+    }
+
+    /// download_persistent_cache_from_local downloads a persistent cache piece from local cache. Fake the download
+    /// persistent cache piece from the local cache, just collect the metrics.
+    #[instrument(skip_all)]
+    pub fn download_persistent_cache_from_local(&self, task_id: &str, length: u64) {
+        collect_download_piece_traffic_metrics(
+            &TrafficType::LocalPeer,
+            self.id_generator.task_type(task_id) as i32,
+            length,
+        );
+    }
+
+    /// download_persistent_cache_from_parent downloads a persistent cache piece from a parent.
+    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all, fields(piece_id))]
+    pub async fn download_persistent_cache_from_parent(
+        &self,
+        piece_id: &str,
+        host_id: &str,
+        task_id: &str,
+        number: u32,
+        length: u64,
+        parent: piece_collector::CollectedParent,
+        is_prefetch: bool,
+    ) -> Result<metadata::Piece> {
+        // Span record the piece_id.
+        Span::current().record("piece_id", piece_id);
+        Span::current().record("piece_length", length);
+
+        if is_prefetch {
+            // Acquire the prefetch rate limiter.
+            self.prefetch_rate_limiter.acquire(length as usize).await;
+        } else {
+            // Acquire the download rate limiter.
+            self.download_rate_limiter.acquire(length as usize).await;
+        }
+
+        // Record the start of downloading piece.
+        let piece = self
+            .storage
+            .download_persistent_cache_piece_started(piece_id, number)
+            .await?;
+
+        // If the piece is downloaded by the other thread,
+        // return the piece directly.
+        if piece.is_finished() {
+            info!("finished persistent cache piece {} from local", piece_id);
+            return Ok(piece);
+        }
+
+        // Create a dfdaemon client.
+        let host = parent.host.clone().ok_or_else(|| {
+            error!("peer host is empty");
+            if let Some(err) = self
+                .storage
+                .download_persistent_cache_piece_failed(piece_id)
+                .err()
+            {
+                error!("set persistent cache piece metadata failed: {}", err)
+            };
+
+            Error::InvalidPeer(parent.id.clone())
+        })?;
+
+        let (content, offset, digest) = self
+            .downloader
+            .download_persistent_cache_piece(
+                format!("{}:{}", host.ip, host.port).as_str(),
+                number,
+                host_id,
+                task_id,
+            )
+            .await
+            .inspect_err(|err| {
+                error!("download persistent cache piece failed: {}", err);
+                if let Some(err) = self
+                    .storage
+                    .download_persistent_cache_piece_failed(piece_id)
+                    .err()
+                {
+                    error!("set persistent cache piece metadata failed: {}", err)
+                };
+            })?;
+        let mut reader = Cursor::new(content);
+
+        // Record the finish of downloading piece.
+        match self
+            .storage
+            .download_persistent_cache_piece_from_parent_finished(
+                piece_id,
+                task_id,
+                offset,
+                length,
+                digest.as_str(),
+                parent.id.as_str(),
+                &mut reader,
+            )
+            .await
+        {
+            Ok(piece) => {
+                collect_download_piece_traffic_metrics(
+                    &TrafficType::RemotePeer,
+                    self.id_generator.task_type(task_id) as i32,
+                    length,
+                );
+
+                Ok(piece)
+            }
+            Err(err) => {
+                error!("download persistent cache piece finished: {}", err);
+                if let Some(err) = self
+                    .storage
+                    .download_persistent_cache_piece_failed(piece_id)
+                    .err()
+                {
+                    error!("set persistent cache piece metadata failed: {}", err)
+                };
+
+                Err(err)
+            }
+        }
+    }
 }
 
 #[cfg(test)]
@@ -648,7 +879,7 @@ mod tests {
     use tempfile::tempdir;
 
     #[tokio::test]
-    async fn should_calculate_interested() {
+    async fn test_calculate_interested() {
         let temp_dir = tempdir().unwrap();
 
         let config = Config::default();
@@ -675,7 +906,8 @@ mod tests {
             id_generator.clone(),
             storage.clone(),
             backend_factory.clone(),
-        );
+        )
+        .unwrap();
 
         let test_cases = vec![
             (1000, 1, None, 1, vec![0], 0, 1),

dragonfly-client/src/resource/piece_collector.rs

@@ -17,9 +17,8 @@
 use crate::grpc::dfdaemon_upload::DfdaemonUploadClient;
 use dashmap::DashMap;
 use dragonfly_api::common::v2::Host;
-use dragonfly_api::dfdaemon::v2::SyncPiecesRequest;
+use dragonfly_api::dfdaemon::v2::{SyncPersistentCachePiecesRequest, SyncPiecesRequest};
 use dragonfly_client_config::dfdaemon::Config;
-use dragonfly_client_core::error::{ErrorType, OrErr};
 use dragonfly_client_core::{Error, Result};
 use dragonfly_client_storage::metadata;
 use std::sync::Arc;
@@ -29,7 +28,9 @@ use tokio::task::JoinSet;
 use tokio_stream::StreamExt;
 use tracing::{error, info, instrument, Instrument};
 
-/// CollectedParent is the parent peer collected from the remote peer.
+const DEFAULT_WAIT_FOR_PIECE_FROM_DIFFERENT_PARENTS: Duration = Duration::from_millis(5);
+
+/// CollectedParent is the parent peer collected from the parent.
 #[derive(Clone, Debug)]
 pub struct CollectedParent {
     /// id is the id of the parent.
@@ -68,27 +69,278 @@ pub struct PieceCollector {
     /// interested_pieces is the pieces interested by the collector.
     interested_pieces: Vec<metadata::Piece>,
 
-    /// collected_pieces is the pieces collected from peers.
-    collected_pieces: Arc<DashMap<u32, String>>,
+    /// collected_pieces is a map to store the collected pieces from different parents.
+    collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
 }
 
+/// PieceCollector is used to collect pieces from peers.
 impl PieceCollector {
     /// new creates a new PieceCollector.
-    #[instrument(skip_all)]
-    pub fn new(
+    pub async fn new(
         config: Arc<Config>,
         host_id: &str,
         task_id: &str,
         interested_pieces: Vec<metadata::Piece>,
         parents: Vec<CollectedParent>,
     ) -> Self {
-        let collected_pieces = Arc::new(DashMap::new());
-        interested_pieces
-            .clone()
-            .into_iter()
-            .for_each(|interested_piece| {
-                collected_pieces.insert(interested_piece.number, "".to_string());
-            });
+        let collected_pieces = Arc::new(DashMap::with_capacity(interested_pieces.len()));
+        for interested_piece in &interested_pieces {
+            collected_pieces.insert(interested_piece.number, Vec::new());
+        }
+
+        Self {
+            config,
+            task_id: task_id.to_string(),
+            host_id: host_id.to_string(),
+            parents,
+            interested_pieces,
+            collected_pieces,
+        }
+    }
+
+    /// run runs the piece collector.
+    #[instrument(skip_all)]
+    pub async fn run(&self) -> Receiver<CollectedPiece> {
+        let config = self.config.clone();
+        let host_id = self.host_id.clone();
+        let task_id = self.task_id.clone();
+        let parents = self.parents.clone();
+        let interested_pieces = self.interested_pieces.clone();
+        let collected_pieces = self.collected_pieces.clone();
+        let collected_piece_timeout = self.config.download.collected_piece_timeout;
+        let (collected_piece_tx, collected_piece_rx) = mpsc::channel(128 * 1024);
+        tokio::spawn(
+            async move {
+                Self::collect_from_parents(
+                    config,
+                    &host_id,
+                    &task_id,
+                    parents,
+                    interested_pieces,
+                    collected_pieces,
+                    collected_piece_tx,
+                    collected_piece_timeout,
+                )
+                .await
+                .unwrap_or_else(|err| {
+                    error!("collect pieces failed: {}", err);
+                });
+            }
+            .in_current_span(),
+        );
+
+        collected_piece_rx
+    }
+
+    /// collect_from_parents collects pieces from multiple parents with load balancing strategy.
+    ///
+    /// The collection process works in two phases:
+    /// 1. **Synchronization Phase**: Waits for a configured duration (DEFAULT_WAIT_FOR_PIECE_FROM_DIFFERENT_PARENTS)
+    ///    to collect the same piece information from different parents. This allows the collector
+    ///    to gather multiple sources for each piece.
+    ///
+    /// 2. **Selection Phase**: After the wait period, randomly selects one parent from the available
+    ///    candidates for each piece and forwards it to the piece downloader.
+    ///
+    /// **Load Balancing Strategy**:
+    /// The random parent selection is designed to distribute download load across multiple parents
+    /// during concurrent piece downloads. This approach ensures:
+    /// - Optimal utilization of bandwidth from multiple parent nodes
+    /// - Prevention of overwhelming any single parent with too many requests
+    /// - Better overall download performance through parallel connections
+    ///
+    /// This strategy is particularly effective when downloading multiple pieces simultaneously,
+    /// as it naturally spreads the workload across the available parent pool.
+    #[allow(clippy::too_many_arguments)]
+    #[instrument(skip_all)]
+    async fn collect_from_parents(
+        config: Arc<Config>,
+        host_id: &str,
+        task_id: &str,
+        parents: Vec<CollectedParent>,
+        interested_pieces: Vec<metadata::Piece>,
+        collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
+        collected_piece_tx: Sender<CollectedPiece>,
+        collected_piece_timeout: Duration,
+    ) -> Result<()> {
+        // Create a task to collect pieces from peers.
+        let mut join_set = JoinSet::new();
+        for parent in parents.iter() {
+            #[allow(clippy::too_many_arguments)]
+            async fn sync_pieces(
+                config: Arc<Config>,
+                host_id: String,
+                task_id: String,
+                parent: CollectedParent,
+                interested_pieces: Vec<metadata::Piece>,
+                collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
+                collected_piece_tx: Sender<CollectedPiece>,
+                collected_piece_timeout: Duration,
+            ) -> Result<CollectedParent> {
+                info!("sync pieces from parent {}", parent.id);
+
+                // If candidate_parent.host is None, skip it.
+                let host = parent.host.clone().ok_or_else(|| {
+                    error!("peer {:?} host is empty", parent);
+                    Error::InvalidPeer(parent.id.clone())
+                })?;
+
+                // Create a dfdaemon client.
+                let dfdaemon_upload_client = DfdaemonUploadClient::new(
+                    config,
+                    format!("http://{}:{}", host.ip, host.port),
+                    false,
+                )
+                .await
+                .inspect_err(|err| {
+                    error!(
+                        "create dfdaemon upload client from parent {} failed: {}",
+                        parent.id, err
+                    );
+                })?;
+
+                let response = dfdaemon_upload_client
+                    .sync_pieces(SyncPiecesRequest {
+                        host_id: host_id.to_string(),
+                        task_id: task_id.to_string(),
+                        interested_piece_numbers: interested_pieces
+                            .iter()
+                            .map(|piece| piece.number)
+                            .collect(),
+                    })
+                    .await
+                    .inspect_err(|err| {
+                        error!("sync pieces from parent {} failed: {}", parent.id, err);
+                    })?;
+
+                // If the response repeating timeout exceeds the piece download timeout, the stream will return error.
+                let out_stream = response.into_inner().timeout(collected_piece_timeout);
+                tokio::pin!(out_stream);
+
+                while let Some(message) = out_stream.try_next().await.inspect_err(|err| {
+                    error!("sync pieces from parent {} failed: {}", parent.id, err);
+                })? {
+                    let message = message?;
+                    if let Some(mut parents) = collected_pieces.get_mut(&message.number) {
+                        parents.push(parent.clone());
+                    } else {
+                        continue;
+                    }
+
+                    // Wait for collecting the piece from different parents when the first
+                    // piece is collected.
+                    tokio::time::sleep(DEFAULT_WAIT_FOR_PIECE_FROM_DIFFERENT_PARENTS).await;
+                    let parents = match collected_pieces.remove(&message.number) {
+                        Some((_, parents)) => parents,
+                        None => continue,
+                    };
+
+                    let parent = match parents.get(fastrand::usize(..parents.len())) {
+                        Some(parent) => parent,
+                        None => {
+                            error!(
+                                "collected_pieces does not contain parent for piece {}",
+                                message.number
+                            );
+                            continue;
+                        }
+                    };
+
+                    info!(
+                        "picked up piece {}-{} metadata from parent {}",
+                        task_id, message.number, parent.id
+                    );
+
+                    collected_piece_tx
+                        .send(CollectedPiece {
+                            number: message.number,
+                            length: message.length,
+                            parent: parent.clone(),
+                        })
+                        .await
+                        .inspect_err(|err| {
+                            error!("send CollectedPiece failed: {}", err);
+                        })?;
+                }
+
+                Ok(parent)
+            }
+
+            join_set.spawn(
+                sync_pieces(
+                    config.clone(),
+                    host_id.to_string(),
+                    task_id.to_string(),
+                    parent.clone(),
+                    interested_pieces.clone(),
+                    collected_pieces.clone(),
+                    collected_piece_tx.clone(),
+                    collected_piece_timeout,
+                )
+                .in_current_span(),
+            );
+        }
+
+        // Wait for all tasks to finish.
+        while let Some(message) = join_set.join_next().await {
+            match message {
+                Ok(Ok(peer)) => {
+                    info!("peer {} sync pieces finished", peer.id);
+
+                    // If all pieces are collected, abort all tasks.
+                    if collected_pieces.is_empty() {
+                        info!("all pieces are collected, abort all tasks");
+                        join_set.abort_all();
+                    }
+                }
+                Ok(Err(err)) => {
+                    error!("sync pieces failed: {}", err);
+                }
+                Err(err) => {
+                    error!("sync pieces failed: {}", err);
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// PersistentCachePieceCollector is used to collect persistent cache pieces from peers.
+pub struct PersistentCachePieceCollector {
+    /// config is the configuration of the dfdaemon.
+    config: Arc<Config>,
+
+    /// host_id is the id of the host.
+    host_id: String,
+
+    /// task_id is the id of the persistent cache task.
+    task_id: String,
+
+    /// parents is the parent peers.
+    parents: Vec<CollectedParent>,
+
+    /// interested_pieces is the pieces interested by the collector.
+    interested_pieces: Vec<metadata::Piece>,
+
+    /// collected_pieces is a map to store the collected pieces from different parents.
+    collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
+}
+
+/// PersistentCachePieceCollector is used to collect persistent cache pieces from peers.
+impl PersistentCachePieceCollector {
+    /// new creates a new PieceCollector.
+    pub async fn new(
+        config: Arc<Config>,
+        host_id: &str,
+        task_id: &str,
+        interested_pieces: Vec<metadata::Piece>,
+        parents: Vec<CollectedParent>,
+    ) -> Self {
+        let collected_pieces = Arc::new(DashMap::with_capacity(interested_pieces.len()));
+        for interested_piece in &interested_pieces {
+            collected_pieces.insert(interested_piece.number, Vec::new());
+        }
 
         Self {
             config,
@@ -110,13 +362,13 @@ impl PieceCollector {
         let interested_pieces = self.interested_pieces.clone();
         let collected_pieces = self.collected_pieces.clone();
         let collected_piece_timeout = self.config.download.piece_timeout;
-        let (collected_piece_tx, collected_piece_rx) = mpsc::channel(1024 * 10);
+        let (collected_piece_tx, collected_piece_rx) = mpsc::channel(10 * 1024);
         tokio::spawn(
             async move {
-                Self::collect_from_remote_peers(
+                Self::collect_from_parents(
                     config,
-                    host_id,
-                    task_id,
+                    &host_id,
+                    &task_id,
                     parents,
                     interested_pieces,
                     collected_pieces,
@@ -125,7 +377,7 @@ impl PieceCollector {
                 )
                 .await
                 .unwrap_or_else(|err| {
-                    error!("collect pieces failed: {}", err);
+                    error!("collect persistent cache pieces failed: {}", err);
                 });
             }
             .in_current_span(),
@@ -134,16 +386,34 @@ impl PieceCollector {
         collected_piece_rx
     }
 
-    /// collect_from_remote_peers collects pieces from remote peers.
+    /// collect_from_parents collects pieces from multiple parents with load balancing strategy.
+    ///
+    /// The collection process works in two phases:
+    /// 1. **Synchronization Phase**: Waits for a configured duration (DEFAULT_WAIT_FOR_PIECE_FROM_DIFFERENT_PARENTS)
+    ///    to collect the same piece information from different parents. This allows the collector
+    ///    to gather multiple sources for each piece.
+    ///
+    /// 2. **Selection Phase**: After the wait period, randomly selects one parent from the available
+    ///    candidates for each piece and forwards it to the piece downloader.
+    ///
+    /// **Load Balancing Strategy**:
+    /// The random parent selection is designed to distribute download load across multiple parents
+    /// during concurrent piece downloads. This approach ensures:
+    /// - Optimal utilization of bandwidth from multiple parent nodes
+    /// - Prevention of overwhelming any single parent with too many requests
+    /// - Better overall download performance through parallel connections
+    ///
+    /// This strategy is particularly effective when downloading multiple pieces simultaneously,
+    /// as it naturally spreads the workload across the available parent pool.
     #[allow(clippy::too_many_arguments)]
     #[instrument(skip_all)]
-    async fn collect_from_remote_peers(
+    async fn collect_from_parents(
         config: Arc<Config>,
-        host_id: String,
-        task_id: String,
+        host_id: &str,
+        task_id: &str,
         parents: Vec<CollectedParent>,
         interested_pieces: Vec<metadata::Piece>,
-        collected_pieces: Arc<DashMap<u32, String>>,
+        collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
         collected_piece_tx: Sender<CollectedPiece>,
         collected_piece_timeout: Duration,
     ) -> Result<()> {
@@ -156,34 +426,35 @@ impl PieceCollector {
                 host_id: String,
                 task_id: String,
                 parent: CollectedParent,
-                parents: Vec<CollectedParent>,
                 interested_pieces: Vec<metadata::Piece>,
-                collected_pieces: Arc<DashMap<u32, String>>,
+                collected_pieces: Arc<DashMap<u32, Vec<CollectedParent>>>,
                 collected_piece_tx: Sender<CollectedPiece>,
                 collected_piece_timeout: Duration,
             ) -> Result<CollectedParent> {
-                info!("sync pieces from parent {}", parent.id);
+                info!("sync persistent cache pieces from parent {}", parent.id);
 
                 // If candidate_parent.host is None, skip it.
                 let host = parent.host.clone().ok_or_else(|| {
-                    error!("peer {:?} host is empty", parent);
+                    error!("persistent cache peer {:?} host is empty", parent);
                     Error::InvalidPeer(parent.id.clone())
                 })?;
 
                 // Create a dfdaemon client.
-                let dfdaemon_upload_client =
-                    DfdaemonUploadClient::new(config, format!("http://{}:{}", host.ip, host.port))
-                        .await
-                        .map_err(|err| {
-                            error!(
-                                "create dfdaemon upload client from parent {} failed: {}",
-                                parent.id, err
-                            );
-                            err
-                        })?;
+                let dfdaemon_upload_client = DfdaemonUploadClient::new(
+                    config,
+                    format!("http://{}:{}", host.ip, host.port),
+                    false,
+                )
+                .await
+                .inspect_err(|err| {
+                    error!(
+                        "create dfdaemon upload client from parent {} failed: {}",
+                        parent.id, err
+                    );
+                })?;
 
                 let response = dfdaemon_upload_client
-                    .sync_pieces(SyncPiecesRequest {
+                    .sync_persistent_cache_pieces(SyncPersistentCachePiecesRequest {
                         host_id: host_id.to_string(),
                         task_id: task_id.to_string(),
                         interested_piece_numbers: interested_pieces
@@ -192,39 +463,54 @@ impl PieceCollector {
                             .collect(),
                     })
                     .await
-                    .map_err(|err| {
-                        error!("sync pieces from parent {} failed: {}", parent.id, err);
-                        err
+                    .inspect_err(|err| {
+                        error!(
+                            "sync persistent cache pieces from parent {} failed: {}",
+                            parent.id, err
+                        );
                     })?;
 
                 // If the response repeating timeout exceeds the piece download timeout, the stream will return error.
                 let out_stream = response.into_inner().timeout(collected_piece_timeout);
                 tokio::pin!(out_stream);
 
-                while let Some(message) =
-                    out_stream.try_next().await.or_err(ErrorType::StreamError)?
-                {
+                while let Some(message) = out_stream.try_next().await.inspect_err(|err| {
+                    error!(
+                        "sync persistent cache pieces from parent {} failed: {}",
+                        parent.id, err
+                    );
+                })? {
                     let message = message?;
-                    let mut parent_id =
-                        match collected_pieces.try_get_mut(&message.number).try_unwrap() {
-                            Some(parent_id) => parent_id,
-                            None => continue,
-                        };
-                    parent_id.push_str(&parent.id);
+                    if let Some(mut parents) = collected_pieces.get_mut(&message.number) {
+                        parents.push(parent.clone());
+                    } else {
+                        continue;
+                    }
+
+                    // Wait for collecting the piece from different parents when the first
+                    // piece is collected.
+                    tokio::time::sleep(DEFAULT_WAIT_FOR_PIECE_FROM_DIFFERENT_PARENTS).await;
+                    let parents = match collected_pieces.remove(&message.number) {
+                        Some((_, parents)) => parents,
+                        None => continue,
+                    };
+
+                    let parent = match parents.get(fastrand::usize(..parents.len())) {
+                        Some(parent) => parent,
+                        None => {
+                            error!(
+                                "collected_pieces does not contain parent for piece {}",
+                                message.number
+                            );
+                            continue;
+                        }
+                    };
 
                     info!(
-                        "received piece {}-{} metadata from parent {}",
+                        "picked up piece {}-{} metadata from parent {}",
                         task_id, message.number, parent.id
                     );
 
-                    let parent = parents
-                        .iter()
-                        .find(|parent| parent.id == parent_id.as_str())
-                        .ok_or_else(|| {
-                            error!("parent {} not found", parent_id.as_str());
-                            Error::InvalidPeer(parent_id.clone())
-                        })?;
-
                     collected_piece_tx
                         .send(CollectedPiece {
                             number: message.number,
@@ -232,16 +518,9 @@ impl PieceCollector {
                             parent: parent.clone(),
                         })
                         .await
-                        .map_err(|err| {
+                        .inspect_err(|err| {
                             error!("send CollectedPiece failed: {}", err);
-                            err
                         })?;
-
-                    // Release the lock of the piece with parent_id.
-                    drop(parent_id);
-
-                    // Remove the piece from collected_pieces.
-                    collected_pieces.remove(&message.number);
                 }
 
                 Ok(parent)
@@ -250,10 +529,9 @@ impl PieceCollector {
             join_set.spawn(
                 sync_pieces(
                     config.clone(),
-                    host_id.clone(),
-                    task_id.clone(),
+                    host_id.to_string(),
+                    task_id.to_string(),
                     parent.clone(),
-                    parents.clone(),
                     interested_pieces.clone(),
                     collected_pieces.clone(),
                     collected_piece_tx.clone(),
@@ -267,19 +545,19 @@ impl PieceCollector {
         while let Some(message) = join_set.join_next().await {
             match message {
                 Ok(Ok(peer)) => {
-                    info!("peer {} sync pieces finished", peer.id);
+                    info!("peer {} sync persistent cache pieces finished", peer.id);
 
                     // If all pieces are collected, abort all tasks.
-                    if collected_pieces.len() == 0 {
-                        info!("all pieces are collected, abort all tasks");
+                    if collected_pieces.is_empty() {
+                        info!("all persistent cache pieces are collected, abort all tasks");
                         join_set.abort_all();
                     }
                 }
                 Ok(Err(err)) => {
-                    error!("sync pieces failed: {}", err);
+                    error!("sync persistent cache pieces failed: {}", err);
                 }
                 Err(err) => {
-                    error!("sync pieces failed: {}", err);
+                    error!("sync persistent cache pieces failed: {}", err);
                 }
             }
         }

dragonfly-client/src/resource/piece_downloader.rs

@@ -0,0 +1,405 @@
+/*
+ *     Copyright 2024 The Dragonfly Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use crate::grpc::dfdaemon_upload::DfdaemonUploadClient;
+use dragonfly_api::dfdaemon::v2::{DownloadPersistentCachePieceRequest, DownloadPieceRequest};
+use dragonfly_client_config::dfdaemon::Config;
+use dragonfly_client_core::{Error, Result};
+use dragonfly_client_storage::metadata;
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::Mutex;
+use tracing::{debug, error, instrument};
+
+/// DEFAULT_DOWNLOADER_CAPACITY is the default capacity of the downloader to store the clients.
+const DEFAULT_DOWNLOADER_CAPACITY: usize = 2000;
+
+/// DEFAULT_DOWNLOADER_IDLE_TIMEOUT is the default idle timeout for the downloader.
+const DEFAULT_DOWNLOADER_IDLE_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Downloader is the interface for downloading pieces, which is implemented by different
+/// protocols. The downloader is used to download pieces from the other peers.
+#[tonic::async_trait]
+pub trait Downloader: Send + Sync {
+    /// download_piece downloads a piece from the other peer by different protocols.
+    async fn download_piece(
+        &self,
+        addr: &str,
+        number: u32,
+        host_id: &str,
+        task_id: &str,
+    ) -> Result<(Vec<u8>, u64, String)>;
+
+    /// download_persistent_cache_piece downloads a persistent cache piece from the other peer by different
+    /// protocols.
+    async fn download_persistent_cache_piece(
+        &self,
+        addr: &str,
+        number: u32,
+        host_id: &str,
+        task_id: &str,
+    ) -> Result<(Vec<u8>, u64, String)>;
+}
+
+/// DownloaderFactory is the factory for creating different downloaders by different protocols.
+pub struct DownloaderFactory {
+    /// downloader is the downloader for downloading pieces, which is implemented by different
+    /// protocols.
+    downloader: Arc<dyn Downloader + Send + Sync>,
+}
+
+/// DownloadFactory implements the DownloadFactory trait.
+impl DownloaderFactory {
+    /// new returns a new DownloadFactory.
+    pub fn new(protocol: &str, config: Arc<Config>) -> Result<Self> {
+        let downloader = match protocol {
+            "grpc" => Arc::new(GRPCDownloader::new(
+                config.clone(),
+                DEFAULT_DOWNLOADER_CAPACITY,
+                DEFAULT_DOWNLOADER_IDLE_TIMEOUT,
+            )),
+            _ => {
+                error!("downloader unsupported protocol: {}", protocol);
+                return Err(Error::InvalidParameter);
+            }
+        };
+
+        Ok(Self { downloader })
+    }
+
+    /// build returns the downloader.
+    pub fn build(&self) -> Arc<dyn Downloader> {
+        self.downloader.clone()
+    }
+}
+
+/// RequestGuard is the guard for the request.
+struct RequestGuard {
+    /// active_requests is the number of the active requests.
+    active_requests: Arc<AtomicUsize>,
+}
+
+/// RequestGuard implements the guard for the request to add or subtract the active requests.
+impl RequestGuard {
+    /// new returns a new RequestGuard.
+    fn new(active_requests: Arc<AtomicUsize>) -> Self {
+        active_requests.fetch_add(1, Ordering::SeqCst);
+        Self { active_requests }
+    }
+}
+
+/// RequestGuard implements the Drop trait.
+impl Drop for RequestGuard {
+    /// drop subtracts the active requests.
+    fn drop(&mut self) {
+        self.active_requests.fetch_sub(1, Ordering::SeqCst);
+    }
+}
+
+/// DfdaemonUploadClientEntry is the entry of the dfdaemon upload client.
+#[derive(Clone)]
+struct DfdaemonUploadClientEntry {
+    /// client is the dfdaemon upload client.
+    client: DfdaemonUploadClient,
+
+    /// active_requests is the number of the active requests.
+    active_requests: Arc<AtomicUsize>,
+
+    /// actived_at is the time when the client is the last active time.
+    actived_at: Arc<std::sync::Mutex<Instant>>,
+}
+
+/// GRPCDownloader is the downloader for downloading pieces by the gRPC protocol.
+/// It will reuse the dfdaemon upload clients to download pieces from the other peers by
+/// peer's address.
+pub struct GRPCDownloader {
+    /// config is the configuration of the dfdaemon.
+    config: Arc<Config>,
+
+    /// clients is the map of the dfdaemon upload clients.
+    clients: Arc<Mutex<HashMap<String, DfdaemonUploadClientEntry>>>,
+
+    /// capacity is the capacity of the dfdaemon upload clients. If the number of the
+    /// clients exceeds the capacity, it will clean up the idle clients.
+    capacity: usize,
+
+    /// client_idle_timeout is the idle timeout for the client. If the client is idle for a long
+    /// time, it will be removed when cleaning up the idle clients.
+    idle_timeout: Duration,
+
+    /// cleanup_at is the time when the client is the last cleanup time.
+    cleanup_at: Arc<Mutex<Instant>>,
+}
+
+/// GRPCDownloader implements the downloader with the gRPC protocol.
+impl GRPCDownloader {
+    /// new returns a new GRPCDownloader.
+    pub fn new(config: Arc<Config>, capacity: usize, idle_timeout: Duration) -> Self {
+        Self {
+            config,
+            clients: Arc::new(Mutex::new(HashMap::new())),
+            capacity,
+            idle_timeout,
+            cleanup_at: Arc::new(Mutex::new(Instant::now())),
+        }
+    }
+
+    /// client returns the dfdaemon upload client by the address.
+    ///
+    /// Opterations:
+    /// 1. If the client entry exists, it will return the client directly to reuse the client by
+    ///    the address.
+    /// 2. If the client entry does not exist, it will create a new client entry and insert it
+    ///    into the clients map.
+    async fn client(&self, addr: &str) -> Result<DfdaemonUploadClient> {
+        let now = Instant::now();
+
+        // Cleanup the idle clients first to avoid the clients exceeding the capacity and the
+        // clients are idle for a long time.
+        self.cleanup_idle_client_entries().await;
+
+        let clients = self.clients.lock().await;
+        if let Some(entry) = clients.get(addr) {
+            debug!("reusing client: {}", addr);
+            *entry.actived_at.lock().unwrap() = now;
+            return Ok(entry.client.clone());
+        }
+        drop(clients);
+
+        // If there are many concurrent requests to create the client, it will create multiple
+        // clients for the same address. But it will reuse the same client by entry operation.
+        debug!("creating client: {}", addr);
+        let client =
+            DfdaemonUploadClient::new(self.config.clone(), format!("http://{}", addr), true)
+                .await?;
+
+        let mut clients = self.clients.lock().await;
+        let entry = clients
+            .entry(addr.to_string())
+            .or_insert(DfdaemonUploadClientEntry {
+                client: client.clone(),
+                active_requests: Arc::new(AtomicUsize::new(0)),
+                actived_at: Arc::new(std::sync::Mutex::new(now)),
+            });
+
+        // If it is created by other concurrent requests and reused client, need to update the
+        // last active time.
+        *entry.actived_at.lock().unwrap() = now;
+        Ok(entry.client.clone())
+    }
+
+    /// get_client_entry returns the client entry by the address.
+    async fn get_client_entry(&self, addr: &str) -> Option<DfdaemonUploadClientEntry> {
+        let clients = self.clients.lock().await;
+        clients.get(addr).cloned()
+    }
+
+    /// remove_client_entry removes the client entry if it is idle.
+    async fn remove_client_entry(&self, addr: &str) {
+        let mut clients = self.clients.lock().await;
+        if let Some(entry) = clients.get(addr) {
+            if entry.active_requests.load(Ordering::SeqCst) == 0 {
+                clients.remove(addr);
+            }
+        }
+    }
+
+    /// cleanup_idle_clients cleans up the idle clients, which are idle for a long time or have no
+    /// active requests.
+    async fn cleanup_idle_client_entries(&self) {
+        let now = Instant::now();
+
+        // Avoid hot cleanup for the clients.
+        let cleanup_at = self.cleanup_at.lock().await;
+        let interval = self.idle_timeout / 2;
+        if now.duration_since(*cleanup_at) < interval {
+            debug!("avoid hot cleanup");
+            return;
+        }
+        drop(cleanup_at);
+
+        let mut clients = self.clients.lock().await;
+        let exceeds_capacity = clients.len() > self.capacity;
+        clients.retain(|addr, entry| {
+            let active_requests = entry.active_requests.load(Ordering::SeqCst);
+            let is_active = active_requests > 0;
+            let actived_at = entry.actived_at.lock().unwrap();
+            let idel_duration = now.duration_since(*actived_at);
+            let is_recent = idel_duration <= self.idle_timeout;
+
+            // Retain the client if it is active or not exceeds the capacity and is recent.
+            let should_retain = is_active || (!exceeds_capacity && is_recent);
+            if !should_retain {
+                debug!(
+                    "removing idle client: {}, exceeds_capacity: {}, idle_duration: {}s",
+                    addr,
+                    exceeds_capacity,
+                    idel_duration.as_secs(),
+                );
+            }
+
+            should_retain
+        });
+
+        // Update the cleanup time.
+        *self.cleanup_at.lock().await = now;
+    }
+}
+
+/// GRPCDownloader implements the Downloader trait.
+#[tonic::async_trait]
+impl Downloader for GRPCDownloader {
+    /// download_piece downloads a piece from the other peer by the gRPC protocol.
+    #[instrument(skip_all)]
+    async fn download_piece(
+        &self,
+        addr: &str,
+        number: u32,
+        host_id: &str,
+        task_id: &str,
+    ) -> Result<(Vec<u8>, u64, String)> {
+        let client = self.client(addr).await?;
+
+        let entry = self
+            .get_client_entry(addr)
+            .await
+            .ok_or(Error::UnexpectedResponse)?;
+        let request_guard = RequestGuard::new(entry.active_requests.clone());
+
+        let response = match client
+            .download_piece(
+                DownloadPieceRequest {
+                    host_id: host_id.to_string(),
+                    task_id: task_id.to_string(),
+                    piece_number: number,
+                },
+                self.config.download.piece_timeout,
+            )
+            .await
+        {
+            Ok(response) => response,
+            Err(err) => {
+                // If the request fails, it will drop the request guard and remove the client
+                // entry to avoid using the invalid client.
+                drop(request_guard);
+                self.remove_client_entry(addr).await;
+                return Err(err);
+            }
+        };
+
+        let Some(piece) = response.piece else {
+            return Err(Error::InvalidParameter);
+        };
+
+        let Some(content) = piece.content else {
+            return Err(Error::InvalidParameter);
+        };
+
+        // Calculate the digest of the piece metadata and compare it with the expected digest,
+        // it verifies the integrity of the piece metadata.
+        let piece_metadata = metadata::Piece {
+            number,
+            length: piece.length,
+            offset: piece.offset,
+            digest: piece.digest.clone(),
+            ..Default::default()
+        };
+
+        if let Some(expected_digest) = response.digest {
+            let digest = piece_metadata.calculate_digest();
+            if expected_digest != digest {
+                return Err(Error::DigestMismatch(
+                    expected_digest.to_string(),
+                    digest.to_string(),
+                ));
+            }
+        }
+
+        Ok((content, piece.offset, piece.digest))
+    }
+
+    /// download_persistent_cache_piece downloads a persistent cache piece from the other peer by
+    /// the gRPC protocol.
+    #[instrument(skip_all)]
+    async fn download_persistent_cache_piece(
+        &self,
+        addr: &str,
+        number: u32,
+        host_id: &str,
+        task_id: &str,
+    ) -> Result<(Vec<u8>, u64, String)> {
+        let client = self.client(addr).await?;
+
+        let entry = self
+            .get_client_entry(addr)
+            .await
+            .ok_or(Error::UnexpectedResponse)?;
+        let request_guard = RequestGuard::new(entry.active_requests.clone());
+
+        let response = match client
+            .download_persistent_cache_piece(
+                DownloadPersistentCachePieceRequest {
+                    host_id: host_id.to_string(),
+                    task_id: task_id.to_string(),
+                    piece_number: number,
+                },
+                self.config.download.piece_timeout,
+            )
+            .await
+        {
+            Ok(response) => response,
+            Err(err) => {
+                // If the request fails, it will drop the request guard and remove the client
+                // entry to avoid using the invalid client.
+                drop(request_guard);
+                self.remove_client_entry(addr).await;
+                return Err(err);
+            }
+        };
+
+        let Some(piece) = response.piece else {
+            return Err(Error::InvalidParameter);
+        };
+
+        let Some(content) = piece.content else {
+            return Err(Error::InvalidParameter);
+        };
+
+        // Calculate the digest of the piece metadata and compare it with the expected digest,
+        // it verifies the integrity of the piece metadata.
+        let piece_metadata = metadata::Piece {
+            number,
+            length: piece.length,
+            offset: piece.offset,
+            digest: piece.digest.clone(),
+            ..Default::default()
+        };
+
+        if let Some(expected_digest) = response.digest {
+            let digest = piece_metadata.calculate_digest();
+            if expected_digest != digest {
+                return Err(Error::DigestMismatch(
+                    expected_digest.to_string(),
+                    digest.to_string(),
+                ));
+            }
+        }
+
+        Ok((content, piece.offset, piece.digest))
+    }
+}

dragonfly-client/src/shutdown.rs

@@ -109,3 +109,100 @@ pub async fn shutdown_signal() {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::time::{sleep, Duration};
+
+    #[tokio::test]
+    async fn test_shutdown_trigger_and_recv() {
+        // Create a new shutdown instance.
+        let mut shutdown = Shutdown::new();
+
+        // Trigger the shutdown signal in a separate task.
+        let shutdown_clone = shutdown.clone();
+        tokio::spawn(async move {
+            // Small delay to ensure the receiver is waiting.
+            sleep(Duration::from_millis(10)).await;
+            shutdown_clone.trigger();
+        });
+
+        // Wait for the shutdown signal.
+        shutdown.recv().await;
+
+        // Verify that is_shutdown is set to true.
+        assert!(shutdown.is_shutdown());
+    }
+
+    #[tokio::test]
+    async fn test_shutdown_multiple_receivers() {
+        // Create a new shutdown instance.
+        let mut shutdown1 = Shutdown::new();
+        let mut shutdown2 = shutdown1.clone();
+        let mut shutdown3 = shutdown1.clone();
+
+        // Trigger the shutdown signal.
+        shutdown1.trigger();
+
+        // All receivers should receive the signal.
+        shutdown1.recv().await;
+        shutdown2.recv().await;
+        shutdown3.recv().await;
+
+        // Verify that all instances have is_shutdown set to true.
+        assert!(shutdown1.is_shutdown());
+        assert!(shutdown2.is_shutdown());
+        assert!(shutdown3.is_shutdown());
+    }
+
+    #[tokio::test]
+    async fn test_shutdown_clone_behavior() {
+        // Create a new shutdown instance.
+        let mut shutdown1 = Shutdown::new();
+
+        // Set is_shutdown to true.
+        shutdown1.trigger();
+        shutdown1.recv().await;
+        assert!(shutdown1.is_shutdown());
+
+        // Clone the instance.
+        let shutdown2 = shutdown1.clone();
+
+        // Verify that the clone has the same is_shutdown value.
+        assert_eq!(shutdown1.is_shutdown(), shutdown2.is_shutdown());
+
+        // Create a new instance before triggering.
+        let mut shutdown3 = Shutdown::new();
+        let mut shutdown4 = shutdown3.clone();
+
+        // Trigger after cloning.
+        shutdown3.trigger();
+
+        // Both should receive the signal.
+        shutdown3.recv().await;
+        shutdown4.recv().await;
+
+        assert!(shutdown3.is_shutdown());
+        assert!(shutdown4.is_shutdown());
+    }
+
+    #[tokio::test]
+    async fn test_shutdown_already_triggered() {
+        // Create a new shutdown instance.
+        let mut shutdown = Shutdown::new();
+
+        // Trigger and receive.
+        shutdown.trigger();
+        shutdown.recv().await;
+        assert!(shutdown.is_shutdown());
+
+        // Call recv again, should return immediately.
+        let start = std::time::Instant::now();
+        shutdown.recv().await;
+        let elapsed = start.elapsed();
+
+        // Verify that recv returned immediately (less than 5ms).
+        assert!(elapsed < Duration::from_millis(5));
+    }
+}

dragonfly-client/src/stats/mod.rs

@@ -67,7 +67,6 @@ pub struct Stats {
 /// Stats implements the stats server.
 impl Stats {
     /// new creates a new Stats.
-    #[instrument(skip_all)]
     pub fn new(
         addr: SocketAddr,
         shutdown: shutdown::Shutdown,
@@ -81,7 +80,6 @@ impl Stats {
     }
 
     /// run starts the stats server.
-    #[instrument(skip_all)]
     pub async fn run(&self) {
         // Clone the shutdown channel.
         let mut shutdown = self.shutdown.clone();

dragonfly-client/src/tracing/mod.rs

@@ -14,16 +14,19 @@
  * limitations under the License.
  */
 
-use opentelemetry::sdk::propagation::TraceContextPropagator;
+use dragonfly_client_config::dfdaemon::Host;
+use opentelemetry::{global, trace::TracerProvider, KeyValue};
+use opentelemetry_otlp::{WithExportConfig, WithTonicConfig};
+use opentelemetry_sdk::{propagation::TraceContextPropagator, Resource};
 use rolling_file::*;
 use std::fs;
-use std::fs::OpenOptions;
-use std::os::unix::io::AsRawFd;
 use std::path::PathBuf;
+use std::str::FromStr;
+use std::time::Duration;
+use tonic::metadata::{MetadataKey, MetadataMap, MetadataValue};
 use tracing::{info, Level};
 use tracing_appender::non_blocking::WorkerGuard;
-use tracing_flame::FlameLayer;
-use tracing_log::LogTracer;
+use tracing_opentelemetry::OpenTelemetryLayer;
 use tracing_subscriber::{
     filter::LevelFilter,
     fmt::{time::ChronoLocal, Layer},
@@ -31,6 +34,9 @@ use tracing_subscriber::{
     EnvFilter, Registry,
 };
 
+/// SPAN_EXPORTER_TIMEOUT is the timeout for the span exporter.
+const SPAN_EXPORTER_TIMEOUT: Duration = Duration::from_secs(10);
+
 /// init_tracing initializes the tracing system.
 #[allow(clippy::too_many_arguments)]
 pub fn init_tracing(
@@ -38,18 +44,22 @@ pub fn init_tracing(
     log_dir: PathBuf,
     log_level: Level,
     log_max_files: usize,
-    jaeger_addr: Option<String>,
-    flamegraph: bool,
-    redirect_stderr: bool,
-    verbose: bool,
+    otel_protocol: Option<String>,
+    otel_endpoint: Option<String>,
+    otel_path: Option<PathBuf>,
+    otel_headers: Option<reqwest::header::HeaderMap>,
+    host: Option<Host>,
+    is_seed_peer: bool,
+    console: bool,
 ) -> Vec<WorkerGuard> {
     let mut guards = vec![];
 
     // Setup stdout layer.
     let (stdout_writer, stdout_guard) = tracing_appender::non_blocking(std::io::stdout());
+    guards.push(stdout_guard);
 
     // Initialize stdout layer.
-    let stdout_filter = if verbose {
+    let stdout_filter = if console {
         LevelFilter::DEBUG
     } else {
         LevelFilter::OFF
@@ -64,7 +74,6 @@ pub fn init_tracing(
         .with_timer(ChronoLocal::rfc_3339())
         .pretty()
         .with_filter(stdout_filter);
-    guards.push(stdout_guard);
 
     // Setup file layer.
     fs::create_dir_all(log_dir.clone()).expect("failed to create log directory");
@@ -76,6 +85,8 @@ pub fn init_tracing(
     .expect("failed to create rolling file appender");
 
     let (rolling_writer, rolling_writer_guard) = tracing_appender::non_blocking(rolling_appender);
+    guards.push(rolling_writer_guard);
+
     let file_logging_layer = Layer::new()
         .with_writer(rolling_writer)
         .with_ansi(false)
@@ -86,71 +97,126 @@ pub fn init_tracing(
         .with_thread_ids(false)
         .with_timer(ChronoLocal::rfc_3339())
         .compact();
-    guards.push(rolling_writer_guard);
 
     // Setup env filter for log level.
     let env_filter = EnvFilter::try_from_default_env()
         .unwrap_or_else(|_| EnvFilter::default().add_directive(log_level.into()));
 
-    // Setup flame layer.
-    let flame_layer = if flamegraph {
-        let (flame_layer, _guard) = FlameLayer::with_file(log_dir.join("tracing.folded"))
-            .expect("failed to create flame layer");
-        Some(flame_layer)
+    // Enable console subscriber layer for tracing spawn tasks on `127.0.0.1:6669` when log level is TRACE.
+    let console_subscriber_layer = if log_level == Level::TRACE {
+        Some(console_subscriber::spawn())
     } else {
         None
     };
 
     let subscriber = Registry::default()
         .with(env_filter)
+        .with(console_subscriber_layer)
         .with(file_logging_layer)
-        .with(stdout_logging_layer)
-        .with(flame_layer);
+        .with(stdout_logging_layer);
 
-    // Setup jaeger layer.
-    if let Some(jaeger_addr) = jaeger_addr {
-        opentelemetry::global::set_text_map_propagator(TraceContextPropagator::new());
-        let tracer = opentelemetry_jaeger::new_agent_pipeline()
-            .with_service_name(name)
-            .with_endpoint(jaeger_addr)
-            .install_batch(opentelemetry::runtime::Tokio)
-            .expect("install");
-        let jaeger_layer = tracing_opentelemetry::layer().with_tracer(tracer);
-        let subscriber = subscriber.with(jaeger_layer);
+    // If OTLP protocol and endpoint are provided, set up OpenTelemetry tracing.
+    if let (Some(protocol), Some(endpoint)) = (otel_protocol, otel_endpoint) {
+        let otlp_exporter = match protocol.as_str() {
+            "grpc" => {
+                let mut metadata = MetadataMap::new();
+                if let Some(headers) = otel_headers {
+                    for (key, value) in headers.iter() {
+                        metadata.insert(
+                            MetadataKey::from_str(key.as_str())
+                                .expect("failed to create metadata key"),
+                            MetadataValue::from_str(value.to_str().unwrap())
+                                .expect("failed to create metadata value"),
+                        );
+                    }
+                }
 
-        tracing::subscriber::set_global_default(subscriber)
-            .expect("failed to set global subscriber");
+                let endpoint_url = url::Url::parse(&format!("http://{}", endpoint))
+                    .expect("failed to parse OTLP endpoint URL");
+
+                opentelemetry_otlp::SpanExporter::builder()
+                    .with_tonic()
+                    .with_endpoint(endpoint_url)
+                    .with_timeout(SPAN_EXPORTER_TIMEOUT)
+                    .with_metadata(metadata)
+                    .build()
+                    .expect("failed to create OTLP exporter")
+            }
+            "http" | "https" => {
+                let mut endpoint_url = url::Url::parse(&format!("{}://{}", protocol, endpoint))
+                    .expect("failed to parse OTLP endpoint URL");
+
+                if let Some(path) = otel_path {
+                    endpoint_url = endpoint_url
+                        .join(path.to_str().unwrap())
+                        .expect("failed to join OTLP endpoint path");
+                }
+
+                opentelemetry_otlp::SpanExporter::builder()
+                    .with_http()
+                    .with_endpoint(endpoint_url.as_str())
+                    .with_protocol(opentelemetry_otlp::Protocol::HttpJson)
+                    .with_timeout(SPAN_EXPORTER_TIMEOUT)
+                    .build()
+                    .expect("failed to create OTLP exporter")
+            }
+            _ => {
+                panic!("unsupported OTLP protocol: {}", protocol);
+            }
+        };
+
+        let host = host.unwrap();
+        let provider = opentelemetry_sdk::trace::SdkTracerProvider::builder()
+            .with_batch_exporter(otlp_exporter)
+            .with_resource(
+                Resource::builder()
+                    .with_service_name(format!("{}-{}", name, host.ip.unwrap()))
+                    .with_schema_url(
+                        [
+                            KeyValue::new(
+                                opentelemetry_semantic_conventions::attribute::SERVICE_NAMESPACE,
+                                "dragonfly",
+                            ),
+                            KeyValue::new(
+                                opentelemetry_semantic_conventions::attribute::HOST_NAME,
+                                host.hostname,
+                            ),
+                            KeyValue::new(
+                                opentelemetry_semantic_conventions::attribute::HOST_IP,
+                                host.ip.unwrap().to_string(),
+                            ),
+                        ],
+                        opentelemetry_semantic_conventions::SCHEMA_URL,
+                    )
+                    .with_attribute(opentelemetry::KeyValue::new(
+                        "host.idc",
+                        host.idc.unwrap_or_default(),
+                    ))
+                    .with_attribute(opentelemetry::KeyValue::new(
+                        "host.location",
+                        host.location.unwrap_or_default(),
+                    ))
+                    .with_attribute(opentelemetry::KeyValue::new("host.seed_peer", is_seed_peer))
+                    .build(),
+            )
+            .build();
+
+        let tracer = provider.tracer(name.to_string());
+        global::set_tracer_provider(provider.clone());
+        global::set_text_map_propagator(TraceContextPropagator::new());
+
+        let jaeger_layer = OpenTelemetryLayer::new(tracer);
+        subscriber.with(jaeger_layer).init();
     } else {
-        tracing::subscriber::set_global_default(subscriber)
-            .expect("failed to set global subscriber");
+        subscriber.init();
     }
 
-    LogTracer::init().expect("failed to init LogTracer");
-
+    std::panic::set_hook(Box::new(tracing_panic::panic_hook));
     info!(
         "tracing initialized directory: {}, level: {}",
         log_dir.as_path().display(),
         log_level
     );
 
-    // Redirect stderr to file.
-    if redirect_stderr {
-        redirect_stderr_to_file(log_dir);
-    }
-
     guards
 }
-
-/// redirect_stderr_to_file redirects stderr to a file.
-fn redirect_stderr_to_file(log_dir: PathBuf) {
-    let log_path = log_dir.join("stderr.log");
-    let file = OpenOptions::new()
-        .create(true)
-        .append(true)
-        .open(log_path)
-        .unwrap();
-
-    unsafe {
-        libc::dup2(file.as_raw_fd(), libc::STDERR_FILENO);
-    }
-}

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.80.0"
+channel = "1.85.0"