Replace UpdateRelaySettings with SetRelaySettings

3 files changed, 6 insertions, 200 deletions

diff --git a/mullvad-management-interface/proto/management_interface.proto b/mullvad-management-interface/proto/management_interface.proto
index 4846f896e2..35417584b3 100644
--- a/mullvad-management-interface/proto/management_interface.proto
+++ b/mullvad-management-interface/proto/management_interface.proto
@@ -28,9 +28,9 @@ service ManagementService {
 
   // Relays and tunnel constraints
   rpc UpdateRelayLocations(google.protobuf.Empty) returns (google.protobuf.Empty) {}
-  rpc UpdateRelaySettings(RelaySettingsUpdate) returns (google.protobuf.Empty) {}
   rpc GetRelayLocations(google.protobuf.Empty) returns (RelayList) {}
   rpc GetCurrentLocation(google.protobuf.Empty) returns (GeoIpLocation) {}
+  rpc SetRelaySettings(RelaySettings) returns (google.protobuf.Empty) {}
   rpc SetBridgeSettings(BridgeSettings) returns (google.protobuf.Empty) {}
   rpc SetBridgeState(BridgeState) returns (google.protobuf.Empty) {}
   rpc SetObfuscationSettings(ObfuscationSettings) returns (google.protobuf.Empty) {}
@@ -101,13 +101,6 @@ service ManagementService {
 
 message UUID { string value = 1; }
 
-message RelaySettingsUpdate {
-  oneof type {
-    CustomRelaySettings custom = 1;
-    NormalRelaySettingsUpdate normal = 2;
-  }
-}
-
 message AccountData { google.protobuf.Timestamp expiry = 1; }
 
 message AccountHistory { google.protobuf.StringValue token = 1; }
@@ -419,20 +412,6 @@ message NormalRelaySettings {
   Ownership ownership = 6;
 }
 
-// Constraints are only updated for fields that are provided
-message NormalRelaySettingsUpdate {
-  LocationConstraint location = 1;
-  ProviderUpdate providers = 2;
-  TunnelTypeUpdate tunnel_type = 3;
-  WireguardConstraints wireguard_constraints = 4;
-  OpenvpnConstraints openvpn_constraints = 5;
-  OwnershipUpdate ownership = 6;
-}
-
-message ProviderUpdate { repeated string providers = 1; }
-
-message TunnelTypeUpdate { optional TunnelType tunnel_type = 2; }
-
 message TransportPort {
   TransportProtocol protocol = 1;
   optional uint32 port = 2;
@@ -440,8 +419,6 @@ message TransportPort {
 
 message OpenvpnConstraints { TransportPort port = 1; }
 
-message OwnershipUpdate { Ownership ownership = 1; }
-
 enum IpVersion {
   V4 = 0;
   V6 = 1;
diff --git a/mullvad-management-interface/src/client.rs b/mullvad-management-interface/src/client.rs
index 417083e161..1c15a169cd 100644
--- a/mullvad-management-interface/src/client.rs
+++ b/mullvad-management-interface/src/client.rs
@@ -8,7 +8,7 @@ use mullvad_types::{
     custom_list::{CustomList, Id},
     device::{Device, DeviceEvent, DeviceId, DeviceState, RemoveDeviceEvent},
     location::GeoIpLocation,
-    relay_constraints::{BridgeSettings, BridgeState, ObfuscationSettings, RelaySettingsUpdate},
+    relay_constraints::{BridgeSettings, BridgeState, ObfuscationSettings, RelaySettings},
     relay_list::RelayList,
     settings::{DnsOptions, Settings},
     states::TunnelState,
@@ -221,10 +221,10 @@ impl MullvadProxyClient {
         Ok(())
     }
 
-    pub async fn update_relay_settings(&mut self, update: RelaySettingsUpdate) -> Result<()> {
-        let update = types::RelaySettingsUpdate::from(update);
+    pub async fn set_relay_settings(&mut self, update: RelaySettings) -> Result<()> {
+        let update = types::RelaySettings::from(update);
         self.0
-            .update_relay_settings(update)
+            .set_relay_settings(update)
             .await
             .map_err(Error::Rpc)?;
         Ok(())
diff --git a/mullvad-management-interface/src/types/conversions/relay_constraints.rs b/mullvad-management-interface/src/types/conversions/relay_constraints.rs
index b33bf3c165..cff2bb5847 100644
--- a/mullvad-management-interface/src/types/conversions/relay_constraints.rs
+++ b/mullvad-management-interface/src/types/conversions/relay_constraints.rs
@@ -1,10 +1,9 @@
 use crate::types::{conversions::net::try_tunnel_type_from_i32, proto, FromProtobufTypeError};
 use mullvad_types::{
     custom_list::Id,
-    relay_constraints::{Constraint, GeographicLocationConstraint, RelaySettingsUpdate},
+    relay_constraints::{Constraint, GeographicLocationConstraint},
 };
 use std::str::FromStr;
-use talpid_types::net::TunnelType;
 
 impl TryFrom<&proto::WireguardConstraints>
     for mullvad_types::relay_constraints::WireguardConstraints
@@ -131,176 +130,6 @@ impl TryFrom<proto::RelaySettings> for mullvad_types::relay_constraints::RelaySe
     }
 }
 
-impl From<RelaySettingsUpdate> for proto::RelaySettingsUpdate {
-    fn from(relay_settings_update: RelaySettingsUpdate) -> Self {
-        match relay_settings_update {
-            RelaySettingsUpdate::Normal(constraints) => proto::RelaySettingsUpdate {
-                r#type: Some(proto::relay_settings_update::Type::Normal(
-                    proto::NormalRelaySettingsUpdate {
-                        location: constraints
-                            .location
-                            .and_then(|constraint| match constraint {
-                                Constraint::Any => None,
-                                Constraint::Only(location) => {
-                                    Some(proto::LocationConstraint::from(location))
-                                }
-                            }),
-                        providers: constraints
-                            .providers
-                            .map(|constraint| proto::ProviderUpdate {
-                                providers: convert_providers_constraint(&constraint),
-                            }),
-                        ownership: constraints
-                            .ownership
-                            .map(|ownership| proto::OwnershipUpdate {
-                                ownership: i32::from(convert_ownership_constraint(&ownership)),
-                            }),
-                        tunnel_type: constraints.tunnel_protocol.map(|protocol| {
-                            proto::TunnelTypeUpdate {
-                                tunnel_type: protocol
-                                    .map(|protocol| {
-                                        i32::from(match protocol {
-                                            TunnelType::Wireguard => proto::TunnelType::Wireguard,
-                                            TunnelType::OpenVpn => proto::TunnelType::Openvpn,
-                                        })
-                                    })
-                                    .option(),
-                            }
-                        }),
-                        wireguard_constraints: constraints.wireguard_constraints.map(
-                            |wireguard_constraints| proto::WireguardConstraints {
-                                port: wireguard_constraints.port.map(u32::from).option(),
-                                ip_version: wireguard_constraints
-                                    .ip_version
-                                    .option()
-                                    .map(|ipv| i32::from(proto::IpVersion::from(ipv))),
-                                use_multihop: wireguard_constraints.use_multihop,
-                                entry_location: wireguard_constraints
-                                    .entry_location
-                                    .option()
-                                    .map(proto::LocationConstraint::from),
-                            },
-                        ),
-                        openvpn_constraints: constraints.openvpn_constraints.map(
-                            |openvpn_constraints| proto::OpenvpnConstraints {
-                                port: openvpn_constraints
-                                    .port
-                                    .option()
-                                    .map(proto::TransportPort::from),
-                            },
-                        ),
-                    },
-                )),
-            },
-            RelaySettingsUpdate::CustomTunnelEndpoint(endpoint) => proto::RelaySettingsUpdate {
-                r#type: Some(proto::relay_settings_update::Type::Custom(
-                    proto::CustomRelaySettings {
-                        host: endpoint.host.to_string(),
-                        config: Some(proto::ConnectionConfig::from(endpoint.config)),
-                    },
-                )),
-            },
-        }
-    }
-}
-
-impl TryFrom<proto::RelaySettingsUpdate> for mullvad_types::relay_constraints::RelaySettingsUpdate {
-    type Error = FromProtobufTypeError;
-
-    fn try_from(
-        settings: proto::RelaySettingsUpdate,
-    ) -> Result<mullvad_types::relay_constraints::RelaySettingsUpdate, Self::Error> {
-        use mullvad_types::{relay_constraints as mullvad_constraints, CustomTunnelEndpoint};
-
-        let update_value = settings
-            .r#type
-            .ok_or(FromProtobufTypeError::InvalidArgument(
-                "missing relay settings",
-            ))?;
-
-        match update_value {
-            proto::relay_settings_update::Type::Custom(settings) => {
-                let config = settings
-                    .config
-                    .ok_or(FromProtobufTypeError::InvalidArgument(
-                        "missing relay connection config",
-                    ))?;
-                let config = mullvad_types::ConnectionConfig::try_from(config)?;
-                Ok(
-                    mullvad_constraints::RelaySettingsUpdate::CustomTunnelEndpoint(
-                        CustomTunnelEndpoint {
-                            host: settings.host,
-                            config,
-                        },
-                    ),
-                )
-            }
-
-            proto::relay_settings_update::Type::Normal(settings) => {
-                // If `location` isn't provided, no changes are made.
-                // If `location` is provided, but is an empty vector,
-                // then the constraint is set to `Constraint::Any`.
-                let location = settings.location.and_then(|loc| {
-                    Constraint::<mullvad_types::relay_constraints::LocationConstraint>::try_from(
-                        loc,
-                    )
-                    .ok()
-                });
-                let providers = if let Some(ref provider_update) = settings.providers {
-                    Some(try_providers_constraint_from_proto(
-                        &provider_update.providers,
-                    )?)
-                } else {
-                    None
-                };
-                let ownership = if let Some(ref ownership_update) = settings.ownership {
-                    Some(try_ownership_constraint_from_i32(
-                        ownership_update.ownership,
-                    )?)
-                } else {
-                    None
-                };
-                let tunnel_protocol = if let Some(update) = settings.tunnel_type {
-                    Some(Constraint::from(
-                        update
-                            .tunnel_type
-                            .map(try_tunnel_type_from_i32)
-                            .transpose()?,
-                    ))
-                } else {
-                    None
-                };
-                let openvpn_constraints =
-                    if let Some(ref constraints) = settings.openvpn_constraints {
-                        Some(mullvad_constraints::OpenVpnConstraints::try_from(
-                            constraints,
-                        )?)
-                    } else {
-                        None
-                    };
-                let wireguard_constraints =
-                    if let Some(ref constraints) = settings.wireguard_constraints {
-                        Some(mullvad_constraints::WireguardConstraints::try_from(
-                            constraints,
-                        )?)
-                    } else {
-                        None
-                    };
-                Ok(mullvad_constraints::RelaySettingsUpdate::Normal(
-                    mullvad_constraints::RelayConstraintsUpdate {
-                        location,
-                        providers,
-                        ownership,
-                        tunnel_protocol,
-                        wireguard_constraints,
-                        openvpn_constraints,
-                    },
-                ))
-            }
-        }
-    }
-}
-
 impl From<mullvad_types::relay_constraints::BridgeState> for proto::BridgeState {
     fn from(state: mullvad_types::relay_constraints::BridgeState) -> Self {
         use mullvad_types::relay_constraints::BridgeState;