Move ResolvedLocationConstraint to mullvad-relay-selector

Author: MarkusPettersson98

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

@@ -3,8 +3,8 @@ use mullvad_types::{
     constraints::{Constraint, Match},
     custom_list::CustomListsSettings,
     relay_constraints::{
-        BridgeState, InternalBridgeConstraints, Ownership, Providers, ResolvedLocationConstraint,
-        TransportPort,
+        BridgeState, GeographicLocationConstraint, InternalBridgeConstraints, LocationConstraint,
+        Ownership, Providers, TransportPort,
     },
     relay_list::{
         OpenVpnEndpoint, OpenVpnEndpointData, Relay, RelayEndpointData, WireguardEndpointData,
@@ -286,3 +286,66 @@ fn openvpn_filter_on_port(port: Constraint<TransportPort>, endpoint: &OpenVpnEnd
             .any(|port| compatible_port(transport_port, port)),
     }
 }
+
+// -- Wrapper around LocationConstraint --
+
+#[derive(Debug, Clone)]
+pub struct ResolvedLocationConstraint(Vec<GeographicLocationConstraint>);
+
+impl<'a> IntoIterator for &'a ResolvedLocationConstraint {
+    type Item = &'a GeographicLocationConstraint;
+
+    type IntoIter = core::slice::Iter<'a, GeographicLocationConstraint>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+impl IntoIterator for ResolvedLocationConstraint {
+    type Item = GeographicLocationConstraint;
+
+    type IntoIter = std::vec::IntoIter<GeographicLocationConstraint>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl FromIterator<GeographicLocationConstraint> for ResolvedLocationConstraint {
+    fn from_iter<T: IntoIterator<Item = GeographicLocationConstraint>>(iter: T) -> Self {
+        Self(Vec::from_iter(iter))
+    }
+}
+
+impl ResolvedLocationConstraint {
+    pub fn from_constraint(
+        location_constraint: Constraint<LocationConstraint>,
+        custom_lists: &CustomListsSettings,
+    ) -> Constraint<ResolvedLocationConstraint> {
+        location_constraint.map(|location| Self::from_location_constraint(location, custom_lists))
+    }
+
+    fn from_location_constraint(
+        location: LocationConstraint,
+        custom_lists: &CustomListsSettings,
+    ) -> ResolvedLocationConstraint {
+        match location {
+            LocationConstraint::Location(location) => Self::from_iter(std::iter::once(location)),
+            LocationConstraint::CustomList { list_id } => custom_lists
+                .iter()
+                .find(|list| list.id == list_id)
+                .map(|custom_list| Self::from_iter(custom_list.locations.clone()))
+                .unwrap_or_else(|| {
+                    log::warn!("Resolved non-existent custom list");
+                    Self::from_iter(std::iter::empty())
+                }),
+        }
+    }
+}
+
+impl Match<Relay> for ResolvedLocationConstraint {
+    fn matches(&self, relay: &Relay) -> bool {
+        self.into_iter().any(|location| location.matches(relay))
+    }
+}

mullvad-types/src/relay_constraints.rs

@@ -85,59 +85,9 @@ pub enum LocationConstraint {
     CustomList { list_id: Id },
 }
 
-#[derive(Debug, Clone)]
-pub struct ResolvedLocationConstraint(Vec<GeographicLocationConstraint>);
-
-impl<'a> IntoIterator for &'a ResolvedLocationConstraint {
-    type Item = &'a GeographicLocationConstraint;
-
-    type IntoIter = core::slice::Iter<'a, GeographicLocationConstraint>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.iter()
-    }
-}
-
-impl IntoIterator for ResolvedLocationConstraint {
-    type Item = GeographicLocationConstraint;
-
-    type IntoIter = std::vec::IntoIter<GeographicLocationConstraint>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_iter()
-    }
-}
-
-impl FromIterator<GeographicLocationConstraint> for ResolvedLocationConstraint {
-    fn from_iter<T: IntoIterator<Item = GeographicLocationConstraint>>(iter: T) -> Self {
-        Self(Vec::from_iter(iter))
-    }
-}
-
-impl ResolvedLocationConstraint {
-    pub fn from_constraint(
-        location_constraint: Constraint<LocationConstraint>,
-        custom_lists: &CustomListsSettings,
-    ) -> Constraint<ResolvedLocationConstraint> {
-        location_constraint.map(|location| Self::from_location_constraint(location, custom_lists))
-    }
-
-    fn from_location_constraint(
-        location: LocationConstraint,
-        custom_lists: &CustomListsSettings,
-    ) -> ResolvedLocationConstraint {
-        match location {
-            LocationConstraint::Location(location) => Self::from_iter(std::iter::once(location)),
-            LocationConstraint::CustomList { list_id } => custom_lists
-                .iter()
-                .find(|list| list.id == list_id)
-                .map(|custom_list| Self::from_iter(custom_list.locations.clone()))
-                .unwrap_or_else(|| {
-                    log::warn!("Resolved non-existent custom list");
-                    Self::from_iter(std::iter::empty())
-                }),
-        }
-    }
+pub struct LocationConstraintFormatter<'a> {
+    pub constraint: &'a LocationConstraint,
+    pub custom_lists: &'a CustomListsSettings,
 }
 
 impl From<GeographicLocationConstraint> for LocationConstraint {
@@ -146,39 +96,6 @@ impl From<GeographicLocationConstraint> for LocationConstraint {
     }
 }
 
-impl Set<Constraint<ResolvedLocationConstraint>> for Constraint<ResolvedLocationConstraint> {
-    fn is_subset(&self, other: &Self) -> bool {
-        match self {
-            Constraint::Any => other.is_any(),
-            Constraint::Only(locations) => match other {
-                Constraint::Any => true,
-                Constraint::Only(other_locations) => {
-                    for location in locations {
-                        if !other_locations
-                            .into_iter()
-                            .any(|other_location| location.is_subset(other_location))
-                        {
-                            return false;
-                        }
-                    }
-                    true
-                }
-            },
-        }
-    }
-}
-
-impl Match<Relay> for ResolvedLocationConstraint {
-    fn matches(&self, relay: &Relay) -> bool {
-        self.into_iter().any(|location| location.matches(relay))
-    }
-}
-
-pub struct LocationConstraintFormatter<'a> {
-    pub constraint: &'a LocationConstraint,
-    pub custom_lists: &'a CustomListsSettings,
-}
-
 impl<'a> fmt::Display for LocationConstraintFormatter<'a> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.constraint {