Make context check for outdated /etc/hosts

Author: nicholastmosher

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "k8-config"
-version = "1.1.1"
+version = "1.2.0"
 authors = ["Fluvio Contributors <[email protected]>"]
 edition = "2018"
 description = "Read Kubernetes config"
@@ -13,7 +13,8 @@ context = ["tera"]
 [dependencies]
 log = "0.4.8"
 dirs = "2.0.2"
-serde = { version ="1.0.103", features = ['derive'] }
+serde = { version = "1.0.103", features = ['derive'] }
 serde_yaml = "0.8.9"
+serde_json = "1.0.57"
 tera = { version = "1.3.0", optional = true }
-
+hostfile = "0.2.0"

src/k8-config/Cargo.toml

@@ -1,6 +1,16 @@
+use std::env;
+use std::io::Write;
+use std::fs::OpenOptions;
+use std::net::IpAddr;
+use std::os::unix::fs::OpenOptionsExt;
+use std::process::{Command, Stdio};
+
+use serde::Deserialize;
 use log::debug;
+use tera::Context;
+use tera::Tera;
 
-use crate::K8Config;
+use crate::{K8Config, ConfigError};
 
 fn load_cert_auth() -> String {
     let k8_config = K8Config::load().expect("loading");
@@ -25,71 +35,234 @@ fn load_cert_auth() -> String {
         .to_string()
 }
 
-pub struct Option {
-    pub ctx_name: String,
+/// Configuration options to wire up Fluvio on Minikube
+pub struct MinikubeContext {
+    name: String,
+    profile: MinikubeProfile,
 }
 
-impl Default for Option {
-    fn default() -> Self {
-        Option {
-            ctx_name: "flvkube".to_owned(),
+impl MinikubeContext {
+    /// Attempts to derive a `MinikubeContext` from the system
+    ///
+    /// This requires the presence of the `minikube` executable,
+    /// which will tell us the current IP and port that minikube
+    /// is running on.
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use k8_config::context::MinikubeContext;
+    /// let context = MinikubeContext::try_from_system().unwrap();
+    /// ```
+    pub fn try_from_system() -> Result<Self, ConfigError> {
+        Ok(Self {
+            name: "flvkube".to_string(),
+            profile: MinikubeProfile::load()?,
+        })
+    }
+
+    /// Sets the name of the context
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use k8_config::context::MinikubeContext;
+    /// let context = MinikubeContext::try_from_system().unwrap()
+    ///     .with_name("my-minikube");
+    /// ```
+    pub fn with_name<S: Into<String>>(mut self, name: S) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Saves the Minikube context for kubectl and updates the minikube IP
+    ///
+    /// # Example
+    ///
+    /// ```no_run
+    /// use k8_config::context::MinikubeContext;
+    /// let context = MinikubeContext::try_from_system().unwrap();
+    /// context.save().unwrap();
+    /// ```
+    pub fn save(&self) -> Result<(), ConfigError> {
+        // Check if the detected minikube IP matches the /etc/hosts entry
+        if !self.profile.matches_hostfile()? {
+            // If the /etc/hosts file is not up to date, update it
+            debug!("hosts file is outdated: updating");
+            self.update_hosts()?;
         }
+        self.update_kubectl_context()?;
+        Ok(())
     }
-}
 
-/// create kube context that copy current cluster configuration
-pub fn create_dns_context(option: Option) {
-    const TEMPLATE: &'static str = r#"
+    /// Updates the `kubectl` context to use the current settings
+    fn update_kubectl_context(&self) -> Result<(), ConfigError> {
+        Command::new("kubectl")
+            .args(&["config", "set-cluster", &self.name])
+            .arg(&format!("--server=https://minikubeCA:{}", self.profile.port()))
+            .arg(&format!("--certificate-authority={}", load_cert_auth()))
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .status()?;
+
+        Command::new("kubectl")
+            .args(&["config", "set-context", &self.name])
+            .arg("--user=minikube")
+            .arg(&format!("--cluster={}", &self.name))
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .status()?;
+
+        Command::new("kubectl")
+            .args(&["config", "use-context", &self.name])
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .status()?;
+
+        Ok(())
+    }
+
+    /// Updates the `/etc/hosts` file by rewriting the line with `minikubeCA`
+    fn update_hosts(&self) -> Result<(), ConfigError> {
+        const TEMPLATE: &'static str = r#"
 #!/bin/bash
-export IP=$(minikube ip)
-sudo sed -i '' '/minikubeCA/d' /etc/hosts
+# Get IP from context, if available
+export IP={{ ip }}
+# If there is no IP in context, use "minikube ip"
+export IP="${IP:-$(minikube ip)}"
+sudo sed -i'' -e '/minikubeCA/d' /etc/hosts
 echo "$IP minikubeCA" | sudo tee -a  /etc/hosts
-cd ~
-kubectl config set-cluster {{ name }} --server=https://minikubeCA:8443 --certificate-authority={{ ca }}
-kubectl config set-context {{ name }} --user=minikube --cluster={{ name }}
-kubectl config use-context {{ name }}
 "#;
 
-    use std::env;
-    use std::fs::OpenOptions;
-    use std::io;
-    use std::io::Write;
-    use std::os::unix::fs::OpenOptionsExt;
-    use std::process::Command;
+        let mut tera = Tera::default();
+        tera.add_raw_template("cube.sh", TEMPLATE)
+            .expect("string compilation");
+
+        let mut context = Context::new();
+        context.insert("ip", &self.profile.ip());
+
+        let render = tera.render("cube.sh", &context).expect("rendering");
+        let tmp_file = env::temp_dir().join("flv_minikube.sh");
+
+        let mut file = OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .mode(0o755)
+            .open(tmp_file.clone())
+            .expect("temp script can't be created");
+
+        file.write_all(render.as_bytes())
+            .expect("file write failed");
 
-    use tera::Context;
-    use tera::Tera;
+        file.sync_all().expect("sync");
+        drop(file);
 
-    let mut tera = Tera::default();
+        debug!("script {}", render);
 
-    tera.add_raw_template("cube.sh", TEMPLATE)
-        .expect("string compilation");
+        Command::new(tmp_file)
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .status()?;
 
-    let mut context = Context::new();
-    context.insert("name", &option.ctx_name);
-    context.insert("ca", &load_cert_auth());
+        Ok(())
+    }
+}
 
-    let render = tera.render("cube.sh", &context).expect("rendering");
+#[derive(Debug, Deserialize)]
+struct MinikubeNode {
+    #[serde(rename = "IP")]
+    ip: IpAddr,
+    #[serde(rename = "Port")]
+    port: u16,
+}
 
-    let tmp_file = env::temp_dir().join("flv_minikube.sh");
+#[derive(Debug, Deserialize)]
+struct MinikubeConfig {
+    #[serde(rename = "Name")]
+    name: String,
+    #[serde(rename = "Nodes")]
+    nodes: Vec<MinikubeNode>,
+}
 
-    let mut file = OpenOptions::new()
-        .create(true)
-        .write(true)
-        .truncate(true)
-        .mode(0o755)
-        .open(tmp_file.clone())
-        .expect("temp script can't be created");
+#[derive(Debug, Deserialize)]
+struct MinikubeProfileWrapper {
+    valid: Vec<MinikubeProfileJson>,
+}
 
-    file.write_all(render.as_bytes())
-        .expect("file write failed");
+#[derive(Debug, Deserialize)]
+struct MinikubeProfileJson {
+    #[serde(rename = "Name")]
+    name: String,
+    #[serde(rename = "Status")]
+    status: String,
+    #[serde(rename = "Config")]
+    config: MinikubeConfig,
+}
 
-    file.sync_all().expect("sync");
-    drop(file);
+/// A description of the active Minikube instance, including IP and port
+#[derive(Debug)]
+struct MinikubeProfile {
+    /// The name of the minikube profile, usually "minikube"
+    name: String,
+    /// The active minikube node, with IP and port
+    node: MinikubeNode,
+}
 
-    debug!("script {}", render);
+impl MinikubeProfile {
+    /// Gets minikube's current profile
+    fn load() -> Result<MinikubeProfile, ConfigError> {
+        let output = Command::new("minikube")
+            .args(&["profile", "list", "-o", "json"])
+            .output()?;
+        let output_string = String::from_utf8(output.stdout)
+            .map_err(|e| ConfigError::Other(format!("`minikube profile list -o json` did not give UTF-8: {}", e)))?;
+        let profiles: MinikubeProfileWrapper = serde_json::from_str(&output_string)
+            .map_err(|e| ConfigError::Other(format!("`minikube profile list -o json` did not give valid JSON: {}", e)))?;
+        let profile_json = profiles.valid.into_iter().next()
+            .ok_or(ConfigError::Other("no valid minikube profiles".to_string()))?;
+        let node = profile_json.config.nodes.into_iter().next()
+            .ok_or(ConfigError::Other("Minikube has no active nodes".to_string()))?;
+        let profile = MinikubeProfile {
+            name: profile_json.name,
+            node,
+        };
+        Ok(profile)
+    }
+
+    fn ip(&self) -> IpAddr {
+        self.node.ip
+    }
+
+    fn port(&self) -> u16 {
+        self.node.port
+    }
+
+    /// Checks whether the `/etc/hosts` file has an up-to-date entry for minikube
+    ///
+    /// Returns `Ok(true)` when the hostfile is up-to-date and no action is required.
+    ///
+    /// Returns `Ok(false)` when the hostfile is out of date or has no `minikubeCA` entry.
+    /// In this case, the `/etc/hosts` file needs to be edited.
+    ///
+    /// Returns `Err(_)` when there is an error detecting the current Minikube ip address
+    /// or if there is an error reading the hosts file.
+    fn matches_hostfile(&self) -> Result<bool, ConfigError> {
+        // Check if the /etc/hosts file matches the active node IP
+        let matches = get_host_entry("minikubeCA")?
+            .map(|ip| ip == self.node.ip)
+            .unwrap_or(false);
+        Ok(matches)
+    }
+}
 
-    let output = Command::new(tmp_file).output().expect("cluster command");
-    io::stdout().write_all(&output.stdout).unwrap();
-    io::stderr().write_all(&output.stderr).unwrap();
+/// Gets the current entry for a given host in `/etc/hosts` if there is one
+fn get_host_entry(hostname: &str) -> Result<Option<IpAddr>, ConfigError> {
+    // Get all of the host entries
+    let hosts = hostfile::parse_hostfile()
+        .map_err(|e| ConfigError::Other(format!("failed to get /etc/hosts entries: {}", e)))?;
+    // Try to find a host entry with the given hostname
+    let minikube_entry = hosts.into_iter()
+        .find(|entry| entry.names.iter().any(|name| name == hostname));
+    Ok(minikube_entry.map(|entry| entry.ip))
 }

src/k8-config/src/context.rs

@@ -3,20 +3,21 @@ use std::io::Error as StdIoError;
 
 use serde_yaml::Error as SerdYamlError;
 
-
 #[derive(Debug)]
 pub enum ConfigError {
     IoError(StdIoError),
     SerdeError(SerdYamlError),
-    NoCurrentContext
+    NoCurrentContext,
+    Other(String),
 }
 
 impl fmt::Display for ConfigError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::IoError(err) => write!(f, "{}", err),
-            Self::SerdeError(err) => write!(f,"{}",err),
-            Self::NoCurrentContext => write!(f,"no current context")
+            Self::SerdeError(err) => write!(f, "{}", err),
+            Self::NoCurrentContext => write!(f, "no current context"),
+            Self::Other(err) => write!(f, "{}", err),
         }
     }
 }