Scala3 Play3 Apache Pekko migration

otoroshi/app/OtoroshiLoader.scala

@@ -1,25 +1,25 @@
 package otoroshi.loader
 
-import com.softwaremill.macwire._
+import com.softwaremill.macwire.*
 import otoroshi.controllers.adminapi.InfosApiController
 import controllers.{Assets, AssetsComponents}
 import otoroshi.netty.ReactorNettyServer
-import otoroshi.actions._
+import otoroshi.actions.*
 import otoroshi.api.OtoroshiLoaderHelper.EnvContainer
 import otoroshi.api.{DocAction, GenericApiController, OtoroshiEnvHolder, OtoroshiLoaderHelper}
-import otoroshi.controllers._
-import otoroshi.controllers.adminapi._
+import otoroshi.controllers.*
+import otoroshi.controllers.adminapi.*
 import otoroshi.env.Env
-import otoroshi.gateway._
-import otoroshi.loader.modules._
+import otoroshi.gateway.*
+import otoroshi.loader.modules.*
 import otoroshi.next.controllers.{NgPluginsController, TryItController}
-import otoroshi.next.controllers.adminapi._
+import otoroshi.next.controllers.adminapi.*
 import otoroshi.next.tunnel.TunnelController
 import otoroshi.next.workflow.WorkflowsController
 import play.api.ApplicationLoader.Context
-import play.api.http.{DefaultHttpFilters, HttpErrorHandler, HttpRequestHandler}
+import play.api.http.{CookiesConfiguration, DefaultHttpFilters, HttpErrorHandler, HttpRequestHandler}
 import play.api.libs.ws.ahc.AhcWSComponents
-import play.api.mvc.EssentialFilter
+import play.api.mvc.{DefaultCookieHeaderEncoding, EssentialFilter}
 import play.api.routing.Router
 import play.api.{Application, ApplicationLoader, BuiltInComponentsFromContext, LoggerConfigurator}
 import play.filters.HttpFiltersComponents
