breaking Java DSL api changes (Duration)

Author: pjfanning

http-caching/src/main/scala/org/apache/pekko/http/caching/javadsl/LfuCacheSettings.scala

@@ -31,8 +31,24 @@ abstract class LfuCacheSettings private[http] () { self: LfuCachingSettingsImpl
   /* JAVA APIs */
   def getMaxCapacity: Int
   def getInitialCapacity: Int
-  def getTimeToLive: Duration
-  def getTimeToIdle: Duration
+
+  /**
+   * Java API
+   * <p>
+   * In 2.0.0, the return type of this method changed from `scala.concurrent.duration.Duration`
+   * to `java.time.Duration`.
+   * </p>
+   */
+  def getTimeToLive: java.time.Duration
+
+  /**
+   * Java API
+   * <p>
+   * In 2.0.0, the return type of this method changed from `scala.concurrent.duration.Duration`
+   * to `java.time.Duration`.
+   * </p>
+   */
+  def getTimeToIdle: java.time.Duration
 
   def withMaxCapacity(newMaxCapacity: Int): LfuCacheSettings = self.copy(maxCapacity = newMaxCapacity)
   def withInitialCapacity(newInitialCapacity: Int): LfuCacheSettings = self.copy(initialCapacity = newInitialCapacity)

http-caching/src/main/scala/org/apache/pekko/http/caching/scaladsl/LfuCacheSettings.scala

@@ -17,6 +17,7 @@ import org.apache.pekko
 import pekko.annotation.DoNotInherit
 import pekko.http.caching.impl.settings.LfuCachingSettingsImpl
 import pekko.http.caching.javadsl
+import pekko.http.impl.util.JavaDurationConverter
 import pekko.http.scaladsl.settings.SettingsCompanion
 import com.typesafe.config.Config
 
@@ -34,8 +35,8 @@ abstract class LfuCacheSettings private[http] () extends javadsl.LfuCacheSetting
 
   final def getMaxCapacity: Int = self.maxCapacity
   final def getInitialCapacity: Int = self.initialCapacity
-  final def getTimeToLive: Duration = self.timeToLive
-  final def getTimeToIdle: Duration = self.timeToIdle
+  final def getTimeToLive: java.time.Duration = JavaDurationConverter.toJava(self.timeToLive)
+  final def getTimeToIdle: java.time.Duration = JavaDurationConverter.toJava(self.timeToIdle)
 
   override def withMaxCapacity(newMaxCapacity: Int): LfuCacheSettings = self.copy(maxCapacity = newMaxCapacity)
   override def withInitialCapacity(newInitialCapacity: Int): LfuCacheSettings =

http-core/src/main/java/org/apache/pekko/http/javadsl/TimeoutAccess.java

@@ -32,8 +32,11 @@ public interface TimeoutAccess {
    *
    * <p>Due to the inherent raciness it is not guaranteed that the returned timeout was applied
    * before the previously set timeout has expired!
+   * 
+   * <p>In 2.0.0, the return type of this method changed from `scala.concurrent.duration.Duration`
+   * to `java.time.Duration`.
    */
-  scala.concurrent.duration.Duration getTimeout();
+  java.time.Duration getTimeout();
 
   /**
    * Tries to set a new timeout. The timeout period is measured as of the point in time that the end

http-core/src/main/scala/org/apache/pekko/http/impl/util/JavaDurationConverter.scala

@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.pekko.http.impl.util
+
+import java.time.temporal.ChronoUnit
+
+import org.apache.pekko
+import pekko.annotation.InternalApi
+
+import scala.concurrent.duration.FiniteDuration
+import scala.jdk.DurationConverters._
+
+/**
+  * Internal Pekko HTTP API
+  */
+@InternalApi
+private[http] object JavaDurationConverter {
+  def toJava(d: scala.concurrent.duration.Duration): java.time.Duration = d match {
+    case fd: scala.concurrent.duration.FiniteDuration => fd.toJava
+    case scala.concurrent.duration.Duration.Inf    => ChronoUnit.FOREVER.getDuration
+    case scala.concurrent.duration.Duration.MinusInf => ChronoUnit.FOREVER.getDuration.negated()
+    case scala.concurrent.duration.Duration.Undefined  => ChronoUnit.FOREVER.getDuration
+  }
+}

http-core/src/main/scala/org/apache/pekko/http/scaladsl/TimeoutAccess.scala

@@ -15,9 +15,10 @@ package org.apache.pekko.http.scaladsl
 
 import org.apache.pekko
 import pekko.annotation.DoNotInherit
+import pekko.http.impl.util.JavaDurationConverter
+import pekko.http.scaladsl.model.{ HttpRequest, HttpResponse }
 
 import scala.concurrent.duration.Duration
-import pekko.http.scaladsl.model.{ HttpRequest, HttpResponse }
 
 /**
  * Enables programmatic access to the server-side request timeout logic.
@@ -37,8 +38,7 @@ trait TimeoutAccess extends pekko.http.javadsl.TimeoutAccess {
    */
   def timeout: Duration
 
-  /** Java API */
-  def getTimeout: Duration = timeout
+  override def getTimeout: java.time.Duration = JavaDurationConverter.toJava(timeout)
 
   /**
    * Tries to set a new timeout.

http/src/main/scala/org/apache/pekko/http/javadsl/server/directives/TimeoutDirectives.scala

@@ -16,20 +16,28 @@ package org.apache.pekko.http.javadsl.server.directives
 import java.time.{ Duration => JDuration }
 import java.util.function.{ Function => JFunction, Supplier }
 
-import scala.concurrent.duration.Duration
+import scala.jdk.DurationConverters._
 
 import org.apache.pekko
+import pekko.http.impl.util.JavaDurationConverter
+import pekko.http.impl.util.JavaMapping.Implicits._
 import pekko.http.javadsl.model.{ HttpRequest, HttpResponse }
 import pekko.http.javadsl.server.Route
 import pekko.http.scaladsl.server.{ Directives => D }
-import pekko.util.JavaDurationConverters._
-
-import pekko.http.impl.util.JavaMapping.Implicits._
 
 abstract class TimeoutDirectives extends WebSocketDirectives {
 
-  def extractRequestTimeout(inner: JFunction[Duration, Route]): RouteAdapter = RouteAdapter {
-    D.extractRequestTimeout { timeout => inner.apply(timeout).delegate }
+  /**
+   * Java API
+   * <p>
+   * In 2.0.0, the input function changed from expecting `scala.concurrent.duration.Duration`
+   * as input to `java.time.Duration`.
+   * </p>
+   */
+  def extractRequestTimeout(inner: JFunction[java.time.Duration, Route]): RouteAdapter = RouteAdapter {
+    D.extractRequestTimeout { timeout =>
+      inner.apply(JavaDurationConverter.toJava(timeout)).delegate
+    }
   }
 
   /**
@@ -55,7 +63,7 @@ abstract class TimeoutDirectives extends WebSocketDirectives {
    */
   def withRequestTimeout(timeout: JDuration, inner: Supplier[Route]): RouteAdapter =
     RouteAdapter {
-      D.withRequestTimeout(timeout.asScala) { inner.get.delegate }
+      D.withRequestTimeout(timeout.toScala) { inner.get.delegate }
     }
 
   /**
@@ -83,7 +91,7 @@ abstract class TimeoutDirectives extends WebSocketDirectives {
   def withRequestTimeout(timeout: JDuration,
       timeoutHandler: JFunction[HttpRequest, HttpResponse],
       inner: Supplier[Route]): RouteAdapter = RouteAdapter {
-    D.withRequestTimeout(timeout.asScala, in => timeoutHandler(in.asJava).asScala) { inner.get.delegate }
+    D.withRequestTimeout(timeout.toScala, in => timeoutHandler(in.asJava).asScala) { inner.get.delegate }
   }
 
   def withoutRequestTimeout(inner: Supplier[Route]): RouteAdapter = RouteAdapter {

http/src/main/scala/org/apache/pekko/http/scaladsl/server/directives/TimeoutDirectives.scala

@@ -34,7 +34,7 @@ trait TimeoutDirectives {
    */
   def extractRequestTimeout: Directive1[Duration] = Directive { inner => ctx =>
     val timeout = ctx.request.header[`Timeout-Access`] match {
-      case Some(t) => t.timeoutAccess.getTimeout
+      case Some(t) => t.timeoutAccess.timeout
       case _ =>
         ctx.log.warning("extractRequestTimeout was used in route however no request-timeout is set!")
         Duration.Inf