Make AddressCache backing non-dynamic, as per Markus' suggestion

Author: acb-mv

mullvad-api/src/address_cache.rs

@@ -30,18 +30,11 @@ pub enum Error {
 /// a backing store for an AddressCache.
 
 #[async_trait]
-pub trait AddressCacheBacking: Sync + Send {
+pub trait AddressCacheBacking: 'static + Sync + Send + std::clone::Clone {
     async fn read(&self) -> Result<Vec<u8>, Error>;
     async fn write(&self, data: &[u8]) -> Result<(), Error>;
 }
 
-// this should allow this to compile.
-impl Debug for dyn AddressCacheBacking {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "[some AddressCacheBacking]")
-    }
-}
-
 #[derive(Clone)]
 pub struct FileAddressCacheBacking {
     read_path: Option<Arc<Path>>,
@@ -74,7 +67,7 @@ impl AddressCacheBacking for FileAddressCacheBacking {
 
 /// A DNS resolver which resolves using `AddressCache`.
 #[async_trait]
-impl DnsResolver for AddressCache {
+impl<T: AddressCacheBacking> DnsResolver for AddressCache<T> {
     async fn resolve(&self, host: String) -> Result<Vec<SocketAddr>, io::Error> {
         self.resolve_hostname(&host)
             .await
@@ -84,69 +77,65 @@ impl DnsResolver for AddressCache {
 }
 
 #[derive(Clone, Debug)]
-pub struct AddressCache {
+pub struct AddressCache<T>
+where
+    T: Clone,
+{
     hostname: String,
     inner: Arc<Mutex<AddressCacheInner>>,
-    backing: Arc<dyn AddressCacheBacking>,
+    backing: Arc<T>,
 }
 
-impl AddressCache {
-    /// Initialise cache using a hardcoded address and a Backing for writing to
-    pub fn new_with_address(endpoint: &ApiEndpoint, backing: Arc<dyn AddressCacheBacking>) -> Self {
-        Self::new_inner(endpoint.address(), endpoint.host().to_owned(), backing)
+impl AddressCache<FileAddressCacheBacking> {
+    /// Initialize cache using `read_path`, and write changes to `write_path`.
+    pub async fn from_file(
+        read_path: &Path,
+        write_path: Option<Box<Path>>,
+        hostname: String,
+    ) -> Result<AddressCache<FileAddressCacheBacking>, Error> {
+        log::debug!("Loading API addresses from {}", read_path.display());
+        let backing = FileAddressCacheBacking {
+            read_path: Some(Arc::from(read_path)),
+            write_path: write_path.map(Arc::from),
+        };
+        AddressCache::from_backing(hostname, Arc::new(backing)).await
     }
 
     /// Initialize cache using the hardcoded address, and write changes to `write_path`.
-    pub fn new(endpoint: &ApiEndpoint, write_path: Option<Box<Path>>) -> AddressCache {
-        AddressCache::new_with_address(
-            endpoint,
-            Arc::new(FileAddressCacheBacking {
-                read_path: None,
-                write_path: write_path.map(Arc::from),
-            }),
-        )
+    pub fn new(
+        endpoint: &ApiEndpoint,
+        write_path: Option<Box<Path>>,
+    ) -> AddressCache<FileAddressCacheBacking> {
+        let backing = FileAddressCacheBacking {
+            read_path: None,
+            write_path: write_path.map(Arc::from),
+        };
+        AddressCache::new_with_address(endpoint, Arc::new(backing))
     }
+}
 
-    pub async fn from_backing(
-        hostname: String,
-        backing: Arc<dyn AddressCacheBacking>,
-    ) -> Result<Self, Error> {
-        let address = read_address_backing(&backing).await?;
+impl<T: AddressCacheBacking + std::clone::Clone> AddressCache<T> {
+    /// Initialise cache using a hardcoded address and a Backing for writing to
+    pub fn new_with_address(endpoint: &ApiEndpoint, backing: Arc<T>) -> Self {
+        Self::new_inner(endpoint.address(), endpoint.host().to_owned(), backing)
+    }
+
+    pub async fn from_backing(hostname: String, backing: Arc<T>) -> Result<Self, Error> {
+        let address = read_address_backing(backing.as_ref()).await?;
         Ok(Self::new_inner(address, hostname, backing))
     }
 
     pub async fn from_backing_or(
         hostname: String,
-        backing: Arc<dyn AddressCacheBacking>,
+        backing: Arc<T>,
         endpoint: &ApiEndpoint,
     ) -> Self {
-        Self::from_backing(hostname.clone(), backing.clone())
+        Self::from_backing(hostname.clone(), Arc::clone(&backing))
             .await
             .unwrap_or(Self::new_inner(endpoint.address(), hostname, backing))
     }
 
-    /// Initialize cache using `read_path`, and write changes to `write_path`.
-    pub async fn from_file(
-        read_path: &Path,
-        write_path: Option<Box<Path>>,
-        hostname: String,
-    ) -> Result<AddressCache, Error> {
-        log::debug!("Loading API addresses from {}", read_path.display());
-        AddressCache::from_backing(
-            hostname,
-            Arc::new(FileAddressCacheBacking {
-                read_path: Some(Arc::from(read_path)),
-                write_path: write_path.map(Arc::from),
-            }),
-        )
-        .await
-    }
-
-    fn new_inner(
-        address: SocketAddr,
-        hostname: String,
-        backing: Arc<dyn AddressCacheBacking>,
-    ) -> Self {
+    fn new_inner(address: SocketAddr, hostname: String, backing: Arc<T>) -> Self {
         let cache = AddressCacheInner::from_address(address);
         log::debug!("Using API address: {}", cache.address);
 
@@ -201,9 +190,7 @@ impl AddressCacheInner {
     }
 }
 
-async fn read_address_backing(
-    backing: &Arc<dyn AddressCacheBacking + 'static>,
-) -> Result<SocketAddr, Error> {
+async fn read_address_backing(backing: &impl AddressCacheBacking) -> Result<SocketAddr, Error> {
     backing
         .read()
         .await

mullvad-api/src/lib.rs

@@ -311,9 +311,12 @@ impl DnsResolver for NullDnsResolver {
 }
 
 /// A type that helps with the creation of API connections.
-pub struct Runtime {
+pub struct Runtime<B = FileAddressCacheBacking>
+where
+    B: AddressCacheBacking,
+{
     handle: tokio::runtime::Handle,
-    address_cache: AddressCache,
+    address_cache: AddressCache<B>,
     api_availability: availability::ApiAvailability,
     endpoint: ApiEndpoint,
     #[cfg(target_os = "android")]
@@ -413,12 +416,29 @@ impl Runtime {
         })
     }
 
+    /// Returns a new request service handle
+    pub fn rest_handle(&self, dns_resolver: impl DnsResolver) -> rest::RequestServiceHandle {
+        self.new_request_service(
+            ApiConnectionMode::Direct.into_provider(),
+            Arc::new(dns_resolver),
+            #[cfg(target_os = "android")]
+            None,
+            #[cfg(any(feature = "api-override", test))]
+            false,
+        )
+    }
+}
+
+impl<B: AddressCacheBacking> Runtime<B> {
     pub async fn with_cache_backing(
         handle: tokio::runtime::Handle,
         endpoint: &ApiEndpoint,
-        backing: Arc<dyn AddressCacheBacking>,
+        backing: Arc<B>,
         #[cfg(target_os = "android")] socket_bypass_tx: Option<mpsc::Sender<SocketBypassRequest>>,
-    ) -> Self {
+    ) -> Runtime<B>
+    where
+        B: AddressCacheBacking,
+    {
         let address_cache =
             AddressCache::from_backing_or(endpoint.host().to_owned(), backing, endpoint).await;
         Runtime {
@@ -431,6 +451,10 @@ impl Runtime {
         }
     }
 
+    pub fn address_cache(&self) -> &AddressCache<B> {
+        &self.address_cache
+    }
+
     /// Returns a request factory initialized to create requests for the master API Assumes an API
     /// endpoint that is constructed from env vars, or uses default values.
     pub fn mullvad_rest_handle<T: ConnectionModeProvider + 'static>(
@@ -452,18 +476,6 @@ impl Runtime {
         rest::MullvadRestHandle::new(service, factory, self.availability_handle())
     }
 
-    /// Returns a new request service handle
-    pub fn rest_handle(&self, dns_resolver: impl DnsResolver) -> rest::RequestServiceHandle {
-        self.new_request_service(
-            ApiConnectionMode::Direct.into_provider(),
-            Arc::new(dns_resolver),
-            #[cfg(target_os = "android")]
-            None,
-            #[cfg(any(feature = "api-override", test))]
-            false,
-        )
-    }
-
     /// Creates a new request service and returns a handle to it.
     fn new_request_service<T: ConnectionModeProvider + 'static>(
         &self,
@@ -490,10 +502,6 @@ impl Runtime {
     pub fn availability_handle(&self) -> ApiAvailability {
         self.api_availability.clone()
     }
-
-    pub fn address_cache(&self) -> &AddressCache {
-        &self.address_cache
-    }
 }
 
 #[derive(Clone)]

mullvad-ios/src/api_client/access_method_resolver.rs

@@ -20,7 +20,7 @@ unsafe extern "C" {
     pub fn swift_read_address_cache() -> SwiftData;
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct IOSAddressCacheBacking {}
 
 #[async_trait]
@@ -42,7 +42,7 @@ pub struct SwiftAccessMethodResolver {
     domain: String,
     state: EncryptedDnsProxyState,
     bridge_provider: SwiftShadowsocksLoaderWrapper,
-    address_cache: AddressCache,
+    address_cache: AddressCache<IOSAddressCacheBacking>,
 }
 
 impl SwiftAccessMethodResolver {
@@ -51,7 +51,7 @@ impl SwiftAccessMethodResolver {
         domain: String,
         state: EncryptedDnsProxyState,
         bridge_provider: SwiftShadowsocksLoaderWrapper,
-        address_cache: AddressCache,
+        address_cache: AddressCache<IOSAddressCacheBacking>,
     ) -> Self {
         Self {
             endpoint,

mullvad-ios/src/api_client/mod.rs

@@ -55,7 +55,7 @@ impl SwiftApiContext {
 }
 
 pub struct ApiContext {
-    api_client: Runtime,
+    api_client: Runtime<IOSAddressCacheBacking>,
     rest_client: MullvadRestHandle,
     access_mode_handler: AccessModeSelectorHandle,
 }
@@ -87,7 +87,7 @@ impl ApiContext {
         });
     }
 
-    pub fn address_cache(&self) -> &AddressCache {
+    pub fn address_cache(&self) -> &AddressCache<IOSAddressCacheBacking> {
         self.api_client.address_cache()
     }
 }