Untested Centos provider for Telemetry

petehayes102 · petehayes102 · commit 083e63a82e52 · 2017-09-26T22:56:20.000+01:00
diff --git a/core/src/errors.rs b/core/src/errors.rs
@@ -6,9 +6,12 @@
 
 error_chain! {
     errors {
-        InvalidSysctlKey(k: String) {
-            description("Provided key not found in sysctl output"),
-            display("Provided key '{}' not found in sysctl output", k),
+        InvalidTelemetryKey {
+            cmd: &'static str,
+            key: String,
+        } {
+            description("Provided key not found in output"),
+            display("Provided key '{}' not found in {} output", key, cmd),
         }
 
         ProviderUnavailable(p: &'static str) {
@@ -18,7 +21,7 @@ error_chain! {
 
         RemoteProvider {
             endpoint: &'static str,
-            func: &'static str
+            func: &'static str,
         } {
             description("Could not run provider function on host"),
             display("Could not run {}::{}() on host", endpoint, func),
diff --git a/core/src/target/linux.rs b/core/src/target/linux.rs
@@ -0,0 +1,56 @@
+// Copyright 2015-2017 Intecture Developers.
+//
+// Licensed under the Mozilla Public License 2.0 <LICENSE or
+// https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
+// modified, or distributed except according to those terms.
+
+use errors::*;
+use regex::Regex;
+use std::{fs, process, str};
+use std::io::Read;
+
+pub fn cpu_vendor() -> Result<String> {
+    get_cpu_item("vendor_id")
+}
+
+pub fn cpu_brand_string() -> Result<String> {
+    get_cpu_item("model name")
+}
+
+pub fn cpu_cores() -> Result<u32> {
+    Ok(get_cpu_item("cpu cores")?
+        .parse::<u32>()
+        .chain_err(|| ErrorKind::InvalidTelemetryKey {
+            cmd: "/proc/cpuinfo",
+            key: "cpu cores".into()
+        })?)
+}
+
+fn get_cpu_item(item: &str) -> Result<String> {
+    // @todo Cache file content
+    let mut fh = fs::File::open("/proc/cpuinfo").chain_err(|| ErrorKind::SystemFile("/proc/cpuinfo"))?;
+    let mut cpuinfo = String::new();
+    fh.read_to_string(&mut cpuinfo).chain_err(|| ErrorKind::SystemFileOutput("/proc/cpuinfo"))?;;
+
+    let pattern = format!(r"(?m)^{}\s+: (.+)$", item);
+    let regex = Regex::new(&pattern).unwrap();
+    let capture = regex.captures(&cpuinfo);
+
+    if let Some(cap) = capture {
+        Ok(cap.get(1).unwrap().as_str().to_string())
+    } else {
+        Err(ErrorKind::InvalidTelemetryKey { cmd: "/proc/cpuinfo", key: item.into() }.into())
+    }
+}
+
+pub fn memory() -> Result<u64> {
+    let output = process::Command::new("free").arg("-b").output().chain_err(|| ErrorKind::SystemCommand("free"))?;
+    let regex = Regex::new(r"(?m)^Mem:\s+([0-9]+)").chain_err(|| "could not create new Regex instance")?;
+    let capture = regex.captures(str::from_utf8(&output.stdout).chain_err(|| ErrorKind::SystemCommandOutput("free"))?.trim());
+
+    if let Some(cap) = capture {
+        Ok(cap.get(1).unwrap().as_str().parse::<u64>().chain_err(|| ErrorKind::SystemFileOutput("/etc/redhat-release"))?)
+    } else {
+        Err(ErrorKind::SystemCommandOutput("free").into())
+    }
+}
diff --git a/core/src/target/mod.rs b/core/src/target/mod.rs
@@ -5,4 +5,6 @@
 // modified, or distributed except according to those terms.
 
 pub mod default;
+pub mod linux;
+pub mod redhat;
 pub mod unix;
diff --git a/core/src/target/redhat.rs b/core/src/target/redhat.rs
@@ -0,0 +1,34 @@
+// Copyright 2015-2017 Intecture Developers.
+//
+// Licensed under the Mozilla Public License 2.0 <LICENSE or
+// https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
+// modified, or distributed except according to those terms.
+
+use errors::*;
+use regex::Regex;
+use std::fs;
+use std::io::Read;
+
+pub fn version() -> Result<(String, u32, u32, u32)> {
+    let mut fh = fs::File::open("/etc/redhat-release").chain_err(|| ErrorKind::SystemFile("/etc/redhat-release"))?;
+    let mut fc = String::new();
+    fh.read_to_string(&mut fc).unwrap();
+
+    let regex = Regex::new(r"release ([0-9]+)(?:\.([0-9]+)(?:\.([0-9]+))?)?").unwrap();
+    if let Some(cap) = regex.captures(&fc) {
+        let version_maj = cap.get(1).unwrap().as_str()
+                             .parse().chain_err(|| ErrorKind::SystemFileOutput("/etc/redhat-release"))?;
+        let version_min = match cap.get(2) {
+            Some(v) => v.as_str().parse().chain_err(|| ErrorKind::SystemFileOutput("/etc/redhat-release"))?,
+            None => 0,
+        };
+        let version_patch = match cap.get(3) {
+            Some(v) => v.as_str().parse().chain_err(|| ErrorKind::SystemFileOutput("/etc/redhat-release"))?,
+            None => 0,
+        };
+        let version_str = format!("{}.{}.{}", version_maj, version_min, version_patch);
+        Ok((version_str, version_maj, version_min, version_patch))
+    } else {
+        Err(ErrorKind::SystemFileOutput("/etc/redhat-release").into())
+    }
+}
diff --git a/core/src/target/unix.rs b/core/src/target/unix.rs
@@ -29,7 +29,7 @@ pub fn version() -> Result<(String, u32, u32)> {
                                   .output()
                                   .chain_err(|| ErrorKind::SystemCommand("uname"))?;
     let version_str = str::from_utf8(&output.stdout).unwrap().trim();
-    let regex = Regex::new(r"([0-9]+)\.([0-9]+)-[A-Z]+").unwrap();
+    let regex = Regex::new(r"([0-9]+)\.([0-9]+)-[A-Z]+").chain_err(|| "could not create new Regex instance")?;
     let errstr = format!("Expected OS version format `u32.u32`, got: '{}'", version_str);
     if let Some(cap) = regex.captures(version_str) {
         let version_maj = cap.get(1).unwrap().as_str().parse().chain_err(|| ErrorKind::SystemCommandOutput("uname"))?;
@@ -54,6 +54,6 @@ pub fn get_sysctl_item(item: &str) -> Result<String> {
     if let Some(cap) = regex.captures(&sysctl) {
         Ok(cap.get(1).unwrap().as_str().into())
     } else {
-        Err(ErrorKind::InvalidSysctlKey(item.into()).into())
+        Err(ErrorKind::InvalidTelemetryKey { cmd: "sysctl", key: item.into() }.into())
     }
 }
diff --git a/core/src/telemetry/mod.rs b/core/src/telemetry/mod.rs
@@ -9,14 +9,14 @@
 mod providers;
 mod serializable;
 
-pub use self::providers::Macos;
+pub use self::providers::{Centos, Freebsd, Macos};
 
 use erased_serde::Serialize;
 use errors::*;
 use ExecutableProvider;
 use host::Host;
 use pnet::datalink::NetworkInterface;
-use self::providers::MacosRemoteProvider;
+use self::providers::{CentosRemoteProvider, FreebsdRemoteProvider, MacosRemoteProvider};
 
 pub trait TelemetryProvider {
     fn available(&Host) -> bool where Self: Sized;
@@ -25,12 +25,16 @@ pub trait TelemetryProvider {
 
 #[derive(Serialize, Deserialize)]
 pub enum RemoteProvider {
-    Macos(MacosRemoteProvider)
+    Centos(CentosRemoteProvider),
+    Freebsd(FreebsdRemoteProvider),
+    Macos(MacosRemoteProvider),
 }
 
 impl <'de>ExecutableProvider<'de> for RemoteProvider {
     fn exec(&self, host: &Host) -> Result<Box<Serialize>> {
         match *self {
+            RemoteProvider::Centos(ref p) => p.exec(host),
+            RemoteProvider::Freebsd(ref p) => p.exec(host),
             RemoteProvider::Macos(ref p) => p.exec(host)
         }
     }
@@ -66,16 +70,40 @@ pub struct FsMount {
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Os {
     pub arch: String,
-    pub family: String,
-    pub platform: String,
+    pub family: OsFamily,
+    pub platform: OsPlatform,
     pub version_str: String,
     pub version_maj: u32,
     pub version_min: u32,
     pub version_patch: u32,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+pub enum OsFamily {
+    Bsd,
+    Darwin,
+    Linux,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub enum OsPlatform {
+    Centos,
+    Debian,
+    Fedora,
+    Freebsd,
+    Macos,
+    Nixos,
+    Ubuntu,
+}
+
 pub fn load(host: &Host) -> Result<Telemetry> {
-    if Macos::available(host) {
+    if Centos::available(host) {
+        Centos::load(host)
+    }
+    else if Freebsd::available(host) {
+        Freebsd::load(host)
+    }
+    else if Macos::available(host) {
         Macos::load(host)
     } else {
         Err(ErrorKind::ProviderUnavailable("Telemetry").into())
diff --git a/core/src/telemetry/providers/centos.rs b/core/src/telemetry/providers/centos.rs
@@ -0,0 +1,84 @@
+// Copyright 2015-2017 Intecture Developers.
+//
+// Licensed under the Mozilla Public License 2.0 <LICENSE or
+// https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
+// modified, or distributed except according to those terms.
+
+use erased_serde::Serialize;
+use errors::*;
+use ExecutableProvider;
+use host::*;
+use pnet::datalink::interfaces;
+use std::{env, str};
+use target::{default, linux, redhat};
+use telemetry::{Cpu, Os, OsFamily, OsPlatform, Telemetry, TelemetryProvider, serializable};
+
+pub struct Centos;
+
+#[derive(Serialize, Deserialize)]
+pub enum RemoteProvider {
+    Available,
+    Load,
+}
+
+impl <'de>ExecutableProvider<'de> for RemoteProvider {
+    fn exec(&self, host: &Host) -> Result<Box<Serialize>> {
+        match *self {
+            RemoteProvider::Available => Ok(Box::new(Centos::available(host))),
+            RemoteProvider::Load => {
+                let t: serializable::Telemetry = Centos::load(host)?.into();
+                Ok(Box::new(t))
+            },
+        }
+    }
+}
+
+impl TelemetryProvider for Centos {
+    fn available(host: &Host) -> bool {
+        if host.is_local() {
+            cfg!(target_os="linux")
+        } else {
+            unimplemented!();
+            // let r = RemoteProvider::Available;
+            // self.host.send(r).chain_err(|| ErrorKind::RemoteProvider("Telemetry", "available"))?;
+            // let t: Telemetry = self.host.recv()?;
+            // Ok(t)
+        }
+    }
+
+    fn load(host: &Host) -> Result<Telemetry> {
+        if host.is_local() {
+            let cpu_vendor = linux::cpu_vendor()?;
+            let cpu_brand = linux::cpu_brand_string()?;
+            let hostname = default::hostname()?;
+            let (version_str, version_maj, version_min, version_patch) = redhat::version()?;
+
+            Ok(Telemetry {
+                cpu: Cpu {
+                    vendor: cpu_vendor,
+                    brand_string: cpu_brand,
+                    cores: linux::cpu_cores()?,
+                },
+                fs: default::fs().chain_err(|| "could not resolve telemetry data")?,
+                hostname: hostname,
+                memory: linux::memory().chain_err(|| "could not resolve telemetry data")?,
+                net: interfaces(),
+                os: Os {
+                    arch: env::consts::ARCH.into(),
+                    family: OsFamily::Linux,
+                    platform: OsPlatform::Centos,
+                    version_str: version_str,
+                    version_maj: version_maj,
+                    version_min: version_min,
+                    version_patch: version_patch
+                },
+            })
+        } else {
+            unimplemented!();
+            // let r = RemoteProvider::Load;
+            // self.host.send(r).chain_err(|| ErrorKind::RemoteProvider("Telemetry", "load"))?;
+            // let t: Telemetry = self.host.recv()?;
+            // Ok(t)
+        }
+    }
+}
diff --git a/core/src/telemetry/providers/freebsd.rs b/core/src/telemetry/providers/freebsd.rs
@@ -13,7 +13,7 @@ use regex::Regex;
 use std::{env, fs, str};
 use std::io::Read;
 use target::{default, unix};
-use telemetry::{Cpu, Os, Telemetry, TelemetryProvider, serializable};
+use telemetry::{Cpu, Os, OsFamily, OsPlatform, Telemetry, TelemetryProvider, serializable};
 
 pub struct Freebsd;
 
@@ -73,8 +73,8 @@ impl TelemetryProvider for Freebsd {
                 net: interfaces(),
                 os: Os {
                     arch: env::consts::ARCH.into(),
-                    family: "bsd".into(),
-                    platform: "freebsd".into(),
+                    family: OsFamily::Bsd,
+                    platform: OsPlatform::Freebsd,
                     version_str: version_str,
                     version_maj: version_maj,
                     version_min: version_min,
@@ -95,7 +95,7 @@ fn telemetry_cpu_vendor() -> Result<String> {
     let mut fh = fs::File::open("/var/run/dmesg.boot")
                           .chain_err(|| ErrorKind::SystemFile("/var/run/dmesg.boot"))?;
     let mut fc = String::new();
-    fh.read_to_string(&mut fc).unwrap();
+    fh.read_to_string(&mut fc).chain_err(|| ErrorKind::SystemFileOutput("/var/run/dmesg.boot"))?;
 
     let regex = Regex::new(r#"(?m)^CPU:.+$\n\s+Origin="([A-Za-z]+)""#).unwrap();
     if let Some(cap) = regex.captures(&fc) {
diff --git a/core/src/telemetry/providers/macos.rs b/core/src/telemetry/providers/macos.rs
@@ -11,7 +11,7 @@ use host::*;
 use pnet::datalink::interfaces;
 use std::{env, process, str};
 use target::{default, unix};
-use telemetry::{Cpu, Os, Telemetry, TelemetryProvider, serializable};
+use telemetry::{Cpu, Os, OsFamily, OsPlatform, Telemetry, TelemetryProvider, serializable};
 
 pub struct Macos;
 
@@ -81,8 +81,8 @@ impl TelemetryProvider for Macos {
                 net: interfaces(),
                 os: Os {
                     arch: env::consts::ARCH.into(),
-                    family: "darwin".into(),
-                    platform: "macos".into(),
+                    family: OsFamily::Darwin,
+                    platform: OsPlatform::Macos,
                     version_str: version_str,
                     version_maj: version_maj,
                     version_min: version_min,
diff --git a/core/src/telemetry/providers/mod.rs b/core/src/telemetry/providers/mod.rs
@@ -4,8 +4,10 @@
 // https://www.tldrlegal.com/l/mpl-2.0>. This file may not be copied,
 // modified, or distributed except according to those terms.
 
+mod centos;
 mod freebsd;
 mod macos;
 
+pub use self::centos::{Centos, RemoteProvider as CentosRemoteProvider};
 pub use self::freebsd::{Freebsd, RemoteProvider as FreebsdRemoteProvider};
 pub use self::macos::{Macos, RemoteProvider as MacosRemoteProvider};
