Remove unneeded trait and complexity

Author: buggmagnet

mullvad-daemon/src/api.rs

@@ -10,33 +10,31 @@ use mullvad_api::{
 };
 use mullvad_encrypted_dns_proxy::state::EncryptedDnsProxyState;
 use mullvad_management_interface::async_trait;
-use mullvad_types::{
-    access_method::{AccessMethod, AccessMethodSetting, BuiltInAccessMethod},
-    relay_list::ShadowsocksBridgeProvider,
-};
+use mullvad_relay_selector::RelaySelector;
+use mullvad_types::access_method::{AccessMethod, AccessMethodSetting, BuiltInAccessMethod};
 #[cfg(target_os = "android")]
 use talpid_core::mpsc::Sender;
 use talpid_types::net::{proxy::CustomProxy, AllowedClients, Connectivity};
 
-pub struct BridgeAndDNSProxyProvider<T> {
-    bridge_provider: T,
+pub struct BridgeAndDNSProxyProvider {
+    relay_selector: RelaySelector,
     encrypted_dns_proxy_cache: EncryptedDnsProxyState,
 }
 
-impl<T: ShadowsocksBridgeProvider> BridgeAndDNSProxyProvider<T> {
-    pub fn new(bridge_provider: T, encrypted_dns_proxy_cache: EncryptedDnsProxyState) -> Self {
+impl BridgeAndDNSProxyProvider {
+    pub fn new(
+        relay_selector: RelaySelector,
+        encrypted_dns_proxy_cache: EncryptedDnsProxyState,
+    ) -> Self {
         Self {
-            bridge_provider,
+            relay_selector,
             encrypted_dns_proxy_cache,
         }
     }
 }
 
 #[async_trait]
-impl<T> BridgeAndDNSProxy for BridgeAndDNSProxyProvider<T>
-where
-    T: ShadowsocksBridgeProvider,
-{
+impl BridgeAndDNSProxy for BridgeAndDNSProxyProvider {
     async fn match_access_method(
         &mut self,
         access_method: &AccessMethodSetting,
@@ -45,7 +43,7 @@ where
             match &access_method.access_method {
                 AccessMethod::BuiltIn(BuiltInAccessMethod::Direct) => ApiConnectionMode::Direct,
                 AccessMethod::BuiltIn(BuiltInAccessMethod::Bridge) => {
-                    let Some(bridge) = self.bridge_provider.get_bridge_forced() else {
+                    let Some(bridge) = self.relay_selector.get_bridge_forced() else {
                         log::warn!("Could not select a Mullvad bridge");
                         log::debug!("The relay list might be empty");
                         return None;

mullvad-relay-selector/src/relay_selector/mod.rs

@@ -39,7 +39,7 @@ use mullvad_types::{
         OpenVpnConstraints, RelayConstraints, RelayOverride, RelaySettings, ResolvedBridgeSettings,
         WireguardConstraints,
     },
-    relay_list::{Relay, RelayEndpointData, RelayList, ShadowsocksBridgeProvider},
+    relay_list::{Relay, RelayEndpointData, RelayList},
     settings::Settings,
     wireguard::QuantumResistantState,
     CustomTunnelEndpoint, Intersection,
@@ -432,47 +432,6 @@ impl<'a> TryFrom<NormalSelectorConfig<'a>> for RelayQuery {
     }
 }
 
-impl ShadowsocksBridgeProvider for RelaySelector {
-    /// Returns a non-custom bridge based on the relay and bridge constraints, ignoring the bridge
-    /// state.
-    fn get_bridge_forced(&self) -> Option<Shadowsocks> {
-        let parsed_relays = &self.parsed_relays.lock().unwrap().parsed_list().clone();
-        let config = self.config.lock().unwrap();
-        let specialized_config = SpecializedSelectorConfig::from(&*config);
-
-        let near_location = match specialized_config {
-            SpecializedSelectorConfig::Normal(config) => RelayQuery::try_from(config.clone())
-                .ok()
-                .and_then(|user_preferences| {
-                    Self::get_relay_midpoint(&user_preferences, parsed_relays, config.custom_lists)
-                }),
-            SpecializedSelectorConfig::Custom(_) => None,
-        };
-
-        let bridge_settings = &config.bridge_settings;
-        let constraints = match bridge_settings.resolve() {
-            Ok(ResolvedBridgeSettings::Normal(settings)) => InternalBridgeConstraints {
-                location: settings.location.clone(),
-                providers: settings.providers.clone(),
-                ownership: settings.ownership,
-                transport_protocol: Constraint::Only(TransportProtocol::Tcp),
-            },
-            _ => InternalBridgeConstraints {
-                location: Constraint::Any,
-                providers: Constraint::Any,
-                ownership: Constraint::Any,
-                transport_protocol: Constraint::Only(TransportProtocol::Tcp),
-            },
-        };
-
-        let custom_lists = &config.custom_lists;
-        Self::get_proxy_settings(parsed_relays, &constraints, near_location, custom_lists)
-            .map(|(settings, _relay)| settings)
-            .inspect_err(|error| log::error!("Failed to get bridge: {error}"))
-            .ok()
-    }
-}
-
 impl RelaySelector {
     /// Returns a new `RelaySelector` backed by relays cached on disk.
     pub fn new(
@@ -545,6 +504,45 @@ impl RelaySelector {
         self.parsed_relays.lock().unwrap().last_updated()
     }
 
+    /// Returns a non-custom bridge based on the relay and bridge constraints, ignoring the bridge
+    /// state.
+    pub fn get_bridge_forced(&self) -> Option<Shadowsocks> {
+        let parsed_relays = &self.parsed_relays.lock().unwrap().parsed_list().clone();
+        let config = self.config.lock().unwrap();
+        let specialized_config = SpecializedSelectorConfig::from(&*config);
+
+        let near_location = match specialized_config {
+            SpecializedSelectorConfig::Normal(config) => RelayQuery::try_from(config.clone())
+                .ok()
+                .and_then(|user_preferences| {
+                    Self::get_relay_midpoint(&user_preferences, parsed_relays, config.custom_lists)
+                }),
+            SpecializedSelectorConfig::Custom(_) => None,
+        };
+
+        let bridge_settings = &config.bridge_settings;
+        let constraints = match bridge_settings.resolve() {
+            Ok(ResolvedBridgeSettings::Normal(settings)) => InternalBridgeConstraints {
+                location: settings.location.clone(),
+                providers: settings.providers.clone(),
+                ownership: settings.ownership,
+                transport_protocol: Constraint::Only(TransportProtocol::Tcp),
+            },
+            _ => InternalBridgeConstraints {
+                location: Constraint::Any,
+                providers: Constraint::Any,
+                ownership: Constraint::Any,
+                transport_protocol: Constraint::Only(TransportProtocol::Tcp),
+            },
+        };
+
+        let custom_lists = &config.custom_lists;
+        Self::get_proxy_settings(parsed_relays, &constraints, near_location, custom_lists)
+            .map(|(settings, _relay)| settings)
+            .inspect_err(|error| log::error!("Failed to get bridge: {error}"))
+            .ok()
+    }
+
     /// Returns random relay and relay endpoint matching `query`.
     pub fn get_relay_by_query(&self, query: RelayQuery) -> Result<GetRelay, Error> {
         let config_guard = self.config.lock().unwrap();

mullvad-types/src/relay_list.rs

@@ -251,7 +251,3 @@ impl ShadowsocksEndpointData {
         }
     }
 }
-
-pub trait ShadowsocksBridgeProvider: Send + Sync {
-    fn get_bridge_forced(&self) -> Option<Shadowsocks>;
-}