move off once_cell

mhils · mhils · commit 56974fd3a7e8 · 2025-04-08T09:15:00.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -57,7 +57,6 @@ publish.workspace = true
 [dependencies]
 anyhow = { version = "1.0.97", features = ["backtrace"] }
 log = "0.4.27"
-once_cell = "1"
 pretty-hex = "0.4.1"
 smoltcp = "0.12"
 tokio = { version = "1.44.1", features = ["macros", "net", "rt-multi-thread", "sync", "time", "io-util", "process"] }
diff --git a/mitmproxy-contentviews/src/grpc.rs b/mitmproxy-contentviews/src/grpc.rs
@@ -1,6 +1,6 @@
 use crate::{Metadata, Prettify, Protobuf, Reencode};
-use mitmproxy_highlight::Language;
 use anyhow::{bail, Context, Result};
+use mitmproxy_highlight::Language;
 use serde::Deserialize;
 use serde_yaml::Value;
 
diff --git a/mitmproxy-contentviews/src/lib.rs b/mitmproxy-contentviews/src/lib.rs
@@ -6,10 +6,10 @@ mod protobuf;
 
 use anyhow::Result;
 
-use mitmproxy_highlight::Language;
 pub use grpc::GRPC;
 pub use hex_dump::HexDump;
 pub use hex_stream::HexStream;
+use mitmproxy_highlight::Language;
 pub use msgpack::MsgPack;
 pub use protobuf::Protobuf;
 
diff --git a/mitmproxy-contentviews/src/msgpack.rs b/mitmproxy-contentviews/src/msgpack.rs
@@ -1,6 +1,6 @@
 use super::{Metadata, Prettify, Reencode};
-use mitmproxy_highlight::Language;
 use anyhow::{Context, Result};
+use mitmproxy_highlight::Language;
 use rmp_serde::{decode, encode};
 
 pub struct MsgPack;
diff --git a/mitmproxy-contentviews/src/protobuf.rs b/mitmproxy-contentviews/src/protobuf.rs
@@ -1,6 +1,6 @@
 use crate::{Metadata, Prettify, Reencode};
-use mitmproxy_highlight::Language;
 use anyhow::{bail, Context, Result};
+use mitmproxy_highlight::Language;
 use protobuf::descriptor::field_descriptor_proto::Label::LABEL_REPEATED;
 use protobuf::descriptor::field_descriptor_proto::Type;
 use protobuf::descriptor::field_descriptor_proto::Type::{
@@ -24,9 +24,9 @@ use std::ops::Deref;
 use std::str::FromStr;
 
 mod tags {
-    use std::sync::LazyLock;
     use regex::Regex;
     use serde_yaml::value::Tag;
+    use std::sync::LazyLock;
 
     pub(super) static BINARY: LazyLock<Tag> = LazyLock::new(|| Tag::new("binary"));
     pub(super) static VARINT: LazyLock<Tag> = LazyLock::new(|| Tag::new("varint"));
diff --git a/mitmproxy-highlight/benches/syntax_highlight.rs b/mitmproxy-highlight/benches/syntax_highlight.rs
@@ -25,11 +25,7 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let data = "<a>x".repeat(8096);
     c.bench_function("syntax_highlight xml", |b| {
-        b.iter(|| {
-            Language::Xml
-                .highlight(black_box(data.as_bytes()))
-                .unwrap()
-        })
+        b.iter(|| Language::Xml.highlight(black_box(data.as_bytes())).unwrap())
     });
 
     // tree_sitter_html is faster, but not by orders of magnitude.
diff --git a/mitmproxy-rs/Cargo.toml b/mitmproxy-rs/Cargo.toml
@@ -22,7 +22,6 @@ mitmproxy-contentviews = { path = "../mitmproxy-contentviews" }
 anyhow = { version = "1.0.97", features = ["backtrace"] }
 data-encoding = "2.8.0"
 log = "0.4.27"
-once_cell = "1"
 pyo3 = { version = "0.24", features = ["abi3", "abi3-py312", "anyhow"] }
 pyo3-async-runtimes = { version = "0.24", features = ["tokio-runtime", "testing", "attributes"] }
 pyo3-log = "0.12"
diff --git a/mitmproxy-rs/src/dns_resolver.rs b/mitmproxy-rs/src/dns_resolver.rs
@@ -1,8 +1,8 @@
 use mitmproxy::dns::{ResolveError, DNS_SERVERS};
-use once_cell::sync::OnceCell;
 use pyo3::exceptions::socket::gaierror;
 use pyo3::prelude::*;
 use pyo3::types::PyAny;
+use std::sync::OnceLock;
 use std::{net::IpAddr, net::SocketAddr, sync::Arc};
 
 /// A DNS resolver backed by [hickory-dns](https://github.com/hickory-dns/hickory-dns).
@@ -78,10 +78,10 @@ pub fn get_system_dns_servers() -> PyResult<Vec<String>> {
     })
 }
 
