libazureinit 0.1.1

A common library for provisioning Linux VMs on Azure.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

use std::io::Write;
use std::process::Command;
use std::process::Stdio;

pub trait Distribution {
    fn create_user(
        &self,
        username: &str,
        password: &str,
    ) -> Result<i32, String>;
    fn set_hostname(&self, hostname: &str) -> Result<i32, String>;
}

pub enum Distributions {
    Debian,
    Ubuntu,
}

impl Distribution for Distributions {
    fn create_user(
        &self,
        username: &str,
        password: &str,
    ) -> Result<i32, String> {
        match self {
            Distributions::Debian | Distributions::Ubuntu => {
                let mut home_path = "/home/".to_string();
                home_path.push_str(username);

                match Command::new("useradd")
                    .arg(username)
                    .arg("--comment")
                    .arg(
                      "Provisioning agent created this user based on username provided in IMDS",
                    )
                    .arg("--groups")
                    .arg("adm,audio,cdrom,dialout,dip,floppy,lxd,netdev,plugdev,sudo,video")
                    .arg("-d")
                    .arg(home_path.clone())
                    .arg("-m")
                    .status(){
                        Ok(_)=>(),
                        Err(err) => return Err(err.to_string()),
                    };

                if password.is_empty() {
                    match Command::new("passwd")
                        .arg("-d")
                        .arg(username)
                        .status()
                    {
                        Ok(status_code) => {
                            if !status_code.success() {
                                return Err("Failed to create user".to_string());
                            }
                        }
                        Err(err) => return Err(err.to_string()),
                    };
                } else {
                    let input = format!("{}:{}", username, password);

                    let mut output = Command::new("chpasswd")
                        .stdin(Stdio::piped())
                        .stdout(Stdio::null())
                        .stderr(Stdio::inherit())
                        .spawn()
                        .expect("Failed to run chpasswd.");

                    let mut stdin =
                        output.stdin.as_ref().ok_or("Failed to open stdin")?;

                    stdin.write_all(input.as_bytes()).map_err(|error| {
                        format!("Failed to write to stdin: {}", error)
                    })?;

                    let status = output.wait().map_err(|error| {
                        format!("Failed to wait for stdin command: {}", error)
                    })?;

                    if !status.success() {
                        return Err(format!(
                            "Chpasswd command failed with exit code {}",
                            status.code().unwrap_or(-1)
                        ));
                    }
                }

                Ok(0)
            }
        }
    }
    fn set_hostname(&self, hostname: &str) -> Result<i32, String> {
        match self {
            Distributions::Debian | Distributions::Ubuntu => {
                match Command::new("hostnamectl")
                    .arg("set-hostname")
                    .arg(hostname)
                    .status()
                {
                    Ok(status_code) => Ok(status_code.code().unwrap_or(1)),
                    Err(err) => Err(err.to_string()),
                }
            }
        }
    }
}
impl From<&str> for Distributions {
    fn from(s: &str) -> Self {
        match s {
            "debian" => Distributions::Debian,
            "ubuntu" => Distributions::Ubuntu,
            _ => panic!("Unknown distribution"),
        }
    }
}