migrate to session v0.5.0

Author: fupelaqu

api/src/main/scala/app/softnetwork/scheduler/api/SchedulerApi.scala

@@ -7,7 +7,11 @@ import app.softnetwork.persistence.schema.SchemaProvider
 import app.softnetwork.scheduler.handlers.SchedulerHandler
 import app.softnetwork.scheduler.launch.SchedulerApplication
 import app.softnetwork.scheduler.persistence.query.Entity2SchedulerProcessorStream
+import app.softnetwork.session.config.Settings
+import app.softnetwork.session.model.SessionManagers
+import com.softwaremill.session.{SessionConfig, SessionManager}
 import com.typesafe.config.Config
+import org.softnetwork.session.model.Session
 
 import scala.concurrent.Future
 
@@ -29,4 +33,10 @@ trait SchedulerApi extends SchedulerApplication { _: SchemaProvider =>
     : ActorSystem[_] => Seq[PartialFunction[HttpRequest, Future[HttpResponse]]] = system =>
     Seq(SchedulerServiceApiHandler.partial(schedulerServer(system))(system))
 
+  override protected def sessionType: Session.SessionType =
+    Settings.Session.SessionContinuityAndTransport
+
+  override protected def manager(implicit sessionConfig: SessionConfig): SessionManager[Session] =
+    SessionManagers.basic
+
 }

build.sbt

@@ -2,7 +2,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "scheduler"
 
-ThisBuild / version := "0.4.1"
+ThisBuild / version := "0.5.0"
 
 ThisBuild / scalaVersion := "2.12.15"
 

core/src/main/scala/app/softnetwork/scheduler/launch/SchedulerEndpoints.scala

@@ -4,11 +4,25 @@ import akka.actor.typed.ActorSystem
 import app.softnetwork.api.server.{ApiEndpoints, Endpoint}
 import app.softnetwork.persistence.schema.SchemaProvider
 import app.softnetwork.scheduler.service.SchedulerServiceEndpoints
+import app.softnetwork.session.service.SessionMaterials
+import com.softwaremill.session.{SessionConfig, SessionManager}
+import org.slf4j.{Logger, LoggerFactory}
+import org.softnetwork.session.model.Session
 
