Better separation of concerns. No one calls SessionDirectly except the clients.

Author: ThomasSession

app/src/main/java/org/session/libsession/messaging/MessagingModuleConfiguration.kt

@@ -9,7 +9,7 @@ import org.session.libsession.messaging.groups.GroupManagerV2
 import org.session.libsession.messaging.groups.LegacyGroupDeprecationManager
 import org.session.libsession.messaging.jobs.MessageSendJob
 import org.session.libsession.messaging.notifications.TokenFetcher
-import org.session.libsession.network.SessionNetwork
+import org.session.libsession.network.ServerClient
 import org.session.libsession.network.SnodeClock
 import org.session.libsession.network.onion.PathManager
 import org.session.libsession.utilities.ConfigFactoryProtocol
@@ -38,7 +38,7 @@ class MessagingModuleConfiguration @Inject constructor(
     val messageSendJobFactory: MessageSendJob.Factory,
     val json: Json,
     val snodeClock: SnodeClock,
-    val sessionNetwork: SessionNetwork,
+    val serverClient: ServerClient,
     val pathManager: PathManager
 ) {
 

app/src/main/java/org/session/libsession/messaging/file_server/FileServerApi.kt

@@ -10,7 +10,7 @@ import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
 import org.session.libsession.database.StorageProtocol
-import org.session.libsession.network.SessionNetwork
+import org.session.libsession.network.ServerClient
 import org.session.libsignal.utilities.ByteArraySlice
 import org.session.libsignal.utilities.HTTP
 import org.session.libsignal.utilities.Hex
@@ -28,7 +28,7 @@ import kotlin.time.Duration.Companion.milliseconds
 @Singleton
 class FileServerApi @Inject constructor(
     private val storage: StorageProtocol,
-    private val sessionNetwork: SessionNetwork
+    private val serverClient: ServerClient
 ) {
 
     companion object {
@@ -94,7 +94,7 @@ class FileServerApi @Inject constructor(
         }
         return if (request.useOnionRouting) {
             try {
-                val response = sessionNetwork.sendToServer(
+                val response = serverClient.send(
                     request = requestBuilder.build(),
                     serverBaseUrl = request.fileServer.url.host,
                     x25519PublicKey =

app/src/main/java/org/session/libsession/messaging/jobs/NotifyPNServerJob.kt

@@ -10,7 +10,7 @@ import org.session.libsession.messaging.MessagingModuleConfiguration
 import org.session.libsession.messaging.jobs.Job.Companion.MAX_BUFFER_SIZE_BYTES
 import org.session.libsession.messaging.sending_receiving.notifications.Server
 import org.session.libsession.messaging.utilities.Data
-import org.session.libsession.network.SessionNetwork
+import org.session.libsession.network.ServerClient
 import org.session.libsession.network.onion.Version
 import org.session.libsession.snode.SnodeMessage
 import org.session.libsignal.utilities.JsonUtil
@@ -25,8 +25,8 @@ class NotifyPNServerJob(val message: SnodeMessage) : Job {
 
     override val maxFailureCount: Int = 20
 
-    private val sessionNetwork: SessionNetwork by lazy {
-        MessagingModuleConfiguration.shared.sessionNetwork
+    private val serverClient: ServerClient by lazy {
+        MessagingModuleConfiguration.shared.serverClient
     }
 
     companion object {
@@ -46,7 +46,7 @@ class NotifyPNServerJob(val message: SnodeMessage) : Job {
         try {
             // High-level application retry (4 attempts)
             retryWithUniformInterval(maxRetryCount = 4) {
-                sessionNetwork.sendToServer(
+                serverClient.send(
                     request = request,
                     serverBaseUrl = server.url,
                     x25519PublicKey = server.publicKey,

app/src/main/java/org/session/libsession/messaging/open_groups/OpenGroupApi.kt

@@ -410,7 +410,7 @@ object OpenGroupApi {
 
         if (request.useOnionRouting) {
             try {
-                return MessagingModuleConfiguration.shared.sessionNetwork.sendToServer(
+                return MessagingModuleConfiguration.shared.serverClient.send(
                     request = requestBuilder.build(),
                     serverBaseUrl = request.server,
                     x25519PublicKey = serverPublicKey

app/src/main/java/org/session/libsession/messaging/sending_receiving/MessageSender.kt

@@ -28,7 +28,7 @@ import org.session.libsession.messaging.messages.visible.VisibleMessage
 import org.session.libsession.messaging.open_groups.OpenGroupApi
 import org.session.libsession.messaging.open_groups.OpenGroupApi.Capability
 import org.session.libsession.messaging.open_groups.OpenGroupMessage
-import org.session.libsession.network.SessionClient
+import org.session.libsession.network.SnodeClient
 import org.session.libsession.network.SnodeClock
 import org.session.libsession.snode.SnodeMessage
 import org.session.libsession.utilities.Address
@@ -62,7 +62,7 @@ class MessageSender @Inject constructor(
     private val messageSendJobFactory: MessageSendJob.Factory,
     private val messageExpirationManager: ExpiringMessageManager,
     private val snodeClock: SnodeClock,
-    private val sessionClient: SessionClient,
+    private val snodeClient: SnodeClient,
     @param:ManagerScope private val scope: CoroutineScope,
 ) {
 
@@ -247,14 +247,14 @@ class MessageSender @Inject constructor(
                             "Unable to authorize group message send"
                         }
 
-                        sessionClient.sendMessage(
+                        snodeClient.sendMessage(
                             auth = groupAuth,
                             message = snodeMessage,
                             namespace = Namespace.GROUP_MESSAGES(),
                         )
                     }
                     is Destination.Contact -> {
-                        sessionClient.sendMessage(snodeMessage, auth = null, namespace = Namespace.DEFAULT())
+                        snodeClient.sendMessage(snodeMessage, auth = null, namespace = Namespace.DEFAULT())
                     }
                     is Destination.OpenGroup,
                     is Destination.OpenGroupInbox -> throw IllegalStateException("Destination should not be an open group.")

app/src/main/java/org/session/libsession/messaging/sending_receiving/ReceivedMessageProcessor.kt

@@ -29,7 +29,7 @@ import org.session.libsession.messaging.open_groups.OpenGroupApi
 import org.session.libsession.messaging.sending_receiving.data_extraction.DataExtractionNotificationInfoMessage
 import org.session.libsession.messaging.sending_receiving.notifications.MessageNotifier
 import org.session.libsession.messaging.utilities.WebRtcUtils
-import org.session.libsession.network.SessionClient
+import org.session.libsession.network.SnodeClient
 import org.session.libsession.utilities.Address
 import org.session.libsession.utilities.Address.Companion.toAddress
 import org.session.libsession.utilities.ConfigFactoryProtocol
@@ -77,7 +77,7 @@ class ReceivedMessageProcessor @Inject constructor(
     private val visibleMessageHandler: Provider<VisibleMessageHandler>,
     private val blindMappingRepository: BlindMappingRepository,
     private val messageParser: MessageParser,
-    private val sessionClient: SessionClient
+    private val snodeClient: SnodeClient
 ) {
     private val threadMutexes = ConcurrentHashMap<Address.Conversable, ReentrantLock>()
 
@@ -454,7 +454,7 @@ class ReceivedMessageProcessor @Inject constructor(
             messageDataProvider.getServerHashForMessage(messageIdToDelete)?.let { serverHash ->
                 scope.launch(Dispatchers.IO) { // using scope as we are slowly migrating to coroutines but we can't migrate everything at once
                     try {
-                        sessionClient.deleteMessage(author, userAuth, listOf(serverHash))
+                        snodeClient.deleteMessage(author, userAuth, listOf(serverHash))
                     } catch (e: Exception) {
                         Log.e("Loki", "Failed to delete message", e)
                     }

app/src/main/java/org/session/libsession/messaging/sending_receiving/notifications/PushRegistryV1.kt

@@ -62,7 +62,7 @@ object PushRegistryV1 {
 
         try {
             retryWithUniformInterval(MAX_RETRY_COUNT) {
-                MessagingModuleConfiguration.shared.sessionNetwork.sendToServer(
+                MessagingModuleConfiguration.shared.serverClient.send(
                     request = request,
                     serverBaseUrl = server.url,
                     x25519PublicKey = server.publicKey,

app/src/main/java/org/session/libsession/messaging/sending_receiving/pollers/Poller.kt

@@ -30,7 +30,7 @@ import org.session.libsession.database.userAuth
 import org.session.libsession.messaging.messages.Message.Companion.senderOrSync
 import org.session.libsession.messaging.sending_receiving.MessageParser
 import org.session.libsession.messaging.sending_receiving.ReceivedMessageProcessor
-import org.session.libsession.network.SessionClient
+import org.session.libsession.network.SnodeClient
 import org.session.libsession.network.SnodeClock
 import org.session.libsession.network.snode.SwarmStorage
 import org.session.libsession.snode.model.RetrieveMessageResponse
@@ -64,7 +64,7 @@ class Poller @AssistedInject constructor(
     private val receivedMessageHashDatabase: ReceivedMessageHashDatabase,
     private val processor: ReceivedMessageProcessor,
     private val messageParser: MessageParser,
-    private val sessionClient: SessionClient,
+    private val snodeClient: SnodeClient,
     private val swarmStorage: SwarmStorage,
     @Assisted scope: CoroutineScope
 ) {
@@ -305,7 +305,7 @@ class Poller @AssistedInject constructor(
 
         // Get messages call wrapped in an async
         val fetchMessageTask = if (!pollOnlyUserProfileConfig) {
-            val request = sessionClient.buildAuthenticatedRetrieveBatchRequest(
+            val request = snodeClient.buildAuthenticatedRetrieveBatchRequest(
                 lastHash = lokiApiDatabase.getLastMessageHashValue(
                     snode = snode,
                     publicKey = userAuth.accountId.hexString,
@@ -316,7 +316,7 @@ class Poller @AssistedInject constructor(
 
             this.async {
                 runCatching {
-                    sessionClient.sendBatchRequest(
+                    snodeClient.sendBatchRequest(
                         snode = snode,
                         publicKey = userPublicKey,
                         request = request,
@@ -341,7 +341,7 @@ class Poller @AssistedInject constructor(
                 .map { type ->
                     val config = configs.getConfig(type)
                     hashesToExtend += config.activeHashes()
-                    val request = sessionClient.buildAuthenticatedRetrieveBatchRequest(
+                    val request = snodeClient.buildAuthenticatedRetrieveBatchRequest(
                         lastHash = lokiApiDatabase.getLastMessageHashValue(
                             snode = snode,
                             publicKey = userAuth.accountId.hexString,
@@ -354,7 +354,7 @@ class Poller @AssistedInject constructor(
 
                     this.async {
                         type to runCatching {
-                            sessionClient.sendBatchRequest(
+                            snodeClient.sendBatchRequest(
                                 snode = snode,
                                 publicKey = userPublicKey,
                                 request = request,
@@ -368,10 +368,10 @@ class Poller @AssistedInject constructor(
         if (hashesToExtend.isNotEmpty()) {
             launch {
                 try {
-                    sessionClient.sendBatchRequest(
+                    snodeClient.sendBatchRequest(
                         snode,
                         userPublicKey,
-                        sessionClient.buildAuthenticatedAlterTtlBatchRequest(
+                        snodeClient.buildAuthenticatedAlterTtlBatchRequest(
                             messageHashes = hashesToExtend.toList(),
                             auth = userAuth,
                             newExpiry = snodeClock.currentTimeMills() + 14.days.inWholeMilliseconds,

app/src/main/java/org/session/libsession/network/ServerClient.kt

@@ -0,0 +1,94 @@
+package org.session.libsession.network
+
+import okhttp3.Request
+import org.session.libsession.network.model.OnionDestination
+import org.session.libsession.network.model.OnionResponse
+import org.session.libsession.network.onion.Version
+import org.session.libsession.network.utilities.getBodyForOnionRequest
+import org.session.libsession.network.utilities.getHeadersForOnionRequest
+import org.session.libsignal.utilities.JsonUtil
+import javax.inject.Inject
+import javax.inject.Singleton
+
+/**
+ * Responsible for encoding HTTP requests into the onion format (v3/v4)
+ * and sending them via the network.
+ */
+@Singleton
+class ServerClient @Inject constructor(
+    private val sessionNetwork: SessionNetwork
+) {
+    suspend fun send(
+        request: Request,
+        serverBaseUrl: String,
+        x25519PublicKey: String,
+        version: Version = Version.V4
+    ): OnionResponse {
+        val url = request.url
+        val payload = generatePayload(request, serverBaseUrl, version)
+
+        val destination = OnionDestination.ServerDestination(
+            host = url.host,
+            target = version.value,
+            x25519PublicKey = x25519PublicKey,
+            scheme = url.scheme,
+            port = url.port
+        )
+
+        return sessionNetwork.sendWithRetry(
+            destination = destination,
+            payload = payload,
+            version = version,
+            snodeToExclude = null,
+            targetSnode = null,
+            publicKey = null
+        )
+    }
+
+    private fun generatePayload(request: Request, server: String, version: Version): ByteArray {
+        val headers = request.getHeadersForOnionRequest().toMutableMap()
+        val url = request.url
+        val urlAsString = url.toString()
+        val body = request.getBodyForOnionRequest() ?: "null"
+
+        val endpoint = if (server.length < urlAsString.length) {
+            urlAsString.substringAfter(server)
+        } else {
+            ""
+        }
+
+        return if (version == Version.V4) {
+            if (request.body != null &&
+                headers.keys.none { it.equals("Content-Type", ignoreCase = true) }
+            ) {
+                headers["Content-Type"] = "application/json"
+            }
+
+            val requestPayload = mapOf(
+                "endpoint" to endpoint,
+                "method" to request.method,
+                "headers" to headers
+            )
+
+            val requestData = JsonUtil.toJson(requestPayload).toByteArray()
+            val prefixData = "l${requestData.size}:".toByteArray(Charsets.US_ASCII)
+            val suffixData = "e".toByteArray(Charsets.US_ASCII)
+
+            if (request.body != null) {
+                val bodyData = if (body is ByteArray) body else body.toString().toByteArray()
+                val bodyLengthData = "${bodyData.size}:".toByteArray(Charsets.US_ASCII)
+                prefixData + requestData + bodyLengthData + bodyData + suffixData
+            } else {
+                prefixData + requestData + suffixData
+            }
+        } else {
+            val payload = mapOf(
+                "body" to body,
+                "endpoint" to endpoint.removePrefix("/"),
+                "method" to request.method,
+                "headers" to headers
+            )
+            JsonUtil.toJson(payload).toByteArray()
+        }
+    }
+}