more wip post stuff for ynqa#16

using https://docs.serde.rs/serde_json/macro.json.html now

Author: clux

examples/crd_api.rs

@@ -1,17 +1,18 @@
 #[macro_use] extern crate log;
 #[macro_use] extern crate failure;
 #[macro_use] extern crate serde_derive;
+use serde_json::json;
 
 use kube::{
-    api::{Api, PostResponse, CreateResponse, PostParams, Object, Void},
+    api::{Api, PostResponse, PostParams, Object},
     client::APIClient,
     config,
 };
 
+//use k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
 use k8s_openapi::apiextensions_apiserver::pkg::apis::apiextensions::v1beta1::{
     //CustomResourceDefinition as Crd,
     CustomResourceDefinitionSpec as CrdSpec,
-    CustomResourceDefinitionNames as CrdNames,
     CustomResourceDefinitionStatus as CrdStatus,
 };
 
@@ -37,35 +38,46 @@ fn main() -> Result<(), failure::Error> {
     let crds = Api::v1beta1CustomResourceDefinition();
 
     // Create the CRD so we can create Foos in kube
-    let foocrd = CrdSpec {
-        group: "clux.dev".into(),
-        version: Some("v1".into()),
-        scope: "Namespaced".into(),
-        names: CrdNames {
-            plural: "foos".into(),
-            singular: Some("foo".into()),
-            kind: "Foo".into(),
-            ..Default::default()
+    let foocrd = json!({
+        "metadata": {
+            "name": "foos.clux.dev"
         },
-        ..Default::default()
-    };
+        "spec": {
+            "group": "clux.dev",
+            "version": "v1",
+            "scope": "Namespaced",
+            "names": {
+                "plural": "foos",
+                "singular": "foo",
+                "kind": "Foo",
+            }
+        }
+    });
+
     let pp = PostParams::default();
     let req = crds.create(&pp, serde_json::to_vec(&foocrd)?)?;
-    match client.request::<CreateResponse<Object<CrdSpec, CrdStatus>>>(req)? {
-        CreateResponse::Created(o) => info!("Created {}", o.metadata.name),
-        CreateResponse::Accepted(o) => info!("Accepted {}", o.metadata.name),
-        CreateResponse::Ok(o) => info!("Ok {}", o.metadata.name),
-        CreateResponse::Error => bail!("Uh oh"),
+    if let Ok(res) = client.request::<Object<CrdSpec, CrdStatus>>(req) {
+        info!("Created {}", res.metadata.name);
+        debug!("Created CRD: {:?}", res.spec);
+    } else {
+        // TODO: need error code here for ease
     }
 
+
     // Manage the Foo CR
     let foos = Api::customResource("foos.clux.dev").version("v1");
 
     // Create some Foos
-    let f1 = FooSpec { name: "baz".into(), info: "unpatched baz".into() };
+    let f1 = json!({
+        "metadata": { "name": "baz" },
+        "spec": FooSpec { name: "baz".into(), info: "unpatched baz".into() }
+    });
     foos.create(&pp, serde_json::to_vec(&f1)?)?;
 
-    let f2 = FooSpec { name: "qux".into(), info: "unpatched qux".into() };
+    let f2 = json!({
+        "metadata": { "name": "qux" },
+        "spec": FooSpec { name: "qux".into(), info: "unpatched qux".into() }
+    });
     foos.create(&pp, serde_json::to_vec(&f2)?)?;
 
 
@@ -81,11 +93,9 @@ fn main() -> Result<(), failure::Error> {
     // Set its status:
     let fs = FooStatus { is_bad: true };
     let req = foos.replace_status("baz", &pp, serde_json::to_vec(&fs)?)?;
-    match client.request::<PostResponse<Foo>>(req)? {
-        PostResponse::Ok(o) => info!("Replaced status {:?} for {}", o.status, o.metadata.name),
-        PostResponse::Created(o) => info!("Replaced status {:?} for {}", o.status, o.metadata.name),
-        PostResponse::Error => bail!("uh oh 2"),
-    }
+    let res = client.request::<Foo>(req)?;
+    info!("Replaced status {:?} for {}", res.status, res.metadata.name);
+
 
     // Verify we can get it
     let req = foos.get("baz")?;
@@ -97,6 +107,5 @@ fn main() -> Result<(), failure::Error> {
     let f2 = client.request::<Foo>(req)?;
     assert_eq!(f2.spec.info, "unpatched qux");
 
-
     Ok(())
 }

src/api/api.rs

@@ -6,7 +6,7 @@ use crate::{Result, Error};
 ///
 /// Used to construct requests from url conventions.
 /// When data is PUT/POST/PATCH'd this struct requires raw bytes.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Api {
     /// API Resource name
     pub resource: String,
@@ -16,6 +16,8 @@ pub struct Api {
     pub namespace: Option<String>,
     /// API version of the resource
     pub version: String,
+    /// Subresource version of scale (takes precedence)
+    pub scale_version: String,
     /// Name of the api prefix (api or apis typically)
     pub prefix: String,
 
@@ -28,18 +30,12 @@ impl Default for Api {
             namespace: None,
             group: "".into(),
             version: "v1".into(),
+            scale_version: "v1beta2".into(), // not stable yet
             prefix: "apis".into(), // seems most common
         }
     }
 }
 
-impl Debug for Api {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "Api {{ {} {} {} {} {:?} }}", self.resource, self.version,
-            self.group, self.prefix, self.namespace)
-    }
-}
-
 #[allow(non_snake_case)]
 impl Api {
     pub fn within(mut self, ns: &str) -> Self {
@@ -142,14 +138,30 @@ impl Api {
 
 // -------------------------------------------------------
 
+// TODO: set these..
+enum SubResource {
+    Scale,
+    Status,
+}
+impl SubResource {
+    fn version(&self) -> String {
+        match self {
+            SubResource::Scale => "v1beta2".into(),
+            SubResource::Status => "v1beta2".into(),
+        }
+    }
+}
 
-impl ToString for Api
-{
-    fn to_string(&self) -> String {
+impl Api {
+    fn make_url(&self, sub: Option<SubResource>) -> String {
         let pref = if self.prefix == "" { "".into() } else { format!("{}/", self.prefix) };
         let g = if self.group == "" { "".into() } else { format!("{}/", self.group) };
-        let v = if self.version == "" { "".into() } else { format!("{}/", self.version) };
+        let v = match sub {
+            Some(s) => format!("{}/", s.version()),
+            None => format!("{}/", self.version)
+        };
         let n = if let Some(ns) = &self.namespace { format!("namespaces/{}/", ns) } else { "".into() };
+
         format!("/{prefix}{group}{version}{namespaces}{resource}",
             prefix = pref,
             group = g,
@@ -181,7 +193,7 @@ pub struct PostParams {
 impl Api {
     /// Create a list request to fully re-fetch the state
     pub fn list(&self, par: &GetParams) -> Result<http::Request<Vec<u8>>> {
-        let mut qp = url::form_urlencoded::Serializer::new(self.to_string() + "?");
+        let mut qp = url::form_urlencoded::Serializer::new(self.make_url(None) + "?");
 
         if let Some(fields) = &par.field_selector {
             qp.append_pair("fieldSelector", &fields);
@@ -200,7 +212,7 @@ impl Api {
 
     /// Create a minimial list request to seed an initial resourceVersion
     pub(crate) fn list_zero_resource_entries(&self, par: &GetParams) -> Result<http::Request<Vec<u8>>> {
-        let mut qp = url::form_urlencoded::Serializer::new(self.to_string() + "?");
+        let mut qp = url::form_urlencoded::Serializer::new(self.make_url(None) + "?");
         qp.append_pair("limit", "1"); // can't have 0..
         if par.include_uninitialized {
             qp.append_pair("includeUninitialized", "true");
@@ -213,7 +225,7 @@ impl Api {
 
     /// Create watch request for a Api at a given version
     pub(crate) fn watch(&self, par: &GetParams, ver: &str) -> Result<http::Request<Vec<u8>>> {
-        let mut qp = url::form_urlencoded::Serializer::new(self.to_string() + "?");
+        let mut qp = url::form_urlencoded::Serializer::new(self.make_url(None) + "?");
 
         qp.append_pair("watch", "true");
         qp.append_pair("resourceVersion", ver);
@@ -236,14 +248,14 @@ impl Api {
 
     /// Get a single instance
     pub fn get(&self, name: &str) -> Result<http::Request<Vec<u8>>> {
-        let mut qp = url::form_urlencoded::Serializer::new(self.to_string() + "/" + name);
+        let mut qp = url::form_urlencoded::Serializer::new(self.make_url(None) + "/" + name);
         let urlstr = qp.finish();
         let mut req = http::Request::get(urlstr);
         req.body(vec![]).map_err(Error::from)
     }
 
     pub fn create(&self, pp: &PostParams, data: Vec<u8>) -> Result<http::Request<Vec<u8>>> {
-        let mut qp = url::form_urlencoded::Serializer::new(self.to_string() + "?");
+        let mut qp = url::form_urlencoded::Serializer::new(self.make_url(None) + "?");
         if pp.dry_run {
             qp.append_pair("dryRun", "true");
         }
@@ -252,7 +264,7 @@ impl Api {
         req.body(data).map_err(Error::from)
     }
     pub fn replace(&self, name: &str, pp: &PostParams, data: Vec<u8>) -> Result<http::Request<Vec<u8>>> {
-        let base_url = self.to_string() + "/" + name + "?";
+        let base_url = self.make_url(None) + "/" + name + "?";
         let mut qp = url::form_urlencoded::Serializer::new(base_url);
         if pp.dry_run {
             qp.append_pair("dryRun", "true");
@@ -282,7 +294,7 @@ impl Api {
     //}
 
     pub fn patch_status(&self, name: &str, pp: &PostParams, patch: Vec<u8>) -> Result<http::Request<Vec<u8>>> {
-        let base_url = self.to_string() + "/" + name + "/status";
+        let base_url = self.make_url(Some(SubResource::Status)) + "/" + name + "/status";
         let mut qp = url::form_urlencoded::Serializer::new(base_url);
         if pp.dry_run {
             qp.append_pair("dryRun", "true");
@@ -293,7 +305,7 @@ impl Api {
     }
 
     pub fn replace_status(&self, name: &str, pp: &PostParams, data: Vec<u8>) -> Result<http::Request<Vec<u8>>> {
-        let base_url = self.to_string() + "/" + name + "/status";
+        let base_url = self.make_url(Some(SubResource::Status)) + "/" + name + "/status";
         let mut qp = url::form_urlencoded::Serializer::new(base_url);
         if pp.dry_run {
             qp.append_pair("dryRun", "true");
@@ -348,7 +360,7 @@ fn patch_status_path(){
     let r = Api::v1Node();
     let pp = PostParams::default();
     let req = r.patch_status("mynode", &pp, vec![]).unwrap();
-    assert_eq!(req.uri(), "/api/v1/nodes/mynode/status");
+    assert_eq!(req.uri(), "/api/v1beta2/nodes/mynode/status");
     assert_eq!(req.method(), "PATCH");
 }
 #[test]

src/api/resource.rs

@@ -144,6 +144,7 @@ pub enum PostResponse<T> where
     Error, // Unauthorized or other
 }
 
+
 /// Generic post response object
 ///
 /// Returned from create new
@@ -156,6 +157,8 @@ pub enum CreateResponse<T> where
     Accepted(T), // StatusCode::ACCEPTED
     Error, // Unauthorized or other
 }
+// NB: 409 CONFLICT returned when already exists..
+
 
 /// Generic response object
 ///