Merge pull request #1 from SDS/vmax_properties

Vmax properties

Author: cholco202

src/lib.rs

@@ -14,9 +14,9 @@ extern crate xml_attributes_derive;
 pub mod brocade;
 pub mod error;
 pub mod hitachi;
-pub mod netapp;
 pub mod ir;
 pub mod isilon;
+pub mod netapp;
 pub mod scaleio;
 pub mod solidfire;
 pub mod telegraf;
@@ -27,3 +27,7 @@ pub mod xtremio;
 pub trait IntoPoint {
     fn into_point(&self, name: Option<&str>) -> Vec<ir::TsPoint>;
 }
+
+pub trait ChildPoint {
+    fn sub_point(&self, p: &mut ir::TsPoint);
+}

src/vmax.rs

@@ -4,6 +4,7 @@ extern crate serde;
 extern crate serde_json;
 
 use error::MetricsResult;
+use ChildPoint;
 use IntoPoint;
 
 use std::fmt::Debug;
@@ -39,16 +40,16 @@ fn get_data<T>(
 where
     T: DeserializeOwned + Debug + IntoPoint,
 {
-    let j: T = client
+    let mut j = client
         .get(&format!(
             "https://{}/univmax/restapi/{}",
             config.endpoint, api_endpoint,
         ))
         .basic_auth(config.user.clone(), Some(config.password.clone()))
         .send()?
-        .error_for_status()?
-        .json()?;
-    Ok(j.into_point(Some(point_name)))
+        .error_for_status()?;
+    let deserialized: T = j.json()?;
+    Ok(deserialized.into_point(Some(point_name)))
 }
 
 /* Changed the GET to POST and added body parameter to pass additional fields to
@@ -962,4 +963,196 @@ fn test_get_per_array_storagegroup_metrics() {
     let i: StorageGroupArrayMetrics = serde_json::from_str(&buff).unwrap();
     println!("result: {:#?}", i);
 }
-//END Section for Test Functions
+
+//For Collecting the VMAX Array System Properties Metrics. This includes the RAW array values for capacity
+//which is found in the GUI Unisphere --> Array --> System --> Symmetrix Properties
+//https://[username]:[password]@[Unisphere Server]:8443/univmax/restapi/90/sloprovisioning/symmetrix/[Array S/N]
+#[test]
+fn test_get_slo_provisioning_system_properties() {
+    use std::fs::File;
+    use std::io::Read;
+
+    let mut f = File::open("tests/vmax/slo_provisioning_system_properties.json").unwrap();
+    let mut buff = String::new();
+    f.read_to_string(&mut buff).unwrap();
+
+    let i: VmaxSystemCapacity = serde_json::from_str(&buff).unwrap();
+    println!("result: {:#?}", i);
+}
+// END Section for Test Functions
+
+// This function is for get_data only, the get_list was not needed. Note the '90' for v9 of the EMC Unisphere software
+pub fn get_vmax_array_raw(
+    client: &reqwest::Client,
+    config: &VmaxConfig,
+    symmetrixid: &str,
+) -> MetricsResult<Vec<TsPoint>> {
+    let vmax_raw = get_data::<VmaxSystemCapacity>(
+        client,
+        config,
+        &format!("90/sloprovisioning/symmetrix/{}", symmetrixid),
+        "vmax_array_raw",
+    )?;
+    debug!("result: {:#?}", vmax_raw);
+    Ok(vmax_raw)
+}
+
+// This is split into objects and sub-objects based upon the new Unisphere release v9
+#[derive(Debug, Deserialize)]
+pub struct VmaxSystemCapacity {
+    #[serde(rename = "symmetrixId")]
+    pub symmetrix_id: String,
+    pub device_count: u64,
+    pub ucode: String,
+    pub model: String,
+    pub local: bool,
+    pub default_fba_srp: String,
+    pub host_visible_device_count: u64,
+    pub system_capacity: SystemCapacity,
+    pub system_efficiency: SystemEfficiency,
+    pub meta_data_usage: MetaDataUsage,
+    #[serde(rename = "sloCompliance")]
+    pub slo_compliance: SloComplianceSys,
+    #[serde(rename = "physicalCapacity")]
+    pub physical_capacity: PhysicalCapacity,
+}
+
+impl IntoPoint for VmaxSystemCapacity {
+    fn into_point(&self, name: Option<&str>) -> Vec<TsPoint> {
+        let mut p = TsPoint::new(name.unwrap_or("unknown"));
+        p.add_tag("symmetrix_id", TsValue::String(self.symmetrix_id.clone()));
+        p.add_field("device_count", TsValue::Long(self.device_count));
+        p.add_field("ucode", TsValue::String(self.ucode.clone()));
+        p.add_field("model", TsValue::String(self.model.clone()));
+        p.add_field("local", TsValue::Boolean(self.local.clone()));
+        p.add_tag(
+            "default_fba_srp",
+            TsValue::String(self.default_fba_srp.clone()),
+        );
+        p.add_field(
+            "host_visible_device_count",
+            TsValue::Long(self.host_visible_device_count),
+        );
+        self.system_capacity.sub_point(&mut p);
+        self.system_efficiency.sub_point(&mut p);
+        self.meta_data_usage.sub_point(&mut p);
+        self.slo_compliance.sub_point(&mut p);
+        self.physical_capacity.sub_point(&mut p);
+        vec![p]
+    }
+}
+
+#[allow(non_snake_case)]
+#[derive(Debug, Deserialize)]
+pub struct SystemCapacity {
+    pub subscribed_allocated_tb: f64,
+    pub subscribed_total_tb: f64,
+    pub snapshot_modified_tb: f64,
+    pub snapshot_total_tb: f64,
+    pub usable_used_tb: f64,
+    pub usable_total_tb: f64,
+    pub subscribed_usable_capacity_percent: f64,
+}
+
+// This implements a new impl for sub_point based upon EMC metrics
+// Use a tags for the those metrics defined as String value and field for the remaining, but not both
+impl ChildPoint for SystemCapacity {
+    fn sub_point(&self, p: &mut TsPoint) {
+        p.add_field(
+            "subscribed_allocated_tb",
+            TsValue::Float(self.subscribed_allocated_tb),
+        );
+        p.add_field(
+            "subscribed_total_tb",
+            TsValue::Float(self.subscribed_total_tb),
+        );
+        p.add_field(
+            "snapshot_modified_tb",
+            TsValue::Float(self.snapshot_modified_tb),
+        );
+        p.add_field("snapshot_total_tb", TsValue::Float(self.snapshot_total_tb));
+        p.add_field("usable_used_tb", TsValue::Float(self.usable_used_tb));
+        p.add_field("usable_total_tb", TsValue::Float(self.usable_total_tb));
+        p.add_field(
+            "subscribed_usable_capacity_percent",
+            TsValue::Float(self.subscribed_usable_capacity_percent),
+        );
+    }
+}
+
+#[allow(non_snake_case)]
+#[derive(Debug, Deserialize)]
+pub struct SystemEfficiency {
+    pub overall_efficiency_ratio_to_one: f64,
+    pub data_reduction_enabled_percent: f64,
+    pub virtual_provisioning_savings_ratio_to_one: f64,
+}
+
+impl ChildPoint for SystemEfficiency {
+    fn sub_point(&self, p: &mut TsPoint) {
+        p.add_field(
+            "overall_efficiency_ratio_to_one",
+            TsValue::Float(self.overall_efficiency_ratio_to_one),
+        );
+        p.add_field(
+            "data_reduction_enabled_percent",
+            TsValue::Float(self.data_reduction_enabled_percent),
+        );
+        p.add_field(
+            "virtual_provisioning_savings_ratio_to_one",
+            TsValue::Float(self.virtual_provisioning_savings_ratio_to_one),
+        );
+    }
+}
+
+#[allow(non_snake_case)]
+#[derive(Debug, Deserialize)]
+pub struct MetaDataUsage {
+    pub system_meta_data_used_percent: f64,
+    pub replication_cache_used_percent: u64,
+}
+
+impl ChildPoint for MetaDataUsage {
+    fn sub_point(&self, p: &mut TsPoint) {
+        p.add_field(
+            "system_meta_data_used_percent",
+            TsValue::Float(self.system_meta_data_used_percent),
+        );
+        p.add_field(
+            "replication_cache_used_percent",
+            TsValue::Long(self.replication_cache_used_percent),
+        );
+    }
+}
+
+#[allow(non_snake_case)]
+#[derive(Debug, Deserialize)]
+pub struct SloComplianceSys {
+    pub slo_stable: i64,
+    pub slo_marginal: i64,
+    pub slo_critical: i64,
+    pub no_slo: i64,
+}
+
+impl ChildPoint for SloComplianceSys {
+    fn sub_point(&self, p: &mut TsPoint) {
+        p.add_field("slo_stable", TsValue::SignedLong(self.slo_stable));
+        p.add_field("slo_marginal", TsValue::SignedLong(self.slo_marginal));
+        p.add_field("slo_critical", TsValue::SignedLong(self.slo_critical));
+        p.add_field("no_slo", TsValue::SignedLong(self.no_slo));
+    }
+}
+
+#[allow(non_snake_case)]
+#[derive(Debug, Deserialize)]
+pub struct PhysicalCapacity {
+    pub used_capacity_gb: f64,
+    pub total_capacity_gb: f64,
+}
+
+impl ChildPoint for PhysicalCapacity {
+    fn sub_point(&self, p: &mut TsPoint) {
+        p.add_field("used_capacity_gb", TsValue::Float(self.used_capacity_gb));
+        p.add_field("total_capacity_gb", TsValue::Float(self.total_capacity_gb));
+    }
+}

tests/vmax/slo_provisioning_system_properties.json

@@ -0,0 +1,37 @@
+{
+    "symmetrixId": "000196702346",
+    "device_count": 3470,
+    "ucode": "5977.1125.1125",
+    "model": "VMAX200K",
+    "local": true,
+    "default_fba_srp": "SRP_1",
+    "system_capacity": {
+        "subscribed_allocated_tb": 439.53,
+        "subscribed_total_tb": 693.84,
+        "snapshot_modified_tb": 0,
+        "snapshot_total_tb": 0,
+        "usable_used_tb": 440.74,
+        "usable_total_tb": 1070.61,
+        "subscribed_usable_capacity_percent": 65
+    },
+    "system_efficiency": {
+        "overall_efficiency_ratio_to_one": 1.6,
+        "data_reduction_enabled_percent": 0,
+        "virtual_provisioning_savings_ratio_to_one": 1.6
+    },
+    "meta_data_usage": {
+        "system_meta_data_used_percent": 56,
+        "replication_cache_used_percent": 0
+    },
+    "sloCompliance": {
+        "slo_stable": 4,
+        "slo_marginal": 0,
+        "slo_critical": 0,
+        "no_slo": 78
+    },
+    "physicalCapacity": {
+        "used_capacity_gb": 1325680.37,
+        "total_capacity_gb": 1325680.37
+    },
+    "host_visible_device_count": 2078
+}