Merge pull request #29 from softwaremill/java_api

Java api

Author: adamw

build.sbt

@@ -54,10 +54,14 @@ lazy val core: Project = (project in file("core"))
   .settings(commonSettings: _*)
   .settings(
     name := "core",
+    testOptions in Test := Seq(Tests.Argument(TestFrameworks.JUnit, "-a")), // required for javadsl JUnit tests
+    crossPaths := false, // https://github.com/sbt/junit-interface/issues/35
     libraryDependencies ++= Seq(
       "com.typesafe.akka" %% "akka-http" % akkaHttpVersion,
       "com.typesafe.akka" %% "akka-http-testkit" % akkaHttpVersion % "test",
       "org.scalacheck" %% "scalacheck" % "1.13.4" % "test",
+      "junit" % "junit" % "4.12" % "test",
+      "com.novocode" % "junit-interface" % "0.11" % "test",
       scalaTest
     )
   )

core/src/main/java/com/softwaremill/session/javadsl/CsrfDirectives.scala

@@ -0,0 +1,29 @@
+package com.softwaremill.session.javadsl
+
+import java.util.function.Supplier
+
+import akka.http.javadsl.server.Route
+import akka.http.javadsl.server.directives.RouteAdapter
+import com.softwaremill.session.CsrfCheckMode
+
+/**
+  * Java alternative for com.softwaremill.session.CsrfDirectives
+  */
+trait CsrfDirectives {
+
+  def randomTokenCsrfProtection[T](checkMode: CsrfCheckMode[T], inner: Supplier[Route]): Route = RouteAdapter {
+    com.softwaremill.session.CsrfDirectives.randomTokenCsrfProtection(checkMode) {
+      inner.get.asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+  def setNewCsrfToken[T](checkMode: CsrfCheckMode[T], inner: Supplier[Route]): Route = RouteAdapter {
+    com.softwaremill.session.CsrfDirectives.setNewCsrfToken(checkMode) {
+      inner.get.asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+
+}
+
+object CsrfDirectives extends CsrfDirectives

core/src/main/java/com/softwaremill/session/javadsl/HttpSessionAwareDirectives.java

@@ -0,0 +1,54 @@
+package com.softwaremill.session.javadsl;
+
+import akka.http.javadsl.server.AllDirectives;
+import akka.http.javadsl.server.Route;
+import com.softwaremill.session.CsrfCheckMode;
+import com.softwaremill.session.SessionContinuity;
+import com.softwaremill.session.SessionManager;
+import com.softwaremill.session.SetSessionTransport;
+import scala.Option;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class HttpSessionAwareDirectives<T> extends AllDirectives {
+
+    private final SessionManager<T> sessionManager;
+
+    public HttpSessionAwareDirectives(SessionManager<T> sessionManager) {
+        this.sessionManager = sessionManager;
+    }
+
+
+    public Route setSession(SessionContinuity sc, SetSessionTransport st, T session, Supplier<Route> continuity) {
+        return SessionDirectives$.MODULE$.setSession(sc, st, session, continuity);
+    }
+
+    public Route optionalSession(SessionContinuity sc, SetSessionTransport st, Function<Option<T>, Route> continuity) {
+        return SessionDirectives$.MODULE$.optionalSession(sc, st, continuity);
+    }
+
+    public Route requiredSession(SessionContinuity<T> sc, SetSessionTransport st, Function<T, Route> continuity) {
+        return SessionDirectives$.MODULE$.requiredSession(sc, st, continuity);
+    }
+
+    public Route touchRequiredSession(SessionContinuity<T> sc, SetSessionTransport st, Function<T, Route> continuity) {
+        return SessionDirectives$.MODULE$.touchRequiredSession(sc, st, continuity);
+    }
+
+    public Route invalidateSession(SessionContinuity<T> sc, SetSessionTransport st, Supplier<Route> continuity) {
+        return SessionDirectives$.MODULE$.invalidateSession(sc, st, continuity);
+    }
+
+    public Route setNewCsrfToken(CsrfCheckMode<T> checkHeader, Supplier<Route> continuity) {
+        return CsrfDirectives$.MODULE$.setNewCsrfToken(checkHeader, continuity);
+    }
+
+    public Route randomTokenCsrfProtection(CsrfCheckMode<T> checkHeader, Supplier<Route> continuity) {
+        return CsrfDirectives$.MODULE$.randomTokenCsrfProtection(checkHeader, continuity);
+    }
+
+    public SessionManager<T> getSessionManager() {
+        return sessionManager;
+    }
+}

core/src/main/java/com/softwaremill/session/javadsl/InMemoryRefreshTokenStorage.scala

@@ -0,0 +1,7 @@
+package com.softwaremill.session.javadsl
+
+/**
+ * Can't use the trait com.softwaremill.session.InMemoryRefreshTokenStorage in Java code, hence this wrapper
+ * http://stackoverflow.com/questions/7637752/using-scala-traits-with-implemented-methods-in-java
+ */
+abstract class InMemoryRefreshTokenStorage[T]() extends com.softwaremill.session.InMemoryRefreshTokenStorage[T]

core/src/main/java/com/softwaremill/session/javadsl/SessionDirectives.scala

@@ -0,0 +1,47 @@
+package com.softwaremill.session.javadsl
+
+import java.util.function.Supplier
+
+import akka.http.javadsl.server.Route
+import akka.http.javadsl.server.directives.RouteAdapter
+import com.softwaremill.session._
+
+/**
+  * Java alternative for  com.softwaremill.session.SessionDirectives
+  */
+trait SessionDirectives extends OneOffSessionDirectives with RefreshableSessionDirectives {
+
+  def setSession[T](sc: SessionContinuity[T], st: SetSessionTransport, v: T, inner: Supplier[Route]): Route = RouteAdapter {
+    com.softwaremill.session.SessionDirectives.setSession(sc, st, v) {
+      inner.get.asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+  def invalidateSession[T](sc: SessionContinuity[T], st: GetSessionTransport, inner: Supplier[Route]): Route = RouteAdapter {
+    com.softwaremill.session.SessionDirectives.invalidateSession(sc, st) {
+      inner.get.asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+  def optionalSession[T](sc: SessionContinuity[T], st: GetSessionTransport, inner: java.util.function.Function[Option[T], Route]): Route = RouteAdapter {
+    com.softwaremill.session.SessionDirectives.optionalSession(sc, st) { session =>
+      inner.apply(session).asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+  def requiredSession[T](sc: SessionContinuity[T], st: GetSessionTransport, inner: java.util.function.Function[T, Route]): Route = RouteAdapter {
+    com.softwaremill.session.SessionDirectives.requiredSession(sc, st) { session =>
+      inner.apply(session).asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+  def touchRequiredSession[T](sc: SessionContinuity[T], st: GetSessionTransport, inner: java.util.function.Function[T, Route]): Route = RouteAdapter {
+    com.softwaremill.session.SessionDirectives.touchRequiredSession(sc, st) { session =>
+      inner.apply(session).asInstanceOf[RouteAdapter].delegate
+    }
+  }
+
+}
+
+object SessionDirectives extends SessionDirectives
+

core/src/main/java/com/softwaremill/session/javadsl/SessionSerializers.java

@@ -0,0 +1,22 @@
+package com.softwaremill.session.javadsl;
+
+import com.softwaremill.session.SessionSerializer;
+import com.softwaremill.session.SessionSerializer$;
+import scala.collection.immutable.Map;
+
+/**
+ * Wrapper for session serializers in com.softwaremill.session.SessionSerializer
+ */
+public final class SessionSerializers {
+
+    public static final SessionSerializer<String, String> StringToStringSessionSerializer = SessionSerializer$.MODULE$.stringToStringSessionSerializer();
+    public static final SessionSerializer<Integer, String> IntToStringSessionSerializer = (SessionSerializer<Integer, String>) (SessionSerializer) SessionSerializer$.MODULE$.intToStringSessionSerializer();
+    public static final SessionSerializer<Long, String> LongToStringSessionSerializer = (SessionSerializer<Long, String>) (SessionSerializer) SessionSerializer$.MODULE$.longToStringSessionSerializer();
+    public static final SessionSerializer<Float, String> FloatToStringSessionSerializer = (SessionSerializer<Float, String>) (SessionSerializer) SessionSerializer$.MODULE$.floatToStringSessionSerializer();
+    public static final SessionSerializer<Double, String> DoubleToStringSessionSerializer = (SessionSerializer<Double, String>) (SessionSerializer) SessionSerializer$.MODULE$.doubleToStringSessionSerializer();
+    public static final SessionSerializer<Map<String, String>, String> MapToStringSessionSerializer = SessionSerializer$.MODULE$.mapToStringSessionSerializer();
+
+    private SessionSerializers() {
+    }
+
+}

core/src/main/java/com/softwaremill/session/javadsl/SessionTransports.java

@@ -0,0 +1,18 @@
+package com.softwaremill.session.javadsl;
+
+import com.softwaremill.session.CookieST$;
+import com.softwaremill.session.HeaderST$;
+import com.softwaremill.session.SetSessionTransport;
+
+/**
+ * Wrapper for session transports in com.softwaremill.session.SetSessionTransport
+ */
+public final class SessionTransports {
+
+    public static final SetSessionTransport CookieST = CookieST$.MODULE$;
+    public static final SetSessionTransport HeaderST = HeaderST$.MODULE$;
+
+    private SessionTransports() {
+    }
+
+}

core/src/main/scala/com/softwaremill/session/CsrfDirectives.scala

@@ -1,7 +1,7 @@
 package com.softwaremill.session
 
-import akka.http.scaladsl.server.{Directive1, Directive0}
 import akka.http.scaladsl.server.Directives._
+import akka.http.scaladsl.server.{Directive0, Directive1}
 import akka.stream.Materializer
 
 trait CsrfDirectives {

core/src/main/scala/com/softwaremill/session/RefreshTokenStorage.scala

@@ -66,4 +66,4 @@ trait InMemoryRefreshTokenStorage[T] extends RefreshTokenStorage[T] {
   }
 
   def log(msg: String): Unit
-}
+}

core/src/main/scala/com/softwaremill/session/SessionConfig.scala

@@ -112,6 +112,8 @@ object SessionConfig {
   /**
    * Creates a default configuration using the given secret.
    */
-  def default(serverSecret: String) = fromConfig(ConfigFactory.load()
+  def default(serverSecret: String): SessionConfig = fromConfig(ConfigFactory.load()
     .withValue("akka.http.session.server-secret", ConfigValueFactory.fromAnyRef(serverSecret)))
+
+  def defaultConfig(serverSecret: String): SessionConfig = default(serverSecret) // required for javadsl directives, because default is a keyword
 }

core/src/main/scala/com/softwaremill/session/SessionDirectives.scala

@@ -1,7 +1,7 @@
 package com.softwaremill.session
 
-import akka.http.scaladsl.server.{Directive1, Directive0}
 import akka.http.scaladsl.server.Directives._
+import akka.http.scaladsl.server.{Directive0, Directive1}
 
 import scala.concurrent.ExecutionContext
 
@@ -80,6 +80,7 @@ trait SessionDirectives extends OneOffSessionDirectives with RefreshableSessionD
   def touchRequiredSession[T](sc: SessionContinuity[T], st: GetSessionTransport): Directive1[T] = {
     requiredSession(sc, st).flatMap { d => setOneOffSessionSameTransport(sc, st, d) & provide(d) }
   }
+
 }
 
 object SessionDirectives extends SessionDirectives