Use new-style futures for AccountsProxy

2 files changed, 26 insertions, 45 deletions

diff --git a/mullvad-daemon/src/lib.rs b/mullvad-daemon/src/lib.rs
index 0c5f11ab9d..5a0b3e551b 100644
--- a/mullvad-daemon/src/lib.rs
+++ b/mullvad-daemon/src/lib.rs
@@ -1242,25 +1242,16 @@ where
         tx: oneshot::Sender<Result<String, mullvad_rpc::rest::Error>>,
     ) {
         let daemon_tx = self.tx.clone();
-        let future = self
-            .accounts_proxy
-            .create_account()
-            .then(move |result| -> Result<(), ()> {
-                match result {
-                    Ok(account_token) => {
-                        let _ =
-                            daemon_tx.send(InternalDaemonEvent::NewAccountEvent(account_token, tx));
-                    }
-                    Err(err) => {
-                        let _ = tx.send(Err(err));
-                    }
-                };
-                Ok(())
-            });
+        let future = self.accounts_proxy.create_account();
 
-        tokio::spawn(async {
-            if future.compat().await.is_err() {
-                log::error!("Failed to spawn future for creating a new account");
+        tokio::spawn(async move {
+            match future.await {
+                Ok(account_token) => {
+                    let _ = daemon_tx.send(InternalDaemonEvent::NewAccountEvent(account_token, tx));
+                }
+                Err(err) => {
+                    let _ = tx.send(Err(err));
+                }
             }
         });
     }
@@ -1270,12 +1261,9 @@ where
         tx: oneshot::Sender<Result<AccountData, mullvad_rpc::rest::Error>>,
         account_token: AccountToken,
     ) {
-        let expiry_old_fut = self.accounts_proxy.get_expiry(account_token);
+        let expiry_fut = self.accounts_proxy.get_expiry(account_token);
         let rpc_call = async {
-            let result = expiry_old_fut
-                .compat()
-                .await
-                .map(|expiry| AccountData { expiry });
+            let result = expiry_fut.await.map(|expiry| AccountData { expiry });
             Self::oneshot_send(tx, result, "account data");
         };
         tokio::spawn(rpc_call);
@@ -1286,10 +1274,9 @@ where
         tx: oneshot::Sender<Result<String, mullvad_rpc::rest::Error>>,
     ) {
         if let Some(account_token) = self.settings.get_account_token() {
-            let old_future = self.accounts_proxy.get_www_auth_token(account_token);
+            let future = self.accounts_proxy.get_www_auth_token(account_token);
             let rpc_call = async {
-                let result = old_future.compat().await;
-                Self::oneshot_send(tx, result, "get_www_auth_token response");
+                Self::oneshot_send(tx, future.await, "get_www_auth_token response");
             };
             tokio::spawn(rpc_call);
         }
@@ -1301,10 +1288,9 @@ where
         voucher: String,
     ) {
         if let Some(account_token) = self.settings.get_account_token() {
-            let old_future = self.accounts_proxy.submit_voucher(account_token, voucher);
+            let future = self.accounts_proxy.submit_voucher(account_token, voucher);
             let rpc_call = async {
-                let result = old_future.compat().await;
-                Self::oneshot_send(tx, result, "submit_voucher response");
+                Self::oneshot_send(tx, future.await, "submit_voucher response");
             };
             tokio::spawn(rpc_call);
         }
diff --git a/mullvad-rpc/src/lib.rs b/mullvad-rpc/src/lib.rs
index ad41e0b5c3..60e39f571e 100644
--- a/mullvad-rpc/src/lib.rs
+++ b/mullvad-rpc/src/lib.rs
@@ -1,7 +1,6 @@
 #![deny(rust_2018_idioms)]
 
 use chrono::{offset::Utc, DateTime};
-use futures01::future::Future as Future01;
 use hyper::Method;
 use mullvad_types::{
     account::{AccountToken, VoucherSubmission},
@@ -126,7 +125,7 @@ impl AccountsProxy {
     pub fn get_expiry(
         &self,
         account: AccountToken,
-    ) -> impl Future01<Item = DateTime<Utc>, Error = rest::Error> {
+    ) -> impl Future<Output = Result<DateTime<Utc>, rest::Error>> {
         let service = self.handle.service.clone();
 
         let response = rest::send_request(
@@ -137,13 +136,13 @@ impl AccountsProxy {
             Some(account),
             StatusCode::OK,
         );
-        self.handle.service.compat_spawn(async move {
+        async move {
             let account: AccountResponse = rest::deserialize_body(response.await?).await?;
             Ok(account.expires)
-        })
+        }
     }
 
-    pub fn create_account(&mut self) -> impl Future01<Item = AccountToken, Error = rest::Error> {
+    pub fn create_account(&mut self) -> impl Future<Output = Result<AccountToken, rest::Error>> {
         let service = self.handle.service.clone();
         let response = rest::send_request(
             &self.handle.factory,
@@ -154,17 +153,17 @@ impl AccountsProxy {
             StatusCode::CREATED,
         );
 
-        self.handle.service.compat_spawn(async move {
+        async move {
             let account: AccountResponse = rest::deserialize_body(response.await?).await?;
             Ok(account.token)
-        })
+        }
     }
 
     pub fn submit_voucher(
         &mut self,
         account_token: AccountToken,
         voucher_code: String,
-    ) -> impl Future01<Item = VoucherSubmission, Error = rest::Error> {
+    ) -> impl Future<Output = Result<VoucherSubmission, rest::Error>> {
         #[derive(serde::Serialize)]
         struct VoucherSubmission {
             voucher_code: String,
@@ -182,15 +181,13 @@ impl AccountsProxy {
             StatusCode::OK,
         );
 
-        self.handle
-            .service
-            .compat_spawn(async move { rest::deserialize_body(response.await?).await })
+        async move { rest::deserialize_body(response.await?).await }
     }
 
     pub fn get_www_auth_token(
         &self,
         account: AccountToken,
-    ) -> impl Future01<Item = String, Error = rest::Error> {
+    ) -> impl Future<Output = Result<String, rest::Error>> {
         #[derive(serde::Deserialize)]
         struct AuthTokenResponse {
             auth_token: String,
@@ -206,12 +203,10 @@ impl AccountsProxy {
             StatusCode::OK,
         );
 
-        let future = async move {
+        async move {
             let response: AuthTokenResponse = rest::deserialize_body(response.await?).await?;
             Ok(response.auth_token)
-        };
-
-        self.handle.service.compat_spawn(future)
+        }
     }
 }