SharedCfg is not Copy (#82)

fafhrd91 · web-flow · commit ee3ca9f3c834 · 2026-02-16T13:08:24.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changes
 
+## [3.7.0] - 2026-02-16
+
+* SharedCfg is not Copy
+
 ## [3.6.2] - 2026-02-11
 
 * Better clippy configuration
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ntex-h2"
-version = "3.6.2"
+version = "3.7.0"
 license = "MIT OR Apache-2.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "An HTTP/2 client and server"
@@ -31,6 +31,7 @@ ntex-io = "3.7"
 ntex-net = "3"
 ntex-service = "4.4"
 ntex-util = "3"
+ntex-server = "3.7"
 
 bitflags = "2"
 foldhash = "0.2"
diff --git a/src/client/connector.rs b/src/client/connector.rs
@@ -90,11 +90,12 @@ where
     type Service = ConnectorService<A, T::Service>;
 
     async fn create(&self, cfg: SharedCfg) -> Result<Self::Service, Self::InitError> {
+        let config = cfg.get();
         let svc = self.svc.create(cfg).await?;
         Ok(ConnectorService {
             svc,
+            config,
             scheme: self.scheme.clone(),
-            config: cfg.get(),
             pool: self.pool.clone(),
             _t: PhantomData,
         })
@@ -126,7 +127,7 @@ where
         let fut = async {
             Ok::<_, ClientError>(SimpleClient::with_params(
                 ctx.call(&self.svc, Connect::new(req)).await?.into(),
-                self.config,
+                self.config.clone(),
                 &self.scheme,
                 authority,
                 false,
diff --git a/src/client/pool.rs b/src/client/pool.rs
@@ -174,7 +174,7 @@ impl Client {
                     // construct client
                     let client = SimpleClient::with_params(
                         io,
-                        inner.cfg,
+                        inner.cfg.clone(),
                         &inner.config.scheme,
                         inner.config.authority.clone(),
                         inner.config.skip_unknown_streams,
@@ -433,22 +433,20 @@ where
     /// Finish configuration process and create connections pool.
     pub async fn build(self, cfg: SharedCfg) -> Result<Client, T::InitError> {
         let connect = self.connect;
+        let tag = cfg.tag();
+        let client_cfg = cfg.get();
         let svc = Pipeline::new(self.connector.create(cfg).await?);
 
         let connector = Box::new(move || {
-            log::trace!(
-                "{}: Opening http/2 connection to {}",
-                cfg.tag(),
-                connect.host()
-            );
+            log::trace!("{tag}: Opening http/2 connection to {}", connect.host());
             let fut = svc.call_static(connect.clone());
             Box::pin(async move { fut.await.map(IoBoxed::from) }) as Fut
         });
 
         Ok(Client {
             inner: Rc::new(Inner {
                 connector,
-                cfg: cfg.get(),
+                cfg: client_cfg,
                 config: self.inner,
             }),
             waiters: Rc::default(),
diff --git a/src/config.rs b/src/config.rs
@@ -11,7 +11,7 @@ use ntex_util::time::Seconds;
 
 use crate::{consts, frame, frame::Settings, frame::WindowSize};
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Clone, Debug)]
 /// Http2 connection configuration
 pub struct ServiceConfig {
     pub(crate) settings: Settings,
diff --git a/src/connection.rs b/src/connection.rs
@@ -990,17 +990,18 @@ mod tests {
 
     const PREFACE: [u8; 24] = *b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";
 
+    #[allow(clippy::needless_pass_by_value)]
     fn get_reset(frm: frame::Frame) -> frame::Reset {
         match frm {
             frame::Frame::Reset(rst) => rst,
-            _ => panic!("Expect Reset frame: {:?}", frm),
+            _ => panic!("Expect Reset frame: {frm:?}"),
         }
     }
 
     fn goaway(frm: frame::Frame) -> frame::GoAway {
         match frm {
             frame::Frame::GoAway(f) => f,
-            _ => panic!("Expect Reset frame: {:?}", frm),
+            _ => panic!("Expect Reset frame: {frm:?}"),
         }
     }
 
diff --git a/src/frame/headers.rs b/src/frame/headers.rs
@@ -561,7 +561,7 @@ mod test {
             HeaderValue::from_static("sup"),
         );
 
-        let mut headers = Headers::new(StreamId::CON, Default::default(), hdrs, false);
+        let mut headers = Headers::new(StreamId::CON, PseudoHeaders::default(), hdrs, false);
         headers.set_end_headers();
         headers.encode(&mut encoder, &mut dst, 8);
         assert_eq!(48, dst.len());
diff --git a/src/hpack/decoder.rs b/src/hpack/decoder.rs
@@ -851,7 +851,7 @@ mod test {
         let mut de = Decoder::new(0);
 
         let mut buf = BytesMut::new();
-        buf.extend(&[0b01000000, 0x80 | 2]);
+        buf.extend(&[0b0100_0000, 0x80 | 2]);
         buf.extend(huff_encode(b"foo"));
         buf.extend(&[0x80 | 3]);
         buf.extend(huff_encode(b"bar"));
@@ -890,7 +890,7 @@ mod test {
         let value = huff_encode(b"bar");
         let mut buf = BytesMut::new();
         // header name is non_huff encoded
-        buf.extend(&[0b01000000, 3]);
+        buf.extend(&[0b0100_0000, 3]);
         buf.extend(b"foo");
         // header value is partial
         buf.extend(&[0x80 | 3]);
diff --git a/src/hpack/encoder.rs b/src/hpack/encoder.rs
@@ -321,7 +321,7 @@ mod test {
         let mut encoder = Encoder::default();
         let res = encode(&mut encoder, vec![method("PATCH")]);
 
-        assert_eq!(res[0], 0b01000000 | 2); // Incremental indexing w/ name pulled from table
+        assert_eq!(res[0], 0b0100_0000 | 2); // Incremental indexing w/ name pulled from table
         assert_eq!(res[1], 0x80 | 5); // header value w/ huffman coding
 
         assert_eq!("PATCH", huff_decode(&res[2..7]));
@@ -338,14 +338,14 @@ mod test {
         let mut encoder = Encoder::default();
         let res = encode(&mut encoder, vec![header("content-language", "foo")]);
 
-        assert_eq!(res[0], 0b01000000 | 27); // Indexed name
+        assert_eq!(res[0], 0b0100_0000 | 27); // Indexed name
         assert_eq!(res[1], 0x80 | 2); // header value w/ huffman coding
 
         assert_eq!("foo", huff_decode(&res[2..4]));
 
         // Same name, new value should still use incremental
         let res = encode(&mut encoder, vec![header("content-language", "bar")]);
-        assert_eq!(res[0], 0b01000000 | 27); // Indexed name
+        assert_eq!(res[0], 0b0100_0000 | 27); // Indexed name
         assert_eq!(res[1], 0x80 | 3); // header value w/ huffman coding
         assert_eq!("bar", huff_decode(&res[2..5]));
     }
@@ -355,7 +355,7 @@ mod test {
         let mut encoder = Encoder::default();
         let res = encode(&mut encoder, vec![header("foo", "hello")]);
 
-        assert_eq!(&[0b01000000, 0x80 | 2], &res[0..2]);
+        assert_eq!(&[0b0100_0000, 0x80 | 2], &res[0..2]);
         assert_eq!("foo", huff_decode(&res[2..4]));
         assert_eq!(0x80 | 4, res[4]);
         assert_eq!("hello", huff_decode(&res[5..]));
@@ -375,10 +375,10 @@ mod test {
 
         // Fill the table
         for i in 0..64 {
-            let key = format!("x-hello-world-{:02}", i);
+            let key = format!("x-hello-world-{i:02}");
             let res = encode(&mut encoder, vec![header(&key, &key)]);
 
-            assert_eq!(&[0b01000000, 0x80 | 12], &res[0..2]);
+            assert_eq!(&[0b0100_0000, 0x80 | 12], &res[0..2]);
             assert_eq!(key, huff_decode(&res[2..14]));
             assert_eq!(0x80 | 12, res[14]);
             assert_eq!(key, huff_decode(&res[15..]));
@@ -396,7 +396,7 @@ mod test {
 
         // Find existing headers
         for i in 0..64 {
-            let key = format!("x-hello-world-{:02}", i);
+            let key = format!("x-hello-world-{i:02}");
             let res = encode(&mut encoder, vec![header(&key, &key)]);
             assert_eq!(0x80, res[0] & 0x80);
         }
@@ -405,7 +405,7 @@ mod test {
         let key = "x-hello-world-64";
         let res = encode(&mut encoder, vec![header(key, key)]);
 
-        assert_eq!(&[0b01000000, 0x80 | 12], &res[0..2]);
+        assert_eq!(&[0b0100_0000, 0x80 | 12], &res[0..2]);
         assert_eq!(key, huff_decode(&res[2..14]));
         assert_eq!(0x80 | 12, res[14]);
         assert_eq!(key, huff_decode(&res[15..]));
@@ -415,7 +415,7 @@ mod test {
 
         // Now try encoding entries that should exist in the table
         for i in 1..65 {
-            let key = format!("x-hello-world-{:02}", i);
+            let key = format!("x-hello-world-{i:02}");
             let res = encode(&mut encoder, vec![header(&key, &key)]);
             assert_eq!(0x80 | (61 + (65 - i)), res[0]);
         }
@@ -678,20 +678,14 @@ mod test {
     fn test_large_size_update() {
         let mut encoder = Encoder::default();
 
-        encoder.update_max_size(1912930560);
-        assert_eq!(Some(SizeUpdate::One(1912930560)), encoder.size_update);
+        encoder.update_max_size(1_912_930_560);
+        assert_eq!(Some(SizeUpdate::One(1_912_930_560)), encoder.size_update);
 
         let mut dst = BytesMut::with_capacity(6);
         encoder.encode_size_updates(&mut dst);
         assert_eq!([63, 225, 129, 148, 144, 7], &dst[..]);
     }
 
-    #[test]
-    #[ignore]
-    fn test_evicted_overflow() {
-        // Not sure what the best way to do this is.
-    }
-
     fn encode(e: &mut Encoder, hdrs: Vec<Header<Option<HeaderName>>>) -> BytesMut {
         let mut dst = BytesMut::with_capacity(1024);
         e.encode(hdrs, &mut dst);
diff --git a/src/hpack/test/fixture.rs b/src/hpack/test/fixture.rs
@@ -16,10 +16,10 @@ fn test_fixture(path: &Path) {
     file.read_to_string(&mut data).unwrap();
 
     let story: Value = serde_json::from_str(&data).unwrap();
-    test_story(story);
+    test_story(&story);
 }
 
-fn test_story(story: Value) {
+fn test_story(story: &Value) {
     let story = story.as_object().unwrap();
 
     if let Some(cases) = story.get("cases") {
@@ -144,10 +144,8 @@ fn key_str(e: &Header) -> &str {
 fn value_str(e: &Header) -> &str {
     match *e {
         Header::Field { ref value, .. } => value.to_str().unwrap(),
-        Header::Authority(ref v) => v,
+        Header::Authority(ref v) | Header::Scheme(ref v) | Header::Path(ref v) => v,
         Header::Method(ref m) => m.as_str(),
-        Header::Scheme(ref v) => v,
-        Header::Path(ref v) => v,
         Header::Protocol(ref v) => v.as_str(),
         Header::Status(ref v) => v.as_str(),
     }
diff --git a/src/hpack/test/fuzz.rs b/src/hpack/test/fuzz.rs
@@ -11,15 +11,16 @@ const MAX_CHUNK: usize = 2 * 1024;
 
 #[test]
 fn hpack_fuzz() {
-    let _ = env_logger::try_init();
     fn prop(fuzz: FuzzHpack) -> TestResult {
         fuzz.run();
         TestResult::from_bool(true)
     }
 
+    let _ = env_logger::try_init();
+
     QuickCheck::new()
         .tests(100)
-        .quickcheck(prop as fn(FuzzHpack) -> TestResult)
+        .quickcheck(prop as fn(FuzzHpack) -> TestResult);
 }
 
 /*
@@ -45,6 +46,7 @@ struct HeaderFrame {
 }
 
 impl FuzzHpack {
+    #[allow(clippy::cast_precision_loss)]
     fn new(seed: [u8; 32]) -> FuzzHpack {
         // Seed the RNG
         let mut rng = StdRng::from_seed(seed);
@@ -142,7 +144,7 @@ impl FuzzHpack {
                     }
                     Err(value) => {
                         expect.push(Header::Field {
-                            name: prev_name.as_ref().cloned().expect("previous header name"),
+                            name: prev_name.clone().expect("previous header name"),
                             value,
                         });
                     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -78,6 +78,7 @@
     clippy::pedantic
 )]
 #![allow(
+    clippy::clone_on_copy,
     clippy::cast_sign_loss,
     clippy::cast_possible_truncation,
     clippy::missing_fields_in_debug,
diff --git a/src/server/service.rs b/src/server/service.rs
@@ -137,8 +137,8 @@ impl<Pub, Ctl> Clone for ServerHandler<Pub, Ctl> {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
-            cfg: self.cfg,
-            shared: self.shared,
+            cfg: self.cfg.clone(),
+            shared: self.shared.clone(),
         }
     }
 }
@@ -159,16 +159,24 @@ where
             read_preface(&io).await?;
 
             // create publish service
-            let pub_srv = inner.publish.create(self.shared).await.map_err(|e| {
-                log::error!("Publish service init error: {e:?}");
-                ServerError::PublishServiceError
-            })?;
+            let pub_srv = inner
+                .publish
+                .create(self.shared.clone())
+                .await
+                .map_err(|e| {
+                    log::error!("Publish service init error: {e:?}");
+                    ServerError::PublishServiceError
+                })?;
 
             // create control service
-            let ctl_srv = inner.control.create(self.shared).await.map_err(|e| {
-                log::error!("Control service init error: {e:?}");
-                ServerError::ControlServiceError
-            })?;
+            let ctl_srv = inner
+                .control
+                .create(self.shared.clone())
+                .await
+                .map_err(|e| {
+                    log::error!("Control service init error: {e:?}");
+                    ServerError::ControlServiceError
+                })?;
 
             Ok::<_, ServerError<()>>((ctl_srv, pub_srv))
         })
@@ -181,7 +189,7 @@ where
             true,
             io.get_ref(),
             codec.clone(),
-            self.cfg,
+            self.cfg.clone(),
             true,
             false,
             self.inner.pool.clone(),

Original file line number	Diff line number	Diff line change
`@@ -990,17 +990,18 @@ mod tests {`
`990`	`990`
`991`	`991`	`const PREFACE: [u8; 24] = b"PRI HTTP/2.0\r\n\r\nSM\r\n\r\n";`
`992`	`992`
	`993`	`+ #[allow(clippy::needless_pass_by_value)]`
`993`	`994`	`fn get_reset(frm: frame::Frame) -> frame::Reset {`
`994`	`995`	`match frm {`
`995`	`996`	`frame::Frame::Reset(rst) => rst,`
`996`		`- _ => panic!("Expect Reset frame: {:?}", frm),`
	`997`	`+ _ => panic!("Expect Reset frame: {frm:?}"),`
`997`	`998`	`}`
`998`	`999`	`}`
`999`	`1000`
`1000`	`1001`	`fn goaway(frm: frame::Frame) -> frame::GoAway {`
`1001`	`1002`	`match frm {`
`1002`	`1003`	`frame::Frame::GoAway(f) => f,`
`1003`		`- _ => panic!("Expect Reset frame: {:?}", frm),`
	`1004`	`+ _ => panic!("Expect Reset frame: {frm:?}"),`
`1004`	`1005`	`}`
`1005`	`1006`	`}`
`1006`	`1007`