v4.0.0

V4

local-runner/runFor.sh → .bin/runFor.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-NAME="Dark Lord Toni"
+NAME="Development"
 REMOVE=0
 
 RED='\033[0;31m'

local-runner/runForDoc.md → .bin/runForDoc.md

@@ -4,7 +4,7 @@ The runFor.sh Script will start a Docker Postgis Container with [docker-compose.
 
 The Postgis data volume will be mounted to: 
 
-- __local-runner/postgis-volume__ 
+- __.bin/postgis-volume__ 
 
 so that even if the container is deleted no data will be lost!
 

.bsp/sbt.json

@@ -1 +1 @@
-{"name":"sbt","version":"1.4.4","bspVersion":"2.0.0-M5","languages":["scala"],"argv":["/Applications/IntelliJ IDEA.app/Contents/jbr/Contents/Home/bin/java","-Xms100m","-Xmx100m","-classpath","/Users/patrickstadler/Library/Application Support/JetBrains/IntelliJIdea2020.3/plugins/Scala/launcher/sbt-launch.jar","xsbt.boot.Boot","-bsp"]}
+{"name":"sbt","version":"1.5.0","bspVersion":"2.0.0-M5","languages":["scala"],"argv":["/Applications/IntelliJ IDEA.app/Contents/jbr/Contents/Home/bin/java","-Xms100m","-Xmx100m","-classpath","/Users/patrickstadler/Library/Application Support/JetBrains/IntelliJIdea2020.3/plugins/Scala/launcher/sbt-launch.jar","xsbt.boot.Boot","-bsp","--sbt-launch-jar=/Users/patrickstadler/Library/Application%20Support/JetBrains/IntelliJIdea2020.3/plugins/Scala/launcher/sbt-launch.jar"]}

.gitignore

@@ -34,7 +34,6 @@ server.pid
 *.eml
 /dist/
 
-
 test.mv.db
 
 #Firebase
@@ -49,10 +48,12 @@ pubSub-dev.json
 .circleci/k8sdeploy.yaml-e
 .metals/*
 
+.bsp/*
+
 #puml
 out/doc
 
 .DS_Store
 
-local-runner/postgis-volume
+.bin/postgis-volume
 .bloop/

app/Module.scala

@@ -1,17 +1,27 @@
-import java.util.Properties
+import com.google.auth.Credentials
+import com.google.auth.oauth2.GoogleCredentials
 
+import java.util.Properties
 import javax.inject.{ Inject, Provider, Singleton }
 import com.typesafe.config.Config
 import play.api.inject.ApplicationLifecycle
 import play.api.{ Configuration, Environment, Logger, Mode }
 import slick.jdbc.JdbcBackend.Database
 import com.google.inject.AbstractModule
 import de.innfactory.auth.firebase.FirebaseBase
+import de.innfactory.auth.firebase.FirebaseBase.getClass
 import de.innfactory.auth.firebase.validator.{ JWTValidatorMock, JwtValidator, JwtValidatorImpl }
 import de.innfactory.bootstrapplay2.db.{ CompaniesDAO, LocationsDAO }
 import de.innfactory.play.flyway.FlywayMigrator
+import io.opencensus.exporter.trace.jaeger.{ JaegerExporterConfiguration, JaegerTraceExporter }
+import io.opencensus.exporter.trace.logging.LoggingTraceExporter
+import io.opencensus.exporter.trace.stackdriver.{ StackdriverTraceConfiguration, StackdriverTraceExporter }
+import io.opencensus.trace.AttributeValue
 import play.api.libs.concurrent.AkkaGuiceSupport
+
+import java.io.InputStream
 import scala.concurrent.Future
+import scala.jdk.CollectionConverters.MapHasAsJava
 
 /**
  * This module handles the bindings for the API to the Slick implementation.
@@ -24,30 +34,97 @@ class Module(environment: Environment, configuration: Configuration) extends Abs
 
  override def configure(): Unit = {
  logger.info(s"Configuring ${environment.mode}")
+
  bind(classOf[Database]).toProvider(classOf[DatabaseProvider])
- bind(classOf[firebaseCreationService]).asEagerSingleton()
- bind(classOf[firebaseDeletionService]).asEagerSingleton()
  bind(classOf[FlywayMigratorImpl]).asEagerSingleton()
- bind(classOf[LocationsDAOCloseHook]).asEagerSingleton()
- bind(classOf[CompaniesDAOCloseHook]).asEagerSingleton()
+ bind(classOf[DAOCloseHook]).asEagerSingleton()
 
  /**
  * Inject Modules depended on environment (Test, Prod, Dev)
  */
  if (environment.mode == Mode.Test) {
+
  logger.info(s"- - - Binding Services for for Test Mode - - -")
- bind(classOf[JwtValidator])
- .to(classOf[JWTValidatorMock]) // Bind Mock JWT Validator for Test Mode
+
+ // Bind Mock JWT Validator for Test Mode
+ bind(classOf[JwtValidator]).to(classOf[JWTValidatorMock])
+
+ } else if (environment.mode == Mode.Dev) {
+
+ logger.info(s"- - - Binding Services for for Dev Mode - - -")
+
+ // Firebase
+ bind(classOf[firebaseCreationService]).asEagerSingleton()
+ bind(classOf[firebaseDeletionService]).asEagerSingleton()
+
+ // Bind Prod JWT Validator for Prod/Dev Mode
+ bind(classOf[JwtValidator]).to(classOf[JwtValidatorImpl])
+
+ // Optional Jaeger Exporter bind(classOf[JaegerTracingCreator]).asEagerSingleton()
+
  } else {
- logger.info(s"- - - Binding Services for for Prod/Dev Mode - - -")
- bind(classOf[JwtValidator])
- .to(classOf[JwtValidatorImpl]) // Bind Prod JWT Validator for Prod/Dev Mode
+
+ logger.info(s"- - - Binding Services for for Prod Mode - - -")
+
+ bind(classOf[firebaseCreationService]).asEagerSingleton()
+ bind(classOf[firebaseDeletionService]).asEagerSingleton()
+
+ // Bind Prod JWT Validator for Prod/Dev Mode
+ bind(classOf[JwtValidator]).to(classOf[JwtValidatorImpl])
+
+ // Tracing
+ bind(classOf[StackdriverTracingCreator]).asEagerSingleton()
+ bind(classOf[LoggingTracingCreator]).asEagerSingleton()
+
  }
 
  }
 
 }
 
