chore: cleanup for post 2.12 removal (#32515)

akka · Sep 18, 2024 · 6e23526 · 6e23526
1 parent 172afd1
commit 6e23526
Show file tree

Hide file tree

Showing 53 changed files with 155 additions and 268 deletions.
diff --git a/akka-actor-tests/src/test/scala/akka/actor/CoordinatedShutdownSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/CoordinatedShutdownSpec.scala
@@ -20,7 +20,6 @@ import akka.ConfigurationException
 import akka.Done
 import akka.actor.CoordinatedShutdown.Phase
 import akka.actor.CoordinatedShutdown.UnknownReason
-import akka.dispatch.ExecutionContexts
 import akka.testkit.AkkaSpec
 import akka.testkit.EventFilter
 import akka.testkit.TestKit
@@ -314,10 +313,10 @@ class CoordinatedShutdownSpec
             Future {
               testProbe.ref ! BMessage("concurrentB")
               Done
-            }(ExecutionContexts.parasitic)
+            }(ExecutionContext.parasitic)
           }
           Done
-        }(ExecutionContexts.parasitic)
+        }(ExecutionContext.parasitic)
 
       val cancellationFut: Future[Done] = {
         val cancellables = (0 until 20).map { _ =>

diff --git a/akka-actor-tests/src/test/scala/akka/dispatch/ExecutionContextSpec.scala b/akka-actor-tests/src/test/scala/akka/dispatch/ExecutionContextSpec.scala
@@ -141,7 +141,7 @@ class ExecutionContextSpec extends AkkaSpec with DefaultTimeout {
     }
 
     "work with same-thread executor plus blocking" in {
-      val ec = akka.dispatch.ExecutionContexts.parasitic
+      val ec = ExecutionContext.parasitic
       var x = 0
       ec.execute(new Runnable {
         override def run = {

diff --git a/akka-actor-tests/src/test/scala/akka/dispatch/SameThreadExecutionContextSpec.scala b/akka-actor-tests/src/test/scala/akka/dispatch/SameThreadExecutionContextSpec.scala
diff --git a/akka-actor-tests/src/test/scala/akka/io/TcpIntegrationSpecSupport.scala b/akka-actor-tests/src/test/scala/akka/io/TcpIntegrationSpecSupport.scala
@@ -6,12 +6,11 @@ package akka.io
 
 import scala.annotation.tailrec
 import scala.collection.immutable
+import scala.concurrent.ExecutionContext
 
 import Tcp._
-
 import akka.actor.ActorRef
 import akka.actor.ActorSystem
-import akka.dispatch.ExecutionContexts
 import akka.io.Inet.SocketOption
 import akka.testkit.{ AkkaSpec, TestProbe }
 import akka.testkit.SocketUtil.temporaryServerAddress
@@ -25,7 +24,7 @@ trait TcpIntegrationSpecSupport { this: AkkaSpec =>
         // terminate clientSystem after server system
         system.whenTerminated.onComplete { _ =>
           res.terminate()
-        }(ExecutionContexts.parasitic)
+        }(ExecutionContext.parasitic)
         res
       } else system
     val bindHandler = TestProbe()

diff --git a/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala b/akka-actor-tests/src/test/scala/akka/util/ByteStringSpec.scala
@@ -989,16 +989,6 @@ class ByteStringSpec extends AnyWordSpec with Matchers with Checkers {
     "serialize correctly" when {
       // note that this is serialization with Java serialization
       // real serialization is in akka-remote
-      if (util.Properties.versionNumberString.startsWith("2.12")) {
-        "parsing regular ByteString1C as compat" in {
-          val oldSerd =
-            "aced000573720021616b6b612e7574696c2e42797465537472696e672442797465537472696e67314336e9eed0afcfe4a40200015b000562797465737400025b427872001b616b6b612e7574696c2e436f6d7061637442797465537472696e67fa2925150f93468f0200007870757200025b42acf317f8060854e002000078700000000a74657374737472696e67"
-          val bs = ByteString("teststring", "UTF8")
-          val str = hexFromSer(bs)
-
-          str should be(oldSerd)
-        }
-      }
 
       "given all types of ByteString" in {
         check { (bs: ByteString) =>

diff --git a/akka-actor-typed/src/main/scala/akka/actor/typed/internal/ActorContextImpl.scala b/akka-actor-typed/src/main/scala/akka/actor/typed/internal/ActorContextImpl.scala
@@ -11,6 +11,7 @@ import java.util.Optional
 import java.util.concurrent.CompletionStage
 
 import scala.annotation.{ nowarn, switch }
+import scala.concurrent.ExecutionContext
 import scala.concurrent.{ ExecutionContextExecutor, Future }
 import scala.jdk.DurationConverters._
 import scala.reflect.ClassTag
@@ -24,7 +25,6 @@ import org.slf4j.LoggerFactory
 import akka.actor.Address
 import akka.actor.typed.internal.adapter.ActorSystemAdapter
 import akka.annotation.InternalApi
-import akka.dispatch.ExecutionContexts
 import akka.pattern.StatusReply
 import akka.util.BoxedType
 import akka.util.OptionVal
@@ -269,7 +269,7 @@ import akka.util.Timeout
 
   // Scala API impl
   def pipeToSelf[Value](future: Future[Value])(mapResult: Try[Value] => T): Unit = {
-    future.onComplete(value => self.unsafeUpcast ! AdaptMessage(value, mapResult))(ExecutionContexts.parasitic)
+    future.onComplete(value => self.unsafeUpcast ! AdaptMessage(value, mapResult))(ExecutionContext.parasitic)
   }
 
   // Java API impl

diff --git a/akka-actor-typed/src/main/scala/akka/actor/typed/internal/TimerSchedulerImpl.scala b/akka-actor-typed/src/main/scala/akka/actor/typed/internal/TimerSchedulerImpl.scala
@@ -7,14 +7,14 @@ package internal
 
 import java.time.Duration
 
+import scala.concurrent.ExecutionContext
 import scala.concurrent.duration.FiniteDuration
 
 import org.slf4j.Logger
 
 import akka.actor.{ Cancellable, NotInfluenceReceiveTimeout }
 import akka.actor.typed.scaladsl.ActorContext
 import akka.annotation.InternalApi
-import akka.dispatch.ExecutionContexts
 import akka.util.OptionVal
 
 /**
@@ -122,13 +122,13 @@ import akka.util.OptionVal
 
     val task = mode match {
       case SingleMode =>
-        ctx.system.scheduler.scheduleOnce(delay, () => ctx.self.unsafeUpcast ! timerMsg)(ExecutionContexts.parasitic)
+        ctx.system.scheduler.scheduleOnce(delay, () => ctx.self.unsafeUpcast ! timerMsg)(ExecutionContext.parasitic)
       case m: FixedDelayMode =>
         ctx.system.scheduler.scheduleWithFixedDelay(m.initialDelay, delay)(() => ctx.self.unsafeUpcast ! timerMsg)(
-          ExecutionContexts.parasitic)
+          ExecutionContext.parasitic)
       case m: FixedRateMode =>
         ctx.system.scheduler.scheduleAtFixedRate(m.initialDelay, delay)(() => ctx.self.unsafeUpcast ! timerMsg)(
-          ExecutionContexts.parasitic)
+          ExecutionContext.parasitic)
     }
 
     val nextTimer = Timer(key, msg, mode.repeat, nextGen, task)

diff --git a/akka-actor-typed/src/main/scala/akka/actor/typed/internal/adapter/ActorSystemAdapter.scala b/akka-actor-typed/src/main/scala/akka/actor/typed/internal/adapter/ActorSystemAdapter.scala
@@ -6,6 +6,7 @@ package akka.actor.typed.internal.adapter
 
 import java.util.concurrent.CompletionStage
 
+import scala.concurrent.ExecutionContext
 import scala.jdk.FutureConverters._
 import scala.concurrent.ExecutionContextExecutor
 
@@ -106,11 +107,9 @@ import akka.util.OptionVal
   override def uptime: Long = classicSystem.uptime
   override def printTree: String = system.printTree
 
-  import akka.dispatch.ExecutionContexts.parasitic
-
   override def terminate(): Unit = system.terminate()
   override lazy val whenTerminated: scala.concurrent.Future[akka.Done] =
-    system.whenTerminated.map(_ => Done)(parasitic)
+    system.whenTerminated.map(_ => Done)(ExecutionContext.parasitic)
   override lazy val getWhenTerminated: CompletionStage[akka.Done] =
     whenTerminated.asJava
 

diff --git a/akka-actor/src/main/mima-filters/2.9.5.backwards.excludes/cleanup-post-2.12-removal.excludes b/akka-actor/src/main/mima-filters/2.9.5.backwards.excludes/cleanup-post-2.12-removal.excludes
@@ -0,0 +1,6 @@
+# #32515 cleanup for post 2.12 removal
+ProblemFilters.exclude[MissingClassProblem]("akka.dispatch.ExecutionContexts$sameThreadExecutionContext$")
+ProblemFilters.exclude[MissingClassProblem]("akka.dispatch.internal.SameThreadExecutionContext")
+ProblemFilters.exclude[MissingClassProblem]("akka.dispatch.internal.SameThreadExecutionContext$")
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.dispatch.ExecutionContexts.parasitic")
+ProblemFilters.exclude[MissingFieldProblem]("akka.dispatch.ExecutionContexts.sameThreadExecutionContext")
diff --git a/akka-actor/src/main/scala/akka/actor/ActorSelection.scala b/akka-actor/src/main/scala/akka/actor/ActorSelection.scala
@@ -5,20 +5,21 @@
 package akka.actor
 
 import akka.annotation.InternalApi
-
 import java.util.concurrent.CompletionStage
 import java.util.regex.Pattern
+
 import scala.annotation.nowarn
 import scala.annotation.tailrec
 import scala.collection.immutable
+import scala.concurrent.ExecutionContext
 import scala.jdk.FutureConverters.FutureOps
 import scala.concurrent.Future
 import scala.concurrent.Promise
 import scala.concurrent.duration._
 import scala.jdk.DurationConverters._
 import scala.language.implicitConversions
 import scala.util.Success
-import akka.dispatch.ExecutionContexts
+
 import akka.pattern.ask
 import akka.routing.MurmurHash
 import akka.util.{ Helpers, Timeout }
@@ -65,7 +66,7 @@ abstract class ActorSelection extends Serializable {
    * [[ActorRef]].
    */
   def resolveOne()(implicit timeout: Timeout): Future[ActorRef] = {
-    implicit val ec = ExecutionContexts.parasitic
+    implicit val ec = ExecutionContext.parasitic
     val p = Promise[ActorRef]()
     this.ask(Identify(None)).onComplete {
       case Success(ActorIdentity(_, Some(ref))) => p.success(ref)

diff --git a/akka-actor/src/main/scala/akka/actor/CoordinatedShutdown.scala b/akka-actor/src/main/scala/akka/actor/CoordinatedShutdown.scala
@@ -24,7 +24,6 @@ import com.typesafe.config.ConfigFactory
 
 import akka.Done
 import akka.annotation.InternalApi
-import akka.dispatch.ExecutionContexts
 import akka.event.Logging
 import akka.pattern.after
 import akka.util.OptionVal
@@ -258,7 +257,7 @@ object CoordinatedShutdown extends ExtensionId[CoordinatedShutdown] with Extensi
         system.whenTerminated.map { _ =>
           if (exitJvm && !runningJvmHook) System.exit(exitCode)
           Done
-        }(ExecutionContexts.parasitic)
+        }(ExecutionContext.parasitic)
       } else if (exitJvm) {
         System.exit(exitCode)
         Future.successful(Done)
@@ -469,7 +468,7 @@ final class CoordinatedShutdown private[akka] (
       override val size: Int = tasks.size
 
       override def run(recoverEnabled: Boolean)(implicit ec: ExecutionContext): Future[Done] = {
-        Future.sequence(tasks.map(_.run(recoverEnabled))).map(_ => Done)(ExecutionContexts.parasitic)
+        Future.sequence(tasks.map(_.run(recoverEnabled))).map(_ => Done)(ExecutionContext.parasitic)
       }
 
       // This method may be run multiple times during the compare-and-set loop of ConcurrentHashMap, so it must be side-effect-free

diff --git a/akka-actor/src/main/scala/akka/dispatch/Future.scala b/akka-actor/src/main/scala/akka/dispatch/Future.scala
@@ -16,9 +16,6 @@ import scala.concurrent.{ ExecutionContext, ExecutionContextExecutor, ExecutionC
 import scala.runtime.{ AbstractPartialFunction, BoxedUnit }
 import scala.util.{ Failure, Success, Try }
 
-import akka.annotation.InternalApi
-import akka.annotation.InternalStableApi
-import akka.dispatch.internal.SameThreadExecutionContext
 import akka.japi.{ Procedure, Function => JFunc, Option => JOption }
 
 /**
@@ -75,32 +72,6 @@ object ExecutionContexts {
    */
   def global(): ExecutionContextExecutor = ExecutionContext.global
 
-  /**
-   * INTERNAL API
-   *
-   * WARNING: Not A General Purpose ExecutionContext!
-   *
-   * This is an execution context which runs everything on the calling thread.
-   * It is very useful for actions which are known to be non-blocking and
-   * non-throwing in order to save a round-trip to the thread pool.
-   *
-   * Once Scala 2.12 is no longer supported this can be dropped in favour of directly using `ExecutionContext.parasitic`
-   */
-  @InternalStableApi
-  private[akka] val parasitic: ExecutionContext = SameThreadExecutionContext()
-
-  /**
-   * INTERNAL API
-   */
-  @InternalApi
-  @deprecated("Use ExecutionContexts.parasitic instead", "2.6.4")
-  private[akka] object sameThreadExecutionContext extends ExecutionContext with BatchingExecutor {
-    override protected def unbatchedExecute(runnable: Runnable): Unit = parasitic.execute(runnable)
-    override protected def resubmitOnBlock: Boolean = false // No point since we execute on same thread
-    override def reportFailure(t: Throwable): Unit =
-      parasitic.reportFailure(t)
-  }
-
 }
 
 /**

diff --git a/akka-actor/src/main/scala/akka/dispatch/internal/SameThreadExecutionContext.scala b/akka-actor/src/main/scala/akka/dispatch/internal/SameThreadExecutionContext.scala
diff --git a/akka-actor/src/main/scala/akka/io/dns/internal/AsyncDnsResolver.scala b/akka-actor/src/main/scala/akka/io/dns/internal/AsyncDnsResolver.scala
@@ -8,13 +8,13 @@ import java.net.{ Inet4Address, Inet6Address, InetAddress, InetSocketAddress }
 
 import scala.collection.immutable
 import scala.collection.mutable
+import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
 import scala.util.{ Failure, Success, Try }
 import scala.util.control.NonFatal
 
 import akka.actor.{ Actor, ActorLogging, ActorRef, ActorRefFactory, Props, Status }
 import akka.annotation.InternalApi
-import akka.dispatch.ExecutionContexts
 import akka.io.SimpleDnsCache
 import akka.io.dns._
 import akka.io.dns.CachePolicy.{ CachePolicy, Never, Ttl }
@@ -229,7 +229,7 @@ private[akka] object AsyncDnsResolver {
                   case _ => DidntDrop(question.id)
                 }
                 .pipeTo(self)
-          }(ExecutionContexts.parasitic)
+          }(ExecutionContext.parasitic)
         } catch {
           case NonFatal(ex) =>
             log.warning(ex, "Not forwarding DNS question to resolver [{}]", resolver)
@@ -405,13 +405,13 @@ private[akka] object AsyncDnsResolver {
           ipv4Recs.flatMap { v4 =>
             ipv6Recs.map { v6 =>
               DnsProtocol.Resolved(searchName, v4.rrs ++ v6.rrs, v4.additionalRecs ++ v6.additionalRecs)
-            }(ExecutionContexts.parasitic)
-          }(ExecutionContexts.parasitic)
+            }(ExecutionContext.parasitic)
+          }(ExecutionContext.parasitic)
 
         case Srv =>
           sendQuestion(resolver, requestId => SrvQuestion(requestId, searchName)).map { answer =>
             DnsProtocol.Resolved(searchName, answer.rrs, answer.additionalRecs)
-          }(ExecutionContexts.parasitic)
+          }(ExecutionContext.parasitic)
       }
   }
 }