{
"logLevel": "DEBUG",
- "server": {
- "listenPort": 6061,
- "idleTimeoutSec": 60,
- "maxPayloadSizeBytes": 1048576
- },
- "cbs": {
- "firstRequestDelaySec": 10,
- "requestIntervalSec": 5
- },
- "security": {
- "keys": {
- "keyStoreFile": "/etc/ves-hv/ssl/server.p12",
- "keyStorePassword": "onaponap",
- "trustStoreFile": "/etc/ves-hv/ssl/trust.p12",
- "trustStorePassword": "onaponap"
- }
- }
+ "server.listenPort": 6061,
+ "server.idleTimeoutSec": 60,
+ "server.maxPayloadSizeBytes": 1048576,
+ "cbs.firstRequestDelaySec": 10,
+ "cbs.requestIntervalSec": 5,
+ "security.keys.keyStoreFile": "/etc/ves-hv/ssl/server.p12",
+ "security.keys.keyStorePassword": "onaponap",
+ "security.keys.trustStoreFile": "/etc/ves-hv/ssl/trust.p12",
+ "security.keys.trustStorePassword": "onaponap"
}
\ No newline at end of file
{
"logLevel": "DEBUG",
- "server": {
- "listenPort": 8061,
- "idleTimeoutSec": 60,
- "maxPayloadSizeBytes": 1048576
- },
- "cbs": {
- "firstRequestDelaySec": 10,
- "requestIntervalSec": 5
- },
- "security": {
- "keys": {
- "keyStoreFile": "development/ssl/server.p12",
- "keyStorePassword": "onaponap",
- "trustStoreFile": "development/ssl/trust.p12",
- "trustStorePassword": "onaponap"
- }
- }
-}
\ No newline at end of file
+ "server.listenPort": 8061,
+ "server.idleTimeoutSec": 60,
+ "server.maxPayloadSizeBytes": 1048576,
+ "cbs.firstRequestDelaySec": 10,
+ "cbs.requestIntervalSec": 5,
+ "security.keys.keyStoreFile": "development/ssl/server.p12",
+ "security.keys.keyStorePassword": "onaponap",
+ "security.keys.trustStoreFile": "development/ssl/trust.p12",
+ "security.keys.trustStorePassword": "onaponap"
+}
.map(::createRoutingDescription)
.onErrorLog(logger, mdc) { "Error while creating configuration" }
.retryWhen(retry)
- .map { PartialConfiguration(collector = Some(PartialCollectorConfig(routing = it))) }
+ .map { PartialConfiguration(routing = it) }
private fun createRoutingDescription(configuration: JsonObject): Option<Routing> = try {
val routes = DataStreams.namedSinks(configuration)
package org.onap.dcae.collectors.veshv.config.impl
-import arrow.core.None
import arrow.core.Option
import arrow.core.Some
import arrow.core.getOrElse
import arrow.core.toOption
-import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
+import kotlin.reflect.KProperty0
+import kotlin.reflect.KProperty1
/**
* @author Pawel Biniek <pawel.biniek@nokia.com>
internal class ConfigurationMerger {
fun merge(base: PartialConfiguration, update: PartialConfiguration): PartialConfiguration =
PartialConfiguration(
- mergeServerConfig(base.server, update.server),
- mergeCbsConfig(base.cbs, update.cbs),
- mergeSecurityConfig(base.security, update.security),
- mergeCollectorConfig(base.collector, update.collector),
- mergeLogLevel(base.logLevel, update.logLevel)
- )
-
-
- private fun mergeServerConfig(baseOption: Option<PartialServerConfig>,
- updateOption: Option<PartialServerConfig>) =
- applyUpdate(baseOption, updateOption) { base, update ->
- PartialServerConfig(
- base.listenPort.updateToGivenOrNone(update.listenPort),
- base.idleTimeoutSec.updateToGivenOrNone(update.idleTimeoutSec),
- base.maxPayloadSizeBytes.updateToGivenOrNone(update.maxPayloadSizeBytes)
- )
- }
+ listenPort = base.listenPort.updateToGivenOrNone(update.listenPort),
+ idleTimeoutSec = base.idleTimeoutSec.updateToGivenOrNone(update.idleTimeoutSec),
+ maxPayloadSizeBytes = base.maxPayloadSizeBytes.updateToGivenOrNone(update.maxPayloadSizeBytes),
+ firstRequestDelaySec = base.firstRequestDelaySec.updateToGivenOrNone(update.firstRequestDelaySec),
+ requestIntervalSec = base.requestIntervalSec.updateToGivenOrNone(update.requestIntervalSec),
- private fun mergeCbsConfig(baseOption: Option<PartialCbsConfig>,
- updateOption: Option<PartialCbsConfig>) =
- applyUpdate(baseOption, updateOption) { base, update ->
- PartialCbsConfig(
- base.firstRequestDelaySec.updateToGivenOrNone(update.firstRequestDelaySec),
- base.requestIntervalSec.updateToGivenOrNone(update.requestIntervalSec)
- )
- }
+ sslDisable = base.sslDisable.updateToGivenOrNone(update.sslDisable),
+ keyStoreFile = base.keyStoreFile.updateToGivenOrNone(update.keyStoreFile),
+ keyStorePassword = base.keyStorePassword.updateToGivenOrNone(update.keyStorePassword),
+ trustStoreFile = base.trustStoreFile.updateToGivenOrNone(update.trustStoreFile),
+ trustStorePassword = base.trustStorePassword.updateToGivenOrNone(update.trustStorePassword),
- private fun mergeSecurityConfig(baseOption: Option<PartialSecurityConfig>,
- updateOption: Option<PartialSecurityConfig>) =
- applyUpdate(baseOption, updateOption) { base, update ->
- PartialSecurityConfig(
- base.keys.updateToGivenOrNone(update.keys)
- )
- }
+ routing = base.routing.updateToGivenOrNone(update.routing),
- private fun mergeCollectorConfig(baseOption: Option<PartialCollectorConfig>,
- updateOption: Option<PartialCollectorConfig>) =
- applyUpdate(baseOption, updateOption) { base, update ->
- PartialCollectorConfig(
- base.routing.updateToGivenOrNone(update.routing)
- )
- }
+ logLevel = base.logLevel.updateToGivenOrNone(update.logLevel)
+ )
+ private fun <T> Option<T>.updateToGivenOrNone(update: Option<T>) =
+ update.getOrElse(this::orNull).toOption()
- private fun mergeLogLevel(base: Option<LogLevel>, update: Option<LogLevel>) =
- base.updateToGivenOrNone(update)
}
-private fun <T> applyUpdate(base: Option<T>, update: Option<T>, overrider: (base: T, update: T) -> T) =
- when {
- base is Some && update is Some -> overrider(base.t, update.t).toOption()
- base is Some && update is None -> base
- base is None && update is Some -> update
- else -> None
- }
-private fun <T> Option<T>.updateToGivenOrNone(update: Option<T>) =
- update.getOrElse(this::orNull).toOption()
+
*/
package org.onap.dcae.collectors.veshv.config.impl
-import arrow.core.Either
import arrow.core.None
import arrow.core.Option
+import arrow.core.Some
import arrow.core.getOrElse
import org.onap.dcae.collectors.veshv.config.api.model.CbsConfiguration
import org.onap.dcae.collectors.veshv.config.api.model.CollectorConfiguration
import org.onap.dcae.collectors.veshv.utils.arrow.doOnEmpty
import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
import org.onap.dcae.collectors.veshv.utils.logging.Logger
+import java.io.File
/**
* @author Jakub Dudycz <jakub.dudycz@nokia.com>
.doOnEmpty { logger.debug { "Cannot bind cbs configuration" } }
.bind()
- val securityConfiguration = validatedSecurityConfiguration(partialConfig)
+ val securityConfiguration = determineSecurityConfiguration(partialConfig)
.doOnEmpty { logger.debug { "Cannot bind security configuration" } }
.bind()
private fun validatedServerConfiguration(partial: PartialConfiguration) =
partial.mapBinding {
- partial.server.bind().let {
- ServerConfiguration(
- it.listenPort.bind(),
- it.idleTimeoutSec.bind(),
- it.maxPayloadSizeBytes.bind()
- )
- }
+ ServerConfiguration(
+ it.listenPort.bind(),
+ it.idleTimeoutSec.bind(),
+ it.maxPayloadSizeBytes.bind()
+ )
}
internal fun validatedCbsConfiguration(partial: PartialConfiguration) =
partial.mapBinding {
- it.cbs.bind().let {
- CbsConfiguration(
- it.firstRequestDelaySec.bind(),
- it.requestIntervalSec.bind()
- )
- }
+ CbsConfiguration(
+ it.firstRequestDelaySec.bind(),
+ it.requestIntervalSec.bind()
+ )
}
- private fun validatedSecurityConfiguration(partial: PartialConfiguration) =
- partial.mapBinding {
- it.security.bind().let {
- SecurityConfiguration(it.keys.map(SecurityKeysPaths::asImmutableSecurityKeys))
+ private fun determineSecurityConfiguration(partial: PartialConfiguration) =
+ partial.sslDisable.fold({ createSecurityConfiguration(partial) }, { sslDisabled ->
+ if (sslDisabled) {
+ Some(SecurityConfiguration(None))
+ } else {
+ createSecurityConfiguration(partial)
}
+ })
+
+ private fun createSecurityConfiguration(partial: PartialConfiguration): Option<SecurityConfiguration> =
+ partial.mapBinding {
+ SecurityConfiguration(
+ Option.fromNullable(SecurityKeysPaths(
+ File(it.keyStoreFile.bind()).toPath(),
+ it.keyStorePassword.bind(),
+ File(it.trustStoreFile.bind()).toPath(),
+ it.trustStorePassword.bind()
+ ).asImmutableSecurityKeys())
+ )
}
private fun validatedCollectorConfig(partial: PartialConfiguration) =
partial.mapBinding {
- partial.collector.bind().let {
- CollectorConfiguration(
- it.routing.bind()
- )
- }
+ CollectorConfiguration(
+ it.routing.bind()
+ )
}
companion object {
import com.google.gson.GsonBuilder
import org.onap.dcae.collectors.veshv.config.impl.gsonadapters.DurationOfSecondsAdapter
import org.onap.dcae.collectors.veshv.config.impl.gsonadapters.OptionAdapter
-import org.onap.dcae.collectors.veshv.config.impl.gsonadapters.SecurityAdapter
import org.onap.dcae.collectors.veshv.utils.logging.Logger
import java.io.Reader
internal class FileConfigurationReader {
private val gson = GsonBuilder()
.registerTypeAdapter(Option::class.java, OptionAdapter())
- .registerTypeAdapter(PartialSecurityConfig::class.java, SecurityAdapter())
.registerTypeAdapter(Duration::class.java, DurationOfSecondsAdapter())
.create()
+++ /dev/null
-/*
- * ============LICENSE_START=======================================================
- * dcaegen2-collectors-veshv
- * ================================================================================
- * Copyright (C) 2019 NOKIA
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-package org.onap.dcae.collectors.veshv.config.impl.gsonadapters
-
-import arrow.core.Option
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import org.onap.dcae.collectors.veshv.config.impl.PartialSecurityConfig
-import org.onap.dcae.collectors.veshv.ssl.boundary.SecurityKeysPaths
-import java.io.File
-import java.lang.reflect.Type
-
-/**
- * @author Pawel Biniek <pawel.biniek@nokia.com>
- * @since March 2019
- */
-internal class SecurityAdapter : JsonDeserializer<PartialSecurityConfig> {
-
- override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext?) =
- json.asJsonObject.let { security ->
- if (security.entrySet().isEmpty() || hasSslDisableSet(security)) {
- PartialSecurityConfig(Option.empty())
- } else {
- PartialSecurityConfig(Option.just(security.securityKeys(::asImmutableSecurityKeys)))
- }
- }
-
- private fun hasSslDisableSet(security: JsonObject) =
- security.has(SSL_DISABLE_KEY) && security[SSL_DISABLE_KEY].asBoolean
-
- private fun JsonObject.securityKeys(f: (JsonObject) -> SecurityKeysPaths) = f(getAsJsonObject(KEYS_OBJECT_KEY))
-
- private fun asImmutableSecurityKeys(keys: JsonObject) = SecurityKeysPaths(
- File(keys[KEY_STORE_FILE_KEY].asString).toPath(),
- keys[KEY_STORE_PASSWORD_KEY].asString,
- File(keys[TRUST_STORE_FILE_KEY].asString).toPath(),
- keys[TRUST_STORE_PASSWORD_KEY].asString
- )
-
- companion object {
- private val SSL_DISABLE_KEY = "sslDisable"
- private val KEYS_OBJECT_KEY = "keys"
- private val KEY_STORE_FILE_KEY = "keyStoreFile"
- private val KEY_STORE_PASSWORD_KEY = "keyStorePassword"
- private val TRUST_STORE_FILE_KEY = "trustStoreFile"
- private val TRUST_STORE_PASSWORD_KEY = "trustStorePassword"
- }
-}
-
import arrow.core.None
import arrow.core.Option
+import com.google.gson.annotations.SerializedName
import org.onap.dcae.collectors.veshv.config.api.model.Routing
-import org.onap.dcae.collectors.veshv.ssl.boundary.SecurityKeysPaths
import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
import java.time.Duration
* @since February 2019
*/
internal data class PartialConfiguration(
- val server: Option<PartialServerConfig> = None,
- val cbs: Option<PartialCbsConfig> = None,
- val security: Option<PartialSecurityConfig> = None,
- val collector: Option<PartialCollectorConfig> = None,
- val logLevel: Option<LogLevel> = None
-)
-
-internal data class PartialServerConfig(
+ @SerializedName("server.listenPort")
val listenPort: Option<Int> = None,
+ @SerializedName("server.idleTimeoutSec")
val idleTimeoutSec: Option<Duration> = None,
- val maxPayloadSizeBytes: Option<Int> = None
-)
+ @SerializedName("server.maxPayloadSizeBytes")
+ val maxPayloadSizeBytes: Option<Int> = None,
-internal data class PartialCbsConfig(
+ @SerializedName("cbs.firstRequestDelaySec")
val firstRequestDelaySec: Option<Duration> = None,
- val requestIntervalSec: Option<Duration> = None
-)
+ @SerializedName("cbs.requestIntervalSec")
+ val requestIntervalSec: Option<Duration> = None,
+
+ @SerializedName("security.sslDisable")
+ val sslDisable: Option<Boolean> = None,
+ @SerializedName("security.keys.keyStoreFile")
+ val keyStoreFile: Option<String> = None,
+ @SerializedName("security.keys.keyStorePassword")
+ val keyStorePassword: Option<String> = None,
+ @SerializedName("security.keys.trustStoreFile")
+ val trustStoreFile: Option<String> = None,
+ @SerializedName("security.keys.trustStorePassword")
+ val trustStorePassword: Option<String> = None,
-internal data class PartialSecurityConfig(val keys: Option<SecurityKeysPaths> = None)
+ @SerializedName("collector.routing")
+ val routing: Option<Routing> = None,
-internal data class PartialCollectorConfig(
- val routing: Option<Routing> = None
+ @SerializedName("logLevel")
+ val logLevel: Option<LogLevel> = None
)
StepVerifier.create(configProvider().take(1))
.consumeNextWith {
- val routes = it.collector.orNull()!!.routing.orNull()!!
+ val routes = it.routing.orNull()!!
val route1 = routes.elementAt(0)
val route2 = routes.elementAt(1)
val receivedSink1 = route1.sink
assertThat(result.logLevel).isEqualTo(Some(LogLevel.INFO))
}
+ val someListenPort = Some(45)
it("merges single embedded parameter into empty config") {
val actual = PartialConfiguration()
- val serverConfig = PartialServerConfig(listenPort = Some(45))
- val diff = PartialConfiguration(server = Some(serverConfig))
+ val diff = PartialConfiguration(listenPort = someListenPort)
val result = ConfigurationMerger().merge(actual, diff)
- assertThat(result.server).isEqualTo(Some(serverConfig))
+ assertThat(result.listenPort).isEqualTo(someListenPort)
}
it("merges single parameter into full config") {
val actual = FileConfigurationReader().loadConfig(
InputStreamReader(
FileConfigurationReaderTest.javaClass.getResourceAsStream("/sampleConfig.json")) as Reader)
- val serverConfig = PartialServerConfig(listenPort = Some(45))
- val diff = PartialConfiguration(server = Some(serverConfig))
+ val diff = PartialConfiguration(listenPort = someListenPort)
val result = ConfigurationMerger().merge(actual, diff)
- assertThat(result.server.orNull()?.listenPort).isEqualTo(serverConfig.listenPort)
- assertThat(result.server.orNull()?.idleTimeoutSec?.isEmpty()).isFalse()
- assertThat(result.server.orNull()?.idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
- assertThat(result.server.orNull()?.maxPayloadSizeBytes?.isEmpty()).isFalse()
- assertThat(result.server.orNull()?.maxPayloadSizeBytes).isEqualTo(Some(512000))
+ assertThat(result.listenPort).isEqualTo(someListenPort)
+ assertThat(result.idleTimeoutSec.isEmpty()).isFalse()
+ assertThat(result.idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
+ assertThat(result.maxPayloadSizeBytes.isEmpty()).isFalse()
+ assertThat(result.maxPayloadSizeBytes).isEqualTo(Some(1048576))
}
it("merges full config into single parameter") {
val result = ConfigurationMerger().merge(actual, diff)
assertThat(result.logLevel).isEqualTo(Some(LogLevel.ERROR))
- assertThat(result.server.isEmpty()).isFalse()
- assertThat(result.server.orNull()?.maxPayloadSizeBytes).isEqualTo(Some(512000))
- assertThat(result.server.orNull()?.idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
+ assertThat(result.maxPayloadSizeBytes).isEqualTo(Some(1048576))
+ assertThat(result.idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
- assertThat(result.security.isEmpty()).isFalse()
- assertThat(result.cbs.isEmpty()).isFalse()
+ assertThat(result.keyStoreFile.isEmpty()).isFalse()
+ assertThat(result.firstRequestDelaySec.isEmpty()).isFalse()
}
}
})
import arrow.core.Option
import arrow.core.Some
import arrow.core.getOrElse
-import com.nhaarman.mockitokotlin2.mock
-import com.nhaarman.mockitokotlin2.verify
-import com.nhaarman.mockitokotlin2.whenever
import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.fail
-import org.assertj.core.api.ObjectAssert
import org.jetbrains.spek.api.Spek
import org.jetbrains.spek.api.dsl.describe
import org.jetbrains.spek.api.dsl.it
import org.onap.dcae.collectors.veshv.config.api.model.Routing
import org.onap.dcae.collectors.veshv.config.impl.ConfigurationValidator.Companion.DEFAULT_LOG_LEVEL
-import org.onap.dcae.collectors.veshv.ssl.boundary.SecurityKeysPaths
import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
import org.onap.dcaegen2.services.sdk.security.ssl.SecurityKeys
+import java.io.File
import java.time.Duration
+
internal object ConfigurationValidatorTest : Spek({
describe("ConfigurationValidator") {
val cut = ConfigurationValidator()
describe("validating partial configuration with missing fields") {
val config = PartialConfiguration(
- Some(PartialServerConfig(listenPort = Some(1)))
+ listenPort = Some(1)
)
it("should return ValidationError") {
}
describe("validating configuration with empty log level") {
- val config = PartialConfiguration(
- Some(PartialServerConfig(
- Some(1),
- Some(Duration.ofSeconds(2)),
- Some(3)
- )),
- Some(PartialCbsConfig(
- Some(Duration.ofSeconds(5)),
- Some(Duration.ofSeconds(3))
- )),
- Some(PartialSecurityConfig(
- Some(mock())
- )),
- Some(PartialCollectorConfig(
- someFromEmptyRouting
- )),
- None
+ val config = partialConfiguration(
+ logLevel = None
)
it("should use default log level") {
}
describe("validating complete configuration") {
- val idleTimeoutSec = Duration.ofSeconds(10L)
- val firstReqDelaySec = Duration.ofSeconds(10L)
- val securityKeys = mock<SecurityKeysPaths>()
- val immutableSecurityKeys = mock<SecurityKeys>()
- whenever(securityKeys.asImmutableSecurityKeys()).thenReturn(immutableSecurityKeys)
-
val config = PartialConfiguration(
- Some(PartialServerConfig(
- Some(1),
- Some(idleTimeoutSec),
- Some(2)
- )),
- Some(PartialCbsConfig(
- Some(firstReqDelaySec),
- Some(Duration.ofSeconds(3))
- )),
- Some(PartialSecurityConfig(
- Some(securityKeys)
- )),
- Some(PartialCollectorConfig(
- someFromEmptyRouting
- )),
- Some(LogLevel.INFO)
+ listenPort = Some(defaultListenPort),
+ idleTimeoutSec = Some(defaultIdleTimeoutSec),
+ maxPayloadSizeBytes = Some(defaultMaxPayloadSizeBytes),
+ firstRequestDelaySec = Some(defaultFirstReqDelaySec),
+ requestIntervalSec = Some(defaultRequestIntervalSec),
+ sslDisable = Some(false),
+ keyStoreFile = Some(KEYSTORE),
+ keyStorePassword = Some(KEYSTORE_PASSWORD),
+ trustStoreFile = Some(TRUSTSTORE),
+ trustStorePassword = Some(TRUSTSTORE_PASSWORD),
+ routing = Some(emptyRouting),
+ logLevel = Some(LogLevel.TRACE)
)
it("should create valid configuration") {
fail("Configuration should have been created successfully")
},
{
- assertThat(it.server.idleTimeout)
- .isEqualTo(idleTimeoutSec)
-
- verify(securityKeys).asImmutableSecurityKeys()
- assertThat(it.security.keys
- .getOrElse { fail("Should be immutableSecurityKeys") })
- .isEqualTo(immutableSecurityKeys)
-
- assertThat(it.cbs.firstRequestDelay)
- .isEqualTo(firstReqDelaySec)
-
- assertThat(it.collector.routing)
- .isEqualTo(emptyRouting)
+ assertThat(it.server.listenPort).isEqualTo(defaultListenPort)
+ assertThat(it.server.idleTimeout).isEqualTo(defaultIdleTimeoutSec)
+ assertThat(it.server.maxPayloadSizeBytes).isEqualTo(defaultMaxPayloadSizeBytes)
+
+ val securityKeys = it.security.keys
+ .getOrElse { fail("Should be immutableSecurityKeys") } as SecurityKeys
+ assertThat(securityKeys.keyStore().path()).isEqualTo(File(KEYSTORE).toPath())
+ assertThat(securityKeys.trustStore().path()).isEqualTo(File(TRUSTSTORE).toPath())
+ securityKeys.keyStorePassword().use { assertThat(it).isEqualTo(KEYSTORE_PASSWORD.toCharArray()) }
+ securityKeys.trustStorePassword().use { assertThat(it).isEqualTo(TRUSTSTORE_PASSWORD.toCharArray()) }
+
+ assertThat(it.cbs.firstRequestDelay).isEqualTo(defaultFirstReqDelaySec)
+ assertThat(it.cbs.requestInterval).isEqualTo(defaultRequestIntervalSec)
+
+ assertThat(it.collector.routing).isEqualTo(emptyRouting)
+ assertThat(it.logLevel).isEqualTo(LogLevel.TRACE)
}
)
}
}
describe("validating configuration with security disabled") {
- val idleTimeoutSec = Duration.ofSeconds(10)
- val firstReqDelaySec = Duration.ofSeconds(10)
- val missingSecurityKeys: Option<SecurityKeysPaths> = None
-
- val config = PartialConfiguration(
- Some(PartialServerConfig(
- Some(1),
- Some(idleTimeoutSec),
- Some(2)
- )),
- Some(PartialCbsConfig(
- Some(firstReqDelaySec),
- Some(Duration.ofSeconds(3))
- )),
- Some(PartialSecurityConfig(
- missingSecurityKeys
- )),
- Some(PartialCollectorConfig(
- someFromEmptyRouting
- )),
- Some(LogLevel.INFO)
+ val config = partialConfiguration(
+ sslDisable = Some(true),
+ keyStoreFile = Some(""),
+ keyStorePassword = Some(""),
+ trustStoreFile = Some(""),
+ trustStorePassword = Some("")
)
it("should create valid configuration") {
},
{
assertThat(it.server.idleTimeout)
- .isEqualTo(idleTimeoutSec)
+ .isEqualTo(defaultIdleTimeoutSec)
assertThat(it.security.keys)
- .isEqualTo(missingSecurityKeys)
+ .isEqualTo(None)
assertThat(it.cbs.firstRequestDelay)
- .isEqualTo(firstReqDelaySec)
+ .isEqualTo(defaultFirstReqDelaySec)
assertThat(it.collector.routing)
.isEqualTo(emptyRouting)
}
}
+ describe("validating configuration with ssl disable missing") {
+ val config = partialConfiguration(
+ sslDisable = None
+ )
+
+ it("should create valid configuration with ssl enabled") {
+ val result = cut.validate(config)
+ result.fold(
+ {
+ fail("Configuration should have been created successfully but was $it")
+ },
+ {
+ val securityKeys = it.security.keys
+ .getOrElse { fail("Should be immutableSecurityKeys") } as SecurityKeys
+ assertThat(securityKeys.keyStore().path()).isEqualTo(File(KEYSTORE).toPath())
+ assertThat(securityKeys.trustStore().path()).isEqualTo(File(TRUSTSTORE).toPath())
+ securityKeys.keyStorePassword().use { assertThat(it).isEqualTo(KEYSTORE_PASSWORD.toCharArray()) }
+ securityKeys.trustStorePassword().use { assertThat(it).isEqualTo(TRUSTSTORE_PASSWORD.toCharArray()) }
+ }
+ )
+ }
+ }
+
}
})
+private fun partialConfiguration(listenPort: Option<Int> = Some(defaultListenPort),
+ idleTimeoutSec: Option<Duration> = Some(defaultIdleTimeoutSec),
+ maxPayloadSizeBytes: Option<Int> = Some(defaultMaxPayloadSizeBytes),
+ firstReqDelaySec: Option<Duration> = Some(defaultFirstReqDelaySec),
+ requestIntervalSec: Option<Duration> = Some(defaultRequestIntervalSec),
+ sslDisable: Option<Boolean> = Some(false),
+ keyStoreFile: Option<String> = Some(KEYSTORE),
+ keyStorePassword: Option<String> = Some(KEYSTORE_PASSWORD),
+ trustStoreFile: Option<String> = Some(TRUSTSTORE),
+ trustStorePassword: Option<String> = Some(TRUSTSTORE_PASSWORD),
+ routing: Option<Routing> = Some(emptyRouting),
+ logLevel: Option<LogLevel> = Some(LogLevel.INFO)
+) =
+ PartialConfiguration(
+ listenPort = listenPort,
+ idleTimeoutSec = idleTimeoutSec,
+ maxPayloadSizeBytes = maxPayloadSizeBytes,
+ firstRequestDelaySec = firstReqDelaySec,
+ requestIntervalSec = requestIntervalSec,
+ sslDisable = sslDisable,
+ keyStoreFile = keyStoreFile,
+ keyStorePassword = keyStorePassword,
+ trustStoreFile = trustStoreFile,
+ trustStorePassword = trustStorePassword,
+ routing = routing,
+ logLevel = logLevel
+ )
+
+val defaultListenPort = 1234
+val defaultRequestIntervalSec = Duration.ofSeconds(3)
+val defaultMaxPayloadSizeBytes = 2
+val defaultIdleTimeoutSec = Duration.ofSeconds(10L)
+val defaultFirstReqDelaySec = Duration.ofSeconds(10L)
+
+val KEYSTORE = "test.ks.pkcs12"
+val KEYSTORE_PASSWORD = "changeMe"
+val TRUSTSTORE = "trust.ks.pkcs12"
+val TRUSTSTORE_PASSWORD = "changeMeToo"
+
val emptyRouting: Routing = emptyList()
-val someFromEmptyRouting = Some(emptyRouting)
package org.onap.dcae.collectors.veshv.config.impl
import arrow.core.Some
+import arrow.core.getOrElse
import org.assertj.core.api.Assertions.assertThat
import org.jetbrains.spek.api.Spek
import org.jetbrains.spek.api.dsl.describe
import org.onap.dcae.collectors.veshv.tests.utils.resourceAsStream
import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
import java.io.StringReader
-import java.net.InetSocketAddress
import java.time.Duration
+import kotlin.test.fail
/**
* @author Pawel Biniek <pawel.biniek@nokia.com>
assertThat(config.logLevel).isEqualTo(Some(LogLevel.ERROR))
}
- it("parses simple structure") {
+ it("parses simple structure and creates correct objects") {
val input = """{
- "server" : {
- "healthCheckApiPort" : 12002,
- "listenPort" : 12003
+ "server.listenPort" : 12003,
+ "cbs.firstRequestDelaySec": 10
}
- }
- """.trimIndent()
+ """.trimIndent()
val config = cut.loadConfig(StringReader(input))
- assertThat(config.server.nonEmpty()).isTrue()
- assertThat(config.server.orNull()?.listenPort).isEqualTo(Some(12003))
+ assertThat(config.listenPort).isEqualTo(Some(12003))
+ assertThat(config.firstRequestDelaySec).isEqualTo(Some(Duration.ofSeconds(10)))
}
it("parses disabled security configuration") {
val input = """{
- "security": {
- }
+ "security.sslDisable": true
}""".trimIndent()
val config = cut.loadConfig(StringReader(input))
- assertThat(config.security.nonEmpty()).isTrue()
- val security = config.security.orNull() as PartialSecurityConfig
- assertThat(security.keys.nonEmpty()).isFalse()
+ assertThat(config.sslDisable.getOrElse { fail("Should be Some") }).isTrue()
}
it("parses invalid log level string to empty option") {
assertThat(config).isNotNull
assertThat(config.logLevel).isEqualTo(Some(LogLevel.ERROR))
- assertThat(config.security.nonEmpty()).isTrue()
- val security = config.security.orNull() as PartialSecurityConfig
- assertThat(security.keys.nonEmpty()).isTrue()
+ assertThat(config.listenPort).isEqualTo(Some(6000))
+ assertThat(config.idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
+ assertThat(config.maxPayloadSizeBytes).isEqualTo(Some(1048576))
- assertThat(config.cbs.nonEmpty()).isTrue()
- val cbs = config.cbs.orNull() as PartialCbsConfig
- assertThat(cbs.firstRequestDelaySec).isEqualTo(Some(Duration.ofSeconds(7)))
- assertThat(cbs.requestIntervalSec).isEqualTo(Some(Duration.ofSeconds(900)))
+ assertThat(config.firstRequestDelaySec).isEqualTo(Some(Duration.ofSeconds(7)))
+ assertThat(config.requestIntervalSec).isEqualTo(Some(Duration.ofSeconds(900)))
- assertThat(config.server.nonEmpty()).isTrue()
- val server = config.server.orNull() as PartialServerConfig
- server.run {
- assertThat(idleTimeoutSec).isEqualTo(Some(Duration.ofSeconds(1200)))
- assertThat(listenPort).isEqualTo(Some(6000))
- assertThat(maxPayloadSizeBytes).isEqualTo(Some(512000))
- }
+ assertThat(config.sslDisable).isEqualTo(Some(false))
+ assertThat(config.keyStoreFile).isEqualTo(Some("test.ks.pkcs12"))
+ assertThat(config.keyStorePassword).isEqualTo(Some("changeMe"))
+ assertThat(config.trustStoreFile).isEqualTo(Some("trust.ks.pkcs12"))
+ assertThat(config.trustStorePassword).isEqualTo(Some("changeMeToo"))
}
}
}
+++ /dev/null
-/*
- * ============LICENSE_START=======================================================
- * dcaegen2-collectors-veshv
- * ================================================================================
- * Copyright (C) 2019 NOKIA
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
-package org.onap.dcae.collectors.veshv.config.impl.gsonadapters
-
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonParser
-import com.google.gson.reflect.TypeToken
-import com.nhaarman.mockitokotlin2.mock
-import org.assertj.core.api.Assertions
-import org.jetbrains.spek.api.Spek
-import org.jetbrains.spek.api.dsl.describe
-import org.jetbrains.spek.api.dsl.given
-import org.jetbrains.spek.api.dsl.it
-
-internal object SecurityAdapterTest : Spek({
-
- describe("deserialization") {
- val gson = JsonParser()
- val context = mock<JsonDeserializationContext>()
- val someType = TypeToken.get(SecurityAdapter::class.java).type
-
- val cut = SecurityAdapter()
-
- given("empty security object") {
- val json = gson.parse("{}")
-
- it("should parse json to security configuration without keys") {
- val deserialized = cut.deserialize(json, someType, context)
-
- Assertions.assertThat(deserialized.keys.isEmpty()).isTrue()
- }
- }
-
- given("valid security object with ssl disabled") {
-
- given("security keys missing") {
- val json = gson.parse(SECURITY_WITH_SSL_DISABLED_AND_KEYS_MISSING)
-
- it("should parse json to security configuration without keys") {
- val deserialized = cut.deserialize(json, someType, context)
-
- Assertions.assertThat(deserialized.keys.isEmpty()).isTrue()
- }
- }
-
- given("security keys provided") {
- val json = gson.parse(SECURITY_WITH_SSL_DISABLED_AND_KEYS_PROVIDED)
-
- it("should parse json to security configuration without keys") {
- val deserialized = cut.deserialize(json, someType, context)
-
- Assertions.assertThat(deserialized.keys.isEmpty()).isTrue()
- }
- }
- }
-
- given("valid security object with missing sslDisable key") {
- val json = gson.parse(MISSING_SSL_DISABLE_ENTRY)
-
- it("should return parse json to security configuration") {
- val deserialized = cut.deserialize(json, someType, context)
-
- Assertions.assertThat(deserialized.keys.isDefined()).isTrue()
- }
- }
-
- given("valid security object with ssl enabled") {
- val json = gson.parse(VALID_SECURITY_WITH_SSL_ENABLED)
-
- it("should return parse json to security configuration") {
- val deserialized = cut.deserialize(json, someType, context)
-
- Assertions.assertThat(deserialized.keys.isDefined()).isTrue()
- }
- }
- }
-})
-
-val SECURITY_WITH_SSL_DISABLED_AND_KEYS_MISSING = """
-{
- "sslDisable": true
-}
-"""
-
-val SECURITY_WITH_SSL_DISABLED_AND_KEYS_PROVIDED = """
-{
- "sslDisable": true,
- "keys": {
- "keyStoreFile": "test.ks.pkcs12",
- "keyStorePassword": "changeMe",
- "trustStoreFile": "trust.ks.pkcs12",
- "trustStorePassword": "changeMeToo"
- }
-}
-"""
-
-val MISSING_SSL_DISABLE_ENTRY = """
-{
- "keys": {
- "keyStoreFile": "test.ks.pkcs12",
- "keyStorePassword": "changeMe",
- "trustStoreFile": "trust.ks.pkcs12",
- "trustStorePassword": "changeMeToo"
- }
-}
-"""
-
-val VALID_SECURITY_WITH_SSL_ENABLED = """
-{
- "sslDisable": false,
- "keys": {
- "keyStoreFile": "test.ks.pkcs12",
- "keyStorePassword": "changeMe",
- "trustStoreFile": "trust.ks.pkcs12",
- "trustStorePassword": "changeMeToo"
- }
-}
-"""
{
"logLevel": "ERROR",
- "server": {
- "healthCheckApiPort": 5000,
- "listenPort": 6000,
- "idleTimeoutSec": 1200,
- "maxPayloadSizeBytes": 512000
- },
- "cbs": {
- "firstRequestDelaySec": 7,
- "requestIntervalSec": 900
- },
- "security": {
- "sslDisable": false,
- "keys": {
- "keyStoreFile": "test.ks.pkcs12",
- "keyStorePassword": "changeMe",
- "trustStoreFile": "trust.ks.pkcs12",
- "trustStorePassword": "changeMeToo"
- }
- }
-}
+ "server.listenPort": 6000,
+ "server.idleTimeoutSec": 1200,
+ "server.maxPayloadSizeBytes": 1048576,
+ "cbs.firstRequestDelaySec": 7,
+ "cbs.requestIntervalSec": 900,
+ "security.sslDisable": false,
+ "security.keys.keyStoreFile": "test.ks.pkcs12",
+ "security.keys.keyStorePassword": "changeMe",
+ "security.keys.trustStoreFile": "trust.ks.pkcs12",
+ "security.keys.trustStorePassword": "changeMeToo"
+}
\ No newline at end of file
{
"logLevel": "INFO",
- "server": {
- "listenPort": 6061,
- "idleTimeoutSec": 60,
- "maxPayloadSizeBytes": 1048576
- },
- "cbs": {
- "firstRequestDelaySec": 10,
- "requestIntervalSec": 5
- },
- "security": {
- }
+ "server.listenPort": 6061,
+ "server.idleTimeoutSec": 60,
+ "server.maxPayloadSizeBytes": 1048576,
+ "cbs.firstRequestDelaySec": 10,
+ "cbs.requestIntervalSec": 5,
+ "security.sslDisable": true
}
Code Review / dcaegen2 / collectors / hv-ves.git / commitdiff