Move devices proxy to own module

2 files changed, 199 insertions, 187 deletions

diff --git a/mullvad-rpc/src/device.rs b/mullvad-rpc/src/device.rs
new file mode 100644
index 0000000000..de572aa20d
--- /dev/null
+++ b/mullvad-rpc/src/device.rs
@@ -0,0 +1,196 @@
+use http::{Method, StatusCode};
+use mullvad_types::{
+    account::AccountToken,
+    device::{Device, DeviceId, DeviceName, DevicePort},
+};
+use std::future::Future;
+use talpid_types::net::wireguard;
+
+use crate::rest;
+
+use super::ACCOUNTS_URL_PREFIX;
+
+#[derive(Clone)]
+pub struct DevicesProxy {
+    handle: rest::MullvadRestHandle,
+}
+
+#[derive(serde::Deserialize)]
+struct DeviceResponse {
+    id: DeviceId,
+    name: DeviceName,
+    pubkey: wireguard::PublicKey,
+    ipv4_address: ipnetwork::Ipv4Network,
+    ipv6_address: ipnetwork::Ipv6Network,
+    ports: Vec<DevicePort>,
+}
+
+impl DevicesProxy {
+    pub fn new(handle: rest::MullvadRestHandle) -> Self {
+        Self { handle }
+    }
+
+    pub fn create(
+        &self,
+        account: AccountToken,
+        pubkey: wireguard::PublicKey,
+    ) -> impl Future<Output = Result<(Device, mullvad_types::wireguard::AssociatedAddresses), rest::Error>>
+    {
+        #[derive(serde::Serialize)]
+        struct DeviceSubmission {
+            pubkey: wireguard::PublicKey,
+        }
+
+        let submission = DeviceSubmission { pubkey };
+
+        let service = self.handle.service.clone();
+        let factory = self.handle.factory.clone();
+        let access_proxy = self.handle.token_store.clone();
+
+        async move {
+            let response = rest::send_json_request(
+                &factory,
+                service,
+                &format!("{}/devices", ACCOUNTS_URL_PREFIX),
+                Method::POST,
+                &submission,
+                Some((access_proxy, account)),
+                &[StatusCode::CREATED],
+            )
+            .await;
+
+            let response: DeviceResponse = rest::deserialize_body(response?).await?;
+            let DeviceResponse {
+                id,
+                name,
+                pubkey,
+                ipv4_address,
+                ipv6_address,
+                ports,
+                ..
+            } = response;
+
+            Ok((
+                Device {
+                    id,
+                    name,
+                    pubkey,
+                    ports,
+                },
+                mullvad_types::wireguard::AssociatedAddresses {
+                    ipv4_address,
+                    ipv6_address,
+                },
+            ))
+        }
+    }
+
+    pub fn get(
+        &self,
+        account: AccountToken,
+        id: DeviceId,
+    ) -> impl Future<Output = Result<Device, rest::Error>> {
+        let service = self.handle.service.clone();
+        let factory = self.handle.factory.clone();
+        let access_proxy = self.handle.token_store.clone();
+        async move {
+            let response = rest::send_request(
+                &factory,
+                service,
+                &format!("{}/devices/{}", ACCOUNTS_URL_PREFIX, id),
+                Method::GET,
+                Some((access_proxy, account)),
+                &[StatusCode::OK],
+            )
+            .await;
+            rest::deserialize_body(response?).await
+        }
+    }
+
+    pub fn list(
+        &self,
+        account: AccountToken,
+    ) -> impl Future<Output = Result<Vec<Device>, rest::Error>> {
+        let service = self.handle.service.clone();
+        let factory = self.handle.factory.clone();
+        let access_proxy = self.handle.token_store.clone();
+        async move {
+            let response = rest::send_request(
+                &factory,
+                service,
+                &format!("{}/devices", ACCOUNTS_URL_PREFIX),
+                Method::GET,
+                Some((access_proxy, account)),
+                &[StatusCode::OK],
+            )
+            .await;
+            rest::deserialize_body(response?).await
+        }
+    }
+
+    pub fn remove(
+        &self,
+        account: AccountToken,
+        id: DeviceId,
+    ) -> impl Future<Output = Result<(), rest::Error>> {
+        let service = self.handle.service.clone();
+        let factory = self.handle.factory.clone();
+        let access_proxy = self.handle.token_store.clone();
+        async move {
+            let response = rest::send_request(
+                &factory,
+                service,
+                &format!("{}/devices/{}", ACCOUNTS_URL_PREFIX, id),
+                Method::DELETE,
+                Some((access_proxy, account)),
+                &[StatusCode::NO_CONTENT],
+            )
+            .await;
+
+            response?;
+            Ok(())
+        }
+    }
+
+    pub fn replace_wg_key(
+        &self,
+        account: AccountToken,
+        id: DeviceId,
+        pubkey: wireguard::PublicKey,
+    ) -> impl Future<Output = Result<mullvad_types::wireguard::AssociatedAddresses, rest::Error>>
+    {
+        #[derive(serde::Serialize)]
+        struct RotateDevicePubkey {
+            pubkey: wireguard::PublicKey,
+        }
+        let req_body = RotateDevicePubkey { pubkey };
+
+        let service = self.handle.service.clone();
+        let factory = self.handle.factory.clone();
+        let access_proxy = self.handle.token_store.clone();
+
+        async move {
+            let response = rest::send_json_request(
+                &factory,
+                service,
+                &format!("{}/devices/{}/pubkey", ACCOUNTS_URL_PREFIX, id),
+                Method::PUT,
+                &req_body,
+                Some((access_proxy, account)),
+                &[StatusCode::OK],
+            )
+            .await;
+
+            let updated_device: DeviceResponse = rest::deserialize_body(response?).await?;
+            let DeviceResponse {
+                ipv4_address,
+                ipv6_address,
+                ..
+            } = updated_device;
+            Ok(mullvad_types::wireguard::AssociatedAddresses {
+                ipv4_address,
+                ipv6_address,
+            })
+        }
+    }
+}
diff --git a/mullvad-rpc/src/lib.rs b/mullvad-rpc/src/lib.rs
index 9e6f42bb23..f93d27262a 100644
--- a/mullvad-rpc/src/lib.rs
+++ b/mullvad-rpc/src/lib.rs
@@ -7,7 +7,6 @@ use futures::Stream;
 use hyper::Method;
 use mullvad_types::{
     account::{AccountToken, VoucherSubmission},
-    device::{Device, DeviceId, DeviceName, DevicePort},
     version::AppVersion,
 };
 use proxy::ApiConnectionMode;
