Working on integrating backup

Sources/BackupFeature/Service/BackupService.swift

@@ -2,6 +2,7 @@ import UIKit
 import Models
 import Combine
 import Defaults
+import Keychain
 import SFTPFeature
 import iCloudFeature
 import DropboxFeature
@@ -14,6 +15,7 @@ public final class BackupService {
     @Dependency private var icloudService: iCloudInterface
     @Dependency private var dropboxService: DropboxInterface
     @Dependency private var networkManager: NetworkMonitoring
+    @Dependency private var keychainHandler: KeychainHandling
     @Dependency private var driveService: GoogleDriveInterface
 
     @KeyObject(.backupSettings, defaultValue: Data()) private var storedSettings: Data
@@ -207,25 +209,25 @@ extension BackupService {
         }
 
         if sftpService.isAuthorized() {
-            let host = ""
-            let username = ""
-            let password = ""
-
-            let completion: SFTPFetchResult = { result in
-                switch result {
-                case .success(let settings):
-                    if let settings = settings {
-                        print("")
-                    } else {
-                        print("")
+            if let keychain = try? DependencyInjection.Container.shared.resolve() as KeychainHandling,
+               let pwd = try? keychain.get(key: .pwd),
+               let host = try? keychain.get(key: .host),
+               let username = try? keychain.get(key: .username) {
+
+                let completion: SFTPFetchResult = { [weak settings] result in
+                    guard let settings = settings else { return }
+
+                    switch result {
+                    case .success(let backupSettings):
+                        settings.value.backups[.sftp] = backupSettings?.backup
+                    case .failure(let error):
+                        print(error.localizedDescription)
                     }
-                case .failure(let error):
-                    print(error.localizedDescription)
                 }
-            }
 
-            let authParams = SFTPAuthParams(host, username, password)
-            sftpService.fetch((authParams, completion))
+                let authParams = SFTPAuthParams(host, username, pwd)
+                sftpService.fetch((authParams, completion))
+            }
         }
 
         if dropboxService.isAuthorized() {
@@ -326,7 +328,11 @@ extension BackupService {
                 // try? FileManager.default.removeItem(at: url)
             }
         case .sftp:
-            break // TODO
+            do {
+                try sftpService.upload(url)
+            } catch {
+                print(error.localizedDescription)
+            }
         }
     }
 }

Sources/NetworkMonitor/MockNetworkMonitor.swift

@@ -32,11 +32,11 @@ public struct MockNetworkMonitor: NetworkMonitoring {
         statusRelay.send(status)
 
         if status == .available {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
                 simulateOscilation(.internetNotAvailable)
             }
         } else if status == .internetNotAvailable {
-            DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 5) {
                 simulateOscilation(.available)
             }
         }

Sources/SFTPFeature/SFTPService.swift

@@ -10,6 +10,7 @@ public typealias SFTPFetchParams = (SFTPAuthParams, SFTPFetchResult)
 
 public struct SFTPService {
     public var isAuthorized: () -> Bool
+    public var upload: (URL) throws -> Void
     public var fetch: (SFTPFetchParams) -> Void
     public var download: (String) throws -> Void
     public var justAuthenticate: (SFTPAuthParams) throws -> Void
@@ -18,15 +19,29 @@ public struct SFTPService {
 public extension SFTPService {
     static var mock = SFTPService(
         isAuthorized: {
-            true
+            print("^^^ Requested auth status on sftp service")
+            return true
+        },
+        upload: { url in
+            print("^^^ Requested upload on sftp service")
+            print("^^^ URL path: \(url.path)")
         },
         fetch: { (authParams, completion) in
+            print("^^^ Requested backup metadata on sftp service.")
+            print("^^^ Host: \(authParams.0)")
+            print("^^^ Username: \(authParams.1)")
+            print("^^^ Password: \(authParams.2)")
             completion(.success(nil))
         },
         download: { path in
-
+            print("^^^ Requested backup download on sftp service.")
+            print("^^^ Path: \(path)")
         },
         justAuthenticate: { host, username, password in
+            print("^^^ Requested to authenticate on sftp service")
+            print("^^^ Host: \(host)")
+            print("^^^ Username: \(username)")
+            print("^^^ Password: \(password)")
         })
 
     static var live = SFTPService(
@@ -40,6 +55,18 @@ public extension SFTPService {
                 return false
             }
         },
+        upload: { url in
+            let keychain = try DependencyInjection.Container.shared.resolve() as KeychainHandling
+            let host = try keychain.get(key: .host)
+            let password = try keychain.get(key: .pwd)
+            let username = try keychain.get(key: .username)
+
+            let ssh = try SSH(host: host!, port: 22)
+            try ssh.authenticate(username: username!, password: password!)
+            let sftp = try ssh.openSftp()
+
+            try sftp.upload(localURL: url, remotePath: "backup/backup.xxm")
+        },
         fetch: { (authParams, completion) in
             let host = authParams.0
             let username = authParams.1