replace dep once_cell with std library equivalent lazylock/oncelock

Author: abd0-omar

Cargo.toml

@@ -37,7 +37,6 @@ derivative = "2.2.0"
 http = "1.0.0"
 log = "0.4"
 h2 = ">=0.4.11"
-once_cell = "1"
 lru = "0.14"
 ahash = ">=0.8.9"
 

docs/user_guide/rate_limiter.md

@@ -7,7 +7,6 @@ Pingora provides a crate `pingora-limits` which provides a simple and easy to us
    async-trait="0.1"
    pingora = { version = "0.3", features = [ "lb" ] }
    pingora-limits = "0.3.0"
-   once_cell = "1.19.0"
    ```
 2. Declare a global rate limiter map to store the rate limiter for each client. In this example, we use `appid`.
 3. Override the `request_filter` method in the `ProxyHttp` trait to implement rate limiting.
@@ -19,7 +18,7 @@ Pingora provides a crate `pingora-limits` which provides a simple and easy to us
 ## Example
 ```rust
 use async_trait::async_trait;
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 use pingora::http::ResponseHeader;
 use pingora::prelude::*;
 use pingora_limits::rate::Rate;
@@ -67,7 +66,7 @@ impl LB {
 }
 
 // Rate limiter
-static RATE_LIMITER: Lazy<Rate> = Lazy::new(|| Rate::new(Duration::from_secs(1)));
+static RATE_LIMITER: LazyLock<Rate> = LazyLock::new(|| Rate::new(Duration::from_secs(1)));
 
 // max request per second per client
 static MAX_REQ_PER_SEC: isize = 1;

pingora-cache/Cargo.toml

@@ -25,7 +25,6 @@ pingora-lru = { version = "0.6.0", path = "../pingora-lru" }
 pingora-timeout = { version = "0.6.0", path = "../pingora-timeout" }
 http = { workspace = true }
 indexmap = "1"
-once_cell = { workspace = true }
 regex = "1"
 blake2 = "0.10"
 serde = { version = "1.0", features = ["derive"] }

pingora-cache/src/cache_control.rs

@@ -19,12 +19,12 @@ use super::*;
 use http::header::HeaderName;
 use http::HeaderValue;
 use indexmap::IndexMap;
-use once_cell::sync::Lazy;
 use pingora_error::{Error, ErrorType};
 use regex::bytes::Regex;
 use std::num::IntErrorKind;
 use std::slice;
 use std::str;
+use std::sync::LazyLock;
 
 /// The max delta-second per [RFC 9111](https://datatracker.ietf.org/doc/html/rfc9111#section-1.2.2)
 // "If a cache receives a delta-seconds value
