Rename `ApiAccessMethod` to `AccessMethodSetting`

`ApiAccessMethod` was just an app-centric wrapper around `AccessMethod`.

8 files changed, 69 insertions, 63 deletions

diff --git a/mullvad-cli/src/cmds/api_access.rs b/mullvad-cli/src/cmds/api_access.rs
index ae202055b6..efb1e7bfd8 100644
--- a/mullvad-cli/src/cmds/api_access.rs
+++ b/mullvad-cli/src/cmds/api_access.rs
@@ -1,8 +1,6 @@
 use anyhow::{anyhow, Result};
 use mullvad_management_interface::MullvadProxyClient;
-use mullvad_types::access_method::{
-    daemon::ApiAccessMethodUpdate, AccessMethod, ApiAccessMethod, CustomAccessMethod,
-};
+use mullvad_types::api_access::{AccessMethod, AccessMethodSetting, CustomAccessMethod};
 use std::net::IpAddr;
 
 use clap::{Args, Subcommand};
@@ -74,7 +72,7 @@ impl ApiAccess {
     /// Add a custom API access method.
     async fn add(cmd: AddCustomCommands) -> Result<()> {
         let mut rpc = MullvadProxyClient::new().await?;
-        let access_method = ApiAccessMethod::try_from(cmd)?;
+        let access_method = AccessMethodSetting::try_from(cmd)?;
         rpc.add_access_method(access_method).await?;
         Ok(())
     }
@@ -99,7 +97,7 @@ impl ApiAccess {
             .ok_or(anyhow!("Can not edit built-in access method"))?;
 
         // Create a new access method combining the new params with the previous values
-        let edited_access_method: ApiAccessMethod = match access_method {
+        let edited_access_method: AccessMethodSetting = match access_method {
             CustomAccessMethod::Shadowsocks(shadowsocks) => {
                 let ip = cmd.params.ip.unwrap_or(shadowsocks.peer.ip()).to_string();
                 let port = cmd.params.port.unwrap_or(shadowsocks.peer.port());
@@ -109,7 +107,7 @@ impl ApiAccess {
                 let enabled = api_access_method.enabled;
                 mullvad_types::api_access::Shadowsocks::from_args(ip, port, cipher, password).map(
                     |shadowsocks| {
-                        ApiAccessMethod::new(name, enabled, AccessMethod::from(shadowsocks))
+                        AccessMethodSetting::new(name, enabled, AccessMethod::from(shadowsocks))
                     },
                 )
             }
@@ -120,16 +118,18 @@ impl ApiAccess {
                     let local_port = cmd.params.local_port.unwrap_or(local.port);
                     let name = cmd.params.name.unwrap_or(api_access_method.get_name());
                     let enabled = api_access_method.enabled();
-                    mullvad_types::api_access::Socks5Local::from_args(ip, port, local_port)
-                        .map(|socks| ApiAccessMethod::new(name, enabled, AccessMethod::from(socks)))
+                    mullvad_types::api_access::Socks5Local::from_args(ip, port, local_port).map(
+                        |socks| AccessMethodSetting::new(name, enabled, AccessMethod::from(socks)),
+                    )
                 }
                 mullvad_types::api_access::Socks5::Remote(remote) => {
                     let ip = cmd.params.ip.unwrap_or(remote.peer.ip()).to_string();
                     let port = cmd.params.port.unwrap_or(remote.peer.port());
                     let name = cmd.params.name.unwrap_or(api_access_method.get_name());
                     let enabled = api_access_method.enabled();
-                    mullvad_types::api_access::Socks5Remote::from_args(ip, port)
-                        .map(|socks| ApiAccessMethod::new(name, enabled, AccessMethod::from(socks)))
+                    mullvad_types::api_access::Socks5Remote::from_args(ip, port).map(|socks| {
+                        AccessMethodSetting::new(name, enabled, AccessMethod::from(socks))
+                    })
                 }
             },
         }
@@ -193,7 +193,7 @@ impl ApiAccess {
     async fn get_access_method(
         rpc: &mut MullvadProxyClient,
         item: &SelectItem,
-    ) -> Result<ApiAccessMethod> {
+    ) -> Result<AccessMethodSetting> {
         rpc.get_api_access_methods()
             .await?
             .get(item.as_array_index()?)
@@ -315,7 +315,7 @@ mod conversions {
 
     use super::{AddCustomCommands, Socks5AddCommands};
 
-    impl TryFrom<AddCustomCommands> for daemon_types::ApiAccessMethod {
+    impl TryFrom<AddCustomCommands> for daemon_types::AccessMethodSetting {
         type Error = Error;
 
         fn try_from(value: AddCustomCommands) -> Result<Self, Self::Error> {
@@ -338,7 +338,7 @@ mod conversions {
                             )
                             .ok_or(anyhow!("Could not create a local Socks5 api proxy"))?,
                         );
-                        daemon_types::ApiAccessMethod::new(
+                        daemon_types::AccessMethodSetting::new(
                             name,
                             enabled,
                             daemon_types::AccessMethod::from(socks_proxy),
@@ -357,7 +357,7 @@ mod conversions {
                             )
                             .ok_or(anyhow!("Could not create a remote Socks5 api proxy"))?,
                         );
-                        daemon_types::ApiAccessMethod::new(
+                        daemon_types::AccessMethodSetting::new(
                             name,
                             enabled,
                             daemon_types::AccessMethod::from(socks_proxy),
@@ -382,7 +382,7 @@ mod conversions {
                     )
                     .ok_or(anyhow!("Could not create a Shadowsocks api proxy"))?;
 
-                    daemon_types::ApiAccessMethod::new(
+                    daemon_types::AccessMethodSetting::new(
                         name,
                         enabled,
                         daemon_types::AccessMethod::from(shadowsocks_proxy),
@@ -395,14 +395,16 @@ mod conversions {
 
 /// Pretty printing of [`ApiAccessMethod`]s
 mod pp {
-    use mullvad_types::api_access::{AccessMethod, ApiAccessMethod, CustomAccessMethod, Socks5};
+    use mullvad_types::api_access::{
+        AccessMethod, AccessMethodSetting, CustomAccessMethod, Socks5,
+    };
 
     pub struct ApiAccessMethodFormatter<'a> {
-        api_access_method: &'a ApiAccessMethod,
+        api_access_method: &'a AccessMethodSetting,
     }
 
     impl<'a> ApiAccessMethodFormatter<'a> {
-        pub fn new(api_access_method: &'a ApiAccessMethod) -> ApiAccessMethodFormatter<'a> {
+        pub fn new(api_access_method: &'a AccessMethodSetting) -> ApiAccessMethodFormatter<'a> {
             ApiAccessMethodFormatter { api_access_method }
         }
     }
@@ -419,6 +421,8 @@ mod pp {
                 }
             };
 
+            writeln!(f, "{:?}", self.api_access_method)?;
+
             match &self.api_access_method.access_method {
                 AccessMethod::BuiltIn(method) => {
                     write!(f, "{}", method.canonical_name())?;
diff --git a/mullvad-daemon/src/access_method.rs b/mullvad-daemon/src/access_method.rs
index dc6c06de06..a3ece35ecb 100644
--- a/mullvad-daemon/src/access_method.rs
+++ b/mullvad-daemon/src/access_method.rs
@@ -26,7 +26,10 @@ impl<L> Daemon<L>
 where
     L: EventListener + Clone + Send + 'static,
 {
-    pub async fn add_access_method(&mut self, access_method: ApiAccessMethod) -> Result<(), Error> {
+    pub async fn add_access_method(
+        &mut self,
+        access_method: AccessMethodSetting,
+    ) -> Result<(), Error> {
         self.settings
             .update(|settings| settings.api_access_methods.append(access_method))
             .await
diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 8d9980ba42..cac152c843 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -41,7 +41,7 @@ use mullvad_relay_selector::{
 use mullvad_types::{
     access_method::{daemon::ApiAccessMethodUpdate, ApiAccessMethod, ApiAccessMethodId},
     account::{AccountData, AccountToken, VoucherSubmission},
-    api_access::{ApiAccessMethod, ApiAccessMethodId},
+    api_access::{AccessMethodSetting, ApiAccessMethodId},
     auth_failed::AuthFailed,
     custom_list::CustomList,
     device::{Device, DeviceEvent, DeviceEventCause, DeviceId, DeviceState, RemoveDeviceEvent},
@@ -262,9 +262,9 @@ pub enum DaemonCommand {
     /// Update a custom list with a given id
     UpdateCustomList(ResponseTx<(), Error>, CustomList),
     /// Get API access methods
-    GetApiAccessMethods(ResponseTx<Vec<ApiAccessMethod>, Error>),
+    GetApiAccessMethods(ResponseTx<Vec<AccessMethodSetting>, Error>),
     /// Add API access methods
-    AddApiAccessMethod(ResponseTx<(), Error>, ApiAccessMethod),
+    AddApiAccessMethod(ResponseTx<(), Error>, AccessMethodSetting),
     /// Remove an API access method
     RemoveApiAccessMethod(ResponseTx<(), Error>, ApiAccessMethodId),
     /// Set the API access method to use
@@ -2243,7 +2243,7 @@ where
         Self::oneshot_send(tx, result, "update_custom_list response");
     }
 
-    fn on_get_api_access_methods(&mut self, tx: ResponseTx<Vec<ApiAccessMethod>, Error>) {
+    fn on_get_api_access_methods(&mut self, tx: ResponseTx<Vec<AccessMethodSetting>, Error>) {
         let result = Ok(self.settings.api_access_methods.cloned());
         Self::oneshot_send(tx, result, "get_api_access_methods response");
     }
@@ -2251,7 +2251,7 @@ where
     async fn on_add_api_access_method(
         &mut self,
         tx: ResponseTx<(), Error>,
-        method: ApiAccessMethod,
+        method: AccessMethodSetting,
     ) {
         let result = self
             .add_access_method(method)
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 12671a41c7..eabdb11826 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -625,7 +625,7 @@ impl ManagementService for ManagementServiceImpl {
     ) -> ServiceResult<()> {
         log::debug!("add_api_access_method");
         let api_access_method =
-            mullvad_types::api_access::ApiAccessMethod::try_from(request.into_inner())?;
+            mullvad_types::api_access::AccessMethodSetting::try_from(request.into_inner())?;
         let (tx, rx) = oneshot::channel();
         self.send_command_to_daemon(DaemonCommand::AddApiAccessMethod(tx, api_access_method))?;
         self.wait_for_result(rx)
diff --git a/mullvad-management-interface/src/client.rs b/mullvad-management-interface/src/client.rs
index 2503d6d55c..a7de6ae55f 100644
--- a/mullvad-management-interface/src/client.rs
+++ b/mullvad-management-interface/src/client.rs
@@ -5,7 +5,7 @@ use futures::{Stream, StreamExt};
 use mullvad_types::{
     access_method::{daemon::ApiAccessMethodUpdate, ApiAccessMethod, ApiAccessMethodId},
     account::{AccountData, AccountToken, VoucherSubmission},
-    api_access::{ApiAccessMethod, ApiAccessMethodId},
+    api_access::{AccessMethodSetting, ApiAccessMethodId},
     custom_list::{CustomList, Id},
     device::{Device, DeviceEvent, DeviceId, DeviceState, RemoveDeviceEvent},
     location::GeoIpLocation,
@@ -165,7 +165,7 @@ impl MullvadProxyClient {
         mullvad_types::relay_list::RelayList::try_from(list).map_err(Error::InvalidResponse)
     }
 
-    pub async fn get_api_access_methods(&mut self) -> Result<Vec<ApiAccessMethod>> {
+    pub async fn get_api_access_methods(&mut self) -> Result<Vec<AccessMethodSetting>> {
         self.0
             .get_settings(())
             .await
@@ -176,7 +176,7 @@ impl MullvadProxyClient {
             .api_access_methods
             .into_iter()
             .map(|api_access_method| {
-                ApiAccessMethod::try_from(api_access_method).map_err(Error::InvalidResponse)
+                AccessMethodSetting::try_from(api_access_method).map_err(Error::InvalidResponse)
             })
             .collect()
     }
@@ -184,7 +184,7 @@ impl MullvadProxyClient {
     pub async fn get_api_access_method(
         &mut self,
         id: &ApiAccessMethodId,
-    ) -> Result<ApiAccessMethod> {
+    ) -> Result<AccessMethodSetting> {
         self.get_api_access_methods()
             .await?
             .into_iter()
@@ -491,7 +491,10 @@ impl MullvadProxyClient {
         Ok(())
     }
 
-    pub async fn add_access_method(&mut self, api_access_method: ApiAccessMethod) -> Result<()> {
+    pub async fn add_access_method(
+        &mut self,
+        api_access_method: AccessMethodSetting,
+    ) -> Result<()> {
         self.0
             .add_api_access_method(types::ApiAccessMethod::from(api_access_method))
             .await
diff --git a/mullvad-management-interface/src/types/conversions/api_access_method.rs b/mullvad-management-interface/src/types/conversions/api_access_method.rs
index fa0d346788..0fd29f4b93 100644
--- a/mullvad-management-interface/src/types/conversions/api_access_method.rs
+++ b/mullvad-management-interface/src/types/conversions/api_access_method.rs
@@ -31,8 +31,8 @@ mod settings {
                 api_access_methods: settings
                     .api_access_methods
                     .iter()
-                    .map(api_access::ApiAccessMethod::try_from)
-                    .collect::<Result<Vec<api_access::ApiAccessMethod>, _>>()?,
+                    .map(api_access::AccessMethodSetting::try_from)
+                    .collect::<Result<Vec<api_access::AccessMethodSetting>, _>>()?,
             })
         }
     }
@@ -55,7 +55,7 @@ mod settings {
                 .ok_or(FromProtobufTypeError::InvalidArgument(
                     "Could not convert Access Method from protobuf",
                 ))
-                .and_then(api_access::ApiAccessMethod::try_from)?;
+                .and_then(api_access::AccessMethodSetting::try_from)?;
 
             let id = value
                 .id
@@ -78,23 +78,23 @@ mod settings {
 mod data {
     use crate::types::{proto, FromProtobufTypeError};
     use mullvad_types::api_access::{
-        AccessMethod, ApiAccessMethod, ApiAccessMethodId, BuiltInAccessMethod, CustomAccessMethod,
-        Shadowsocks, Socks5, Socks5Local, Socks5Remote,
+        AccessMethod, AccessMethodSetting, ApiAccessMethodId, BuiltInAccessMethod,
+        CustomAccessMethod, Shadowsocks, Socks5, Socks5Local, Socks5Remote,
     };
 
-    impl TryFrom<proto::ApiAccessMethods> for Vec<ApiAccessMethod> {
+    impl TryFrom<proto::ApiAccessMethods> for Vec<AccessMethodSetting> {
         type Error = FromProtobufTypeError;
 
         fn try_from(value: proto::ApiAccessMethods) -> Result<Self, Self::Error> {
             value
                 .api_access_methods
                 .iter()
-                .map(ApiAccessMethod::try_from)
+                .map(AccessMethodSetting::try_from)
                 .collect()
         }
     }
 
-    impl TryFrom<proto::ApiAccessMethod> for ApiAccessMethod {
+    impl TryFrom<proto::ApiAccessMethod> for AccessMethodSetting {
         type Error = FromProtobufTypeError;
 
         fn try_from(value: proto::ApiAccessMethod) -> Result<Self, Self::Error> {
@@ -185,7 +185,12 @@ mod data {
                 }
             };
 
-            Ok(ApiAccessMethod::with_id(id, name, enabled, access_method))
+            Ok(AccessMethodSetting::with_id(
+                id,
+                name,
+                enabled,
+                access_method,
+            ))
         }
     }
 
@@ -207,8 +212,8 @@ mod data {
         }
     }
 
-    impl From<ApiAccessMethod> for proto::ApiAccessMethod {
-        fn from(value: ApiAccessMethod) -> Self {
+    impl From<AccessMethodSetting> for proto::ApiAccessMethod {
+        fn from(value: AccessMethodSetting) -> Self {
             let id = proto::Uuid::from(value.get_id());
             let name = value.get_name();
             let enabled = value.enabled();
@@ -265,16 +270,16 @@ mod data {
         }
     }
 
-    impl TryFrom<&proto::ApiAccessMethod> for ApiAccessMethod {
+    impl TryFrom<&proto::ApiAccessMethod> for AccessMethodSetting {
         type Error = FromProtobufTypeError;
 
         fn try_from(value: &proto::ApiAccessMethod) -> Result<Self, Self::Error> {
-            ApiAccessMethod::try_from(value.clone())
+            AccessMethodSetting::try_from(value.clone())
         }
     }
 
-    impl From<Vec<ApiAccessMethod>> for proto::ApiAccessMethods {
-        fn from(value: Vec<ApiAccessMethod>) -> proto::ApiAccessMethods {
+    impl From<Vec<AccessMethodSetting>> for proto::ApiAccessMethods {
+        fn from(value: Vec<AccessMethodSetting>) -> proto::ApiAccessMethods {
             proto::ApiAccessMethods {
                 api_access_methods: value.iter().map(|method| method.clone().into()).collect(),
             }
diff --git a/mullvad-management-interface/src/types/rpc/api_access_method_update.rs b/mullvad-management-interface/src/types/rpc/api_access_method_update.rs
deleted file mode 100644
index b270893102..0000000000
--- a/mullvad-management-interface/src/types/rpc/api_access_method_update.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-/// A short-lived datastructure used in the `ApiAccessMethodUpdate` RPC call.
-use mullvad_types::api_access::{ApiAccessMethod, ApiAccessMethodId};
-/// Argument to gRPC call `UpdateApiAccessMethod`.
-#[derive(Debug, Clone, PartialEq)]
-pub struct ApiAccessMethodUpdate {
-    pub id: ApiAccessMethodId,
-    pub access_method: ApiAccessMethod,
-}
diff --git a/mullvad-types/src/api_access.rs b/mullvad-types/src/api_access.rs
index c20a1fe7fd..b916a7f323 100644
--- a/mullvad-types/src/api_access.rs
+++ b/mullvad-types/src/api_access.rs
@@ -6,12 +6,12 @@ use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
 /// Daemon settings for API access methods.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Settings {
-    pub api_access_methods: Vec<ApiAccessMethod>,
+    pub api_access_methods: Vec<AccessMethodSetting>,
 }
 
 impl Settings {
     /// Append an [`AccessMethod`] to the end of `api_access_methods`.
-    pub fn append(&mut self, api_access_method: ApiAccessMethod) {
+    pub fn append(&mut self, api_access_method: AccessMethodSetting) {
         self.api_access_methods.push(api_access_method)
     }
 
@@ -21,7 +21,7 @@ impl Settings {
     }
 
     /// Search for a particular [`AccessMethod`] in `api_access_methods`.
-    pub fn find(&self, element: &ApiAccessMethodId) -> Option<&ApiAccessMethod> {
+    pub fn find(&self, element: &ApiAccessMethodId) -> Option<&AccessMethodSetting> {
         self.api_access_methods
             .iter()
             .find(|api_access_method| *element == api_access_method.get_id())
@@ -32,7 +32,7 @@ impl Settings {
     /// If the [`AccessMethod`] is found to be part of `api_access_methods`, a
     /// mutable reference to that inner element is returned. Otherwise, `None`
     /// is returned.
-    pub fn find_mut(&mut self, element: &ApiAccessMethodId) -> Option<&mut ApiAccessMethod> {
+    pub fn find_mut(&mut self, element: &ApiAccessMethodId) -> Option<&mut AccessMethodSetting> {
         self.api_access_methods
             .iter_mut()
             .find(|api_access_method| *element == api_access_method.get_id())
@@ -41,13 +41,13 @@ impl Settings {
     /// Equivalent to [`Vec::retain`].
     pub fn retain<F>(&mut self, f: F)
     where
-        F: FnMut(&ApiAccessMethod) -> bool,
+        F: FnMut(&AccessMethodSetting) -> bool,
     {
         self.api_access_methods.retain(f)
     }
 
     /// Clone the content of `api_access_methods`.
-    pub fn cloned(&self) -> Vec<ApiAccessMethod> {
+    pub fn cloned(&self) -> Vec<AccessMethodSetting> {
         self.api_access_methods.clone()
     }
 }
@@ -58,7 +58,7 @@ impl Default for Settings {
             api_access_methods: vec![BuiltInAccessMethod::Direct, BuiltInAccessMethod::Bridge]
                 .into_iter()
                 .map(|built_in| {
-                    ApiAccessMethod::new(
+                    AccessMethodSetting::new(
                         built_in.canonical_name(),
                         true,
                         AccessMethod::from(built_in),
@@ -72,9 +72,8 @@ impl Default for Settings {
 /// API Access Method datastructure
 ///
 /// Mirrors the protobuf definition
-/// TODO(Create a constructor functions for this struct (?))
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct ApiAccessMethod {
+pub struct AccessMethodSetting {
     /// Some unique id (distinct for each `AccessMethod`).
     id: ApiAccessMethodId,
     pub name: String,
@@ -110,7 +109,7 @@ pub enum AccessMethod {
     Custom(CustomAccessMethod),
 }
 
-impl ApiAccessMethod {
+impl AccessMethodSetting {
     pub fn new(name: String, enabled: bool, access_method: AccessMethod) -> Self {
         Self {
             id: ApiAccessMethodId::new(),