Add DAITA into TunnelSettings

4 files changed, 45 insertions, 55 deletions

diff --git a/ios/MullvadREST/Relay/RelaySelectorProtocol.swift b/ios/MullvadREST/Relay/RelaySelectorProtocol.swift
index c1de0951aa..44a01f8dc8 100644
--- a/ios/MullvadREST/Relay/RelaySelectorProtocol.swift
+++ b/ios/MullvadREST/Relay/RelaySelectorProtocol.swift
@@ -7,11 +7,12 @@
 //
 
 import Foundation
+import MullvadSettings
 import MullvadTypes
 
 /// Protocol describing a type that can select a relay.
 public protocol RelaySelectorProtocol {
-    func selectRelays(with constraints: RelayConstraints, connectionAttemptCount: UInt) throws -> SelectedRelays
+    func selectRelays(connectionAttemptCount: UInt) throws -> SelectedRelays
 }
 
 /// Struct describing the selected relay.
diff --git a/ios/MullvadREST/Relay/RelaySelectorWrapper.swift b/ios/MullvadREST/Relay/RelaySelectorWrapper.swift
index 3ee447d0ab..839b19f84a 100644
--- a/ios/MullvadREST/Relay/RelaySelectorWrapper.swift
+++ b/ios/MullvadREST/Relay/RelaySelectorWrapper.swift
@@ -11,40 +11,40 @@ import MullvadTypes
 
 public final class RelaySelectorWrapper: RelaySelectorProtocol {
     let relayCache: RelayCacheProtocol
-    let multihopUpdater: MultihopUpdater
-    private var multihopState: MultihopState = .off
-    private var observer: MultihopObserverBlock!
+
+    let tunnelSettingsUpdater: SettingsUpdater
+    private var tunnelSettings = LatestTunnelSettings()
+    private var observer: SettingsObserverBlock!
 
     deinit {
-        self.multihopUpdater.removeObserver(observer)
+        self.tunnelSettingsUpdater.removeObserver(observer)
     }
 
     public init(
         relayCache: RelayCacheProtocol,
-        multihopUpdater: MultihopUpdater
+        tunnelSettingsUpdater: SettingsUpdater
     ) {
         self.relayCache = relayCache
-        self.multihopUpdater = multihopUpdater
+        self.tunnelSettingsUpdater = tunnelSettingsUpdater
 
         self.addObserver()
     }
 
     public func selectRelays(
-        with constraints: RelayConstraints,
         connectionAttemptCount: UInt
     ) throws -> SelectedRelays {
         let relays = try relayCache.read().relays
 
-        switch multihopState {
+        switch tunnelSettings.tunnelMultihopState {
         case .off:
             return try SinglehopPicker(
-                constraints: constraints,
+                constraints: tunnelSettings.relayConstraints,
                 relays: relays,
                 connectionAttemptCount: connectionAttemptCount
             ).pick()
         case .on:
             return try MultihopPicker(
-                constraints: constraints,
+                constraints: tunnelSettings.relayConstraints,
                 relays: relays,
                 connectionAttemptCount: connectionAttemptCount
             ).pick()
@@ -52,10 +52,10 @@ public final class RelaySelectorWrapper: RelaySelectorProtocol {
     }
 
     private func addObserver() {
-        self.observer = MultihopObserverBlock(didUpdateMultihop: { [weak self] _, multihopState in
-            self?.multihopState = multihopState
+        self.observer = SettingsObserverBlock(didUpdateSettings: { [weak self] latestTunnelSettings in
+            self?.tunnelSettings = latestTunnelSettings
         })
 
-        multihopUpdater.addObserver(observer)
+        tunnelSettingsUpdater.addObserver(observer)
     }
 }
diff --git a/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksLoader.swift b/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksLoader.swift
index 2b46571bc8..c35b0692b5 100644
--- a/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksLoader.swift
+++ b/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksLoader.swift
@@ -18,47 +18,42 @@ public protocol ShadowsocksLoaderProtocol {
 public class ShadowsocksLoader: ShadowsocksLoaderProtocol {
     let cache: ShadowsocksConfigurationCacheProtocol
     let relaySelector: ShadowsocksRelaySelectorProtocol
-    let constraintsUpdater: RelayConstraintsUpdater
-    let multihopUpdater: MultihopUpdater
-    private var multihopState: MultihopState = .off
-    private var observer: MultihopObserverBlock!
+    let settingsUpdater: SettingsUpdater
+
+    private var observer: SettingsObserverBlock!
+    private var tunnelSettings = LatestTunnelSettings()
+    private let settingsStrategy = TunnelSettingsStrategy()
 
     deinit {
-        self.multihopUpdater.removeObserver(observer)
+        self.settingsUpdater.removeObserver(observer)
     }
 
-    private var relayConstraints = RelayConstraints()
-
     public init(
         cache: ShadowsocksConfigurationCacheProtocol,
         relaySelector: ShadowsocksRelaySelectorProtocol,
-        constraintsUpdater: RelayConstraintsUpdater,
-        multihopUpdater: MultihopUpdater
+        settingsUpdater: SettingsUpdater
     ) {
         self.cache = cache
         self.relaySelector = relaySelector
-        self.constraintsUpdater = constraintsUpdater
-        self.multihopUpdater = multihopUpdater
+        self.settingsUpdater = settingsUpdater
         self.addObservers()
     }
 
     private func addObservers() {
-        // The constraints gets updated a lot when observing the tunnel, clear the cache if the constraints have changed.
-        constraintsUpdater.onNewConstraints = { [weak self] newConstraints in
-            if self?.relayConstraints != newConstraints {
-                self?.relayConstraints = newConstraints
-                try? self?.clear()
-            }
-        }
-
-        // The multihop state gets updated a lot when observing the tunnel, clear the cache if the multihop settings have changed.
-        self.observer = MultihopObserverBlock(didUpdateMultihop: { [weak self] _, newMultihopState in
-            if self?.multihopState != newMultihopState {
-                self?.multihopState = newMultihopState
-                try? self?.clear()
-            }
-        })
-        multihopUpdater.addObserver(self.observer)
+        observer =
+            SettingsObserverBlock(
+                didUpdateSettings: { [weak self] latestTunnelSettings in
+                    guard let self else { return }
+                    if settingsStrategy.shouldReconnectToNewRelay(
+                        oldSettings: tunnelSettings,
+                        newSettings: latestTunnelSettings
+                    ) {
+                        try? clear()
+                    }
+                    tunnelSettings = latestTunnelSettings
+                }
+            )
+        settingsUpdater.addObserver(self.observer)
     }
 
     public func clear() throws {
@@ -81,7 +76,7 @@ public class ShadowsocksLoader: ShadowsocksLoaderProtocol {
     /// Returns a randomly selected shadowsocks configuration.
     private func create() throws -> ShadowsocksConfiguration {
         let bridgeConfiguration = try relaySelector.getBridges()
-        let closestRelay = try relaySelector.selectRelay(with: relayConstraints, multihopState: multihopState)
+        let closestRelay = try relaySelector.selectRelay(with: tunnelSettings)
 
         guard let bridgeAddress = closestRelay?.ipv4AddrIn,
               let bridgeConfiguration else { throw POSIXError(.ENOENT) }
diff --git a/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksRelaySelector.swift b/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksRelaySelector.swift
index 2519c4065a..c0d83bc701 100644
--- a/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksRelaySelector.swift
+++ b/ios/MullvadREST/Transport/Shadowsocks/ShadowsocksRelaySelector.swift
@@ -11,10 +11,7 @@ import MullvadSettings
 import MullvadTypes
 
 public protocol ShadowsocksRelaySelectorProtocol {
-    func selectRelay(
-        with constraints: RelayConstraints,
-        multihopState: MultihopState
-    ) throws -> REST.BridgeRelay?
+    func selectRelay(with settings: LatestTunnelSettings) throws -> REST.BridgeRelay?
 
     func getBridges() throws -> REST.ServerShadowsocks?
 }
@@ -28,21 +25,18 @@ final public class ShadowsocksRelaySelector: ShadowsocksRelaySelectorProtocol {
         self.relayCache = relayCache
     }
 
-    public func selectRelay(
-        with constraints: RelayConstraints,
-        multihopState: MultihopState
-    ) throws -> REST.BridgeRelay? {
+    public func selectRelay(with settings: LatestTunnelSettings) throws -> REST.BridgeRelay? {
         let cachedRelays = try relayCache.read().relays
 
-        let locationConstraint = switch multihopState {
-        case .on: constraints.entryLocations
-        case .off: constraints.exitLocations
+        let locationConstraint = switch settings.tunnelMultihopState {
+        case .on: settings.relayConstraints.entryLocations
+        case .off: settings.relayConstraints.exitLocations
         }
 
         return RelaySelector.Shadowsocks.closestRelay(
             location: locationConstraint,
-            port: constraints.port,
-            filter: constraints.filter,
+            port: settings.relayConstraints.port,
+            filter: settings.relayConstraints.filter,
             in: cachedRelays
         )
     }