LFS: Implemented SSH support and code cleanup

Author: JetpackDuba

src/main/kotlin/com/jetpackduba/gitnuro/App.kt

@@ -22,6 +22,7 @@ import androidx.compose.ui.unit.sp
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
 import androidx.compose.ui.window.rememberWindowState
+import com.jetpackduba.gitnuro.credentials.SshProcess
 import com.jetpackduba.gitnuro.di.DaggerAppComponent
 import com.jetpackduba.gitnuro.extensions.preferenceValue
 import com.jetpackduba.gitnuro.extensions.toWindowPlacement
@@ -30,7 +31,7 @@ import com.jetpackduba.gitnuro.generated.resources.logo
 import com.jetpackduba.gitnuro.git.AppGpgSigner
 import com.jetpackduba.gitnuro.keybindings.KeybindingOption
 import com.jetpackduba.gitnuro.keybindings.matchesBinding
-import com.jetpackduba.gitnuro.lfs.GLfsFactory
+import com.jetpackduba.gitnuro.lfs.AppLfsFactory
 import com.jetpackduba.gitnuro.logging.printError
 import com.jetpackduba.gitnuro.managers.AppStateManager
 import com.jetpackduba.gitnuro.managers.TempFilesManager
@@ -49,11 +50,9 @@ import com.jetpackduba.gitnuro.ui.components.TabInformation
 import com.jetpackduba.gitnuro.ui.context_menu.AppPopupMenu
 import com.jetpackduba.gitnuro.ui.dialogs.settings.ProxyType
 import kotlinx.coroutines.launch
-import org.eclipse.jgit.lfs.BuiltinLFS
 import org.eclipse.jgit.lib.GpgConfig
-import org.eclipse.jgit.lib.Signer
-import org.eclipse.jgit.lib.SignerFactory
 import org.eclipse.jgit.lib.Signers
+import org.eclipse.jgit.transport.URIish
 import org.eclipse.jgit.util.LfsFactory
 import java.io.File
 import java.io.FileOutputStream
