Reuse RPC connection in `DaemonRpcClient`

12 files changed, 47 insertions, 50 deletions

diff --git a/mullvad-cli/src/cmds/account.rs b/mullvad-cli/src/cmds/account.rs
index 65d7d1f904..5ad7822222 100644
--- a/mullvad-cli/src/cmds/account.rs
+++ b/mullvad-cli/src/cmds/account.rs
@@ -50,7 +50,7 @@ impl Command for Account {
 
 impl Account {
     fn set(&self, token: Option<AccountToken>) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.set_account(token.clone())?;
         if let Some(token) = token {
             println!("Mullvad account \"{}\" set", token);
@@ -61,7 +61,7 @@ impl Account {
     }
 
     fn get(&self) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let account_token = rpc.get_account()?;
         if let Some(account_token) = account_token {
             println!("Mullvad account: {}", account_token);
diff --git a/mullvad-cli/src/cmds/connect.rs b/mullvad-cli/src/cmds/connect.rs
index 50308b2b82..b9da45618d 100644
--- a/mullvad-cli/src/cmds/connect.rs
+++ b/mullvad-cli/src/cmds/connect.rs
@@ -17,7 +17,7 @@ impl Command for Connect {
     }
 
     fn run(&self, _matches: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.connect()?;
         Ok(())
     }
diff --git a/mullvad-cli/src/cmds/disconnect.rs b/mullvad-cli/src/cmds/disconnect.rs
index ee1337a10d..70e5699545 100644
--- a/mullvad-cli/src/cmds/disconnect.rs
+++ b/mullvad-cli/src/cmds/disconnect.rs
@@ -17,7 +17,7 @@ impl Command for Disconnect {
     }
 
     fn run(&self, _matches: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.disconnect()?;
         Ok(())
     }
diff --git a/mullvad-cli/src/cmds/lan.rs b/mullvad-cli/src/cmds/lan.rs
index 84830eae87..7f6b3a0444 100644
--- a/mullvad-cli/src/cmds/lan.rs
+++ b/mullvad-cli/src/cmds/lan.rs
@@ -43,14 +43,14 @@ impl Command for Lan {
 
 impl Lan {
     fn set(&self, allow_lan: bool) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.set_allow_lan(allow_lan)?;
         println!("Changed local network sharing setting");
         Ok(())
     }
 
     fn get(&self) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let allow_lan = rpc.get_allow_lan()?;
         println!(
             "Local network sharing setting: {}",
diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index 0df0e46b4f..27aaf3d6b4 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -3,12 +3,14 @@ use std::str::FromStr;
 use {Command, Result, ResultExt};
 
 use mullvad_ipc_client::DaemonRpcClient;
-use mullvad_types::relay_constraints::{Constraint, LocationConstraint, OpenVpnConstraints,
-                                       RelayConstraintsUpdate, RelaySettingsUpdate,
-                                       TunnelConstraints};
+use mullvad_types::relay_constraints::{
+    Constraint, LocationConstraint, OpenVpnConstraints, RelayConstraintsUpdate,
+    RelaySettingsUpdate, TunnelConstraints,
+};
 use mullvad_types::CustomTunnelEndpoint;
-use talpid_types::net::{OpenVpnEndpointData, TransportProtocol, TunnelEndpointData,
-                        WireguardEndpointData};
+use talpid_types::net::{
+    OpenVpnEndpointData, TransportProtocol, TunnelEndpointData, WireguardEndpointData,
+};
 
 pub struct Relay;
 
@@ -113,7 +115,7 @@ impl Command for Relay {
 
 impl Relay {
     fn update_constraints(&self, update: RelaySettingsUpdate) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.update_relay_settings(update)?;
         println!("Relay constraints updated");
         Ok(())
@@ -183,7 +185,7 @@ impl Relay {
     }
 
     fn get(&self) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let constraints = rpc.get_relay_settings()?;
         println!("Current constraints: {:#?}", constraints);
 
@@ -191,7 +193,7 @@ impl Relay {
     }
 
     fn list(&self, _matches: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let mut locations = rpc.get_relay_locations()?;
         locations.countries.sort_by(|c1, c2| c1.name.cmp(&c2.name));
         for mut country in locations.countries {
diff --git a/mullvad-cli/src/cmds/shutdown.rs b/mullvad-cli/src/cmds/shutdown.rs
index 43bc3342fd..f56ba0a972 100644
--- a/mullvad-cli/src/cmds/shutdown.rs
+++ b/mullvad-cli/src/cmds/shutdown.rs
@@ -15,7 +15,7 @@ impl Command for Shutdown {
     }
 
     fn run(&self, _matches: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         rpc.shutdown()?;
         Ok(())
     }
diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index a869fd5eb6..f6a41f8813 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -17,7 +17,7 @@ impl Command for Status {
     }
 
     fn run(&self, _matches: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let state = rpc.get_state()?;
         print!("Tunnel status: ");
         match (state.state, state.target_state) {
diff --git a/mullvad-cli/src/cmds/tunnel.rs b/mullvad-cli/src/cmds/tunnel.rs
index c83d6e0b98..b06b7df3ee 100644
--- a/mullvad-cli/src/cmds/tunnel.rs
+++ b/mullvad-cli/src/cmds/tunnel.rs
@@ -71,7 +71,7 @@ impl Tunnel {
                 Some(mssfix_str.parse()?)
             };
 
-            let rpc = DaemonRpcClient::new()?;
+            let mut rpc = DaemonRpcClient::new()?;
             rpc.set_openvpn_mssfix(mssfix)?;
             println!("mssfix parameter updated");
             Ok(())
@@ -81,7 +81,7 @@ impl Tunnel {
     }
 
     fn get_tunnel_options() -> Result<TunnelOptions> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         Ok(rpc.get_tunnel_options()?)
     }
 
diff --git a/mullvad-cli/src/cmds/version.rs b/mullvad-cli/src/cmds/version.rs
index 468dc35ee9..c3adca3040 100644
--- a/mullvad-cli/src/cmds/version.rs
+++ b/mullvad-cli/src/cmds/version.rs
@@ -16,7 +16,7 @@ impl Command for Version {
     }
 
     fn run(&self, _: &clap::ArgMatches) -> Result<()> {
-        let rpc = DaemonRpcClient::new()?;
+        let mut rpc = DaemonRpcClient::new()?;
         let current_version = rpc.get_current_version()?;
         println!("Current version: {}", current_version);
         let version_info = rpc.get_version_info()?;
diff --git a/mullvad-daemon/src/rpc_uniqueness_check.rs b/mullvad-daemon/src/rpc_uniqueness_check.rs
index fd889cdddf..96f1e9c15c 100644
--- a/mullvad-daemon/src/rpc_uniqueness_check.rs
+++ b/mullvad-daemon/src/rpc_uniqueness_check.rs
@@ -9,7 +9,7 @@ use mullvad_ipc_client::DaemonRpcClient;
 /// other daemon has stopped.
 pub fn is_another_instance_running() -> bool {
     match DaemonRpcClient::new() {
-        Ok(client) => match client.get_state() {
+        Ok(mut client) => match client.get_state() {
             Ok(_) => true,
             Err(error) => {
                 let chained_error = error.chain_err(|| {
diff --git a/mullvad-daemon/tests/common/mod.rs b/mullvad-daemon/tests/common/mod.rs
index 84bd84a3ed..5356f4ee1e 100644
--- a/mullvad-daemon/tests/common/mod.rs
+++ b/mullvad-daemon/tests/common/mod.rs
@@ -99,7 +99,7 @@ impl DaemonRunner {
     fn request_clean_shutdown(&mut self, _: &mut duct::Handle) -> bool {
         use self::mullvad_ipc_client::DaemonRpcClient;
 
-        if let Ok(rpc_client) = DaemonRpcClient::new() {
+        if let Ok(mut rpc_client) = DaemonRpcClient::new() {
             rpc_client.shutdown().is_ok()
         } else {
             false
diff --git a/mullvad-ipc-client/src/lib.rs b/mullvad-ipc-client/src/lib.rs
index 8139b6d714..8123c66bb0 100644
--- a/mullvad-ipc-client/src/lib.rs
+++ b/mullvad-ipc-client/src/lib.rs
@@ -69,18 +69,16 @@ error_chain! {
 static NO_ARGS: [u8; 0] = [];
 
 pub struct DaemonRpcClient {
-    address: String,
-    credentials: String,
+    rpc_client: WsIpcClient,
 }
 
 impl DaemonRpcClient {
     pub fn new() -> Result<Self> {
         let (address, credentials) = Self::read_rpc_file()?;
+        let rpc_client =
+            WsIpcClient::connect(&address).chain_err(|| ErrorKind::StartRpcClient(address))?;
 
-        Ok(DaemonRpcClient {
-            address,
-            credentials,
-        })
+        Ok(DaemonRpcClient { rpc_client })
     }
 
     fn read_rpc_file() -> Result<(String, String)> {
@@ -110,87 +108,84 @@ impl DaemonRpcClient {
         Ok((address, credentials))
     }
 
-    pub fn auth(&self, credentials: &str) -> Result<()> {
+    pub fn auth(&mut self, credentials: &str) -> Result<()> {
         self.call("auth", &[credentials])
     }
 
-    pub fn connect(&self) -> Result<()> {
+    pub fn connect(&mut self) -> Result<()> {
         self.call("connect", &NO_ARGS)
     }
 
-    pub fn disconnect(&self) -> Result<()> {
+    pub fn disconnect(&mut self) -> Result<()> {
         self.call("disconnect", &NO_ARGS)
     }
 
-    pub fn get_account(&self) -> Result<Option<AccountToken>> {
+    pub fn get_account(&mut self) -> Result<Option<AccountToken>> {
         self.call("get_account", &NO_ARGS)
     }
 
-    pub fn get_account_data(&self, account: AccountToken) -> Result<AccountData> {
+    pub fn get_account_data(&mut self, account: AccountToken) -> Result<AccountData> {
         self.call("get_account_data", &[account])
     }
 
-    pub fn get_allow_lan(&self) -> Result<bool> {
+    pub fn get_allow_lan(&mut self) -> Result<bool> {
         self.call("get_allow_lan", &NO_ARGS)
     }
 
-    pub fn get_current_location(&self) -> Result<GeoIpLocation> {
+    pub fn get_current_location(&mut self) -> Result<GeoIpLocation> {
         self.call("get_current_location", &NO_ARGS)
     }
 
-    pub fn get_current_version(&self) -> Result<String> {
+    pub fn get_current_version(&mut self) -> Result<String> {
         self.call("get_current_version", &NO_ARGS)
     }
 
-    pub fn get_relay_locations(&self) -> Result<RelayList> {
+    pub fn get_relay_locations(&mut self) -> Result<RelayList> {
         self.call("get_relay_locations", &NO_ARGS)
     }
 
-    pub fn get_relay_settings(&self) -> Result<RelaySettings> {
+    pub fn get_relay_settings(&mut self) -> Result<RelaySettings> {
         self.call("get_relay_settings", &NO_ARGS)
     }
 
-    pub fn get_state(&self) -> Result<DaemonState> {
+    pub fn get_state(&mut self) -> Result<DaemonState> {
         self.call("get_state", &NO_ARGS)
     }
 
-    pub fn get_tunnel_options(&self) -> Result<TunnelOptions> {
+    pub fn get_tunnel_options(&mut self) -> Result<TunnelOptions> {
         self.call("get_tunnel_options", &NO_ARGS)
     }
 
-    pub fn get_version_info(&self) -> Result<AppVersionInfo> {
+    pub fn get_version_info(&mut self) -> Result<AppVersionInfo> {
         self.call("get_version_info", &NO_ARGS)
     }
 
-    pub fn set_account(&self, account: Option<AccountToken>) -> Result<()> {
+    pub fn set_account(&mut self, account: Option<AccountToken>) -> Result<()> {
         self.call("set_account", &[account])
     }
 
-    pub fn set_allow_lan(&self, allow_lan: bool) -> Result<()> {
+    pub fn set_allow_lan(&mut self, allow_lan: bool) -> Result<()> {
         self.call("set_allow_lan", &[allow_lan])
     }
 
-    pub fn set_openvpn_mssfix(&self, mssfix: Option<u16>) -> Result<()> {
+    pub fn set_openvpn_mssfix(&mut self, mssfix: Option<u16>) -> Result<()> {
         self.call("set_openvpn_mssfix", &[mssfix])
     }
 
-    pub fn shutdown(&self) -> Result<()> {
+    pub fn shutdown(&mut self) -> Result<()> {
         self.call("shutdown", &NO_ARGS)
     }
 
-    pub fn update_relay_settings(&self, update: RelaySettingsUpdate) -> Result<()> {
+    pub fn update_relay_settings(&mut self, update: RelaySettingsUpdate) -> Result<()> {
         self.call("update_relay_settings", &[update])
     }
 
-    pub fn call<A, O>(&self, method: &str, args: &A) -> Result<O>
+    pub fn call<A, O>(&mut self, method: &str, args: &A) -> Result<O>
     where
         A: Serialize,
         O: for<'de> Deserialize<'de>,
     {
-        let mut rpc_client = WsIpcClient::connect(&self.address)
-            .chain_err(|| ErrorKind::StartRpcClient(self.address.clone()))?;
-
-        rpc_client
+        self.rpc_client
             .call(method, args)
             .chain_err(|| ErrorKind::RpcCallError(method.to_owned()))
     }