Debug

SessionSnodeKit/OnionRequestAPI.swift

@@ -13,7 +13,7 @@ public enum OnionRequestAPI {
     public static var paths: [Path] = [] // Not a set to ensure we consistently show the same path to the user
 
     // MARK: Settings
-    public static let maxFileSize = 10_000_000 // 10 MB
+    public static let maxRequestSize = 10_000_000 // 10 MB
     /// The number of snodes (including the guard snode) in a path.
     private static let pathSize: UInt = 3
     /// The number of times a path can fail before it's replaced.
@@ -88,10 +88,9 @@ public enum OnionRequestAPI {
             return Promise<Set<Snode>> { $0.fulfill(guardSnodes) }
         } else {
             SNLog("Populating guard snode cache.")
-            return SnodeAPI.getRandomSnode().then2 { _ -> Promise<Set<Snode>> in // Just used to populate the snode pool
             var unusedSnodes = SnodeAPI.snodePool.subtracting(reusableGuardSnodes) // Sync on LokiAPI.workQueue
             let reusableGuardSnodeCount = UInt(reusableGuardSnodes.count)
-                guard unusedSnodes.count >= (targetGuardSnodeCount - reusableGuardSnodeCount) else { throw Error.insufficientSnodes }
+            guard unusedSnodes.count >= (targetGuardSnodeCount - reusableGuardSnodeCount) else { return Promise(error: Error.insufficientSnodes) }
             func getGuardSnode() -> Promise<Snode> {
                 // randomElement() uses the system's default random generator, which is cryptographically secure
                 guard let candidate = unusedSnodes.randomElement() else { return Promise<Snode> { $0.reject(Error.insufficientSnodes) } }
@@ -110,7 +109,6 @@ public enum OnionRequestAPI {
             }
         }
     }
-    }
 
     /// Builds and returns `targetPathCount` paths. The returned promise errors out with `Error.insufficientSnodes`
     /// if not enough (reliable) snodes are available.
@@ -120,7 +118,6 @@ public enum OnionRequestAPI {
         DispatchQueue.main.async {
             NotificationCenter.default.post(name: .buildingPaths, object: nil)
         }
-        return SnodeAPI.getRandomSnode().then2 { _ -> Promise<[Path]> in // Just used to populate the snode pool
         let reusableGuardSnodes = reusablePaths.map { $0[0] }
         return getGuardSnodes(reusing: reusableGuardSnodes).map2 { guardSnodes -> [Path] in
             var unusedSnodes = SnodeAPI.snodePool.subtracting(guardSnodes).subtracting(reusablePaths.flatMap { $0 })
@@ -150,7 +147,6 @@ public enum OnionRequestAPI {
             return paths
         }
     }
-    }
 
     /// Returns a `Path` to be used for building an onion request. Builds new paths as needed.
     private static func getPath(excluding snode: Snode?) -> Promise<Path> {
@@ -353,7 +349,7 @@ public enum OnionRequestAPI {
                 let url = "\(guardSnode!.address):\(guardSnode!.port)/onion_req/v2"
                 let finalEncryptionResult = intermediate.finalEncryptionResult
                 let onion = finalEncryptionResult.ciphertext
-                if case Destination.server = destination, Double(onion.count) > 0.75 * Double(maxFileSize) {
+                if case Destination.server = destination, Double(onion.count) > 0.75 * Double(maxRequestSize) {
                     SNLog("Approaching request size limit: ~\(onion.count) bytes.")
                 }
                 let parameters: JSON = [

SessionSnodeKit/SnodeAPI.swift

@@ -148,7 +148,7 @@ public final class SnodeAPI : NSObject {
         if hasInsufficientSnodes || hasSnodePoolExpired {
             if let getSnodePoolPromise = getSnodePoolPromise { return getSnodePoolPromise }
             let promise: Promise<Set<Snode>>
-            if snodePool.isEmpty {
+            if snodePool.count < minSnodePoolCount {
                 promise = getSnodePoolFromSeedNode()
             } else {
                 promise = getSnodePoolFromSnode().recover2 { _ in
@@ -232,11 +232,11 @@ public final class SnodeAPI : NSObject {
             snodePool.remove(snode)
             snodes.insert(snode)
         }
-        let rawSnodePoolPromises: [Promise<Set<Snode>>] = snodes.map { snode in
+        let snodePoolPromises: [Promise<Set<Snode>>] = snodes.map { snode in
             return attempt(maxRetryCount: 4, recoveringOn: Threading.workQueue) {
                 let parameters: JSON = [
                     "endpoint" : "get_service_nodes",
-                    "oxend_params" : [
+                    "params" : [
                         "limit" : 256,
                         "active_only" : true,
                         "fields" : [
@@ -244,11 +244,11 @@ public final class SnodeAPI : NSObject {
                         ]
                     ]
                 ]
-                return invoke(.getAllSnodes, on: snode, parameters: parameters).map2 { rawResponse in
-                    guard let json = rawResponse as? JSON, let intermediate1 = json["result"] as? String,
-                        let intermediate1AsData = intermediate1.data(using: String.Encoding.utf8),
-                        let intermediate2 = try JSONSerialization.jsonObject(with: intermediate1AsData, options: [ .fragmentsAllowed ]) as? JSON,
-                        let rawSnodes = intermediate2["service_node_states"] as? [JSON] else { throw Error.snodePoolUpdatingFailed }
+                let promise: Promise<Set<Snode>> = invoke(.getAllSnodes, on: snode, parameters: parameters).map2 { rawResponse in
+                    guard let json = rawResponse as? JSON, let intermediate = json["result"] as? JSON,
+                        let rawSnodes = intermediate["service_node_states"] as? [JSON] else {
+                        throw Error.snodePoolUpdatingFailed
+                    }
                     return Set(rawSnodes.compactMap { rawSnode in
                         guard let address = rawSnode["public_ip"] as? String, let port = rawSnode["storage_port"] as? Int,
                             let ed25519PublicKey = rawSnode["pubkey_ed25519"] as? String, let x25519PublicKey = rawSnode["pubkey_x25519"] as? String, address != "0.0.0.0" else {
@@ -258,9 +258,10 @@ public final class SnodeAPI : NSObject {
                         return Snode(address: "https://\(address)", port: UInt16(port), publicKeySet: Snode.KeySet(ed25519Key: ed25519PublicKey, x25519Key: x25519PublicKey))
                     })
                 }
+                return promise
             }
         }
-        let promise = when(fulfilled: rawSnodePoolPromises).map2 { results -> Set<Snode> in
+        let promise = when(fulfilled: snodePoolPromises).map2 { results -> Set<Snode> in
             var result: Set<Snode> = results[0]
             results.forEach { result = result.union($0) }
             if result.count > 24 { // We want the snodes to agree on at least this many snodes
@@ -269,9 +270,6 @@ public final class SnodeAPI : NSObject {
                 throw Error.inconsistentSnodePools
             }
         }
-        promise.catch2 { error in
-            SNLog("\(error)")
-        }
         return promise
     }