Migrate launcher into separate chatoverflow-launcher repository

Author: hlxid

.gitignore

@@ -0,0 +1 @@
+target/

bootstrap/build.sbt

@@ -0,0 +1,27 @@
+name := "chatoverflow-launcher-bootstrap"
+// s"$version-$versionSuffix" has to represent the tag name of the current release inorder for the Updater to know the current version.
+version := "0.3"
+lazy val versionSuffix = "prealpha"
+assemblyJarName in assembly := "ChatOverflow-Launcher.jar"
+
+// Coursier is used to download the deps of the framework
+// Excluding argonaut and it's dependencies because we don't use any json with Coursier and that way we are able
+// to reduce the assembly jar file size from about 17MB (way too big) to only 8,8 MB, which is acceptable.
+libraryDependencies += "io.get-coursier" %% "coursier" % "2.0.0-RC3-2" excludeAll(
+  ExclusionRule(organization = "org.scala-lang", name = "scala-reflect"),
+  ExclusionRule(organization = "io.argonaut", name = "argonaut_2.12"),
+  ExclusionRule(organization = "com.chuusai", name = "shapeless_2.12"),
+  ExclusionRule(organization = "com.github.alexarchambault", name = "argonaut-shapeless_6.2_2.12")
+)
+
+// Command Line Parsing
+libraryDependencies += "com.github.scopt" %% "scopt" % "3.5.0"
+
+fork := true
+
+packageBin / includePom := false
+
+Compile / compile := {
+  IO.write((Compile / classDirectory).value / "version.txt", version.value + "-" + versionSuffix)
+  (Compile / compile).value
+}

bootstrap/src/main/scala/Bootstrap.scala

@@ -0,0 +1,117 @@
+import java.io.File
+
+import CLI._
+
+/**
+  * The bootstrap launcher downloads all required libraries and starts chat overflow with the correct parameters.
+  */
+object Bootstrap {
+
+  // Java home path (jre installation folder)
+  private val javaHomePath: String = System.getProperty("java.home")
+
+  // Chat Overflow Launcher / Main class (should not change anymore)
+  private val chatOverflowMainClass = "org.codeoverflow.chatoverflow.Launcher"
+
+  /**
+   * Launcher entry point.
+   * Validates installation, downloads dependencies and start ChatOverflow.
+   *
+   * @param args the arguments, which are passed to ChatOverflow
+   */
+  def main(args: Array[String]): Unit = {
+    val conf: Config = ArgsParser.parse(args, Config()) match {
+      case Some(value) => value
+      case None => System.exit(1); null
+    }
+
+    if (testValidity(conf.directory)) {
+      println("Valid ChatOverflow installation. Checking libraries...")
+
+      val deps = new DependencyDownloader(conf.directory).fetchDependencies().map(u => new File(u.getFile))
+      if (deps.nonEmpty) {
+        val javaPath = createJavaPath()
+        if (javaPath.isDefined) {
+          println("Found java installation. Starting ChatOverflow...")
+
+          // Start chat overflow!
+          val command = List(javaPath.get, "-cp", s"bin/*${deps.mkString(File.pathSeparator, File.pathSeparator, "")}", chatOverflowMainClass) ++ args
+          val processBuilder = new java.lang.ProcessBuilder(command: _*)
+            .inheritIO().directory(new File(conf.directory))
+
+          processBuilder.environment().put("CHATOVERFLOW_BOOTSTRAP", "true")
+
+          val process = processBuilder.start()
+
+          val exitCode = process.waitFor()
+          println(s"ChatOverflow stopped with exit code: $exitCode")
+        } else {
+          println("Unable to find java installation. Unable to start.")
+        }
+      } else {
+        println("Error: Problem with libraries. Unable to start.")
+      }
+    } else {
+      println("Error: Invalid ChatOverflow installation. Please extract all provided files properly. Unable to start.")
+    }
+  }
+
+  /**
+    * Takes the java home path of the launcher and tries to find the java(.exe)
+    *
+    * @return the path to the java runtime or none, if the file was not found
+    */
+  private def createJavaPath(): Option[String] = {
+
+    // Check validity of java.home path first
+    if (!new File(javaHomePath).exists()) {
+      None
+    } else {
+
+      // Check for windows and unix java versions
+      // This should work on current and older java JRE/JDK installations,
+      // see: https://stackoverflow.com/questions/52584888/how-to-use-jdk-without-jre-in-java-11
+      val javaExePath = s"$javaHomePath/bin/java.exe"
+      val javaPath = s"$javaHomePath/bin/java"
+
+      if (new File(javaExePath).exists()) {
+        Some(javaExePath)
+      } else if (new File(javaPath).exists()) {
+        Some(javaPath)
+      } else {
+        None
+      }
+    }
+
+  }
+
+  /**
+    * Checks, if the installation is valid
+    */
+  private def testValidity(currentFolderPath: String): Boolean = {
+    // The first check is the existence of a bin folder
+    val binDir = new File(s"$currentFolderPath/bin")
+    check(binDir.exists() && binDir.isDirectory, "The bin directory doesn't exist") && {
+      // Next are the existence of a framework, api and gui jar
+      val jars = binDir.listFiles().filter(_.getName.endsWith(".jar"))
+
+      check(jars.exists(_.getName.toLowerCase.startsWith("chatoverflow_")), "There is no api jar in the bin directory.") &&
+        check(jars.exists(_.getName.toLowerCase.startsWith("chatoverflow-api")), "There is no api jar in the bin directory.") &&
+        check(jars.exists(_.getName.toLowerCase.startsWith("chatoverflow-gui")),
+          "Note: No gui jar detected. The ChatOverflow gui won't be usable.", required = false)
+    }
+  }
+
+  /**
+   * Helper method for [[Bootstrap.testValidity()]]. Checks condition, prints description if the condition is false and
+   * returns false if the condition is false and the check is required.
+   */
+  private def check(condition: Boolean, description: String, required: Boolean = true): Boolean = {
+    if (condition) {
+      true
+    } else {
+      println(description)
+      !required
+    }
+  }
+}

