Initial code for adding users to groups upon creation

examples/group/add_to_group.yaml

@@ -0,0 +1,12 @@
+depends:
+  - group
+
+actions:
+  - action: user.add
+    fullname: testuser
+    home_dir: /home/test
+    username: test
+    shell: sh
+    group: 
+      - testgroup
+

lib/src/actions/group/providers/linux.rs

@@ -26,7 +26,7 @@ impl GroupProvider for LinuxGroupProvider {
         vec![Step {
             atom: Box::new(Exec {
                 command: String::from(cli.to_str().unwrap()),
-                arguments: vec![String::from(group.group_name.clone())],
+                arguments: vec![group.group_name.clone()],
                 privileged: true,
                 ..Default::default()
             }),
@@ -36,23 +36,29 @@ impl GroupProvider for LinuxGroupProvider {
     }
 }
 
-#[cfg(tests)]
+#[cfg(target_os = "linux")]
+#[cfg(test)]
 mod test {
-    use crate::actions::group::*;
+    use crate::actions::group::providers::{GroupProvider, LinuxGroupProvider};
+    use crate::actions::group::GroupVariant;
 
     #[test]
     fn test_add_group() {
         let group_provider = LinuxGroupProvider {};
-        let steps = user_provider.add_user(&GroupVariant { group_name: test });
+        let steps = group_provider.add_group(&GroupVariant {
+            group_name: String::from("test"),
+            ..Default::default()
+        });
 
         assert_eq!(steps.len(), 1);
     }
 
     #[test]
     fn test_add_group_no_group_name() {
         let group_provider = LinuxGroupProvider {};
-        let steps = group_provider.add_user(&GroupVariant {
+        let steps = group_provider.add_group(&GroupVariant {
             // empty for test purposes
+            ..Default::default()
         });
 
         assert_eq!(steps.len(), 0);

lib/src/actions/user/mod.rs

@@ -24,6 +24,9 @@ pub struct User {
     #[serde(default)]
     shell: String,
 
+    #[serde(default)]
+    group: Vec<String>,
+
     #[serde(default)]
     variants: HashMap<os_info::Type, UserVariant>,
 }
@@ -44,6 +47,9 @@ pub struct UserVariant {
 
     #[serde(default)]
     shell: String,
+
+    #[serde(default)]
+    group: Vec<String>,
 }
 
 impl From<&User> for UserVariant {
@@ -61,6 +67,7 @@ impl From<&User> for UserVariant {
                 home_dir: user.home_dir.clone(),
                 fullname: user.fullname.clone(),
                 shell: user.shell.clone(),
+                group: user.group.clone(),
             };
         };
 
@@ -74,6 +81,7 @@ impl From<&User> for UserVariant {
             home_dir: user.home_dir.clone(),
             fullname: user.fullname.clone(),
             shell: user.shell.clone(),
+            group: user.group.clone(),
         };
 
         user.provider = variant.provider.clone();

lib/src/actions/user/providers/freebsd.rs

@@ -2,6 +2,7 @@ use super::UserProvider;
 use crate::steps::Step;
 use crate::{actions::user::UserVariant, atoms::command::Exec};
 use serde::{Deserialize, Serialize};
+use tracing::warn;
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct FreeBSDUserProvider {}
@@ -52,4 +53,9 @@ impl UserProvider for FreeBSDUserProvider {
             finalizers: vec![],
         }]
     }
+
+    fn add_to_group(&self, _user: &UserVariant) -> Vec<Step> {
+        warn!(message = "Functionality not implemented for platform");
+        vec![]
+    }
 }

lib/src/actions/user/providers/linux.rs

@@ -43,7 +43,7 @@ impl UserProvider for LinuxUserProvider {
             args.push(user.fullname.clone());
         }
 
-        vec![Step {
+        let mut steps: Vec<Step> = vec![Step {
             atom: Box::new(Exec {
                 command: String::from(cli.to_str().unwrap()),
                 arguments: vec![].into_iter().chain(args.clone()).collect(),
@@ -52,18 +52,72 @@ impl UserProvider for LinuxUserProvider {
             }),
             initializers: vec![],
             finalizers: vec![],
-        }]
+        }];
+
+        if !user.group.is_empty() {
+            for group in self.add_to_group(user) {
+                steps.push(group);
+            }
+        }
+
+        steps
+    }
+
+    fn add_to_group(&self, user: &UserVariant) -> Vec<Step> {
+        let cli = match which("usermod") {
+            Ok(c) => c,
+            Err(_) => {
+                warn!(message = "Could not get the proper user add tool");
+                return vec![];
+            }
+        };
+
+        if user.group.is_empty() {
+            warn!(message = "No groups listed to add user to");
+            return vec![];
+        }
+
+        if user.username.is_empty() {
+            warn!(message = "No user specified to add to group(s)");
+            return vec![];
+        }
+
+        let mut steps: Vec<Step> = vec![];
+
+        for group in user.group.iter() {
+            steps.push(Step {
+                atom: Box::new(Exec {
+                    command: String::from(cli.to_str().unwrap()),
+                    arguments: vec![String::from("-a"), String::from("-G"), String::from(group)],
+                    privileged: true,
+                    ..Default::default()
+                }),
+                initializers: vec![],
+                finalizers: vec![],
+            });
+        }
+
+        steps
     }
 }
 
-#[cfg(tests)]
+#[cfg(target_os = "linux")]
+#[cfg(test)]
 mod test {
-    use crate::actions::user::*;
+    use crate::actions::user::providers::{LinuxUserProvider, UserProvider};
+    use crate::actions::user::UserVariant;
 
     #[test]
     fn test_add_user() {
         let user_provider = LinuxUserProvider {};
-        let steps = user_provider.add_user(&UserVariant { username: test });
+        let steps = user_provider.add_user(&UserVariant {
+            username: String::from("test"),
+            shell: String::from("sh"),
+            home_dir: String::from("/home/test"),
+            fullname: String::from("Test User"),
+            group: vec![],
+            ..Default::default()
+        });
 
         assert_eq!(steps.len(), 1);
     }
@@ -72,9 +126,44 @@ mod test {
     fn test_add_user_no_username() {
         let user_provider = LinuxUserProvider {};
         let steps = user_provider.add_user(&UserVariant {
-            // empty for test purposes
+            username: String::from(""),
+            shell: String::from("sh"),
+            home_dir: String::from("/home/test"),
+            fullname: String::from("Test User"),
+            group: vec![],
+            ..Default::default()
         });
 
         assert_eq!(steps.len(), 0);
     }
+
+    #[test]
+    fn test_add_to_group() {
+        let user_provider = LinuxUserProvider {};
+        let steps = user_provider.add_to_group(&UserVariant {
+            username: String::from("test"),
+            shell: String::from("sh"),
+            home_dir: String::from("/home/test"),
+            fullname: String::from("Test User"),
+            group: vec![String::from("testgroup"), String::from("wheel")],
+            ..Default::default()
+        });
+
+        assert_eq!(steps.len(), 2);
+    }
+
+    #[test]
+    fn test_create_user_add_to_group() {
+        let user_provider = LinuxUserProvider {};
+        let steps = user_provider.add_user(&UserVariant {
+            username: String::from("test"),
+            shell: String::from(""),
+            home_dir: String::from(""),
+            fullname: String::from(""),
+            group: vec![String::from("testgroup")],
+            ..Default::default()
+        });
+
+        assert_eq!(steps.len(), 2);
+    }
 }

lib/src/actions/user/providers/mod.rs

@@ -51,4 +51,5 @@ impl Default for UserProviders {
 
 pub trait UserProvider {
     fn add_user(&self, user: &UserVariant) -> Vec<Step>;
+    fn add_to_group(&self, user: &UserVariant) -> Vec<Step>;
 }

lib/src/actions/user/providers/none.rs

@@ -12,4 +12,9 @@ impl UserProvider for NoneUserProvider {
         warn!("This system does not have a provider for users");
         vec![]
     }
+
+    fn add_to_group(&self, _user: &UserVariant) -> Vec<Step> {
+        warn!(message = "This system does not have a provider for users");
+        vec![]
+    }
 }