Rust 1.84

Author: eaufavor

.bleep

@@ -1 +1 @@
-e7df08c79f6333db2821028ef00eb65ea6152a48
+68e54ed85ef028f1813154c46a67a2ebeb5c46ff

pingora-cache/src/eviction/lru.rs

@@ -93,7 +93,7 @@ struct InsertToManager<'a, const N: usize> {
     lru: &'a Manager<N>,
 }
 
-impl<'de, 'a, const N: usize> serde::de::Visitor<'de> for InsertToManager<'a, N> {
+impl<'de, const N: usize> serde::de::Visitor<'de> for InsertToManager<'_, N> {
     type Value = ();
 
     fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {

pingora-cache/src/eviction/simple_lru.rs

@@ -142,7 +142,7 @@ struct InsertToManager<'a> {
     lru: &'a Manager,
 }
 
-impl<'de, 'a> serde::de::Visitor<'de> for InsertToManager<'a> {
+impl<'de> serde::de::Visitor<'de> for InsertToManager<'_> {
     type Value = ();
 
     fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {

pingora-cache/src/filters.rs

@@ -96,7 +96,7 @@ pub fn calculate_fresh_until(
 
     let uncacheable = cache_control
         .as_ref()
-        .map_or(false, |cc| cc.is_cacheable() == Cacheable::No);
+        .is_some_and(|cc| cc.is_cacheable() == Cacheable::No);
     if uncacheable {
         return None;
     }

pingora-cache/src/predictor.rs

@@ -124,7 +124,7 @@ where
                 return None;
             }
             // Skip certain NoCacheReason::Custom according to user
-            Custom(reason) if self.skip_custom_reasons_fn.map_or(false, |f| f(reason)) => {
+            Custom(reason) if self.skip_custom_reasons_fn.is_some_and(|f| f(reason)) => {
                 return None;
             }
             Custom(_) | OriginNotCache | ResponseTooLarge => { /* mark uncacheable for these only */

pingora-core/src/connectors/http/mod.rs

@@ -61,7 +61,7 @@ impl Connector {
             }
             let h2_only = peer
                 .get_peer_options()
-                .map_or(false, |o| o.alpn.get_min_http_version() == 2)
+                .is_some_and(|o| o.alpn.get_min_http_version() == 2)
                 && !self.h2.h1_is_preferred(peer);
             if !h2_only {
                 // We next check the reuse pool for h1 before creating a new h2 connection.

pingora-core/src/connectors/http/v2.rs

@@ -376,7 +376,7 @@ impl Connector {
         self.transport
             .preferred_http_version
             .get(peer)
-            .map_or(false, |v| matches!(v, ALPN::H1))
+            .is_some_and(|v| matches!(v, ALPN::H1))
     }
 }
 

pingora-core/src/protocols/http/v1/common.rs

@@ -156,7 +156,7 @@ pub(super) fn is_upgrade_req(req: &RequestHeader) -> bool {
 pub(super) fn is_expect_continue_req(req: &RequestHeader) -> bool {
     req.version == http::Version::HTTP_11
         // https://www.rfc-editor.org/rfc/rfc9110#section-10.1.1
-        && req.headers.get(header::EXPECT).map_or(false, |v| {
+        && req.headers.get(header::EXPECT).is_some_and(|v| {
             v.as_bytes().eq_ignore_ascii_case(b"100-continue")
         })
 }
@@ -234,7 +234,7 @@ pub(super) fn populate_headers(
         if !header.name.is_empty() {
             header_ref.push(KVRef::new(
                 header.name.as_ptr() as usize - base,
-                header.name.as_bytes().len(),
+                header.name.len(),
                 header.value.as_ptr() as usize - base,
                 header.value.len(),
             ));

pingora-core/src/protocols/http/v2/client.rs

@@ -230,7 +230,7 @@ impl Http2Session {
         // if response_body_reader doesn't exist, the response is not even read yet
         self.response_body_reader
             .as_ref()
-            .map_or(false, |reader| reader.is_end_stream())
+            .is_some_and(|reader| reader.is_end_stream())
     }
 
     /// Check whether stream finished with error.
@@ -396,7 +396,7 @@ impl Http2Session {
             if let Some(err) = e.root_cause().downcast_ref::<h2::Error>() {
                 if err.is_go_away()
                     && err.is_remote()
-                    && err.reason().map_or(false, |r| r == h2::Reason::NO_ERROR)
+                    && (err.reason() == Some(h2::Reason::NO_ERROR))
                 {
                     e.retry = true.into();
                 }
@@ -416,26 +416,16 @@ impl Http2Session {
  5. All other errors will terminate the request
 */
 fn handle_read_header_error(e: h2::Error) -> Box<Error> {
-    if e.is_remote()
-        && e.reason()
-            .map_or(false, |r| r == h2::Reason::HTTP_1_1_REQUIRED)
-    {
+    if e.is_remote() && (e.reason() == Some(h2::Reason::HTTP_1_1_REQUIRED)) {
         let mut err = Error::because(H2Downgrade, "while reading h2 header", e);
         err.retry = true.into();
         err
-    } else if e.is_go_away()
-        && e.is_library()
-        && e.reason()
-            .map_or(false, |r| r == h2::Reason::PROTOCOL_ERROR)
-    {
+    } else if e.is_go_away() && e.is_library() && (e.reason() == Some(h2::Reason::PROTOCOL_ERROR)) {
         // remote send invalid H2 responses
         let mut err = Error::because(InvalidH2, "while reading h2 header", e);
         err.retry = true.into();
         err
-    } else if e.is_go_away()
-        && e.is_remote()
-        && e.reason().map_or(false, |r| r == h2::Reason::NO_ERROR)
-    {
+    } else if e.is_go_away() && e.is_remote() && (e.reason() == Some(h2::Reason::NO_ERROR)) {
         // is_go_away: retry via another connection, this connection is being teardown
         let mut err = Error::because(H2Error, "while reading h2 header", e);
         err.retry = true.into();

pingora-core/src/protocols/http/v2/server.rs

@@ -67,7 +67,7 @@ use std::pin::Pin;
 /// Calling `.await` in this object will not return until the client decides to close this stream.
 pub struct Idle<'a>(&'a mut HttpSession);
 
-impl<'a> Future for Idle<'a> {
+impl Future for Idle<'_> {
     type Output = Result<h2::Reason>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
@@ -398,7 +398,7 @@ impl HttpSession {
                     .request_header
                     .headers
                     .get(header::CONTENT_LENGTH)
-                    .map_or(false, |cl| cl.as_bytes() == b"0"))
+                    .is_some_and(|cl| cl.as_bytes() == b"0"))
     }
 
     pub fn retry_buffer_truncated(&self) -> bool {

pingora-core/src/protocols/l4/ext.rs

@@ -447,7 +447,7 @@ pub(crate) async fn connect_with<F: FnOnce(&TcpSocket) -> Result<()> + Clone>(
     bind_to: Option<&BindTo>,
     set_socket: F,
 ) -> Result<TcpStream> {
-    if bind_to.as_ref().map_or(false, |b| b.will_fallback()) {
+    if bind_to.as_ref().is_some_and(|b| b.will_fallback()) {
         // if we see an EADDRNOTAVAIL error clear the port range and try again
         let connect_result = inner_connect_with(addr, bind_to, set_socket.clone()).await;
         if let Err(e) = connect_result.as_ref() {

pingora-core/src/server/mod.rs

@@ -359,14 +359,14 @@ impl Server {
         #[cfg(all(not(debug_assertions), feature = "sentry"))]
         let _guard = self.sentry.as_ref().map(|opts| sentry::init(opts.clone()));
 
-        if self.options.as_ref().map_or(false, |o| o.test) {
+        if self.options.as_ref().is_some_and(|o| o.test) {
             info!("Server Test passed, exiting");
             std::process::exit(0);
         }
 
         // load fds
         #[cfg(unix)]
-        match self.load_fds(self.options.as_ref().map_or(false, |o| o.upgrade)) {
+        match self.load_fds(self.options.as_ref().is_some_and(|o| o.upgrade)) {
             Ok(_) => {
                 info!("Bootstrap done");
             }

pingora-ketama/examples/health_aware_selector.rs

@@ -31,7 +31,7 @@ struct HealthAwareNodeSelector<'a> {
     node_health_repo: &'a NodeHealthRepository,
 }
 
-impl<'a> HealthAwareNodeSelector<'a> {
+impl HealthAwareNodeSelector<'_> {
     fn new(r: Continuum, tries: usize, nhr: &NodeHealthRepository) -> HealthAwareNodeSelector {
         HealthAwareNodeSelector {
             ring: r,

pingora-load-balancing/src/lib.rs

@@ -322,7 +322,7 @@ pub struct LoadBalancer<S> {
     pub parallel_health_check: bool,
 }
 
-impl<'a, S: BackendSelection> LoadBalancer<S>
+impl<S: BackendSelection> LoadBalancer<S>
 where
     S: BackendSelection + 'static,
     S::Iter: BackendIter,

pingora-lru/src/lib.rs

@@ -366,7 +366,7 @@ impl<'a, T> Iterator for LruUnitIter<'a, T> {
     }
 }
 
-impl<'a, T> DoubleEndedIterator for LruUnitIter<'a, T> {
+impl<T> DoubleEndedIterator for LruUnitIter<'_, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.iter.next_back().map(|key| {
             // safe because we always items in table and list are always 1:1

pingora-lru/src/linked_list.rs

@@ -339,7 +339,7 @@ impl<'a> Iterator for LinkedListIter<'a> {
     }
 }
 
-impl<'a> DoubleEndedIterator for LinkedListIter<'a> {
+impl DoubleEndedIterator for LinkedListIter<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         let prev_index = self.list.prev(self.tail);
         if prev_index == HEAD || prev_index == NULL {

pingora-proxy/examples/grpc_web_module.rs

@@ -27,7 +27,7 @@ use pingora_core::{
 };
 use pingora_proxy::{ProxyHttp, Session};
 
-/// This example shows how to use the gRPC-web bridge module
+// This example shows how to use the gRPC-web bridge module
 
 pub struct GrpcWebBridgeProxy;
 

pingora-proxy/examples/use_module.rs

@@ -23,7 +23,7 @@ use pingora_core::Result;
 use pingora_http::RequestHeader;
 use pingora_proxy::{ProxyHttp, Session};
 
-/// This example shows how to build and import 3rd party modules
+// This example shows how to build and import 3rd party modules
 
 /// A simple ACL to check "Authorization: basic $credential" header
 mod my_acl {

pingora-proxy/src/proxy_h1.rs

@@ -574,7 +574,7 @@ impl<SV> HttpProxy<SV> {
          * output anything yet.
          * Don't write 0 bytes to the network since it will be
          * treated as the terminating chunk */
-        if !upstream_end_of_body && data.as_ref().map_or(false, |d| d.is_empty()) {
+        if !upstream_end_of_body && data.as_ref().is_some_and(|d| d.is_empty()) {
             return Ok(false);
         }
 

pingora-proxy/src/proxy_h2.rs

@@ -542,7 +542,7 @@ impl<SV> HttpProxy<SV> {
         /* it is normal to get 0 bytes because of multi-chunk parsing or request_body_filter.
          * Although there is no harm writing empty byte to h2, unlike h1, we ignore it
          * for consistency */
-        if !end_of_body && data.as_ref().map_or(false, |d| d.is_empty()) {
+        if !end_of_body && data.as_ref().is_some_and(|d| d.is_empty()) {
             return Ok(false);
         }
 

pingora-proxy/src/proxy_trait.rs

@@ -453,7 +453,7 @@ pub trait ProxyHttp {
         // it is disconnected
         // or doing so is explicitly permitted by the client or origin server
         // (e.g. headers or an out-of-band contract)
-        error.map_or(false, |e| e.esource() == &ErrorSource::Upstream)
+        error.is_some_and(|e| e.esource() == &ErrorSource::Upstream)
     }
 
     /// This filter is called when the request just established or reused a connection to the upstream

pingora-proxy/tests/utils/mock_origin.rs

@@ -46,7 +46,8 @@ fn init() -> bool {
     process::Command::new("pkill")
         .args(["-F", "/tmp/pingora_mock_origin.pid"])
         .spawn()
-        .unwrap();
+        .unwrap()
+        .wait();
     let _origin = thread::spawn(|| {
         process::Command::new("openresty")
             .args(["-p", &format!("{}/origin", super::conf_dir())])