Remove seemingly unused config parsing classes (#5917)

This commit is contained in:
Christian Sailer 2020-02-13 13:26:15 +00:00 committed by GitHub
parent edf0c25e21
commit 16b2852716
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 0 additions and 161 deletions

View File

@ -1,30 +0,0 @@
package net.corda.common.configuration.parsing.internal.versioned
import com.typesafe.config.Config
import net.corda.common.configuration.parsing.internal.Configuration
import net.corda.common.configuration.parsing.internal.Valid
import net.corda.common.configuration.parsing.internal.valid
import net.corda.common.validation.internal.Validated.Companion.invalid
class VersionedSpecificationRegistry<VALUE> private constructor(private val versionFromConfig: (Config) -> Valid<Int>, private val specifications: Map<Int, Configuration.Specification<VALUE>>) : (Config) -> Valid<Configuration.Specification<VALUE>> {
companion object {
fun <V> mapping(versionParser: Configuration.Value.Parser<Int>, specifications: Map<Int, Configuration.Specification<V>>) = VersionedSpecificationRegistry({ config -> versionParser.parse(config) }, specifications)
fun <V> mapping(versionParser: Configuration.Value.Parser<Int>, vararg specifications: Pair<Int, Configuration.Specification<V>>) = VersionedSpecificationRegistry({ config -> versionParser.parse(config) }, specifications.toMap())
fun <V> mapping(versionParser: (Config) -> Valid<Int>, specifications: Map<Int, Configuration.Specification<V>>) = VersionedSpecificationRegistry(versionParser, specifications)
fun <V> mapping(versionParser: (Config) -> Valid<Int>, vararg specifications: Pair<Int, Configuration.Specification<V>>) = VersionedSpecificationRegistry(versionParser, specifications.toMap())
}
override fun invoke(configuration: Config): Valid<Configuration.Specification<VALUE>> {
return versionFromConfig.invoke(configuration).mapValid { version ->
val value = specifications[version]
value?.let { valid(it) } ?: invalid<Configuration.Specification<VALUE>, Configuration.Validation.Error>(Configuration.Validation.Error.UnsupportedVersion.of(version))
}
}
}

View File

@ -1,131 +0,0 @@
package net.corda.common.configuration.parsing.internal.versioned
import com.typesafe.config.Config
import net.corda.common.configuration.parsing.internal.*
import net.corda.common.validation.internal.Validated
import net.corda.common.validation.internal.Validated.Companion.invalid
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
class VersionedParsingExampleTest {
@Test(timeout=300_000)
fun correct_parsing_function_is_used_for_present_version() {
val versionParser = Configuration.Version.Extractor.fromPath("configuration.metadata.version")
val extractVersion: (Config) -> Valid<Int> = { config -> versionParser.parseRequired(config) }
val parseConfiguration = VersionedSpecificationRegistry.mapping(extractVersion, 1 to RpcSettingsSpec.V1, 2 to RpcSettingsSpec.V2)
val principalAddressValue = Address("localhost", 8080)
val adminAddressValue = Address("127.0.0.1", 8081)
val configurationV1 = configObject("configuration.metadata.version" to 1, "principalHost" to principalAddressValue.host, "principalPort" to principalAddressValue.port, "adminHost" to adminAddressValue.host, "adminPort" to adminAddressValue.port).toConfig().also { println(it.serialize()) }
val rpcSettingsFromVersion1Conf = parseConfiguration.invoke(configurationV1).mapValid { it.parse(configurationV1) }
assertResult(rpcSettingsFromVersion1Conf, principalAddressValue, adminAddressValue)
val addressesValue = configObject("principal" to "${principalAddressValue.host}:${principalAddressValue.port}", "admin" to "${adminAddressValue.host}:${adminAddressValue.port}")
val configurationV2 = configObject("configuration.metadata.version" to 2, "configuration.value.addresses" to addressesValue).toConfig().also { println(it.serialize()) }
val rpcSettingsFromVersion2Conf = parseConfiguration.invoke(configurationV2).mapValid { it.parse(configurationV2) }
assertResult(rpcSettingsFromVersion2Conf, principalAddressValue, adminAddressValue)
}
@Test(timeout=300_000)
fun default_value_is_used_for_absent_version() {
val defaultVersion = 2
val versionParser = Configuration.Version.Extractor.fromPath("configuration.metadata.version", defaultVersion)
val extractVersion: (Config) -> Valid<Int> = { config -> versionParser.parseRequired(config) }
val parseConfiguration = VersionedSpecificationRegistry.mapping(extractVersion, 1 to RpcSettingsSpec.V1, 2 to RpcSettingsSpec.V2)
val principalAddressValue = Address("localhost", 8080)
val adminAddressValue = Address("127.0.0.1", 8081)
val addressesValue = configObject("principal" to "${principalAddressValue.host}:${principalAddressValue.port}", "admin" to "${adminAddressValue.host}:${adminAddressValue.port}")
val configurationV2 = configObject("configuration.value.addresses" to addressesValue).toConfig().also { println(it.serialize()) }
val rpcSettingsFromVersion2Conf = parseConfiguration.invoke(configurationV2).mapValid { it.parse(configurationV2) }
assertResult(rpcSettingsFromVersion2Conf, principalAddressValue, adminAddressValue)
}
private fun assertResult(result: Valid<RpcSettings>, principalAddressValue: Address, adminAddressValue: Address) {
assertThat(result.isValid).isTrue()
assertThat(result.value()).satisfies { value ->
assertThat(value.principal).isEqualTo(principalAddressValue)
assertThat(value.admin).isEqualTo(adminAddressValue)
}
}
private data class RpcSettings(val principal: Address, val admin: Address)
private object RpcSettingsSpec {
private fun addressFor(host: String, port: Int): Valid<Address> {
return try {
require(host.isNotBlank())
require(port > 0)
Validated.valid(Address(host, port))
} catch (e: Exception) {
return Validated.invalid(Configuration.Validation.Error.BadValue.of(host, Address::class.java.simpleName, "Value must be of format \"host(String):port(Int > 0)\" e.g., \"127.0.0.1:8080\""))
}
}
object V1 : Configuration.Specification<RpcSettings>("RpcSettings") {
private val principalHost by string()
private val principalPort by int()
private val adminHost by string()
private val adminPort by int()
override fun parseValid(configuration: Config): Valid<RpcSettings> {
val principalHost = configuration[principalHost]
val principalPort = configuration[principalPort]
val adminHost = configuration[adminHost]
val adminPort = configuration[adminPort]
val principalAddress = addressFor(principalHost, principalPort)
val adminAddress = addressFor(adminHost, adminPort)
return if (principalAddress.isValid && adminAddress.isValid) {
return valid(RpcSettings(principalAddress.value(), adminAddress.value()))
} else {
invalid(principalAddress.errors + adminAddress.errors)
}
}
}
object V2 : Configuration.Specification<RpcSettings>("RpcSettings", prefix = "configuration.value") {
private object AddressesSpec : Configuration.Specification<Addresses>("Addresses") {
val principal by string().mapValid(::parseAddress)
val admin by string().mapValid(::parseAddress)
override fun parseValid(configuration: Config) = valid(Addresses(configuration[principal],configuration[admin]))
private fun parseAddress(rawValue: String): Valid<Address> {
return Address.validFromRawValue(rawValue) { error -> Configuration.Validation.Error.BadValue.of(error) }
}
}
private val addresses by nested(AddressesSpec)
override fun parseValid(configuration: Config): Valid<RpcSettings> {
val addresses = configuration[addresses]
return valid(RpcSettings(addresses.principal, addresses.admin))
}
}
}
}
private fun Configuration.Version.Extractor.parseRequired(config: Config, options: Configuration.Validation.Options = Configuration.Validation.Options.defaults) = parse(config, options).map { it }