Fix build

Signed-off-by: clux <[email protected]>

examples/crd_api.rs

@@ -43,7 +43,7 @@ async fn main() -> Result<()> {
     let client = Client::try_default().await?;
 
     // Manage CRDs first
-    let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+    let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
 
     // Delete any old versions of it first:
     let dp = DeleteParams::default();

examples/crd_apply.rs

@@ -40,7 +40,7 @@ async fn main() -> anyhow::Result<()> {
 
     // 0. Ensure the CRD is installed (you probably just want to do this on CI)
     // (crd file can be created by piping `Foo::crd`'s yaml ser to kubectl apply)
-    let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+    let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
     info!("Creating crd: {}", serde_yaml::to_string(&Foo::crd())?);
     crds.patch("foos.clux.dev", &ssapply, &Patch::Apply(Foo::crd()))
         .await?;

examples/crd_derive_multi.rs

@@ -101,7 +101,7 @@ async fn main() -> anyhow::Result<()> {
 }
 
 async fn apply_crd(client: Client, crd: CustomResourceDefinition) -> anyhow::Result<()> {
-    let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+    let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
     info!("Creating crd: {}", serde_yaml::to_string(&crd)?);
     let ssapply = PatchParams::apply("crd_derive_multi").force();
     crds.patch("manyderives.kube.rs", &ssapply, &Patch::Apply(&crd))
@@ -116,7 +116,7 @@ async fn apply_crd(client: Client, crd: CustomResourceDefinition) -> anyhow::Res
 }
 
 async fn cleanup(client: Client) -> anyhow::Result<()> {
-    let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+    let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
     let obj = crds.delete("manyderives.kube.rs", &Default::default()).await?;
     if let either::Either::Left(o) = obj {
         let uid = o.uid().unwrap();

examples/crd_derive_schema.rs

@@ -220,7 +220,7 @@ async fn main() -> Result<()> {
 
 // Create CRD and wait for it to be ready.
 async fn create_crd(client: Client) -> Result<CustomResourceDefinition> {
-    let api = Api::<CustomResourceDefinition>::all(client);
+    let api = Api::<CustomResourceDefinition>::cluster(client);
     api.create(&PostParams::default(), &Foo::crd()).await?;
 
     // Wait until it's accepted and established by the api-server
@@ -235,7 +235,7 @@ async fn create_crd(client: Client) -> Result<CustomResourceDefinition> {
 
 // Delete the CRD if it exists and wait until it's deleted.
 async fn delete_crd(client: Client) -> Result<()> {
-    let api = Api::<CustomResourceDefinition>::all(client);
+    let api = Api::<CustomResourceDefinition>::cluster(client);
     if api.get("foos.clux.dev").await.is_ok() {
         api.delete("foos.clux.dev", &DeleteParams::default()).await?;
 

examples/crd_reflector.rs

@@ -25,7 +25,7 @@ async fn main() -> anyhow::Result<()> {
 
     // 0. Ensure the CRD is installed (you probably just want to do this on CI)
     // (crd file can be created by piping `Foo::crd`'s yaml ser to kubectl apply)
-    let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+    let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
     info!("Creating crd: {}", serde_yaml::to_string(&Foo::crd())?);
     let ssapply = PatchParams::apply("crd_reflector_example").force();
     crds.patch("foos.clux.dev", &ssapply, &Patch::Apply(Foo::crd()))

examples/dynamic_api.rs

@@ -2,7 +2,7 @@
 
 use kube::{
     api::{Api, DynamicObject, ResourceExt},
-    discovery::{verbs, Discovery, Scope},
+    discovery::{verbs, Discovery},
     Client,
 };
 use tracing::*;
@@ -18,11 +18,7 @@ async fn main() -> anyhow::Result<()> {
             if !caps.supports_operation(verbs::LIST) {
                 continue;
             }
-            let api: Api<DynamicObject> = if caps.scope == Scope::Cluster {
-                Api::all_with(client.clone(), &ar)
-            } else {
-                Api::default_namespaced_with(client.clone(), &ar)
-            };
+            let api: Api<DynamicObject> = Api::dynamic(client.clone(), &ar, caps.scope);
 
             info!("{}/{} : {}", group.name(), ar.version, ar.kind);
 

examples/kubectl.rs

@@ -228,12 +228,17 @@ fn dynamic_api(
     ns: Option<&str>,
     all: bool,
 ) -> Api<DynamicObject> {
-    if caps.scope == Scope::Cluster || all {
-        Api::all_with(client, &ar)
-    } else if let Some(namespace) = ns {
-        Api::namespaced_with(client, namespace, &ar)
-    } else {
-        Api::default_namespaced_with(client, &ar)
+    match caps.scope {
+        Scope::Cluster => Api::cluster_with(client, &ar),
+        Scope::Namespaced => {
+            if all {
+                Api::all_with(client, &ar)
+            } else if let Some(namespace) = ns {
+                Api::namespaced_with(client, namespace, &ar)
+            } else {
+                Api::default_namespaced_with(client, &ar)
+            }
+        }
     }
 }
 

examples/node_reflector.rs

@@ -12,7 +12,7 @@ async fn main() -> anyhow::Result<()> {
     tracing_subscriber::fmt::init();
     let client = Client::try_default().await?;
 
-    let nodes: Api<Node> = Api::all(client.clone());
+    let nodes: Api<Node> = Api::cluster(client.clone());
     let wc = watcher::Config::default()
         .labels("kubernetes.io/arch=amd64") // filter instances by label
         .timeout(10); // short watch timeout in this example

examples/node_watcher.rs

@@ -12,7 +12,7 @@ async fn main() -> anyhow::Result<()> {
     tracing_subscriber::fmt::init();
     let client = Client::try_default().await?;
     let events: Api<Event> = Api::all(client.clone());
-    let nodes: Api<Node> = Api::all(client.clone());
+    let nodes: Api<Node> = Api::cluster(client.clone());
 
     let use_watchlist = std::env::var("WATCHLIST").map(|s| s == "1").unwrap_or(false);
     let wc = if use_watchlist {

kube-derive/src/lib.rs

@@ -53,7 +53,7 @@ mod custom_resource;
 ///  # struct FooSpec {}
 ///  # let client: Client = todo!();
 ///  let foos: Api<Foo> = Api::default_namespaced(client.clone());
-///  let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+///  let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
 ///  crds.patch("foos.clux.dev", &PatchParams::apply("myapp"), &Patch::Apply(Foo::crd())).await;
 /// # Ok(())
 /// # }

kube-runtime/src/controller/mod.rs

@@ -855,10 +855,10 @@ where
     /// ```
     /// # use kube::runtime::{Controller, controller::Action, reflector::ObjectRef, watcher};
     /// # use kube::{Api, ResourceExt};
-    /// # use k8s_openapi::api::core::v1::{ConfigMap, Namespace};
+    /// # use k8s_openapi::api::core::v1::{ConfigMap, Pod};
     /// # use futures::StreamExt;
     /// # use std::sync::Arc;
-    /// # type WatchedResource = Namespace;
+    /// # type WatchedResource = Pod;
     /// # struct Context;
     /// # async fn reconcile(_: Arc<ConfigMap>, _: Arc<Context>) -> Result<Action, kube::Error> {
     /// #     Ok(Action::await_change())
@@ -963,7 +963,7 @@ where
     /// fn mapper(_: DaemonSet) -> Option<ObjectRef<CustomResource>> { todo!() }
     /// # async fn doc(client: kube::Client) {
     /// let api: Api<DaemonSet> = Api::all(client.clone());
-    /// let cr: Api<CustomResource> = Api::all(client.clone());
+    /// let cr: Api<CustomResource> = Api::default_namespaced(client.clone());
     /// let daemons = watcher(api, watcher::Config::default())
     ///     .touched_objects()
     ///     .predicate_filter(predicates::generation);

kube-runtime/src/events.rs

@@ -292,7 +292,7 @@ mod test {
     async fn event_recorder_attaches_events_without_namespace() -> Result<(), Box<dyn std::error::Error>> {
         let client = Client::try_default().await?;
 
-        let svcs: Api<ClusterRole> = Api::all(client.clone());
+        let svcs: Api<ClusterRole> = Api::cluster(client.clone());
         let s = svcs.get("system:basic-user").await?; // always get this default ClusterRole
         let recorder = Recorder::new(client.clone(), "kube".into(), s.object_ref(&()));
         recorder

kube-runtime/src/reflector/mod.rs

@@ -39,7 +39,7 @@ pub use store::{store, Store};
 /// # async fn wrapper() -> Result<(), Box<dyn std::error::Error>> {
 /// # let client: kube::Client = todo!();
 ///
-/// let nodes: Api<Node> = Api::all(client);
+/// let nodes: Api<Node> = Api::cluster(client);
 /// let node_filter = Config::default().labels("kubernetes.io/arch=amd64");
 /// let (reader, writer) = reflector::store();
 ///

kube-runtime/src/wait.rs

@@ -39,7 +39,7 @@ pub enum Error {
 /// # async fn wrapper() -> Result<(), Box<dyn std::error::Error>> {
 /// # let client: kube::Client = todo!();
 ///
-/// let crds: Api<CustomResourceDefinition> = Api::all(client);
+/// let crds: Api<CustomResourceDefinition> = Api::cluster(client);
 /// // .. create or apply a crd here ..
 /// let establish = await_condition(crds, "foos.clux.dev", conditions::is_crd_established());
 /// let _ = tokio::time::timeout(std::time::Duration::from_secs(10), establish).await?;

kube/src/lib.rs

@@ -70,7 +70,7 @@
 //! #[tokio::main]
 //! async fn main() -> Result<(), Box<dyn std::error::Error>> {
 //!     let client = Client::try_default().await?;
-//!     let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+//!     let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
 //!
 //!     // Apply the CRD so users can create Foo instances in Kubernetes
 //!     crds.patch("foos.clux.dev",
@@ -241,7 +241,7 @@ mod test {
         use serde_json::json;
         let client = Client::try_default().await?;
         let ssapply = PatchParams::apply("kube").force();
-        let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+        let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
         // Server-side apply CRD and wait for it to get ready
         crds.patch("foos.clux.dev", &ssapply, &Patch::Apply(Foo::crd()))
             .await?;
@@ -365,7 +365,7 @@ mod test {
     async fn derived_resources_discoverable() -> Result<(), Box<dyn std::error::Error>> {
         use crate::{
             core::{DynamicObject, GroupVersion, GroupVersionKind},
-            discovery::{self, verbs, ApiGroup, Discovery, Scope},
+            discovery::{self, verbs, ApiGroup, Discovery},
             runtime::wait::{await_condition, conditions, Condition},
         };
 
@@ -377,7 +377,7 @@ mod test {
         let client = Client::try_default().await?;
 
         // install crd is installed
-        let crds: Api<CustomResourceDefinition> = Api::all(client.clone());
+        let crds: Api<CustomResourceDefinition> = Api::cluster(client.clone());
         let ssapply = PatchParams::apply("kube").force();
         crds.patch("testcrs.kube.rs", &ssapply, &Patch::Apply(TestCr::crd()))
             .await?;
@@ -421,11 +421,7 @@ mod test {
                 if !caps.supports_operation(verbs::LIST) {
                     continue;
                 }
-                let api: Api<DynamicObject> = if caps.scope == Scope::Namespaced {
-                    Api::default_namespaced_with(client.clone(), &ar)
-                } else {
-                    Api::all_with(client.clone(), &ar)
-                };
+                let api: Api<DynamicObject> = Api::dynamic(client.clone(), &ar, caps.scope);
                 api.list(&Default::default()).await?;
             }
         }

kube/src/mock_tests.rs

@@ -32,7 +32,7 @@ async fn watchers_respect_pagination_limits() {
     // NB: scenario only responds responds to TWO paginated list calls with two objects
     let mocksrv = fakeserver.run(Scenario::PaginatedList);
 
-    let api: Api<Hack> = Api::all(client);
+    let api: Api<Hack> = Api::cluster(client);
     let cfg = Config::default().page_size(1);
     let mut stream = watcher(api, cfg).applied_objects().boxed();
     let first: Hack = stream.try_next().await.unwrap().unwrap();