small docs

Author: clux

README.md

@@ -62,15 +62,14 @@ The main feature of `Informer<T, U>` is that after calling `.poll()` you handle
 inf.poll()?; // watches + queues events
 
 while let Some(event) = inf.pop() {
-    reconcile(&client, event)?;
+    handle_event(&client, event)?;
 }
 ```
 
 How you handle them is up to you, you could build your own state, you can call a kube client, or you can simply print events. Here's a sketch of how such a handler would look:
 
 ```rust
-fn reconcile(c: &APIClient, event: WatchEvent<PodSpec, PodStatus>) -> Result<(), failure::Error> {
-    // use the kube api client here..
+fn handle_event(c: &APIClient, event: WatchEvent<PodSpec, PodStatus>) -> Result<(), failure::Error> {
     match ev {
         WatchEvent::Added(o) => {
             let containers = o.spec.containers.into_iter().map(|c| c.name).collect::<Vec<_>>();

examples/node_informer.rs

@@ -4,8 +4,10 @@ use kube::{
     client::APIClient,
     config,
 };
-use k8s_openapi::api::core::v1::{NodeSpec, NodeStatus};
-use k8s_openapi::api::core::v1::{Event, ListEventForAllNamespacesOptional};
+use k8s_openapi::api::core::v1::{
+    NodeSpec, NodeStatus,
+    Event, ListEventForAllNamespacesOptional,
+};
 
 fn main() -> Result<(), failure::Error> {
     std::env::set_var("RUST_LOG", "info,kube=trace");
@@ -59,7 +61,7 @@ fn handle_nodes(client: &APIClient, ev: WatchEvent<NodeSpec, NodeStatus>) -> Res
             );
         },
         WatchEvent::Error(e) => {
-            warn!("Error event: {:?}", e); // ought to refresh here
+            warn!("Error event: {:?}", e);
         }
     }
     Ok(())

examples/pod_informer.rs

@@ -24,14 +24,13 @@ fn main() -> Result<(), failure::Error> {
 
         // Handle events one by one, draining the informer
         while let Some(event) = inf.pop() {
-            reconcile(&client, event)?;
+            handle_node(&client, event)?;
         }
     }
 }
 
 // This function lets the app handle an event from kube
-fn reconcile(_c: &APIClient, ev: WatchEvent<PodSpec, PodStatus>) -> Result<(), failure::Error> {
-    // TODO: Use the kube api client here..
+fn handle_node(_c: &APIClient, ev: WatchEvent<PodSpec, PodStatus>) -> Result<(), failure::Error> {
     match ev {
         WatchEvent::Added(o) => {
             let containers = o.spec.containers.into_iter().map(|c| c.name).collect::<Vec<_>>();
@@ -45,7 +44,7 @@ fn reconcile(_c: &APIClient, ev: WatchEvent<PodSpec, PodStatus>) -> Result<(), f
             info!("Deleted Pod: {}", o.metadata.name);
         },
         WatchEvent::Error(e) => {
-            warn!("Error event: {:?}", e); // ought to refresh here
+            warn!("Error event: {:?}", e);
         }
     }
     Ok(())

examples/pod_reflector.rs

@@ -15,6 +15,7 @@ fn main() -> Result<(), failure::Error> {
     let resource = ResourceType::Pods(Some("kube-system".into()));
     let rf : Reflector<PodSpec, PodStatus> = Reflector::new(client.clone(), resource.into())?;
 
+    // Can read initial state now:
     rf.read()?.into_iter().for_each(|(name, p)| {
         info!("Found pod {} ({}) with {:?}",
             name,
@@ -23,12 +24,11 @@ fn main() -> Result<(), failure::Error> {
         );
     });
 
-    // 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 `rf` as app state
+    // Poll to keep data up to date:
     loop {
         rf.poll()?;
 
-        // Can also print internal state
+        // up to date state:
         let pods = rf.read()?.into_iter().map(|(name, _)| name).collect::<Vec<_>>();
         info!("Current pods: {:?}", pods);
     }

src/client/mod.rs

@@ -106,7 +106,6 @@ impl APIClient {
                 xs.push(r);
             }
             Ok(xs)
-
         }
     }
 }