+@Singleton
+class LoggingTracingCreator @Inject() (lifecycle: ApplicationLifecycle) {
+ LoggingTraceExporter.register()
+ lifecycle.addStopHook { () =>
+ Future.successful(LoggingTraceExporter.unregister())
+ }
+}
+
+@Singleton
+class JaegerTracingCreator @Inject() (lifecycle: ApplicationLifecycle) {
+ val jaegerExporterConfiguration: JaegerExporterConfiguration = JaegerExporterConfiguration
+ .builder()
+ .setServiceName("bootstrap-play2")
+ .setThriftEndpoint("http://127.0.0.1:14268/api/traces")
+ .build()
+ JaegerTraceExporter.createAndRegister(jaegerExporterConfiguration)
+
+ lifecycle.addStopHook { () =>
+ Future.successful(JaegerTraceExporter.unregister())
+ }
+}
+
+@Singleton
+class StackdriverTracingCreator @Inject() (lifecycle: ApplicationLifecycle, config: Config) {
+ val serviceAccount: InputStream = getClass.getClassLoader.getResourceAsStream(config.getString("firebase.file"))
+ val credentials: GoogleCredentials = GoogleCredentials.fromStream(serviceAccount)
+ val stackDriverTraceExporterConfig: StackdriverTraceConfiguration = StackdriverTraceConfiguration
+ .builder()
+ .setProjectId(config.getString("project.id"))
+ .setCredentials(credentials)
+ .setFixedAttributes(
+ Map(
+ ("/component", AttributeValue.stringAttributeValue("PlayServer"))
+ ).asJava
+ )
+ .build()
+
+ StackdriverTraceExporter.createAndRegister(stackDriverTraceExporterConfig)
+ lifecycle.addStopHook { () =>
+ Future.successful(StackdriverTraceExporter.unregister())
+ }
+}
+
 /** Migrate Flyway on application start */
 class FlywayMigratorImpl @Inject() (env: Environment, configuration: Configuration)
  extends FlywayMigrator(configuration, env, configIdentifier = "bootstrap-play2")
@@ -72,15 +149,11 @@ class DatabaseProvider @Inject() (config: Config) extends Provider[Database] {
 }
 
 /** Closes DAO. Important on dev restart. */
