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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
use std::collections::HashMap;
use test_rpc::{meta::OsVersion, mullvad_daemon::Verbosity};
const PLIST_OVERRIDE_FILE: &str = "/Library/LaunchDaemons/net.mullvad.daemon.plist";
/// Restart the Mullvad VPN application.
///
/// This function waits for the app to successfully start again.
pub async fn restart_app() -> Result<(), test_rpc::Error> {
stop_app().await?;
start_app().await?;
Ok(())
}
/// Stop the Mullvad VPN application.
///
/// This function waits for the app to successfully shut down.
pub async fn stop_app() -> Result<(), test_rpc::Error> {
set_launch_daemon_state(false).await?;
tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
Ok(())
}
/// Start the Mullvad VPN application.
///
/// This function waits for the app to successfully start again.
pub async fn start_app() -> Result<(), test_rpc::Error> {
set_launch_daemon_state(true).await?;
tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
Ok(())
}
#[allow(clippy::unused_async)]
pub async fn set_daemon_log_level(_verbosity_level: Verbosity) -> Result<(), test_rpc::Error> {
// TODO: Not implemented
log::warn!("Setting log level is not implemented on macOS");
Ok(())
}
pub async fn set_daemon_environment(env: HashMap<String, String>) -> Result<(), test_rpc::Error> {
tokio::task::spawn_blocking(|| {
let mut parsed_plist = plist::Value::from_file(PLIST_OVERRIDE_FILE).map_err(|error| {
test_rpc::Error::ServiceNotFound(format!("failed to parse plist: {error}"))
})?;
let mut vars = plist::Dictionary::new();
for (k, v) in env {
// Set environment globally (not for service) to prevent it from being lost on upgrade
std::process::Command::new("launchctl")
.arg("setenv")
.args([&k, &v])
.status()
.map_err(|e| test_rpc::Error::ServiceChange(e.to_string()))?;
vars.insert(k, plist::Value::String(v));
}
// Add permanent env var
parsed_plist
.as_dictionary_mut()
.ok_or_else(|| test_rpc::Error::ServiceChange("plist missing dict".to_owned()))?
.insert(
"EnvironmentVariables".to_owned(),
plist::Value::Dictionary(vars),
);
let daemon_plist = std::fs::File::create(PLIST_OVERRIDE_FILE)
.map_err(|e| test_rpc::Error::ServiceChange(format!("failed to open plist: {e}")))?;
parsed_plist
.to_writer_xml(daemon_plist)
.map_err(|e| test_rpc::Error::ServiceChange(format!("failed to replace plist: {e}")))?;
Ok::<(), test_rpc::Error>(())
})
.await
.unwrap()?;
// Restart service
set_launch_daemon_state(false).await?;
tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
set_launch_daemon_state(true).await?;
tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
Ok(())
}
async fn set_launch_daemon_state(on: bool) -> Result<(), test_rpc::Error> {
let mut launchctl = tokio::process::Command::new("launchctl");
if on {
launchctl
.args(["load", "-w", PLIST_OVERRIDE_FILE])
.status()
.await
.map_err(|e| test_rpc::Error::ServiceStart(e.to_string()))?;
} else {
launchctl
.args(["unload", "-w", PLIST_OVERRIDE_FILE])
.status()
.await
.map_err(|e| test_rpc::Error::ServiceStop(e.to_string()))?;
}
Ok(())
}
pub async fn get_daemon_environment() -> Result<HashMap<String, String>, test_rpc::Error> {
let plist = tokio::task::spawn_blocking(|| {
let parsed_plist = plist::Value::from_file(PLIST_OVERRIDE_FILE).map_err(|error| {
test_rpc::Error::ServiceNotFound(format!("failed to parse plist: {error}"))
})?;
Ok::<plist::Value, test_rpc::Error>(parsed_plist)
})
.await
.map_err(test_rpc::Error::from_tokio_join_error)??;
let plist_tree = plist
.as_dictionary()
.ok_or_else(|| test_rpc::Error::ServiceNotFound("plist missing dict".to_owned()))?;
let Some(env_vars) = plist_tree.get("EnvironmentVariables") else {
// `EnvironmentVariables` does not exist in plist file, so there are no env variables to
// parse.
return Ok(HashMap::new());
};
let env_vars = env_vars.as_dictionary().ok_or_else(|| {
test_rpc::Error::ServiceNotFound("`EnvironmentVariables` is not a dict".to_owned())
})?;
let env = env_vars
.clone()
.into_iter()
.filter_map(|(key, value)| Some((key, value.into_string()?)))
.collect();
Ok(env)
}
pub fn get_os_version() -> Result<OsVersion, test_rpc::Error> {
use test_rpc::meta::MacosVersion;
let version = talpid_platform_metadata::MacosVersion::new()
.inspect_err(|error| {
log::error!("Failed to obtain OS version: {error}");
})
.map_err(|_| test_rpc::Error::Syscall)?;
Ok(OsVersion::Macos(MacosVersion {
major: version.major_version(),
}))
}
|
