code.grnet.gr Git - aquarium/blob - src/main/scala/gr/grnet/aquarium/Configurator.scala

   1 /*
   2  * Copyright 2011 GRNET S.A. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or
   5  * without modification, are permitted provided that the following
   6  * conditions are met:
   7  *
   8  *   1. Redistributions of source code must retain the above
   9  *      copyright notice, this list of conditions and the following
  10  *      disclaimer.
  11  *
  12  *   2. Redistributions in binary form must reproduce the above
  13  *      copyright notice, this list of conditions and the following
  14  *      disclaimer in the documentation and/or other materials
  15  *      provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  21  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  24  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  25  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  27  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and
  31  * documentation are those of the authors and should not be
  32  * interpreted as representing official policies, either expressed
  33  * or implied, of GRNET S.A.
  34  */
  35
  36 package gr.grnet.aquarium
  37
  38 import actor.{ActorProvider}
  39 import com.ckkloverdos.resource._
  40 import com.ckkloverdos.sys.SysProp
  41 import com.ckkloverdos.props.Props
  42 import com.ckkloverdos.maybe.{Maybe, Failed, Just, NoVal}
  43 import com.ckkloverdos.convert.Converters.{DefaultConverters => TheDefaultConverters}
  44 import processor.actor.{UserEventProcessorService, ResourceEventProcessorService, EventProcessorService}
  45 import store._
  46 import util.{Lifecycle, Loggable}
  47
  48 /**
  49  * The master configurator. Responsible to load all of application configuration and provide the relevant services.
  50  *
  51  * @author Christos KK Loverdos <loverdos@gmail.com>.
  52  */
  53 class Configurator(val props: Props) extends Loggable {
  54   import Configurator.Keys
  55
  56   /**
  57    * Reflectively provide a new instance of a class and configure it appropriately.
  58    */
  59   private[this] def newInstance[C : Manifest](className: String): C = {
  60     val instanceM = Maybe(defaultClassLoader.loadClass(className).newInstance().asInstanceOf[C])
  61     instanceM match {
  62       case Just(instance) ⇒ instance match {
  63         case configurable: Configurable ⇒
  64           Maybe(configurable configure props) match {
  65             case Just(_) ⇒
  66               instance
  67             case Failed(e, _) ⇒
  68               throw new Exception("Could not configure instance of %s".format(className), e)
  69             case NoVal ⇒
  70               throw new Exception("Could not configure instance of %s".format(className))
  71           }
  72         case _ ⇒
  73           instance
  74       }
  75       case Failed(e, _) ⇒
  76         throw new Exception("Could not instantiate %s".format(className), e)
  77       case NoVal ⇒
  78         throw new Exception("Could not instantiate %s".format(className))
  79     }
  80
  81   }
  82
  83   private[this] lazy val _actorProvider: ActorProvider = {
  84     val instance = newInstance[ActorProvider](props.getEx(Keys.actor_provider_class))
  85     logger.info("Loaded ActorProvider: %s".format(instance.getClass))
  86     instance
  87   }
  88
  89   private[this] lazy val _storeProvider: StoreProvider = {
  90     val instance = newInstance[StoreProvider](props.getEx(Keys.store_provider_class))
  91     logger.info("Loaded StoreProvider: %s".format(instance.getClass))
  92     instance
  93   }
  94
  95   private[this] lazy val _restService: Lifecycle = {
  96     val instance = newInstance[Lifecycle](props.getEx(Keys.rest_service_class))
  97     logger.info("Loaded RESTService: %s".format(instance.getClass))
  98     instance
  99   }
 100
 101   private[this] lazy val _userStateStoreM: Maybe[UserStateStore] = {
 102     // If there is a specific `UserStateStore` implementation specified in the
 103     // properties, then this implementation overrides the user store given by
 104     // `StoreProvider`.
 105     props.get(Keys.user_state_store_class) map { className ⇒
 106       val instance = newInstance[UserStateStore](className)
 107       logger.info("Overriding UserStateStore provisioning. Implementation given by: %s".format(instance.getClass))
 108       instance
 109     }
 110   }
 111
 112   private[this] lazy val _resourceEventStoreM: Maybe[ResourceEventStore] = {
 113     // If there is a specific `EventStore` implementation specified in the
 114     // properties, then this implementation overrides the event store given by
 115     // `StoreProvider`.
 116     props.get(Keys.resource_event_store_class) map { className ⇒
 117       val instance = newInstance[ResourceEventStore](className)
 118       logger.info("Overriding EventStore provisioning. Implementation given by: %s".format(instance.getClass))
 119       instance
 120     }
 121   }
 122
 123   private[this] lazy val _userEventStoreM: Maybe[UserEventStore] = {
 124     props.get(Keys.user_event_store_class) map { className ⇒
 125       val instance = newInstance[UserEventStore](className)
 126       logger.info("Overriding UserEventStore provisioning. Implementation given by: %s".format(instance.getClass))
 127       instance
 128     }
 129   }
 130
 131   private[this] lazy val _WalletEventStoreM: Maybe[WalletEntryStore] = {
 132     // If there is a specific `IMStore` implementation specified in the
 133     // properties, then this implementation overrides the event store given by
 134     // `IMProvider`.
 135     props.get(Keys.wallet_entry_store_class) map { className ⇒
 136       val instance = newInstance[WalletEntryStore](className)
 137       logger.info("Overriding WalletEntryStore provisioning. Implementation given by: %s".format(instance.getClass))
 138       instance
 139     }
 140   }
 141
 142   private[this] lazy val _resEventProc: ResourceEventProcessorService = new ResourceEventProcessorService
 143
 144   private[this] lazy val _imEventProc: EventProcessorService = new UserEventProcessorService
 145
 146   def get(key: String, default: String = ""): String = props.getOr(key, default)
 147
 148   def defaultClassLoader = Thread.currentThread().getContextClassLoader
 149
 150   def startServices(): Unit = {
 151     _restService.start()
 152     _actorProvider.start()
 153     _resEventProc.start()
 154     _imEventProc.start()
 155   }
 156
 157   def stopServices(): Unit = {
 158     _imEventProc.stop()
 159     _resEventProc.stop()
 160     _restService.stop()
 161     _actorProvider.stop()
 162
 163 //    akka.actor.Actor.registry.shutdownAll()
 164   }
 165
 166   def stopServicesWithDelay(millis: Long) {
 167     Thread sleep millis
 168     stopServices()
 169   }
 170
 171   def actorProvider = _actorProvider
 172
 173   def userStateStore = {
 174     _userStateStoreM match {
 175       case Just(us) ⇒ us
 176       case _        ⇒ storeProvider.userStateStore
 177     }
 178   }
 179
 180   def resourceEventStore = {
 181     _resourceEventStoreM match {
 182       case Just(es) ⇒ es
 183       case _        ⇒ storeProvider.resourceEventStore
 184     }
 185   }
 186
 187   def walletStore = {
 188     _WalletEventStoreM match {
 189       case Just(es) ⇒ es
 190       case _        ⇒ storeProvider.walletEntryStore
 191     }
 192   }
 193
 194   def userEventStore = {
 195     _userEventStoreM match {
 196       case Just(es) ⇒ es
 197       case _        ⇒ storeProvider.userEventStore
 198     }
 199   }
 200
 201   def storeProvider = _storeProvider
 202 }
 203
 204 object Configurator {
 205   implicit val DefaultConverters = TheDefaultConverters
 206
 207   val MasterConfName = "aquarium.properties"
 208
 209   /**
 210    * Current directory resource context.
 211    * Normally this should be the application installation directory.
 212    *
 213    * It takes priority over `ClasspathBaseResourceContext`.
 214    */
 215   val AppBaseResourceContext = new FileStreamResourceContext(".")
 216
 217   /**
 218    * The venerable /etc resource context
 219    */
 220   val SlashEtcResourceContext = new FileStreamResourceContext("/etc")
 221
 222   /**
 223    * Class loader resource context.
 224    * This has the lowest priority.
 225    */
 226   val ClasspathBaseResourceContext = new ClassLoaderStreamResourceContext(Thread.currentThread().getContextClassLoader)
 227
 228   /**
 229    * Use this property to override the place where aquarium configuration resides.
 230    *
 231    * The value of this property is a folder that defines the highest-priority resource context.
 232    */
 233   val ConfBaseFolderSysProp = SysProp("aquarium.conf.base.folder")
 234
 235   /**
 236    * The resource context used in the application.
 237    */
 238   lazy val MasterResourceContext = {
 239     val rc0 = ClasspathBaseResourceContext
 240     val rc1 = AppBaseResourceContext
 241     val rc2 = SlashEtcResourceContext
 242     val basicContext = new CompositeStreamResourceContext(NoVal, rc2, rc1, rc0)
 243
 244     ConfBaseFolderSysProp.value match {
 245       case Just(value) ⇒
 246         // We have a system override for the configuration location
 247         new CompositeStreamResourceContext(Just(basicContext), new FileStreamResourceContext(value))
 248       case NoVal ⇒
 249         basicContext
 250       case Failed(e, m) ⇒
 251         throw new RuntimeException(m , e)
 252     }
 253   }
 254
 255   lazy val MasterConfResource = {
 256     val maybeMCResource = MasterResourceContext getResource MasterConfName
 257     maybeMCResource match {
 258       case Just(masterConfResource) ⇒
 259         masterConfResource
 260       case NoVal ⇒
 261         throw new RuntimeException("Could not find master configuration file: %s".format(MasterConfName))
 262       case Failed(e, m) ⇒
 263         throw new RuntimeException(m, e)
 264     }
 265   }
 266
 267   lazy val MasterConfProps = {
 268     val maybeProps = Props apply MasterConfResource
 269     maybeProps match {
 270       case Just(props) ⇒
 271         props
 272       case NoVal ⇒
 273         throw new RuntimeException("Could not load master configuration file: %s".format(MasterConfName))
 274       case Failed(e, m) ⇒
 275         throw new RuntimeException(m, e)
 276     }
 277   }
 278
 279   lazy val MasterConfigurator = {
 280     Maybe(new Configurator(MasterConfProps)) match {
 281       case Just(masterConf) ⇒
 282         masterConf
 283       case NoVal ⇒
 284         throw new RuntimeException("Could not initialize master configuration file: %s".format(MasterConfName))
 285       case Failed(e, m) ⇒
 286         throw new RuntimeException(m, e)
 287     }
 288   }
 289
 290   /**
 291    * Defines the names of all the known keys inside the master properties file.
 292    */
 293   final object Keys {
 294     /**
 295      * The Aquarium version. Will be reported in any due occasion.
 296      */
 297     final val version = "version"
 298
 299     /**
 300      * The fully qualified name of the class that implements the `ActorProvider`.
 301      * Will be instantiated reflectively and should have a public default constructor.
 302      */
 303     final val actor_provider_class = "actor.provider.class"
 304
 305     /**
 306      * The class that initializes the REST service
 307      */
 308     final val rest_service_class = "rest.service.class"
 309
 310     /**
 311      * The fully qualified name of the class that implements the `StoreProvider`.
 312      * Will be instantiated reflectively and should have a public default constructor.
 313      */
 314     final val store_provider_class = "store.provider.class"
 315
 316     /**
 317      * The class that implements the User store
 318      */
 319     final val user_state_store_class = "user.state.store.class"
 320
 321     /**
 322      * The class that implements the resource event store
 323      */
 324     final val resource_event_store_class = "resource.event.store.class"
 325
 326     /**
 327      * The class that implements the IM event store
 328      */
 329     final val user_event_store_class = "user.event.store.class"
 330
 331     /**
 332      * The class that implements the wallet entries store
 333      */
 334     final val wallet_entry_store_class = "wallet.entry.store.class"
 335
 336     /** The lower mark for the UserActors' LRU, managed by UserActorManager.
 337      *
 338      * The terminology is borrowed from the (also borrowed) Apache-lucene-solr-based implementation.
 339      *
 340      */
 341     final val user_actors_lru_lower_mark = "user.actors.LRU.lower.mark"
 342
 343     /**
 344      * The upper mark for the UserActors' LRU, managed by UserActorManager.
 345      *
 346      * The terminology is borrowed from the (also borrowed) Apache-lucene-solr-based implementation.
 347      */
 348     final val user_actors_lru_upper_mark = "user.actors.LRU.upper.mark"
 349
 350     /**
 351      * Comma separated list of amqp servers running in active-active
 352      * configuration.
 353      */
 354     final val amqp_servers = "amqp.servers"
 355
 356     /**
 357      * Comma separated list of amqp servers running in active-active
 358      * configuration.
 359      */
 360     final val amqp_port = "amqp.port"
 361
 362     /**
 363      * User name for connecting with the AMQP server
 364      */
 365     final val amqp_username = "amqp.username"
 366
 367     /**
 368      * Passwd for connecting with the AMQP server
 369      */
 370     final val amqp_password = "amqp.passwd"
 371
 372     /**
 373      * Virtual host on the AMQP server
 374      */
 375     final val amqp_vhost = "amqp.vhost"
 376
 377     /**
 378      * Comma separated list of exchanges known to aquarium
 379      */
 380     final val amqp_exchanges = "amqp.exchanges"
 381
 382     /**
 383      * REST service listening port.
 384      *
 385      * Default is 8080.
 386      */
 387     final val rest_port = "rest.port"
 388
 389     /*
 390      * Provider for persistence services
 391      */
 392     final val persistence_provider = "persistence.provider"
 393
 394     /**
 395      * Hostname for the persistence service
 396      */
 397     final val persistence_host = "persistence.host"
 398
 399     /**
 400      * Username for connecting to the persistence service
 401      */
 402     final val persistence_username = "persistence.username"
 403
 404     /**
 405      *  Password for connecting to the persistence service
 406      */
 407     final val persistence_password = "persistence.password"
 408
 409     /**
 410      *  Password for connecting to the persistence service
 411      */
 412     final val persistence_port = "persistence.port"
 413
 414     /**
 415      *  The DB schema to use
 416      */
 417     final val persistence_db = "persistence.db"
 418
 419     /**
 420      * A time period in milliseconds for which we can tolerate stale data regarding user state.
 421      *
 422      * The smaller the value, the more accurate the user credits and other state data are.
 423      *
 424      * If a request for user state (e.g. balance) is received and the request timestamp exceeds
 425      * the timestamp of the last known balance amount by this value, then a re-computation for
 426      * the balance is triggered.
 427      */
 428     final val user_state_timestamp_threshold = "user.state.timestamp.threshold"
 429   }
 430 }