-struct AddrInfoErrorConst(&'static str, OnceCell<isize>);
+struct AddrInfoErrorConst(&'static str, OnceLock<isize>);
 impl AddrInfoErrorConst {
     const fn new(identifier: &'static str) -> Self {
-        AddrInfoErrorConst(identifier, OnceCell::new())
+        AddrInfoErrorConst(identifier, OnceLock::new())
     }
     fn get(&self) -> isize {
         *self.1.get_or_init(|| {
diff --git a/mitmproxy-rs/src/lib.rs b/mitmproxy-rs/src/lib.rs
@@ -1,10 +1,9 @@
 extern crate core;
 
-use std::sync::RwLock;
+use std::sync::{LazyLock, Mutex};
 
 use crate::contentview::{Contentview, InteractiveContentview};
 use mitmproxy_contentviews::{Prettify, Reencode};
-use once_cell::sync::Lazy;
 use pyo3::{exceptions::PyException, prelude::*};
 
 mod contentview;
@@ -17,15 +16,15 @@ pub mod task;
 mod udp_client;
 mod util;
 
-static LOGGER_INITIALIZED: Lazy<RwLock<bool>> = Lazy::new(|| RwLock::new(false));
+static LOGGER_INITIALIZED: LazyLock<Mutex<bool>> = LazyLock::new(|| Mutex::new(false));
 
 fn init_logger() -> PyResult<()> {
-    if *LOGGER_INITIALIZED.read().unwrap() {
+    if *LOGGER_INITIALIZED.lock().unwrap() {
         // logger already initialized
         Ok(())
     } else if pyo3_log::try_init().is_ok() {
         // logger successfully initialized
-        *LOGGER_INITIALIZED.write().unwrap() = true;
+        *LOGGER_INITIALIZED.lock().unwrap() = true;
         Ok(())
     } else {
         // logger was not initialized and could not be initialized
diff --git a/src/dns.rs b/src/dns.rs
@@ -1,21 +1,20 @@
-use hickory_resolver::config::{LookupIpStrategy, ResolveHosts};
-use hickory_resolver::lookup_ip::LookupIp;
-use hickory_resolver::system_conf::read_system_conf;
-use hickory_resolver::TokioResolver;
-use once_cell::sync::Lazy;
-use std::net::IpAddr;
-use std::net::SocketAddr;
-
 use hickory_resolver::config::NameServerConfig;
 use hickory_resolver::config::ResolverConfig;
+use hickory_resolver::config::{LookupIpStrategy, ResolveHosts};
+use hickory_resolver::lookup_ip::LookupIp;
 use hickory_resolver::name_server::TokioConnectionProvider;
 pub use hickory_resolver::proto::op::Query;
 pub use hickory_resolver::proto::op::ResponseCode;
 use hickory_resolver::proto::xfer::Protocol;
 use hickory_resolver::proto::ProtoError;
+use hickory_resolver::system_conf::read_system_conf;
 pub use hickory_resolver::ResolveError;
+use hickory_resolver::TokioResolver;
+use std::net::IpAddr;
+use std::net::SocketAddr;
+use std::sync::LazyLock;
 
-pub static DNS_SERVERS: Lazy<Result<Vec<String>, ResolveError>> = Lazy::new(|| {
+pub static DNS_SERVERS: LazyLock<Result<Vec<String>, ResolveError>> = LazyLock::new(|| {
     let (config, _opts) = read_system_conf()?;
     Ok(config
         .name_servers()
diff --git a/src/processes/mod.rs b/src/processes/mod.rs
@@ -1,5 +1,6 @@
 pub use image;
 use std::path::PathBuf;
+use std::sync::LazyLock;
 
 #[cfg(any(target_os = "linux", target_os = "macos"))]
 mod nix_list;
@@ -34,8 +35,8 @@ pub struct ProcessInfo {
 pub type ProcessList = Vec<ProcessInfo>;
 
 #[cfg(any(windows, target_os = "macos"))]
-pub static ICON_CACHE: once_cell::sync::Lazy<std::sync::Mutex<IconCache>> =
-    once_cell::sync::Lazy::new(|| std::sync::Mutex::new(IconCache::default()));
+pub static ICON_CACHE: LazyLock<std::sync::Mutex<IconCache>> =
+    LazyLock::new(|| std::sync::Mutex::new(IconCache::default()));
 
 pub mod bench {
     #[cfg(target_os = "macos")]
diff --git a/src/processes/windows_list.rs b/src/processes/windows_list.rs
@@ -5,10 +5,9 @@ use std::iter;
 use std::mem::size_of;
 use std::os::windows::prelude::{OsStrExt, OsStringExt};
 use std::path::{Path, PathBuf};
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 use anyhow::{anyhow, Result};
-use once_cell::sync::Lazy;
 use windows::core::w;
 use windows::core::{BOOL, PCWSTR, PWSTR};
 use windows::Win32::Foundation::{CloseHandle, HANDLE, HWND, LPARAM, MAX_PATH};
@@ -85,8 +84,8 @@ pub fn enumerate_pids() -> Result<Vec<PID>> {
     Ok(pids)
 }
 
-pub static DISPLAY_NAME_CACHE: Lazy<Mutex<DisplayNameCache>> =
-    Lazy::new(|| Mutex::new(DisplayNameCache::default()));
+pub static DISPLAY_NAME_CACHE: LazyLock<Mutex<DisplayNameCache>> =
+    LazyLock::new(|| Mutex::new(DisplayNameCache::default()));
 
 #[derive(Default)]
 pub struct DisplayNameCache(HashMap<PathBuf, Result<String>>);
