Remove the need for mut in some apis (#733)

Author: fafhrd91

Cargo.toml

@@ -42,10 +42,10 @@ ntex-macros = { path = "ntex-macros" }
 ntex-util = { path = "ntex-util" }
 
 [workspace.dependencies]
-ntex = "3.0.0-pre.15"
+ntex = "3.0.0"
 ntex-bytes = "1.4.1"
 ntex-codec = "1.1.0"
-ntex-io = "3.6.0"
+ntex-io = "3.7.0"
 ntex-dispatcher = "3.0.0"
 ntex-net = "3.5.2"
 ntex-http = "1.0.0"

ntex-io/CHANGES.md

@@ -1,6 +1,8 @@
 # Changes
 
-## [3.7.0] - 2026-01-xx
+## [3.7.0] - 2026-01-31
+
+* Fix BufferCfg::resize_min()
 
 * Drop Dispatcher
 

ntex-io/src/cfg.rs

@@ -1,4 +1,4 @@
-use std::{cell::UnsafeCell, cmp};
+use std::cell::UnsafeCell;
 
 use ntex_bytes::{BytesMut, buf::BufMut};
 use ntex_service::cfg::{CfgContext, Configuration};
@@ -263,12 +263,17 @@ impl BufConfig {
     #[inline]
     /// Resize buffer
     pub fn resize_min(&self, buf: &mut BytesMut, size: usize) {
-        if buf.remaining_mut() < cmp::min(self.low, size) {
-            let cap = buf.capacity();
-            let mut new_size = self.high;
-            while cap >= new_size && size >= new_size {
+        let mut avail = buf.remaining_mut();
+        println!("resize: {avail} -- {size}");
+        if avail < size {
+            avail += self.high;
+            let mut new_size = self.high + self.high;
+            println!("resize 2: {avail} -- {new_size}");
+            while avail < size {
+                avail += self.high;
                 new_size += self.high;
             }
+            println!("resize 3: {new_size}");
             buf.reserve_capacity(new_size);
         }
     }

ntex-tls/examples/webclient.rs

@@ -30,7 +30,7 @@ async fn main() -> Result<(), SendRequestError> {
         .unwrap();
 
     // Create request builder, configure request and send
-    let mut response = client
+    let response = client
         .get("https://127.0.0.1:8443/")
         .header("User-Agent", "ntex")
         .send()

ntex/CHANGES.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [3.0.0] 2026-02-xx
+
+* Remove the need for mut in h2::Payload
+
+* Remove the need for mut in ClientResponse::json() and ClientResponse::body()
+
 ## [3.0.0-pre.15] 2026-01-29
 
 * Use ntex_dispatcher::Dispatcher instead of ntex-io

ntex/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex"
-version = "3.0.0-pre.15"
+version = "3.0.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "Framework for composable network services"
 readme = "README.md"

ntex/examples/client.rs

@@ -7,7 +7,7 @@ async fn main() -> Result<(), SendRequestError> {
     let client = Client::new().await;
 
     // Create request builder, configure request and send
-    let mut response = client
+    let response = client
         .get("https://www.rust-lang.org/")
         .header("User-Agent", "ntex")
         .send()

ntex/src/client/h1proto.rs

@@ -54,7 +54,7 @@ where
     );
 
     // send request
-    let codec = h1::ClientCodec::default();
+    let codec = h1::ClientCodec::new(true, io.cfg());
     io.send((head, body.size()).into(), &codec).await?;
 
     log::trace!("http1 request has been sent");

ntex/src/client/h2proto.rs

@@ -129,7 +129,7 @@ async fn get_response(
                             stream.tag(),
                             stream.id()
                         );
-                        let (mut pl, payload) = H2Payload::create(stream.empty_capacity());
+                        let (pl, payload) = H2Payload::create(stream.empty_capacity());
 
                         let _ = crate::rt::spawn(async move {
                             loop {

ntex/src/client/response.rs

@@ -1,6 +1,6 @@
 use std::cell::{Ref, RefMut};
 use std::task::{Context, Poll};
-use std::{fmt, future::Future, marker::PhantomData, mem, pin::Pin, rc::Rc};
+use std::{cell::Cell, fmt, future::Future, marker::PhantomData, pin::Pin, rc::Rc};
 
 use serde::de::DeserializeOwned;
 
@@ -18,7 +18,7 @@ use super::{ClientConfig, error::JsonPayloadError};
 /// Client Response
 pub struct ClientResponse {
     pub(crate) head: ResponseHead,
-    pub(crate) payload: Payload,
+    pub(crate) payload: Cell<Option<Payload>>,
     config: Rc<ClientConfig>,
 }
 
@@ -63,8 +63,8 @@ impl ClientResponse {
     pub fn new(head: ResponseHead, payload: Payload, config: Rc<ClientConfig>) -> Self {
         ClientResponse {
             head,
-            payload,
             config,
+            payload: Cell::new(Some(payload)),
         }
     }
 
@@ -114,13 +114,17 @@ impl ClientResponse {
     }
 
     /// Set a body and return previous body value
-    pub fn set_payload(&mut self, payload: Payload) {
-        self.payload = payload;
+    pub fn set_payload(&self, payload: Payload) {
+        self.payload.set(Some(payload));
     }
 
     /// Get response's payload
-    pub fn take_payload(&mut self) -> Payload {
-        mem::take(&mut self.payload)
+    pub fn take_payload(&self) -> Payload {
+        if let Some(pl) = self.payload.take() {
+            pl
+        } else {
+            Payload::None
+        }
     }
 
     /// Request extensions
@@ -138,7 +142,7 @@ impl ClientResponse {
 
 impl ClientResponse {
     /// Loads http response's body.
-    pub fn body(&mut self) -> MessageBody {
+    pub fn body(&self) -> MessageBody {
         MessageBody::new(self)
     }
 
@@ -149,7 +153,7 @@ impl ClientResponse {
     ///
     /// * content type is not `application/json`
     /// * content length is greater than 256k
-    pub fn json<T: DeserializeOwned>(&mut self) -> JsonBody<T> {
+    pub fn json<T: DeserializeOwned>(&self) -> JsonBody<T> {
         JsonBody::new(self)
     }
 }
@@ -158,7 +162,13 @@ impl Stream for ClientResponse {
     type Item = Result<Bytes, PayloadError>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Pin::new(&mut self.get_mut().payload).poll_next(cx)
+        if let Some(mut pl) = self.payload.take() {
+            let result = Pin::new(&mut pl).poll_next(cx);
+            self.payload.set(Some(pl));
+            result
+        } else {
+            Poll::Ready(None)
+        }
     }
 }
 
@@ -183,7 +193,7 @@ pub struct MessageBody {
 
 impl MessageBody {
     /// Create `MessageBody` for request.
-    pub fn new(res: &mut ClientResponse) -> MessageBody {
+    pub fn new(res: &ClientResponse) -> MessageBody {
         let mut len = None;
         if let Some(l) = res.headers().get(&CONTENT_LENGTH) {
             if let Ok(s) = l.to_str() {
@@ -276,7 +286,7 @@ where
     U: DeserializeOwned,
 {
     /// Create `JsonBody` for request.
-    pub fn new(res: &mut ClientResponse) -> Self {
+    pub fn new(res: &ClientResponse) -> Self {
         // check content-type
         let json = if let Ok(Some(mime)) = res.mime_type() {
             mime.subtype() == mime::JSON || mime.suffix() == Some(mime::JSON)
@@ -423,24 +433,24 @@ mod tests {
 
     #[crate::rt_test]
     async fn test_body() {
-        let mut req = TestResponse::with_header(header::CONTENT_LENGTH, "xxxx").finish();
+        let req = TestResponse::with_header(header::CONTENT_LENGTH, "xxxx").finish();
         match req.body().await.err().unwrap() {
             PayloadError::UnknownLength => (),
             _ => unreachable!("error"),
         }
 
-        let mut req = TestResponse::with_header(header::CONTENT_LENGTH, "1000000").finish();
+        let req = TestResponse::with_header(header::CONTENT_LENGTH, "1000000").finish();
         match req.body().await.err().unwrap() {
             PayloadError::Overflow => (),
             _ => unreachable!("error"),
         }
 
-        let mut req = TestResponse::default()
+        let req = TestResponse::default()
             .set_payload(Bytes::from_static(b"test"))
             .finish();
         assert_eq!(req.body().await.ok().unwrap(), Bytes::from_static(b"test"));
 
-        let mut req = TestResponse::default()
+        let req = TestResponse::default()
             .set_payload(Bytes::from_static(b"11111111111111"))
             .finish();
         match req.body().limit(5).await.err().unwrap() {
@@ -466,20 +476,20 @@ mod tests {
 
     #[crate::rt_test]
     async fn test_json_body() {
-        let mut req = TestResponse::default().finish();
-        let json = JsonBody::<MyObject>::new(&mut req).await;
+        let req = TestResponse::default().finish();
+        let json = JsonBody::<MyObject>::new(&req).await;
         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
 
-        let mut req = TestResponse::default()
+        let req = TestResponse::default()
             .header(
                 header::CONTENT_TYPE,
                 header::HeaderValue::from_static("application/text"),
             )
             .finish();
-        let json = JsonBody::<MyObject>::new(&mut req).await;
+        let json = JsonBody::<MyObject>::new(&req).await;
         assert!(json_eq(json.err().unwrap(), JsonPayloadError::ContentType));
 
-        let mut req = TestResponse::default()
+        let req = TestResponse::default()
             .header(
                 header::CONTENT_TYPE,
                 header::HeaderValue::from_static("application/json"),
@@ -490,13 +500,13 @@ mod tests {
             )
             .finish();
 
-        let json = JsonBody::<MyObject>::new(&mut req).limit(100).await;
+        let json = JsonBody::<MyObject>::new(&req).limit(100).await;
         assert!(json_eq(
             json.err().unwrap(),
             JsonPayloadError::Payload(PayloadError::Overflow)
         ));
 
-        let mut req = TestResponse::default()
+        let req = TestResponse::default()
             .header(
                 header::CONTENT_TYPE,
                 header::HeaderValue::from_static("application/json"),
@@ -508,7 +518,7 @@ mod tests {
             .set_payload(Bytes::from_static(b"{\"name\": \"test\"}"))
             .finish();
 
-        let json = JsonBody::<MyObject>::new(&mut req).await;
+        let json = JsonBody::<MyObject>::new(&req).await;
         assert_eq!(
             json.ok().unwrap(),
             MyObject {