fix(volo-grpc): use concat to get the entire encoded result from linkedbytes (#628)

* chore(volo): add test coverage workflow

* fix(volo-grpc): use linkedbytes concat to get the full encoded results

* perf(volo-grpc): yield each node as a separate frame to avoid copy

* chore(volo-grpc): update version and cargo clippy

* fix(volo-grpc): the start of prefix is always 0 because we use new buffer for each item

* chore(volo): calculate the coverage of multiple features for each crate

* chore: remove unused files

Author: Ggiggle

.github/codecov.yaml

@@ -0,0 +1,10 @@
+coverage:
+  status:
+    project:               
+      default:
+        informational: true  
+    patch:
+      default:
+        target: 70%  
+        threshold: 0%
+        informational: false

.github/workflows/ci.yaml

@@ -144,3 +144,42 @@ jobs:
       - name: Cli tests
         run: |
           bash scripts/volo-cli-test.sh
+  coverage:
+    runs-on: [self-hosted, Linux, amd64]
+    timeout-minutes: 40
+    permissions:
+      contents: read
+      checks: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+
+        with:
+          components: rustfmt, clippy
+      - uses: taiki-e/install-action@v2
+
+        with:
+          tool: cargo-llvm-cov
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-nextest
+
+
+      - name: Generate coverage (LCOV + HTML)
+        run: |
+          bash scripts/coverage.sh
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: coverage-html
+          path: target/llvm-cov/html
+
+
+      - name: Upload to Codecov
+        uses: codecov/codecov-action@v4
+
+        with:
+          files: lcov.info
+          fail_ci_if_error: true
+          verbose: true

Cargo.lock

@@ -153,8 +153,12 @@ volo = { path = "../volo" }
 volo-grpc = { path = "../volo-grpc", features = ["grpc-web"] }
 volo-thrift = { path = "../volo-thrift", features = ["multiplex"] }
 volo-http = { path = "../volo-http", features = [
-    "client", "server",
-    "json", "query", "form", "cookie",
+    "client",
+    "server",
+    "json",
+    "query",
+    "form",
+    "cookie",
     "http1",
 ] }
 

examples/Cargo.toml

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+IGNORE_REGEX='(^|[\\/])(benches|tests?|examples|target|gen|test_data)([\\/])|(^|[\\/])build\\.rs$|(^|[\\/])\\.cargo[\\/]registry'
+
+run_nextest() {
+  local package="$1"
+  local features="${2:-}"
+  local no_tests_behavior="${NO_TESTS_BEHAVIOR:-pass}"
+  if [ -n "$features" ]; then
+    cargo llvm-cov nextest -p "$package" --features "$features" --all-targets --no-report \
+      --no-tests="$no_tests_behavior" \
+      --ignore-filename-regex "$IGNORE_REGEX"
+  else
+    cargo llvm-cov nextest -p "$package" --all-targets --no-report \
+      --no-tests="$no_tests_behavior" \
+      --ignore-filename-regex "$IGNORE_REGEX"
+  fi
+}
+
+report_all() {
+  cargo llvm-cov report --lcov --output-path lcov.info \
+    --ignore-filename-regex "$IGNORE_REGEX"
+  cargo llvm-cov report --html \
+    --ignore-filename-regex "$IGNORE_REGEX"
+}
+
+main() {
+  # 1. clean up previous coverage data
+  cargo llvm-cov clean --workspace || true
+
+  # 2.run tests with coverage, align with scripts/clippy-and-test.sh
+  run_nextest volo-thrift
+  run_nextest volo-grpc 'rustls'
+  run_nextest volo-http 'client,server,http1,query,form,json,tls,cookie,multipart,ws'
+  run_nextest volo-http 'client,server,http2,query,form,json,tls,cookie,multipart,ws'
+  run_nextest volo-http 'full'
+  run_nextest volo 'rustls'
+  run_nextest volo-build
+  run_nextest volo-cli
+
+  # 3.generate coverage report
+  report_all
+}
+
+main "$@"
+
+

scripts/coverage.sh

@@ -1,6 +1,6 @@
 [package]
 name = "volo-grpc"
-version = "0.11.7"
+version = "0.11.8"
 edition.workspace = true
 homepage.workspace = true
 repository.workspace = true
@@ -53,6 +53,7 @@ hyper-util = { workspace = true, features = [
   "server",
   "http2",
 ] }
+linkedbytes.workspace = true
 matchit.workspace = true
 paste.workspace = true
 percent-encoding.workspace = true

volo-grpc/Cargo.toml

@@ -12,7 +12,6 @@ use flate2::bufread::{GzDecoder, GzEncoder};
 #[cfg(feature = "zlib")]
 use flate2::bufread::{ZlibDecoder, ZlibEncoder};
 use http::HeaderValue;
-use pilota::LinkedBytes;
 
 use super::BUFFER_SIZE;
 #[cfg(feature = "compress")]
@@ -274,23 +273,23 @@ impl CompressionEncoding {
 /// Compress `len` bytes from `src_buf` into `dest_buf`.
 pub(crate) fn compress(
     encoding: CompressionEncoding,
-    src_buf: &mut LinkedBytes,
-    dest_buf: &mut LinkedBytes,
+    src_buf: &mut BytesMut,
+    dest_buf: &mut BytesMut,
 ) -> Result<(), io::Error> {
-    let len = src_buf.bytes().len();
+    let len = src_buf.len();
     let capacity = ((len / BUFFER_SIZE) + 1) * BUFFER_SIZE;
 
     dest_buf.reserve(capacity);
 
     match encoding {
         #[cfg(feature = "gzip")]
         CompressionEncoding::Gzip(Some(config)) => {
-            let mut gz_encoder = GzEncoder::new(&src_buf.bytes()[0..len], config.level);
+            let mut gz_encoder = GzEncoder::new(&src_buf[0..len], config.level);
             io::copy(&mut gz_encoder, &mut dest_buf.writer())?;
         }
         #[cfg(feature = "zlib")]
         CompressionEncoding::Zlib(Some(config)) => {
-            let mut zlib_encoder = ZlibEncoder::new(&src_buf.bytes()[0..len], config.level);
+            let mut zlib_encoder = ZlibEncoder::new(&src_buf[0..len], config.level);
             io::copy(&mut zlib_encoder, &mut dest_buf.writer())?;
         }
         #[cfg(feature = "zstd")]
@@ -302,13 +301,13 @@ pub(crate) fn compress(
                 level as i32
             };
             let mut zstd_encoder = zstd::Encoder::new(dest_buf.writer(), zstd_level)?;
-            io::copy(&mut &src_buf.bytes()[0..len], &mut zstd_encoder)?;
+            io::copy(&mut &src_buf[0..len], &mut zstd_encoder)?;
             zstd_encoder.finish()?;
         }
         _ => {}
     };
 
-    src_buf.bytes_mut().advance(len);
+    src_buf.advance(len);
     Ok(())
 }
 
@@ -349,8 +348,7 @@ pub(crate) fn decompress(
 
 #[cfg(test)]
 mod tests {
-    use bytes::BufMut;
-    use pilota::LinkedBytes;
+    use bytes::BytesMut;
 
     #[cfg(feature = "gzip")]
     use crate::codec::compression::GzipConfig;
@@ -367,11 +365,11 @@ mod tests {
 
     #[test]
     fn test_consistency_for_compression() {
-        let mut src = LinkedBytes::with_capacity(BUFFER_SIZE);
-        let mut compress_buf = LinkedBytes::new();
-        let mut de_data = LinkedBytes::with_capacity(BUFFER_SIZE);
+        let mut src = BytesMut::with_capacity(BUFFER_SIZE);
+        let mut compress_buf = BytesMut::new();
+        let mut de_data = BytesMut::with_capacity(BUFFER_SIZE);
         let test_data = &b"test compression"[..];
-        src.put(test_data);
+        src.extend_from_slice(test_data);
 
         let encodings = [
             #[cfg(feature = "gzip")]
@@ -390,11 +388,10 @@ mod tests {
         ];
 
         for encoding in encodings {
-            compress_buf.reset();
+            compress_buf.clear();
             compress(encoding, &mut src, &mut compress_buf).expect("compress failed:");
-            decompress(encoding, compress_buf.bytes_mut(), de_data.bytes_mut())
-                .expect("decompress failed:");
-            assert_eq!(test_data, de_data.bytes());
+            decompress(encoding, &mut compress_buf, &mut de_data).expect("decompress failed:");
+            assert_eq!(test_data, de_data.as_ref());
         }
     }
 }