Handle possible OverlappingFileLockExceptions for cache file (#218)

* Handle possible OverlappingFileLockExceptions for cache file

* code style fix

* small improvement in a comment

Author: LukaszKontowski

codec-registration-checker-compiler-plugin/src/main/scala/org/virtuslab/ash/CodecRegistrationCheckerCompilerPlugin.scala

@@ -5,6 +5,7 @@ import java.io.FileNotFoundException
 import java.io.IOException
 import java.io.RandomAccessFile
 import java.nio.ByteBuffer
+import java.nio.channels.OverlappingFileLockException
 import java.nio.charset.StandardCharsets
 
 import scala.tools.nsc.Global
@@ -30,35 +31,54 @@ class CodecRegistrationCheckerCompilerPlugin(override val global: Global) extend
 
     options.filterNot(_.startsWith("-")).headOption match {
       case Some(path) =>
-        try {
-          val cacheFile = new File(path + File.separator + directClassDescendantsCacheFileName)
-          cacheFile.getCanonicalPath
-          pluginOptions.directClassDescendantsCacheFile = cacheFile
-          pluginOptions.oldParentChildFQCNPairs = {
-            val raf = new RandomAccessFile(cacheFile, "rw")
-            try {
-              val channel = raf.getChannel
-              val lock = channel.lock()
+        /*
+        Below retry-loop is needed because of possible OverlappingFileLockException that might
+        occur if codec-registration-checker-plugin is enabled in multiple projects (modules)
+        and these projects are compiled in parallel by `sbt compile`. As all projects/modules
+        share the same cache file - `channel.lock()` might cause mentioned exception.
+         */
+        var shouldInitialize = false
+        var loopCount = 0
+        val maxTries = 5
+        while (loopCount < maxTries && !shouldInitialize) {
+          try {
+            val cacheFile = new File(path + File.separator + directClassDescendantsCacheFileName)
+            cacheFile.getCanonicalPath
+            pluginOptions.directClassDescendantsCacheFile = cacheFile
+            pluginOptions.oldParentChildFQCNPairs = {
+              val raf = new RandomAccessFile(cacheFile, "rw")
               try {
-                val buffer = ByteBuffer.allocate(channel.size().toInt)
-                channel.read(buffer)
-                CodecRegistrationCheckerCompilerPlugin.parseCacheFile(buffer.rewind())
+                val channel = raf.getChannel
+                val lock = channel.lock()
+                try {
+                  val buffer = ByteBuffer.allocate(channel.size().toInt)
+                  channel.read(buffer)
+                  CodecRegistrationCheckerCompilerPlugin.parseCacheFile(buffer.rewind())
+                } finally {
+                  lock.close()
+                }
               } finally {
-                lock.close()
+                raf.close()
               }
-            } finally {
-              raf.close()
             }
+            shouldInitialize = true
+          } catch {
+            case _: FileNotFoundException =>
+              pluginOptions.oldParentChildFQCNPairs = Nil
+              shouldInitialize = true
+            case e: OverlappingFileLockException =>
+              if (loopCount + 1 == maxTries)
+                error(s"OverlappingFileLockException thrown, message: ${e.getMessage}")
+              else
+                Thread.sleep(20)
+            case e: IOException =>
+              error(s"IOException thrown, message: ${e.getMessage}")
+            case e: RuntimeException =>
+              error(s"RuntimeException thrown, message: ${e.getMessage}")
           }
-          true
-        } catch {
-          case _: FileNotFoundException =>
-            pluginOptions.oldParentChildFQCNPairs = Nil
-            true
-          case e @ (_: IOException | _: RuntimeException) =>
-            error(s"Exception thrown, message: ${e.getMessage}")
-            false
+          loopCount += 1
         }
+        shouldInitialize
       case None =>
         error("No directory for saving cache file specified")
         false

docs/GUIDE.md

@@ -119,7 +119,9 @@ This option disables detection of messages/events/state based on return type of
 `Compile / scalacOptions += "-P:serializability-checker-plugin:--disable-detection-higher-order-function"`<br><br>
 
 ### Codec Registration Checker Compiler Plugin
-Before using this compiler plugin, make sure that you are using both [annotations](#annotations) properly. If so &mdash; the plugin can be used right away. This plugin checks whether classes marked with serializability trait are being referenced in a marked serializer, which ensures that codecs will be registered in runtime.<br><br>
+Before using this compiler plugin, make sure that you are using both [annotations](#annotations) properly. If so &mdash; the plugin can be used right away. This plugin checks whether classes marked with serializability trait are being referenced in a marked serializer, which ensures that codecs will be registered in runtime.
+
+**Note** - Codec Registration Checker Compiler Plugin is useful only in projects (modules) where the [@Serializer](#Serializer) annotation is used. Therefore, if you are using Akka Serialization Helper in multiple modules but in fact use `@Serializer` annotation in only one module, you might disable this plugin in all other modules except the one where `@Serializer` annotation is used.<br><br>
 Codec Registration Checker Compiler Plugin does not need additional configuration, but you can change default configurations as explained below:
 
 - `--disable`