kube 0.38.0

Kubernetes client in futures controller runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Crate for interacting with the Kubernetes API
//!
//! This crate includes the tools for manipulating Kubernetes resources as
//! well as keeping track of those resources as they change over time
//!
//! # Example
//!
//! The following example will crate a [`Pod`][k8s_openapi::api::core::v1::Pod]
//! and then watch for it to become available
//!
//! ```rust,no_run
//! use futures::{StreamExt, TryStreamExt};
//! use kube::api::{Api, ListParams, PostParams, WatchEvent};
//! use kube::Client;
//! use kube::runtime::Informer;
//! use k8s_openapi::api::core::v1::Pod;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), kube::Error> {
//!     // Read the environment to find config for kube client.
//!     // Note that this tries an in-cluster configuration first,
//!     // then falls back on a kubeconfig file.
//!     let kube_client = Client::try_default().await?;
//!
//!     // Get a strongly typed handle to the Kubernetes API for interacting
//!     // with pods in the "default" namespace.
//!     let pods: Api<Pod> = Api::namespaced(kube_client, "default");
//!
//!     // Create a pod from JSON
//!     let pod = serde_json::from_value(serde_json::json!({
//!         "apiVersion": "v1",
//!         "kind": "Pod",
//!         "metadata": {
//!             "name": "my-pod"
//!         },
//!         "spec": {
//!             "containers": [
//!                 {
//!                     "name": "my-container",
//!                     "image": "myregistry.azurecr.io/hello-world:v1",
//!                 },
//!             ],
//!         }
//!     }))?;
//!
//!     // Create the pod
//!     let pod = pods.create(&PostParams::default(), &pod).await?;
//!
//!     // Create an informer for watching events about
//!     let informer = Informer::new(pods).params(
//!         ListParams::default()
//!             .fields("metadata.name=my-pod")
//!             .timeout(10),
//!     );
//!
//!     // Get an event stream from the informer
//!     let mut events_stream = informer.poll().await?.boxed();
//!
//!     // Keep getting events from the events stream
//!     while let Some(event) = events_stream.try_next().await? {
//!         match event {
//!             WatchEvent::Modified(e) if e.status.as_ref().unwrap().phase.as_ref().unwrap() == "Running" => {
//!                 println!("It's running!");
//!             }
//!             WatchEvent::Error(e) => {
//!                 panic!("WatchEvent error: {:?}", e);
//!             }
//!             _ => {}
//!         }
//!     }
//!     Ok(())
//! }
//! ```

#![deny(missing_docs)]

#[macro_use] extern crate static_assertions;
assert_cfg!(
    all(
        not(all(feature = "native-tls", feature = "rustls-tls")),
        any(feature = "native-tls", feature = "rustls-tls")
    ),
    "Must use exactly one of native-tls or rustls-tls features"
);

#[macro_use] extern crate log;

pub mod api;
pub mod client;
pub mod config;
#[deprecated(note = "Replaced by the kube-runtime crate", since = "0.38.0")]
// Rust doesn't allow items within a deprecated module to interact with each other..
#[allow(deprecated)]
pub mod runtime;

pub mod error;
mod oauth2;

pub use api::{Api, Resource};
#[doc(inline)] pub use client::Client;
#[doc(inline)] pub use config::Config;
#[doc(inline)] pub use error::Error;

/// Convient alias for `Result<T, Error>`
pub type Result<T> = std::result::Result<T, Error>;