Merge pull request #20 from dsx-tech/refactoring

Remove redundant class ConfigManager

Author: pltanton

rhea-core/src/main/kotlin/uk/dsxt/rhea/ConfigManager.kt

@@ -18,7 +18,7 @@ open class PropertyGroup {
 
     private val group = javaClass.kotlin.simpleName
 
-    private fun groupName() = group?.substringBefore("$") ?: reactiveConfigLogger.error("Unexpected name $group")
+    private fun groupName() = group?.substringBefore("$") ?: ReactiveConfig.reactiveConfigLogger.error("Unexpected name $group")
 
     private fun name(): String = outer() + groupName()
 

rhea-core/src/main/kotlin/uk/dsxt/rhea/PropertyGroup.kt

@@ -1,20 +1,41 @@
 package uk.dsxt.rhea
 
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.channels.BroadcastChannel
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.asFlow
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import mu.KotlinLogging
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.EmptyCoroutineContext
 
 /**
- * [ConfigSource] that reads configuration from Vault.
+ * [ReactiveConfig] manages configuration.
  *
  * **Note: use [Builder] to build instances of this class.
  */
-class ReactiveConfig private constructor(val manager: ConfigManager) {
+class ReactiveConfig private constructor(
+    private val mapOfSources: MutableMap<String, ConfigSource>,
+    private val configScope: CoroutineScope,
+    private val channelOfChanges: BroadcastChannel<RawProperty>
+) {
+    private val flowOfChanges: Flow<RawProperty> = channelOfChanges.asFlow()
+    private val mapOfProperties: MutableMap<String, Reloadable<*>> = ConcurrentHashMap()
+
+    companion object {
+        val reactiveConfigLogger = KotlinLogging.logger {}
+    }
 
     /**
      * Builder for [ReactiveConfig].
      */
     class Builder {
-        private val manager: ConfigManager = ConfigManager()
+        private val mapOfSources: MutableMap<String, ConfigSource> = ConcurrentHashMap()
+        private val configScope = CoroutineScope(EmptyCoroutineContext)
+        private val channelOfChanges: BroadcastChannel<RawProperty> = BroadcastChannel(Channel.BUFFERED)
 
         /**
          * Adds configuration [source] in [ReactiveConfig]s built.
@@ -25,8 +46,11 @@ class ReactiveConfig private constructor(val manager: ConfigManager) {
          */
         fun addSource(name: String, source: ConfigSource): Builder {
             return apply {
-                manager.mapOfSources[name] = source
-                manager.addSource(source)
+                mapOfSources[name] = source
+                configScope.launch {
+                    source.subscribe(channelOfChanges, configScope)
+                }
+                Thread.sleep(100)
             }
         }
 
@@ -36,25 +60,25 @@ class ReactiveConfig private constructor(val manager: ConfigManager) {
          * @return new instance of [ReactiveConfig]
          */
         fun build(): ReactiveConfig {
-            return ReactiveConfig(manager)
+            return ReactiveConfig(mapOfSources, configScope, channelOfChanges)
         }
     }
 
     /**
      * @return [Reloadable] that holds the freshest value of property with given [key] and [type].
      */
     operator fun <T> get(key: String, type: PropertyType<T>): Reloadable<T>? {
-        if (manager.mapOfProperties.containsKey(key)) {
-            with(manager.mapOfProperties[key]) {
+        if (mapOfProperties.containsKey(key)) {
+            with(mapOfProperties[key]) {
                 return this as Reloadable<T>
             }
         } else {
             synchronized(this) {
-                if (!manager.mapOfProperties.containsKey(key)) {
+                if (!mapOfProperties.containsKey(key)) {
                     var isSet = false
                     var initialValue: T = type.initial
 
-                    for (source in manager.mapOfSources.values) {
+                    for (source in mapOfSources.values) {
                         with(type.parse(source.getNode(key))) {
                             when (this) {
                                 is ParseResult.Success -> {
@@ -71,7 +95,7 @@ class ReactiveConfig private constructor(val manager: ConfigManager) {
                     if (isSet) {
                         return Reloadable(
                             initialValue,
-                            manager.flowOfChanges
+                            flowOfChanges
                                 .filter { rawProperty: RawProperty ->
                                     rawProperty.key == key
                                 }
@@ -89,16 +113,16 @@ class ReactiveConfig private constructor(val manager: ConfigManager) {
                                 .map {
                                     it as T
                                 },
-                            manager.configScope
+                            configScope
                         ).also {
-                            manager.mapOfProperties[key] = it
+                            mapOfProperties[key] = it
                         }
                     } else {
                         reactiveConfigLogger.error("Couldn't find property with key=$key in any config sources")
                         return null
                     }
                 } else {
-                    with(manager.mapOfProperties[key]) {
+                    with(mapOfProperties[key]) {
                         return this as Reloadable<T>
                     }
                 }

rhea-core/src/main/kotlin/uk/dsxt/rhea/ReactiveConfig.kt

@@ -3,14 +3,16 @@ package uk.dsxt.rhea
 import org.spekframework.spek2.Spek
 import org.spekframework.spek2.style.specification.describe
 import kotlin.test.assertNotNull
-import kotlin.test.assertTrue
+import kotlin.test.assertNull
 
-object outer : PropertyGroup(){
+object outer : PropertyGroup() {
     val first by booleanType
+
     object inside : PropertyGroup() {
         object deeper : PropertyGroup() {
             val anotherone by intType.nullable()
         }
+
         val third by stringType
     }
 }
@@ -21,7 +23,7 @@ object PropertyGroupTest : Spek({
         .addSource("configMock", source)
         .build()
 
-    describe("emitting values with our keys"){
+    describe("emitting values with our keys") {
         source.addToMap("outer.inside.deeper.anotherone", null)
         source.addToMap("outer.inside.third", "three")
         source.addToMap("outer.first", true)
@@ -31,8 +33,9 @@ object PropertyGroupTest : Spek({
     val reloadable2 = config[outer.inside.third]
     val reloadable3 = config[outer.first]
 
-    describe("wait until reloadables will be created"){
-        while (reloadable3 == null){}
+    describe("wait until reloadables will be created") {
+        while (reloadable3 == null) {
+        }
     }
 
     describe("asserting that right keys created")
@@ -42,10 +45,10 @@ object PropertyGroupTest : Spek({
             assertNotNull(reloadable2)
             assertNotNull(reloadable3)
         }
-        it("keys should be added to the map"){
-            assertTrue(config.manager.mapOfProperties.containsKey("outer.inside.deeper.anotherone"))
-            assertTrue(config.manager.mapOfProperties.containsKey("outer.inside.third"))
-            assertTrue(config.manager.mapOfProperties.containsKey("outer.first"))
+        it("keys should be added to the map") {
+            assertNotNull(config["outer.inside.deeper.anotherone", intType.nullable()])
+            assertNotNull(config["outer.inside.third", stringType])
+            assertNull(config["outer.firs", booleanType])
         }
     }
 })