From db17b5a46290d310ddbf5a907fe2a1bf5261aa48 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 25 Nov 2021 21:32:44 -0500 Subject: [PATCH 01/10] lm-coursier 2.0.9 https://github.com/coursier/sbt-coursier/releases/tag/v2.0.9 https://github.com/coursier/coursier/releases/tag/v2.1.0-M1 --- project/Dependencies.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index aa9948bfc..a9451c2ab 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -77,7 +77,7 @@ object Dependencies { def addSbtZincCompile = addSbtModule(sbtZincPath, "zincCompileJVM2_12", zincCompile) def addSbtZincCompileCore = addSbtModule(sbtZincPath, "zincCompileCoreJVM2_12", zincCompileCore) - val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % "2.0.8" + val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % "2.0.9" def sjsonNew(n: String) = Def.setting("com.eed3si9n" %% n % "0.9.1") // contrabandSjsonNewVersion.value From a448b1caab5b028923c1390ab6cf23a1824d95dc Mon Sep 17 00:00:00 2001 From: David Francoeur Date: Sat, 27 Nov 2021 02:44:49 -0500 Subject: [PATCH 02/10] Load credentials from SBT_CREDENTIALS (#6724) Load credentials from SBT_CREDENTIALS Prefer sys.env to System.getenv --- .../main/scala/sbt/internal/util/Util.scala | 4 +-- .../scala/sbt/internal/util/Terminal.scala | 32 +++++++++---------- .../sbt/internal/client/NetworkClient.scala | 2 +- main/src/main/scala/sbt/Defaults.scala | 3 +- .../src/main/scala/sbt/internal/SysProp.scala | 6 +++- .../internal/bsp/BuildServerConnection.scala | 2 +- .../run/fork/src/main/scala/ForkFail.scala | 2 +- .../sbt-test/tests/fork2/changes/Test.scala | 2 +- 8 files changed, 28 insertions(+), 25 deletions(-) diff --git a/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala b/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala index 8ec3636a6..ca03ed381 100644 --- a/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala +++ b/internal/util-collection/src/main/scala/sbt/internal/util/Util.scala @@ -54,7 +54,7 @@ object Util { System.getProperty("os.name").toLowerCase(Locale.ENGLISH).contains("windows") lazy val isCygwin: Boolean = { - val os = Option(System.getenv("OSTYPE")) + val os = sys.env.get("OSTYPE") os match { case Some(x) => x.toLowerCase(Locale.ENGLISH).contains("cygwin") case _ => false @@ -64,7 +64,7 @@ object Util { lazy val isNonCygwinWindows: Boolean = isWindows && !isCygwin lazy val isCygwinWindows: Boolean = isWindows && isCygwin - lazy val isEmacs: Boolean = Option(System.getenv("INSIDE_EMACS")).isDefined + lazy val isEmacs: Boolean = sys.env.contains("INSIDE_EMACS") def nil[A]: List[A] = List.empty[A] def nilSeq[A]: Seq[A] = Seq.empty[A] diff --git a/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala index 7fecdf0e5..9fa61c02e 100644 --- a/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala +++ b/internal/util-logging/src/main/scala/sbt/internal/util/Terminal.scala @@ -308,7 +308,7 @@ object Terminal { } private[sbt] lazy val isAnsiSupported: Boolean = logFormatEnabled.getOrElse(useColorDefault) - private[this] val isDumb = "dumb" == System.getenv("TERM") + private[this] val isDumb = Some("dumb") == sys.env.get("TERM") private[this] def isDumbTerminal = isDumb || System.getProperty("jline.terminal", "") == "none" private[this] val hasConsole = Option(java.lang.System.console).isDefined private[this] def useColorDefault: Boolean = { @@ -736,22 +736,20 @@ object Terminal { val supershell: Boolean ) private[sbt] val TERMINAL_PROPS = "SBT_TERMINAL_PROPS" - private val props = System.getenv(TERMINAL_PROPS) match { - case null => None - case p => - p.split(",") match { - case Array(width, height, ansi, color, supershell) => - Try( - new Props( - width.toInt, - height.toInt, - ansi.toBoolean, - color.toBoolean, - supershell.toBoolean - ) - ).toOption - case _ => None - } + private val props = sys.env.get(TERMINAL_PROPS) flatMap { p => + p.split(",") match { + case Array(width, height, ansi, color, supershell) => + Try( + new Props( + width.toInt, + height.toInt, + ansi.toBoolean, + color.toBoolean, + supershell.toBoolean + ) + ).toOption + case _ => None + } } private[sbt] def startedByRemoteClient = props.isDefined diff --git a/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala index 8141376ac..71a11e6fd 100644 --- a/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala +++ b/main-command/src/main/scala/sbt/internal/client/NetworkClient.scala @@ -139,7 +139,7 @@ class NetworkClient( private val rebooting = new AtomicBoolean(false) private lazy val noTab = arguments.completionArguments.contains("--no-tab") private lazy val noStdErr = arguments.completionArguments.contains("--no-stderr") && - System.getenv("SBTC_AUTO_COMPLETE") == null + !sys.env.contains("SBTC_AUTO_COMPLETE") private def mkSocket(file: File): (Socket, Option[String]) = ClientSocket.socket(file, useJNI) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index ec25047a0..facf6637a 100644 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -148,6 +148,7 @@ object Defaults extends BuildCommon { val m = (for (a <- cp; an <- a.metadata get Keys.analysis) yield (a.data, an)).toMap m.get _ } + private[sbt] def globalDefaults(ss: Seq[Setting[_]]): Seq[Setting[_]] = Def.defaultSettings(inScope(GlobalScope)(ss)) @@ -229,7 +230,7 @@ object Defaults extends BuildCommon { private[sbt] lazy val globalIvyCore: Seq[Setting[_]] = Seq( internalConfigurationMap :== Configurations.internalMap _, - credentials :== Nil, + credentials :== SysProp.sbtCredentialsEnv.toList, exportJars :== false, trackInternalDependencies :== TrackLevel.TrackAlways, exportToInternal :== TrackLevel.TrackAlways, diff --git a/main/src/main/scala/sbt/internal/SysProp.scala b/main/src/main/scala/sbt/internal/SysProp.scala index c761e7f04..fbf0942b2 100644 --- a/main/src/main/scala/sbt/internal/SysProp.scala +++ b/main/src/main/scala/sbt/internal/SysProp.scala @@ -15,8 +15,9 @@ import scala.util.control.NonFatal import scala.concurrent.duration._ import sbt.internal.util.{ Terminal => ITerminal, Util } import sbt.internal.util.complete.SizeParser -import sbt.nio.Keys._ import sbt.io.syntax._ +import sbt.librarymanagement.ivy.{ Credentials, FileCredentials } +import sbt.nio.Keys._ // See also BuildPaths.scala // See also LineReader.scala @@ -216,4 +217,7 @@ object SysProp { .getOrElse(linuxCache) baseCache.getAbsoluteFile / "v1" } + + val sbtCredentialsEnv: Option[Credentials] = + sys.env.get("SBT_CREDENTIALS").map(raw => new FileCredentials(new File(raw))) } diff --git a/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala index dc99a4973..66ac7bdf0 100644 --- a/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala +++ b/protocol/src/main/scala/sbt/internal/bsp/BuildServerConnection.scala @@ -61,7 +61,7 @@ object BuildServerConnection { // For those who use an old sbt script, the -Dsbt.script is not set // As a fallback we try to find the sbt script in $PATH val fileName = if (Properties.isWin) "sbt.bat" else "sbt" - val envPath = Option(System.getenv("PATH")).getOrElse("") + val envPath = sys.env.getOrElse("PATH", "") val allPaths = envPath.split(File.pathSeparator).map(Paths.get(_)) allPaths .map(_.resolve(fileName)) diff --git a/sbt-app/src/sbt-test/run/fork/src/main/scala/ForkFail.scala b/sbt-app/src/sbt-test/run/fork/src/main/scala/ForkFail.scala index 847230c81..a1d489232 100644 --- a/sbt-app/src/sbt-test/run/fork/src/main/scala/ForkFail.scala +++ b/sbt-app/src/sbt-test/run/fork/src/main/scala/ForkFail.scala @@ -1,6 +1,6 @@ object ForkTest { def main(args:Array[String]): Unit = { - val name = Option(System.getenv("flag.name")) getOrElse("flag") + val name = sys.env.getOrElse("flag.name", "flag") println("Name: " + name) val cwd = (new java.io.File(name)).getAbsoluteFile cwd.getParentFile.mkdirs() diff --git a/sbt-app/src/sbt-test/tests/fork2/changes/Test.scala b/sbt-app/src/sbt-test/tests/fork2/changes/Test.scala index 6706da71f..f2d45c34f 100644 --- a/sbt-app/src/sbt-test/tests/fork2/changes/Test.scala +++ b/sbt-app/src/sbt-test/tests/fork2/changes/Test.scala @@ -1,7 +1,7 @@ import org.scalatest.FlatSpec class Test extends FlatSpec { - val v = Option(System.getenv("tests.max.value")) getOrElse Int.MaxValue + val v = sys.env.getOrElse("tests.max.value", Int.MaxValue) "A simple equation" should "hold" in { assert(Int.MaxValue == v) } From 7d429c6724dbb4a0c8be3c43910f5e9d98e224b7 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 27 Nov 2021 20:17:26 -0500 Subject: [PATCH 03/10] --no-server mode Fixes #6530 Ref #6101 Problem ------- Although having sbt server up by default is beneficial to well-tested platforms like macOS, on less tested setups various native and/or native-adjacent techniques we use could end up causing instability. Solution -------- This adds `--no-server` as a quick way of telling sbt not to start up the sbt server or create virtual terminal. --- launcher-package/src/universal/bin/sbt.bat | 14 ++++++++++++++ sbt | 2 ++ 2 files changed, 16 insertions(+) diff --git a/launcher-package/src/universal/bin/sbt.bat b/launcher-package/src/universal/bin/sbt.bat index fb325c19a..f44af2219 100755 --- a/launcher-package/src/universal/bin/sbt.bat +++ b/launcher-package/src/universal/bin/sbt.bat @@ -50,6 +50,7 @@ set sbt_args_sbt_dir= set sbt_args_sbt_version= set sbt_args_mem= set sbt_args_client= +set sbt_args_no_server= rem users can set SBT_OPTS via .sbtopts if exist .sbtopts for /F %%A in (.sbtopts) do ( @@ -205,6 +206,15 @@ if defined _no_colors_arg ( goto args_loop ) +if "%~0" == "-no-server" set _no_server_arg=true +if "%~0" == "--no-server" set _no_server_arg=true + +if defined _no_server_arg ( + set _no_server_arg= + set sbt_args_no_server=1 + goto args_loop +) + if "%~0" == "-no-global" set _no_global_arg=true if "%~0" == "--no-global" set _no_global_arg=true @@ -646,6 +656,10 @@ if defined sbt_args_traces ( set _SBT_OPTS=-Dsbt.traces=true !_SBT_OPTS! ) +if defined sbt_args_no_server ( + set _SBT_OPTS=-Dsbt.io.virtual=false -Dsbt.server.autostart=false !_SBT_OPTS! +) + rem TODO: _SBT_OPTS needs to be processed as args and diffed against SBT_ARGS if !sbt_args_print_sbt_version! equ 1 ( diff --git a/sbt b/sbt index c14c2ec32..39b1dac32 100755 --- a/sbt +++ b/sbt @@ -22,6 +22,7 @@ declare sbt_verbose= declare sbt_debug= declare build_props_sbt_version= declare use_sbtn= +declare no_server= declare sbtn_command="$SBTN_CMD" declare sbtn_version="1.4.7" @@ -631,6 +632,7 @@ map_args () { -traces|--traces) options=( "${options[@]}" "-Dsbt.traces=true" ) && shift ;; --supershell=*) options=( "${options[@]}" "-Dsbt.supershell=${1:13}" ) && shift ;; -supershell=*) options=( "${options[@]}" "-Dsbt.supershell=${1:12}" ) && shift ;; + -no-server|--no-server) options=( "${options[@]}" "-Dsbt.io.virtual=false" "-Dsbt.server.autostart=false" ) && shift ;; --color=*) options=( "${options[@]}" "-Dsbt.color=${1:8}" ) && shift ;; -color=*) options=( "${options[@]}" "-Dsbt.color=${1:7}" ) && shift ;; -no-share|--no-share) options=( "${options[@]}" "${noshare_opts[@]}" ) && shift ;; From f11a25a9c98023e38a76f0be2777a2b3f57699c3 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 27 Nov 2021 21:19:38 -0500 Subject: [PATCH 04/10] Add test --- .../src/test/scala/ScriptTest.scala | 85 ++++++++++++------- 1 file changed, 56 insertions(+), 29 deletions(-) diff --git a/launcher-package/integration-test/src/test/scala/ScriptTest.scala b/launcher-package/integration-test/src/test/scala/ScriptTest.scala index 570f0b0dd..e1fe01b5f 100644 --- a/launcher-package/integration-test/src/test/scala/ScriptTest.scala +++ b/launcher-package/integration-test/src/test/scala/ScriptTest.scala @@ -4,7 +4,8 @@ import minitest._ import java.io.File object SbtScriptTest extends SimpleTestSuite with PowerAssertions { - lazy val isWindows: Boolean = sys.props("os.name").toLowerCase(java.util.Locale.ENGLISH).contains("windows") + lazy val isWindows: Boolean = + sys.props("os.name").toLowerCase(java.util.Locale.ENGLISH).contains("windows") lazy val sbtScript = if (isWindows) new File("target/universal/stage/bin/sbt.bat") else new File("target/universal/stage/bin/sbt") @@ -12,12 +13,13 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { private val javaBinDir = new File("integration-test", "bin").getAbsolutePath private def makeTest( - name: String, - javaOpts: String = "", - sbtOpts: String = "", + name: String, + javaOpts: String = "", + sbtOpts: String = "", )(args: String*)(f: List[String] => Any) = { test(name) { - val out = sbtProcessWithOpts(args: _*)(javaOpts = javaOpts, sbtOpts = sbtOpts).!!.linesIterator.toList + val out = + sbtProcessWithOpts(args: _*)(javaOpts = javaOpts, sbtOpts = sbtOpts).!!.linesIterator.toList f(out) () } @@ -26,12 +28,14 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { def sbtProcess(args: String*) = sbtProcessWithOpts(args: _*)("", "") def sbtProcessWithOpts(args: String*)(javaOpts: String, sbtOpts: String) = { val path = sys.env("PATH") - sbt.internal.Process(Seq(sbtScript.getAbsolutePath) ++ args, new File("citest"), + sbt.internal.Process( + Seq(sbtScript.getAbsolutePath) ++ args, + new File("citest"), "JAVA_OPTS" -> javaOpts, "SBT_OPTS" -> sbtOpts, if (isWindows) "JAVACMD" -> new File(javaBinDir, "java.cmd").getAbsolutePath() - else + else "PATH" -> (javaBinDir + File.pathSeparator + path) ) } @@ -48,9 +52,14 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { assert(out.contains[String]("-Dsbt.color=false")) } - makeTest("sbt --no-colors in SBT_OPTS", sbtOpts = "--no-colors")("compile", "-v") { out: List[String] => - if (isWindows) cancel("Test not supported on windows") - assert(out.contains[String]("-Dsbt.log.noformat=true")) + makeTest("sbt --no-colors in SBT_OPTS", sbtOpts = "--no-colors")("compile", "-v") { + out: List[String] => + if (isWindows) cancel("Test not supported on windows") + assert(out.contains[String]("-Dsbt.log.noformat=true")) + } + + makeTest("sbt --no-server")("compile", "--no-server", "-v") { out: List[String] => + assert(out.contains[String]("-Dsbt.server.autostart=false")) } makeTest("sbt --debug-inc")("compile", "--debug-inc", "-v") { out: List[String] => @@ -77,33 +86,43 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { assert(out.contains[String]("-Xmx503m")) } - makeTest("sbt with -mem 503, -Xmx in JAVA_OPTS", javaOpts = "-Xmx1024m")("-mem", "503", "-v") { out: List[String] => - assert(out.contains[String]("-Xmx503m")) - assert(!out.contains[String]("-Xmx1024m")) + makeTest("sbt with -mem 503, -Xmx in JAVA_OPTS", javaOpts = "-Xmx1024m")("-mem", "503", "-v") { + out: List[String] => + assert(out.contains[String]("-Xmx503m")) + assert(!out.contains[String]("-Xmx1024m")) } - makeTest("sbt with -mem 503, -Xmx in SBT_OPTS", sbtOpts = "-Xmx1024m")("-mem", "503", "-v") { out: List[String] => - assert(out.contains[String]("-Xmx503m")) - assert(!out.contains[String]("-Xmx1024m")) + makeTest("sbt with -mem 503, -Xmx in SBT_OPTS", sbtOpts = "-Xmx1024m")("-mem", "503", "-v") { + out: List[String] => + assert(out.contains[String]("-Xmx503m")) + assert(!out.contains[String]("-Xmx1024m")) } - makeTest("sbt with -mem 503, -Xss in JAVA_OPTS", javaOpts = "-Xss6m")("-mem", "503", "-v") { out: List[String] => - assert(out.contains[String]("-Xmx503m")) - assert(!out.contains[String]("-Xss6m")) + makeTest("sbt with -mem 503, -Xss in JAVA_OPTS", javaOpts = "-Xss6m")("-mem", "503", "-v") { + out: List[String] => + assert(out.contains[String]("-Xmx503m")) + assert(!out.contains[String]("-Xss6m")) } - makeTest("sbt with -mem 503, -Xss in SBT_OPTS", sbtOpts = "-Xss6m")("-mem", "503", "-v") { out: List[String] => - assert(out.contains[String]("-Xmx503m")) - assert(!out.contains[String]("-Xss6m")) + makeTest("sbt with -mem 503, -Xss in SBT_OPTS", sbtOpts = "-Xss6m")("-mem", "503", "-v") { + out: List[String] => + assert(out.contains[String]("-Xmx503m")) + assert(!out.contains[String]("-Xss6m")) } - makeTest("sbt with -Xms2048M -Xmx2048M -Xss6M in JAVA_OPTS", javaOpts = "-Xms2048M -Xmx2048M -Xss6M")("-v") { out: List[String] => + makeTest( + "sbt with -Xms2048M -Xmx2048M -Xss6M in JAVA_OPTS", + javaOpts = "-Xms2048M -Xmx2048M -Xss6M" + )("-v") { out: List[String] => assert(out.contains[String]("-Xms2048M")) assert(out.contains[String]("-Xmx2048M")) assert(out.contains[String]("-Xss6M")) } - makeTest("sbt with -Xms2048M -Xmx2048M -Xss6M in SBT_OPTS", sbtOpts = "-Xms2048M -Xmx2048M -Xss6M")( "-v") { out: List[String] => + makeTest( + "sbt with -Xms2048M -Xmx2048M -Xss6M in SBT_OPTS", + sbtOpts = "-Xms2048M -Xmx2048M -Xss6M" + )("-v") { out: List[String] => assert(out.contains[String]("-Xms2048M")) assert(out.contains[String]("-Xmx2048M")) assert(out.contains[String]("-Xss6M")) @@ -125,13 +144,18 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { assert(out.contains[String]("-XX:PermSize=128M")) } - makeTest("sbt with -XX:+UseG1GC -XX:+PrintGC in JAVA_OPTS", javaOpts = "-XX:+UseG1GC -XX:+PrintGC")("-v") { out: List[String] => + makeTest( + "sbt with -XX:+UseG1GC -XX:+PrintGC in JAVA_OPTS", + javaOpts = "-XX:+UseG1GC -XX:+PrintGC" + )("-v") { out: List[String] => assert(out.contains[String]("-XX:+UseG1GC")) assert(out.contains[String]("-XX:+PrintGC")) assert(!out.contains[String]("-XX:+UseG1GC=-XX:+PrintGC")) } - makeTest("sbt with -XX:-UseG1GC -XX:-PrintGC in SBT_OPTS", sbtOpts = "-XX:+UseG1GC -XX:+PrintGC")( "-v") { out: List[String] => + makeTest("sbt with -XX:-UseG1GC -XX:-PrintGC in SBT_OPTS", sbtOpts = "-XX:+UseG1GC -XX:+PrintGC")( + "-v" + ) { out: List[String] => assert(out.contains[String]("-XX:+UseG1GC")) assert(out.contains[String]("-XX:+PrintGC")) assert(!out.contains[String]("-XX:+UseG1GC=-XX:+PrintGC")) @@ -140,7 +164,8 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { test("sbt with -debug in SBT_OPTS appears in sbt commands") { if (isWindows) cancel("Test not supported on windows") - val out: List[String] = sbtProcessWithOpts("compile", "-v")(javaOpts = "", sbtOpts = "-debug").!!.linesIterator.toList + val out: List[String] = + sbtProcessWithOpts("compile", "-v")(javaOpts = "", sbtOpts = "-debug").!!.linesIterator.toList // Debug argument must appear in the 'commands' section (after the sbt-launch.jar argument) to work val sbtLaunchMatcher = """^.+sbt-launch.jar["]{0,1}$""".r val locationOfSbtLaunchJarArg = out.zipWithIndex.collectFirst { @@ -155,7 +180,9 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { } makeTest("sbt --jvm-debug ")("--jvm-debug", "12345", "-v") { out: List[String] => - assert(out.contains[String]("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=12345")) + assert( + out.contains[String]("-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=12345") + ) } makeTest("sbt --no-share adds three system properties")("--no-share") { out: List[String] => @@ -171,7 +198,7 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions { test("sbt --script-version should print sbtVersion") { val out = sbtProcess("--script-version").!!.trim - val expectedVersion = "^"+SbtRunnerTest.versionRegEx+"$" + val expectedVersion = "^" + SbtRunnerTest.versionRegEx + "$" assert(out.matches(expectedVersion)) () } From e3afa845ec00f13c55041d1a719d86cbf90602e6 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 27 Nov 2021 21:26:52 -0500 Subject: [PATCH 05/10] Extend supershell close timeout Fixes #6592 Problem ------- On Heroku there's timeout. Solution -------- This seems to be coming from supershell closing the executor. Extend the timeout to 30s. --- main/src/main/scala/sbt/internal/TaskProgress.scala | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/main/src/main/scala/sbt/internal/TaskProgress.scala b/main/src/main/scala/sbt/internal/TaskProgress.scala index cf9ce2e88..65fea78fc 100644 --- a/main/src/main/scala/sbt/internal/TaskProgress.scala +++ b/main/src/main/scala/sbt/internal/TaskProgress.scala @@ -70,8 +70,9 @@ private[sbt] class TaskProgress( pending.clear() scheduler.shutdownNow() executor.shutdownNow() - if (!executor.awaitTermination(1, TimeUnit.SECONDS) || - !scheduler.awaitTermination(1, TimeUnit.SECONDS)) { + if (!executor.awaitTermination(30, TimeUnit.SECONDS) || + !scheduler.awaitTermination(30, TimeUnit.SECONDS)) { + scala.Console.err.println("timed out closing the executor of supershell") throw new TimeoutException } } From 5b179395ec0b7c6c767ae3944e5556df0e802e8f Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Sat, 27 Nov 2021 23:42:20 -0500 Subject: [PATCH 06/10] Fixes fake position handling, take 2 Fixes #6720 Ref #5994 Problem ------- Sometimes the compiler returns a fake position such as ``. This causes this causes InvalidPathException on Windows if we try to convert it into NIO path. Solution -------- Looks for less-than sign in the VirtualFileRef and skip those. Since BSP requires the diagnostic info to be associated with files, we probably can't do much. --- .../internal/server/BuildServerReporter.scala | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala index 41a35ee8e..dba366578 100644 --- a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala +++ b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala @@ -80,11 +80,17 @@ final class BuildServerReporterImpl( private lazy val exchange = StandardMain.exchange private val problemsByFile = mutable.Map[Path, Vector[Diagnostic]]() + // sometimes the compiler returns a fake position such as + // on Windows, this causes InvalidPathException (see #5994 and #6720) + private def toSafePath(ref: VirtualFileRef): Option[Path] = + if (ref.id().contains("<")) None + else Some(converter.toPath(ref)) + override def sendSuccessReport(analysis: CompileAnalysis): Unit = { for { (source, infos) <- analysis.readSourceInfos.getAllSourceInfos.asScala + filePath <- toSafePath(source) } { - val filePath = converter.toPath(source) val diagnostics = infos.getReportedProblems.toSeq.flatMap(toDiagnostic) val params = PublishDiagnosticsParams( textDocument = TextDocumentIdentifier(filePath.toUri), @@ -98,8 +104,10 @@ final class BuildServerReporterImpl( } override def sendFailureReport(sources: Array[VirtualFile]): Unit = { - for (source <- sources) { - val filePath = converter.toPath(source) + for { + source <- sources + filePath <- toSafePath(source) + } { val diagnostics = problemsByFile.getOrElse(filePath, Vector()) val params = PublishDiagnosticsParams( textDocument = TextDocumentIdentifier(filePath.toUri), @@ -116,8 +124,8 @@ final class BuildServerReporterImpl( for { id <- problem.position.sourcePath.toOption diagnostic <- toDiagnostic(problem) + filePath <- toSafePath(VirtualFileRef.of(id)) } { - val filePath = converter.toPath(VirtualFileRef.of(id)) problemsByFile(filePath) = problemsByFile.getOrElse(filePath, Vector()) :+ diagnostic val params = PublishDiagnosticsParams( TextDocumentIdentifier(filePath.toUri), From bdccb6cbd54623f7140c6e92eb28269cf21973d2 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 29 Nov 2021 05:18:00 -0500 Subject: [PATCH 07/10] Zinc 1.6.0-M2 --- project/Dependencies.scala | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index a9451c2ab..34650e71a 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -12,10 +12,10 @@ object Dependencies { sys.env.get("BUILD_VERSION") orElse sys.props.get("sbt.build.version") // sbt modules - private val ioVersion = nightlyVersion.getOrElse("1.6.0-M1") + private val ioVersion = nightlyVersion.getOrElse("1.6.0-M2") private val lmVersion = - sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.6.0-M1") - val zincVersion = nightlyVersion.getOrElse("1.6.0-M1") + sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.6.0-M2") + val zincVersion = nightlyVersion.getOrElse("1.6.0-M2") private val sbtIO = "org.scala-sbt" %% "io" % ioVersion From 2f2ceeb9c95dc91c9f004aac7070fd40e8d0a68a Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 29 Nov 2021 05:32:33 -0500 Subject: [PATCH 08/10] Update banner --- main/src/main/scala/sbt/internal/Banner.scala | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/main/src/main/scala/sbt/internal/Banner.scala b/main/src/main/scala/sbt/internal/Banner.scala index 35f94bc80..b43f811ad 100644 --- a/main/src/main/scala/sbt/internal/Banner.scala +++ b/main/src/main/scala/sbt/internal/Banner.scala @@ -10,6 +10,15 @@ package sbt.internal private[sbt] object Banner { def apply(version: String): Option[String] = version match { + case v if v.startsWith("1.6.0") => + Some(s""" + |Here are some highlights of this release: + | - Improved JDK 17 support + | - Improved Build Server Protocol (BSP) support + | - Tab completion of global keys + |See https://eed3si9n.com/sbt-1.6.0-beta for full release notes. + |Hide the banner for this release by running `skipBanner`. + |""".stripMargin.linesIterator.mkString("\n")) case v if v.startsWith("1.4.0") => Some(s""" |Here are some highlights of this release: From daa57c4e1c79919e6f64c9512417f3fdaeabe7a8 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 29 Nov 2021 12:49:43 -0500 Subject: [PATCH 09/10] sbt 1.6.0-RC1 --- sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sbt b/sbt index 39b1dac32..218f45141 100755 --- a/sbt +++ b/sbt @@ -1,7 +1,7 @@ #!/usr/bin/env bash set +e -declare builtin_sbt_version="1.5.5" +declare builtin_sbt_version="1.6.0-RC1" declare -a residual_args declare -a java_args declare -a scalac_args From 0fef804b180486aef0a99eb35884006f5ed86c58 Mon Sep 17 00:00:00 2001 From: Adrien Piquerez Date: Sun, 5 Dec 2021 15:38:56 +0100 Subject: [PATCH 10/10] Fix #6738: register all forked process --- .../src/main/scala/sbt/ForkTests.scala | 10 +---- run/src/main/scala/sbt/Fork.scala | 13 ++++-- run/src/main/scala/sbt/Run.scala | 40 ++++++++++++------- 3 files changed, 37 insertions(+), 26 deletions(-) diff --git a/main-actions/src/main/scala/sbt/ForkTests.scala b/main-actions/src/main/scala/sbt/ForkTests.scala index 80694ce30..ba707d5a2 100755 --- a/main-actions/src/main/scala/sbt/ForkTests.scala +++ b/main-actions/src/main/scala/sbt/ForkTests.scala @@ -18,7 +18,7 @@ import sbt.util.Logger import sbt.ConcurrentRestrictions.Tag import sbt.protocol.testing._ import sbt.internal.util.Util.{ AnyOps, none } -import sbt.internal.util.{ RunningProcesses, Terminal => UTerminal } +import sbt.internal.util.{ Terminal => UTerminal } private[sbt] object ForkTests { def apply( @@ -158,13 +158,7 @@ private[sbt] object ForkTests { classOf[ForkMain].getCanonicalName, server.getLocalPort.toString ) - val p = Fork.java.fork(fork, options) - RunningProcesses.add(p) - val ec = try p.exitValue() - finally { - if (p.isAlive()) p.destroy() - RunningProcesses.remove(p) - } + val ec = Fork.java(fork, options) val result = if (ec != 0) TestOutput( diff --git a/run/src/main/scala/sbt/Fork.scala b/run/src/main/scala/sbt/Fork.scala index b2cb449d0..c7e74c0f7 100644 --- a/run/src/main/scala/sbt/Fork.scala +++ b/run/src/main/scala/sbt/Fork.scala @@ -9,10 +9,9 @@ package sbt import java.io.File import java.lang.ProcessBuilder.Redirect - import scala.sys.process.Process import OutputStrategy._ -import sbt.internal.util.Util +import sbt.internal.util.{ RunningProcesses, Util } import Util.{ AnyOps, none } import java.lang.{ ProcessBuilder => JProcessBuilder } @@ -31,7 +30,15 @@ final class Fork(val commandName: String, val runnerClass: Option[String]) { * It is configured according to `config`. * If `runnerClass` is defined for this Fork instance, it is prepended to `arguments` to define the arguments passed to the forked command. */ - def apply(config: ForkOptions, arguments: Seq[String]): Int = fork(config, arguments).exitValue() + def apply(config: ForkOptions, arguments: Seq[String]): Int = { + val p = fork(config, arguments) + RunningProcesses.add(p) + try p.exitValue() + finally { + if (p.isAlive()) p.destroy() + RunningProcesses.remove(p) + } + } /** * Forks the configured process and returns a `Process` that can be used to wait for completion or to terminate the forked process. diff --git a/run/src/main/scala/sbt/Run.scala b/run/src/main/scala/sbt/Run.scala index 4df43f707..637c1473a 100644 --- a/run/src/main/scala/sbt/Run.scala +++ b/run/src/main/scala/sbt/Run.scala @@ -10,7 +10,6 @@ package sbt import java.io.File import java.lang.reflect.Method import java.lang.reflect.Modifier.{ isPublic, isStatic } - import sbt.internal.inc.ScalaInstance import sbt.internal.inc.classpath.{ ClasspathFilter, ClasspathUtil } import sbt.internal.util.MessageOnlyException @@ -34,29 +33,40 @@ class ForkRun(config: ForkOptions) extends ScalaRun { s"""Nonzero exit code returned from $label: $exitCode""".stripMargin ) ) - val process = fork(mainClass, classpath, options, log) - def cancel() = { - log.warn("Run canceled.") - process.destroy() - 1 + + log.info(s"running (fork) $mainClass ${Run.runOptionsStr(options)}") + val c = configLogged(log) + val scalaOpts = scalaOptions(mainClass, classpath, options) + val exitCode = try Fork.java(c, scalaOpts) + catch { + case _: InterruptedException => + log.warn("Run canceled.") + 1 } - val exitCode = try process.exitValue() - catch { case _: InterruptedException => cancel() } processExitCode(exitCode, "runner") } def fork(mainClass: String, classpath: Seq[File], options: Seq[String], log: Logger): Process = { log.info(s"running (fork) $mainClass ${Run.runOptionsStr(options)}") - val scalaOptions = classpathOption(classpath) ::: mainClass :: options.toList - val configLogged = - if (config.outputStrategy.isDefined) config - else config.withOutputStrategy(OutputStrategy.LoggedOutput(log)) + val c = configLogged(log) + val scalaOpts = scalaOptions(mainClass, classpath, options) + // fork with Java because Scala introduces an extra class loader (#702) - Fork.java.fork(configLogged, scalaOptions) + Fork.java.fork(c, scalaOpts) } - private def classpathOption(classpath: Seq[File]) = - "-classpath" :: Path.makeString(classpath) :: Nil + + private def configLogged(log: Logger): ForkOptions = { + if (config.outputStrategy.isDefined) config + else config.withOutputStrategy(OutputStrategy.LoggedOutput(log)) + } + + private def scalaOptions( + mainClass: String, + classpath: Seq[File], + options: Seq[String] + ): Seq[String] = + "-classpath" :: Path.makeString(classpath) :: mainClass :: options.toList } class Run(private[sbt] val newLoader: Seq[File] => ClassLoader, trapExit: Boolean)