!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");

}