bootstrap/src/main/scala/CLI.scala

@@ -0,0 +1,35 @@
+import java.io.File
+import java.nio.file.Paths
+
+
+object CLI {
+
+  /**
+   * Everything in here also has to be defined in the CLI class of the framework, because
+   * all arguments including bootstrap specific ones are passed through to the framework.
+   * Filtering these options out would be way too difficult, because you need to know if a option
+   * is a simple flag or is followed by a value. Scopt doesn't expose anything to get this so we would
+   * need to use reflect, which is very ugly.
+   * This, while not that elegant as I would like it to be, is just simple and works.
+   */
+  object ArgsParser extends scopt.OptionParser[Config]("ChatOverflow Launcher") {
+    opt[File]("directory")
+      .action((x, c) => c.copy(directory = x.getAbsolutePath))
+      .text("The directory in which ChatOverflow will be executed")
+      .validate(f =>
+        if (!f.exists())
+          Left("Directory doesn't exist")
+        else if (!f.isDirectory)
+          Left("Path isn't a directory")
+        else
+          Right()
+      )
+
+    override def errorOnUnknownArgument: Boolean = false
+
+    override def reportWarning(msg: String): Unit = ()
+  }
+
+  case class Config(directory: String = Paths.get("").toAbsolutePath.toString)
+
+}

bootstrap/src/main/scala/DependencyDownloader.scala

@@ -0,0 +1,70 @@
+import java.io.{File, InputStream}
+import java.net.{URL, URLClassLoader}
+
+import coursier.Fetch
+import coursier.cache.FileCache
+import coursier.cache.loggers.{FileTypeRefreshDisplay, RefreshLogger}
+import coursier.core.{Configuration, Dependency}
+import coursier.maven.{MavenRepository, PomParser}
+
+import scala.io.Source
+
+class DependencyDownloader(directory: String) {
+  private val pomFile = "dependencies.pom"
+  private val logger = RefreshLogger.create(System.out, FileTypeRefreshDisplay.create())
+  private val cache = FileCache().noCredentials.withLogger(logger)
+
+  // Classloader containing all jars, used to get the dependencies from the framework jar
+  private val jarFiles = {
+    val jarsOpt = Option(new File(s"$directory/bin").listFiles())
+    jarsOpt.getOrElse(Array()).filter(_.getName.endsWith(".jar")).map(_.toURI.toURL)
+  }
+  private val classloader = new URLClassLoader(jarFiles)
+
+  private def getPomIs: InputStream = classloader.getResourceAsStream(pomFile)
+
+  /**
+   * Parses the pom file of the framework jar and returns a seq of all dependencies that are required to run it.
+   *
+   * @return the seq of dependencies, if it is empty an error has occurred and logged.
+   */
+  private def parsePom(): Seq[Dependency] = {
+    if (getPomIs == null) {
+      println("Couldn't find the pom containing all required dependencies for the framework in the jar.")
+      return Seq()
+    }
+
+    val pomFile = Source.fromInputStream(getPomIs)
+    val parser = coursier.core.compatibility.xmlParseSax(pomFile.mkString, new PomParser)
+    parser.project match {
+      case Right(deps) =>
+        deps.dependencies
+          .filterNot(_._1 == Configuration.provided) // Provided deps are... well provided and no download is required
+          .map(_._2)
+          .filter(_.module.name.value != "chatoverflow-api") // We already have the api locally inside the bin directory
+      case Left(errorMsg) =>
+        println(s"Pom containing all required dependencies for the framework couldn't be parsed: $errorMsg")
+        Seq()
+    }
+  }
+
+  /**
+   * Fetches all required dependencies for the framework using Coursier.
+   *
+   * @return a seq of urls of jar files that need to be included to the classpath. A empty seq signifies an error.
+   */
+  def fetchDependencies(): Seq[URL] = {
+    val deps = parsePom()
+    if (deps.isEmpty)
+      return Seq()
+
+    // IntelliJ may warn you that a implicit is missing. This is one of the many bugs in IntelliJ, the code compiles fine.
+    val jars: Seq[File] = Fetch()
+      .withCache(cache)
+      .addDependencies(deps: _*)
+      .addRepositories(MavenRepository("https://jcenter.bintray.com")) // JCenter is used for JDA (DiscordConnector)
+      .run
+
+    jars.map(_.toURI.toURL)
+  }
+}

build.sbt

@@ -0,0 +1,7 @@
+name := "chatoverflow-launcher"
+
+lazy val launcherBootstrapProject = project in file("bootstrap")
+lazy val launcherUpdaterProject = project in file("updater")
+
+lazy val launcherProject = (project in file("."))
+  .aggregate(launcherBootstrapProject, launcherUpdaterProject)

deployment-files/end-user/ChatOverflow.bat

@@ -0,0 +1,3 @@
+@ECHO OFF
+
+java -jar ChatOverflow.jar %*

deployment-files/end-user/ChatOverflow.command

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+called_path=${0%/*}
+cd $called_path
+java -jar ChatOverflow.jar "$@"

deployment-files/end-user/ChatOverflow.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+java -jar ChatOverflow.jar "$@"