1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
package com.drivergrp.core
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport
import akka.http.scaladsl.model.StatusCodes
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.server.RouteResult._
import akka.http.scaladsl.server.{Route, RouteConcatenation}
import akka.stream.ActorMaterializer
import com.drivergrp.core.logging.{Logger, TypesafeScalaLogger}
import com.drivergrp.core.rest.Swagger
import com.drivergrp.core.time.provider.{SystemTimeProvider, TimeProvider}
import com.typesafe.config.Config
import org.slf4j.LoggerFactory
import spray.json.DefaultJsonProtocol
import scala.concurrent.Await
import scala.concurrent.duration._
object app {
class DriverApp(version: String, buildNumber: Int,
modules: Seq[Module],
time: TimeProvider = new SystemTimeProvider(),
log: Logger = new TypesafeScalaLogger(
com.typesafe.scalalogging.Logger(LoggerFactory.getLogger(classOf[DriverApp]))),
config: Config = com.drivergrp.core.config.loadDefaultConfig,
interface: String = "localhost", port: Int = 8080) {
implicit private lazy val actorSystem = ActorSystem("spray-routing", config)
implicit private lazy val executionContext = actorSystem.dispatcher
implicit private lazy val materializer = ActorMaterializer()(actorSystem)
private lazy val http = Http()(actorSystem)
def run() = {
activateServices(modules)
scheduleServicesDeactivation(modules)
bindHttp(modules)
Console.print(s"${this.getClass.getName} App is started")
}
def stop() = {
http.shutdownAllConnectionPools().onComplete { _ =>
val _ = actorSystem.terminate()
val terminated = Await.result(actorSystem.whenTerminated, 30.seconds)
val addressTerminated = if(terminated.addressTerminated) "is" else "is not"
Console.print(s"${this.getClass.getName} App $addressTerminated stopped ")
}
}
protected def bindHttp(modules: Seq[Module]) {
import SprayJsonSupport._
import DefaultJsonProtocol._
val serviceTypes = modules.flatMap(_.routeTypes)
val swaggerService = new Swagger(actorSystem, serviceTypes, config)
val swaggerRoutes = swaggerService.routes ~ swaggerService.swaggerUI
val versionRoute = path("version") {
complete(Map(
"version" -> version,
"buildNumber" -> buildNumber.toString,
"serverTime" -> time.currentTime().millis.toString
))
}
val _ = http.bindAndHandle(
route2HandlerFlow(logRequestResult("log")(
modules.map(_.route).foldLeft(versionRoute ~ swaggerRoutes) { _ ~ _ })),
interface, port)(materializer)
}
/**
* Initializes services
*/
protected def activateServices(services: Seq[Module]) = {
services.foreach { service =>
Console.print(s"Service ${service.name} starts ...")
try {
service.activate()
} catch {
case t: Throwable =>
log.fatal(s"Service ${service.name} failed to activate", t)
Console.print(" Failed! (check log)")
}
Console.println(" Done")
}
}
/**
* Schedules services to be deactivated on the app shutdown
*/
protected def scheduleServicesDeactivation(services: Seq[Module]) = {
Runtime.getRuntime.addShutdownHook(new Thread() {
override def run(): Unit = {
services.foreach { service =>
Console.print(s"Service ${service.name} shutting down ...")
try {
service.deactivate()
} catch {
case t: Throwable =>
log.fatal(s"Service ${service.name} failed to deactivate", t)
Console.print(" Failed! (check log)")
}
Console.println(" Done")
}
}
})
}
}
import scala.reflect.runtime.universe._
trait Module {
val name: String
def route: Route
def routeTypes: Seq[Type]
def activate(): Unit = {}
def deactivate(): Unit = {}
}
class EmptyModule extends Module {
val name = "Nothing"
def route: Route = complete(StatusCodes.OK)
def routeTypes = Seq.empty[Type]
}
class SimpleModule(val name: String, val route: Route, routeType: Type) extends Module {
def routeTypes: Seq[Type] = Seq(routeType)
}
/**
* Module implementation which may be used to composed a few
*
* @param name more general name of the composite module,
* must be provided as there is no good way to automatically
* generalize the name from the composed modules' names
* @param modules modules to compose into a single one
*/
class CompositeModule(val name: String, modules: Seq[Module])
extends Module with RouteConcatenation {
def route: Route = modules.map(_.route).reduce(_ ~ _)
def routeTypes = modules.flatMap(_.routeTypes)
override def activate() = modules.foreach(_.activate())
override def deactivate() = modules.reverse.foreach(_.deactivate())
}
}
|