@@ -67,6 +67,8 @@ package object modules {
 
     // lazy val gzipFilterConfig                           = GzipFilterConfig.fromConfiguration(configuration)
     // lazy val gzipFilter                                 = wire[GzipFilter]
+    lazy val headerEncoding = new play.api.mvc.DefaultCookieHeaderEncoding(httpConfiguration.cookies)
+
     override lazy val httpFilters: Seq[EssentialFilter] = Seq()
 
     lazy val circuitBreakersHolder: CircuitBreakersHolder = wire[CircuitBreakersHolder]

otoroshi/app/actions/api.scala

@@ -2,22 +2,22 @@ package otoroshi.actions
 
 import java.util.Base64
 import java.util.concurrent.atomic.AtomicReference
-import akka.http.scaladsl.util.FastFuture
+import org.apache.pekko.http.scaladsl.util.FastFuture
 import com.auth0.jwt.JWT
 import com.auth0.jwt.algorithms.Algorithm
-import com.google.common.base.Charsets
+import java.nio.charset.StandardCharsets
 import next.models.Api
 import otoroshi.env.Env
 import otoroshi.gateway.Errors
 import otoroshi.models.{ApiKey, BackOfficeUser, EntityLocationSupport, _}
 import otoroshi.models.RightsChecker.{SuperAdminOnly, TenantAdminOnly}
-import otoroshi.utils.syntax.implicits._
+import otoroshi.utils.syntax.implicits.*
 import play.api.Logger
 import play.api.libs.json.{JsArray, JsValue, Json}
-import play.api.mvc._
+import play.api.mvc.*
 import otoroshi.security.{IdGenerator, OtoroshiClaim}
 import otoroshi.utils.{JsonPathValidator, JsonValidator}
-import otoroshi.utils.http.RequestImplicits._
+import otoroshi.utils.http.RequestImplicits.*
 
 import scala.concurrent.{ExecutionContext, Future}
 import scala.util.{Failure, Success, Try}
@@ -35,12 +35,12 @@ trait ApiActionContextCapable {
   lazy val forbidden  = ApiActionContext.forbidden
   lazy val fforbidden = ApiActionContext.fforbidden
 
-  def user(implicit env: Env): Option[JsValue] =
+  def user(using env: Env): Option[JsValue] =
     request.headers
       .get(env.Headers.OtoroshiAdminProfile)
-      .flatMap(p => Try(Json.parse(new String(Base64.getDecoder.decode(p), Charsets.UTF_8))).toOption)
+      .flatMap(p => Try(Json.parse(new String(Base64.getDecoder.decode(p), StandardCharsets.UTF_8))).toOption)
 
-  def from(implicit env: Env): String = request.theIpAddress
+  def from(using env: Env): String = request.theIpAddress
 
   def ua: String = request.theUserAgent
 
@@ -50,7 +50,7 @@ trait ApiActionContextCapable {
 
   private val bouRef = new AtomicReference[Either[String, Option[BackOfficeUser]]]()
 
-  def userIsSuperAdmin(implicit env: Env): Boolean = {
+  def userIsSuperAdmin(using env: Env): Boolean = {
     backOfficeUser match {
       case Left(_)           => false
       case Right(None)       => {
@@ -68,13 +68,13 @@ trait ApiActionContextCapable {
     }
   }
 
-  def oneAuthorizedTenant(implicit env: Env): TenantId =
+  def oneAuthorizedTenant(using env: Env): TenantId =
     backOfficeUser.toOption.flatten.map(_.rights.oneAuthorizedTenant).getOrElse(TenantId.default)
 
-  def oneAuthorizedTeam(implicit env: Env): TeamId =
+  def oneAuthorizedTeam(using env: Env): TeamId =
     backOfficeUser.toOption.flatten.map(_.rights.oneAuthorizedTeam).getOrElse(TeamId.default)
 
-  def backOfficeUser(implicit env: Env): Either[String, Option[BackOfficeUser]] = {
+  def backOfficeUser(using env: Env): Either[String, Option[BackOfficeUser]] = {
     Option(bouRef.get()).getOrElse {
       (
         if (env.bypassUserRightsCheck) {
@@ -104,7 +104,6 @@ trait ApiActionContextCapable {
                     adminEntityValidators = Map.empty
                   )
                   Right(user.some)
-                case _                => Left("You're not authorized here (invalid setup) ! ")
               }
             case Some(userJwt) =>
               Try(JWT.require(Algorithm.HMAC512(apiKey.clientSecret)).build().verify(userJwt)) match {
@@ -128,19 +127,19 @@ trait ApiActionContextCapable {
     }
   }
 
-  private def rootOrTenantAdmin(user: BackOfficeUser)(f: => Boolean)(implicit env: Env): Boolean = {
+  private def rootOrTenantAdmin(user: BackOfficeUser)(f: => Boolean)(using env: Env): Boolean = {
     if (env.bypassUserRightsCheck || SuperAdminOnly.canPerform(user, currentTenant)) { // || TenantAdminOnly.canPerform(user, currentTenant)) {
       true
     } else {
       f
     }
   }
 
-  def canUserReadJson(item: JsValue)(implicit env: Env): Boolean = {
+  def canUserReadJson(item: JsValue)(using env: Env): Boolean = {
     canUserRead(FakeEntityLocationSupport(EntityLocation.readFromKey(item)))
   }
 
-  def canUserRead[T <: EntityLocationSupport](item: T)(implicit env: Env): Boolean = {
+  def canUserRead[T <: EntityLocationSupport](item: T)(using env: Env): Boolean = {
     backOfficeUser match {
       case Left(_)           => false
       case Right(None)       => true
@@ -157,11 +156,11 @@ trait ApiActionContextCapable {
     }
   }
 
-  def canUserWriteJson(item: JsValue)(implicit env: Env): Boolean = {
+  def canUserWriteJson(item: JsValue)(using env: Env): Boolean = {
     canUserWrite(FakeEntityLocationSupport(EntityLocation.readFromKey(item)))
   }
 
-  def canUserWrite[T <: EntityLocationSupport](item: T)(implicit env: Env): Boolean = {
+  def canUserWrite[T <: EntityLocationSupport](item: T)(using env: Env): Boolean = {
     backOfficeUser match {
       case Left(_)           => false
       case Right(None)       => true
@@ -179,7 +178,7 @@ trait ApiActionContextCapable {
     }
   }
 
-  def checkRights(rc: RightsChecker)(f: Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def checkRights(rc: RightsChecker)(f: Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     if (env.bypassUserRightsCheck) {
       f
     } else {
@@ -198,7 +197,7 @@ trait ApiActionContextCapable {
 
   private def findServiceById(
       serviceId: String
-  )(implicit ec: ExecutionContext, env: Env): Future[Option[ServiceDescriptor]] = {
+  )(using ec: ExecutionContext, env: Env): Future[Option[ServiceDescriptor]] = {
     def getRouteCompositions = {
       env.datastores.routeCompositionDataStore.findById(serviceId) flatMap {
         case Some(service) => service.toRoutes.head.legacy.some.vfuture
@@ -245,7 +244,7 @@ trait ApiActionContextCapable {
   }
 
   /// utils methods
-  def canReadService(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canReadService(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     if (id == "global") {
       f
     } else {
@@ -256,50 +255,50 @@ trait ApiActionContextCapable {
     }
   }
 
-  def canWriteService(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canWriteService(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     findServiceById(id).flatMap {
       case Some(service) if canUserWrite(service) => f
       case _                                      => fforbidden
     }
   }
 
-  def canReadApikey(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canReadApikey(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     env.datastores.apiKeyDataStore.findById(id).flatMap {
       case Some(service) if canUserRead(service) => f
       case _                                     => fforbidden
     }
   }
 
-  def canWriteApikey(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canWriteApikey(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     env.datastores.apiKeyDataStore.findById(id).flatMap {
       case Some(service) if canUserWrite(service) => f
       case _                                      => fforbidden
     }
   }
 
-  def canReadGroup(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canReadGroup(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     env.datastores.serviceGroupDataStore.findById(id).flatMap {
       case Some(service) if canUserRead(service) => f
       case _                                     => fforbidden
     }
   }
 
-  def canWriteGroup(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canWriteGroup(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     env.datastores.serviceGroupDataStore.findById(id).flatMap {
       case Some(service) if canUserWrite(service) => f
       case _                                      => fforbidden
     }
   }
 
-  def canWriteAuthModule(id: String)(f: => Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def canWriteAuthModule(id: String)(f: => Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     // env.datastores.authConfigsDataStore.findById(id).flatMap {
     env.proxyState.authModuleAsync(id).flatMap {
       case Some(mod) if canUserWrite(mod) => f
       case _                              => fforbidden
     }
   }
 
-  def validateEntity(json: JsValue, singularName: String)(implicit env: Env): Either[JsValue, JsValue] = {
+  def validateEntity(json: JsValue, singularName: String)(using env: Env): Either[JsValue, JsValue] = {
     backOfficeUser match {
       case Left(err)         => Left(err.json)
       case Right(None)       => Right(json)
@@ -329,17 +328,17 @@ trait ApiActionContextCapable {
 
 case class ApiActionContext[A](apiKey: ApiKey, request: Request[A]) extends ApiActionContextCapable {}
 
-class ApiAction(val parser: BodyParser[AnyContent])(implicit env: Env)
+class ApiAction(val parser: BodyParser[AnyContent])(using env: Env)
     extends ActionBuilder[ApiActionContext, AnyContent]
     with ActionFunction[Request, ApiActionContext] {
 
-  implicit lazy val ec = env.otoroshiExecutionContext
+  implicit lazy val ec: scala.concurrent.ExecutionContext = env.otoroshiExecutionContext
 
   lazy val logger = Logger("otoroshi-api-action")
 
-  def decodeBase64(encoded: String): String = new String(OtoroshiClaim.decoder.decode(encoded), Charsets.UTF_8)
+  def decodeBase64(encoded: String): String = new String(OtoroshiClaim.decoder.decode(encoded), StandardCharsets.UTF_8)
 
-  def error(message: String, ex: Option[Throwable] = None)(implicit request: Request[_]): Future[Result] = {
+  def error(message: String, ex: Option[Throwable] = None)(using request: Request[_]): Future[Result] = {
     ex match {
       case Some(e) => logger.error(s"error message: $message", e)
       case None    => logger.error(s"error message: $message")
@@ -361,7 +360,7 @@ class ApiAction(val parser: BodyParser[AnyContent])(implicit env: Env)
     def perform(): Future[Result] = {
       request.headers.get(env.Headers.OtoroshiClaim).get.split("\\.").toSeq match {
         case Seq(head, body, signature) => {
-          val claim          = Json.parse(new String(OtoroshiClaim.decoder.decode(body), Charsets.UTF_8))
+          val claim          = Json.parse(new String(OtoroshiClaim.decoder.decode(body), StandardCharsets.UTF_8))
           val lastestApikey  = (claim \ "access_type").asOpt[String].exists(v => v == "apikey" || v == "both")
           val latestClientId = (claim \ "apikey" \ "clientId").asOpt[String]
           (claim \ "sub").as[String].split(":").toSeq match {
@@ -439,15 +438,15 @@ class ApiAction(val parser: BodyParser[AnyContent])(implicit env: Env)
 
 case class UnAuthApiActionContent[A](req: Request[A])
 
-class UnAuthApiAction(val parser: BodyParser[AnyContent])(implicit env: Env)
+class UnAuthApiAction(val parser: BodyParser[AnyContent])(using env: Env)
     extends ActionBuilder[UnAuthApiActionContent, AnyContent]
     with ActionFunction[Request, UnAuthApiActionContent] {
 
-  implicit lazy val ec = env.otoroshiExecutionContext
+  implicit lazy val ec: scala.concurrent.ExecutionContext = env.otoroshiExecutionContext
 
   lazy val logger = Logger("otoroshi-api-action")
 
-  def error(message: String, ex: Option[Throwable] = None)(implicit request: Request[_]): Future[Result] = {
+  def error(message: String, ex: Option[Throwable] = None)(using request: Request[_]): Future[Result] = {
     ex match {
       case Some(e) => logger.error(s"error message: $message", e)
       case None    => logger.error(s"error message: $message")

otoroshi/app/actions/backoffice.scala

@@ -1,8 +1,8 @@
 package otoroshi.actions
 
-import akka.http.scaladsl.model.Uri
-import akka.http.scaladsl.model.Uri.Path
-import akka.http.scaladsl.util.FastFuture
+import org.apache.pekko.http.scaladsl.model.Uri
+import org.apache.pekko.http.scaladsl.model.Uri.Path
+import org.apache.pekko.http.scaladsl.util.FastFuture
 import otoroshi.auth.GenericOauth2Module
 import otoroshi.env.Env
 import otoroshi.events.{Alerts, BlackListedBackOfficeUserAlert}
@@ -11,17 +11,17 @@ import otoroshi.models.BackOfficeUser
 import otoroshi.models.RightsChecker.{SuperAdminOnly, TenantAdminOnly}
 import otoroshi.models.{EntityLocationSupport, RightsChecker, TenantId}
 import otoroshi.utils.TypedMap
-import otoroshi.utils.syntax.implicits._
+import otoroshi.utils.syntax.implicits.*
 import play.api.libs.json.Json
 import play.api.mvc.Results.Status
-import play.api.mvc._
-import otoroshi.utils.http.RequestImplicits._
+import play.api.mvc.*
+import otoroshi.utils.http.RequestImplicits.*
 
 import scala.concurrent.{ExecutionContext, Future}
 
 case class BackOfficeActionContext[A](request: Request[A], user: Option[BackOfficeUser]) {
   def connected: Boolean              = user.isDefined
-  def from(implicit env: Env): String = request.theIpAddress
+  def from(using env: Env): String = request.theIpAddress
   def ua: String                      = request.theUserAgent
 }
 
@@ -30,36 +30,36 @@ case class BackOfficeActionContextAuth[A](request: Request[A], user: BackOfficeU
   lazy val forbidden  = ApiActionContext.forbidden
   lazy val fforbidden = ApiActionContext.fforbidden
 
-  def from(implicit env: Env): String = request.theIpAddress
+  def from(using env: Env): String = request.theIpAddress
   def ua: String                      = request.theUserAgent
 
   lazy val currentTenant: TenantId = {
     val value = request.headers.get("Otoroshi-Tenant").getOrElse("default")
     TenantId(value)
   }
 
-  private def rootOrTenantAdmin(user: BackOfficeUser)(f: => Boolean)(implicit env: Env): Boolean = {
+  private def rootOrTenantAdmin(user: BackOfficeUser)(f: => Boolean)(using env: Env): Boolean = {
     if (env.bypassUserRightsCheck || SuperAdminOnly.canPerform(user, currentTenant)) { // || TenantAdminOnly.canPerform(user, currentTenant)) {
       true
     } else {
       f
     }
   }
 
-  def canUserRead[T <: EntityLocationSupport](item: T)(implicit env: Env): Boolean = {
+  def canUserRead[T <: EntityLocationSupport](item: T)(using env: Env): Boolean = {
     rootOrTenantAdmin(user) {
       (currentTenant.value == item.location.tenant.value || item.location.tenant == TenantId.all) && user.rights
         .canReadTenant(item.location.tenant) && user.rights.canReadTeams(currentTenant, item.location.teams)
     }
   }
-  def canUserWrite[T <: EntityLocationSupport](item: T)(implicit env: Env): Boolean = {
+  def canUserWrite[T <: EntityLocationSupport](item: T)(using env: Env): Boolean = {
     rootOrTenantAdmin(user) {
       (currentTenant.value == item.location.tenant.value || item.location.tenant == TenantId.all) && user.rights
         .canWriteTenant(item.location.tenant) && user.rights.canWriteTeams(currentTenant, item.location.teams)
     }
   }
 
-  def checkRights(rc: RightsChecker)(f: Future[Result])(implicit ec: ExecutionContext, env: Env): Future[Result] = {
+  def checkRights(rc: RightsChecker)(f: Future[Result])(using ec: ExecutionContext, env: Env): Future[Result] = {
     if (env.bypassUserRightsCheck) {
       f
     } else {
@@ -72,11 +72,11 @@ case class BackOfficeActionContextAuth[A](request: Request[A], user: BackOfficeU
   }
 }
 
-class BackOfficeAction(val parser: BodyParser[AnyContent])(implicit env: Env)
+class BackOfficeAction(val parser: BodyParser[AnyContent])(using env: Env)
     extends ActionBuilder[BackOfficeActionContext, AnyContent]
     with ActionFunction[Request, BackOfficeActionContext] {
 
-  implicit lazy val ec = env.otoroshiExecutionContext
+  implicit lazy val ec: scala.concurrent.ExecutionContext = env.otoroshiExecutionContext
 
   override def invokeBlock[A](
       request: Request[A],
@@ -112,11 +112,11 @@ class BackOfficeAction(val parser: BodyParser[AnyContent])(implicit env: Env)
   override protected def executionContext: ExecutionContext = ec
 }
 
-class BackOfficeActionAuth(val parser: BodyParser[AnyContent])(implicit env: Env)
+class BackOfficeActionAuth(val parser: BodyParser[AnyContent])(using env: Env)
     extends ActionBuilder[BackOfficeActionContextAuth, AnyContent]
     with ActionFunction[Request, BackOfficeActionContextAuth] {
 
-  implicit lazy val ec = env.otoroshiExecutionContext
+  implicit lazy val ec: scala.concurrent.ExecutionContext = env.otoroshiExecutionContext
 
   // val checker = new AdminClearanceChecker()(env)