clippy: Disallow lock and instant types from std

.clippy.toml

@@ -6,16 +6,17 @@ disallowed-methods = [
     "std::env::set_var",
     "std::env::remove_var",
 
-    # Use parking_lot instead.
-    "std::sync::Mutex",
-    "std::sync::RwLock",
-
-    # Use tokio::time::Instant instead.
-    "std::time::Instant::now",
-
     # Avoid instances of https://github.com/rust-lang/rust/issues/86470 until tokio/tokio#4461 is
     # available.
     "tokio::time::Instant::duration_since",
     "tokio::time::Instant::elapsed",
     # Clippy doesn't let us ban tokio::time::Instant::sub, but it knows what it did.
 ]
+disallowed-types = [
+    # Use parking_lot instead.
+    "std::sync::Mutex",
+    "std::sync::RwLock",
+
+    # Use tokio::time::Instant instead.
+    "std::time::Instant",
+]

linkerd/app/admin/src/server.rs

@@ -201,7 +201,7 @@ where
 mod tests {
     use super::*;
     use http::method::Method;
-    use tokio::time::Duration;
+    use std::time::Duration;
     use tokio::{sync::mpsc, time::timeout};
     use tower::util::ServiceExt;
 

linkerd/app/core/src/config.rs

@@ -4,7 +4,7 @@ use crate::{
     svc::{stack::CloneParam, Param},
     transport::{Keepalive, ListenAddr},
 };
-use tokio::time::Duration;
+use std::time::Duration;
 
 #[derive(Clone, Debug)]
 pub struct ServerConfig {

linkerd/app/core/src/control.rs

@@ -221,7 +221,7 @@ mod resolve {
 
 mod balance {
     use crate::proxy::http;
-    use tokio::time::Duration;
+    use std::time::Duration;
 
     const EWMA_DEFAULT_RTT: Duration = Duration::from_millis(30);
     const EWMA_DECAY: Duration = Duration::from_secs(10);

linkerd/app/core/src/dns.rs

@@ -1,6 +1,6 @@
 pub use linkerd_dns::*;
 use std::path::PathBuf;
-use tokio::time::Duration;
+use std::time::Duration;
 
 #[derive(Clone, Debug)]
 pub struct Config {

linkerd/app/core/src/errors.rs

@@ -8,7 +8,7 @@ pub use tonic::Code as Grpc;
 
 #[derive(Debug, Error)]
 #[error("connect timed out after {0:?}")]
-pub struct ConnectTimeout(pub(crate) tokio::time::Duration);
+pub struct ConnectTimeout(pub(crate) std::time::Duration);
 
 /// Obtain the source error at the end of a chain of `Error`s.
 pub fn root_cause<'e>(

linkerd/app/core/src/transport.rs

@@ -11,7 +11,7 @@ pub use self::allow_ips::AllowIps;
 pub struct Metrics(metrics::Registry<labels::Key>);
 
 impl Metrics {
-    pub fn new(retain_idle: tokio::time::Duration) -> (Self, metrics::Report<labels::Key>) {
+    pub fn new(retain_idle: std::time::Duration) -> (Self, metrics::Report<labels::Key>) {
         let (reg, report) = metrics::new(retain_idle);
         (Self(reg), report)
     }

linkerd/app/inbound/src/detect.rs

@@ -504,7 +504,7 @@ mod tests {
                 negotiated_protocol: None,
             }),
             policy: allow(Protocol::Detect {
-                timeout: tokio::time::Duration::from_secs(10),
+                timeout: std::time::Duration::from_secs(10),
             }),
         };
 
@@ -533,7 +533,7 @@ mod tests {
                 negotiated_protocol: None,
             }),
             policy: allow(Protocol::Detect {
-                timeout: tokio::time::Duration::from_secs(10),
+                timeout: std::time::Duration::from_secs(10),
             }),
         };
 

linkerd/app/inbound/src/http/tests.rs

@@ -513,7 +513,7 @@ fn connect_timeout(
         Box::pin(
             async move {
                 tracing::info!("sleeping so that the proxy hits a connect timeout");
-                tokio::time::sleep(tokio::time::Duration::from_secs(3)).await;
+                tokio::time::sleep(std::time::Duration::from_secs(3)).await;
                 // The proxy hits a connect timeout so we don't need to worry
                 // about returning a service here.
                 unreachable!();

linkerd/app/inbound/src/policy/defaults.rs

@@ -1,6 +1,6 @@
 use linkerd_app_core::{IpNet, Ipv4Net, Ipv6Net};
 use linkerd_server_policy::{Authentication, Authorization, Protocol, ServerPolicy, Suffix};
-use tokio::time::Duration;
+use std::time::Duration;
 
 pub fn all_authenticated(timeout: Duration) -> ServerPolicy {
     mk(

linkerd/app/inbound/src/test_util.rs

@@ -15,7 +15,7 @@ use linkerd_app_core::{
 };
 pub use linkerd_app_test as support;
 use linkerd_server_policy::{Authentication, Authorization, Protocol, ServerPolicy};
-use tokio::time::Duration;
+use std::time::Duration;
 
 pub fn default_config() -> Config {
     let cluster_local = "svc.cluster.local."
@@ -53,7 +53,7 @@ pub fn default_config() -> Config {
         policy: policy::Config::Fixed {
             default: ServerPolicy {
                 protocol: Protocol::Detect {
-                    timeout: tokio::time::Duration::from_secs(10),
+                    timeout: std::time::Duration::from_secs(10),
                 },
                 authorizations: vec![Authorization {
                     authentication: Authentication::Unauthenticated,
@@ -73,7 +73,7 @@ pub fn default_config() -> Config {
 pub fn runtime() -> (ProxyRuntime, drain::Signal) {
     let (drain_tx, drain) = drain::channel();
     let (tap, _) = tap::new();
-    let (metrics, _) = metrics::Metrics::new(tokio::time::Duration::from_secs(10));
+    let (metrics, _) = metrics::Metrics::new(std::time::Duration::from_secs(10));
     let runtime = ProxyRuntime {
         identity: rustls::creds::default_for_test().1.into(),
         metrics: metrics.proxy,

linkerd/app/integration/src/lib.rs

@@ -30,10 +30,10 @@ pub use std::net::SocketAddr;
 use std::pin::Pin;
 pub use std::sync::Arc;
 use std::task::{Context, Poll};
+pub use std::time::Duration;
 pub use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 use tokio::net::TcpListener;
 pub use tokio::sync::oneshot;
-pub use tokio::time::Duration;
 pub use tonic as grpc;
 pub use tower::Service;
 pub use tracing::*;

linkerd/app/integration/src/tests/profile_dst_overrides.rs

@@ -61,7 +61,7 @@ async fn wait_for_profile_stage(client: &client::Client, metrics: &client::Clien
             break;
         }
 
-        tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+        tokio::time::sleep(std::time::Duration::from_millis(200)).await;
     }
 }
 

linkerd/app/integration/src/tests/profiles.rs

@@ -129,7 +129,7 @@ macro_rules! profile_test {
                 break;
             }
 
-            tokio::time::sleep(tokio::time::Duration::from_millis(200)).await;
+            tokio::time::sleep(std::time::Duration::from_millis(200)).await;
         }
 
         $with_client(client).await;

linkerd/app/integration/src/tests/transparency.rs

@@ -1367,7 +1367,7 @@ async fn retry_reconnect_errors() {
 
     drop(tx); // start `listen` now
               // This may be flaky on CI.
-    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
 
     let res = fut.await.expect("response");
     assert_eq!(res.status(), http::StatusCode::OK);

linkerd/app/outbound/src/resolve.rs

@@ -5,7 +5,7 @@ use linkerd_app_core::{
     },
     svc::{layer, NewService},
 };
-use tokio::time::Duration;
+use std::time::Duration;
 
 pub fn layer<T, R, N>(
     resolve: R,

linkerd/app/outbound/src/test_util.rs

@@ -51,7 +51,7 @@ pub(crate) fn default_config() -> Config {
 pub(crate) fn runtime() -> (ProxyRuntime, drain::Signal) {
     let (drain_tx, drain) = drain::channel();
     let (tap, _) = tap::new();
-    let (metrics, _) = metrics::Metrics::new(tokio::time::Duration::from_secs(10));
+    let (metrics, _) = metrics::Metrics::new(std::time::Duration::from_secs(10));
     let runtime = ProxyRuntime {
         identity: linkerd_meshtls_rustls::creds::default_for_test().1.into(),
         metrics: metrics.proxy,

linkerd/app/src/tap.rs

@@ -110,7 +110,7 @@ impl Tap {
 impl<T> ExtractParam<tls::server::Timeout, T> for TlsParams {
     #[inline]
     fn extract_param(&self, _: &T) -> tls::server::Timeout {
-        tls::server::Timeout(tokio::time::Duration::from_secs(1))
+        tls::server::Timeout(std::time::Duration::from_secs(1))
     }
 }
 

linkerd/exp-backoff/src/lib.rs

@@ -7,9 +7,9 @@ use rand::{rngs::SmallRng, thread_rng, SeedableRng};
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
+use std::time::Duration;
 use thiserror::Error;
 use tokio::time;
-use tokio::time::Duration;
 
 /// A jittered exponential backoff strategy.
 // The raw fields are exposed so this type can be constructed statically.

linkerd/meshtls/boring/src/tests.rs

@@ -1,6 +1,6 @@
 use linkerd_identity::{Credentials, DerX509};
 use linkerd_tls_test_util::*;
-use tokio::time::Duration;
+use std::time::Duration;
 
 fn load(ent: &Entity) -> crate::creds::Store {
     let roots_pem = std::str::from_utf8(ent.trust_anchors).expect("valid PEM");

linkerd/meshtls/rustls/src/tests.rs

@@ -1,6 +1,6 @@
 use linkerd_identity::{Credentials, DerX509};
 use linkerd_tls_test_util::*;
-use tokio::time::Duration;
+use std::time::Duration;
 
 fn load(ent: &Entity) -> crate::creds::Store {
     let roots_pem = std::str::from_utf8(ent.trust_anchors).expect("valid PEM");

linkerd/proxy/discover/src/buffer.rs

@@ -4,8 +4,8 @@ use pin_project::pin_project;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
+use std::time::Duration;
 use tokio::sync::{mpsc, oneshot};
-use tokio::time::Duration;
 use tokio::time::{self, Sleep};
 use tokio_util::sync::PollSender;
 use tower::discover;

linkerd/proxy/http/src/timeout.rs

@@ -1,7 +1,7 @@
 use linkerd_error::Error;
 use linkerd_stack::{layer, MapErr, NewService, Param, Timeout, TimeoutError};
+use std::time::Duration;
 use thiserror::Error;
-use tokio::time::Duration;
 
 #[derive(Clone, Debug)]
 pub struct ResponseTimeout(pub Option<Duration>);

linkerd/proxy/transport/src/lib.rs

@@ -17,8 +17,8 @@ pub use self::{
 };
 use linkerd_io as io;
 use socket2::TcpKeepalive;
+use std::time::Duration;
 use tokio::net::TcpStream;
-use tokio::time::Duration;
 
 #[derive(Copy, Clone, Debug, Default)]
 pub struct Keepalive(pub Option<Duration>);

linkerd/stack/src/failfast.rs

@@ -171,7 +171,7 @@ where
 #[cfg(test)]
 mod test {
     use super::FailFast;
-    use tokio::time::Duration;
+    use std::time::Duration;
     use tokio_test::{assert_pending, assert_ready, assert_ready_ok};
     use tower::layer::Layer;
     use tower_test::mock::{self, Spawn};