!7

sS standardCredentials() { ret ""; } // public snippets only

// (transpilation md5, snippetID) => jar file
//static new SerializeComputations<PairS, File> computations;
// transpilation md5 => jar file
static new SerializeComputations<S, File> computations;

static File compileSrcLib(S srcLibID) {
  new CompilerBot2 subBot;
  subBot.dontCompile = true;
  ret assertFileExists(subBot.compileSnippet(srcLibID));
}

static Lock lock = lock();

html {
  // lock lock; // now using SerializeComputations
  
  uri = dropPrefixSlash(uri);
  S snippetID = fsI(uri);
  if (!isSnippetPublic(snippetID)) fail("Snippet not public: " + snippetID);
  S transpiledSrc = getServerTranspiled2(snippetID);
  
  // md5 check (if parameter supplied)
  
  S md5 = params.get('md5);
  S srcMD5 = md5(transpiledSrc);
  if (md5 != null && !eq(md5, srcMD5)) ret "md5 mismatch";
  bool forceCompilation = eq(params.get("forceCompilation"), "1");
  
  File jar;
  try {
    jar = computations.get(srcMD5/*, snippetID)*/, -> {
      print("Entering compilation (forceCompilation=" + forceCompilation + ")");
      new CompilerBot2 bot;
      bot.useRenaming = !sameSnippetID(snippetID, #1001638);
      bot.forceCompilation = forceCompilation;
      bot.compileSrcLib = lambda1 compileSrcLib;
      ret bot.compileSnippet(snippetID);
    });
  } catch print e {
    // dexcompile.php can't handle code 500
    ret /*subBot_serve500*/("Error. " + e);
  }
  
  bool forceRepackage = eq("1", params.get("repackage"));
  bool withLibs = eq("1", params.get("withLibs"));
  bool noCompiler = eq("1", params.get("noCompiler"));
  bool withX30 = eq("1", params.get("withX30"));
  bool x30UtilOnly = eq("1", params.get("x30UtilOnly"));
  bool noSrc = eq("1", params.get("noSrc"));
  bool dynamicObjectOnly = eq("dynamicObjectOnly", params.get("mode"));
  bool uncompressed = eq("1", params.get("uncompressed"));
  S nameForDelivery = params.get("name");
  
  L<Map> existingFilesJSON = (L) jsonDecode(params.get("existingFiles"));
  S existingFilesComp = params.get("existingFilesComp");
  if (nempty(existingFilesComp))
    existingFilesJSON = (L) jsonDecode(gunzipToText(base64decode(existingFilesComp)));
  
  File jar2 = jar;
  if (withLibs) jar2 = appendToBaseFileName(jar2, ".with-libs"); 
  if (noCompiler) jar2 = appendToBaseFileName(jar2, ".no-compiler"); 
  if (dynamicObjectOnly) jar2 = appendToBaseFileName(jar2, ".dynamicObjectOnly"); 
  if (noSrc) jar2 = appendToBaseFileName(jar2, ".noSrc"); 
  if (uncompressed) jar2 = appendToBaseFileName(jar2, ".uncomp"); 
  
  bool withSrc = !noSrc;
      
  IPred<S> generalFileFilter = f -> 
       (withSrc || !endsWith(f, ".java"))
    && !startsWithOneOf(f, "META-INF/versions/", "META-INF/LICENSE"); // see flatlaf jar
  
  if (!eq(jar, jar2)) {
    lock lock;
  
    if (fileLength(jar2) <= 22 || forceRepackage) {
      temp var jarOut = zipOutputStream(jar2);
      new Set<S> entries;
      
      text2zip(jarOut, "source.txt",
        renderColonProperties(
          jar := f2s(jar2),
          packagingDate := dateWithSecondsUTC()));
      
      Zip2Zip_b z2z = new(jar, jarOut, entries);
      z2z.predicate = generalFileFilter;
      if (uncompressed) z2z.modifyZipEntry = e -> {
        e.setMethod(ZipOutputStream.STORED);
        e.setCompressedSize(e.getSize());
      };
      z2z.run();
      
      if (withLibs) {
        Pair<S, LS> srcAndLibs = extractLibsFromTranspilation(transpiledSrc);
        fOr (S libID : srcAndLibs.b) {
          File fixer = compilerBotDestDir("fixer" + psI(libID) + ".jar");
  
          if (fileExists(fixer)) {
            println("APPLYING FIXER: " + fixer);
            z2z.inZip = fixer;
            z2z.predicate = null;
            z2z.run();
          }
            
          z2z.inZip = loadLibraryOrSrcLib(libID, lambda1 compileSrcLib);
          z2z.run();
        }
      }
      
      z2z.inZip = pathToJavaxJar();
      
      if (withX30) {
        z2z.predicate = null;
        z2z.run();
      } else if (x30UtilOnly) {
        z2z.predicate = name -> startsWithOneOf(name, "x30_pkg");
        z2z.run();
      } else if (noCompiler) {
        z2z.predicate = name -> !
          startsWithOneOf(name, "org/eclipse/", "META-INF/", "ecj.", "about.html");
        z2z.run();
      } else if (dynamicObjectOnly) {
        z2z.predicate = name -> contains(name, "DynamicObject");
        z2z.run();
      }
    }
    
    jar = jar2;
  }
  
  if (nempty(existingFilesJSON)) {
    L<Map> newFingerprints = zipFileToJSONFingerprint_md5(jar);
    new SS map;
    for (Map m : existingFilesJSON)
      map.put((S) m.get("name"), (S) m.get("md5"));
    
    jar2 = createTempFile("partial", ".jar");
    {
      temp ZipOutputStream outJar = zipOutputStream(jar2);
      temp ZipFile jarIn = new ZipFile(jar);
      new LS toKeep;
      for (Map fp : newFingerprints) {
        S name = (S) fp.get("name");
        S oldMD5 = map.get(name);
        if (!eq(oldMD5, fp.get("md5"))) {
          outJar.putNextEntry(new ZipEntry(name));
          ZipEntry entry = jarIn.getEntry(name);
          copyStreamAndCloseInput(jarIn.getInputStream(entry), outJar);
        } else
          toKeep.add(name);
      }
      text2zip(outJar, "to-keep", lines_rtrim(toKeep));
    }
    
    jar = jar2;
  }
  
  if (forceRepackage)
    sendToSnippetUpdatesBot("/transpileOK/" + psI(snippetID));

  print("Serving jar for " + snippetID + ": " + renderFileInfo(jar));
  if (eq(params.get("makeJarOnly"), "1"))
    ret "OK: " + f2s(jar);
  else
    ret subBot_serveFileWithName(jar,
      or2(nameForDelivery, psI(snippetID) + ".jar"),
      "application/java-archive");
}

Began life as a copy of #1020140