Merge pull request ynqa#15 from clux/fixups

api rewrite

Author: clux

CHANGELOG.md

@@ -1,7 +1,8 @@
 0.7.0 / UNRELEASED
 ==================
   * Expose list/watch parameters #11
-
+  * ApiResource -> Api
+  * ResourceType has been removed in favour of `Api::v1Pod()` say
 
 0.6.0 / 2019-05-12
 ==================

README.md

@@ -20,12 +20,12 @@ One of the main abstractions exposed from `kube::api` is `Reflector<T, U>`. This
 
 It handles the api mechanics for watching kube resources, tracking resourceVersions, and using watch events; it builds and maintains an internal map.
 
-To use it, you just feed in `T` as a `Spec` struct and `U` as a `Status` struct, which can be as complete or incomplete as you like. Here, using the complete structs via [k8s-openapi](https://docs.rs/k8s-openapi/0.4.0/k8s_openapi/api/core/v1/struct.PodSpec.html):
+To use it, you just feed in `T` as a `Spec` struct and `U` as a `Status` struct, which can be as complete or incomplete as you like. Here, using the complete structs via [k8s-openapi](https://docs.rs/k8s-openapi/0.4.0/k8s_openapi/api/core/v1/struct.NodeSpec.html):
 
 ```rust
-use k8s_openapi::api::core::v1::{PodSpec, PodStatus};
-let resource = ResourceType::Pods(Some("kube-system".into()));
-let rf : Reflector<PodSpec, PodStatus> = Reflector::new(client.clone(), resource.into())?
+use k8s_openapi::api::core::v1::{NodeSpec, NodeStatus};
+let api = Api::v1Node();
+let rf : Reflector<NodeSpec, NodeStatus> = Reflector::new(client, api)?
     .timeout(10)
     .init();
 ```
@@ -54,8 +54,8 @@ You tell it what type parameters correspond to; `T` should be a `Spec` struct, a
 
 ```rust
 use k8s_openapi::api::core::v1::{PodSpec, PodStatus};
-let resource = ResourceType::Pods(Some("kube-system".into()));
-let inf : Informer<PodSpec, PodStatus> = Informer::new(client.clone(), resource.into())
+let api = Api::v1Pod();
+let inf : Informer<PodSpec, PodStatus> = Informer::new(client, api)
     .init()?;
 ```
 

examples/crd_reflector.rs

@@ -2,16 +2,16 @@
 #[macro_use] extern crate serde_derive;
 
 use kube::{
-    api::{ApiResource, Reflector, Void},
+    api::{Api, Reflector, Void},
     client::APIClient,
     config,
 };
 
 // Own custom resource
 #[derive(Deserialize, Serialize, Clone)]
-pub struct FooResource {
-  name: String,
-  info: String,
+pub struct Foo {
+    name: String,
+    info: String,
 }
 
 fn main() -> Result<(), failure::Error> {
@@ -21,14 +21,11 @@ fn main() -> Result<(), failure::Error> {
     let client = APIClient::new(config);
 
     // This example requires `kubectl apply -f examples/foo.yaml` run first
-    let resource = ApiResource {
-        group: "clux.dev".into(),
-        resource: "foos".into(),
-        version: "v1".into(),
-        namespace: Some("kube-system".into()),
-        ..Default::default()
-    };
-    let rf : Reflector<FooResource, Void> = Reflector::new(client, resource)
+    let resource = Api::customResource("foos")
+        .group("clux.dev")
+        .within("kube-system");
+
+    let rf : Reflector<Foo, Void> = Reflector::new(client, resource)
         .init()?;
 
     loop {

examples/deployment_reflector.rs

@@ -1,6 +1,6 @@
 #[macro_use] extern crate log;
 use kube::{
-    api::{ResourceType, Reflector},
+    api::{Api, Reflector},
     client::APIClient,
     config,
 };
@@ -12,9 +12,9 @@ fn main() -> Result<(), failure::Error> {
     let config = config::load_kube_config().expect("failed to load kubeconfig");
     let client = APIClient::new(config);
 
-    let resource = ResourceType::Deploys(Some("kube-system".into()));
+    let resource = Api::v1Deployment().within("kube-system");
     let rf : Reflector<DeploymentSpec, DeploymentStatus> =
-        Reflector::new(client, resource.into())
+        Reflector::new(client, resource)
         .init()?;
 
     // rf is initialized with full state, which can be extracted on demand.

examples/node_informer.rs

@@ -1,6 +1,6 @@
 #[macro_use] extern crate log;
 use kube::{
-    api::{ResourceType, Informer, WatchEvent},
+    api::{Api, Informer, WatchEvent},
     client::APIClient,
     config,
 };
@@ -15,8 +15,8 @@ fn main() -> Result<(), failure::Error> {
     let config = config::load_kube_config().expect("failed to load kubeconfig");
     let client = APIClient::new(config);
 
-    let nodes = ResourceType::Nodes;
-    let ni = Informer::new(client.clone(), nodes.into())
+    let nodes = Api::v1Node();
+    let ni = Informer::new(client.clone(), nodes)
         .labels("role=worker")
         .init()?;
 

examples/node_reflector.rs

@@ -1,6 +1,6 @@
 #[macro_use] extern crate log;
 use kube::{
-    api::{ResourceType, Reflector},
+    api::{Api, Reflector},
     client::APIClient,
     config,
 };
@@ -12,7 +12,7 @@ fn main() -> Result<(), failure::Error> {
     let config = config::load_kube_config().expect("failed to load kubeconfig");
     let client = APIClient::new(config);
 
-    let resource = ResourceType::Nodes;
+    let resource = Api::v1Node();
     let rf : Reflector<NodeSpec, NodeStatus> = Reflector::new(client, resource.into())
         .labels("role=master")
         .init()?;

examples/pod_informer.rs

@@ -1,7 +1,7 @@
 #[macro_use] extern crate log;
 use std::env;
 use kube::{
-    api::{ResourceType, Informer, WatchEvent},
+    api::{Api, Informer, WatchEvent},
     client::APIClient,
     config,
 };
@@ -12,11 +12,10 @@ fn main() -> Result<(), failure::Error> {
     env_logger::init();
     let config = config::load_kube_config().expect("failed to load kubeconfig");
     let client = APIClient::new(config);
-    let namespace = Some(env::var("NAMESPACE").unwrap_or("kube-system".into()));
+    let namespace = env::var("NAMESPACE").unwrap_or("kube-system".into());
 
-    let resource = ResourceType::Pods(namespace);
-    let inf : Informer<PodSpec, PodStatus> = Informer::new(client.clone(), resource.into())
-        .init()?;
+    let resource = Api::v1Pod().within(&namespace);
+    let inf = Informer::new(client.clone(), resource).init()?;
 
     // Here we both poll and reconcile based on events from the main thread
     // If you run this next to actix-web (say), spawn a thread and pass `inf` as app state

examples/pod_reflector.rs

@@ -1,6 +1,6 @@
 #[macro_use] extern crate log;
 use kube::{
-    api::{ResourceType, Reflector},
+    api::{Api, Reflector},
     client::APIClient,
     config,
 };
@@ -12,8 +12,8 @@ fn main() -> Result<(), failure::Error> {
     let config = config::load_kube_config().expect("failed to load kubeconfig");
     let client = APIClient::new(config);
 
-    let resource = ResourceType::Pods(Some("kube-system".into()));
-    let rf : Reflector<PodSpec, PodStatus> = Reflector::new(client.clone(), resource.into())
+    let resource = Api::v1Pod().within("kube-system");
+    let rf : Reflector<PodSpec, PodStatus> = Reflector::new(client.clone(), resource)
         .init()?;
 
     // Can read initial state now: