Construct `AccessModeSelectorHandle` by calling `AccessModeSelector::spawn`

Construct an `AccessModeSelectorHandle` by calling
`AccessModeSelector::spawn`, which is consistent with how actors are
spawned in other parts of the `mullvad-daemon`.

3 files changed, 33 insertions, 54 deletions

diff --git a/mullvad-daemon/src/access_method.rs b/mullvad-daemon/src/access_method.rs
index b0dd0506c3..97dfa815f5 100644
--- a/mullvad-daemon/src/access_method.rs
+++ b/mullvad-daemon/src/access_method.rs
@@ -198,15 +198,7 @@ where
                 .notify_settings(self.settings.to_settings());
 
             let handle = self.connection_modes_handler.clone();
-            let new_access_methods = self
-                .settings
-                .api_access_methods
-                .access_method_settings
-                .iter()
-                .filter(|api_access_method| api_access_method.enabled())
-                .cloned()
-                .collect();
-
+            let new_access_methods = self.settings.api_access_methods.collect_enabled();
             tokio::spawn(async move {
                 match handle.update_access_methods(new_access_methods).await {
                     Ok(_) => (),
diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
index 47a9969a76..ef6d2ff106 100644
--- a/mullvad-daemon/src/api.rs
+++ b/mullvad-daemon/src/api.rs
@@ -46,21 +46,6 @@ pub struct AccessModeSelectorHandle {
 }
 
 impl AccessModeSelectorHandle {
-    pub fn new(
-        cache_dir: PathBuf,
-        relay_selector: RelaySelector,
-        connection_modes: Vec<AccessMethodSetting>,
-    ) -> Self {
-        let (cmd_tx, cmd_rx) = mpsc::unbounded();
-
-        let mut actor = AccessModeSelector {
-            cmd_rx,
-            state: ApiConnectionModeProvider::new(cache_dir, relay_selector, connection_modes),
-        };
-        tokio::spawn(async move { actor.run().await });
-        Self { cmd_tx }
-    }
-
     async fn send_command<T>(&self, make_cmd: impl FnOnce(ResponseTx<T>) -> Message) -> Result<T> {
         let (tx, rx) = oneshot::channel();
         // TODO(markus): Error handling
@@ -120,7 +105,36 @@ pub struct AccessModeSelector {
 }
 
 impl AccessModeSelector {
-    async fn run(&mut self) {
+    pub fn spawn(
+        cache_dir: PathBuf,
+        relay_selector: RelaySelector,
+        connection_modes: Vec<AccessMethodSetting>,
+    ) -> AccessModeSelectorHandle {
+        let (cmd_tx, cmd_rx) = mpsc::unbounded();
+
+        let state =
+            match ApiConnectionModeProvider::new(cache_dir, relay_selector, connection_modes) {
+                Ok(provider) => provider,
+                Err(api::Error::NoAccessMethods) => {
+                    // No settings seem to have been found. Default to using the the
+                    // direct access method.
+                    let default = mullvad_types::access_method::Settings::direct();
+                    api::ApiConnectionModeProvider::new(
+                    cache_dir.clone(),
+                    relay_selector.clone(),
+                    vec![default],
+                )
+                .expect(
+                    "Failed to create the data structure responsible for managing access methods",
+                )
+                }
+            };
+        let selector = AccessModeSelector { cmd_rx, state };
+        tokio::spawn(selector.into_future());
+        AccessModeSelectorHandle { cmd_tx }
+    }
+
+    async fn into_future(mut self) {
         while let Some(cmd) = self.cmd_rx.next().await {
             let _ = match cmd {
                 Message::Get(tx) => self.on_get_access_method(tx),
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index ee3e75d7d6..90dbd1f4f4 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -683,36 +683,9 @@ where
                 .set_config(new_selector_config(settings));
         });
 
-        let connection_modes: Vec<_> = settings
-                .api_access_methods
-                .access_method_settings
-                .iter()
-                // We only care about the access methods which are set to 'enabled' by the user.
-                .filter(|api_access_method| api_access_method.enabled())
-                .cloned()
-                .collect();
-        let proxy_provider = match api::ApiConnectionModeProvider::new(
-            cache_dir.clone(),
-            relay_selector.clone(),
-            connection_modes,
-        ) {
-            Ok(provider) => provider,
-            Err(api::Error::NoAccessMethods) => {
-                // No settings seem to have been found. Default to using the the
-                // direct access method.
-                let default = mullvad_types::access_method::Settings::direct();
-                api::ApiConnectionModeProvider::new(
-                    cache_dir.clone(),
-                    relay_selector.clone(),
-                    vec![default],
-                )
-                .expect(
-                    "Failed to create the data structure responsible for managing access methods",
-                )
-            }
-        };
+        let connection_modes = settings.api_access_methods.collect_enabled();
 
-        let connection_modes_handler = api::AccessModeSelectorHandle::new(
+        let connection_modes_handler = api::AccessModeSelector::spawn(
             cache_dir.clone(),
             relay_selector.clone(),
             connection_modes,