diff --git a/apps/meta-app/src/test/resources/shrine.conf b/apps/meta-app/src/test/resources/shrine.conf
index ce3a42e59..26c9544b7 100644
--- a/apps/meta-app/src/test/resources/shrine.conf
+++ b/apps/meta-app/src/test/resources/shrine.conf
@@ -1,62 +1,62 @@
shrine {
humanReadableNodeName = "UnitTestNode"
messagequeue {
- implementation = "net.shrine.hornetqmom.LocalHornetQMom"
+ implementation = "net.shrine.hornetqmom.LocalHornetQMom" //todo stays this way until the package rename SHRINE-2307
}
metaData {
ping = "pong"
five = 5
list = [list, list, list]
object {
objectVal = 10
}
}
problem {
problemHandler = "net.shrine.problem.NoOpProblemHandler$"
}
authenticate {
realm = "test meta service"
usersource {
//Bogus security for testing
type = "ConfigUserSource" //Must be ConfigUserSource (for isolated testing) or PmUserSource (for everything else)
researcher {
username = "ben"
password = "kapow"
}
steward {
username = "dave"
password = "kablam"
}
qep{
username = "qep"
password = "trustme"
}
admin{
username = "keith"
password = "shh!"
}
}
}
queryEntryPoint {
audit {
collectQepAudit = false
database {
slickProfileClassName = "slick.driver.H2Driver$"
createTablesOnStart = true //for testing with H2 in memory, when not running unit tests. Set to false normally
dataSourceFrom = "testDataSource" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
testDataSource {
driverClassName = "org.h2.Driver"
url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1" //H2 embedded in-memory for unit tests ;TRACE_LEVEL_SYSTEM_OUT=2 for H2's trace
}
}
}
}
}
spray.can.server.request-timeout = 20 s
\ No newline at end of file
diff --git a/messagequeue/hornetqclient/src/main/resources/reference.conf b/messagequeue/hornetqclient/src/main/resources/reference.conf
index 1147a8d80..601bf6ae2 100644
--- a/messagequeue/hornetqclient/src/main/resources/reference.conf
+++ b/messagequeue/hornetqclient/src/main/resources/reference.conf
@@ -1,24 +1,24 @@
shrine {
messagequeue {
- hornetq {
+ blockingq {
serverUrl = "https://localhost:6443/shrine-metadata/mom"
webClientTimeOutSecond = 10 seconds
}
httpClient {
defaultTimeOut = 10 seconds
timeOutWaitGap = 1 second
}
}
}
//todo typesafe config precedence seems to do the right thing, but I haven't found the rules that say this reference.conf should override others
// todo go with the actor system, also check other apps, possiblly they use it too
akka {
loglevel = INFO
// log-config-on-start = on
loggers = ["akka.event.slf4j.Slf4jLogger"]
// logging-filter = "akka.event.slf4j.Slf4jLoggingFilter"
// Toggles whether the threads created by this ActorSystem should be daemons or not
daemonic = on
}
\ No newline at end of file
diff --git a/messagequeue/hornetqclient/src/main/scala/net/shrine/hornetqclient/HornetQMomWebClient.scala b/messagequeue/hornetqclient/src/main/scala/net/shrine/hornetqclient/HornetQMomWebClient.scala
index ca591defe..55cb1f024 100644
--- a/messagequeue/hornetqclient/src/main/scala/net/shrine/hornetqclient/HornetQMomWebClient.scala
+++ b/messagequeue/hornetqclient/src/main/scala/net/shrine/hornetqclient/HornetQMomWebClient.scala
@@ -1,208 +1,212 @@
package net.shrine.hornetqclient
import java.util.UUID
import akka.actor.ActorSystem
import net.shrine.config.ConfigExtensions
import net.shrine.hornetqmom.MessageContainer
import net.shrine.log.Loggable
import net.shrine.messagequeueservice.{CouldNotCreateQueueButOKToRetryException, Message, MessageQueueService, Queue}
import net.shrine.source.ConfigSource
import org.json4s.NoTypeHints
import org.json4s.native.Serialization
import org.json4s.native.Serialization.read
import spray.http.{HttpEntity, HttpMethods, HttpRequest, HttpResponse, StatusCodes}
import scala.collection.immutable.Seq
import scala.concurrent.duration.Duration
import scala.language.postfixOps
import scala.util.control.NonFatal
import scala.util.{Failure, Success, Try}
/**
* A simple HornetQMomWebClient that uses HornetQMomWebApi to createQueue,
* deleteQueue, sendMessage, receiveMessage, getQueues, and sendReceipt
*
* @author yifan
* @since 8/10/17
*/
object HornetQMomWebClient extends MessageQueueService with Loggable {
// we need an ActorSystem to host our application in
implicit val system: ActorSystem = ActorSystem("momServer", ConfigSource.config)
- val webClientTimeOut: Duration = ConfigSource.config.get("shrine.messagequeue.hornetq.webClientTimeOutSecond", Duration(_))
+ val configPath = "shrine.messagequeue.blockingq"
+ def webClientConfig = ConfigSource.config.getConfig("shrine.messagequeue.blockingq")
+
+ //todo Yifan's work changes the name to webClientTimeOut
+ val webClientTimeOut: Duration = webClientConfig.get("webClientTimeOutSecond", Duration(_))
// TODO in SHRINE-2167: Extract and share a SHRINE actor system
// the service actor replies to incoming HttpRequests
// implicit val serviceActor: ActorRef = startServiceActor()
// def startActorSystem(): ActorSystem = try {
// val actorSystem: ActorSystem = ActorSystem("momServer", ConfigSource.config)
// info(s"Starting ActorSystem: ${actorSystem.name} for HornetQMomWebClient at time: ${actorSystem.startTime}")
// actorSystem
// } catch {
// case NonFatal(x) => {
// debug(s"NonFatalException thrown while starting ActorSystem for HornetQMomWebClient: ${x.getMessage}")
// throw x
// }
// case x: ExceptionInInitializerError => {
// debug(s"ExceptionInInitializerError thrown while starting ActorSystem for HornetQMomWebClient: ${x.getMessage}")
// throw x
// }
// }
//
// def startServiceActor(): ActorRef = try {
// // the service actor replies to incoming HttpRequests
// val actor: ActorRef = system.actorOf(Props[HornetQMomWebClientServiceActor])
// info(s"Starting ServiceActor: ${actor.toString()} for HornetQMomWebClient")
// actor
// }
// catch {
// case NonFatal(x) => {
// debug(s"NonFatalException thrown while starting ServiceActor for HornetQMomWebClient: ${x.getMessage}")
// throw x
// }
// case x: ExceptionInInitializerError => {
// debug(s"ExceptionInInitializerError thrown while starting ServiceActor for HornetQMomWebClient: ${x.getMessage}")
// throw x
// }
// }
- val momUrl: String = ConfigSource.config.getString("shrine.messagequeue.hornetq.serverUrl")
+ val momUrl: String = webClientConfig.getString("serverUrl")
override def createQueueIfAbsent(queueName: String): Try[Queue] = {
val proposedQueue: Queue = Queue(queueName)
val createQueueUrl = momUrl + s"/createQueue/${proposedQueue.name}"
val request: HttpRequest = HttpRequest(HttpMethods.PUT, createQueueUrl)
for {
response: HttpResponse <- Try(HttpClient.webApiCall(request, webClientTimeOut))
queue: Queue <- queueFromResponse(response)
} yield queue
}
def queueFromResponse(response: HttpResponse):Try[Queue] = Try {
if(response.status == StatusCodes.Created) {
val queueString = response.entity.asString
implicit val formats = Serialization.formats(NoTypeHints)
read[Queue](queueString)(formats, manifest[Queue])
} else {
if((response.status == StatusCodes.NotFound) ||
(response.status == StatusCodes.RequestTimeout))throw new CouldNotCreateQueueButOKToRetryException(response.status,response.entity.asString)
else throw new IllegalStateException(s"Response status is ${response.status}, not Created. Cannot make a queue from this response: ${response.entity.asString}") //todo more specific custom exception SHRINE-2213
}
}.transform({ s =>
Success(s)
},{throwable =>
throwable match {
case NonFatal(x) => error(s"Unable to create a Queue from '${response.entity.asString}' due to exception",throwable) //todo probably want to wrap more information into a new Throwable here SHRINE-2213
case _ =>
}
Failure(throwable)
})
override def deleteQueue(queueName: String): Try[Unit] = {
val proposedQueue: Queue = Queue(queueName)
val deleteQueueUrl = momUrl + s"/deleteQueue/${proposedQueue.name}"
val request: HttpRequest = HttpRequest(HttpMethods.PUT, deleteQueueUrl)
Try(HttpClient.webApiCall(request, webClientTimeOut)) // StatusCodes.OK
}
override def queues: Try[Seq[Queue]] = {
val getQueuesUrl = momUrl + s"/getQueues"
val request: HttpRequest = HttpRequest(HttpMethods.GET, getQueuesUrl)
for {
response: HttpResponse <- Try(HttpClient.webApiCall(request, webClientTimeOut))
allQueues: Seq[Queue] <- Try {
val allQueues: String = response.entity.asString
implicit val formats = Serialization.formats(NoTypeHints)
read[Seq[Queue]](allQueues)(formats, manifest[Seq[Queue]])
}
} yield allQueues
}
override def send(contents: String, to: Queue): Try[Unit] = {
debug(s"send to $to '$contents'")
val sendMessageUrl = momUrl + s"/sendMessage/${to.name}"
val request: HttpRequest = HttpRequest(
method = HttpMethods.PUT,
uri = sendMessageUrl,
entity = HttpEntity(contents) //todo set contents as XML or json SHRINE-2215
)
for {
response: HttpResponse <- Try(HttpClient.webApiCall(request, webClientTimeOut))
} yield response
}
//todo test receiving no message SHRINE-2213
override def receive(from: Queue, timeout: Duration): Try[Option[Message]] = {
val seconds = timeout.toSeconds
val receiveMessageUrl = momUrl + s"/receiveMessage/${from.name}?timeOutSeconds=$seconds"
val request: HttpRequest = HttpRequest(HttpMethods.GET, receiveMessageUrl)
for {
//use the time to make the API call plus the timeout for the long poll
response: HttpResponse <- Try(HttpClient.webApiCall(request, webClientTimeOut + timeout))
messageResponse: Option[Message] <- messageOptionFromResponse(response)
} yield messageResponse
}
def messageOptionFromResponse(response: HttpResponse):Try[Option[Message]] = Try {
if(response.status == StatusCodes.NotFound) None
else if (response.status == StatusCodes.OK) Some {
val responseString = response.entity.asString
MessageContainer.fromJson(responseString)
} else {
throw new IllegalStateException(s"Response status is ${response.status}, not OK or NotFound. Cannot make a Message from this response: ${response.entity.asString}")
}
}.transform({ s =>
val hornetQMessage = s.map(msg => HornetQClientMessage(UUID.fromString(msg.id), msg.contents))
Success(hornetQMessage)
},{throwable =>
throwable match {
case NonFatal(x) => error(s"Unable to create a Message from '${response.entity.asString}' due to exception",throwable) //todo probably want to report a Problem here SHRINE-2216
case _ =>
}
Failure(throwable)
})
case class HornetQClientMessage private(messageID: UUID, messageContent: String) extends Message {
override def contents: String = messageContent
override def complete(): Try[Unit] = {
val entity: HttpEntity = HttpEntity(messageID.toString)
val completeMessageUrl: String = s"$momUrl/acknowledge"
val request: HttpRequest = HttpRequest(HttpMethods.PUT, completeMessageUrl).withEntity(entity)
for {
response: HttpResponse <- Try(HttpClient.webApiCall(request)).transform({r =>
info(s"Message ${this.messageID} completed with ${r.status}")
Success(r)
}, { throwable =>
debug(s"Message ${this.messageID} failed in its complete process due to ${throwable.getMessage}")
Failure(throwable)
})
} yield response
}
}
}
// TODO in SHRINE-2167: Extract and share a SHRINE actor system
//class HornetQMomWebClientServiceActor extends Actor with MetaDataService {
//
// // the HttpService trait defines only one abstract member, which
// // connects the services environment to the enclosing actor or test
// def actorRefFactory: ActorRefFactory = context
//
// // this actor only runs our route, but you could add
// // other things here, like request stream processing
// // or timeout handling
// def receive: Receive = runRoute(route)
//
// override implicit val ec: ExecutionContext = ExecutionContext.Implicits.global
//
// override def system: ActorSystem = context.system
//}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/main/resources/reference.conf b/messagequeue/hornetqmom/src/main/resources/reference.conf
index f0678d49d..363c01b7f 100644
--- a/messagequeue/hornetqmom/src/main/resources/reference.conf
+++ b/messagequeue/hornetqmom/src/main/resources/reference.conf
@@ -1,10 +1,10 @@
shrine {
messagequeue {
- hornetq {
+ blockingq {
}
- hornetQWebApi {
+ blockingqWebApi {
enabled = false
messageTimeToLive = 15 days
}
}
}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/HornetQMomWebApi.scala b/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/HornetQMomWebApi.scala
index 88e16fc7d..71afa4523 100644
--- a/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/HornetQMomWebApi.scala
+++ b/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/HornetQMomWebApi.scala
@@ -1,326 +1,332 @@
package net.shrine.hornetqmom
import java.util.UUID
import java.util.concurrent.{Executors, ScheduledExecutorService, TimeUnit}
import net.shrine.config.ConfigExtensions
import net.shrine.log.{Log, Loggable}
import net.shrine.messagequeueservice.{Message, Queue}
import net.shrine.problem.{AbstractProblem, ProblemSources}
import net.shrine.source.ConfigSource
import org.json4s.native.Serialization
import org.json4s.native.Serialization.write
import org.json4s.{NoTypeHints, ShortTypeHints}
import spray.http.StatusCodes
import spray.routing.{HttpService, Route}
import scala.collection.concurrent.TrieMap
import scala.collection.immutable.Seq
import scala.concurrent.duration.Duration
import scala.util.control.NonFatal
import scala.util.{Failure, Success, Try}
/**
* A web API that provides access to the internal HornetQMom library.
* Allows client to createQueue, deleteQueue, sendMessage, receiveMessage, getQueues, and sendReceipt
*
* Created by yifan on 7/24/17.
*/
trait HornetQMomWebApi extends HttpService
with Loggable {
- def enabled: Boolean = ConfigSource.config.getBoolean("shrine.messagequeue.hornetQWebApi.enabled")
+ val configPath = "shrine.messagequeue.blockingqWebApi"
+ def webApiConfig = ConfigSource.config.getConfig(configPath)
+
+ //if(!webClientConfig.getConfigOrEmpty("serverUrl").isEmpty) webClientConfig.getString("serverUrl")
+ def enabled: Boolean = webApiConfig.getBoolean("enabled")
+
val warningMessage: String = "If you intend for this node to serve as this SHRINE network's messaging hub " +
- "set shrine.messagequeue.hornetQWebApi.enabled to true in your shrine.conf." +
+ "set shrine.messagequeue.blockingqWebApi.enabled to true in your shrine.conf." +
" You do not want to do this unless you are the hub admin!"
if(!enabled) {
debug(s"HornetQMomWebApi is not enabled.")
}
// keep a map of messages and ids
private val idToMessages: TrieMap[UUID, (Message, Long)] = TrieMap.empty
case class MapSentinelRunner(timeOutInMillis: Long) extends Runnable {
// watches the map
override def run(): Unit = {
val currentTimeInMillis = System.currentTimeMillis()
try {
Log.debug("About to clean up outstanding messages.")
idToMessages.retain({ (uuid, localHornetQMessageAndCreatedTime) =>
(currentTimeInMillis - localHornetQMessageAndCreatedTime._2) < timeOutInMillis
})
Log.debug(s"Outstanding messages that exceed $timeOutInMillis milliseconds have been cleaned from the map.")
} catch {
case NonFatal(x) => ExceptionWhileCleaningUpMessageProblem(timeOutInMillis, x)
//pass-through to blow up the thread, receive no more results, do something dramatic in UncaughtExceptionHandler.
case x => Log.error("Fatal exception while cleaning up outstanding messages", x)
throw x
}
}
}
def momRoute: Route = pathPrefix("mom") {
if (!enabled) {
respondWithStatus(StatusCodes.NotFound) {
complete(warningMessage)
}
} else {
put {
createQueue ~
sendMessage ~
acknowledge
} ~ receiveMessage ~ getQueues ~ deleteQueue
}
}
// SQS returns CreateQueueResult, which contains queueUrl: String
def createQueue: Route =
path("createQueue" / Segment) { queueName =>
detach() {
val createdQueueTry: Try[Queue] = LocalHornetQMom.createQueueIfAbsent(queueName)
createdQueueTry match {
case Success(queue) => {
implicit val formats = Serialization.formats(NoTypeHints)
val response: String = write[Queue](queue)(formats)
respondWithStatus(StatusCodes.Created) {
complete(response)
}
}
case Failure(x) => {
internalServerErrorOccured(x, "createQueue")
}
}
}
}
// SQS takes in DeleteMessageRequest, which contains a queueUrl: String and a ReceiptHandle: String
// returns a DeleteMessageResult, toString for debugging
def deleteQueue: Route = path("deleteQueue" / Segment) { queueName =>
put {
detach() {
val deleteQueueTry: Try[Unit] = LocalHornetQMom.deleteQueue(queueName)
deleteQueueTry match {
case Success(v) => {
complete(StatusCodes.OK)
}
case Failure(x) => {
internalServerErrorOccured(x, "deleteQueue")
}
}
}
}
}
// SQS sendMessage(String queueUrl, String messageBody) => SendMessageResult
def sendMessage: Route = path("sendMessage" / Segment) { toQueue =>
requestInstance { request =>
val messageContent = request.entity.asString
debug(s"sendMessage to $toQueue '$messageContent'")
detach() {
val sendTry: Try[Unit] = LocalHornetQMom.send(messageContent, Queue(toQueue))
sendTry match {
case Success(v) => {
complete(StatusCodes.Accepted)
}
case Failure(x) => {
internalServerErrorOccured(x, "sendMessage")
}
}
}
}
}
// SQS ReceiveMessageResult receiveMessage(String queueUrl)
def receiveMessage: Route =
get {
path("receiveMessage" / Segment) { fromQueue =>
parameter('timeOutSeconds ? 20) { timeOutSeconds =>
val timeout: Duration = Duration.create(timeOutSeconds, "seconds")
detach() {
val receiveTry: Try[Option[Message]] = LocalHornetQMom.receive(Queue(fromQueue), timeout)
receiveTry match {
case Success(optionMessage) => {
optionMessage.fold(complete(StatusCodes.NotFound)){localHornetQMessage =>
// add message in the map with an unique UUID
val msgID = UUID.randomUUID()
scheduleCleanupMessageMap(msgID, localHornetQMessage)
complete(MessageContainer(msgID.toString, localHornetQMessage.contents).toJson)
}
}
case Failure(x) => {
internalServerErrorOccured(x, "receiveMessage")
}
}
}
}
}
}
private def scheduleCleanupMessageMap(msgID: UUID, localHornetQMessage: Message) = {
idToMessages.update(msgID, (localHornetQMessage, System.currentTimeMillis()))
// a sentinel that monitors the hashmap of idToMessages, any message that has been outstanding for more than 3X or 10X
// time-to-live need to get cleaned out of this map
- val messageTimeToLiveInMillis: Long = ConfigSource.config.get("shrine.messagequeue.hornetQWebApi.messageTimeToLive", Duration(_)).toMillis
+ val messageTimeToLiveInMillis: Long = webApiConfig.get("messageTimeToLive", Duration(_)).toMillis
val sentinelRunner: MapSentinelRunner = MapSentinelRunner(messageTimeToLiveInMillis)
try {
Log.debug(s"Starting the sentinel scheduler that cleans outstanding messages exceeds 3 times $messageTimeToLiveInMillis")
MessageMapCleaningScheduler.schedule(sentinelRunner, messageTimeToLiveInMillis * 3, TimeUnit.MILLISECONDS)
} catch {
case NonFatal(x) => ExceptionWhileSchedulingSentinelProblem(messageTimeToLiveInMillis, x)
//pass-through to blow up the thread, receive no more results, do something dramatic in UncaughtExceptionHandler.
case x => Log.error("Fatal exception while scheduling a sentinel for cleaning up outstanding messages", x)
throw x
}
}
// SQS has DeleteMessageResult deleteMessage(String queueUrl, String receiptHandle)
def acknowledge: Route = path("acknowledge") {
entity(as[String]) { messageUUID =>
detach() {
val id: UUID = UUID.fromString(messageUUID)
// retrieve the localMessage from the concurrent hashmap
val getMessageTry: Try[Option[(Message, Long)]] = Try {
idToMessages.remove(id)
}.transform({ messageAndTime =>
Success(messageAndTime)
}, { throwable =>
Failure(MessageDoesNotExistException(id))
})
getMessageTry match {
case Success(messageAndTimeOption) => {
messageAndTimeOption.fold({
respondWithStatus(StatusCodes.NotFound) {
val noMessageProblem = MessageDoesNotExistInMapProblem(id)
complete(noMessageProblem.description)
}
}) { messageAndTime =>
messageAndTime._1.complete()
complete(StatusCodes.ResetContent)
}
}
case Failure(x) => {
x match {
case m: MessageDoesNotExistException => {
respondWithStatus(StatusCodes.NotFound) {
complete(m.getMessage)
}
}
case _ => internalServerErrorOccured(x, "acknowledge")
}
}
}
}
}
}
// Returns the names of the queues created on this server. Seq[Any]
def getQueues: Route = path("getQueues") {
get {
detach() {
implicit val formats = Serialization.formats(NoTypeHints)
respondWithStatus(StatusCodes.OK) {
val getQueuesTry: Try[Seq[Queue]] = LocalHornetQMom.queues
getQueuesTry match {
case Success(seqQueue) => {
complete(write[Seq[Queue]](LocalHornetQMom.queues.get)(formats))
}
case Failure(x) => {
internalServerErrorOccured(x, "getQueues")
}
}
}
}
}
}
def internalServerErrorOccured(x: Throwable, function: String): Route = {
respondWithStatus(StatusCodes.InternalServerError) {
val serverErrorProblem: HornetQMomServerErrorProblem = HornetQMomServerErrorProblem(x, function)
debug(s"HornetQ encountered a Problem during $function, Problem Details: $serverErrorProblem")
complete(s"HornetQ throws an exception while trying to $function. HornetQ Server response: ${x.getMessage}" +
s"Exception is from ${x.getClass}")
}
}
}
object MessageMapCleaningScheduler {
private val scheduler: ScheduledExecutorService = Executors.newScheduledThreadPool(1)
def schedule(command: Runnable, delay: Long, unit: TimeUnit) = {
scheduler.schedule(command, delay, unit)
}
def shutDown() = {
scheduler.shutdownNow()
}
}
case class MessageContainer(id: String, contents: String) {
def toJson: String = {
Serialization.write(this)(MessageContainer.messageFormats)
}
}
object MessageContainer {
val messageFormats = Serialization.formats(ShortTypeHints(List(classOf[MessageContainer])))
def fromJson(jsonString: String): MessageContainer = {
implicit val formats = messageFormats
Serialization.read[MessageContainer](jsonString)
}
}
case class HornetQMomServerErrorProblem(x:Throwable, function:String) extends AbstractProblem(ProblemSources.Hub) {
override val throwable = Some(x)
override val summary: String = "SHRINE cannot use HornetQMomWebApi due to a server error occurred in hornetQ."
override val description: String = s"HornetQ throws an exception while trying to $function," +
s" the server's response is: ${x.getMessage} from ${x.getClass}."
}
+//todo is this used anywhere?
case class CannotUseHornetQMomWebApiProblem(x:Throwable) extends AbstractProblem(ProblemSources.Hub) {
override val throwable = Some(x)
override val summary: String = "SHRINE cannot use HornetQMomWebApi due to configuration in shrine.conf."
override val description: String = "If you intend for this node to serve as this SHRINE network's messaging hub " +
"set shrine.messagequeue.hornetQWebApi.enabled to true in your shrine.conf." +
" You do not want to do this unless you are the hub admin!"
}
case class MessageDoesNotExistException(id: UUID) extends Exception(s"Cannot match given ${id.toString} to any Message in HornetQ server! Message does not exist!")
case class MessageDoesNotExistInMapProblem(id: UUID) extends AbstractProblem(ProblemSources.Hub) {
override def summary: String = s"The client expected message $id, but the server did not find it and could not complete() the message."
override def description: String = s"The client expected message $id from , but the server did not find it and could not complete() the message." +
s" Message either has never been received or already been completed!"
}
case class ExceptionWhileCleaningUpMessageProblem(timeOutInMillis: Long, x:Throwable) extends AbstractProblem(ProblemSources.Hub) {
override val throwable = Some(x)
override def summary: String = s"The Hub encountered an exception while trying to " +
s"cleanup messages that has been outstanding for more than $timeOutInMillis milliseconds"
override def description: String = s"The Hub encountered an exception while trying to " +
s"cleanup messages that has been received for more than $timeOutInMillis milliseconds " +
s"on Thread ${Thread.currentThread().getName}: ${x.getMessage}"
}
case class ExceptionWhileSchedulingSentinelProblem(timeOutInMillis: Long, x:Throwable) extends AbstractProblem(ProblemSources.Hub) {
override val throwable = Some(x)
override def summary: String = s"The Hub encountered an exception while trying to " +
s"schedule a sentinel that cleans up outstanding messages exceed $timeOutInMillis milliseconds"
override def description: String = s"The Hub encountered an exception while trying to " +
s"schedule a sentinel that cleans up outstanding messages exceed $timeOutInMillis milliseconds " +
s"on Thread ${Thread.currentThread().getName}: ${x.getMessage}"
}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/LocalHornetQMom.scala b/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/LocalHornetQMom.scala
index 8e167a3f3..963f7407b 100644
--- a/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/LocalHornetQMom.scala
+++ b/messagequeue/hornetqmom/src/main/scala/net/shrine/hornetqmom/LocalHornetQMom.scala
@@ -1,95 +1,95 @@
package net.shrine.hornetqmom
import java.util.concurrent.{BlockingDeque, LinkedBlockingDeque, TimeUnit}
import com.typesafe.config.Config
import net.shrine.config.ConfigExtensions
import net.shrine.log.Log
import net.shrine.messagequeueservice.{Message, MessageQueueService, Queue}
import net.shrine.source.ConfigSource
import scala.collection.concurrent.{TrieMap, Map => ConcurrentMap}
import scala.collection.immutable.Seq
import scala.concurrent.blocking
import scala.concurrent.duration.Duration
import scala.util.{Success, Try}
/**
* This object is the local version of the Message-Oriented Middleware API, which uses HornetQ service
*
* @author david
* @since 7/18/17
*/
object LocalHornetQMom extends MessageQueueService {
- val config: Config = ConfigSource.config.getConfig("shrine.messagequeue.hornetq")
+ val configPath = "shrine.messagequeue.blockingq"
+ val config = ConfigSource.config.getConfig(configPath)
/**
* Use HornetQMomStopper to stop the hornetQServer without unintentially starting it
*/
private[hornetqmom] def stop() = {
//todo use to turn off the scheduler for redelivery and time to live SHRINE-2309
}
//todo key should be a Queue instead of a String SHRINE-2308
//todo rename
val namesToShadowQueues:ConcurrentMap[String,BlockingDeque[String]] = TrieMap.empty
//queue lifecycle
def createQueueIfAbsent(queueName: String): Try[Queue] = Try {
namesToShadowQueues.getOrElseUpdate(queueName, new LinkedBlockingDeque[String]())
Queue(queueName)
}
def deleteQueue(queueName: String): Try[Unit] = Try{
namesToShadowQueues.remove(queueName).getOrElse(throw new IllegalStateException(s"$queueName not found")) //todo this is actually fine - the state we want SHRINE-2308
}
override def queues: Try[Seq[Queue]] = Try{
namesToShadowQueues.keys.map(Queue(_))(collection.breakOut)
}
//send a message
def send(contents: String, to: Queue): Try[Unit] = Try{
val queue = namesToShadowQueues.getOrElse(to.name,throw new IllegalStateException(s"queue $to not found")) //todo better error handling SHRINE-2308
queue.addLast(contents)
Log.debug(s"After send to ${to.name} - shadowQueue ${queue.size} $queue")
}
//receive a message
/**
* Always do AWS SQS-style long polling.
* Be sure your code can handle receiving the same message twice.
*
* @return Some message before the timeout, or None
*/
def receive(from: Queue, timeout: Duration): Try[Option[Message]] = Try {
val shadowQueue = namesToShadowQueues.getOrElse(from.name,throw new IllegalStateException(s"Queue $from not found")) //todo better exception SHRINE-2308
Log.debug(s"Before receive from ${from.name} - shadowQueue ${shadowQueue.size} ${shadowQueue.toString}")
blocking {
val shadowMessage: Option[String] = Option(shadowQueue.pollFirst(timeout.toMillis, TimeUnit.MILLISECONDS))
shadowMessage.map(SimpleMessage(_))
}
}
//todo dead letter queue for all messages SHRINE-2261
val unit = ()
case class SimpleMessage(contents:String) extends Message {
override def complete(): Try[Unit] = Success(unit) //todo fill this in when you build out complete SHRINE-2309
}
}
/**
* If the configuration is such that HornetQ should have been started use this object to stop it
*/
object LocalHornetQMomStopper {
def stop(): Unit = {
- if(ConfigSource.config.getBoolean("shrine.messagequeue.hornetQWebApi.enabled")) {
- LocalHornetQMom.stop()
- }
+ //a lot less interesting without hornetq - not a big deal to stop schedulers that were never started , maybe nothing to do.
+ LocalHornetQMom.stop()
}
}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/test/resources/shrine.conf b/messagequeue/hornetqmom/src/test/resources/shrine.conf
index 809810e7c..4b3056b63 100644
--- a/messagequeue/hornetqmom/src/test/resources/shrine.conf
+++ b/messagequeue/hornetqmom/src/test/resources/shrine.conf
@@ -1,11 +1,11 @@
shrine {
messagequeue {
- hornetQWebApiTest {
+ hornetQWebApiTest { //todo this looks unlikely
enabled = false
messageTimeToLive = 15 days
}
}
problem {
problemHandler = "net.shrine.problem.NoOpProblemHandler$"
}
}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiConfigTest.scala b/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiConfigTest.scala
index 51c1926af..24aff98f2 100644
--- a/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiConfigTest.scala
+++ b/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiConfigTest.scala
@@ -1,34 +1,34 @@
package net.shrine.hornetqmom
import akka.actor.ActorRefFactory
import net.shrine.source.ConfigSource
import org.junit.runner.RunWith
import org.scalatest.FlatSpec
import org.scalatest.junit.JUnitRunner
import spray.http.StatusCodes.NotFound
import spray.testkit.ScalatestRouteTest
/**
* Test to make sure hornetQMomWebApi is only available when correctly configured
* Created by yifan on 9/8/17.
*/
@RunWith(classOf[JUnitRunner])
class HornetQMomWebApiConfigTest extends FlatSpec with ScalatestRouteTest with HornetQMomWebApi {
override def actorRefFactory: ActorRefFactory = system
private val queueName = "testQueue"
"HornetQMomWebApi" should "block user from using the API and return a 404 response" in {
-
- ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.hornetQWebApi.enabled", "false", "HornetQMomWebApiConfigTest") {
+//todo shouldn't need to set the config to the default value
+ ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.blockingqWebApi.enabled", "false", "HornetQMomWebApiConfigTest") {
Put(s"/mom/createQueue/$queueName") ~> momRoute ~> check {
val response = new String(body.data.toByteArray)
assertResult(warningMessage)(response)
assertResult(NotFound)(status)
}
}
}
}
\ No newline at end of file
diff --git a/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiTest.scala b/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiTest.scala
index 2b14612c0..ae01fbbf9 100644
--- a/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiTest.scala
+++ b/messagequeue/hornetqmom/src/test/scala/net/shrine/hornetqmom/HornetQMomWebApiTest.scala
@@ -1,117 +1,117 @@
package net.shrine.hornetqmom
import java.util.UUID
import akka.actor.ActorRefFactory
import net.shrine.messagequeueservice.Queue
import net.shrine.source.ConfigSource
import org.json4s.NoTypeHints
import org.json4s.native.Serialization
import org.json4s.native.Serialization.read
import org.junit.runner.RunWith
import org.scalatest.FlatSpec
import org.scalatest.junit.JUnitRunner
import spray.http.HttpEntity
import spray.http.StatusCodes._
import spray.testkit.ScalatestRouteTest
import scala.collection.immutable.Seq
/**
* Test basic functions of HornetQMomWebApi
* Created by yifan on 7/27/17.
*/
@RunWith(classOf[JUnitRunner])
class HornetQMomWebApiTest extends FlatSpec with ScalatestRouteTest with HornetQMomWebApi {
override def actorRefFactory: ActorRefFactory = system
private val proposedQueueName = "test Queue"
private val queue: Queue = Queue(proposedQueueName)
private val queueName: String = queue.name // "testQueue"
private val messageContent = "test Content"
"HornetQMomWebApi" should "create/delete the given queue, send/receive message, get queues" in {
- ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.hornetQWebApi.enabled", "true", "HornetQMomWebApiTest") {
+ ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.blockingqWebApi.enabled", "true", "HornetQMomWebApiTest") {
Put(s"/mom/createQueue/$queueName") ~> momRoute ~> check {
val response = new String(body.data.toByteArray)
implicit val formats = Serialization.formats(NoTypeHints)
val jsonToQueue = read[Queue](response)(formats, manifest[Queue])
val responseQueueName = jsonToQueue.name
assertResult(Created)(status)
assertResult(queueName)(responseQueueName)
}
// should be OK to create a queue twice
Put(s"/mom/createQueue/$queueName") ~> momRoute ~> check {
val response = new String(body.data.toByteArray)
implicit val formats = Serialization.formats(NoTypeHints)
val jsonToQueue = read[Queue](response)(formats, manifest[Queue])
val responseQueueName = jsonToQueue.name
assertResult(Created)(status)
assertResult(queueName)(responseQueueName)
}
Put(s"/mom/sendMessage/$queueName", HttpEntity(s"$messageContent")) ~> momRoute ~> check {
assertResult(Accepted)(status)
}
Get(s"/mom/getQueues") ~> momRoute ~> check {
val response: String = new String(body.data.toByteArray)
implicit val formats = Serialization.formats(NoTypeHints)
val jsonToSeq: Seq[Queue] = read[Seq[Queue]](response)(formats, manifest[Seq[Queue]])
assertResult(OK)(status)
assertResult(queueName)(jsonToSeq.head.name)
}
var messageUUID: String = ""
// given timeout is 2 seconds
Get(s"/mom/receiveMessage/$queueName?timeOutSeconds=2") ~> momRoute ~> check {
val response = new String(body.data.toByteArray)
assertResult(OK)(status)
val responseMsg = MessageContainer.fromJson(response)
messageUUID = responseMsg.id
assertResult(responseMsg.contents)(messageContent)
}
Put("/mom/acknowledge", HttpEntity(s"$messageUUID")) ~> momRoute ~> check {
assertResult(ResetContent)(status)
}
val nonExistingUUID = UUID.randomUUID()
Put("/mom/acknowledge", HttpEntity(s"$nonExistingUUID")) ~> momRoute ~> check {
val response = new String(body.data.toByteArray)
assertResult(NotFound)(status)
assertResult(MessageDoesNotExistInMapProblem(nonExistingUUID).description)(response)
}
Put(s"/mom/deleteQueue/$queueName") ~> momRoute ~> check {
assertResult(OK)(status)
}
}
}
"HornetQMomWebApi" should "respond InternalServerError with the corresponding error message when " +
"failures occur while creating/deleting the given queue, sending/receiving message, getting queues" in {
- ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.hornetQWebApi.enabled", "true", "HornetQMomWebApiTest") {
+ ConfigSource.atomicConfig.configForBlock("shrine.messagequeue.blockingqWebApi.enabled", "true", "HornetQMomWebApiTest") {
//todo Not a problem. The system is in the state you want. SHRINE-2208
Put(s"/mom/deleteQueue/$queueName") ~> momRoute ~> check {
assertResult(InternalServerError)(status)
}
//todo I don't think this one rates more than a 404 SHRINE-2208
Put(s"/mom/sendMessage/$queueName", HttpEntity(s"$messageContent")) ~> momRoute ~> check {
assertResult(InternalServerError)(status)
}
//todo I don't think this one rates more than a 404 SHRINE-2208
// given timeout is 1 seconds
Get(s"/mom/receiveMessage/$queueName?timeOutSeconds=1") ~> momRoute ~> check {
assertResult(InternalServerError)(status)
}
}
}
}
\ No newline at end of file
diff --git a/shrine-setup/src/main/resources/shrine.conf b/shrine-setup/src/main/resources/shrine.conf
index 111c56dc9..17e0460ce 100644
--- a/shrine-setup/src/main/resources/shrine.conf
+++ b/shrine-setup/src/main/resources/shrine.conf
@@ -1,367 +1,367 @@
shrine {
metaData {
ping = "pong"
}
pmEndpoint {
// url = "http://shrine-dev1.catalyst/i2b2/services/PMService/getServices" //use your i2b2 pm url
}
ontEndpoint {
// url = "http://shrine-dev1.catalyst/i2b2/rest/OntologyService/" //use your i2b2 ontology url
}
hiveCredentials {
//use your i2b2 hive credentials
// domain = "i2b2demo"
// username = "demo"
// password = "examplePassword"
// crcProjectId = "Demo"
// ontProjectId = "SHRINE"
}
messagequeue {
- hornetq {
+ blockingq {
serverUrl = "https://localhost:6443/shrine-metadata/mom"
}
// If you intend for your node to serve as this SHRINE network's messaging hub,
- // then set shrine.messagequeue.hornetQWebApi.enabled to true in your shrine.conf.
+ // then set shrine.messagequeue.blockginqWebApi.enabled to true in your shrine.conf.
// You do not want to do this unless you are the hub admin
- hornetQWebApi {
+ blockingqWebApi {
// enabled = false
// messageTimeToLive = 15 days
// webClientTimeOut = 10 seconds
}
httpClient {
defaultTimeOut = 10 seconds
timeOutWaitGap = 1 second
}
messagequeue {
// receiveWaitTime = "15 seconds"
}
}
breakdownResultOutputTypes {
//use breakdown values appropriate for your shrine network
// PATIENT_AGE_COUNT_XML {
// description = "Age patient breakdown"
// }
// PATIENT_RACE_COUNT_XML {
// description = "Race patient breakdown"
// }
// PATIENT_VITALSTATUS_COUNT_XML {
// description = "Vital Status patient breakdown"
// }
// PATIENT_GENDER_COUNT_XML {
// description = "Gender patient breakdown"
// }
}
queryEntryPoint {
// create = true //false for no qep
// audit {
// collectQepAudit = true //false to not use the 1.20 audit db tables
// database {
// dataSourceFrom = "JNDI" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
// jndiDataSourceName = "java:comp/env/jdbc/qepAuditDB" //or leave out for tests
// slickProfileClassName = "slick.driver.MySQLDriver$" // Can be
// slick.driver.H2Driver$
// slick.driver.MySQLDriver$
// slick.driver.PostgresDriver$
// slick.driver.SQLServerDriver$
// slick.driver.JdbcDriver$
// freeslick.OracleProfile$
// freeslick.MSSQLServerProfile$
//
// (Yes, with the $ on the end)
// For testing without JNDI
// testDataSource {
//typical test settings for unit tests
//driverClassName = "org.h2.Driver"
//url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1" //H2 embedded in-memory for unit tests
//url = "jdbc:h2:~/stewardTest.h2" //H2 embedded on disk at ~/test
// }
// timeout = 30 //time to wait before db gives up, in seconds.
// createTablesOnStart = false //for testing with H2 in memory, when not running unit tests. Set to false normally
// }
// }
// trustModelIsHub = true // true by default, false for P2P networks.
// authenticationType = "pm" //can be none, pm, or ecommons
// authorizationType = "shrine-steward" //can be none, shrine-steward, or hms-steward
//hms-steward config
// sheriffEndpoint {
// url = "http://localhost:8080/shrine-hms-authorization/queryAuthorization"
// timeout {
// seconds = 1
// }
// }
// sheriffCredentials {
// username = "sheriffUsername"
// password = "sheriffPassword"
// }
//shrine-steward config
// shrineSteward {
// qepUserName = "qep"
// qepPassword = "trustme"
// stewardBaseUrl = "https://localhost:6443"
// }
// includeAggregateResults = false
//
// maxQueryWaitTime {
// minutes = 5 //must be longer than the hub's maxQueryWaitTime
// }
// broadcasterServiceEndpoint {
// url = "http://example.com/shrine/rest/broadcaster/broadcast" //url for the hub
// acceptAllCerts = true
// timeout {
// seconds = 1
// }
// }
}
hub {
// create = false //change to true to start a hub
maxQueryWaitTime {
// minutes = 4.5 //Needs to be longer than the adapter's maxQueryWaitTime, but shorter than the qep's
}
// downstreamNodes { //Add your downstream nodes here
// shrine-dev2 = "https://shrine-dev2.catalyst:6443/shrine/rest/adapter/requests"
// }
shouldQuerySelf = false //true if there is an adapter at the hub , or just add a loopback address to downstreamNodes
}
adapter {
// create = true by default. False to not create an adapter.
// audit {
// collectAdapterAudit = true by default. False to not fill in the audit database
// database {
// dataSourceFrom = "JNDI" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
// jndiDataSourceName = "java:comp/env/jdbc/adapterAuditDB" //or leave out for tests
// slickProfileClassName = "slick.driver.MySQLDriver$" // Can be
// slick.driver.H2Driver$
// slick.driver.MySQLDriver$
// slick.driver.PostgresDriver$
// slick.driver.SQLServerDriver$
// slick.driver.JdbcDriver$
// freeslick.OracleProfile$
// freeslick.MSSQLServerProfile$
//
// (Yes, with the $ on the end)
// For testing without JNDI
// testDataSource {
//typical test settings for unit tests
//driverClassName = "org.h2.Driver"
//url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1" //H2 embedded in-memory for unit tests
//url = "jdbc:h2:~/stewardTest.h2" //H2 embedded on disk at ~/test
// }
// createTablesOnStart = false //for testing with H2 in memory, when not running unit tests. Set to false normally
// }
// obfuscation {
// binSize = 5 by default //Round to the nearest binSize. Use 1 for no effect (to match SHRINE 1.21 and earlier).
// sigma = 6.5 by default //Noise to inject. Use 0 for no effect. (Use 1.33 to match SHRINE 1.21 and earlier).
// clamp = 10 by default //Maximum ammount of noise to inject. (Use 3 to match SHRINE 1.21 and earlier).
// }
// adapterLockoutAttemptsThreshold = 0 by default // Number of allowed queries with the same actual result that can exist before a researcher is locked out of the adapter. In 1.24 the lockout code and this config value will be removed
// botDefense {
// countsAndMilliseconds = [ //to turn off, use an empty json list
// {count = 10, milliseconds = 60000}, //allow up to 10 queries in one minute by default
// {count = 200, milliseconds = 36000000} //allow up to 4 queries in 10 hours by default
// ]
// }
crcEndpoint {
//must be filled in url = "http://shrine-dev1.catalyst/i2b2/services/QueryToolService/"
}
setSizeObfuscation = true //must be set. false turns off obfuscation
adapterMappingsFileName = "AdapterMappings.xml"
maxSignatureAge {
minutes = 5 //must be longer than the hub's maxQueryWaitTime
}
immediatelyRunIncomingQueries = true //false to queue them
//delayResponse = "0 seconds" //time to delay before responding to a query. Should be 0 except for testing in shrine-qa
}
networkStatusQuery = "\\\\SHRINE\\SHRINE\\Demographics\\Gender\\Male\\"
humanReadableNodeName = "shrine-dev1"
shrineDatabaseType = "mysql"
keystore {
file = "/opt/shrine/shrine.keystore"
password = "changeit"
privateKeyAlias = "shrine-dev1.catalyst"
keyStoreType = "JKS"
caCertAliases = [
"shrine-dev-ca"
]
}
problem {
// problemHandler = "net.shrine.problem.LogAndDatabaseProblemHandler$" Can be other specialized problemHandler implementations
// database {
// dataSourceFrom = "JNDI" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
// jndiDataSourceName = "java:comp/env/jdbc/problemDB"
// slickProfileClassName = "slick.driver.MySQLDriver$" // Can be
// slick.driver.H2Driver$
// slick.driver.MySQLDriver$
// slick.driver.PostgresDriver$
// slick.driver.SQLServerDriver$
// slick.driver.JdbcDriver$
// freeslick.OracleProfile$
// freeslick.MSSQLServerProfile$
//
// (Yes, with the $ on the end)
// For testing without JNDI
// testDataSource {
//typical test settings for unit tests
//driverClassName = "org.h2.Driver"
//url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1" //H2 embedded in-memory for unit tests
//url = "jdbc:h2:~/stewardTest.h2" //H2 embedded on disk at ~/test
// }
// createTablesOnStart = false //for testing with H2 in memory, when not running unit tests. Set to false normally
// }
}
dashboard {
// gruntWatch = false //false for production, true for mvn tomcat7:run . Allows the client javascript and html files to be loaded via gruntWatch .
// happyBaseUrl = "https://localhost:6443/shrine/rest/happy" If the shine servlet is running on a different machime from the dashboard, change this URL to match
// statusBaseUrl = "https://localhost:6443/shrine/rest/internalstatus" If the shine servlet is running on a different machime from the dashboard, change this URL to match
// }
// status {
//permittedHostOfOrigin = "localhost" //If absent then get the host name via java.net.InetAddress.getLocalHost.getHostName . Override to control
}
//Get the older squerl-basd databases through JNDI (inside of tomcant, using tomcat's db connection pool) or directly via a db config here (for testing
squerylDataSource {
// database {
// dataSourceFrom = "JNDI" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
// jndiDataSourceName = "java:comp/env/jdbc/shrineDB" //or leave out for tests
// }
}
authenticate {
// realm = "SHRINE Researcher API" //todo figure out what this means. SHRINE-1978
usersource {
// domain = "i2b2demo" //you must provide your own domain
}
}
steward {
// createTopicsMode = Pending //Can be Pending, Approved, or TopcisIgnoredJustLog. Pending by default
//Pending - new topics start in the Pending state; researchers must wait for the Steward to approve them
//Approved - new topics start in the Approved state; researchers can use them immediately
//TopicsIgnoredJustLog - all queries are logged and approved; researchers don't need to create topics
emailDataSteward {
// sendAuditEmails = true //false to turn off the whole works of emailing the data steward
// interval = "1 day" //Audit researchers daily
// timeAfterMidnight = "6 hours" //Audit researchers at 6 am. If the interval is less than 1 day then this delay is ignored.
// maxQueryCountBetweenAudits = 30 //If a researcher runs more than this many queries since the last audit audit her
// minTimeBetweenAudits = "30 days" //If a researcher runs at least one query, audit those queries if this much time has passed
//You must provide the email address of the shrine node system admin, to handle bounces and invalid addresses
//from = "shrine-admin@example.com"
//You must provide the email address of the data steward
//to = "shrine-steward@example.com"
// subject = "Audit SHRINE researchers"
//The baseUrl for the data steward to be substituted in to email text. Must be supplied if it is used in the email text.
//stewardBaseUrl = "https://example.com:8443/steward/"
//Text to use for the email audit.
// AUDIT_LINES will be replaced by a researcherLine for each researcher to audit.
// STEWARD_BASE_URL will be replaced by the value in stewardBaseUrl if available.
// emailBody = """Please audit the following users at STEWARD_BASE_URL at your earliest convinience:
//
//AUDIT_LINES""" //note that this can be a multiline message
//Text to use per researcher to audit.
//FULLNAME, USERNAME, COUNT and LAST_AUDIT_DATE will be replaced with appropriate text.
// researcherLine = "FULLNAME (USERNAME) has run COUNT queries since LAST_AUDIT_DATE."
}
// database {
// dataSourceFrom = "JNDI" //Can be JNDI or testDataSource . Use testDataSource for tests, JNDI everywhere else
// jndiDataSourceName = "java:comp/env/jdbc/stewardDB" //or leave out for tests
// slickProfileClassName = "slick.driver.MySQLDriver$" // Can be
// slick.driver.H2Driver$
// slick.driver.MySQLDriver$
// slick.driver.PostgresDriver$
// slick.driver.SQLServerDriver$
// slick.driver.JdbcDriver$
// freeslick.OracleProfile$
// freeslick.MSSQLServerProfile$
//
// (Yes, with the $ on the end)
// For testing without JNDI
// testDataSource {
//typical test settings for unit tests
//driverClassName = "org.h2.Driver"
//url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1" //H2 embedded in-memory for unit tests
//url = "jdbc:h2:~/stewardTest.h2" //H2 embedded on disk at ~/test
// }
// createTablesOnStart = false // true for testing with H2 in memory, when not running unit tests. Set to false normally
// }
// gruntWatch = false //false for production, true for mvn tomcat7:run . Allows the client javascript and html files to be loaded via gruntWatch .
}
email {
//add javax mail properties from https://www.tutorialspoint.com/javamail_api/javamail_api_smtp_servers.htm here
// javaxmail {
// mail {
// smtp {
//for postfix on localhost
// host = localhost
// port = 25
//for AWS SES - See http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-using-smtp-java.html
// host = email-smtp.us-east-1.amazonaws.com
// port = 25
// transport.protocol = smtps
// auth = true
// starttls.enable = true
// starttls.required = true
// }
// }
// }
//Must be set for AWS SES. See http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-using-smtp-java.html
// authenticator {
// username = yourUsername
// password = yourPassword
// }
}
}
//Default settings for akka
//akka {
// loglevel = INFO
// log-config-on-start = on
// loggers = ["akka.event.slf4j.Slf4jLogger"]
// Toggles whether the threads created by this ActorSystem should be daemons or not. Use daemonic inside of tomcat to support shutdown
// daemonic = on
//}
//You'll see these settings for spray, baked into the .war files.
//spray.servlet {
// boot-class = "net.shrine.dashboard.net.shrine.metadata.Boot" //Don't change this one. It'll start the wrong (or no) application if you change it.
// request-timeout = 30s
//}