@@ -91,7 +90,7 @@ class App {
     lateinit var signer: AppGpgSigner
 
     @Inject
-    lateinit var gLfsFactory: GLfsFactory
+    lateinit var lfsFactory: AppLfsFactory
 
     init {
         appComponent.inject(this)
@@ -123,7 +122,7 @@ class App {
         }
 
         tabsManager.loadPersistedTabs()
-        gLfsFactory.register()
+        LfsFactory.setInstance(lfsFactory)
 
         if (dirToOpen != null)
             addDirTab(dirToOpen)
@@ -289,7 +288,6 @@ class App {
                 modifier = Modifier
                     .background(MaterialTheme.colors.background)
                     .onPreviewKeyEvent {
-                        println(it.toString())
                         when {
                             it.matchesBinding(KeybindingOption.OPEN_NEW_TAB) -> {
                                 tabsManager.addNewEmptyTab()
@@ -316,6 +314,7 @@ class App {
                                 }
                                 true
                             }
+
                             else -> false
                         }
                     }

src/main/kotlin/com/jetpackduba/gitnuro/AppConstants.kt

@@ -38,3 +38,9 @@ data class License(
 )
 
 data class Project(val name: String, val url: String, val license: License)
+
+
+object NetworkConstants {
+    const val ACCEPT_HEADER = "Accept"
+    const val AUTH_HEADER = "Authorization"
+}

src/main/kotlin/com/jetpackduba/gitnuro/credentials/CredentialsCacheRepository.kt

@@ -37,7 +37,7 @@ class CredentialsCacheRepository @Inject constructor() {
     }
 
     suspend fun cacheHttpCredentials(credentials: CredentialsCacheType.HttpCredentialsCache) {
-        cacheHttpCredentials(credentials.url, credentials.userName, credentials.password, credentials.isLfs)
+        cacheHttpCredentials(credentials.url, credentials.user, credentials.password, credentials.isLfs)
     }
 
     suspend fun cacheHttpCredentials(url: String, userName: String, password: String, isLfs: Boolean) {
@@ -109,7 +109,7 @@ sealed interface CredentialsCacheType {
 
     data class HttpCredentialsCache(
         val url: String,
-        val userName: String,
+        val user: String,
         val password: String,
         val isLfs: Boolean,
     ) : CredentialsCacheType

src/main/kotlin/com/jetpackduba/gitnuro/credentials/CredentialsStateManager.kt

@@ -17,9 +17,6 @@ class CredentialsStateManager @Inject constructor() {
     val credentialsState: StateFlow<CredentialsState>
         get() = _credentialsState
 
-    val currentCredentialsState: CredentialsState
-        get() = credentialsState.value
-
     suspend fun requestHttpCredentials(): CredentialsAccepted.HttpCredentialsAccepted {
         return requestAwaitingCredentials(CredentialsRequest.HttpCredentialsRequest)
     }
@@ -58,7 +55,7 @@ class CredentialsStateManager @Inject constructor() {
 
     private suspend inline fun <reified T : CredentialsAccepted> requestAwaitingCredentials(credentialsRequest: CredentialsRequest): T {
         mutex.withLock {
-            assert(this.currentCredentialsState is CredentialsState.None)
+            assert(this.credentialsState.value is CredentialsState.None)
 
             _credentialsState.value = credentialsRequest
 
@@ -88,7 +85,7 @@ sealed interface CredentialsAccepted : CredentialsState {
     data class LfsCredentialsAccepted(val user: String, val password: String) : CredentialsAccepted {
         companion object {
             fun fromCachedCredentials(credentials: CredentialsCacheType.HttpCredentialsCache): LfsCredentialsAccepted {
-                return LfsCredentialsAccepted(credentials.userName, credentials.password)
+                return LfsCredentialsAccepted(credentials.user, credentials.password)
             }
         }
     }

src/main/kotlin/com/jetpackduba/gitnuro/credentials/GSessionManager.kt

@@ -1,6 +1,5 @@
 package com.jetpackduba.gitnuro.credentials
 
-import com.jetpackduba.gitnuro.git.remote_operations.CredentialsCache
 import org.eclipse.jgit.transport.CredentialsProvider
 import org.eclipse.jgit.transport.RemoteSession
 import org.eclipse.jgit.transport.SshSessionFactory
@@ -10,10 +9,10 @@ import javax.inject.Inject
 import javax.inject.Provider
 
 class GSessionManager @Inject constructor(
-    private val GSshSessionFactory: GSshSessionFactory,
+    private val sshSessionFactory: GSshSessionFactory,
 ) {
     fun generateSshSessionFactory(): GSshSessionFactory {
-        return GSshSessionFactory
+        return sshSessionFactory
     }
 }
 
@@ -27,7 +26,7 @@ class GSshSessionFactory @Inject constructor(
         tms: Int,
     ): RemoteSession {
         val remoteSession = sessionProvider.get()
-        remoteSession.setup(uri, credentialsProvider as SshCredentialsProvider)
+        remoteSession.setup(uri, credentialsProvider)
 
         return remoteSession
     }

src/main/kotlin/com/jetpackduba/gitnuro/credentials/HttpCredentialsProvider.kt

@@ -90,15 +90,15 @@ class HttpCredentialsProvider @AssistedInject constructor(
                 if (appSettingsRepository.cacheCredentialsInMemory) {
                     credentialsCached = CredentialsCacheType.HttpCredentialsCache(
                         url = uri.toString(),
-                        userName = credentials.user,
+                        user = credentials.user,
                         password = credentials.password,
                         isLfs = false,
                     )
                 }
 
                 return true
             } else {
-                userItem.value = cachedCredentials.userName
+                userItem.value = cachedCredentials.user
                 passwordItem.value = cachedCredentials.password.toCharArray()
 
                 return true

src/main/kotlin/com/jetpackduba/gitnuro/credentials/SshRemoteSession.kt

@@ -3,19 +3,16 @@ package com.jetpackduba.gitnuro.credentials
 import Session
 import com.jetpackduba.gitnuro.exceptions.SshException
 import com.jetpackduba.gitnuro.extensions.throwIfSshMessage
-import kotlinx.coroutines.runBlocking
 import org.eclipse.jgit.transport.CredentialItem
+import org.eclipse.jgit.transport.CredentialsProvider
 import org.eclipse.jgit.transport.RemoteSession
 import org.eclipse.jgit.transport.URIish
-import java.util.concurrent.CancellationException
 import javax.inject.Inject
 
 
 private const val NOT_EXPLICIT_PORT = -1
 
-class SshRemoteSession @Inject constructor(
-    private val credentialsStateManager: CredentialsStateManager,
-) : RemoteSession {
+class SshRemoteSession @Inject constructor() : RemoteSession {
     private lateinit var session: Session
     private lateinit var process: SshProcess
     override fun exec(commandName: String, timeout: Int): Process {
@@ -33,7 +30,7 @@ class SshRemoteSession @Inject constructor(
         session.disconnect()
     }
 
-    fun setup(uri: URIish, sshCredentialsProvider: SshCredentialsProvider) {
+    fun setup(uri: URIish, sshCredentialsProvider: CredentialsProvider) {
         val session = Session.new()
             ?: throw SshException("Could not obtain the session, this is likely a bug. Please file a report.")
 

src/main/kotlin/com/jetpackduba/gitnuro/extensions/GenericUtils.kt

@@ -0,0 +1,14 @@
+package com.jetpackduba.gitnuro.extensions
+
+inline fun <T1: Any, T2: Any, R: Any> safeLet(p1: T1?, p2: T2?, block: (T1, T2)->R?): R? {
+    return if (p1 != null && p2 != null) block(p1, p2) else null
+}
+inline fun <T1: Any, T2: Any, T3: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, block: (T1, T2, T3)->R?): R? {
+    return if (p1 != null && p2 != null && p3 != null) block(p1, p2, p3) else null
+}
+inline fun <T1: Any, T2: Any, T3: Any, T4: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, p4: T4?, block: (T1, T2, T3, T4)->R?): R? {
+    return if (p1 != null && p2 != null && p3 != null && p4 != null) block(p1, p2, p3, p4) else null
+}
+inline fun <T1: Any, T2: Any, T3: Any, T4: Any, T5: Any, R: Any> safeLet(p1: T1?, p2: T2?, p3: T3?, p4: T4?, p5: T5?, block: (T1, T2, T3, T4, T5)->R?): R? {
+    return if (p1 != null && p2 != null && p3 != null && p4 != null && p5 != null) block(p1, p2, p3, p4, p5) else null
+}

src/main/kotlin/com/jetpackduba/gitnuro/extensions/InputStreamExtensions.kt

@@ -9,4 +9,19 @@ fun InputStream.toByteArray(): ByteArray {
         this.transferTo(byteArrayOutStream)
         byteArrayOutStream.toByteArray()
     }
+}
+
+fun InputStream.readUntilValue(limitValue: Int): ByteArray {
+    var value: Byte
+    val bytesList = mutableListOf<Byte>()
+
+    do {
+        value = this.read().toByte()
+
+        if (value.toInt() != limitValue) {
+            bytesList.add(value)
+        }
+    } while (value.toInt() != limitValue)
+
+    return bytesList.toByteArray()
 }

src/main/kotlin/com/jetpackduba/gitnuro/extensions/StringExtensions.kt

@@ -66,4 +66,6 @@ fun String.throwIfSshMessage() {
     if (this.isNotEmpty()) {
         throw SshException(this)
     }
-}
+}
+
+fun String.isHttpOrHttps() = this.startsWith("http://") or this.startsWith("https://")