Homec4science
Diffusion SHRINE MedCo Fork (release/1.23.1) Browse

shrine-medco/apps/dashboard-app/src/main/scala/net/shrine/dashboard/DashboardService.scala
de257c0aaederelease/1.23.1

Last Change
Raw File

DashboardService.scala
View Options

package net.shrine.dashboard
import akka.actor.Actor
import akka.event.Logging
import net.shrine.authentication.UserAuthenticator
import net.shrine.authorization.steward.OutboundUser
import net.shrine.dashboard.jwtauth.ShrineJwtAuthenticator
import net.shrine.i2b2.protocol.pm.User
import net.shrine.status.protocol.{Config => StatusProtocolConfig}
import net.shrine.dashboard.httpclient.HttpClientDirectives.{forwardUnmatchedPath, requestUriThenRoute}
import net.shrine.log.Loggable
import shapeless.HNil
import spray.http.{HttpRequest, HttpResponse, StatusCodes, Uri}
import spray.httpx.Json4sSupport
import spray.routing.directives.LogEntry
import spray.routing.{AuthenticationFailedRejection, Directive0, HttpService, Rejected, Route, RouteConcatenation}
import org.json4s.{DefaultFormats, Formats}
import org.json4s.native.JsonMethods.{parse => json4sParse}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.xml.Elem
/**
* Mixes the DashboardService trait with an Akka Actor to provide the actual service.
*/
class DashboardServiceActor extends Actor with DashboardService {
// the HttpService trait defines only one abstract member, which
// connects the services environment to the enclosing actor or test
def actorRefFactory = context
// this actor only runs our route, but you could add
// other things here, like request stream processing
// or timeout handling
def receive = runRoute(route)
}
/**
* A web service that provides the Dashboard endpoints. It is a trait to support testing independent of Akka.
*/
trait DashboardService extends HttpService with Json4sSupport with Loggable {
implicit def json4sFormats: Formats = DefaultFormats
val userAuthenticator = UserAuthenticator(DashboardConfigSource.config)
//don't need to do anything special for unauthorized users, but they do need access to a static form.
lazy val route:Route = gruntWatchCorsSupport{
redirectToIndex ~ staticResources ~ makeTrouble ~ about ~ authenticatedInBrowser ~ authenticatedDashboard
}
/** logs the request method, uri and response at info level */
def logEntryForRequestResponse(req: HttpRequest): Any => Option[LogEntry] = {
case res: HttpResponse => Some(LogEntry(s"\n Request: $req\n Response: $res", Logging.InfoLevel))
case _ => None // other kind of responses
}
/** logs just the request method, uri and response status at info level */
def logEntryForRequest(req: HttpRequest): Any => Option[LogEntry] = {
case res: HttpResponse => Some(LogEntry(s"\n Request: $req\n Response status: ${res.status}", Logging.InfoLevel))
case _ => None // other kind of responses
}
def authenticatedInBrowser: Route = pathPrefixTest("user"|"admin"|"toDashboard") {
logRequestResponse(logEntryForRequestResponse _) { //logging is controlled by Akka's config, slf4j, and log4j config
reportIfFailedToAuthenticate {
authenticate(userAuthenticator.basicUserAuthenticator) { user =>
pathPrefix("user") {
userRoute(user)
} ~
pathPrefix("admin") {
adminRoute(user)
} ~
pathPrefix("toDashboard") {
toDashboardRoute(user)
}
}
}
}
}
val reportIfFailedToAuthenticate = routeRouteResponse {
case Rejected(List(AuthenticationFailedRejection(_,_))) =>
complete("AuthenticationFailed")
}
def authenticatedDashboard:Route = pathPrefix("fromDashboard") {
logRequestResponse(logEntryForRequestResponse _) { //logging is controlled by Akka's config, slf4j, and log4j config
get { //all remote dashboard calls are gets.
authenticate(ShrineJwtAuthenticator.authenticate) { user =>
adminRoute(user)
}
}
}
}
def makeTrouble = pathPrefix("makeTrouble") {
complete(throw new IllegalStateException("fake trouble"))
}
lazy val redirectToIndex = pathEnd {
redirect("shrine-dashboard/client/index.html", StatusCodes.PermanentRedirect) //todo pick up "shrine-dashboard" programatically
} ~
( path("index.html") | pathSingleSlash) {
redirect("client/index.html", StatusCodes.PermanentRedirect)
}
lazy val staticResources = pathPrefix("client") {
pathEnd {
redirect("client/index.html", StatusCodes.PermanentRedirect)
} ~
pathSingleSlash {
redirect("index.html", StatusCodes.PermanentRedirect)
} ~ {
getFromResourceDirectory("client")
}
}
lazy val about = pathPrefix("about") {
complete("Nothing here yet") //todo
}
def userRoute(user:User):Route = get {
pathPrefix("whoami") {
complete(OutboundUser.createFromUser(user))
}
}
//todo check that this an admin.
def adminRoute(user:User):Route = get {
pathPrefix("happy") {
val happyBaseUrl: String = DashboardConfigSource.config.getString("shrine.dashboard.happyBaseUrl")
forwardUnmatchedPath(happyBaseUrl)
} ~
pathPrefix("messWithHappyVersion") { //todo is this used?
val happyBaseUrl: String = DashboardConfigSource.config.getString("shrine.dashboard.happyBaseUrl")
def pullClasspathFromConfig(httpResponse:HttpResponse,uri:Uri):Route = {
ctx => {
val result = httpResponse.entity.asString
ctx.complete(s"Got '$result' from $uri")
}
}
requestUriThenRoute(happyBaseUrl+"/version",pullClasspathFromConfig)
} ~
pathPrefix("ping") {complete("pong")}~
pathPrefix("status"){statusRoute(user)}
}
//Manually test this by running a curl command
//curl -k -w "\n%{response_code}\n" -u dave:kablam "https://shrine-dev1.catalyst:6443/shrine-dashboard/toDashboard/shrine-dev2.catalyst/shrine-dashboard/fromDashboard/ping"
/**
* Forward a request from this dashboard to a remote dashboard
*/
def toDashboardRoute(user:User):Route = get {
pathPrefix(Segment) { dnsName =>
val remoteDashboardProtocol = DashboardConfigSource.config.getString("shrine.dashboard.remoteDashboard.protocol")
val remoteDashboardPort = DashboardConfigSource.config.getString("shrine.dashboard.remoteDashboard.port")
val remoteDashboardPathPrefix = DashboardConfigSource.config.getString("shrine.dashboard.remoteDashboard.pathPrefix")
val baseUrl = s"$remoteDashboardProtocol$dnsName$remoteDashboardPort/$remoteDashboardPathPrefix"
forwardUnmatchedPath(baseUrl,Some(ShrineJwtAuthenticator.createOAuthCredentials(user)))
}
}
def statusRoute(user:User):Route = get {
pathPrefix("config"){getConfig}~
pathPrefix("classpath"){getClasspath}~
pathPrefix("options"){getOptions}~
pathPrefix("summary"){getSummary}
}
val statusBaseUrl = DashboardConfigSource.config.getString("shrine.dashboard.statusBaseUrl")
lazy val getConfig:Route = {
def completeSummaryRoute(httpResponse:HttpResponse,uri:Uri):Route = {
ctx => {
val config = ConfigParser(httpResponse.entity.asString)
ctx.complete(
ShrineConfig(config)
)
}
}
requestUriThenRoute(statusBaseUrl + "/config", completeSummaryRoute)
}
lazy val getClasspath:Route = {
def pullClasspathFromConfig(httpResponse:HttpResponse,uri:Uri):Route = {
ctx => {
val result = httpResponse.entity.asString
val shrineConfig = ShrineConfig(ConfigParser(result))
ctx.complete(shrineConfig)
}
}
requestUriThenRoute(statusBaseUrl + "/config",pullClasspathFromConfig)
}
lazy val getOptions:Route = {
def completeSummaryRoute(httpResponse:HttpResponse,uri:Uri):Route = {
ctx => {
val config = ConfigParser(httpResponse.entity.asString)
ctx.complete(
Options(config)
)
}
}
requestUriThenRoute(statusBaseUrl + "/config", completeSummaryRoute)
}
//todo this is the Happy summary. Rename, eventually delete when the status service can provide the same
lazy val getSummary:Route = {
val happyBaseUrl: String = DashboardConfigSource.config.getString("shrine.dashboard.happyBaseUrl")
def pullSummaryFromHappy(httpResponse:HttpResponse,uri:Uri):Route = {
ctx => {
val result: Elem = scala.xml.XML.loadString(httpResponse.entity.asString)
val isHub: Boolean = (result \\ "notAHub").text.length == 0
val shrineVersion = (result \\ "versionInfo" \ "shrineVersion").text
val shrineBuildDate = (result \\ "versionInfo" \ "buildDate").text
val ontologyVersion = (result \\ "versionInfo" \ "ontologyVersion").text
val ontologyTerm = (result \\ "adapter" \\ "queryDefinition" \\ "term").text
val hubOk = {
if(!isHub) true
else {
val hasFailures = (result \\ "net" \ "failureCount").text.toInt > 0
val hasInvalidResults = (result \\ "net" \ "validResultCount").text.toInt != (result \\ "net" \ "expectedResultCount").text.toInt
val hasTimeouts = (result \\ "net" \ "timeoutCount").text.toInt > 0
!hasFailures && !hasInvalidResults && !hasTimeouts
}
}
val adapterOk = (result \\ "adapter" \\ "errorResponse").length == 0
val keystoreOk = true
val qepOk = true
val summary = Summary(
isHub = isHub,
shrineVersion = shrineVersion,
shrineBuildDate = shrineBuildDate,
ontologyVersion = ontologyVersion,
ontologyTerm = ontologyTerm,
adapterOk = adapterOk,
keystoreOk = keystoreOk,
hubOk = hubOk,
qepOk = qepOk
)
ctx.complete(summary)
}
}
requestUriThenRoute(happyBaseUrl+"/all", pullSummaryFromHappy)
}
}
case class Summary(
isHub:Boolean,
shrineVersion:String,
shrineBuildDate:String,
ontologyVersion:String,
ontologyTerm:String,
adapterOk:Boolean,
keystoreOk:Boolean,
hubOk:Boolean,
qepOk:Boolean
)
/**
* Centralized parsing logic for map of shrine.conf
* the class literal `T.class` in Java.
*/
//todo this thing is ShrineConfig's apply method. Move it all there and get rid of this mess
//todo this class' crap is spread out everywhere. Clean it all up.
case class ConfigParser(shrineMap:Map[String, String]){
private val trueVal = "true"
private val rootKey = "shrine"
def IsHub =
getOrElse(rootKey + ".hub.create", "")
.toLowerCase == trueVal
// -- -- //
def StewardEnabled =
shrineMap.keySet
.contains(rootKey + ".queryEntryPoint.shrineSteward")
// -- -- //
def ShouldQuerySelf =
getOrElse(rootKey + ".hub.shouldQuerySelf", "")
.toLowerCase == trueVal
// -- -- //
def DownstreamNodes =
for((k,v) <- shrineMap.filterKeys(_.toLowerCase.startsWith
("shrine.hub.downstreamnodes"))) yield DownstreamNode(k.split('.').last,
v.split("\"").mkString(""))
// -- -- //
def fromJsonString(jsonString:String) = jsonString.split("\"").mkString("")
def get(key:String) = shrineMap.get(key).map(fromJsonString)
def getOrElse(key:String, elseVal:String = "") = get(key).getOrElse(elseVal)
}
object ConfigParser {
def apply(jsonString:String):ConfigParser = {
// -- needed to use json4s parse -- //
implicit def json4sFormats: Formats = DefaultFormats
ConfigParser(json4sParse(jsonString).extract[StatusProtocolConfig].keyValues
.filterKeys(_.toLowerCase.startsWith("shrine")))
}
}
case class DownstreamNode(name:String, url:String){
}
//todo this is filling for the dashboard Summary - major components of shrine, and downstream nodes for a hub. Rename
case class Options(isHub:Boolean, stewardEnabled:Boolean, shouldQuerySelf:Boolean,
downstreamNodes:Iterable[DownstreamNode])
object Options{
def apply(parsedConfig:ConfigParser):Options ={
val isHub = parsedConfig.IsHub
val stewardEnabled = parsedConfig.StewardEnabled
val shouldQuerySelf = parsedConfig.ShouldQuerySelf
val downstreamNodes = parsedConfig.DownstreamNodes
Options(isHub, stewardEnabled, shouldQuerySelf, downstreamNodes)
}
}
//todo replace with the actual config, scrubbed of passwords
case class ShrineConfig(isHub:Boolean,
hub:Hub,
pmEndpoint:Endpoint,
ontEndpoint:Endpoint,
hiveCredentials: HiveCredentials,
adapter: Adapter,
queryEntryPoint:QEP,
networkStatusQuery:String
)
object ShrineConfig{
def apply(config:ConfigParser):ShrineConfig = {
val hub = Hub(config)
val isHub = config.IsHub
val pmEndpoint = Endpoint("pm",config)
val ontEndpoint = Endpoint("ont",config)
val hiveCredentials = HiveCredentials(config)
val adapter = Adapter(config)
val queryEntryPoint = QEP(config)
val networkStatusQuery = config.shrineMap("shrine.networkStatusQuery")
ShrineConfig(isHub, hub, pmEndpoint, ontEndpoint, hiveCredentials, adapter, queryEntryPoint, networkStatusQuery)
}
}
case class Endpoint(acceptAllCerts:Boolean, url:String, timeoutSeconds:Int)
object Endpoint{
def apply(endpointType:String,parsedConfig:ConfigParser):Endpoint = {
val prefix = "shrine." + endpointType.toLowerCase + "Endpoint."
val acceptAllCerts = parsedConfig.shrineMap.getOrElse(prefix + "acceptAllCerts", "") == "true"
val url = parsedConfig.shrineMap.getOrElse(prefix + "url","")
val timeoutSeconds = parsedConfig.shrineMap.getOrElse(prefix + "timeout.seconds", "0").toInt
Endpoint(acceptAllCerts, url, timeoutSeconds)
}
}
case class HiveCredentials(domain:String, username:String, password:String,
crcProjectId:String, ontProjectId:String)
object HiveCredentials{
def apply(parsedConfig:ConfigParser):HiveCredentials = {
val key = "shrine.hiveCredentials."
val domain = parsedConfig.shrineMap.getOrElse(key + "domain","")
val username = parsedConfig.shrineMap.getOrElse(key + "username","")
val password = "REDACTED"
val crcProjectId = parsedConfig.shrineMap.getOrElse(key + "crcProjectId","")
val ontProjectId = parsedConfig.shrineMap.getOrElse(key + "ontProjectId","")
HiveCredentials(domain, username, password, crcProjectId, ontProjectId)
}
}
// -- hub only -- //
case class Hub(shouldQuerySelf:Boolean, create:Boolean,
downstreamNodes:Iterable[DownstreamNode])
object Hub{
def apply(parsedConfig:ConfigParser):Hub = {
val shouldQuerySelf = parsedConfig.ShouldQuerySelf
val create = parsedConfig.IsHub
val downstreamNodes = parsedConfig.DownstreamNodes
Hub(shouldQuerySelf, create, downstreamNodes)
}
}
// -- adapter info -- //
case class Adapter(crcEndpointUrl:String, setSizeObfuscation:Boolean, adapterLockoutAttemptsThreshold:Int,
adapterMappingsFilename:String)
object Adapter{
def apply(parsedConfig:ConfigParser):Adapter = {
val key = "shrine.adapter."
val crcEndpointUrl = parsedConfig.shrineMap.getOrElse(key + "crcEndpoint.url","")
val setSizeObfuscation = parsedConfig.shrineMap.getOrElse(key + "setSizeObfuscation","").toLowerCase == "true"
val adapterLockoutAttemptsThreshold = parsedConfig.shrineMap.getOrElse(key + "adapterLockoutAttemptsThreshold", "0").toInt
val adapterMappingsFileName = parsedConfig.shrineMap.getOrElse(key + "adapterMappingsFileName","")
Adapter(crcEndpointUrl, setSizeObfuscation, adapterLockoutAttemptsThreshold, adapterMappingsFileName)
}
}
case class Steward(qepUserName:String, stewardBaseUrl:String)
object Steward {
def apply (parsedConfig:ConfigParser):Steward = {
val key = "shrine.queryEntryPoint.shrineSteward."
val qepUserName = parsedConfig.shrineMap.getOrElse(key + "qepUserName","")
val stewardBaseUrl = parsedConfig.shrineMap.getOrElse(key + "stewardBaseUrl","")
Steward(qepUserName, stewardBaseUrl)
}
}
// -- if needed -- //
case class TimeoutInfo (timeUnit:String, description:String)
case class DatabaseInfo(createTablesOnStart:Boolean, dataSourceFrom:String,
jndiDataSourceName:String, slickProfileClassName:String)
case class Audit(database:DatabaseInfo, collectQepAudit:Boolean)
object Audit{
def apply(parsedConfig:ConfigParser):Audit = {
val key = "shrine.queryEntryPoint.audit."
val createTablesOnStart = parsedConfig.shrineMap.getOrElse(key + "database.createTablesOnStart","") == "true"
val dataSourceFrom = parsedConfig.shrineMap.getOrElse(key + "database.dataSourceFrom","")
val jndiDataSourceName = parsedConfig.shrineMap.getOrElse(key + "database.jndiDataSourceName","")
val slickProfileClassName = parsedConfig.shrineMap.getOrElse(key + "database.slickProfileClassName","")
val collectQepAudit = parsedConfig.shrineMap.getOrElse(key + "collectQepAudit","") == "true"
val database = DatabaseInfo(createTablesOnStart, dataSourceFrom, jndiDataSourceName, slickProfileClassName)
Audit(database, collectQepAudit)
}
}
case class QEP(
maxQueryWaitTimeMinutes:Int,
create:Boolean,
attachSigningCert:Boolean,
authorizationType:String,
includeAggregateResults:Boolean,
authenticationType:String,
audit:Audit,
shrineSteward:Steward,
broadcasterServiceEndpointUrl:Option[String]
)
object QEP{
val key = "shrine.queryEntryPoint."
def apply(parsedConfig:ConfigParser):QEP = QEP(
maxQueryWaitTimeMinutes = parsedConfig.shrineMap.getOrElse(key + "maxQueryWaitTime.minutes", "0").toInt,
create = parsedConfig.shrineMap.getOrElse(key + "create","") == "true",
attachSigningCert = parsedConfig.shrineMap.getOrElse(key + "attachSigningCert","") == "true",
authorizationType = parsedConfig.shrineMap.getOrElse(key + "authorizationType",""),
includeAggregateResults = parsedConfig.shrineMap.getOrElse(key + "includeAggregateResults","") == "true",
authenticationType = parsedConfig.shrineMap.getOrElse(key + "authenticationType", ""),
audit = Audit(parsedConfig),
shrineSteward = Steward(parsedConfig),
broadcasterServiceEndpointUrl = parsedConfig.shrineMap.get(key + "broadcasterServiceEndpoint.url")
)
}
//adapted from https://gist.github.com/joseraya/176821d856b43b1cfe19
object gruntWatchCorsSupport extends Directive0 with RouteConcatenation {
import spray.http.HttpHeaders.{`Access-Control-Allow-Methods`, `Access-Control-Max-Age`, `Access-Control-Allow-Headers`,`Access-Control-Allow-Origin`}
import spray.routing.directives.RespondWithDirectives.respondWithHeaders
import spray.routing.directives.MethodDirectives.options
import spray.routing.directives.RouteDirectives.complete
import spray.http.HttpMethods.{OPTIONS,GET,POST}
import spray.http.AllOrigins
private val allowOriginHeader = `Access-Control-Allow-Origin`(AllOrigins)
private val optionsCorsHeaders = List(
`Access-Control-Allow-Headers`("Origin, X-Requested-With, Content-Type, Accept, Accept-Encoding, Accept-Language, Host, Referer, User-Agent, Authorization"),
`Access-Control-Max-Age`(1728000)) //20 days
val gruntWatch:Boolean = DashboardConfigSource.config.getBoolean("shrine.dashboard.gruntWatch")
override def happly(f: (HNil) => Route): Route = {
if(gruntWatch) {
options {
respondWithHeaders(`Access-Control-Allow-Methods`(OPTIONS, GET, POST) :: allowOriginHeader :: optionsCorsHeaders){
complete(StatusCodes.OK)
}
} ~ f(HNil)
}
else f(HNil)
}
}
c4science · Help