Use serde to deserialize targets

Author: puetzp

src/client.rs

@@ -4,7 +4,7 @@ use crate::error::{
 };
 use crate::response::*;
 use crate::selector::Selector;
-use crate::util::{validate_duration, TargetHealth, TargetState};
+use crate::util::{validate_duration, TargetState};
 use std::collections::HashMap;
 
 /// A helper enum that is passed to the [Client::new] function in
@@ -561,52 +561,9 @@ fn parse_target_response(response: HashMap<String, serde_json::Value>) -> Result
 
     match status {
         "success" => {
-            let data_obj = response["data"].as_object().unwrap();
-            let mut active = vec![];
-            let mut dropped = vec![];
-
-            for target in data_obj["activeTargets"].as_array().unwrap() {
-                let target_obj = target.as_object().unwrap();
-                let discovered_labels =
-                    parse_metric(target_obj["discoveredLabels"].as_object().unwrap());
-                let labels = parse_metric(target_obj["labels"].as_object().unwrap());
-                let scrape_pool = target_obj["scrapePool"].as_str().unwrap().to_string();
-                let scrape_url = target_obj["scrapeUrl"].as_str().unwrap().to_string();
-                let global_url = target_obj["globalUrl"].as_str().unwrap().to_string();
-                let last_error = target_obj["lastError"].as_str().unwrap().to_string();
-                let last_scrape = target_obj["lastScrape"].as_str().unwrap().to_string();
-                let last_scrape_duration = target_obj["lastScrapeDuration"].as_f64().unwrap();
-
-                let health = match target_obj["health"].as_str().unwrap() {
-                    "up" => TargetHealth::Up,
-                    "down" => TargetHealth::Down,
-                    "unknown" => TargetHealth::Unknown,
-                    _ => unreachable!(),
-                };
-
-                active.push(ActiveTarget {
-                    discovered_labels,
-                    labels,
-                    scrape_pool,
-                    scrape_url,
-                    global_url,
-                    last_error,
-                    last_scrape,
-                    last_scrape_duration,
-                    health,
-                });
-            }
-
-            for target in data_obj["droppedTargets"].as_array().unwrap() {
-                let target_obj = target.as_object().unwrap();
-                let discovered_labels =
-                    parse_metric(target_obj["discoveredLabels"].as_object().unwrap());
-                dropped.push(DroppedTarget(discovered_labels));
-            }
-
-            let result = Targets { active, dropped };
-
-            Ok(Response::Targets(result))
+            let raw_targets = response["data"].to_owned();
+            let targets: Targets = serde_json::from_value(raw_targets).unwrap();
+            Ok(Response::Targets(targets))
         }
         "error" => {
             return Err(Error::ResponseError(ResponseError {

src/response.rs

@@ -76,9 +76,11 @@ impl Sample {
 }
 
 /// Collection of active and dropped targets as returned by the API.
-#[derive(Debug)]
+#[derive(Debug, Deserialize)]
 pub struct Targets {
+    #[serde(alias = "activeTargets")]
     pub(crate) active: Vec<ActiveTarget>,
+    #[serde(alias = "droppedTargets")]
     pub(crate) dropped: Vec<DroppedTarget>,
 }
 
@@ -95,15 +97,22 @@ impl Targets {
 }
 
 /// A single active target.v
-#[derive(Debug)]
+#[derive(Debug, Deserialize)]
 pub struct ActiveTarget {
+    #[serde(alias = "discoveredLabels")]
     pub(crate) discovered_labels: HashMap<String, String>,
     pub(crate) labels: HashMap<String, String>,
+    #[serde(alias = "scrapePool")]
     pub(crate) scrape_pool: String,
+    #[serde(alias = "scrapeUrl")]
     pub(crate) scrape_url: String,
+    #[serde(alias = "globalUrl")]
     pub(crate) global_url: String,
+    #[serde(alias = "lastError")]
     pub(crate) last_error: String,
+    #[serde(alias = "lastScrape")]
     pub(crate) last_scrape: String,
+    #[serde(alias = "lastScrapeDuration")]
     pub(crate) last_scrape_duration: f64,
     pub(crate) health: TargetHealth,
 }
@@ -156,13 +165,15 @@ impl ActiveTarget {
 }
 
 /// A single dropped target.
-#[derive(Debug)]
-pub struct DroppedTarget(pub(crate) HashMap<String, String>);
+#[derive(Debug, Deserialize)]
+pub struct DroppedTarget {
+    #[serde(alias = "discoveredLabels")]
+    pub(crate) discovered_labels: HashMap<String, String>,
+}
 
 impl DroppedTarget {
     /// Get a list of unmodified labels as before relabelling occurred.
     pub fn discovered_labels(&self) -> &HashMap<String, String> {
-        let DroppedTarget(discovered_labels) = self;
-        discovered_labels
+        &self.discovered_labels
     }
 }

src/util.rs

@@ -74,10 +74,13 @@ impl fmt::Display for TargetState {
 }
 
 /// A helper type to represent possible target health states.
-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, serde::Deserialize)]
 pub enum TargetHealth {
+    #[serde(alias = "up")]
     Up,
+    #[serde(alias = "down")]
     Down,
+    #[serde(alias = "unknown")]
     Unknown,
 }