From 0b801e7598f9cd2076155f7c90c99bf87de6c38e Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 3 Apr 2018 14:25:59 +1000 Subject: [PATCH 1/4] Bump Scala version to 2.12.5 --- project/Dependencies.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 94a583ea8..d7272d442 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -4,7 +4,7 @@ import sbt.contraband.ContrabandPlugin.autoImport._ object Dependencies { // WARNING: Please Scala update versions in PluginCross.scala too - val scala212 = "2.12.4" + val scala212 = "2.12.5" val baseScalaVersion = scala212 // sbt modules From 70d3484896345698d5d142578e451bdb6dcd388a Mon Sep 17 00:00:00 2001 From: Jason Zaugg Date: Tue, 3 Apr 2018 14:27:21 +1000 Subject: [PATCH 2/4] Avoid printing RejectedExectionExeption stack trace after cancellation Before: ``` [warn] /Users/jz/code/zinc/internal/zinc-apiinfo/src/main/scala/xsbt/api/Visit.scala:187:19: parameter value s in method visitString is never used [warn] def visitString(s: String): Unit = () [warn] ^ ^C [warn] Canceling execution... [warn] 10 warnings found [info] Compilation has been cancelled [error] java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.ExecutorCompletionService$QueueingFuture@33ec70dd rejected from java.util.concurrent.ThreadPoolExecutor@4b832de6[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 1410] [error] at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063) [error] at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830) [error] at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379) [error] at java.util.concurrent.ExecutorCompletionService.submit(ExecutorCompletionService.java:181) [error] at sbt.CompletionService$.submit(CompletionService.scala:36) [error] at sbt.ConcurrentRestrictions$$anon$4.submitValid(ConcurrentRestrictions.scala:176) [error] at sbt.ConcurrentRestrictions$$anon$4.submit(ConcurrentRestrictions.scala:165) [error] at sbt.Execute.submit(Execute.scala:262) [error] at sbt.Execute.ready(Execute.scala:242) [error] at sbt.Execute.notifyDone(Execute.scala:181) [error] at sbt.Execute.$anonfun$retire$2(Execute.scala:152) [error] at sbt.Execute.$anonfun$retire$2$adapted(Execute.scala:151) [error] at scala.collection.immutable.List.foreach(List.scala:389) [error] at sbt.Execute.retire(Execute.scala:151) [error] at sbt.Execute.$anonfun$work$2(Execute.scala:279) [error] at sbt.Execute$$anon$1.process(Execute.scala:24) [error] at sbt.Execute.next$1(Execute.scala:104) [error] at sbt.Execute.processAll(Execute.scala:107) [error] at sbt.Execute.runKeep(Execute.scala:84) [error] at sbt.EvaluateTask$.liftedTree1$1(EvaluateTask.scala:387) [error] at sbt.EvaluateTask$.run$1(EvaluateTask.scala:386) [error] at sbt.EvaluateTask$.runTask(EvaluateTask.scala:405) [error] at sbt.internal.Aggregation$.$anonfun$timedRun$4(Aggregation.scala:100) [error] at sbt.EvaluateTask$.withStreams(EvaluateTask.scala:331) [error] at sbt.internal.Aggregation$.timedRun(Aggregation.scala:98) [error] at sbt.internal.Aggregation$.runTasks(Aggregation.scala:111) [error] at sbt.internal.Aggregation$.$anonfun$applyTasks$1(Aggregation.scala:68) [error] at sbt.Command$.$anonfun$applyEffect$2(Command.scala:130) [error] at sbt.internal.Aggregation$.$anonfun$evaluatingParser$11(Aggregation.scala:220) [error] at sbt.internal.Act$.$anonfun$actParser0$3(Act.scala:387) [error] at sbt.MainLoop$.processCommand(MainLoop.scala:154) [error] at sbt.MainLoop$.$anonfun$next$2(MainLoop.scala:137) [error] at sbt.State$$anon$1.runCmd$1(State.scala:242) [error] at sbt.State$$anon$1.process(State.scala:248) [error] at sbt.MainLoop$.$anonfun$next$1(MainLoop.scala:137) [error] at sbt.internal.util.ErrorHandling$.wideConvert(ErrorHandling.scala:16) [error] at sbt.MainLoop$.next(MainLoop.scala:137) [error] at sbt.MainLoop$.run(MainLoop.scala:130) [error] at sbt.MainLoop$.$anonfun$runWithNewLog$1(MainLoop.scala:108) [error] at sbt.io.Using.apply(Using.scala:22) [error] at sbt.MainLoop$.runWithNewLog(MainLoop.scala:102) [error] at sbt.MainLoop$.runAndClearLast(MainLoop.scala:58) [error] at sbt.MainLoop$.runLoggedLoop(MainLoop.scala:43) [error] at sbt.MainLoop$.runLogged(MainLoop.scala:35) [error] at sbt.StandardMain$.runManaged(Main.scala:113) [error] at sbt.xMain.run(Main.scala:76) [error] at xsbt.boot.Launch$$anonfun$run$1.apply(Launch.scala:109) [error] at xsbt.boot.Launch$.withContextLoader(Launch.scala:128) [error] at xsbt.boot.Launch$.run(Launch.scala:109) [error] at xsbt.boot.Launch$$anonfun$apply$1.apply(Launch.scala:35) [error] at xsbt.boot.Launch$.launch(Launch.scala:117) [error] at xsbt.boot.Launch$.apply(Launch.scala:18) [error] at xsbt.boot.Boot$.runImpl(Boot.scala:41) [error] at xsbt.boot.Boot$.main(Boot.scala:17) [error] at xsbt.boot.Boot.main(Boot.scala) [error] java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.ExecutorCompletionService$QueueingFuture@33ec70dd rejected from java.util.concurrent.ThreadPoolExecutor@4b832de6[Terminated, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 1410] [error] Use 'last' for the full log. ``` After: ``` sbt:zinc Root> ;zincIvyIntegration/cleanClasses;zincIvyIntegration/compile [success] Total time: 0 s, completed 03/04/2018 2:24:33 PM [info] Compiling 5 Scala sources and 1 Java source to /Users/jz/code/zinc/internal/zinc-ivy-integration/target/scala-2.12/classes ... [warn] /Users/jz/code/zinc/internal/zinc-ivy-integration/src/main/scala/sbt/internal/inc/ResourceLoader.scala:14:42: parameter value classLoader in method getPropertiesFor is never used [warn] def getPropertiesFor(resource: String, classLoader: ClassLoader): Properties = { [warn] ^ [warn] /Users/jz/code/zinc/internal/zinc-ivy-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala:13:17: Unused import [warn] import java.net.URLClassLoader [warn] ^ [warn] /Users/jz/code/zinc/internal/zinc-ivy-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala:137:26: Unused import [warn] import sbt.io.Path.toURLs [warn] ^ [warn] /Users/jz/code/zinc/internal/zinc-ivy-integration/src/main/scala/sbt/internal/inc/ZincComponentCompiler.scala:94:30: The outer reference in this type test cannot be checked at run time. [warn] private final case class ScalaArtifacts(compiler: File, library: File, others: Vector[File]) [warn] ^ ^C [warn] Canceling execution... [warn] four warnings found [info] Compilation has been cancelled [error] Total time: 1 s, completed 03/04/2018 2:24:35 PM ``` Best served with https://github.com/scala/scala/pull/6479 Fixes #3958 --- main/src/main/scala/sbt/EvaluateTask.scala | 7 ++++++- tasks/src/main/scala/sbt/Execute.scala | 11 +++++++++-- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala index 1d17f5cc3..558fe2daf 100644 --- a/main/src/main/scala/sbt/EvaluateTask.scala +++ b/main/src/main/scala/sbt/EvaluateTask.scala @@ -11,6 +11,7 @@ import sbt.internal.{ Load, BuildStructure, TaskTimings, TaskName, GCUtil } import sbt.internal.util.{ Attributed, ErrorHandling, HList, RMap, Signals, Types } import sbt.util.{ Logger, Show } import sbt.librarymanagement.{ Resolver, UpdateReport } +import java.util.concurrent.RejectedExecutionException import scala.concurrent.duration.Duration import java.io.File @@ -387,7 +388,11 @@ object EvaluateTask { val results = x.runKeep(root)(service) storeValuesForPrevious(results, state, streams) applyResults(results, state, root) - } catch { case inc: Incomplete => (state, Inc(inc)) } finally shutdown() + } catch { + case _: RejectedExecutionException => + (state, Inc(Incomplete(None, message = Some("cancelled")))) + case inc: Incomplete => (state, Inc(inc)) + } finally shutdown() val replaced = transformInc(result) logIncResult(replaced, state, streams) (newState, replaced) diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala index 267a1383a..e3030cc00 100644 --- a/tasks/src/main/scala/sbt/Execute.scala +++ b/tasks/src/main/scala/sbt/Execute.scala @@ -7,8 +7,10 @@ package sbt +import java.util.concurrent.RejectedExecutionException + import sbt.internal.util.ErrorHandling.wideConvert -import sbt.internal.util.{ DelegatingPMap, PMap, RMap, IDSet, ~> } +import sbt.internal.util.{ DelegatingPMap, IDSet, PMap, RMap, ~> } import sbt.internal.util.Types._ import Execute._ @@ -76,7 +78,12 @@ private[sbt] final class Execute[A[_] <: AnyRef]( "State: " + state.toString + "\n\nResults: " + results + "\n\nCalls: " + callers + "\n\n" def run[T](root: A[T])(implicit strategy: Strategy): Result[T] = - try { runKeep(root)(strategy)(root) } catch { case i: Incomplete => Inc(i) } + try { + runKeep(root)(strategy)(root) + } catch { + case i: Incomplete => Inc(i) + case _: RejectedExecutionException => Inc(Incomplete(None, message = Some("cancelled"))) + } def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] = { assert(state.isEmpty, "Execute already running/ran.") From d48aa310e6442ff7ed2909c7686496822cea5ab4 Mon Sep 17 00:00:00 2001 From: Dale Wijnand Date: Tue, 3 Apr 2018 16:02:52 +0100 Subject: [PATCH 3/4] Catch RejectedExecutionException in Execute#runKeep --- main/src/main/scala/sbt/EvaluateTask.scala | 7 +----- tasks/src/main/scala/sbt/Execute.scala | 29 +++++++++++----------- 2 files changed, 15 insertions(+), 21 deletions(-) diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala index 558fe2daf..1d17f5cc3 100644 --- a/main/src/main/scala/sbt/EvaluateTask.scala +++ b/main/src/main/scala/sbt/EvaluateTask.scala @@ -11,7 +11,6 @@ import sbt.internal.{ Load, BuildStructure, TaskTimings, TaskName, GCUtil } import sbt.internal.util.{ Attributed, ErrorHandling, HList, RMap, Signals, Types } import sbt.util.{ Logger, Show } import sbt.librarymanagement.{ Resolver, UpdateReport } -import java.util.concurrent.RejectedExecutionException import scala.concurrent.duration.Duration import java.io.File @@ -388,11 +387,7 @@ object EvaluateTask { val results = x.runKeep(root)(service) storeValuesForPrevious(results, state, streams) applyResults(results, state, root) - } catch { - case _: RejectedExecutionException => - (state, Inc(Incomplete(None, message = Some("cancelled")))) - case inc: Incomplete => (state, Inc(inc)) - } finally shutdown() + } catch { case inc: Incomplete => (state, Inc(inc)) } finally shutdown() val replaced = transformInc(result) logIncResult(replaced, state, streams) (newState, replaced) diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala index e3030cc00..f063080ca 100644 --- a/tasks/src/main/scala/sbt/Execute.scala +++ b/tasks/src/main/scala/sbt/Execute.scala @@ -78,22 +78,21 @@ private[sbt] final class Execute[A[_] <: AnyRef]( "State: " + state.toString + "\n\nResults: " + results + "\n\nCalls: " + callers + "\n\n" def run[T](root: A[T])(implicit strategy: Strategy): Result[T] = - try { - runKeep(root)(strategy)(root) - } catch { - case i: Incomplete => Inc(i) - case _: RejectedExecutionException => Inc(Incomplete(None, message = Some("cancelled"))) - } - def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] = { - assert(state.isEmpty, "Execute already running/ran.") + try { runKeep(root)(strategy)(root) } catch { case i: Incomplete => Inc(i) } - addNew(root) - processAll() - assert(results contains root, "No result for root node.") - val finalResults = triggers.onComplete(results) - progressState = progress.allCompleted(progressState, finalResults) - finalResults - } + def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] = + try { + assert(state.isEmpty, "Execute already running/ran.") + + addNew(root) + processAll() + assert(results contains root, "No result for root node.") + val finalResults = triggers.onComplete(results) + progressState = progress.allCompleted(progressState, finalResults) + finalResults + } catch { + case _: RejectedExecutionException => throw Incomplete(None, message = Some("cancelled")) + } def processAll()(implicit strategy: Strategy): Unit = { @tailrec def next(): Unit = { From b78a0f667be2c0d27d4f313aeacb98a53833d2cd Mon Sep 17 00:00:00 2001 From: Dale Wijnand Date: Tue, 3 Apr 2018 16:05:56 +0100 Subject: [PATCH 4/4] Catch RejectedExecutionException in CompletionService.submit --- .../main/scala/sbt/CompletionService.scala | 7 ++++-- tasks/src/main/scala/sbt/Execute.scala | 23 ++++++++----------- 2 files changed, 14 insertions(+), 16 deletions(-) diff --git a/tasks/src/main/scala/sbt/CompletionService.scala b/tasks/src/main/scala/sbt/CompletionService.scala index f6fc3a957..88f00a5e8 100644 --- a/tasks/src/main/scala/sbt/CompletionService.scala +++ b/tasks/src/main/scala/sbt/CompletionService.scala @@ -17,7 +17,8 @@ import java.util.concurrent.{ CompletionService => JCompletionService, Executor, Executors, - ExecutorCompletionService + ExecutorCompletionService, + RejectedExecutionException, } object CompletionService { @@ -33,7 +34,9 @@ object CompletionService { def take() = completion.take().get() } def submit[T](work: () => T, completion: JCompletionService[T]): () => T = { - val future = completion.submit { new Callable[T] { def call = work() } } + val future = try completion.submit { new Callable[T] { def call = work() } } catch { + case _: RejectedExecutionException => throw Incomplete(None, message = Some("cancelled")) + } () => future.get() } diff --git a/tasks/src/main/scala/sbt/Execute.scala b/tasks/src/main/scala/sbt/Execute.scala index f063080ca..c5d16288e 100644 --- a/tasks/src/main/scala/sbt/Execute.scala +++ b/tasks/src/main/scala/sbt/Execute.scala @@ -7,8 +7,6 @@ package sbt -import java.util.concurrent.RejectedExecutionException - import sbt.internal.util.ErrorHandling.wideConvert import sbt.internal.util.{ DelegatingPMap, IDSet, PMap, RMap, ~> } import sbt.internal.util.Types._ @@ -80,19 +78,16 @@ private[sbt] final class Execute[A[_] <: AnyRef]( def run[T](root: A[T])(implicit strategy: Strategy): Result[T] = try { runKeep(root)(strategy)(root) } catch { case i: Incomplete => Inc(i) } - def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] = - try { - assert(state.isEmpty, "Execute already running/ran.") + def runKeep[T](root: A[T])(implicit strategy: Strategy): RMap[A, Result] = { + assert(state.isEmpty, "Execute already running/ran.") - addNew(root) - processAll() - assert(results contains root, "No result for root node.") - val finalResults = triggers.onComplete(results) - progressState = progress.allCompleted(progressState, finalResults) - finalResults - } catch { - case _: RejectedExecutionException => throw Incomplete(None, message = Some("cancelled")) - } + addNew(root) + processAll() + assert(results contains root, "No result for root node.") + val finalResults = triggers.onComplete(results) + progressState = progress.allCompleted(progressState, finalResults) + finalResults + } def processAll()(implicit strategy: Strategy): Unit = { @tailrec def next(): Unit = {