@@ -157,13 +157,13 @@ impl<'a> Iterator for ListValueIter<'a> {
 // note the `token` implementation excludes disallowed ASCII ranges
 // and disallowed delimiters: https://datatracker.ietf.org/doc/html/rfc9110#section-5.6.2
 // though it does not forbid `obs-text`: %x80-FF
-static RE_CACHE_DIRECTIVE: Lazy<Regex> =
+static RE_CACHE_DIRECTIVE: LazyLock<Regex> =
     // to break our version down further:
     // `(?-u)`: unicode support disabled, which puts the regex into "ASCII compatible mode" for specifying literal bytes like \x7F: https://docs.rs/regex/1.10.4/regex/bytes/index.html#syntax
     // `(?:^|(?:\s*[,;]\s*)`: allow either , or ; as a delimiter
     // `([^\x00-\x20\(\)<>@,;:\\"/\[\]\?=\{\}\x7F]+)`: token (directive name capture group)
     // `(?:=((?:[^\x00-\x20\(\)<>@,;:\\"/\[\]\?=\{\}\x7F]+|(?:"(?:[^"\\]|\\.)*"))))`: token OR quoted-string (directive value capture-group)
-    Lazy::new(|| {
+    LazyLock::new(|| {
         Regex::new(r#"(?-u)(?:^|(?:\s*[,;]\s*))([^\x00-\x20\(\)<>@,;:\\"/\[\]\?=\{\}\x7F]+)(?:=((?:[^\x00-\x20\(\)<>@,;:\\"/\[\]\?=\{\}\x7F]+|(?:"(?:[^"\\]|\\.)*"))))?"#).unwrap()
     });
 

pingora-cache/src/memory.rs

@@ -427,7 +427,7 @@ impl Storage for MemCache {
 mod test {
     use super::*;
     use cf_rustracing::span::Span;
-    use once_cell::sync::Lazy;
+    use std::sync::LazyLock;
 
     fn gen_meta() -> CacheMeta {
         let mut header = ResponseHeader::build(200, None).unwrap();
@@ -445,7 +445,7 @@ mod test {
 
     #[tokio::test]
     async fn test_write_then_read() {
-        static MEM_CACHE: Lazy<MemCache> = Lazy::new(MemCache::new);
+        static MEM_CACHE: LazyLock<MemCache> = LazyLock::new(MemCache::new);
         let span = &Span::inactive().handle();
 
         let key1 = CacheKey::new("", "a", "1");
@@ -482,7 +482,7 @@ mod test {
 
     #[tokio::test]
     async fn test_read_range() {
-        static MEM_CACHE: Lazy<MemCache> = Lazy::new(MemCache::new);
+        static MEM_CACHE: LazyLock<MemCache> = LazyLock::new(MemCache::new);
         let span = &Span::inactive().handle();
 
         let key1 = CacheKey::new("", "a", "1");
@@ -527,7 +527,7 @@ mod test {
     async fn test_write_while_read() {
         use futures::FutureExt;
 
-        static MEM_CACHE: Lazy<MemCache> = Lazy::new(MemCache::new);
+        static MEM_CACHE: LazyLock<MemCache> = LazyLock::new(MemCache::new);
         let span = &Span::inactive().handle();
 
         let key1 = CacheKey::new("", "a", "1");
@@ -594,7 +594,7 @@ mod test {
 
     #[tokio::test]
     async fn test_purge_partial() {
-        static MEM_CACHE: Lazy<MemCache> = Lazy::new(MemCache::new);
+        static MEM_CACHE: LazyLock<MemCache> = LazyLock::new(MemCache::new);
         let cache = &MEM_CACHE;
 
         let key = CacheKey::new("", "a", "1").to_compact();
@@ -621,7 +621,7 @@ mod test {
 
     #[tokio::test]
     async fn test_purge_complete() {
-        static MEM_CACHE: Lazy<MemCache> = Lazy::new(MemCache::new);
+        static MEM_CACHE: LazyLock<MemCache> = LazyLock::new(MemCache::new);
         let cache = &MEM_CACHE;
 
         let key = CacheKey::new("", "a", "1").to_compact();

pingora-cache/src/meta.rs

@@ -16,12 +16,12 @@
 
 pub use http::Extensions;
 use log::warn;
-use once_cell::sync::{Lazy, OnceCell};
 use pingora_error::{Error, ErrorType::*, OrErr, Result};
 use pingora_header_serde::HeaderSerde;
 use pingora_http::{HMap, ResponseHeader};
 use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
+use std::sync::{LazyLock, OnceLock};
 use std::time::{Duration, SystemTime};
 
 use crate::key::HashBinary;
@@ -568,9 +568,9 @@ impl CacheMetaDefaults {
 /// The dictionary content for header compression.
 ///
 /// Used during initialization of [`HEADER_SERDE`].
-static COMPRESSION_DICT_CONTENT: OnceCell<Cow<'static, [u8]>> = OnceCell::new();
+static COMPRESSION_DICT_CONTENT: OnceLock<Cow<'static, [u8]>> = OnceLock::new();
 
-static HEADER_SERDE: Lazy<HeaderSerde> = Lazy::new(|| {
+static HEADER_SERDE: LazyLock<HeaderSerde> = LazyLock::new(|| {
     let dict_opt = if let Some(dict_content) = COMPRESSION_DICT_CONTENT.get() {
         Some(dict_content.to_vec())
     } else {

pingora-cache/src/put.rs

@@ -215,7 +215,7 @@ impl<C: CachePut> CachePutCtx<C> {
 mod test {
     use super::*;
     use cf_rustracing::span::Span;
-    use once_cell::sync::Lazy;
+    use std::sync::LazyLock;
 
     struct TestCachePut();
     impl CachePut for TestCachePut {
@@ -227,7 +227,7 @@ mod test {
     }
 
     type TestCachePutCtx = CachePutCtx<TestCachePut>;
-    static CACHE_BACKEND: Lazy<MemCache> = Lazy::new(MemCache::new);
+    static CACHE_BACKEND: LazyLock<MemCache> = LazyLock::new(MemCache::new);
 
     #[tokio::test]
     async fn test_cache_put() {

pingora-core/Cargo.toml

@@ -38,7 +38,6 @@ log = { workspace = true }
 h2 = { workspace = true }
 derivative.workspace = true
 clap = { version = "3.2.25", features = ["derive"] }
-once_cell = { workspace = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_yaml = "0.8"
 strum = "0.26.2"

pingora-core/src/connectors/offload.rs

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 use log::debug;
-use once_cell::sync::OnceCell;
 use rand::Rng;
+use std::sync::OnceLock;
 use tokio::runtime::{Builder, Handle};
 use tokio::sync::oneshot::{channel, Sender};
 
@@ -25,7 +25,7 @@ pub(crate) struct OffloadRuntime {
     thread_per_shard: usize,
     // Lazily init the runtimes so that they are created after pingora
     // daemonize itself. Otherwise the runtime threads are lost.
-    pools: OnceCell<Box<[(Handle, Sender<()>)]>>,
+    pools: OnceLock<Box<[(Handle, Sender<()>)]>>,
 }
 
 impl OffloadRuntime {
@@ -35,7 +35,7 @@ impl OffloadRuntime {
         OffloadRuntime {
             shards,
             thread_per_shard,
-            pools: OnceCell::new(),
+            pools: OnceLock::new(),
         }
     }
 

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

@@ -26,13 +26,13 @@ pub mod grpc_web;
 use async_trait::async_trait;
 use bytes::Bytes;
 use http::HeaderMap;
-use once_cell::sync::OnceCell;
 use pingora_error::Result;
 use pingora_http::{RequestHeader, ResponseHeader};
 use std::any::Any;
 use std::any::TypeId;
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 /// The trait an HTTP traffic module needs to implement
 #[async_trait]
@@ -101,15 +101,15 @@ pub type ModuleBuilder = Box<dyn HttpModuleBuilder + 'static + Send + Sync>;
 /// The object to hold multiple http modules
 pub struct HttpModules {
     modules: Vec<ModuleBuilder>,
-    module_index: OnceCell<Arc<HashMap<TypeId, usize>>>,
+    module_index: OnceLock<Arc<HashMap<TypeId, usize>>>,
 }
 
 impl HttpModules {
     /// Create a new [HttpModules]
     pub fn new() -> Self {
         HttpModules {
             modules: vec![],
-            module_index: OnceCell::new(),
+            module_index: OnceLock::new(),
         }
     }