chore: create & delete sync sessions over gRPC

Author: ethanndickson

Coder-Desktop/VPNLib/FileSync/FileSyncDaemon.swift

@@ -162,7 +162,7 @@ public class MutagenDaemon: FileSyncDaemon {
             // Already connected
             return
         }
-        group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        group = MultiThreadedEventLoopGroup(numberOfThreads: 2)
         do {
             channel = try GRPCChannelPool.with(
                 target: .unixDomainSocket(mutagenDaemonSocket.path),
@@ -252,51 +252,6 @@ public class MutagenDaemon: FileSyncDaemon {
             logger.info("\(line, privacy: .public)")
         }
     }
-
-    public func refreshSessions() async {
-        guard case .running = state else { return }
-        // TODO: Implement
-    }
-
-    public func createSession(
-        localPath _: String,
-        agentHost _: String,
-        remotePath _: String
-    ) async throws(DaemonError) {
-        if case .stopped = state {
-            do throws(DaemonError) {
-                try await start()
-            } catch {
-                state = .failed(error)
-                throw error
-            }
-        }
-        // TODO: Add session
-    }
-
-    public func deleteSessions(ids _: [String]) async throws(DaemonError) {
-        // TODO: Delete session
-        await stopIfNoSessions()
-    }
-
-    private func stopIfNoSessions() async {
-        let sessions: Synchronization_ListResponse
-        do {
-            sessions = try await client!.sync.list(Synchronization_ListRequest.with { req in
-                req.selection = .with { selection in
-                    selection.all = true
-                }
-            })
-        } catch {
-            state = .failed(.daemonStartFailure(error))
-            return
-        }
-        // If there's no configured sessions, the daemon doesn't need to be running
-        if sessions.sessionStates.isEmpty {
-            logger.info("No sync sessions found")
-            await stop()
-        }
-    }
 }
 
 struct DaemonClient {

Coder-Desktop/VPNLib/FileSync/FileSyncManagement.swift

@@ -0,0 +1,80 @@
+public extension MutagenDaemon {
+    func refreshSessions() async {
+        guard case .running = state else { return }
+        let sessions: Synchronization_ListResponse
+        do {
+            sessions = try await client!.sync.list(Synchronization_ListRequest.with { req in
+                req.selection = .with { selection in
+                    selection.all = true
+                }
+            })
+        } catch {
+            state = .failed(.grpcFailure(error))
+            return
+        }
+        sessionState = sessions.sessionStates.map { FileSyncSession(state: $0) }
+        if sessionState.isEmpty {
+            logger.info("No sync sessions found")
+            await stop()
+        }
+    }
+
+    func createSession(
+        localPath: String,
+        agentHost: String,
+        remotePath: String
+    ) async throws(DaemonError) {
+        if case .stopped = state {
+            do throws(DaemonError) {
+                try await start()
+            } catch {
+                state = .failed(error)
+                throw error
+            }
+        }
+        let (stream, promptID) = try await host()
+        defer { stream.cancel() }
+        let req = Synchronization_CreateRequest.with { req in
+            req.prompter = promptID
+            req.specification = .with { spec in
+                spec.alpha = .with { alpha in
+                    alpha.protocol = .local
+                    alpha.path = localPath
+                }
+                spec.beta = .with { beta in
+                    beta.protocol = .ssh
+                    beta.host = agentHost
+                    beta.path = remotePath
+                }
+                // TODO: Ingest a config from somewhere
+                spec.configuration = Synchronization_Configuration()
+                spec.configurationAlpha = Synchronization_Configuration()
+                spec.configurationBeta = Synchronization_Configuration()
+            }
+        }
+        do {
+            _ = try await client!.sync.create(req)
+        } catch {
+            throw .grpcFailure(error)
+        }
+        await refreshSessions()
+    }
+
+    func deleteSessions(ids: [String]) async throws(DaemonError) {
+        // Terminating sessions does not require prompting
+        let (stream, promptID) = try await host(allowPrompts: false)
+        defer { stream.cancel() }
+        guard case .running = state else { return }
+        do {
+            _ = try await client!.sync.terminate(Synchronization_TerminateRequest.with { req in
+                req.prompter = promptID
+                req.selection = .with { selection in
+                    selection.specifications = ids
+                }
+            })
+        } catch {
+            throw .grpcFailure(error)
+        }
+        await refreshSessions()
+    }
+}