Switch PosixPluginFrontend to sockets

Author: bell-db

bridge/src/main/scala/protocbridge/frontend/PosixPluginFrontend.scala

@@ -1,98 +1,75 @@
 package protocbridge.frontend
 
-import java.nio.file.{Files, Path}
+import protocbridge.{ExtraEnv, ProtocCodeGenerator}
 
-import protocbridge.ProtocCodeGenerator
-import protocbridge.ExtraEnv
+import java.net.ServerSocket
 import java.nio.file.attribute.PosixFilePermission
-
-import scala.concurrent.blocking
-import scala.concurrent.Future
-import scala.concurrent.ExecutionContext.Implicits.global
-import scala.sys.process._
+import java.nio.file.{Files, Path}
 import java.{util => ju}
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.{Future, blocking}
 
 /** PluginFrontend for Unix-like systems (Linux, Mac, etc)
   *
-  * Creates a pair of named pipes for input/output and a shell script that
-  * communicates with them.
+  * Creates a server socket and a shell script that communicates with it.
   */
 object PosixPluginFrontend extends PluginFrontend {
-  case class InternalState(
-      inputPipe: Path,
-      outputPipe: Path,
-      tempDir: Path,
-      shellScript: Path
-  )
+  case class InternalState(serverSocket: ServerSocket, shellScript: Path)
 
   override def prepare(
       plugin: ProtocCodeGenerator,
       env: ExtraEnv
   ): (Path, InternalState) = {
-    val tempDirPath = Files.createTempDirectory("protopipe-")
-    val inputPipe = createPipe(tempDirPath, "input")
-    val outputPipe = createPipe(tempDirPath, "output")
-    val sh = createShellScript(inputPipe, outputPipe)
+    // We use socket instead of named pipes.
+    // This is because named pipes are unreliable on macOS: https://github.com/scalapb/protoc-bridge/issues/366.
+    val ss = new ServerSocket(0) // Bind to any available port.
+    val sh = createShellScript(ss.getLocalPort)
 
     Future {
       blocking {
+        // Accept a single client connection from the shell script.
+        val client = ss.accept()
+
         try {
-          val fsin = Files.newInputStream(inputPipe)
-          val response = PluginFrontend.runWithInputStream(plugin, fsin, env)
-          fsin.close()
+          val cis = client.getInputStream
+          val response = PluginFrontend.runWithInputStream(plugin, cis, env)
 
-          val fsout = Files.newOutputStream(outputPipe)
-          fsout.write(response)
-          fsout.close()
+          val cos = client.getOutputStream
+          cos.write(response)
         } catch {
           case e: Throwable =>
             // Handles rare exceptions not already gracefully handled in `runWithBytes`.
             // Such exceptions aren't converted to `CodeGeneratorResponse`
-            // because `fsin` might not be fully consumed,
-            // therefore the plugin shell script might hang on `inputPipe`,
-            // and never consume `CodeGeneratorResponse`.
+            // because `cis` might not be fully consumed,
+            // therefore the plugin shell script might hang on `nc` write,
+            // and never get to `nc` read and consume `CodeGeneratorResponse`.
+            //
+            // Instead, we simply force close the client connection,
+            // so that the plugin shell script can exit.
             System.err.println("Exception occurred in PluginFrontend outside runWithBytes")
             e.printStackTrace(System.err)
-            // Force an exit of the program.
-            // This is because the plugin shell script might hang on `inputPipe`,
-            // due to `fsin` not fully consumed.
-            // Or it might hang on `outputPipe`, due to `fsout` not closed.
-            // Therefore, the program might be stuck waiting for protoc,
-            // which in turn is waiting for the plugin shell script.
-            //
-            // We can't simply close `fsout` here either,
-            // because `Files.newOutputStream(outputPipe)` will hang
-            // if `outputPipe` is not yet opened by the plugin shell script for reading.
-            sys.exit(1)
+        } finally {
+           client.close()
         }
       }
     }
-    (sh, InternalState(inputPipe, outputPipe, tempDirPath, sh))
+    (sh, InternalState(ss, sh))
   }
 
   override def cleanup(state: InternalState): Unit = {
+    state.serverSocket.close()
     if (sys.props.get("protocbridge.debug") != Some("1")) {
-      Files.delete(state.inputPipe)
-      Files.delete(state.outputPipe)
-      Files.delete(state.tempDir)
       Files.delete(state.shellScript)
     }
   }
 
-  private def createPipe(tempDirPath: Path, name: String): Path = {
-    val pipeName = tempDirPath.resolve(name)
-    Seq("mkfifo", "-m", "600", pipeName.toAbsolutePath.toString).!!
-    pipeName
-  }
-
-  private def createShellScript(inputPipe: Path, outputPipe: Path): Path = {
+  private def createShellScript(port: Int): Path = {
     val shell = sys.env.getOrElse("PROTOCBRIDGE_SHELL", "/bin/sh")
     val scriptName = PluginFrontend.createTempFile(
       "",
       s"""|#!$shell
           |set -e
-          |cat /dev/stdin > "$inputPipe"
-          |cat "$outputPipe"
+          |nc localhost $port
       """.stripMargin
     )
     val perms = new ju.HashSet[PosixFilePermission]

bridge/src/test/scala/protocbridge/frontend/PosixPluginFrontendSpec.scala

@@ -40,6 +40,7 @@ class PosixPluginFrontendSpec extends AnyFlatSpec with Matchers {
       process.exitValue()
       actualOutput.toByteArray mustBe toReceive
       PosixPluginFrontend.cleanup(state)
+      state.serverSocket.isClosed mustBe true
     }
   }
 }