Rust 2024 let-chains to simplify wait Conditions

.github/workflows/lint.yml

@@ -33,4 +33,4 @@ jobs:
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rustfmt
-      - run: rustfmt +nightly --edition 2021 --check $(find . -type f -iname *.rs)
+      - run: rustfmt +nightly --edition 2024 --check $(find . -type f -iname *.rs)

.github/workflows/rustfmt.yml

@@ -17,15 +17,15 @@ jobs:
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: rustfmt
-      - run: rustfmt +nightly --edition 2021 $(find . -type f -iname *.rs)
+      - run: rustfmt +nightly --edition 2024 $(find . -type f -iname *.rs)
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v7
         with:
           commit-message: rustfmt
           signoff: true
           title: rustfmt
           body: |
-            Changes from `rustfmt +nightly --edition 2021 $(find . -type f -iname *.rs)`.
+            Changes from `rustfmt +nightly --edition 2024 $(find . -type f -iname *.rs)`.
           branch: rustfmt
           # Delete branch when merged
           delete-branch: true

e2e/job.rs

@@ -1,8 +1,8 @@
 use k8s_openapi::api::batch::v1::Job;
 use kube::{
+    Client,
     api::{Api, DeleteParams, PostParams},
     runtime::wait::{await_condition, conditions},
-    Client,
 };
 use tracing::info;
 

examples/admission_controller.rs

@@ -1,11 +1,11 @@
 use json_patch::jsonptr::PointerBuf;
 use kube::core::{
-    admission::{AdmissionRequest, AdmissionResponse, AdmissionReview},
     DynamicObject, Resource, ResourceExt,
+    admission::{AdmissionRequest, AdmissionResponse, AdmissionReview},
 };
 use std::{convert::Infallible, error::Error};
 use tracing::*;