-trait SchedulerEndpoints extends ApiEndpoints { _: SchedulerGuardian with SchemaProvider =>
+import scala.concurrent.ExecutionContext
 
-  def schedulerEndpoints: ActorSystem[_] => SchedulerServiceEndpoints = system =>
-    SchedulerServiceEndpoints.apply(system, sessionEndpoints(system))
+trait SchedulerEndpoints extends ApiEndpoints { self: SchedulerGuardian with SchemaProvider =>
+
+  def schedulerEndpoints: ActorSystem[_] => SchedulerServiceEndpoints = sys =>
+    new SchedulerServiceEndpoints with SessionMaterials {
+      override implicit def system: ActorSystem[_] = sys
+      override lazy val ec: ExecutionContext = sys.executionContext
+      lazy val log: Logger = LoggerFactory getLogger getClass.getName
+      override protected def sessionType: Session.SessionType = self.sessionType
+      override implicit def manager(implicit
+        sessionConfig: SessionConfig
+      ): SessionManager[Session] = self.manager
+    }
 
   override def endpoints: ActorSystem[_] => List[Endpoint] = system =>
     List(schedulerEndpoints(system))

core/src/main/scala/app/softnetwork/scheduler/launch/SchedulerGuardian.scala

@@ -17,9 +17,12 @@ import app.softnetwork.scheduler.persistence.typed.SchedulerBehavior
 import app.softnetwork.scheduler.service.SchedulerServiceEndpoints
 import app.softnetwork.session.CsrfCheckHeader
 import app.softnetwork.session.launch.SessionGuardian
-import app.softnetwork.session.service.SessionEndpoints
+import app.softnetwork.session.service.SessionMaterials
+import com.softwaremill.session.{SessionConfig, SessionManager}
 import org.slf4j.{Logger, LoggerFactory}
+import org.softnetwork.session.model.Session
 
+import scala.concurrent.ExecutionContext
 import scala.util.{Failure, Success, Try}
 
 trait SchedulerGuardian extends SessionGuardian with CsrfCheckHeader { self: SchemaProvider =>
@@ -68,10 +71,14 @@ trait SchedulerGuardian extends SessionGuardian with CsrfCheckHeader { self: Sch
     sys.env.getOrElse("VERSION", SchedulerCoreBuildInfo.version)
 
   def schedulerSwagger: ActorSystem[_] => SwaggerEndpoint = sys =>
-    new SchedulerServiceEndpoints with SwaggerEndpoint {
+    new SchedulerServiceEndpoints with SwaggerEndpoint with SessionMaterials {
       override implicit def system: ActorSystem[_] = sys
+      override lazy val ec: ExecutionContext = sys.executionContext
       lazy val log: Logger = LoggerFactory getLogger getClass.getName
-      override def sessionEndpoints: SessionEndpoints = self.sessionEndpoints(system)
+      override protected def sessionType: Session.SessionType = self.sessionType
+      override implicit def manager(implicit
+        sessionConfig: SessionConfig
+      ): SessionManager[Session] = self.manager
       override val applicationVersion: String = systemVersion()
     }
 }

core/src/main/scala/app/softnetwork/scheduler/launch/SchedulerRoutes.scala

@@ -4,11 +4,25 @@ import akka.actor.typed.ActorSystem
 import app.softnetwork.api.server.{ApiRoute, ApiRoutes}
 import app.softnetwork.persistence.schema.SchemaProvider
 import app.softnetwork.scheduler.service.SchedulerService
+import app.softnetwork.session.service.SessionMaterials
+import com.softwaremill.session.{SessionConfig, SessionManager}
+import org.slf4j.{Logger, LoggerFactory}
+import org.softnetwork.session.model.Session
 
-trait SchedulerRoutes extends ApiRoutes { _: SchedulerGuardian with SchemaProvider =>
+import scala.concurrent.ExecutionContext
 
-  def schedulerService: ActorSystem[_] => SchedulerService = system =>
-    SchedulerService(system, sessionService(system))
+trait SchedulerRoutes extends ApiRoutes { self: SchedulerGuardian with SchemaProvider =>
+
+  def schedulerService: ActorSystem[_] => SchedulerService = sys =>
+    new SchedulerService with SessionMaterials {
+      override implicit def system: ActorSystem[_] = sys
+      override lazy val ec: ExecutionContext = sys.executionContext
+      lazy val log: Logger = LoggerFactory getLogger getClass.getName
+      override protected def sessionType: Session.SessionType = self.sessionType
+      override implicit def manager(implicit
+        sessionConfig: SessionConfig
+      ): SessionManager[Session] = self.manager
+    }
 
   override def apiRoutes: ActorSystem[_] => List[ApiRoute] =
     system =>

core/src/main/scala/app/softnetwork/scheduler/service/SchedulerService.scala

@@ -4,46 +4,44 @@ import akka.actor.typed.ActorSystem
 import akka.http.scaladsl.model.{HttpResponse, StatusCodes}
 import akka.http.scaladsl.server.{Directives, Route}
 import app.softnetwork.api.server._
-import app.softnetwork.persistence.service.Service
 import app.softnetwork.scheduler.config.SchedulerSettings
 import app.softnetwork.scheduler.handlers.{SchedulerDao, SchedulerHandler}
 import app.softnetwork.scheduler.message._
 import app.softnetwork.scheduler.model._
 import app.softnetwork.serialization._
-import app.softnetwork.session.service.SessionService
+import app.softnetwork.session.config.Settings
+import app.softnetwork.session.service.{ServiceWithSessionDirectives, SessionMaterials}
 import com.softwaremill.session.CsrfDirectives.hmacTokenCsrfProtection
 import com.softwaremill.session.CsrfOptions.checkHeader
+import com.softwaremill.session.SessionConfig
 import com.typesafe.scalalogging.StrictLogging
 import de.heikoseeberger.akkahttpjson4s.Json4sSupport
 import org.json4s.jackson.Serialization
 import org.json4s.{jackson, Formats}
-import org.slf4j.{Logger, LoggerFactory}
-import org.softnetwork.session.model.Session
 
 trait SchedulerService
     extends Directives
     with DefaultComplete
     with Json4sSupport
     with StrictLogging
-    with Service[SchedulerCommand, SchedulerCommandResult]
+    with ServiceWithSessionDirectives[SchedulerCommand, SchedulerCommandResult]
     with SchedulerDao
-    with SchedulerHandler
-    with ApiRoute {
+    with SchedulerHandler { _: SessionMaterials =>
 
-  implicit def serialization: Serialization.type = jackson.Serialization
+  implicit def sessionConfig: SessionConfig = Settings.Session.DefaultSessionConfig
 
-  override implicit def formats: Formats = commonFormats
+  override implicit def ts: ActorSystem[_] = system
 
-  import Session._
+  implicit def serialization: Serialization.type = jackson.Serialization
 
-  def sessionService: SessionService
+  override implicit def formats: Formats = commonFormats
 
   val route: Route = {
     pathPrefix(SchedulerSettings.SchedulerPath) {
       // check anti CSRF token
       hmacTokenCsrfProtection(checkHeader) {
         // check if a session exists
-        sessionService.requiredSession { session =>
+        requiredSession(sc, gt) { session =>
           // only administrators should be allowed to access this resource
           if (session.admin) {
             schedules ~ crons ~ scheduler
@@ -79,7 +77,7 @@ trait SchedulerService
         }
       }
     } ~ get {
-      loadScheduler() completeWith {
+      loadScheduler()(system) completeWith {
         case Some(s) =>
           complete(
             HttpResponse(
@@ -113,7 +111,7 @@ trait SchedulerService
         }
       }
     } ~ get {
-      loadScheduler() completeWith {
+      loadScheduler()(system) completeWith {
         case Some(s) =>
           complete(
             HttpResponse(
@@ -136,7 +134,7 @@ trait SchedulerService
     }
 
   private[this] def getScheduler(scheduler: Option[String]): Route = {
-    loadScheduler(scheduler) completeWith {
+    loadScheduler(scheduler)(system) completeWith {
       case Some(s) =>
         complete(
           HttpResponse(
@@ -148,13 +146,3 @@ trait SchedulerService
     }
   }
 }
-
-object SchedulerService {
-  def apply(_system: ActorSystem[_], _sessionService: SessionService): SchedulerService = {
-    new SchedulerService {
-      override def sessionService: SessionService = _sessionService
-      override implicit def system: ActorSystem[_] = _system
-      lazy val log: Logger = LoggerFactory getLogger getClass.getName
-    }
-  }
-}

core/src/main/scala/app/softnetwork/scheduler/service/SchedulerServiceEndpoints.scala

@@ -6,8 +6,9 @@ import app.softnetwork.scheduler.config.SchedulerSettings
 import app.softnetwork.scheduler.handlers.{SchedulerDao, SchedulerHandler}
 import app.softnetwork.scheduler.message.{SchedulerNotFound, _}
 import app.softnetwork.scheduler.model._
-import app.softnetwork.session.service.{ServiceWithSessionEndpoints, SessionEndpoints}
-import org.slf4j.{Logger, LoggerFactory}
+import app.softnetwork.session.config.Settings
+import app.softnetwork.session.service.{ServiceWithSessionEndpoints, SessionMaterials}
+import com.softwaremill.session.SessionConfig
 import org.softnetwork.session.model.Session
 import sttp.capabilities
 import sttp.capabilities.akka.AkkaStreams
@@ -22,10 +23,14 @@ import scala.language.implicitConversions
 trait SchedulerServiceEndpoints
     extends ServiceWithSessionEndpoints[SchedulerCommand, SchedulerCommandResult]
     with SchedulerDao
-    with SchedulerHandler {
+    with SchedulerHandler { _: SessionMaterials =>
 
   import app.softnetwork.serialization._
 
+  implicit def sessionConfig: SessionConfig = Settings.Session.DefaultSessionConfig
+
+  override implicit def ts: ActorSystem[_] = system
+
   def secureEndpoint: PartialServerEndpointWithSecurityOutput[
     (Seq[Option[String]], Option[String], Method, Option[String]),
     Session,
@@ -90,7 +95,7 @@ trait SchedulerServiceEndpoints
     rootSchedulesEndpoint.get
       .out(jsonBody[Seq[ScheduleView]].description("Schedules loaded"))
       .serverLogic { _ => _ =>
-        loadScheduler().map {
+        loadScheduler()(system).map {
           case Some(scheduler) =>
             Right(scheduler.schedules.map(_.view))
           case _ => Left(resultToApiError(SchedulerNotFound))
@@ -136,7 +141,7 @@ trait SchedulerServiceEndpoints
     rootCronTabsEndpoint.get
       .out(jsonBody[Seq[CronTab]].description("Cron tabs loaded"))
       .serverLogic { _ => _ =>
-        loadScheduler().map {
+        loadScheduler()(system).map {
           case Some(scheduler) => Right(scheduler.cronTabs)
           case _               => Left(resultToApiError(SchedulerNotFound))
         }
@@ -152,7 +157,7 @@ trait SchedulerServiceEndpoints
             case Nil => None
             case _   => Some(paths.head)
           }
-        loadScheduler(id).map {
+        loadScheduler(id)(system).map {
           case Some(scheduler) => Right(scheduler)
           case _               => Left(resultToApiError(SchedulerNotFound))
         }
@@ -170,14 +175,3 @@ trait SchedulerServiceEndpoints
     )
 
 }
-
-object SchedulerServiceEndpoints {
-  def apply(
-    _system: ActorSystem[_],
-    _sessionEndpoints: SessionEndpoints
-  ): SchedulerServiceEndpoints = new SchedulerServiceEndpoints {
-    override implicit def system: ActorSystem[_] = _system
-    lazy val log: Logger = LoggerFactory getLogger getClass.getName
-    override def sessionEndpoints: SessionEndpoints = _sessionEndpoints
-  }
-}

project/Versions.scala

@@ -1,6 +1,6 @@
 object Versions {
 
-  val genericPersistence = "0.4.1"
+  val genericPersistence = "0.5.0"
 
   val scalatest = "3.2.16"
 }

testkit/src/main/scala/app/softnetwork/scheduler/scalatest/SchedulerEndpointsTestKit.scala

@@ -3,12 +3,17 @@ package app.softnetwork.scheduler.scalatest
 import akka.actor.typed.ActorSystem
 import app.softnetwork.api.server.Endpoint
 import app.softnetwork.persistence.schema.SchemaProvider
-import app.softnetwork.scheduler.launch.{SchedulerEndpoints, SchedulerGuardian}
+import app.softnetwork.scheduler.launch.SchedulerEndpoints
 import app.softnetwork.session.CsrfCheck
-import app.softnetwork.session.scalatest.SessionEndpointsRoutes
+import app.softnetwork.session.scalatest.{SessionEndpointsRoutes, SessionTestKit}
+import app.softnetwork.session.service.SessionMaterials
 
 trait SchedulerEndpointsTestKit extends SchedulerEndpoints with SessionEndpointsRoutes {
-  _: SchedulerGuardian with SchemaProvider with CsrfCheck =>
+  _: SessionTestKit
+    with SchedulerTestKit
+    with SchemaProvider
+    with SessionMaterials
+    with CsrfCheck =>
 
   override def endpoints: ActorSystem[_] => List[Endpoint] =
     system =>

testkit/src/main/scala/app/softnetwork/scheduler/scalatest/SchedulerRouteTestKit.scala

@@ -9,13 +9,14 @@ import app.softnetwork.scheduler.message._
 import app.softnetwork.scheduler.model.{CronTab, Schedule, Scheduler}
 import app.softnetwork.serialization._
 import app.softnetwork.session.scalatest.SessionTestKit
+import app.softnetwork.session.service.SessionMaterials
 import org.scalatest.Suite
 
 trait SchedulerRouteTestKit
     extends SessionTestKit
     with SchedulerTestKit
     with SchedulerGrpcServices {
-  _: Suite with ApiRoutes =>
+  _: Suite with ApiRoutes with SessionMaterials =>
 
   override def beforeAll(): Unit = {
     super.beforeAll()