@@ -17,7 +16,7 @@ use std::{
     net::{IpAddr, Ipv4Addr, SocketAddr},
     path::Path,
 };
-use talpid_types::{net::wireguard, ErrorExt};
+use talpid_types::ErrorExt;
 
 pub mod availability;
 use availability::{ApiAvailability, ApiAvailabilityHandle};
@@ -32,8 +31,10 @@ pub use crate::https_client_with_sni::SocketBypassRequest;
 
 mod access;
 mod address_cache;
+pub mod device;
 mod relay_list;
 pub use address_cache::AddressCache;
+pub use device::DevicesProxy;
 pub use hyper::StatusCode;
 pub use relay_list::RelayListProxy;
 
@@ -411,191 +412,6 @@ impl AccountsProxy {
     }
 }
 
-#[derive(Clone)]
-pub struct DevicesProxy {
-    handle: rest::MullvadRestHandle,
-}
-
-#[derive(serde::Deserialize)]
-struct DeviceResponse {
-    id: DeviceId,
-    name: DeviceName,
-    pubkey: wireguard::PublicKey,
-    ipv4_address: ipnetwork::Ipv4Network,
-    ipv6_address: ipnetwork::Ipv6Network,
-    ports: Vec<DevicePort>,
-}
-
-impl DevicesProxy {
-    pub fn new(handle: rest::MullvadRestHandle) -> Self {
-        Self { handle }
-    }
-
-    pub fn create(
-        &self,
-        account: AccountToken,
-        pubkey: wireguard::PublicKey,
-    ) -> impl Future<Output = Result<(Device, mullvad_types::wireguard::AssociatedAddresses), rest::Error>>
-    {
-        #[derive(serde::Serialize)]
-        struct DeviceSubmission {
-            pubkey: wireguard::PublicKey,
-        }
-
-        let submission = DeviceSubmission { pubkey };
-
-        let service = self.handle.service.clone();
-        let factory = self.handle.factory.clone();
-        let access_proxy = self.handle.token_store.clone();
-
-        async move {
-            let response = rest::send_json_request(
-                &factory,
-                service,
-                &format!("{}/devices", ACCOUNTS_URL_PREFIX),
-                Method::POST,
-                &submission,
-                Some((access_proxy, account)),
-                &[StatusCode::CREATED],
-            )
-            .await;
-
-            let response: DeviceResponse = rest::deserialize_body(response?).await?;
-            let DeviceResponse {
-                id,
-                name,
-                pubkey,
-                ipv4_address,
-                ipv6_address,
-                ports,
-                ..
-            } = response;
-
-            Ok((
-                Device {
-                    id,
-                    name,
-                    pubkey,
-                    ports,
-                },
-                mullvad_types::wireguard::AssociatedAddresses {
-                    ipv4_address,
-                    ipv6_address,
-                },
-            ))
-        }
-    }
-
-    pub fn get(
-        &self,
-        account: AccountToken,
-        id: DeviceId,
-    ) -> impl Future<Output = Result<Device, rest::Error>> {
-        let service = self.handle.service.clone();
-        let factory = self.handle.factory.clone();
-        let access_proxy = self.handle.token_store.clone();
-        async move {
-            let response = rest::send_request(
-                &factory,
-                service,
-                &format!("{}/devices/{}", ACCOUNTS_URL_PREFIX, id),
-                Method::GET,
-                Some((access_proxy, account)),
-                &[StatusCode::OK],
-            )
-            .await;
-            rest::deserialize_body(response?).await
-        }
-    }
-
-    pub fn list(
-        &self,
-        account: AccountToken,
-    ) -> impl Future<Output = Result<Vec<Device>, rest::Error>> {
-        let service = self.handle.service.clone();
-        let factory = self.handle.factory.clone();
-        let access_proxy = self.handle.token_store.clone();
-        async move {
-            let response = rest::send_request(
-                &factory,
-                service,
-                &format!("{}/devices", ACCOUNTS_URL_PREFIX),
-                Method::GET,
-                Some((access_proxy, account)),
-                &[StatusCode::OK],
-            )
-            .await;
-            rest::deserialize_body(response?).await
-        }
-    }
-
-    pub fn remove(
-        &self,
-        account: AccountToken,
-        id: DeviceId,
-    ) -> impl Future<Output = Result<(), rest::Error>> {
-        let service = self.handle.service.clone();
-        let factory = self.handle.factory.clone();
-        let access_proxy = self.handle.token_store.clone();
-        async move {
-            let response = rest::send_request(
-                &factory,
-                service,
-                &format!("{}/devices/{}", ACCOUNTS_URL_PREFIX, id),
-                Method::DELETE,
-                Some((access_proxy, account)),
-                &[StatusCode::NO_CONTENT],
-            )
-            .await;
-
-            response?;
-            Ok(())
-        }
-    }
-
-    pub fn replace_wg_key(
-        &self,
-        account: AccountToken,
-        id: DeviceId,
-        pubkey: wireguard::PublicKey,
-    ) -> impl Future<Output = Result<mullvad_types::wireguard::AssociatedAddresses, rest::Error>>
-    {
-        #[derive(serde::Serialize)]
-        struct RotateDevicePubkey {
-            pubkey: wireguard::PublicKey,
-        }
-        let req_body = RotateDevicePubkey { pubkey };
-
-        let service = self.handle.service.clone();
-        let factory = self.handle.factory.clone();
-        let access_proxy = self.handle.token_store.clone();
-
-        async move {
-            let response = rest::send_json_request(
-                &factory,
-                service,
-                &format!("{}/devices/{}/pubkey", ACCOUNTS_URL_PREFIX, id),
-                Method::PUT,
-                &req_body,
-                Some((access_proxy, account)),
-                &[StatusCode::OK],
-            )
-            .await;
-
-            let updated_device: DeviceResponse = rest::deserialize_body(response?).await?;
-            let DeviceResponse {
-                ipv4_address,
-                ipv6_address,
-                ..
-            } = updated_device;
-            Ok(mullvad_types::wireguard::AssociatedAddresses {
-                ipv4_address,
-                ipv6_address,
-            })
-        }
-    }
-}
-
 pub struct ProblemReportProxy {
     handle: rest::MullvadRestHandle,
 }