Implement projects as groups

Cargo.toml

@@ -16,11 +16,22 @@ clap = "2.19"
 error-chain="0.12.1"
 toml_edit="0.1.5"
 nix = "0.9.0"
+openssl = "0.10"
+openssl-sys = "0.9.58"
+chrono = "0.4"
+log = "0.4"
+fern = "0.6"
+lazy_static = "1.5.0"
+regex = "1.11.1"
 
 [[ bin ]]
 name = "watchdog"
 path = "src/main.rs"
 
 [lib]
 name = "lib"
-path = "src/lib/lib.rs"
+path = "src/lib/lib.rs"
+
+[features]
+default = []
+auto-update = []

install/install.sh

@@ -6,6 +6,11 @@ mkdir -p /opt/watchdog/logs
 touch /opt/watchdog/logs/sudo.logs
 touch /opt/watchdog/logs/su.logs
 touch /opt/watchdog/logs/ssh.logs
+mkdir -p /opt/watchdog/custom-logs
+touch /opt/watchdog/custom-logs/ssh.logs
+touch /opt/watchdog/custom-logs/sudo.logs
+touch /opt/watchdog/custom-logs/su.logs
+touch /opt/watchdog/custom-logs/auth.logs
 
 cp ../target/release/watchdog /opt/watchdog/bin/watchdog
 chown root /opt/watchdog/bin/watchdog

sample.config.toml

@@ -21,4 +21,11 @@ token = 'secret_token'
 # Make an incoming hook to your Slack workspace from this
 # app(https://slack.com/apps/A0F7XDUAZ-incoming-webhooks)
 # and paste the hook URL here. You can customize the icon and name as you like.
-slack = 'https://hooks.slack.com/services/ABCDEFGHI/ABCDEFGHI/abcdefghijklmnopqrstuvwx'
+token = 'bot_token'
+channel = 'C0123456789'
+
+# Logging
+[logging]
+debug='true'
+offset='+5:30'
+verbosity='v'

src/auth.rs

@@ -1,5 +1,5 @@
-use std::fs;
-
+use lib::logger::LogTarget;
+use log::{error, info};
 use nix::unistd::{fork, ForkResult};
 
 use lib::config::read_config;
@@ -8,42 +8,56 @@ use lib::init::init;
 use lib::keyhouse::{get_name, validate_user};
 use lib::notifier;
 
+#[cfg(feature = "auto-update")]
+use crate::update::handle_update;
+
 pub fn handle_auth(ssh_host_username: &str, ssh_key: &str) -> Result<()> {
     let config = read_config()?;
     init(&config)?;
+    info!(target: LogTarget::AUTH.as_str(), "ssh_key in handle_auth: {}", ssh_key);
+
+    #[cfg(feature = "auto-update")]
+    {
+        match handle_update() {
+            Ok(_) => {
+                info!(target: LogTarget::UPDATE.as_str(), "Update handled successfully");
+            }
+            Err(e) => {
+                error!(target: LogTarget::UPDATE.as_str(), "Error handling update: {}", e);
+                return Err(e);
+            }
+        }
+    }
 
     match validate_user(&config, ssh_host_username.to_string(), ssh_key) {
         Ok(true) => {
-            let data = format!(
-                "ssh_host_username = '{}'\nssh_key = '{}'\n",
-                ssh_host_username, ssh_key
-            );
-
-            fs::write("/opt/watchdog/ssh_env", data)
-                        .chain_err(|| "Cannot write temporary environment file. Please check if the watchdog `auth_keys_cmd` is run by the root user")?;
-
+            info!(target: LogTarget::AUTH.as_str(), "User validated by handle auth");
             println!("{}", ssh_key);
             Ok(())
         }
 
         Ok(false) => {
+            info!(target: LogTarget::AUTH.as_str(), "User not validated");
             let name = get_name(&config, ssh_key)?;
-
+            info!(target: LogTarget::AUTH.as_str(), "Logging failed");
             match fork() {
                 Ok(ForkResult::Parent { .. }) => {}
                 Ok(ForkResult::Child) => {
                     notifier::post_ssh_summary(
                         &config,
                         false,
-                        name,
-                        ssh_host_username.to_string(),
+                        &name,
+                        &ssh_host_username.to_string(),
                     )?;
+                    std::process::exit(0);
                 }
                 Err(_) => println!("Fork failed"),
             }
             Ok(())
         }
-
-        Err(e) => Err(e).chain_err(|| "Error while validating user from keyhouse"),
+        Err(e) => {
+            error!(target: LogTarget::AUTH.as_str(), "Error while validating user from keyhouse");
+            Err(e).chain_err(|| "Error while validating user from keyhouse")
+        }
     }
 }

