@onekeyfe/react-native-sni-connect 1.0.0 → 1.1.0

package/android/src/main/java/com/sniconnect/SniConnectModule.kt

@@ -38,10 +38,16 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
     private const val EVENT_NAME = "SniConnectLog"
   }
 
+  /**
+   * Cache key for OkHttpClient instances
+   * Uses hostname:IP combination to ensure:
+   * - Different IPs for the same hostname are isolated (accurate speed testing)
+   * - Same hostname+IP combination can reuse connections (performance optimization)
+   * Note: timeout is NOT part of the key to allow connection reuse across different timeout values
+   */
   private data class ClientKey(
-    val ip: String,
     val hostname: String,
-    val timeoutMillis: Long,
+    val ip: String,
   )
 
   private val clientCache = ConcurrentHashMap<ClientKey, OkHttpClient>()
@@ -136,6 +142,9 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
       val request = buildRequest(config)
       val call = client.newCall(request)
 
+      // Apply per-request timeout
+      call.timeout().timeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+
       // Register the call if requestId is provided
       config.requestId?.let { requestId ->
         activeCalls[requestId] = call
@@ -191,14 +200,19 @@ class SniConnectModule(reactContext: ReactApplicationContext) :
 
   private fun getOrCreateClient(config: RequestConfig): OkHttpClient {
     val normalizedHost = config.hostname.lowercase(Locale.US)
-    val key = ClientKey(config.ip, normalizedHost, config.timeoutMillis)
+    val key = ClientKey(normalizedHost, config.ip)
 
     return clientCache.getOrPut(key) {
+      // Note: timeout is not part of the cache key to allow connection reuse
+      // Use reasonable default timeouts for the client
+      // Per-request timeout is applied via call.timeout() in performRequest
+      val defaultTimeout = 60_000L // 60 seconds
+
       OkHttpClient.Builder()
-        .connectTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
-        .readTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
-        .writeTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
-        .callTimeout(config.timeoutMillis, TimeUnit.MILLISECONDS)
+        .connectTimeout(defaultTimeout, TimeUnit.MILLISECONDS)
+        .readTimeout(defaultTimeout, TimeUnit.MILLISECONDS)
+        .writeTimeout(defaultTimeout, TimeUnit.MILLISECONDS)
+        .callTimeout(0, TimeUnit.MILLISECONDS) // Disable client-level call timeout
         .hostnameVerifier { _, session ->
           HttpsURLConnection.getDefaultHostnameVerifier().verify(config.hostname, session)
         }

package/ios/SniConnectClient.swift

@@ -179,8 +179,10 @@ final class SniConnectClient {
     private static let cache = DNSCache()
 
     /// LRU cache for DNS mappings with size limit and TTL support
+    /// Uses hostname:IP as cache key to ensure different IPs for the same hostname are isolated
     private class DNSCache {
       private struct CacheEntry {
+        let hostname: String
         let ip: String
         let timestamp: TimeInterval
       }
@@ -188,33 +190,34 @@ final class SniConnectClient {
       private var storage: [String: CacheEntry] = [:]
       private var accessOrder: [String] = []
 
+      // Mapping from hostname to IP for DNS resolution
+      // This stores the most recently set IP for each hostname
+      private var hostnameToIP: [String: String] = [:]
+
       // Maximum cache entries (100 as specified in requirements)
       private let maxSize = 100
       // TTL in seconds (5 minutes default)
       private let ttl: TimeInterval = 300
 
-      func get(_ domain: String) -> String? {
-        let key = domain.lowercased()
-        guard let entry = storage[key] else { return nil }
-
-        // Check if entry has expired
-        let now = Date().timeIntervalSince1970
-        if now - entry.timestamp > ttl {
-          remove(key)
-          return nil
-        }
+      /// Generate cache key using hostname:IP format
+      /// This ensures different IPs for the same hostname are isolated (accurate speed testing)
+      private func makeCacheKey(hostname: String, ip: String) -> String {
+        return "\(hostname.lowercased()):\(ip)"
+      }
 
-        // Update access order (LRU)
-        if let index = accessOrder.firstIndex(of: key) {
-          accessOrder.remove(at: index)
-        }
-        accessOrder.append(key)
+      func get(_ domain: String) -> String? {
+        let normalizedDomain = domain.lowercased()
 
-        return entry.ip
+        // Return the most recently set IP for this hostname
+        return hostnameToIP[normalizedDomain]
       }
 
       func set(_ ip: String, for domain: String) {
-        let key = domain.lowercased()
+        let normalizedDomain = domain.lowercased()
+        let key = makeCacheKey(hostname: normalizedDomain, ip: ip)
+
+        // Update hostname to IP mapping
+        hostnameToIP[normalizedDomain] = ip
 
         // Evict oldest entry if cache is full
         if storage.count >= maxSize && storage[key] == nil {
@@ -225,7 +228,7 @@ final class SniConnectClient {
         }
 
         // Add or update entry
-        let entry = CacheEntry(ip: ip, timestamp: Date().timeIntervalSince1970)
+        let entry = CacheEntry(hostname: normalizedDomain, ip: ip, timestamp: Date().timeIntervalSince1970)
         storage[key] = entry
 
         // Update access order
@@ -235,8 +238,7 @@ final class SniConnectClient {
         accessOrder.append(key)
       }
 
-      func remove(_ domain: String) {
-        let key = domain.lowercased()
+      func remove(_ key: String) {
         storage.removeValue(forKey: key)
         if let index = accessOrder.firstIndex(of: key) {
           accessOrder.remove(at: index)
@@ -246,6 +248,7 @@ final class SniConnectClient {
       func clear() {
         storage.removeAll()
         accessOrder.removeAll()
+        hostnameToIP.removeAll()
       }
 
       func cleanExpired() {
@@ -253,6 +256,10 @@ final class SniConnectClient {
         let expiredKeys = storage.filter { now - $0.value.timestamp > ttl }.map { $0.key }
         for key in expiredKeys {
           remove(key)
+          // Also remove from hostnameToIP if this was the active mapping
+          if let entry = storage[key], hostnameToIP[entry.hostname] == entry.ip {
+            hostnameToIP.removeValue(forKey: entry.hostname)
+          }
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-sni-connect",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A React Native library for SNI-based HTTP requests with DNS caching and request management",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",