Add an indirection in SocketHandler, to default to JNI on Windows (#4)

Author: alexarchambault

library/src/libdaemonjvm/internal/DefaultSocketHandler.scala

@@ -0,0 +1,6 @@
+package libdaemonjvm.internal
+
+object DefaultSocketHandler {
+  def default: SocketHandler =
+    JniSocketHandler
+}

library/src/libdaemonjvm/internal/JniSocketHandler.scala

@@ -0,0 +1,59 @@
+package libdaemonjvm.internal
+
+import java.nio.channels.{ServerSocketChannel, SocketChannel}
+import java.nio.file.Path
+
+import org.scalasbt.ipcsocket.{UnixDomainServerSocket, UnixDomainSocket}
+import java.net.Socket
+import java.net.ServerSocket
+import java.io.IOException
+import org.scalasbt.ipcsocket.NativeErrorException
+import scala.util.Properties
+import org.scalasbt.ipcsocket.Win32NamedPipeSocket
+import org.scalasbt.ipcsocket.Win32NamedPipeServerSocket
+
+import libdaemonjvm.errors._
+import libdaemonjvm.SocketPaths
+import java.util.Locale
+
+object JniSocketHandler extends SocketHandler {
+
+  def supported(): Boolean =
+    (Properties.isLinux || Properties.isWin || Properties.isMac) &&
+    sys.props.get("os.arch").exists { arch =>
+      val arch0 = arch.toLowerCase(Locale.ROOT)
+      arch0 == "x86_64" || arch0 == "amd64"
+    }
+
+  private val connectionRelatedCodes = Set(61, 111)
+  private def exHandler: PartialFunction[Throwable, Nothing] = {
+    case ex: IOException
+        if Option(ex.getCause)
+          .collect { case e: NativeErrorException => e }
+          .exists(e => connectionRelatedCodes(e.returnCode)) =>
+      throw new ConnectExceptionLike(ex)
+    case ex: IOException if ex.getMessage.contains("error code 2") =>
+      throw new SocketExceptionLike(ex)
+    case ex: IOException if ex.getMessage.contains("Couldn't open pipe for") =>
+      throw new SocketExceptionLike(ex)
+  }
+
+  private def actualPath(paths: SocketPaths): String =
+    if (usesWindowsPipe) paths.windowsPipeName
+    else paths.path.toString
+
+  def usesWindowsPipe: Boolean =
+    Properties.isWin
+
+  def client(paths: SocketPaths): Either[Socket, SocketChannel] = {
+    val s =
+      try SocketMaker.client(actualPath(paths))
+      catch exHandler
+    Left(s)
+  }
+
+  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel] = {
+    val s = SocketMaker.server(actualPath(paths))
+    Left(s)
+  }
+}

library/src/libdaemonjvm/internal/SocketHandler.scala

@@ -3,50 +3,22 @@ package libdaemonjvm.internal
 import java.nio.channels.{ServerSocketChannel, SocketChannel}
 import java.nio.file.Path
 
-import org.scalasbt.ipcsocket.{UnixDomainServerSocket, UnixDomainSocket}
 import java.net.Socket
 import java.net.ServerSocket
-import java.io.IOException
-import org.scalasbt.ipcsocket.NativeErrorException
-import scala.util.Properties
-import org.scalasbt.ipcsocket.Win32NamedPipeSocket
-import org.scalasbt.ipcsocket.Win32NamedPipeServerSocket
 
-import libdaemonjvm.errors._
 import libdaemonjvm.SocketPaths
 
-object SocketHandler {
-  private val connectionRelatedCodes = Set(61, 111)
-  private def exHandler: PartialFunction[Throwable, Nothing] = {
-    case ex: IOException
-        if Option(ex.getCause)
-          .collect { case e: NativeErrorException => e }
-          .exists(e => connectionRelatedCodes(e.returnCode)) =>
-      throw new ConnectExceptionLike(ex)
-    case ex: IOException if ex.getMessage.contains("error code 2") =>
-      throw new SocketExceptionLike(ex)
-    case ex: IOException if ex.getMessage.contains("Couldn't open pipe for") =>
-      throw new SocketExceptionLike(ex)
-  }
-
-  private def actualPath(paths: SocketPaths): String =
-    if (usesWindowsPipe) paths.windowsPipeName
-    // val bt = "\\"
-    // s"$bt$bt.${bt}pipe$bt" + f
-    else paths.path.toString
+trait SocketHandler {
+  def usesWindowsPipe: Boolean
+  def client(paths: SocketPaths): Either[Socket, SocketChannel]
+  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel]
+}
 
+object SocketHandler {
   def usesWindowsPipe: Boolean =
-    Properties.isWin
-
-  def client(paths: SocketPaths): Either[Socket, SocketChannel] = {
-    val s =
-      try SocketMaker.client(actualPath(paths))
-      catch exHandler
-    Left(s)
-  }
-
-  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel] = {
-    val s = SocketMaker.server(actualPath(paths))
-    Left(s)
-  }
+    DefaultSocketHandler.default.usesWindowsPipe
+  def client(paths: SocketPaths): Either[Socket, SocketChannel] =
+    DefaultSocketHandler.default.client(paths)
+  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel] =
+    DefaultSocketHandler.default.server(paths)
 }

library16/src/libdaemonjvm/internal/DefaultSocketHandler.scala

@@ -0,0 +1,20 @@
+package libdaemonjvm.internal
+
+import scala.util.Properties
+
+object DefaultSocketHandler {
+  def default: SocketHandler =
+    sys.props.get("libdaemonjvm.internal.DefaultSocketHandler") match {
+      case Some("JniSocketHandler" | "jni")       => JniSocketHandler
+      case Some("Java16SocketHandler" | "java16") => Java16SocketHandler
+      case _                                      =>
+        // On Windows, default to JNI for now when we can, as the JNI and Java 16
+        // support aren't compatible with each other, so that Java 8 and Java 17 processes
+        // can talk to each other (via the JNI stuff).
+        // In more detail, JNI support relies on Windows "named pipes", while the Java 16
+        // one relies on proper Unix-like domain socket support (added at some point in Windows
+        // 10). Hence the incompatibility.
+        if (Properties.isWin && JniSocketHandler.supported()) JniSocketHandler
+        else Java16SocketHandler
+    }
+}

library16/src/libdaemonjvm/internal/SocketHandler.scala renamed to library16/src/libdaemonjvm/internal/Java16SocketHandler.scala

@@ -13,7 +13,7 @@ import java.nio.file.Paths
 
 import libdaemonjvm.SocketPaths
 
-object SocketHandler {
+object Java16SocketHandler extends SocketHandler {
   def usesWindowsPipe: Boolean = false
 
   def client(paths: SocketPaths): Either[Socket, SocketChannel] = {