refactoring

src/main/kotlin/io/emeraldpay/dshackle/config/AccessLogReader.kt

@@ -1,14 +1,8 @@
 package io.emeraldpay.dshackle.config
 
-import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
 
-class AccessLogReader : YamlConfigReader(), ConfigReader<AccessLogConfig> {
+class AccessLogReader : YamlConfigReader<AccessLogConfig>() {
-
-    companion object {
-        private val log = LoggerFactory.getLogger(AccessLogReader::class.java)
-    }
-
     override fun read(input: MappingNode?): AccessLogConfig {
         return getMapping(input, "accessLog")?.let { node ->
             val enabled = getValueAsBool(node, "enabled") ?: false

src/main/kotlin/io/emeraldpay/dshackle/config/AuthConfigReader.kt

@@ -19,7 +19,7 @@ package io.emeraldpay.dshackle.config
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
 
-class AuthConfigReader : YamlConfigReader() {
+class AuthConfigReader : YamlConfigReader<AuthConfig>() {
 
     companion object {
         private val log = LoggerFactory.getLogger(AuthConfigReader::class.java)
@@ -82,4 +82,8 @@ class AuthConfigReader : YamlConfigReader() {
             auth
         }
     }
+
+    override fun read(input: MappingNode?): AuthConfig? {
+        return null
+    }
 }

src/main/kotlin/io/emeraldpay/dshackle/config/CacheConfigReader.kt

@@ -17,19 +17,13 @@ package io.emeraldpay.dshackle.config
 
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 
-class CacheConfigReader : YamlConfigReader(), ConfigReader<CacheConfig> {
+class CacheConfigReader : YamlConfigReader<CacheConfig>() {
 
     companion object {
         private val log = LoggerFactory.getLogger(CacheConfigReader::class.java)
     }
 
-    fun read(input: InputStream): CacheConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
-
     override fun read(input: MappingNode?): CacheConfig? {
         return getMapping(input, "cache")?.let { node ->
             val config = CacheConfig()

src/main/kotlin/io/emeraldpay/dshackle/config/ChainsConfig.kt

@@ -1,11 +1,19 @@
 package io.emeraldpay.dshackle.config
 
 import io.emeraldpay.dshackle.Chain
+import java.lang.IllegalStateException
 
-class ChainsConfig(var chains: Map<Chain, ChainConfig>, val currentDefault: ChainConfig) {
+class ChainsConfig(private val chains: Map<Chain, RawChainConfig>?, val currentDefault: RawChainConfig?) {
     companion object {
         @JvmStatic
-        fun default(): ChainsConfig = ChainsConfig(emptyMap(), ChainConfig.default())
+        fun default(): ChainsConfig = ChainsConfig(emptyMap(), RawChainConfig.default())
+    }
+
+    data class RawChainConfig(val syncingLagSize: Int?, val laggingLagSize: Int?) {
+        companion object {
+            @JvmStatic
+            fun default() = RawChainConfig(6, 1)
+        }
     }
 
     data class ChainConfig(val syncingLagSize: Int, val laggingLagSize: Int) {
@@ -15,5 +23,15 @@ class ChainsConfig(var chains: Map<Chain, ChainConfig>, val currentDefault: Chai
         }
     }
 
-    fun resolve(chain: Chain) = chains[chain] ?: currentDefault
+    fun resolve(chain: Chain): ChainConfig {
+        val default = currentDefault ?: panic()
+        val raw = chains?.get(chain) ?: default
+
+        return ChainConfig(
+            laggingLagSize = raw.laggingLagSize ?: default.laggingLagSize ?: panic(),
+            syncingLagSize = raw.syncingLagSize ?: default.syncingLagSize ?: panic(),
+        )
+    }
+
+    fun panic(): Nothing = throw IllegalStateException("Chains settings state is illegal - default config is null")
 }

src/main/kotlin/io/emeraldpay/dshackle/config/ChainsConfigReader.kt

@@ -3,43 +3,48 @@ package io.emeraldpay.dshackle.config
 import io.emeraldpay.dshackle.Global
 import org.yaml.snakeyaml.nodes.CollectionNode
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 
-class ChainsConfigReader : YamlConfigReader(), ConfigReader<ChainsConfig> {
+class ChainsConfigReader : YamlConfigReader<ChainsConfig>() {
-
-    fun read(input: InputStream): ChainsConfig {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
 
     override fun read(input: MappingNode?): ChainsConfig {
-        val chains = getList<MappingNode>(input, "chains")?.let {
+        return getMapping(input, "chain-settings")?.let {
-            readChains(it)
-        }
 
-        if (chains == null) {
+            val chains = getList<MappingNode>(it, "chains")?.let {
-            return ChainsConfig.default()
+                readChains(it)
-        } else {
+            }
 
-            val default = chains.firstOrNull { it.first == "default" }?.second ?: ChainsConfig.ChainConfig.default()
+            val default = getMapping(it, "default")?.let {
+                readChain(it)
+            }
 
             return ChainsConfig(
-                chains.filter { it.first != "default" }
+                chains
-                    .map { Global.chainById(it.first) to it.second }
+                    ?.map { Global.chainById(it.first) to it.second }
-                    .associateBy({ it.first }, { it.second }),
+                    ?.associateBy({ it.first }, { it.second }) ?: emptyMap(),
                 default
             )
+        } ?: ChainsConfig.default()
+    }
+
+    private fun readChain(node: MappingNode): ChainsConfig.RawChainConfig? {
+        return getMapping(node, "lags")?.let {
+            return ChainsConfig.RawChainConfig(
+                getValueAsInt(it, "syncing"),
+                getValueAsInt(it, "lagging")
+            )
         }
     }
 
-    private fun readChains(node: CollectionNode<MappingNode>): List<Pair<String, ChainsConfig.ChainConfig>> {
+    private fun readChains(node: CollectionNode<MappingNode>): List<Pair<String, ChainsConfig.RawChainConfig>> {
-        return node.value.map {
+        return node.value.mapNotNull {
-            val key = getValueAsString(it, "name") ?: throw IllegalArgumentException()
+            val key = getValueAsString(it, "name")
-            val value = ChainsConfig.ChainConfig(
+                ?: throw InvalidConfigYamlException(filename, it.startMark, "chain name required")
-                getValueAsInt(it, "syncing-size") ?: throw IllegalArgumentException(),
+            val value = readChain(it)
-                getValueAsInt(it, "lagging-size") ?: throw IllegalArgumentException()
+            if (value != null) {
-            )
+                return@mapNotNull key to value
-            key to value
+            } else {
+                return@mapNotNull null
+            }
         }
     }
 }

src/main/kotlin/io/emeraldpay/dshackle/config/CompressionConfigReader.kt

@@ -1,14 +1,8 @@
 package io.emeraldpay.dshackle.config
 
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
-
-class CompressionConfigReader : YamlConfigReader(), ConfigReader<CompressionConfig> {
-    fun read(input: InputStream): CompressionConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
 
+class CompressionConfigReader : YamlConfigReader<CompressionConfig>() {
     override fun read(input: MappingNode?): CompressionConfig {
         val config = CompressionConfig()
         getMapping(input, "compression")?.let { node ->

src/main/kotlin/io/emeraldpay/dshackle/config/HealthConfigReader.kt

@@ -20,19 +20,13 @@ import io.emeraldpay.dshackle.Global
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.CollectionNode
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 
-class HealthConfigReader : YamlConfigReader(), ConfigReader<HealthConfig> {
+class HealthConfigReader : YamlConfigReader<HealthConfig>() {
 
     companion object {
         private val log = LoggerFactory.getLogger(HealthConfigReader::class.java)
     }
 
-    fun read(input: InputStream): HealthConfig {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
-
     override fun read(input: MappingNode?): HealthConfig {
         return readInternal(getMapping(input, "health"))
     }

src/main/kotlin/io/emeraldpay/dshackle/config/MainConfigReader.kt

@@ -18,11 +18,10 @@ package io.emeraldpay.dshackle.config
 import io.emeraldpay.dshackle.FileResolver
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 
 class MainConfigReader(
     fileResolver: FileResolver
-) : YamlConfigReader(), ConfigReader<MainConfig> {
+) : YamlConfigReader<MainConfig>() {
 
     companion object {
         private val log = LoggerFactory.getLogger(MainConfigReader::class.java)
@@ -40,11 +39,6 @@ class MainConfigReader(
     private val compressionConfigReader = CompressionConfigReader()
     private val chainsConfigReader = ChainsConfigReader()
 
-    fun read(input: InputStream): MainConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
-
     override fun read(input: MappingNode?): MainConfig? {
         val config = MainConfig()
         getValueAsString(input, "host")?.let {

src/main/kotlin/io/emeraldpay/dshackle/config/MonitoringConfigReader.kt

@@ -15,21 +15,9 @@
  */
 package io.emeraldpay.dshackle.config
 
-import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
-
-class MonitoringConfigReader : YamlConfigReader(), ConfigReader<MonitoringConfig> {
-
-    companion object {
-        private val log = LoggerFactory.getLogger(MonitoringConfigReader::class.java)
-    }
-
-    fun read(input: InputStream): MonitoringConfig {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
 
+class MonitoringConfigReader : YamlConfigReader<MonitoringConfig>() {
     override fun read(input: MappingNode?): MonitoringConfig {
         return readInternal(getMapping(input, "monitoring"))
     }

src/main/kotlin/io/emeraldpay/dshackle/config/ProxyConfigReader.kt

@@ -21,25 +21,18 @@ import io.emeraldpay.dshackle.Global
 import org.apache.commons.lang3.StringUtils
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 
 /**
  * Read YAML config, part related to Proxy configuration
  */
-class ProxyConfigReader : YamlConfigReader(), ConfigReader<ProxyConfig> {
+class ProxyConfigReader : YamlConfigReader<ProxyConfig>() {
 
     companion object {
         private val log = LoggerFactory.getLogger(ProxyConfigReader::class.java)
     }
 
-    private var filename = "dshackle.yaml"
     private val authConfigReader = AuthConfigReader()
 
-    fun read(input: InputStream): ProxyConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
-
     override fun read(input: MappingNode?): ProxyConfig? {
         return readInternal(getMapping(input, "proxy"))
     }

src/main/kotlin/io/emeraldpay/dshackle/config/SignatureConfigReader.kt

@@ -1,21 +1,9 @@
 package io.emeraldpay.dshackle.config
 
 import io.emeraldpay.dshackle.FileResolver
-import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
-
-class SignatureConfigReader(val fileResolver: FileResolver) : YamlConfigReader(), ConfigReader<SignatureConfig> {
-
-    companion object {
-        private val log = LoggerFactory.getLogger(SignatureConfig::class.java)
-    }
-
-    fun read(input: InputStream): SignatureConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
 
+class SignatureConfigReader(val fileResolver: FileResolver) : YamlConfigReader<SignatureConfig>() {
     override fun read(input: MappingNode?): SignatureConfig? {
         return getMapping(input, "signed-response")?.let { node ->
             val config = SignatureConfig()

src/main/kotlin/io/emeraldpay/dshackle/config/TokensConfigReader.kt

@@ -18,18 +18,12 @@ package io.emeraldpay.dshackle.config
 import io.emeraldpay.dshackle.Global
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 import java.util.Locale
 
-class TokensConfigReader : YamlConfigReader(), ConfigReader<TokensConfig> {
+class TokensConfigReader : YamlConfigReader<TokensConfig>() {
 
     private val log = LoggerFactory.getLogger(TokensConfigReader::class.java)
 
-    fun read(input: InputStream): TokensConfig? {
-        val configNode = readNode(input)
-        return read(configNode)
-    }
-
     override fun read(input: MappingNode?): TokensConfig? {
         val tokens = getList<MappingNode>(input, "tokens")?.value?.map { node ->
             val token = TokensConfig.Token()

src/main/kotlin/io/emeraldpay/dshackle/config/UpstreamsConfigReader.kt

@@ -20,31 +20,25 @@ import io.emeraldpay.dshackle.FileResolver
 import org.apache.commons.lang3.StringUtils
 import org.slf4j.LoggerFactory
 import org.yaml.snakeyaml.nodes.MappingNode
-import java.io.InputStream
 import java.net.URI
 import java.time.Duration
 import java.util.Locale
 
 class UpstreamsConfigReader(
     private val fileResolver: FileResolver
-) : YamlConfigReader(), ConfigReader<UpstreamsConfig> {
+) : YamlConfigReader<UpstreamsConfig>() {
 
     private val log = LoggerFactory.getLogger(UpstreamsConfigReader::class.java)
     private val authConfigReader = AuthConfigReader()
     private val knownNodeIds: MutableSet<Int> = HashSet()
 
-    fun read(input: InputStream): UpstreamsConfig? {
-        val configNode = readNode(input)
-        return readInternal(configNode)
-    }
-
     override fun read(input: MappingNode?): UpstreamsConfig? {
         return getMapping(input, "cluster")?.let {
             readInternal(it)
         }
     }
 
-    fun readInternal(input: MappingNode?): UpstreamsConfig? {
+    fun readInternal(input: MappingNode?): UpstreamsConfig {
         val config = UpstreamsConfig()
 
         getList<MappingNode>(input, "defaults")?.value?.forEach { opts ->

src/main/kotlin/io/emeraldpay/dshackle/config/YamlConfigReader.kt

@@ -25,9 +25,15 @@ import java.io.InputStream
 import java.io.InputStreamReader
 import java.util.Locale
 
-abstract class YamlConfigReader {
+abstract class YamlConfigReader<T> : ConfigReader<T> {
     private val envVariables = EnvVariables()
 
+    val filename = "dshackle.yaml"
+
+    fun read(input: InputStream): T? {
+        val configNode = readNode(input)
+        return read(configNode)
+    }
     fun readNode(input: String): MappingNode {
         return readNode(input.byteInputStream())
     }

src/main/resources/chains.yaml

@@ -0,0 +1,16 @@
+version: v1
+
+chain-settings:
+  default:
+    lags:
+      syncing: 6
+      lagging: 1
+  chains:
+    - id: eth
+      lags:
+        syncing: 6
+        lagging: 1
+    - name: polygon
+      lags:
+        syncing: 20
+        lagging: 10

src/test/groovy/io/emeraldpay/dshackle/config/YamlConfigReaderSpec.groovy

@@ -15,6 +15,7 @@
  */
 package io.emeraldpay.dshackle.config
 
+import org.jetbrains.annotations.Nullable
 import org.yaml.snakeyaml.Yaml
 import org.yaml.snakeyaml.nodes.MappingNode
 import spock.lang.Specification
@@ -41,5 +42,10 @@ class YamlConfigReaderSpec extends Specification {
         return new Yaml().compose(new StringReader("$key: $value")) as MappingNode
     }
 
-    class Impl extends YamlConfigReader {}
+    class Impl extends YamlConfigReader {
+        @Override
+        Object read(@Nullable MappingNode input) {
+            return null
+        }
+    }
 }

src/test/resources/configs/chains-basic.yaml

@@ -1,7 +1,12 @@
 version: v1
 
-chains:
+chain-settings:
-  - name: eth
+  default:
-    syncing-size: 10
+    lags:
-    lagging-size: 5
+      syncing: 6
-
+      lagging: 1
+  chains:
+    - id: eth
+      lags:
+        syncing: 6
+        lagging: 1