Add LockError type for when lock cannot be acquired

Author: alexarchambault

library/src/libdaemonjvm/LockFiles.scala

@@ -8,27 +8,38 @@ import java.nio.file.attribute.PosixFilePermission
 import java.nio.file.StandardOpenOption
 import scala.collection.JavaConverters._
 import scala.util.Properties
+import libdaemonjvm.server.LockError
+import java.nio.channels.OverlappingFileLockException
 
 final case class LockFiles(
   lockFile: Path,
   pidFile: Path,
   socketPaths: SocketPaths
 ) {
-  def withLock[T](t: => T): T = {
+  def withLock[T](t: => Either[LockError, T]): Either[LockError, T] = {
     if (!Files.exists(lockFile)) {
       Files.createDirectories(lockFile.normalize.getParent)
       Files.write(lockFile, Array.emptyByteArray)
     }
-    var c: FileChannel = null
-    var l: FileLock    = null
+    var c: FileChannel                                    = null
+    var l: Either[OverlappingFileLockException, FileLock] = null
     try {
       c = FileChannel.open(lockFile, StandardOpenOption.WRITE)
-      l = c.lock()
-      t
+      l =
+        try Right(c.tryLock())
+        catch {
+          case ex: OverlappingFileLockException =>
+            Left(ex)
+        }
+      l match {
+        case Left(ex)    => Left(new LockError.Locked(lockFile, ex))
+        case Right(null) => Left(new LockError.Locked(lockFile))
+        case Right(_)    => t
+      }
     }
     finally {
       if (l != null)
-        try l.release()
+        try l.foreach(_.release())
         catch {
           case _: ClosedChannelException =>
           case _: IOException            =>

library/src/libdaemonjvm/server/LockError.scala

@@ -25,4 +25,6 @@ object LockError {
       extends FatalError(s"Cannot delete $file", cause)
   final class ZombieFound(val pid: Int, val connectionError: Throwable)
       extends RecoverableError(s"Cannot connect to process $pid", connectionError)
+  final class Locked(val file: Path, cause: Throwable = null)
+      extends RecoverableError(s"$file already locked", cause)
 }

tests/test/src/libdaemonjvm/tests/LockTests.scala

@@ -140,4 +140,23 @@ class LockTests extends munit.FunSuite {
     }
   }
 
+  test("locked") {
+    TestUtil.withTestDir { dir =>
+      val files = TestUtil.lockFiles(dir)
+      val e = files.withLock {
+        TestUtil.tryAcquire(files) { maybeChannel =>
+          maybeChannel match {
+            case Left(e: LockError.Locked) =>
+            case Left(otherError) =>
+              throw new Exception("Unexpected error type (expected Locked)", otherError)
+            case Right(channel) =>
+              sys.error("Opening new server channel should have failed")
+          }
+        }
+        Right(())
+      }
+      expect(e.isRight)
+    }
+  }
+
 }