2019-04-30 06:27:39 +02:00
|
|
|
import PromiseKit
|
|
|
|
|
2019-05-08 01:29:07 +02:00
|
|
|
@objc public final class LokiAPI : NSObject {
|
2019-05-23 03:49:05 +02:00
|
|
|
internal static let storage = OWSPrimaryStorage.shared()
|
2019-04-30 06:27:39 +02:00
|
|
|
|
2019-05-21 05:44:46 +02:00
|
|
|
// MARK: Settings
|
2019-05-08 01:29:07 +02:00
|
|
|
private static let version = "v1"
|
2019-05-24 01:11:16 +02:00
|
|
|
public static let defaultMessageTTL: UInt64 = 1 * 24 * 60 * 60 * 1000
|
2019-04-30 06:27:39 +02:00
|
|
|
|
2019-05-23 03:49:05 +02:00
|
|
|
internal static let ourHexEncodedPubKey = OWSIdentityManager.shared().identityKeyPair()!.hexEncodedPublicKey
|
|
|
|
|
2019-04-30 06:27:39 +02:00
|
|
|
// MARK: Types
|
2019-05-07 05:53:31 +02:00
|
|
|
public typealias RawResponse = Any
|
2019-04-30 06:27:39 +02:00
|
|
|
|
2019-05-07 02:10:15 +02:00
|
|
|
public enum Error : LocalizedError {
|
2019-05-22 08:04:51 +02:00
|
|
|
/// Only applicable to snode targets as proof of work isn't required for P2P messaging.
|
2019-05-07 02:10:15 +02:00
|
|
|
case proofOfWorkCalculationFailed
|
|
|
|
|
2019-05-23 05:36:50 +02:00
|
|
|
// Failed to send the message'
|
|
|
|
case internalError
|
|
|
|
|
2019-05-07 02:10:15 +02:00
|
|
|
public var errorDescription: String? {
|
|
|
|
switch self {
|
|
|
|
case .proofOfWorkCalculationFailed: return NSLocalizedString("Failed to calculate proof of work.", comment: "")
|
2019-05-23 05:36:50 +02:00
|
|
|
case .internalError: return "Failed while trying to send message"
|
2019-05-07 02:10:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-30 06:27:39 +02:00
|
|
|
// MARK: Lifecycle
|
2019-05-06 08:13:32 +02:00
|
|
|
override private init() { }
|
2019-04-30 06:27:39 +02:00
|
|
|
|
2019-05-21 05:26:51 +02:00
|
|
|
// MARK: Internal API
|
2019-05-22 08:54:57 +02:00
|
|
|
internal static func invoke(_ method: Target.Method, on target: Target, associatedWith hexEncodedPublicKey: String, parameters: [String:Any] = [:]) -> Promise<RawResponse> {
|
2019-05-08 01:29:07 +02:00
|
|
|
let url = URL(string: "\(target.address):\(target.port)/\(version)/storage_rpc")!
|
2019-04-30 06:27:39 +02:00
|
|
|
let request = TSRequest(url: url, method: "POST", parameters: [ "method" : method.rawValue, "params" : parameters ])
|
2019-05-22 08:54:57 +02:00
|
|
|
return TSNetworkManager.shared().makePromise(request: request).map { $0.responseObject }.handlingSwarmSpecificErrorsIfNeeded(for: target, associatedWith: hexEncodedPublicKey)
|
2019-04-30 06:27:39 +02:00
|
|
|
}
|
2019-05-07 02:29:44 +02:00
|
|
|
|
2019-05-21 05:26:51 +02:00
|
|
|
// MARK: Public API
|
2019-05-22 03:32:32 +02:00
|
|
|
public static func getMessages() -> Promise<Set<Promise<[SSKProtoEnvelope]>>> {
|
2019-05-23 03:49:05 +02:00
|
|
|
return getTargetSnodes(for: ourHexEncodedPubKey).mapValues { targetSnode in
|
2019-05-22 03:32:32 +02:00
|
|
|
let lastHash = getLastMessageHashValue(for: targetSnode) ?? ""
|
2019-05-23 03:49:05 +02:00
|
|
|
let parameters: [String:Any] = [ "pubKey" : ourHexEncodedPubKey, "lastHash" : lastHash ]
|
2019-05-23 07:28:38 +02:00
|
|
|
return invoke(.getMessages, on: targetSnode, associatedWith: ourHexEncodedPubKey, parameters: parameters).map { rawResponse in
|
2019-05-22 03:32:32 +02:00
|
|
|
guard let json = rawResponse as? JSON, let rawMessages = json["messages"] as? [JSON] else { return [] }
|
|
|
|
updateLastMessageHashValueIfPossible(for: targetSnode, from: rawMessages)
|
|
|
|
let newRawMessages = removeDuplicates(from: rawMessages)
|
|
|
|
return parseProtoEnvelopes(from: newRawMessages)
|
2019-05-21 05:48:42 +02:00
|
|
|
}
|
2019-05-21 08:40:31 +02:00
|
|
|
}.map { Set($0) }
|
2019-05-07 08:03:57 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 05:45:38 +02:00
|
|
|
public static func ping(_ hexEncodedPublicKey: String) -> Promise<Set<Promise<RawResponse>>> {
|
|
|
|
let isP2PMessagingPossible = false
|
|
|
|
if isP2PMessagingPossible {
|
|
|
|
// TODO: Send using P2P protocol
|
|
|
|
} else {
|
|
|
|
let parameters: [String:Any] = [ "pubKey" : hexEncodedPublicKey ] // TODO: Figure out correct parameters
|
|
|
|
return getTargetSnodes(for: hexEncodedPublicKey).mapValues { invoke(.sendMessage, on: $0, associatedWith: hexEncodedPublicKey, parameters: parameters) }.map { Set($0) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// MARK: Public API (Obj-C)
|
|
|
|
@objc public static func objc_sendSignalMessage(_ signalMessage: SignalMessage, to destination: String, with timestamp: UInt64) -> AnyPromise {
|
|
|
|
let promise = sendSignalMessage(signalMessage, to: destination, timestamp: timestamp).mapValues { AnyPromise.from($0) }.map { Set($0) }
|
|
|
|
return AnyPromise.from(promise)
|
|
|
|
}
|
|
|
|
|
|
|
|
// MARK: Sending
|
2019-05-22 08:04:51 +02:00
|
|
|
public static func sendSignalMessage(_ signalMessage: SignalMessage, to destination: String, timestamp: UInt64) -> Promise<Set<Promise<RawResponse>>> {
|
2019-05-23 05:36:50 +02:00
|
|
|
guard let message = Message.from(signalMessage: signalMessage, timestamp: timestamp) else {
|
|
|
|
return Promise(error: Error.internalError)
|
|
|
|
}
|
|
|
|
|
|
|
|
// Send message through the storage server
|
|
|
|
// We put this here because `recover` expects `Promise<Set<Promise<RawResponse>>>`
|
|
|
|
let sendThroughStorageServer: () -> Promise<Set<Promise<RawResponse>>> = { () in
|
|
|
|
return message.calculatePoW().then { powMessage -> Promise<Set<Promise<RawResponse>>> in
|
|
|
|
let snodes = getTargetSnodes(for: powMessage.destination)
|
|
|
|
return sendMessage(powMessage, targets: snodes)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-24 01:33:41 +02:00
|
|
|
// If we have the p2p details then send message to that
|
|
|
|
// If that failes then fallback to storage server
|
2019-05-23 05:36:50 +02:00
|
|
|
// TODO: probably only send to p2p if user is online or we are pinging them
|
|
|
|
// p2pDetails && (isPing || peerIsOnline)
|
|
|
|
if let p2pDetails = contactP2PDetails[destination] {
|
2019-05-24 07:20:49 +02:00
|
|
|
let targets = Promise.wrap([p2pDetails.target])
|
2019-05-24 05:45:38 +02:00
|
|
|
return sendMessage(message, targets: targets).recover { _ in return sendThroughStorageServer() }
|
2019-05-23 05:36:50 +02:00
|
|
|
}
|
|
|
|
|
2019-05-24 01:33:41 +02:00
|
|
|
return sendThroughStorageServer()
|
2019-05-22 08:04:51 +02:00
|
|
|
}
|
|
|
|
|
2019-05-23 05:36:50 +02:00
|
|
|
internal static func sendMessage(_ lokiMessage: Message, targets: Promise<[Target]>) -> Promise<Set<Promise<RawResponse>>> {
|
|
|
|
let parameters = lokiMessage.toJSON()
|
2019-05-23 07:28:38 +02:00
|
|
|
return targets.mapValues { invoke(.sendMessage, on: $0, associatedWith: lokiMessage.destination, parameters: parameters) }.map { Set($0) }
|
2019-05-08 02:04:19 +02:00
|
|
|
}
|
|
|
|
|
2019-05-22 03:32:32 +02:00
|
|
|
// MARK: Parsing
|
|
|
|
|
|
|
|
// The parsing utilities below use a best attempt approach to parsing; they warn for parsing failures but don't throw exceptions.
|
|
|
|
|
|
|
|
private static func updateLastMessageHashValueIfPossible(for target: Target, from rawMessages: [JSON]) {
|
|
|
|
guard let lastMessage = rawMessages.last, let hashValue = lastMessage["hash"] as? String, let expiresAt = lastMessage["expiration"] as? Int else {
|
|
|
|
Logger.warn("[Loki] Failed to update last message hash value from: \(rawMessages).")
|
|
|
|
return
|
2019-05-21 07:21:51 +02:00
|
|
|
}
|
2019-05-22 03:32:32 +02:00
|
|
|
setLastMessageHashValue(for: target, hashValue: hashValue, expiresAt: UInt64(expiresAt))
|
2019-05-21 07:21:51 +02:00
|
|
|
}
|
|
|
|
|
2019-05-22 03:32:32 +02:00
|
|
|
private static func removeDuplicates(from rawMessages: [JSON]) -> [JSON] {
|
2019-05-22 04:06:02 +02:00
|
|
|
var receivedMessageHashValues = getReceivedMessageHashValues() ?? []
|
2019-05-22 03:32:32 +02:00
|
|
|
return rawMessages.filter { rawMessage in
|
|
|
|
guard let hashValue = rawMessage["hash"] as? String else {
|
|
|
|
Logger.warn("[Loki] Missing hash value for message: \(rawMessage).")
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
let isDuplicate = receivedMessageHashValues.contains(hashValue)
|
|
|
|
receivedMessageHashValues.insert(hashValue)
|
|
|
|
setReceivedMessageHashValues(to: receivedMessageHashValues)
|
|
|
|
return !isDuplicate
|
|
|
|
}
|
2019-05-21 07:21:51 +02:00
|
|
|
}
|
|
|
|
|
2019-05-22 03:32:32 +02:00
|
|
|
private static func parseProtoEnvelopes(from rawMessages: [JSON]) -> [SSKProtoEnvelope] {
|
|
|
|
return rawMessages.compactMap { rawMessage in
|
|
|
|
guard let base64EncodedData = rawMessage["data"] as? String, let data = Data(base64Encoded: base64EncodedData) else {
|
|
|
|
Logger.warn("[Loki] Failed to decode data for message: \(rawMessage).")
|
2019-05-21 05:26:51 +02:00
|
|
|
return nil
|
|
|
|
}
|
2019-05-22 04:06:30 +02:00
|
|
|
guard let envelope = try? LokiMessageWrapper.unwrap(data: data) else {
|
2019-05-22 03:32:32 +02:00
|
|
|
Logger.warn("[Loki] Failed to unwrap data for message: \(rawMessage).")
|
2019-05-21 05:26:51 +02:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return envelope
|
2019-05-22 03:32:32 +02:00
|
|
|
}
|
|
|
|
}
|
2019-05-08 08:02:53 +02:00
|
|
|
}
|