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..9204835eb 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.webApiConfig.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 //}