feature(Reachability): add reachability checking for network connections (#439)

- Add network reachability for datafile fetch and event dispatching.
- Reachability is checked once the first request fails.

Author: jaeopt

DemoSwiftApp/DemoSwiftApp.xcodeproj/project.pbxproj

@@ -560,6 +560,7 @@
 				TargetAttributes = {
 					252D7DEC21C8800800134A7A = {
 						CreatedOnToolsVersion = 10.1;
+						DevelopmentTeam = BDMC9C2X5M;
 						ProvisioningStyle = Automatic;
 						SystemCapabilities = {
 							com.apple.BackgroundModes = {
@@ -953,6 +954,7 @@
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = BDMC9C2X5M;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_PREPROCESSOR_DEFINITIONS = (
 					"DEBUG=1",
@@ -983,6 +985,7 @@
 				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = BDMC9C2X5M;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				INFOPLIST_FILE = "$(SRCROOT)/DemoSwiftiOS/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";

OptimizelySwiftSDK.xcodeproj/project.pbxproj

@@ -36,6 +36,9 @@ open class DefaultDatafileHandler: OPTDatafileHandler {
 
     // and our download queue to speed things up.
     let downloadQueue = DispatchQueue(label: "DefaultDatafileHandlerQueue")
+    
+    // network reachability
+    let reachability = NetworkReachability(maxContiguousFails: 1)
 
     public required init() {}
 
@@ -47,45 +50,59 @@ open class DefaultDatafileHandler: OPTDatafileHandler {
                                completionHandler: @escaping DatafileDownloadCompletionHandler) {
 
         downloadQueue.async {
+            
+            func returnCached(_ result: OptimizelyResult<Data?>? = nil) -> OptimizelyResult<Data?> {
+                if let data = self.loadSavedDatafile(sdkKey: sdkKey) {
+                    return .success(data)
+                } else {
+                    return result ?? .failure(.datafileLoadingFailed(sdkKey))
+                }
+            }
+        
+            if self.reachability.shouldBlockNetworkAccess() {
+                let optError = OptimizelyError.datafileDownloadFailed("NetworkReachability down")
+                self.logger.e(optError)
+
+                let result = OptimizelyResult<Data?>.failure(optError)
+                completionHandler(returnCached(result))
+                return
+            }
+            
             let session = self.getSession(resourceTimeoutInterval: resourceTimeoutInterval)
 
             guard let request = self.getRequest(sdkKey: sdkKey) else { return }
 
             let task = session.downloadTask(with: request) { (url, response, error) in
-                var result = OptimizelyResult<Data?>.failure(.datafileLoadingFailed(sdkKey))
-
-                let returnCached = {
-                    if let data = self.loadSavedDatafile(sdkKey: sdkKey) {
-                        result = .success(data)
-                    }
-                }
+                var result = OptimizelyResult<Data?>.failure(.generic)
 
                 if error != nil {
-                    self.logger.e(error.debugDescription)
-                    result = .failure(.datafileDownloadFailed(error.debugDescription))
-                    returnCached() // error recovery
+                    let optError = OptimizelyError.datafileDownloadFailed(error.debugDescription)
+                    self.logger.e(optError)
+                    result = returnCached(.failure(optError))  // error recovery
                 } else if let response = response as? HTTPURLResponse {
                     switch response.statusCode {
                     case 200:
                         if let data = self.getResponseData(sdkKey: sdkKey, response: response, url: url) {
                             result = .success(data)
                         } else {
-                            returnCached() // error recovery
+                            result = returnCached() // error recovery
                         }
                     case 304:
                         self.logger.d("The datafile was not modified and won't be downloaded again")
 
                         if returnCacheIfNoChange {
-                            returnCached()
+                            result = returnCached()
                         } else {
                             result = .success(nil)
                         }
                     default:
                         self.logger.i("got response code \(response.statusCode)")
-                        returnCached() // error recovery
+                        result = returnCached() // error recovery
                     }
                 }
 
+                self.reachability.updateNumContiguousFails(isError: (error != nil))
+                
                 completionHandler(result)
             }
 
@@ -244,6 +261,24 @@ extension DefaultDatafileHandler {
                                 updateInterval: Int,
                                 datafileChangeNotification: ((Data) -> Void)?) {
         let beginDownloading = Date()
+
+        let scheduleNextUpdate: () -> Void = {
+            guard self.hasPeriodicInterval(sdkKey: sdkKey) else { return }
+            
+            // adjust the next fire time so that events will be fired at fixed interval regardless of the download latency
+            // if latency is too big (or returning from background mode), fire the next event immediately once
+            
+            var interval = self.timers.property?[sdkKey]?.interval ?? updateInterval
+            let delay = Int(Date().timeIntervalSince(beginDownloading))
+            interval -= delay
+            if interval < 0 {
+                interval = 0
+            }
+            
+            self.logger.d("next datafile download is \(interval) seconds \(Date())")
+            self.startPeriodicUpdates(sdkKey: sdkKey, updateInterval: interval, datafileChangeNotification: datafileChangeNotification)
+        }
+        
         self.downloadDatafile(sdkKey: sdkKey) { (result) in
             switch result {
             case .success(let data):
@@ -255,20 +290,7 @@ extension DefaultDatafileHandler {
                 self.logger.e(error.reason)
             }
 
-            if self.hasPeriodicInterval(sdkKey: sdkKey) {
-                // adjust the next fire time so that events will be fired at fixed interval regardless of the download latency
-                // if latency is too big (or returning from background mode), fire the next event immediately once
-                
-                var interval = self.timers.property?[sdkKey]?.interval ?? updateInterval
-                let delay = Int(Date().timeIntervalSince(beginDownloading))
-                interval -= delay
-                if interval < 0 {
-                    interval = 0
-                }
-                
-                self.logger.d("next datafile download is \(interval) seconds \(Date())")
-                self.startPeriodicUpdates(sdkKey: sdkKey, updateInterval: interval, datafileChangeNotification: datafileChangeNotification)
-            }
+            scheduleNextUpdate()
         }
     }
 

Sources/Customization/DefaultDatafileHandler.swift

@@ -51,6 +51,9 @@ open class DefaultEventDispatcher: BackgroundingCallbacks, OPTEventDispatcher {
     var timer = AtomicProperty<Timer>()
     var observers = [NSObjectProtocol]()
 
+    // network reachability
+    let reachability = NetworkReachability(maxContiguousFails: 1)
+
     public init(batchSize: Int = DefaultValues.batchSize,
                 backingStore: DataStoreType = .file,
                 dataStoreName: String = "OPTEventQueue",
@@ -143,8 +146,8 @@ open class DefaultEventDispatcher: BackgroundingCallbacks, OPTEventDispatcher {
                 }
 
                 // we've exhuasted our failure count.  Give up and try the next time a event
-                // is queued or someone calls flush.
-                if failureCount > DefaultValues.maxFailureCount {
+                // is queued or someone calls flush (changed to >= so that retried exactly "maxFailureCount" times).
+                if failureCount >= DefaultValues.maxFailureCount {
                     self.logger.e(.eventSendRetyFailed(failureCount))
                     break
                 }
@@ -174,8 +177,13 @@ open class DefaultEventDispatcher: BackgroundingCallbacks, OPTEventDispatcher {
     }
 
     open func sendEvent(event: EventForDispatch, completionHandler: @escaping DispatchCompletionHandler) {
-        let config = URLSessionConfiguration.ephemeral
-        let session = URLSession(configuration: config)
+        
+        if self.reachability.shouldBlockNetworkAccess() {
+            completionHandler(.failure(.eventDispatchFailed("NetworkReachability down")))
+            return
+        }
+        
+        let session = getSession()
         var request = URLRequest(url: event.url)
         request.httpMethod = "POST"
         request.httpBody = event.body
@@ -191,11 +199,18 @@ open class DefaultEventDispatcher: BackgroundingCallbacks, OPTEventDispatcher {
                 self.logger.d("Event Sent")
                 completionHandler(.success(event.body))
             }
+            
+            self.reachability.updateNumContiguousFails(isError: (error != nil))
         }
 
         task.resume()
     }
 
+    func getSession() -> URLSession {
+        let config = URLSessionConfiguration.ephemeral
+        return URLSession(configuration: config)
+    }
+
 }
 
 // MARK: - internals

Sources/Customization/DefaultEventDispatcher.swift

@@ -0,0 +1,100 @@
+//
+// Copyright 2021, Optimizely, Inc. and contributors 
+// 
+// Licensed under the Apache License, Version 2.0 (the "License");  
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at   
+// 
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+import Foundation
+import Network
+
+class NetworkReachability {
+    
+    var monitor: AnyObject?
+    let queue = DispatchQueue(label: "reachability")
+    
+    // the number of contiguous download failures (reachability)
+    var numContiguousFails = 0
+    // the maximum number of contiguous network connection failures allowed before reachability checking
+    var maxContiguousFails: Int
+    static let defaultMaxContiguousFails = 1
+
+    #if targetEnvironment(simulator)
+    private var connected = false       // initially false for testing support
+    #else
+    private var connected = true        // initially true for safety in production
+    #endif
+    
+    var isConnected: Bool {
+        get {
+            var result = false
+            queue.sync {
+                result = connected
+            }
+            return result
+        }
+        // for test support only
+        set {
+            queue.sync {
+                connected = newValue
+            }
+        }
+    }
+    
+    init(maxContiguousFails: Int? = nil) {
+        self.maxContiguousFails = maxContiguousFails ?? NetworkReachability.defaultMaxContiguousFails
+     
+        if #available(macOS 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) {
+            
+            // NOTE: test with real devices only (simulator not updating properly)
+
+            self.monitor = NWPathMonitor()
+            
+            (monitor as! NWPathMonitor).pathUpdateHandler = { [weak self] (path: NWPath) -> Void in
+                // "Reachability path: satisfied (Path is satisfied), interface: en0, ipv4, ipv6, dns, expensive, constrained"
+                // "Reachability path: unsatisfied (No network route)"
+                // print("Reachability path: \(path)")
+                
+                // this task runs in sync queue. set private variable (instead of isConnected to avoid deadlock)
+                self?.connected = (path.status == .satisfied)
+            }
+            
+            (monitor as! NWPathMonitor).start(queue: queue)
+        }
+    }
+    
+    func stop() {
+        if #available(macOS 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) {
+            guard let monitor = monitor as? NWPathMonitor else { return }
+
+            monitor.pathUpdateHandler = nil
+            monitor.cancel()
+        }
+    }
+    
+    func updateNumContiguousFails(isError: Bool) {
+        numContiguousFails = isError ? (numContiguousFails + 1) : 0
+    }
+            
+    /// Skip network access when reachability is down (optimization for iOS12+ only)
+    /// - Returns: true when network access should be blocked
+    func shouldBlockNetworkAccess() -> Bool {
+        if numContiguousFails < maxContiguousFails { return false }
+
+        if #available(macOS 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) {
+            return !isConnected
+        } else {
+            return false
+        }
+    }
+    
+}