Disable unexpected compilation exceptions caching

scex-core/src/main/scala/com/avsystem/scex/compiler/CachingScexCompiler.scala

@@ -1,14 +1,14 @@
 package com.avsystem.scex
 package compiler
 
-import java.util.concurrent.{ExecutionException, TimeUnit}
-
+import com.avsystem.scex.compiler.ScexCompiler.CompilationFailedException
 import com.avsystem.scex.parsing.PositionMapping
 import com.avsystem.scex.validation.{SymbolValidator, SyntaxValidator}
 import com.google.common.cache.CacheBuilder
 import com.google.common.util.concurrent.ExecutionError
 
-import scala.util.Try
+import java.util.concurrent.{ExecutionException, TimeUnit}
+import scala.util.{Failure, Success, Try}
 
 trait CachingScexCompiler extends ScexCompiler {
 
@@ -42,21 +42,40 @@ trait CachingScexCompiler extends ScexCompiler {
  private val symbolValidatorsCache =
  CacheBuilder.newBuilder.build[String, SymbolValidator]
 
+ // used to avoid unexpected exceptions caching, such as a random NPE thrown during a machine I/O error
+ private def invalidateCacheEntry(result: Try[_], invalidate: () => Unit): Unit =
+ if (!settings.cacheUnexpectedCompilationExceptions.value)
+ result match {
+ case Failure(_: CompilationFailedException) | Success(_) =>
+ case Failure(_) => invalidate()
+ }
+
  override protected def preprocess(expression: String, template: Boolean) =
  unwrapExecutionException(
  preprocessingCache.get((expression, template), callable(super.preprocess(expression, template))))
 
- override protected def compileExpression(exprDef: ExpressionDef) =
- unwrapExecutionException(
-  expressionCache.get(exprDef, callable(super.compileExpression(exprDef))))
+ override protected def compileExpression(exprDef: ExpressionDef) = {
+ val result = unwrapExecutionException(expressionCache.get(exprDef, callable(super.compileExpression(exprDef))))
+ invalidateCacheEntry(result, () => expressionCache.invalidate(exprDef))
 
- override protected def compileProfileObject(profile: ExpressionProfile) =
- unwrapExecutionException(underLock(
+ result
+ }
+
+ override protected def compileProfileObject(profile: ExpressionProfile) = {
+ val result = unwrapExecutionException(underLock(
  profileCompilationResultsCache.get(profile, callable(super.compileProfileObject(profile)))))
+ invalidateCacheEntry(result, () => profileCompilationResultsCache.invalidate(profile))
 
- override protected def compileExpressionUtils(source: NamedSource) =
- unwrapExecutionException(underLock(
+ result
+ }
+
+ override protected def compileExpressionUtils(source: NamedSource) = {
+ val result = unwrapExecutionException(underLock(
  utilsCompilationResultsCache.get(source.name, callable(super.compileExpressionUtils(source)))))
+ invalidateCacheEntry(result, () => utilsCompilationResultsCache.invalidate(source.name))
+
+ result
+ }
 
  override protected def compileJavaGetterAdapters(profile: ExpressionProfile, name: String, classes: Seq[Class[_]], full: Boolean) =
  unwrapExecutionException(underLock(

scex-core/src/main/scala/com/avsystem/scex/compiler/ScexSettings.scala

@@ -54,6 +54,10 @@ class ScexSettings extends Settings {
  final val backwardsCompatCacheVersion = StringSetting("-SCEXbackwards-compat-cache-version", "versionString",
  "Additional version string for controlling invalidation of classfile cache", "0")
 
+ final val cacheUnexpectedCompilationExceptions = BooleanSetting("-SCEXcache-unexpected-compilation-exceptions",
+ "Enables the caching of unexpected exceptions (such as NPE when accessing scex_classes) thrown during the expression compilation. " +
+ "CompilationFailedExceptions are always cached, regardless of this setting. They indicate e.g. syntax errors, which should always be cached to avoid redundant compilations.", default = false)
+
  def resolvedClassfileDir: Option[PlainDirectory] = Option(classfileDirectory.value)
  .filter(_.trim.nonEmpty).map(path => new PlainDirectory(new Directory(new File(path))))
 }

scex-core/src/test/scala/com/avsystem/scex/compiler/ScexCompilationCachingTest.scala

@@ -0,0 +1,109 @@
+package com.avsystem.scex.compiler
+
+import com.avsystem.scex.ExpressionProfile
+import com.avsystem.scex.compiler.ScexCompiler.CompileError
+import com.avsystem.scex.japi.{DefaultJavaScexCompiler, JavaScexCompiler, ScalaTypeTokens}
+import com.avsystem.scex.util.{PredefinedAccessSpecs, SimpleContext}
+import com.google.common.util.concurrent.UncheckedExecutionException
+import org.scalatest.funsuite.AnyFunSuite
+
+final class ScexCompilationCachingTest extends AnyFunSuite with CompilationTest {
+
+ private var compilationCount = 0
+
+ private val settings = new ScexSettings
+ settings.classfileDirectory.value = "testClassfileCache"
+ settings.noGetterAdapters.value = true // to reduce number of compilations in tests
+
+ private val acl = PredefinedAccessSpecs.basicOperations
+ private val defaultProfile = createProfile(acl, utils = "val utilValue = 42")
+
+ private def createFailingCompiler: JavaScexCompiler =
+ new DefaultJavaScexCompiler(settings) {
+ override protected def compile(sourceFile: ScexSourceFile): Either[ScexClassLoader, List[CompileError]] = {
+ compilationCount += 1
+ if (compilationCount == 1) throw new NullPointerException()
+ else super.compile(sourceFile)
+ }
+ }
+
+ private def createCountingCompiler: JavaScexCompiler =
+ new DefaultJavaScexCompiler(settings) {
+ override protected def compile(sourceFile: ScexSourceFile): Either[ScexClassLoader, List[CompileError]] = {
+ compilationCount += 1
+ super.compile(sourceFile)
+ }
+ }
+
+ override def newProfileName(): String = "constant_name"
+
+ private def compileExpression(
+ compiler: JavaScexCompiler,
+ expression: String = s""""value"""",
+ profile: ExpressionProfile = defaultProfile,
+ ): Unit = {
+ compiler.buildExpression
+ .contextType(ScalaTypeTokens.create[SimpleContext[Unit]])
+ .resultType(classOf[String])
+ .expression(expression)
+ .template(false)
+ .profile(profile)
+ .get
+ }
+
+ test("Unexpected exceptions shouldn't be cached by default") {
+ compilationCount = 0
+ val compiler = createFailingCompiler
+
+ assertThrows[UncheckedExecutionException](compileExpression(compiler))
+ assert(compilationCount == 1) // utils compilation ended with NPE
+ compileExpression(compiler)
+ assert(compilationCount == 3) // 2x utils compilation + 1x final expression compilation
+ }
+
+ test("Unexpected exceptions should be cached when enabled using ScexSetting") {
+ compilationCount = 0
+ val compiler = createFailingCompiler
+ compiler.settings.cacheUnexpectedCompilationExceptions.value = true
+
+ assertThrows[UncheckedExecutionException](compileExpression(compiler))
+ assert(compilationCount == 1)
+ assertThrows[UncheckedExecutionException](compileExpression(compiler))
+ assert(compilationCount == 1) // result fetched from cache
+ }
+
+ test("CompilationFailedExceptions should always be cached") {
+ compilationCount = 0
+ val compiler = createCountingCompiler
+ val profile = createProfile(acl, utils = """invalidValue""")
+
+ compiler.settings.cacheUnexpectedCompilationExceptions.value = true
+ assertThrows[UncheckedExecutionException](compileExpression(compiler, profile = profile))
+ assert(compilationCount == 1)
+ assertThrows[UncheckedExecutionException](compileExpression(compiler, profile = profile))
+ assert(compilationCount == 1)
+
+ compiler.settings.cacheUnexpectedCompilationExceptions.value = false
+ assertThrows[UncheckedExecutionException](compileExpression(compiler, profile = profile))
+ assert(compilationCount == 1)
+ assertThrows[UncheckedExecutionException](compileExpression(compiler, profile = profile))
+ assert(compilationCount == 1)
+ }
+
+ test("Successful compilation should always be cached") {
+ compilationCount = 0
+ val compiler = createCountingCompiler
+
+ compiler.settings.cacheUnexpectedCompilationExceptions.value = true
+ compileExpression(compiler)
+ assert(compilationCount == 2) // utils + expression value
+ compileExpression(compiler)
+ assert(compilationCount == 2)
+
+ compiler.settings.cacheUnexpectedCompilationExceptions.value = false
+ compileExpression(compiler)
+ assert(compilationCount == 2)
+ compileExpression(compiler)
+ assert(compilationCount == 2)
+ }
+}