diff options
10 files changed, 161 insertions, 90 deletions
diff --git a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/AdapterFactory.kt b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/AdapterFactory.kt index d9e7432d..2a8a3960 100644 --- a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/AdapterFactory.kt +++ b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/AdapterFactory.kt @@ -33,8 +33,8 @@ object AdapterFactory { fun kafkaSink(): SinkProvider = KafkaSinkProvider() fun loggingSink(): SinkProvider = LoggingSinkProvider() - fun consulConfigurationProvider(url: String, updateInterval: Duration): ConfigurationProvider = - ConsulConfigurationProvider(url, updateInterval, httpAdapter()) + fun consulConfigurationProvider(url: String, firstRequestDelay: Duration): ConfigurationProvider = + ConsulConfigurationProvider(url, httpAdapter(), firstRequestDelay) fun httpAdapter(): HttpAdapter = HttpAdapter(HttpClient.create()) } diff --git a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProvider.kt b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProvider.kt index c70d128a..727f025b 100644 --- a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProvider.kt +++ b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProvider.kt @@ -26,9 +26,14 @@ import org.onap.ves.VesEventV5.VesEvent.CommonEventHeader.Domain.HVRANMEAS import org.onap.ves.VesEventV5.VesEvent.CommonEventHeader.Domain.forNumber import org.slf4j.LoggerFactory import reactor.core.publisher.Flux +import reactor.core.publisher.Mono +import reactor.ipc.netty.http.client.HttpClientException +import reactor.retry.Retry +import reactor.retry.retryExponentialBackoff import java.io.StringReader import java.time.Duration -import java.util.Base64 +import java.util.* +import java.util.concurrent.TimeUnit import java.util.concurrent.atomic.AtomicReference import javax.json.Json import javax.json.JsonObject @@ -39,18 +44,17 @@ import javax.json.JsonObject * @since May 2018 */ internal class ConsulConfigurationProvider(private val url: String, - private val updateInterval: Duration, - private val http: HttpAdapter + private val http: HttpAdapter, + private val firstRequestDelay: Duration ) : ConfigurationProvider { - - private val logger = LoggerFactory.getLogger(ConsulConfigurationProvider::class.java) - private var lastConfigurationHash: AtomicReference<Int> = AtomicReference() + private val lastModifyIndex: AtomicReference<Int> = AtomicReference(0) + private val lastConfigurationHash: AtomicReference<Int> = AtomicReference(0) override fun invoke(): Flux<CollectorConfiguration> = Flux.concat(createDefaultConfigurationFlux(), createConsulFlux()) - private fun createDefaultConfigurationFlux(): Flux<CollectorConfiguration> = Flux.just( + private fun createDefaultConfigurationFlux(): Mono<CollectorConfiguration> = Mono.just( CollectorConfiguration( kafkaBootstrapServers = "kafka:9092", routing = routing { @@ -60,22 +64,45 @@ internal class ConsulConfigurationProvider(private val url: String, withFixedPartitioning() } }.build()) - ).doOnNext { logger.info("Applied default configuration") } - - private fun createConsulFlux(): Flux<CollectorConfiguration> = Flux.interval(updateInterval) - .flatMap { http.get(url) } - .doOnError { logger.error("Encountered an error when trying to acquire configuration from consul. " + - "Shutting down..") } - .filter { it.hashCode() != lastConfigurationHash.get() } - .doOnNext { lastConfigurationHash.set(it.hashCode()) } - .map { getConfigurationJson(it) } - .map { createCollectorConfiguration(it) } - - - private fun getConfigurationJson(str: String): JsonObject { - val response = Json.createReader(StringReader(str)).readArray().getJsonObject(0) - val decodedValue = String( - Base64.getDecoder().decode(response.getString("Value"))) + ).doOnNext { logger.info("Applied default configuration") }.delayElement(firstRequestDelay) + + private fun createConsulFlux(): Flux<CollectorConfiguration> = + http.get(url, mapOf(Pair("index", lastModifyIndex.get()))) + .doOnError { + logger.error("Encountered an error " + + "when trying to acquire configuration from consul. Shutting down..") + } + .map(::parseJsonResponse) + .doOnNext(::updateModifyIndex) + .map(::extractEncodedConfiguration) + .flatMap(::filterDifferentValues) + .map(::decodeConfiguration) + .map(::createCollectorConfiguration) + .repeat() + + private fun parseJsonResponse(responseString: String): JsonObject = + Json.createReader(StringReader(responseString)).readArray().first().asJsonObject() + + private fun updateModifyIndex(response: JsonObject) = + lastModifyIndex.set(response.getInt("ModifyIndex")) + + private fun extractEncodedConfiguration(response: JsonObject): String = + response.getString("Value") + + private fun filterDifferentValues(base64Value: String): Mono<String> { + val newHash = hashOf(base64Value) + return if (newHash == lastConfigurationHash.get()) { + Mono.empty() + } else { + lastConfigurationHash.set(newHash) + Mono.just(base64Value) + } + } + + private fun hashOf(str: String) = str.hashCode() + + private fun decodeConfiguration(encodedConfiguration: String): JsonObject { + val decodedValue = String(Base64.getDecoder().decode(encodedConfiguration)) logger.info("Obtained new configuration from consul:\n$decodedValue") return Json.createReader(StringReader(decodedValue)).readObject() } @@ -97,5 +124,9 @@ internal class ConsulConfigurationProvider(private val url: String, }.build() ) } + + companion object { + private val logger = LoggerFactory.getLogger(ConsulConfigurationProvider::class.java) + } } diff --git a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapter.kt b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapter.kt index a41cd09f..4503955f 100644 --- a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapter.kt +++ b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapter.kt @@ -23,7 +23,6 @@ import org.slf4j.LoggerFactory import reactor.core.publisher.Mono import reactor.core.publisher.toMono import reactor.ipc.netty.http.client.HttpClient -import reactor.ipc.netty.http.client.HttpClientResponse import java.nio.charset.Charset /** @@ -34,12 +33,31 @@ open class HttpAdapter(private val httpClient: HttpClient) { private val logger = LoggerFactory.getLogger(HttpAdapter::class.java) - open fun get(url: String): Mono<String> = - httpClient.get(url) - .doOnError { - logger.error("Failed to get resource on path: $url (${it.localizedMessage})") - logger.debug("Nested exception:", it) - } - .flatMap { it.receiveContent().toMono() } - .map { it.content().toString(Charset.defaultCharset()) } + open fun get(url: String, queryParams: Map<String, Any> = emptyMap()): Mono<String> = httpClient + .get(url + createQueryString(queryParams)) + .doOnError { + logger.error("Failed to get resource on path: $url (${it.localizedMessage})") + logger.debug("Nested exception:", it) + } + .flatMap { it.receiveContent().toMono() } + .map { it.content().toString(Charset.defaultCharset()) } + + + private fun createQueryString(params: Map<String, Any>): String { + if (params.isEmpty()) + return "" + + val builder = StringBuilder("?") + params.forEach { (key, value) -> + builder + .append(key) + .append("=") + .append(value) + .append("&") + + } + + return builder.removeSuffix("&").toString() + } + } diff --git a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/model/ServerConfiguration.kt b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/model/ServerConfiguration.kt index 025c59f6..a486996e 100644 --- a/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/model/ServerConfiguration.kt +++ b/hv-collector-core/src/main/kotlin/org/onap/dcae/collectors/veshv/model/ServerConfiguration.kt @@ -29,7 +29,7 @@ import java.time.Duration data class ServerConfiguration( val port: Int, val configurationUrl: String, - val configurationUpdateInterval: Duration, + val firstRequestDelay: Duration, val securityConfiguration: SecurityConfiguration, val idleTimeout: Duration, val dummyMode: Boolean = false) diff --git a/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProviderTest.kt b/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProviderTest.kt index dd190848..c98c97a6 100644 --- a/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProviderTest.kt +++ b/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/ConsulConfigurationProviderTest.kt @@ -19,12 +19,14 @@ */ package org.onap.dcae.collectors.veshv.impl.adapters +import com.nhaarman.mockito_kotlin.eq import com.nhaarman.mockito_kotlin.mock import com.nhaarman.mockito_kotlin.verify import com.nhaarman.mockito_kotlin.whenever import org.jetbrains.spek.api.Spek import org.jetbrains.spek.api.dsl.given import org.jetbrains.spek.api.dsl.it +import org.mockito.Mockito import org.onap.ves.VesEventV5.VesEvent.CommonEventHeader.Domain import reactor.core.publisher.Mono import reactor.ipc.netty.http.client.HttpClient @@ -39,15 +41,16 @@ import kotlin.test.assertEquals */ internal object ConsulConfigurationProviderTest : Spek({ - val updateInterval = Duration.ofMillis(1) val httpAdapterMock: HttpAdapter = mock() + val firstRequestDelay = Duration.ofMillis(1) given("valid resource url") { val validUrl = "http://valid-url/" - val consulConfigProvider = ConsulConfigurationProvider(validUrl, updateInterval, httpAdapterMock) + val consulConfigProvider = ConsulConfigurationProvider(validUrl, httpAdapterMock, firstRequestDelay) - whenever(httpAdapterMock.get(validUrl)).thenReturn(Mono.just(constructConsulResponse())) + whenever(httpAdapterMock.get(eq(validUrl), Mockito.anyMap())) + .thenReturn(Mono.just(constructConsulResponse())) it("should use default configuration at the beginning, " + "then apply received configuration") { @@ -79,9 +82,10 @@ internal object ConsulConfigurationProviderTest : Spek({ given("invalid resource url") { val invalidUrl = "http://invalid-url/" - val consulConfigProvider = ConsulConfigurationProvider(invalidUrl, updateInterval, httpAdapterMock) + val consulConfigProvider = ConsulConfigurationProvider(invalidUrl, httpAdapterMock, firstRequestDelay) - whenever(httpAdapterMock.get(invalidUrl)).thenReturn(Mono.error(RuntimeException("Test exception"))) + whenever(httpAdapterMock.get(eq(invalidUrl), Mockito.anyMap())) + .thenReturn(Mono.error(RuntimeException("Test exception"))) it("should use default configuration at the beginning, then should interrupt the flux") { diff --git a/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapterTest.kt b/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapterTest.kt index 79eda995..123d8f72 100644 --- a/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapterTest.kt +++ b/hv-collector-core/src/test/kotlin/org/onap/dcae/collectors/veshv/impl/adapters/HttpAdapterTest.kt @@ -20,10 +20,12 @@ package org.onap.dcae.collectors.veshv.impl.adapters import com.nhaarman.mockito_kotlin.mock +import com.nhaarman.mockito_kotlin.verify import com.nhaarman.mockito_kotlin.whenever import io.netty.buffer.Unpooled import io.netty.handler.codec.http.HttpContent 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 import reactor.core.publisher.Flux @@ -32,44 +34,65 @@ import reactor.ipc.netty.http.client.HttpClient import reactor.ipc.netty.http.client.HttpClientResponse import reactor.test.StepVerifier import java.nio.charset.Charset -import kotlin.test.assertEquals /** * @author Jakub Dudycz <jakub.dudycz@nokia.com> * @since May 2018 */ internal object HttpAdapterTest : Spek({ - - given("valid resource url") { + describe("HttpAdapter") { val httpClientMock: HttpClient = mock() val httpAdapter = HttpAdapter(httpClientMock) - val validUrl = "http://valid-url/" - val responseContent = """{"key1": "value1", "key2": "value2"}""" - val httpResponse = createHttpResponseMock(responseContent) - whenever(httpClientMock.get(validUrl)).thenReturn(Mono.just(httpResponse)) - it("should return response string") { - StepVerifier - .create(httpAdapter.get(validUrl)) - .expectNext(responseContent) + given("url without query params") { + val initialUrl = "http://test-url" + whenever(httpClientMock.get(initialUrl)).thenReturn(Mono.empty()) + + it("should not append query string") { + httpAdapter.get(initialUrl) + verify(httpClientMock).get(initialUrl) + } } - } - given("invalid resource url") { + given("url with query params") { + val queryParams = mapOf(Pair("key", "value")) + val initialUrl = "http://test-url" + val expectedUrl = "http://test-url?key=value" + whenever(httpClientMock.get(expectedUrl)).thenReturn(Mono.empty()) - val httpClientMock: HttpClient = mock() - val httpAdapter = HttpAdapter(httpClientMock) - val invalidUrl = "http://invalid-url/" - val exceptionMessage = "Test exception" - whenever(httpClientMock.get(invalidUrl)).thenReturn(Mono.error(Exception(exceptionMessage))) + it("should parse them to query string and append to url") { + httpAdapter.get(initialUrl, queryParams) + verify(httpClientMock).get(expectedUrl) + } + } - it("should interrupt the flux") { - StepVerifier - .create(httpAdapter.get(invalidUrl)) - .verifyErrorMessage(exceptionMessage) + given("valid resource url") { + val validUrl = "http://valid-url/" + val responseContent = """{"key1": "value1", "key2": "value2"}""" + val httpResponse = createHttpResponseMock(responseContent) + whenever(httpClientMock.get(validUrl)).thenReturn(Mono.just(httpResponse)) + + it("should return response string") { + StepVerifier + .create(httpAdapter.get(validUrl)) + .expectNext(responseContent) + } + } + + given("invalid resource url") { + val invalidUrl = "http://invalid-url/" + val exceptionMessage = "Test exception" + whenever(httpClientMock.get(invalidUrl)).thenReturn(Mono.error(Exception(exceptionMessage))) + + it("should interrupt the flux") { + StepVerifier + .create(httpAdapter.get(invalidUrl)) + .verifyErrorMessage(exceptionMessage) + } } } + }) fun createHttpResponseMock(content: String): HttpClientResponse { diff --git a/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfiguration.kt b/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfiguration.kt index 63de270e..9e4c5f2d 100644 --- a/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfiguration.kt +++ b/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfiguration.kt @@ -24,21 +24,12 @@ import org.apache.commons.cli.DefaultParser import org.onap.dcae.collectors.veshv.domain.SecurityConfiguration import org.onap.dcae.collectors.veshv.model.ServerConfiguration import org.onap.dcae.collectors.veshv.utils.commandline.ArgBasedConfiguration -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.LISTEN_PORT -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.UPDATE_INTERVAL -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.CONSUL_CONFIG_URL -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.PRIVATE_KEY_FILE -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.CERT_FILE -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.TRUST_CERT_FILE -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.IDLE_TIMEOUT_SEC -import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.DUMMY_MODE - +import org.onap.dcae.collectors.veshv.utils.commandline.CommandLineOption.* import java.time.Duration internal object DefaultValues { const val PORT = 6061 - const val UPDATE_INTERVAL = 300L + const val CONSUL_FIRST_REQUEST_DELAY = 10L const val CONFIG_URL = "" const val PRIVATE_KEY_FILE = "/etc/ves-hv/server.key" const val CERT_FILE = "/etc/ves-hv/server.crt" @@ -49,8 +40,8 @@ internal object DefaultValues { internal class ArgBasedServerConfiguration : ArgBasedConfiguration<ServerConfiguration>(DefaultParser()) { override val cmdLineOptionsList = listOf( LISTEN_PORT, - UPDATE_INTERVAL, CONSUL_CONFIG_URL, + CONSUL_FIRST_REQUEST_DELAY, PRIVATE_KEY_FILE, CERT_FILE, TRUST_CERT_FILE, @@ -61,14 +52,14 @@ internal class ArgBasedServerConfiguration : ArgBasedConfiguration<ServerConfigu override fun getConfiguration(cmdLine: CommandLine): ServerConfiguration { val port = cmdLine.intValue(LISTEN_PORT, DefaultValues.PORT) val configUrl = cmdLine.stringValue(CONSUL_CONFIG_URL, DefaultValues.CONFIG_URL) - val updateInterval = cmdLine.longValue(UPDATE_INTERVAL, DefaultValues.UPDATE_INTERVAL) + val firstRequestDelay = cmdLine.longValue(CONSUL_FIRST_REQUEST_DELAY, DefaultValues.CONSUL_FIRST_REQUEST_DELAY) val idleTimeoutSec = cmdLine.longValue(IDLE_TIMEOUT_SEC, DefaultValues.IDLE_TIMEOUT_SEC) val dummyMode = cmdLine.hasOption(DUMMY_MODE) val security = createSecurityConfiguration(cmdLine) return ServerConfiguration( port = port, configurationUrl = configUrl, - configurationUpdateInterval = Duration.ofSeconds(updateInterval), + firstRequestDelay = Duration.ofSeconds(firstRequestDelay), securityConfiguration = security, idleTimeout = Duration.ofSeconds(idleTimeoutSec), dummyMode = dummyMode) diff --git a/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/main.kt b/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/main.kt index f5efab2b..1661aeae 100644 --- a/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/main.kt +++ b/hv-collector-main/src/main/kotlin/org/onap/dcae/collectors/veshv/main/main.kt @@ -55,10 +55,7 @@ fun main(args: Array<String>) = private fun createServer(config: ServerConfiguration): Server { val sink = if (config.dummyMode) AdapterFactory.loggingSink() else AdapterFactory.kafkaSink() val collectorProvider = CollectorFactory( - AdapterFactory.consulConfigurationProvider( - config.configurationUrl, config.configurationUpdateInterval), - sink, - MicrometerMetrics() + AdapterFactory.consulConfigurationProvider(config.configurationUrl, config.firstRequestDelay), sink, MicrometerMetrics() ).createVesHvCollectorProvider() return ServerFactory.createNettyTcpServer(config, collectorProvider) diff --git a/hv-collector-main/src/test/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfigurationTest.kt b/hv-collector-main/src/test/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfigurationTest.kt index 2c49cf98..8f0c2af9 100644 --- a/hv-collector-main/src/test/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfigurationTest.kt +++ b/hv-collector-main/src/test/kotlin/org/onap/dcae/collectors/veshv/main/ArgBasedServerConfigurationTest.kt @@ -40,8 +40,8 @@ import java.time.Duration object ArgBasedServerConfigurationTest : Spek({ lateinit var cut: ArgBasedServerConfiguration val configurationUrl = "http://test-address/test" + val firstRequestDelay = "10" val listenPort = "6969" - val updateInterval = "10" val pk = Paths.get("/", "etc", "ves", "pk.pem") val cert = Paths.get("/", "etc", "ssl", "certs", "ca-bundle.crt") val trustCert = Paths.get("/", "etc", "ves", "trusted.crt") @@ -63,7 +63,7 @@ object ArgBasedServerConfigurationTest : Spek({ beforeEachTest { result = parse("--listen-port", listenPort, "--config-url", configurationUrl, - "--update-interval", updateInterval, + "--first-request-delay", firstRequestDelay, "--private-key-file", pk.toFile().absolutePath, "--cert-file", cert.toFile().absolutePath, "--trust-cert-file", trustCert.toFile().absolutePath) @@ -73,8 +73,8 @@ object ArgBasedServerConfigurationTest : Spek({ assertThat(result.port).isEqualTo(6969) } - it("should set update interval") { - assertThat(result.configurationUpdateInterval).isEqualTo(Duration.ofSeconds(10)) + it("should set proper first consul request delay") { + assertThat(result.firstRequestDelay).isEqualTo(Duration.ofSeconds(10)) } it("should set proper config url") { @@ -86,19 +86,25 @@ object ArgBasedServerConfigurationTest : Spek({ SecurityConfiguration(pk, cert, trustCert) ) } + + } given("some parameters are present in the short form") { lateinit var result: ServerConfiguration beforeEachTest { - result = parse("-p", "666", "-c", configurationUrl) + result = parse("-p", "666", "-c", configurationUrl, "-d", firstRequestDelay) } it("should set proper port") { assertThat(result.port).isEqualTo(666) } + it("should set proper first consul request delay") { + assertThat(result.firstRequestDelay).isEqualTo(Duration.ofSeconds(10)) + } + it("should set proper config url") { assertThat(result.configurationUrl).isEqualTo(configurationUrl) } @@ -119,8 +125,9 @@ object ArgBasedServerConfigurationTest : Spek({ assertThat(result.configurationUrl).isEqualTo(DefaultValues.CONFIG_URL) } - it("should set default update interval") { - assertThat(result.configurationUpdateInterval).isEqualTo(Duration.ofSeconds(DefaultValues.UPDATE_INTERVAL)) + it("should set default first consul request delay") { + assertThat(result.firstRequestDelay) + .isEqualTo(Duration.ofSeconds(DefaultValues.CONSUL_FIRST_REQUEST_DELAY)) } on("security config") { diff --git a/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/commandline/CommandLineOption.kt b/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/commandline/CommandLineOption.kt index b20f2aab..82711d9b 100644 --- a/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/commandline/CommandLineOption.kt +++ b/hv-collector-utils/src/main/kotlin/org/onap/dcae/collectors/veshv/utils/commandline/CommandLineOption.kt @@ -35,10 +35,10 @@ enum class CommandLineOption(val option: Option) { .desc("URL of ves configuration on consul") .build() ), - UPDATE_INTERVAL(Option.builder("I") - .longOpt("update-interval") + CONSUL_FIRST_REQUEST_DELAY(Option.builder("d") + .longOpt("first-request-delay") .hasArg() - .desc("Consul configuration update interval in seconds") + .desc("Delay of first request to consul in seconds") .build() ), VES_HV_PORT(Option.builder("p") |