Merge rather than update constraints

3 files changed, 18 insertions, 28 deletions

diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index 1787dc0bee..7817b983e4 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -80,6 +80,6 @@ impl Command for Relay {
 impl Relay {
     fn update_constraints(&self, constraints_update: RelayConstraintsUpdate) -> Result<()> {
         rpc::call("update_relay_constraints", &[constraints_update])
-            .map(|_: Option<()>| println!("relay constraints updated"))
+            .map(|_: Option<()>| println!("Relay constraints updated"))
     }
 }
diff --git a/mullvad-daemon/src/settings.rs b/mullvad-daemon/src/settings.rs
index f217d9a677..587143b3b7 100644
--- a/mullvad-daemon/src/settings.rs
+++ b/mullvad-daemon/src/settings.rs
@@ -137,15 +137,16 @@ impl Settings {
     }
 
     pub fn update_relay_constraints(&mut self, update: RelayConstraintsUpdate) -> Result<bool> {
-        let new_constraints = self.relay_constraints.update(update);
+        let new_constraints = self.relay_constraints.merge(update);
+        if self.relay_constraints != new_constraints {
 
-        if new_constraints {
             debug!(
-                "changed relay constraints from {:?} to {:?}",
+                "changing relay constraints from {:?} to {:?}",
                 self.relay_constraints,
                 new_constraints
             );
 
+            self.relay_constraints = new_constraints;
             self.save().map(|_| true)
         } else {
             Ok(false)
diff --git a/mullvad-types/src/relay_constraints.rs b/mullvad-types/src/relay_constraints.rs
index 6e09b06667..b546cc9703 100644
--- a/mullvad-types/src/relay_constraints.rs
+++ b/mullvad-types/src/relay_constraints.rs
@@ -1,61 +1,50 @@
 use std::str::FromStr;
 use talpid_types::net::TransportProtocol;
 
-#[derive(Debug, Clone, Deserialize, Serialize)]
+#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
 pub struct RelayConstraints {
     pub host: Option<String>,
     pub tunnel: TunnelConstraints,
 }
 
 impl RelayConstraints {
-    pub fn update(&mut self, update: RelayConstraintsUpdate) -> bool {
-        let mut updated = false;
+    pub fn merge(&mut self, update: RelayConstraintsUpdate) -> Self {
 
-        if let Some(new_host) = update.host {
-            self.host = new_host;
-            updated = true;
+        RelayConstraints {
+            host: update.host.unwrap_or_else(|| self.host.clone()),
+            tunnel: self.tunnel.merge(update.tunnel),
         }
-
-        updated || self.tunnel.update(update.tunnel)
     }
 }
 
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
 pub enum TunnelConstraints {
     OpenVpn(OpenVpnConstraints),
 }
 
 impl TunnelConstraints {
-    pub fn update(&mut self, update: TunnelConstraintsUpdate) -> bool {
+    pub fn merge(&mut self, update: TunnelConstraintsUpdate) -> Self {
         match *self {
             TunnelConstraints::OpenVpn(ref mut current) => match update {
-                TunnelConstraintsUpdate::OpenVpn(openvpn_update) => current.update(openvpn_update),
+                TunnelConstraintsUpdate::OpenVpn(openvpn_update) => TunnelConstraints::OpenVpn(current.merge(openvpn_update)),
             },
         }
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
 pub struct OpenVpnConstraints {
     pub port: Port,
     pub protocol: TransportProtocol,
 }
 
 impl OpenVpnConstraints {
-    pub fn update(&mut self, update: OpenVpnConstraintsUpdate) -> bool {
-        let mut updated = false;
-
-        if let Some(new_port) = update.port {
-            self.port = new_port;
-            updated = true;
+    pub fn merge(&mut self, update: OpenVpnConstraintsUpdate) -> Self {
+        OpenVpnConstraints {
+            port: update.port.unwrap_or(self.port),
+            protocol: update.protocol.unwrap_or(self.protocol),
         }
-        if let Some(new_protocol) = update.protocol {
-            self.protocol = new_protocol;
-            updated = true;
-        }
-
-        updated
     }
 }