[PLAT-33341] Add Caffeine interface to limit Sjsonnet worker cache size

build.sc

@@ -1,5 +1,5 @@
 import mill._, scalalib._, publish._, scalajslib._, scalanativelib._, scalanativelib.api._
-val sjsonnetVersion = "0.4.1"
+val sjsonnetVersion = "0.4.1-SNAPSHOT"
 
 object sjsonnet extends Cross[SjsonnetModule]("2.12.13", "2.13.4")
 class SjsonnetModule(val crossScalaVersion: String) extends Module {

sjsonnet/client/src/sjsonnet/client/Util.java

@@ -70,11 +70,11 @@ public static String readString(InputStream inputStream) throws IOException {
                 total += res;
             }
         }
-        return new String(arr);
+        return new String(arr, "UTF-8");
     }
 
     public static void writeString(OutputStream outputStream, String string) throws IOException {
-        byte[] bytes = string.getBytes();
+        byte[] bytes = string.getBytes("UTF-8");
         writeInt(outputStream, bytes.length);
         outputStream.write(bytes);
     }

sjsonnet/server/src/sjsonnet/SjsonnetServerMain.scala

@@ -24,7 +24,11 @@ trait SjsonnetServerMain[T]{
             wd: os.Path): (Boolean, Option[T])
 }
 
