import gr.grnet.aquarium.store._
import gr.grnet.aquarium.connector.rabbitmq.service.RabbitMQService
import gr.grnet.aquarium.converter.StdConverters
-import com.ckkloverdos.resource.FileStreamResource
/**
- * The master configurator. Responsible to load all of application configuration and provide the relevant services.
+ * This is the Aquarium entry point.
+ *
+ * Responsible to load all of application configuration and provide the relevant services.
*
* @author Christos KK Loverdos <loverdos@gmail.com>.
*/
-final class Configurator(val props: Props) extends Loggable {
- import Configurator.Keys
+final class Aquarium(val props: Props) extends Loggable {
+ import Aquarium.Keys
/**
* Reflectively provide a new instance of a class and configure it appropriately.
def storeProvider = _storeProvider
- def withStoreProviderClass[C <: StoreProvider](spc: Class[C]): Configurator = {
+ def withStoreProviderClass[C <: StoreProvider](spc: Class[C]): Aquarium = {
val map = this.props.map
val newMap = map.updated(Keys.store_provider_class, spc.getName)
val newProps = new Props(newMap)
- new Configurator(newProps)
+ new Aquarium(newProps)
}
def eventsStoreFolder = _eventsStoreFolder
- def adminCookie: MaybeOption[String] = props.get(Configurator.Keys.admin_cookie) match {
+ def adminCookie: MaybeOption[String] = props.get(Aquarium.Keys.admin_cookie) match {
case just @ Just(_) ⇒ just
case _ ⇒ NoVal
}
}
-object Configurator {
+object Aquarium {
implicit val DefaultConverters = TheDefaultConverters
final val PolicyConfName = ResourceLocator.ResourceNames.POLICY_YAML
}
}
- lazy val MasterConfigurator = {
- Maybe(new Configurator(AquariumProperties)) match {
+ /**
+ * The main [[gr.grnet.aquarium.Aquarium]] instance.
+ */
+ final lazy val Instance = {
+ Maybe(new Aquarium(AquariumProperties)) match {
case Just(masterConf) ⇒
masterConf
throw error
}
- val mc = Configurator.MasterConfigurator
+ val mc = Aquarium.Instance
for(folder ← mc.eventsStoreFolder) {
- logger.info("{} = {}", Configurator.Keys.events_store_folder, folder)
+ logger.info("{} = {}", Aquarium.Keys.events_store_folder, folder)
}
mc.eventsStoreFolder.throwMe // on error
/**
* Locates resources.
*
- * This code was initially in [[gr.grnet.aquarium.Configurator]].
+ * This code was initially in [[gr.grnet.aquarium.Aquarium]].
*
* @author Christos KK Loverdos <loverdos@gmail.com>
*/
import cc.spray.can.HttpMethods.GET
import cc.spray.can._
import gr.grnet.aquarium.util.Loggable
-import gr.grnet.aquarium.Configurator
+import gr.grnet.aquarium.Aquarium
import akka.actor.Actor
import gr.grnet.aquarium.actor.{RESTRole, RoleableActor, RouterRole}
import RESTPaths.{UserBalancePath, UserStatePath, AdminPingAll}
callRouter(GetUserStateRequest(userId, millis), responder)
case AdminPingAll() ⇒
- val mc = Configurator.MasterConfigurator
+ val mc = Aquarium.Instance
mc.adminCookie match {
case Just(adminCookie) ⇒
- headers.find(_.name.toLowerCase == Configurator.HTTP.RESTAdminHeaderNameLowerCase) match {
+ headers.find(_.name.toLowerCase == Aquarium.HTTP.RESTAdminHeaderNameLowerCase) match {
case Some(cookieHeader) if(cookieHeader.value == adminCookie) ⇒
callRouter(PingAllRequest(), responder)
private[this]
def callRouter(message: RouterRequestMessage, responder: RequestResponder): Unit = {
- val configurator = Configurator.MasterConfigurator
+ val configurator = Aquarium.Instance
val actorProvider = configurator.actorProvider
val router = actorProvider.actorForRole(RouterRole)
val futureResponse = router ask message
import gr.grnet.aquarium.util.shortClassNameOf
import message.config.{ActorProviderConfigured, AquariumPropertiesLoaded}
import akka.config.Supervision.Temporary
-import gr.grnet.aquarium.Configurator
+import gr.grnet.aquarium.Aquarium
import gr.grnet.aquarium.util.date.{TimeHelpers, MutableDateCalc}
import gr.grnet.aquarium.actor.message.event.{ProcessResourceEvent, ProcessIMEvent}
import gr.grnet.aquarium.actor.message.{GetUserStateResponse, GetUserBalanceResponse, GetUserStateRequest, GetUserBalanceRequest}
def role = UserActorRole
- private[this] def _configurator: Configurator = Configurator.MasterConfigurator
+ private[this] def _configurator: Aquarium = Aquarium.Instance
private[this] def _timestampTheshold =
- _configurator.props.getLong(Configurator.Keys.user_state_timestamp_threshold).getOr(10000)
+ _configurator.props.getLong(Aquarium.Keys.user_state_timestamp_threshold).getOr(10000)
private[this] def _haveUserState = {
import gr.grnet.aquarium.util.{safeUnit, shortClassNameOf}
import com.rabbitmq.client.{Envelope, Consumer, ShutdownSignalException, ShutdownListener, ConnectionFactory, Channel, Connection}
import com.rabbitmq.client.AMQP.BasicProperties
-import gr.grnet.aquarium.Configurator
+import gr.grnet.aquarium.Aquarium
import gr.grnet.aquarium.connector.rabbitmq.eventbus.RabbitMQError
import gr.grnet.aquarium.service.event.BusEvent
import gr.grnet.aquarium.connector.handler.{PayloadHandlerExecutor, HandlerResultPanic, HandlerResultRequeue, HandlerResultReject, HandlerResultSuccess, PayloadHandler}
case object ReconnectStartReason extends StartReason
case object PingStartReason extends StartReason
- private[this] def timerService = Configurator.MasterConfigurator.timerService
+ private[this] def timerService = Aquarium.Instance.timerService
private[this] def doSafeShutdownSequence(): Unit = {
_state.set(ShutdownSequence)
}
private[this] def postBusError(event: BusEvent): Unit = {
- Configurator.MasterConfigurator.eventBus ! event
+ Aquarium.Instance.eventBus ! event
}
private[this] def doSchedulePing(): Unit = {
package gr.grnet.aquarium.connector.rabbitmq.service
import com.ckkloverdos.props.Props
-import gr.grnet.aquarium.util.date.TimeHelpers
import gr.grnet.aquarium.util.{Loggable, Lifecycle}
import gr.grnet.aquarium.util.safeUnit
import com.rabbitmq.client.Address
-import gr.grnet.aquarium.{Configurator, Configurable}
+import gr.grnet.aquarium.{Aquarium, Configurable}
import gr.grnet.aquarium.connector.rabbitmq.conf.{TopicExchange, RabbitMQConsumerConf, RabbitMQExchangeType}
import gr.grnet.aquarium.connector.rabbitmq.service.RabbitMQService.RabbitMQConfKeys
import com.ckkloverdos.env.{EnvKey, Env}
def propertyPrefix = Some(RabbitMQService.PropertiesPrefix)
- def configurator = Configurator.MasterConfigurator
+ def aquarium = Aquarium.Instance
- def eventBus = configurator.eventBus
+ def eventBus = aquarium.eventBus
- def resourceEventStore = configurator.resourceEventStore
+ def resourceEventStore = aquarium.resourceEventStore
- def imEventStore = configurator.imEventStore
+ def imEventStore = aquarium.imEventStore
- def converters = configurator.converters
+ def converters = aquarium.converters
- def router = configurator.actorProvider.actorForRole(RouterRole)
+ def router = aquarium.actorProvider.actorForRole(RouterRole)
/**
* Configure this instance with the provided properties.
val rcHandler = new GenericPayloadHandler[ResourceEventModel, ResourceEventStore#ResourceEvent](
jsonParser,
- (payload, error) ⇒ LocalFSEventStore.storeUnparsedResourceEvent(configurator, payload, error),
+ (payload, error) ⇒ LocalFSEventStore.storeUnparsedResourceEvent(aquarium, payload, error),
rcEventParser,
rcEvent ⇒ resourceEventStore.insertResourceEvent(rcEvent),
rcDebugForwardAction
val imHandler = new GenericPayloadHandler[IMEventModel, IMEventStore#IMEvent](
jsonParser,
- (payload, error) ⇒ LocalFSEventStore.storeUnparsedIMEvent(configurator, payload, error),
+ (payload, error) ⇒ LocalFSEventStore.storeUnparsedIMEvent(aquarium, payload, error),
imEventParser,
imEvent ⇒ imEventStore.insertIMEvent(imEvent),
imDebugForwardAction
package gr.grnet.aquarium.logic.accounting
import dsl.{Timeslot, DSLPolicy, DSL}
-import gr.grnet.aquarium.Configurator._
+import gr.grnet.aquarium.Aquarium._
import java.io.{InputStream, FileInputStream, File}
import java.util.Date
import gr.grnet.aquarium.util.date.TimeHelpers
import gr.grnet.aquarium.util.Loggable
import java.util.concurrent.atomic.AtomicReference
-import gr.grnet.aquarium.Configurator
-import gr.grnet.aquarium.Configurator.Keys
+import gr.grnet.aquarium.Aquarium
+import gr.grnet.aquarium.Aquarium.Keys
import com.ckkloverdos.maybe.{Failed, NoVal, Just}
import collection.immutable.{TreeMap, SortedMap}
/* Pointer to the latest policy */
private lazy val currentPolicy = {new AtomicReference[DSLPolicy](latestPolicy)}
- /* Configurator to use for loading information about the policy store */
- private var config: Configurator = _
+ /* Aquarium to use for loading information about the policy store */
+ private var config: Aquarium = _
/**
* Get the latest defined policy.
* Set the configurator to use for loading policy stores. Should only
* used for unit testing.
*/
- def withConfigurator(config: Configurator): Unit =
+ def withConfigurator(config: Aquarium): Unit =
this.config = config
/**
*/
private[logic] def reloadPolicies: SortedMap[Timeslot, DSLPolicy] =
if (config == null)
- reloadPolicies(MasterConfigurator)
+ reloadPolicies(Instance)
else
reloadPolicies(config)
- private def reloadPolicies(config: Configurator):
+ private def reloadPolicies(config: Aquarium):
SortedMap[Timeslot, DSLPolicy] = {
//1. Load policies from db
val pol = config.policyStore.loadPolicyEntriesAfter(0)
//2. Check whether policy file has been updated
val latestPolicyChange = if (pol.isEmpty) 0 else pol.last.validFrom
- val policyf = MasterConfigurator.findConfigFile(PolicyConfName, Keys.aquarium_policy, PolicyConfName)
+ val policyf = Instance.findConfigFile(PolicyConfName, Keys.aquarium_policy, PolicyConfName)
var updated = false
if (policyf.exists) {
import dsl.DSLAgreement
import gr.grnet.aquarium.util.Loggable
-import gr.grnet.aquarium.Configurator
-import gr.grnet.aquarium.Configurator.{MasterConfigurator, Keys}
+import gr.grnet.aquarium.Aquarium
+import gr.grnet.aquarium.Aquarium.{Instance, Keys}
import io.Source
import java.io.{InputStream, File}
import java.util.regex.Pattern
* Load and parse the mappings file
*/
private[logic] def loadMappings = synchronized {
- val config = MasterConfigurator.get(Keys.aquarium_role_agreement_map)
- val configFile = MasterConfigurator.findConfigFile(
- Configurator.RolesAgreementsName, Keys.aquarium_role_agreement_map,
- Configurator.RolesAgreementsName)
+ val config = Aquarium.Instance.get(Keys.aquarium_role_agreement_map)
+ val configFile = Aquarium.Instance.findConfigFile(
+ Aquarium.RolesAgreementsName, Keys.aquarium_role_agreement_map,
+ Aquarium.RolesAgreementsName)
def loadFromClasspath: Source = {
- getClass.getClassLoader.getResourceAsStream(Configurator.RolesAgreementsName) match {
+ getClass.getClassLoader.getResourceAsStream(Aquarium.RolesAgreementsName) match {
case x: InputStream =>
logger.warn("Using default role to agreement mappings, this is " +
"problably not what you want")
import gr.grnet.aquarium.actor.RESTRole
import _root_.akka.actor._
import cc.spray.can.{ServerConfig, HttpClient, HttpServer}
-import gr.grnet.aquarium.util.date.TimeHelpers
-import gr.grnet.aquarium.util.{LogHelpers, Loggable, Lifecycle}
-import gr.grnet.aquarium.{AquariumInternalError, AquariumException, Configurator}
+import gr.grnet.aquarium.util.{Loggable, Lifecycle}
+import gr.grnet.aquarium.{AquariumInternalError, Aquarium}
/**
* REST service based on Actors and Spray.
private[this] var _clientActor: ActorRef = _
def start(): Unit = {
- val mc = Configurator.MasterConfigurator
- this._port = mc.props.getInt(Configurator.Keys.rest_port).getOr(
+ val aquarium = Aquarium.Instance
+ this._port = aquarium.props.getInt(Aquarium.Keys.rest_port).getOr(
throw new AquariumInternalError(
- "%s was not specified in Aquarium properties".format(Configurator.Keys.rest_port)))
+ "%s was not specified in Aquarium properties".format(Aquarium.Keys.rest_port)))
logStoppingF("on port %s", this._port) {
- this._restActor = mc.actorProvider.actorForRole(RESTRole)
+ this._restActor = aquarium.actorProvider.actorForRole(RESTRole)
// Start Spray subsystem
this._serverActor = Actor.actorOf(new HttpServer(ServerConfig(port = this._port))).start()
this._clientActor = Actor.actorOf(new HttpClient()).start()
package gr.grnet.aquarium.store
-import gr.grnet.aquarium.Configurator
+import gr.grnet.aquarium.Aquarium
import java.io.{FileOutputStream, File}
import gr.grnet.aquarium.util.{Loggable, stringOfStackTrace}
import gr.grnet.aquarium.util.date.{TimeHelpers, MutableDateCalc}
writeToFile(file, jsonPayload, appendString)
}
- def storeUnparsedResourceEvent(mc: Configurator, initialPayload: Array[Byte], exception: Throwable): Unit = {
+ def storeUnparsedResourceEvent(mc: Aquarium, initialPayload: Array[Byte], exception: Throwable): Unit = {
for(root <- mc.eventsStoreFolder) {
val occurredMDC = new MutableDateCalc(TimeHelpers.nowMillis())
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
}
}
- def storeResourceEvent(mc: Configurator, event: ResourceEventModel, initialPayload: Array[Byte]): Unit = {
+ def storeResourceEvent(mc: Aquarium, event: ResourceEventModel, initialPayload: Array[Byte]): Unit = {
require(event ne null, "Resource event must be not null")
for(root <- mc.eventsStoreFolder) {
}
}
- def storeUnparsedIMEvent(mc: Configurator, initialPayload: Array[Byte], exception: Throwable): Unit = {
+ def storeUnparsedIMEvent(mc: Aquarium, initialPayload: Array[Byte], exception: Throwable): Unit = {
for(root <- mc.eventsStoreFolder) {
val occurredMDC = new MutableDateCalc(TimeHelpers.nowMillis())
val occurredString = occurredMDC.toFilename_YYYYMMDDHHMMSSSSS
}
}
- def storeIMEvent(mc: Configurator, event: IMEventModel, initialPayload: Array[Byte]): Unit = {
+ def storeIMEvent(mc: Aquarium, event: IMEventModel, initialPayload: Array[Byte]): Unit = {
require(event ne null, "IM event must be not null")
for(root <- mc.eventsStoreFolder) {
val occurredMDC = new MutableDateCalc(event.occurredMillis)
*/
trait StoreConfigurator extends Loggable {
- def configurator: Configurator =
+ def configurator: Aquarium =
LogicTestsAssumptions.propertyValue(PropertyNames.TestStore) match {
- case "mem" => Configurator.MasterConfigurator.withStoreProviderClass(classOf[MemStore])
- case "mongo" => Configurator.MasterConfigurator.withStoreProviderClass(classOf[MongoDBStoreProvider])
+ case "mem" => Aquarium.Instance.withStoreProviderClass(classOf[MemStore])
+ case "mongo" => Aquarium.Instance.withStoreProviderClass(classOf[MongoDBStoreProvider])
case _ =>
logger.warn("Unknown store type, defaulting to \"mem\"")
- Configurator.MasterConfigurator.withStoreProviderClass(classOf[MemStore])
+ Aquarium.Instance.withStoreProviderClass(classOf[MemStore])
}
}
import gr.grnet.aquarium.util.makeString
import gr.grnet.aquarium.converter.StdConverters
import net.liftweb.json.JsonAST.{JValue, JInt}
-import gr.grnet.aquarium.{AquariumException, LogicTestsAssumptions, Configurator}
+import gr.grnet.aquarium.{AquariumException, LogicTestsAssumptions, Aquarium}
+import org.apache.ivy.util.Configurator
/**
*
assumeTrue(LogicTestsAssumptions.EnableSprayTests)
// Initialize configuration subsystem
- val mc = Configurator.MasterConfigurator
- mc.startServices()
- val port = mc.props.getInt(Configurator.Keys.rest_port).getOr(
- throw new AquariumException("No %s specified in aquarium properties".format(Configurator.Keys.rest_port)))
+ val aquarium = Aquarium.Instance
+ aquarium.startServices()
+ val port = aquarium.props.getInt(Aquarium.Keys.rest_port).getOr(
+ throw new AquariumException("No %s specified in aquarium properties".format(Aquarium.Keys.rest_port)))
val dialog = SprayHttpDialog("localhost", port)
val pingReq = HttpRequest(method = GET, uri = "/ping", headers = HttpHeader("Content-Type", "text/plain; charset=UTF-8")::Nil)
}
}
- mc.stopServicesWithDelay(1000)
+ aquarium.stopServicesWithDelay(1000)
}
}
\ No newline at end of file
import com.ckkloverdos.maybe.{Maybe, Just}
import org.junit.{Assert, Ignore, Test}
import gr.grnet.aquarium.logic.accounting.algorithm.{ExecutableCostPolicyAlgorithm, CostPolicyAlgorithmCompiler}
-import gr.grnet.aquarium.{AquariumException, Configurator}
+import gr.grnet.aquarium.{AquariumException}
+import gr.grnet.aquarium.Aquarium.{Instance ⇒ AquariumInstance}
import gr.grnet.aquarium.computation.{UserState, BillingMonthInfo, UserStateComputations}
import gr.grnet.aquarium.computation.reason.MonthlyBillingCalculation
+import org.apache.ivy.util.Configurator
/**
val Synnefo = ClientSim("synnefo")(TheUIDGenerator)
val Pithos = ClientSim("pithos" )(TheUIDGenerator)
- val mc = Configurator.MasterConfigurator.withStoreProviderClass(classOf[MemStore])
- Policy.withConfigurator(mc)
- val StoreProvider = mc.storeProvider
+ val aquarium = AquariumInstance.withStoreProviderClass(classOf[MemStore])
+ Policy.withConfigurator(aquarium)
+ val StoreProvider = aquarium.storeProvider
val ResourceEventStore = StoreProvider.resourceEventStore
val StartOfBillingYearDateCalc = new MutableDateCalc(2012, 1, 1)