-use warp::{reply, Filter, Reply};
+use warp::{Filter, Reply, reply};
 
 #[tokio::main]
 async fn main() {

examples/cert_check.rs

@@ -1,13 +1,13 @@
 use std::borrow::Cow;
 
 use k8s_openapi::{
-    api::core::v1::{ConfigMap, Namespace as Ns},
     NamespaceResourceScope,
+    api::core::v1::{ConfigMap, Namespace as Ns},
 };
 use kube::{
+    Client, Resource,
     api::ObjectMeta,
     client::scope::{Cluster, Namespace},
-    Client, Resource,
 };
 use serde::{Deserialize, Serialize};
 use tracing::*;

examples/configmapgen_controller.rs

@@ -5,12 +5,12 @@ use anyhow::Result;
 use futures::StreamExt;
 use k8s_openapi::api::core::v1::ConfigMap;
 use kube::{
+    Client, CustomResource,
     api::{Api, ObjectMeta, Patch, PatchParams, Resource},
     runtime::{
         controller::{Action, Config, Controller},
         watcher,
     },
-    Client, CustomResource,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

examples/crd_api.rs

@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::{Result, bail};
 use either::Either::{Left, Right};
 use garde::Validate;
 use schemars::JsonSchema;
@@ -10,9 +10,9 @@ use tracing::*;
 
 use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition;
 use kube::{
+    Client, CustomResource,
     api::{Api, DeleteParams, ListParams, Patch, PatchParams, PostParams, ResourceExt},
     core::crd::CustomResourceExt,
-    Client, CustomResource,
 };
 
 // Own custom resource
@@ -212,9 +212,10 @@ async fn main() -> Result<()> {
     match foos.create(&pp, &fx).await {
         Err(kube::Error::Api(ae)) => {
             assert_eq!(ae.code, 422);
-            assert!(ae
-                .message
-                .contains("spec.name in body should be at least 3 chars long"));
+            assert!(
+                ae.message
+                    .contains("spec.name in body should be at least 3 chars long")
+            );
         }
         Err(e) => bail!("somehow got unexpected error from validation: {:?}", e),
         Ok(o) => bail!("somehow created {:?} despite validation", o),

examples/crd_apply.rs

@@ -8,9 +8,9 @@ use apiexts::CustomResourceDefinition;
 use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1 as apiexts;
 
 use kube::{
+    Client, CustomResource, CustomResourceExt,
     api::{Api, Patch, PatchParams, ResourceExt},
     runtime::wait::{await_condition, conditions},
-    Client, CustomResource, CustomResourceExt,
 };
 
 /// Spec object for Foo

examples/crd_derive.rs

@@ -1,7 +1,7 @@
 use k8s_openapi::apimachinery::pkg::apis::meta::v1::Condition;
 use kube::{
-    core::object::{HasSpec, HasStatus},
     CustomResource, CustomResourceExt, Resource,
+    core::object::{HasSpec, HasStatus},
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

examples/crd_derive_custom_schema.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use kube::CustomResourceExt;
 use kube_derive::CustomResource;
-use schemars::{json_schema, JsonSchema};
+use schemars::{JsonSchema, json_schema};
 use serde::{Deserialize, Serialize};
 
 /// CustomResource with manually implemented `JsonSchema`

examples/crd_derive_multi.rs

@@ -1,9 +1,9 @@
 use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition;
 use kube::{
+    Client, CustomResource, CustomResourceExt, ResourceExt,
     api::{Api, Patch, PatchParams},
     core::crd::merge_crds,
     runtime::wait::{await_condition, conditions},
-    Client, CustomResource, CustomResourceExt, ResourceExt,
 };
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@@ -108,7 +108,7 @@ async fn main() -> anyhow::Result<()> {
         .await
         .unwrap_err();
     info!("cannot get old on v1 anymore: {:?}", v1err); // mandatory field oldprop truncated
-                                                        // ...but the change is still there:
+    // ...but the change is still there:
     let old_still_there = v2api.get("old").await?;
     assert_eq!(old_still_there.spec.name, "i am old2");
 

examples/crd_derive_schema.rs

@@ -1,13 +1,13 @@
-use anyhow::{anyhow, Result};
+use anyhow::{Result, anyhow};
 use futures::{StreamExt, TryStreamExt};
 use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomResourceDefinition;
 use kube::{
+    Client, CustomResource, CustomResourceExt, KubeSchema,
     api::{
         Api, ApiResource, DeleteParams, DynamicObject, GroupVersionKind, Patch, PatchParams, PostParams,
         WatchEvent, WatchParams,
     },
     runtime::wait::{await_condition, conditions},
-    Client, CustomResource, CustomResourceExt, KubeSchema,
 };
 use serde::{Deserialize, Serialize};
 

examples/crd_reflector.rs

@@ -3,9 +3,9 @@ use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1::CustomRe
 use tracing::*;
 
 use kube::{
-    api::{Api, Patch, PatchParams, ResourceExt},
-    runtime::{reflector, watcher, WatchStreamExt},
     Client, CustomResource, CustomResourceExt,
+    api::{Api, Patch, PatchParams, ResourceExt},
+    runtime::{WatchStreamExt, reflector, watcher},
 };
 
 use schemars::JsonSchema;

examples/custom_client.rs

@@ -4,7 +4,7 @@ use k8s_openapi::api::core::v1::Pod;
 use tower::BoxError;
 use tracing::*;
 
-use kube::{client::ConfigExt, Api, Client, Config, ResourceExt};
+use kube::{Api, Client, Config, ResourceExt, client::ConfigExt};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

examples/custom_client_tls.rs

@@ -6,7 +6,7 @@ use k8s_openapi::api::core::v1::Pod;
 use tower::{BoxError, ServiceBuilder};
 use tracing::*;
 
-use kube::{client::ConfigExt, Api, Client, Config, ResourceExt};
+use kube::{Api, Client, Config, ResourceExt, client::ConfigExt};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {

examples/custom_client_trace.rs

@@ -9,8 +9,8 @@ use tower_http::{decompression::DecompressionLayer, trace::TraceLayer};
 use tracing::{Span, *};
 
 use kube::{
-    client::{Body, ConfigExt},
     Api, Client, Config, ResourceExt,
+    client::{Body, ConfigExt},
 };
 
 #[tokio::main]

examples/dynamic_api.rs

@@ -1,9 +1,9 @@
 //! In this example we will implement something similar to `kubectl get all`.
 
 use kube::{
-    api::{Api, DynamicObject, ResourceExt},
-    discovery::{verbs, Discovery, Scope},
     Client,
+    api::{Api, DynamicObject, ResourceExt},
+    discovery::{Discovery, Scope, verbs},
 };
 use tracing::*;
 

examples/dynamic_jsonpath.rs

@@ -2,8 +2,8 @@ use anyhow::{Context, Error};
 use jsonpath_rust::JsonPath;
 use k8s_openapi::api::core::v1::Pod;
 use kube::{
-    api::{Api, ListParams},
     Client,
+    api::{Api, ListParams},
 };
 use tracing::*;
 

examples/dynamic_pod.rs

@@ -1,6 +1,6 @@
 use kube::{
-    api::{Api, ApiResource, NotUsed, Object, ResourceExt},
     Client,
+    api::{Api, ApiResource, NotUsed, Object, ResourceExt},
 };
 use serde::Deserialize;
 use tracing::*;

examples/dynamic_watcher.rs

@@ -1,7 +1,7 @@
 use futures::{Stream, StreamExt, TryStreamExt};
 use kube::{
     api::{Api, ApiResource, DynamicObject, GroupVersionKind, Resource, ResourceExt},
-    runtime::{metadata_watcher, watcher, watcher::Event, WatchStreamExt},
+    runtime::{WatchStreamExt, metadata_watcher, watcher, watcher::Event},
 };
 use serde::de::DeserializeOwned;
 use tracing::*;

examples/errorbounded_configmap_watcher.rs

@@ -1,10 +1,10 @@
 use futures::prelude::*;
 use k8s_openapi::api::core::v1::ConfigMap;
 use kube::{
+    Client, Resource,
     api::{Api, ObjectMeta},
     core::DeserializeGuard,
-    runtime::{reflector::ObjectRef, watcher, WatchStreamExt},
-    Client, Resource,
+    runtime::{WatchStreamExt, reflector::ObjectRef, watcher},
 };
 use serde::Deserialize;
 use tracing::*;

examples/event_watcher.rs

@@ -7,8 +7,8 @@ use k8s_openapi::{
     chrono::Utc,
 };
 use kube::{
-    runtime::{watcher, WatchStreamExt},
     Api, Client, ResourceExt,
+    runtime::{WatchStreamExt, watcher},
 };
 
 /// limited variant of `kubectl events` that works on current context's namespace

examples/job_api.rs

@@ -1,8 +1,8 @@
 use k8s_openapi::api::batch::v1::Job;
 use kube::{
+    Client,
     api::{Api, DeleteParams, PostParams},
     runtime::wait::{await_condition, conditions},
-    Client,
 };
 use tracing::info;
 

examples/kubectl.rs

@@ -1,19 +1,20 @@
 //! This is a simple imitation of the basic functionality of kubectl:
 //! kubectl {get, delete, apply, watch, edit} <resource> [name]
 //! with labels and namespace selectors supported.
-use anyhow::{bail, Context, Result};
+use anyhow::{Context, Result, bail};
 use futures::{StreamExt, TryStreamExt};
 use k8s_openapi::{apimachinery::pkg::apis::meta::v1::Time, chrono::Utc};
 use kube::{
+    Client,
     api::{Api, DynamicObject, ListParams, Patch, PatchParams, ResourceExt},
     config::KubeConfigOptions,
     core::GroupVersionKind,
     discovery::{ApiCapabilities, ApiResource, Discovery, Scope},
     runtime::{
+        WatchStreamExt,
         wait::{await_condition, conditions::is_deleted},
-        watcher, WatchStreamExt,
+        watcher,
     },
-    Client,
 };
 use tracing::*;
 

examples/log_stream.rs

@@ -4,8 +4,8 @@ use k8s_openapi::{
     chrono::{DateTime, Utc},
 };
 use kube::{
-    api::{Api, LogParams},
     Client,
+    api::{Api, LogParams},
 };
 use tracing::*;
 

examples/multi_watcher.rs

@@ -1,12 +1,12 @@
-use futures::{stream, StreamExt, TryStreamExt};
+use futures::{StreamExt, TryStreamExt, stream};
 use k8s_openapi::api::{
     apps::v1::Deployment,
     core::v1::{ConfigMap, Secret},
 };
 use kube::{
-    api::{Api, ResourceExt},
-    runtime::{watcher, WatchStreamExt},
     Client,
+    api::{Api, ResourceExt},
+    runtime::{WatchStreamExt, watcher},
 };
 use tracing::*;
 

examples/node_reflector.rs

@@ -3,9 +3,9 @@ use std::pin::pin;
 use futures::TryStreamExt;
 use k8s_openapi::api::core::v1::Node;
 use kube::{
-    api::{Api, ResourceExt},
-    runtime::{predicates, reflector, watcher, Predicate, WatchStreamExt},
     Client,
+    api::{Api, ResourceExt},
+    runtime::{Predicate, WatchStreamExt, predicates, reflector, watcher},
 };
 use tracing::*;
 

examples/node_watcher.rs

@@ -4,8 +4,8 @@ use futures::TryStreamExt;
 use k8s_openapi::api::core::v1::{Event, Node};
 use kube::{
     api::{Api, ListParams, ResourceExt},
-    client::{scope, Client},
-    runtime::{watcher, WatchStreamExt},
+    client::{Client, scope},
+    runtime::{WatchStreamExt, watcher},
 };
 use tracing::*;
 

examples/pod_api.rs

@@ -3,9 +3,9 @@ use serde_json::json;
 use tracing::*;
 
 use kube::{
+    Client,
     api::{Api, DeleteParams, ListParams, Patch, PatchParams, PostParams, ResourceExt},
     runtime::wait::{await_condition, conditions::is_pod_running},
-    Client,
 };
 
 #[tokio::main]

examples/pod_attach.rs

@@ -1,14 +1,14 @@
 use std::io::Write;
 use tracing::*;
 
-use futures::{join, stream, StreamExt, TryStreamExt};
+use futures::{StreamExt, TryStreamExt, join, stream};
 use k8s_openapi::api::core::v1::Pod;
 
 use kube::{
+    Client,
     api::{
         Api, AttachParams, AttachedProcess, DeleteParams, PostParams, ResourceExt, WatchEvent, WatchParams,
     },
-    Client,
 };
 
 #[tokio::main]

examples/pod_cp.rs

@@ -3,8 +3,8 @@ use k8s_openapi::api::core::v1::Pod;
 use tracing::*;
 
 use kube::{
-    api::{Api, AttachParams, DeleteParams, PostParams, ResourceExt, WatchEvent, WatchParams},
     Client,
+    api::{Api, AttachParams, DeleteParams, PostParams, ResourceExt, WatchEvent, WatchParams},
 };
 use tokio::io::AsyncWriteExt;