-object SjsonnetServerMain extends SjsonnetServerMain[collection.mutable.HashMap[(Path, String), Either[String, (Expr, FileScope)]]]{
+//  [Ask] SjsonnetServerMain has a valid main method (args0: Array[String]): Unit,
+//  [warn]   but sjsonnet.SjsonnetServerMain will not have an entry point on the JVM.
+//  [warn]   Reason: companion is a trait, which means no static forwarder can be generated.
+//  [warn] object SjsonnetServerMain extends SjsonnetServerMain[DefaultParseCache]{
+object SjsonnetServerMain extends SjsonnetServerMain[DefaultParseCache]{
   def main(args0: Array[String]): Unit = {
     // Disable SIGINT interrupt signal in the Mill server.
     //
@@ -45,7 +49,7 @@ object SjsonnetServerMain extends SjsonnetServerMain[collection.mutable.HashMap[
     ).run()
   }
   def main0(args: Array[String],
-            stateCache: Option[collection.mutable.HashMap[(Path, String), Either[String, (Expr, FileScope)]]],
+            stateCache: Option[DefaultParseCache],
             mainInteractive: Boolean,
             stdin: InputStream,
             stdout: PrintStream,
@@ -55,7 +59,7 @@ object SjsonnetServerMain extends SjsonnetServerMain[collection.mutable.HashMap[
             wd: os.Path) = {
 
     val stateCache2 = stateCache.getOrElse{
-      val p = collection.mutable.HashMap[(Path, String), Either[String, (Expr, FileScope)]]()
+      val p = new DefaultParseCache
       this.stateCache = Some(p)
       p
     }

sjsonnet/src-js/sjsonnet/SjsonnetMain.scala

@@ -6,7 +6,7 @@ import scala.scalajs.js.annotation.{JSExport, JSExportTopLevel}
 
 @JSExportTopLevel("SjsonnetMain")
 object SjsonnetMain {
-  def createParseCache() = collection.mutable.HashMap[(Path, String), Either[String, (Expr, FileScope)]]()
+  def createParseCache() = new DefaultParseCache
   @JSExport
   def interpret(text: String,
                 extVars: js.Any,
@@ -28,8 +28,8 @@ object SjsonnetMain {
         def read(path: Path): Option[String] =
           Option(importLoader(path.asInstanceOf[JsVirtualPath].path))
       },
-      preserveOrder,
-      parseCache = createParseCache()
+      parseCache = createParseCache(),
+      preserveOrder
     )
     interp.interpret0(text, JsVirtualPath("(memory)"), ujson.WebJson.Builder) match{
       case Left(msg) => throw new js.JavaScriptException(msg)

sjsonnet/src-jvm-native/sjsonnet/SjsonnetMain.scala

@@ -8,7 +8,7 @@ import scala.util.Try
 import scala.util.control.NonFatal
 
 object SjsonnetMain {
-  def createParseCache() = collection.mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]]()
+  def createParseCache() = new DefaultParseCache
 
   def resolveImport(searchRoots0: Seq[Path], allowedInputs: Option[Set[os.Path]] = None) = new Importer {
     def resolve(docBase: Path, importName: String): Option[Path] =
@@ -33,7 +33,7 @@ object SjsonnetMain {
         case Array(s, _*) if s == "-i" || s == "--interactive" => args.tail
         case _ => args
       },
-      collection.mutable.HashMap.empty,
+      new DefaultParseCache,
       System.in,
       System.out,
       System.err,
@@ -44,7 +44,7 @@ object SjsonnetMain {
   }
 
   def main0(args: Array[String],
-            parseCache: collection.mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]],
+            parseCache: ParseCache,
             stdin: InputStream,
             stdout: PrintStream,
             stderr: PrintStream,
@@ -127,7 +127,7 @@ object SjsonnetMain {
 
   def mainConfigured(file: String,
                      config: Config,
-                     parseCache: collection.mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]],
+                     parseCache: ParseCache,
                      wd: os.Path,
                      allowedInputs: Option[Set[os.Path]] = None,
                      importer: Option[(Path, String) => Option[os.Path]] = None): Either[String, String] = {
@@ -182,10 +182,10 @@ object SjsonnetMain {
         }
         case None => resolveImport(config.jpaths.map(os.Path(_, wd)).map(OsPath(_)), allowedInputs)
       },
+      parseCache,
       preserveOrder = config.preserveOrder.value,
       strict = config.strict.value,
-      storePos = if (config.yamlDebug.value) currentPos = _ else null,
-      parseCache
+      storePos = if (config.yamlDebug.value) currentPos = _ else null
     )
 
     (config.multi, config.yamlStream.value) match {

sjsonnet/src/sjsonnet/Importer.scala

@@ -43,8 +43,8 @@ class CachedImporter(parent: Importer) extends Importer {
 
 class CachedResolver(
   parentImporter: Importer,
-  val parseCache: mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]] = new mutable.HashMap
-) extends CachedImporter(parentImporter) {
+  val parseCache: ParseCache
+                    ) extends CachedImporter(parentImporter) {
 
   def parse(path: Path, txt: String)(implicit ev: EvalErrorScope): Either[Error, (Expr, FileScope)] = {
     parseCache.getOrElseUpdate((path, txt), {

sjsonnet/src/sjsonnet/Interpreter.scala

@@ -15,11 +15,11 @@ class Interpreter(extVars: Map[String, ujson.Value],
                   tlaVars: Map[String, ujson.Value],
                   wd: Path,
                   importer: Importer,
+                  val parseCache: ParseCache,
                   preserveOrder: Boolean = false,
                   strict: Boolean = false,
-                  storePos: Position => Unit = null,
-                  val parseCache: mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]] = new mutable.HashMap,
-                  ) { self =>
+                  storePos: Position => Unit = null
+                 ) { self =>
 
   val resolver = new CachedResolver(importer, parseCache) {
     override def process(expr: Expr, fs: FileScope): Either[Error, (Expr, FileScope)] =

sjsonnet/src/sjsonnet/ParseCache.scala

@@ -0,0 +1,15 @@
+package sjsonnet
+
+// Trait extended by JsonnetWorker (in universe) so that it can pass the cache based on Caffeine to main0 here
+trait ParseCache {
+  def getOrElseUpdate(key: (Path, String), defaultValue:  => Either[Error, (Expr, FileScope)]): Either[Error, (Expr, FileScope)]
+}
+
+// A default implementation based on a mutable HashMap. This implementation is not thread-safe.
+class DefaultParseCache extends ParseCache {
+  val cache = new collection.mutable.HashMap[(Path, String), Either[Error, (Expr, FileScope)]]()
+
+  override def getOrElseUpdate(key: (Path, String), defaultValue:  => Either[Error, (Expr, FileScope)]): Either[Error, (Expr, FileScope)] = {
+    cache.getOrElseUpdate(key, defaultValue)
+  }
+}

sjsonnet/test/src-jvm-native/sjsonnet/ErrorTests.scala

@@ -10,6 +10,7 @@ object ErrorTests extends TestSuite{
       Map(),
       OsPath(os.pwd),
       importer = sjsonnet.SjsonnetMain.resolveImport(Array.empty[Path]),
+      parseCache = new DefaultParseCache
     )
     interp.interpret(os.read(p), OsPath(p))
   }

sjsonnet/test/src-jvm-native/sjsonnet/FileTests.scala

@@ -10,6 +10,7 @@ object FileTests extends TestSuite{
       Map("var1" -> "test", "var2" -> ujson.Obj("x" -> 1, "y" -> 2)),
       OsPath(testSuiteRoot),
       importer = sjsonnet.SjsonnetMain.resolveImport(Array(OsPath(testSuiteRoot))),
+      parseCache = new DefaultParseCache
     )
     interp.interpret(os.read(p), OsPath(p))
   }

sjsonnet/test/src-jvm-native/sjsonnet/MainTests.scala

@@ -16,9 +16,9 @@ object MainTests extends TestSuite {
       val outF = File.createTempFile("sjsonnet", ".json")
       val out = new ByteArrayOutputStream()
       val pout = new PrintStream(out)
-      SjsonnetMain.main0(Array(source), collection.mutable.HashMap.empty, System.in, pout, System.err, os.pwd, None)
+      SjsonnetMain.main0(Array(source), new DefaultParseCache, System.in, pout, System.err, os.pwd, None)
       pout.flush()
-      SjsonnetMain.main0(Array("-o", outF.getAbsolutePath, source), collection.mutable.HashMap.empty, System.in, System.out, System.err, os.pwd, None)
+      SjsonnetMain.main0(Array("-o", outF.getAbsolutePath, source), new DefaultParseCache, System.in, System.out, System.err, os.pwd, None)
       val stdoutBytes = out.toByteArray
       val fileBytes = os.read(os.Path(outF)).getBytes
       // stdout mode uses println so it has an extra platform-specific line separator at the end

sjsonnet/test/src-jvm-native/sjsonnet/PrettyYamlRendererTests.scala

@@ -11,6 +11,7 @@ object PrettyYamlRendererTests extends TestSuite{
       Map(),
       OsPath(testSuiteRoot),
       importer = sjsonnet.SjsonnetMain.resolveImport(Array(OsPath(testSuiteRoot))),
+      parseCache = new DefaultParseCache,
       storePos = if (comments) currentPos = _ else null
     )
     val res = interp.interpret0(

sjsonnet/test/src-jvm/sjsonnet/ErrorTestsJvmOnly.scala

@@ -10,6 +10,7 @@ object ErrorTestsJvmOnly extends TestSuite {
       Map(),
       OsPath(os.pwd),
       importer = sjsonnet.SjsonnetMain.resolveImport(Array.empty[Path]),
+      parseCache = new DefaultParseCache
     )
     interp.interpret(os.read(p), OsPath(p))
   }

sjsonnet/test/src/sjsonnet/TestUtils.scala

@@ -7,6 +7,7 @@ object TestUtils {
       Map(),
       DummyPath(),
       Importer.empty,
+      parseCache = new DefaultParseCache,
       preserveOrder = preserveOrder,
       strict = strict
     ).interpret(s, DummyPath("(memory)")) match {