Remove JNI stuff remnants (#12)

Author: alexarchambault

README.md

@@ -58,10 +58,7 @@ import java.nio.file._
 
 val daemonDirectory: Path = ??? // pass a directory under the user home dir, computed with directories-jvm for example
 val lockFiles = LockFiles.under(daemonDirectory, "my-app-name\\daemon") // second argument is the Windows named pipe path (that doesn't live in the file system)
-val res = Lock.tryAcquire(lockFiles) { serverSocket: Either[ServerSocket, ServerSocketChannel] =>
-  // serverSocket is a Right(…) when Java >= 16 Unix domain socket support is used,
-  // it's Left(…) when ipcsocket JNI support is used
-
+val res = Lock.tryAcquire(lockFiles) { serverSocket: ServerSocketChannel =>
   // you should start listening on serverSocket here, and as much as possible,
   // only exit this block when you are actually accepting incoming connections
 }

library/src/libdaemonjvm/client/Connect.scala

@@ -1,6 +1,5 @@
 package libdaemonjvm.client
 
-import java.net.Socket
 import java.nio.channels.SocketChannel
 import java.nio.charset.StandardCharsets
 import java.nio.file.Files
@@ -10,23 +9,19 @@ import libdaemonjvm.LockFiles
 
 object Connect {
 
-  def tryConnect(files: LockFiles): Option[Either[ConnectError, Either[Socket, SocketChannel]]] =
+  def tryConnect(files: LockFiles): Option[Either[ConnectError, SocketChannel]] =
     tryConnect(files, LockProcess.default)
 
   def tryConnect(
     files: LockFiles,
     proc: LockProcess
-  ): Option[Either[ConnectError, Either[Socket, SocketChannel]]] = {
-
-    def ifProcessRunning(pid: Int): Either[ConnectError, Either[Socket, SocketChannel]] =
-      SocketFile.connect(files.socketPaths) match {
-        case Left(e) =>
-          Left(new ConnectError.ZombieFound(pid, e))
-        case Right(s) =>
-          Right(s)
-      }
+  ): Option[Either[ConnectError, SocketChannel]] = {
+
+    def ifProcessRunning(pid: Int): Either[ConnectError, SocketChannel] =
+      SocketFile.connect(files.socketPaths)
+        .left.map(e => new ConnectError.ZombieFound(pid, e))
 
-    def ifFiles(hasLock: Boolean): Option[Either[ConnectError, Either[Socket, SocketChannel]]] = {
+    def ifFiles(hasLock: Boolean): Option[Either[ConnectError, SocketChannel]] = {
       val b = Files.readAllBytes(files.pidFile)
 
       // FIXME Catch malformed content errors here?

library/src/libdaemonjvm/internal/Java16SocketHandler.scala

@@ -7,23 +7,21 @@ import java.nio.file.Path
 
 import scala.util.control.NonFatal
 import java.nio.channels.ServerSocketChannel
-import java.net.ServerSocket
-import java.net.Socket
 import java.nio.file.Paths
 
 import libdaemonjvm.SocketPaths
 
 object Java16SocketHandler extends SocketHandler {
   def usesWindowsPipe: Boolean = false
 
-  def client(paths: SocketPaths): Either[Socket, SocketChannel] = {
+  def client(paths: SocketPaths): SocketChannel = {
     val a                = UnixDomainSocketAddress.of(paths.path)
     var s: SocketChannel = null
     try {
       s = SocketChannel.open(StandardProtocolFamily.UNIX)
       s.connect(a)
       s.finishConnect()
-      Right(s)
+      s
     }
     catch {
       case NonFatal(ex) =>
@@ -37,10 +35,10 @@ object Java16SocketHandler extends SocketHandler {
     }
   }
 
-  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel] = {
+  def server(paths: SocketPaths): ServerSocketChannel = {
     val a = UnixDomainSocketAddress.of(paths.path)
     val s = ServerSocketChannel.open(StandardProtocolFamily.UNIX)
     s.bind(a)
-    Right(s)
+    s
   }
 }

library/src/libdaemonjvm/internal/SocketFile.scala

@@ -3,35 +3,34 @@ package libdaemonjvm.internal
 import java.net.SocketException
 import java.nio.channels.SocketChannel
 import java.nio.file.Path
-import java.net.Socket
 
 import libdaemonjvm.errors._
 import libdaemonjvm.SocketPaths
 
 object SocketFile {
   def canConnect(paths: SocketPaths): Either[Throwable, Unit] = {
-    var s: Either[Throwable, Either[Socket, SocketChannel]] = null
+    var s: Either[Throwable, SocketChannel] = null
     try {
       s = connect(paths)
       s.map(_ => ())
     }
     finally if (s != null)
-      s.toOption.foreach(_.merge.close())
+      s.toOption.foreach(_.close())
   }
-  def connect(paths: SocketPaths): Either[Throwable, Either[Socket, SocketChannel]] = {
-    var s: Either[Socket, SocketChannel] = null
+  def connect(paths: SocketPaths): Either[Throwable, SocketChannel] = {
+    var s: SocketChannel = null
     try {
       s = SocketHandler.client(paths)
       Right(s)
     }
     catch {
       case e: SocketException =>
         if (s != null)
-          s.merge.close()
+          s.close()
         Left(e)
       case e: SocketExceptionLike =>
         if (s != null)
-          s.merge.close()
+          s.close()
         Left(e)
     }
   }

library/src/libdaemonjvm/internal/SocketHandler.scala

@@ -3,22 +3,19 @@ package libdaemonjvm.internal
 import java.nio.channels.{ServerSocketChannel, SocketChannel}
 import java.nio.file.Path
 
-import java.net.Socket
-import java.net.ServerSocket
-
 import libdaemonjvm.SocketPaths
 
 trait SocketHandler {
   def usesWindowsPipe: Boolean
-  def client(paths: SocketPaths): Either[Socket, SocketChannel]
-  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel]
+  def client(paths: SocketPaths): SocketChannel
+  def server(paths: SocketPaths): ServerSocketChannel
 }
 
 object SocketHandler {
   def usesWindowsPipe: Boolean =
     DefaultSocketHandler.default.usesWindowsPipe
-  def client(paths: SocketPaths): Either[Socket, SocketChannel] =
+  def client(paths: SocketPaths): SocketChannel =
     DefaultSocketHandler.default.client(paths)
-  def server(paths: SocketPaths): Either[ServerSocket, ServerSocketChannel] =
+  def server(paths: SocketPaths): ServerSocketChannel =
     DefaultSocketHandler.default.server(paths)
 }

library/src/libdaemonjvm/server/Lock.scala

@@ -6,14 +6,13 @@ import java.nio.file.{Files, Path}
 
 import libdaemonjvm.LockFiles
 import libdaemonjvm.internal.{LockProcess, SocketFile, SocketHandler}
-import java.net.ServerSocket
 
 object Lock {
 
   def tryAcquire[T](
     files: LockFiles
   )(
-    startListening: Either[ServerSocket, ServerSocketChannel] => T
+    startListening: ServerSocketChannel => T
   ): Either[LockError, T] =
     tryAcquire(files, LockProcess.default) {
       val socket = SocketHandler.server(files.socketPaths)

library/test/src/libdaemonjvm/tests/TestUtil.scala

@@ -7,7 +7,6 @@ import java.nio.channels.ServerSocketChannel
 import libdaemonjvm._
 import libdaemonjvm.internal._
 import libdaemonjvm.server._
-import java.net.ServerSocket
 import scala.util.Properties
 import java.util.concurrent.CountDownLatch
 import java.net.Socket
@@ -49,89 +48,36 @@ object TestUtil {
   }
   def tryAcquire[T](dir: os.Path)(f: (
     LockFiles,
-    Either[LockError, Either[ServerSocket, ServerSocketChannel]]
+    Either[LockError, ServerSocketChannel]
   ) => T): T = {
     val files = lockFiles(dir)
     tryAcquire(files) { maybeChannel =>
       f(files, maybeChannel)
     }
   }
-  def tryAcquire[T](files: LockFiles)(f: Either[
-    LockError,
-    Either[ServerSocket, ServerSocketChannel]
-  ] => T): T =
+  def tryAcquire[T](files: LockFiles)(f: Either[LockError, ServerSocketChannel] => T): T =
     tryAcquire(files, LockProcess.default)(f)
   def tryAcquire[T](
     files: LockFiles,
     proc: LockProcess
-  )(f: Either[LockError, Either[ServerSocket, ServerSocketChannel]] => T): T = {
-    var serverChannel: Either[ServerSocket, ServerSocketChannel] = null
-    var acceptThreadOpt                                          = Option.empty[Thread]
-    val accepting                                                = new CountDownLatch(1)
-    val shouldStop                                               = new AtomicBoolean(false)
+  )(f: Either[LockError, ServerSocketChannel] => T): T = {
+    var serverChannel: ServerSocketChannel = null
+    val accepting                          = new CountDownLatch(1)
     try {
       val maybeServerChannel = Lock.tryAcquire(files, proc) {
         serverChannel = SocketHandler.server(files.socketPaths)
-        if (Properties.isWin)
-          // Windows named pipes seem no to accept clients unless accept is being called on the server socket
-          acceptThreadOpt =
-            serverChannel.left.toOption.map(acceptAndDiscard(
-              _,
-              accepting,
-              () => shouldStop.get()
-            ))
-        for (t <- acceptThreadOpt) {
-          t.start()
-          accepting.await()
-          // waiting so that the accept call below effectively awaits client... :|
-          Thread.sleep(
-            1000L
-          )
-        }
         serverChannel
       }
       f(maybeServerChannel)
     }
     finally {
-      shouldStop.set(true)
       try SocketFile.canConnect(files.socketPaths) // unblock the server thread last accept
       catch {
         case NonFatal(e) =>
           System.err.println(s"Ignoring $e while trying to unblock last accept")
       }
       for (channel <- Option(serverChannel))
-        channel.merge.close()
+        channel.close()
     }
   }
-
-  val acceptAndDiscardCount = new AtomicInteger
-  def acceptAndDiscard(
-    s: ServerSocket,
-    accepting: CountDownLatch,
-    shouldStop: () => Boolean
-  ): Thread =
-    new Thread(
-      s"libdaemonjvm-tests-accept-and-discard-${acceptAndDiscardCount.incrementAndGet()}"
-    ) {
-      setDaemon(true)
-      val closeCount = new AtomicInteger
-      def closeSocket(socket: Socket): Unit = {
-        val t = new Thread(s"$getName-close-${closeCount.incrementAndGet()}") {
-          setDaemon(true)
-          override def run(): Unit = {
-            socket.close()
-          }
-        }
-        t.start()
-      }
-      override def run(): Unit = {
-        accepting.countDown()
-        while (!shouldStop()) {
-          val client = s.accept()
-          // closing the client socket in the background, as this call seems to block a few seconds
-          closeSocket(client)
-        }
-      }
-    }
-
 }

manual/server/src/libdaemonjvm/TestServer.scala

@@ -49,7 +49,7 @@ object TestServer {
       )
     }
     val files = LockFiles.under(path)
-    Lock.tryAcquire(files)(s => runServer(() => s.fold(_.accept(), _.accept()))) match {
+    Lock.tryAcquire(files)(s => runServer(() => s.accept())) match {
       case Left(e)   => throw e
       case Right(()) =>
     }