src/lib/config.rs

@@ -3,7 +3,7 @@ use std::fs;
 use serde_derive::Deserialize;
 use toml_edit::{value, Document};
 
-use crate::errors::*;
+use crate::{constants::CONFIG_PATH, errors::*};
 
 #[derive(Deserialize, Clone)]
 pub struct KeyhouseConf {
@@ -13,24 +13,33 @@ pub struct KeyhouseConf {
 
 #[derive(Deserialize, Clone)]
 pub struct NotifiersConf {
-    pub slack: String,
+    pub token: String,
+    pub channel: String,
+}
+
+#[derive(Deserialize, Clone)]
+pub struct LoggingConf {
+    pub debug: String,
+    pub offset: String,
+    pub verbosity: String,
 }
 
 #[derive(Deserialize, Clone)]
 pub struct Config {
     pub hostname: String,
     pub keyhouse: KeyhouseConf,
     pub notifiers: NotifiersConf,
+    pub logging: LoggingConf,
 }
 
 pub fn read_config() -> Result<Config> {
-    let toml_str = fs::read_to_string("/opt/watchdog/config.toml")?;
+    let toml_str = fs::read_to_string(CONFIG_PATH)?;
     let config: Config = toml::from_str(&toml_str)?;
     Ok(config)
 }
 
 pub fn set_config_value(key: &str, val: &str) -> Result<()> {
-    let toml_str = fs::read_to_string("/opt/watchdog/config.toml")?;
+    let toml_str = fs::read_to_string(CONFIG_PATH)?;
     let mut doc = toml_str.parse::<Document>().chain_err(|| {
         "Invalid TOML file. Please reverify if /opt/watchdog/config.toml is a valid toml file."
     })?;
@@ -44,27 +53,43 @@ pub fn set_config_value(key: &str, val: &str) -> Result<()> {
         "keyhouse.token" => {
             doc["keyhouse"]["token"] = value(val);
         }
-        "notifiers.slack" => {
-            doc["notifiers"]["slack"] = value(val);
+        "notifiers.token" => {
+            doc["notifiers"]["token"] = value(val);
+        }
+        "notifiers.channel" => {
+            doc["notifiers"]["channel"] = value(val);
+        }
+        "logging.debug" => {
+            doc["logging"]["debug"] = value(val);
+        }
+        "logging.offset" => {
+            doc["logging"]["offset"] = value(val);
+        }
+        "logging.verbosity" => {
+            doc["logging"]["verbosity"] = value(val);
         }
         _ => {
             return Err("Invalid Key passed".into());
         }
     }
-    fs::write("/opt/watchdog/config.toml", doc.to_string())?;
+    fs::write(CONFIG_PATH, doc.to_string())?;
     Ok(())
 }
 
 pub fn get_config_value(key: &str) -> Result<String> {
-    let toml_str = fs::read_to_string("/opt/watchdog/config.toml")?;
+    let toml_str = fs::read_to_string(CONFIG_PATH)?;
     let doc = toml_str.parse::<Document>().chain_err(|| {
         "Invalid TOML file. Please reverify if /opt/watchdog/config.toml is a valid toml file."
     })?;
     let val = match key {
         "hostname" => doc["hostname"].as_str(),
         "keyhouse.base_url" => doc["keyhouse"]["base_url"].as_str(),
         "keyhouse.token" => doc["keyhouse"]["token"].as_str(),
-        "notifiers.slack" => doc["notifiers"]["slack"].as_str(),
+        "notifiers.token" => doc["notifiers"]["token"].as_str(),
+        "notifiers.channel" => doc["notifiers"]["channel"].as_str(),
+        "logging.debug" => doc["logging"]["debug"].as_str(),
+        "logging.offset" => doc["logging"]["offset"].as_str(),
+        "logging.verbosity" => doc["logging"]["verbosity"].as_str(),
         _ => {
             return Err("Invalid Key passed".into());
         }

src/lib/constants.rs

@@ -0,0 +1,4 @@
+pub const BASE_COMMIT_PATH: &str = "/opt/watchdog/base_commit.txt";
+pub const CONFIG_PATH: &str = "/opt/watchdog/config.toml";
+pub const LOG_PATH: &str = "/opt/watchdog/custom-logs";
+pub const HOME_DIR: &str = "/opt/watchdog/users";