-class CompaniesDAOCloseHook @Inject() (dao: CompaniesDAO, lifecycle: ApplicationLifecycle) {
- lifecycle.addStopHook { () =>
- Future.successful(dao.close())
- }
-}
-
-/** Closes DAO. Important on dev restart. */
-class LocationsDAOCloseHook @Inject() (dao: LocationsDAO, lifecycle: ApplicationLifecycle) {
+class DAOCloseHook @Inject() (companiesDAO: CompaniesDAO, locationsDAO: LocationsDAO, lifecycle: ApplicationLifecycle) {
  lifecycle.addStopHook { () =>
- Future.successful(dao.close())
+ Future.successful({
+ companiesDAO.close()
+ locationsDAO.close()
+ })
  }
 }

app/de/innfactory/bootstrapplay2/actions/CompanyForUserExtractAction.scala

@@ -1,35 +1,61 @@
 package de.innfactory.bootstrapplay2.actions
 
+import cats.implicits.catsSyntaxEitherId
 import com.google.inject.Inject
 import de.innfactory.bootstrapplay2.common.authorization.FirebaseEmailExtractor
+import de.innfactory.bootstrapplay2.common.request.TraceContext
+import de.innfactory.bootstrapplay2.common.results.ErrorResponse
 import de.innfactory.bootstrapplay2.db.CompaniesDAO
 import de.innfactory.bootstrapplay2.models.api.Company
-import play.api.mvc.{ ActionBuilder, ActionTransformer, AnyContent, BodyParsers, Request, WrappedRequest }
+import de.innfactory.play.tracing.{ RequestWithTrace, TraceRequest, UserExtractionActionBase }
+import io.opencensus.trace.Span
+import play.api.Environment
+import play.api.mvc.Results.Forbidden
+import play.api.mvc.{ BodyParsers, Request, Result, WrappedRequest }
 
 import scala.concurrent.{ ExecutionContext, Future }
 
-class RequestWithCompany[A](val company: Option[Company], val email: Option[String], request: Request[A])
- extends WrappedRequest[A](request)
+class RequestWithCompany[A](
+ val company: Company,
+ val email: Option[String],
+ val request: Request[A],
+ val traceSpan: Span
+) extends WrappedRequest[A](request)
+ with TraceRequest[A]
 
 class CompanyForUserExtractAction @Inject() (
- val parser: BodyParsers.Default,
  companiesDAO: CompaniesDAO,
  firebaseEmailExtractor: FirebaseEmailExtractor[Any]
-)(implicit val executionContext: ExecutionContext)
- extends ActionBuilder[RequestWithCompany, AnyContent]
- with ActionTransformer[Request, RequestWithCompany] {
- def transform[A](request: Request[A]): Future[RequestWithCompany[A]] =
+)(implicit executionContext: ExecutionContext, parser: BodyParsers.Default, environment: Environment)
+ extends UserExtractionActionBase[RequestWithTrace, RequestWithCompany] {
+
+ override def extractUserAndCreateNewRequest[A](request: RequestWithTrace[A])(implicit
+ environment: Environment,
+ parser: BodyParsers.Default,
+ executionContext: ExecutionContext
+ ): Future[Either[Result, RequestWithCompany[A]]] =
  Future.successful {
  val result: Option[Future[Option[Company]]] = for {
  email <- firebaseEmailExtractor.extractEmail(request)
  } yield for {
- user <- companiesDAO.internal_lookupByEmail(email)
+ user <- companiesDAO.internal_lookupByEmail(email)(new TraceContext(request.traceSpan))
  } yield user
-
  result match {
  case Some(v) =>
- v.map(new RequestWithCompany(_, firebaseEmailExtractor.extractEmail(request), request))
- case None => Future(new RequestWithCompany(None, firebaseEmailExtractor.extractEmail(request), request))
+ v.map {
+ case Some(value) =>
+ new RequestWithCompany(
+ value,
+ firebaseEmailExtractor.extractEmail(request),
+ request.request,
+ request.traceSpan
+ ).asRight[Result]
+ case None => Forbidden(ErrorResponse.fromMessage("Forbidden")).asLeft[RequestWithCompany[A]]
+ }
+ case None =>
+ Future(
+ Forbidden(ErrorResponse.fromMessage("Forbidden")).asLeft[RequestWithCompany[A]]
+ )
  }
  }.flatten
 }

app/de/innfactory/bootstrapplay2/actions/JwtValidationAction.scala

@@ -1,56 +1,28 @@
 package de.innfactory.bootstrapplay2.actions
 
 import com.google.inject.Inject
-import com.nimbusds.jwt.proc.BadJWTException
-import de.innfactory.auth.firebase.validator.{ JwtToken, JwtValidator }
-import play.api.Environment
-import play.api.mvc.Results.Forbidden
-import play.api.mvc.Results.Unauthorized
+import de.innfactory.auth.firebase.validator.JwtValidator
+import de.innfactory.bootstrapplay2.common.implicits.JWT.JwtTokenGenerator
+import de.innfactory.play.tracing.{ BaseAuthHeaderRefineAction, RequestWithTrace }
+import play.api.mvc.BodyParsers
 
-import scala.concurrent.{ ExecutionContext, Future }
-import play.api.mvc._
+import scala.concurrent.ExecutionContext
 
-class JwtValidationAction @Inject() (parser: BodyParsers.Default, jwtValidator: JwtValidator, environment: Environment)(
- implicit ec: ExecutionContext
-) extends ActionBuilderImpl(parser) {
- override def invokeBlock[A](request: Request[A], block: (Request[A]) => Future[Result]) =
- if (extractAndCheckAuthHeader(request.headers).getOrElse(false))
- block(request)
- else if (request.headers.get("Authorization").isEmpty)
- Future.successful(Unauthorized("Unauthorized"))
- else
- Future.successful(Forbidden("Forbidden"))
+class JwtValidationAction @Inject() (
+ parser: BodyParsers.Default,
+ jwtValidator: JwtValidator
+)(implicit
+ ec: ExecutionContext
+) extends BaseAuthHeaderRefineAction[RequestWithTrace](parser) {
 
- /**
- * Extract auth header from requestHeaders
- * @param requestHeader
- * @return
- */
- def extractAndCheckAuthHeader(requestHeader: Headers) =
- for {
- header <- requestHeader.get("Authorization")
- } yield checkAuthHeader(header)
-
- /**
- * check and validate auth header
- * @param authHeader
- * @return
- */
- def checkAuthHeader(authHeader: String): Boolean =
- // In Test env, jwt will not be validated
- if (environment.mode.toString != "Test") {
- val jwtToken = authHeader match {
- case token: String if token.startsWith("Bearer") =>
- JwtToken(token.splitAt(7)._2)
- case token => JwtToken(token)
- }
-
- jwtValidator.validate(jwtToken) match {
- case Left(error: BadJWTException) =>
- false
- case Right(_) => true
- }
- } else
- true
+ override def checkAuthHeader(authHeader: String): Boolean = {
+ val jwtToken = authHeader.toJwtToken
+ val res = jwtValidator.validate(jwtToken) match {
+ case Left(_) => false
+ case Right(_) => true
+ }
+ println("Auth Header Check on " + authHeader + " " + res)
+ res
+ }
 
 }

app/de/innfactory/bootstrapplay2/actions/TracingCompanyAction.scala

@@ -0,0 +1,19 @@
+package de.innfactory.bootstrapplay2.actions
+
+import com.google.inject.Inject
+import de.innfactory.play.tracing.TracingAction
+import play.api.Environment
+import play.api.mvc._
+
+import scala.concurrent.ExecutionContext
+
+class TracingCompanyAction @Inject() (
+ val parser: BodyParsers.Default,
+ companyAction: CompanyForUserExtractAction,
+ jwtValidationAction: JwtValidationAction,
+ traceAction: TracingAction,
+ implicit val environment: Environment
+)(implicit val executionContext: ExecutionContext) {
+ def apply(traceString: String): ActionBuilder[RequestWithCompany, AnyContent] =
+ traceAction(traceString).andThen(jwtValidationAction).andThen(companyAction)
+}

app/de/innfactory/bootstrapplay2/actorsystem/services/HelloWorldService.scala

@@ -21,7 +21,7 @@ trait HelloWorldService {
 class HelloWorldServiceImpl @Inject() (
 )(implicit ec: ExecutionContext, system: ActorSystem)
  extends HelloWorldService {
- // asking someone requires a timeout if the timeout hits without response
+ //  // asking someone requires a timeout if the timeout hits without response
  // the ask is failed with a TimeoutException
  private implicit val timeout: Timeout = 10.seconds