private static boolean isUnknownPropertyName(final String propertyName) { return !new KsqlConfigResolver() .resolve(propertyName, false) .isPresent(); }
private static Optional<ConfigItem> resolveStreamsConfig( final String propertyName, final boolean strict) { final String key = stripPrefix(propertyName, KsqlConfig.KSQL_STREAMS_PREFIX); final Optional<ConfigItem> resolved = STREAM_CONFIG_DEFS .stream() .map(def -> resolveConfig(def.prefix, def.def, key)) .filter(Optional::isPresent) .map(Optional::get) .findFirst(); if (resolved.isPresent()) { return resolved; } if (key.startsWith(StreamsConfig.CONSUMER_PREFIX) || key.startsWith(StreamsConfig.PRODUCER_PREFIX)) { return Optional.empty(); // Unknown producer / consumer config } if (propertyName.startsWith(KsqlConfig.KSQL_STREAMS_PREFIX)) { return Optional.empty(); // Unknown streams config } // Unknown config (which could be used): return strict ? Optional.empty() : Optional.of(ConfigItem.unresolved(key)); }
@Override public Optional<ConfigItem> resolve(final String propertyName, final boolean strict) { if (propertyName.startsWith(KsqlConfig.KSQL_CONFIG_PROPERTY_PREFIX) && !propertyName.startsWith(KsqlConfig.KSQL_STREAMS_PREFIX)) { return resolveKsqlConfig(propertyName); } return resolveStreamsConfig(propertyName, strict); }
private void assertNotFound(final String configName) { assertThat(resolver.resolve(configName, false), is(Optional.empty())); }
public LocalPropertyParser() { this(new KsqlConfigResolver(), new LocalPropertyValidator()); }
private static Optional<ConfigItem> resolveKsqlConfig(final String propertyName) { final Optional<ConfigItem> possibleItem = resolveConfig("", KSQL_CONFIG_DEF, propertyName); if (possibleItem.isPresent()) { return possibleItem; } if (propertyName.startsWith(KsqlConfig.KSQL_FUNCTIONS_PROPERTY_PREFIX)) { // Functions properties are free form, so can not be resolved / validated: return Optional.of(ConfigItem.unresolved(propertyName)); } return Optional.empty(); }
private static Optional<ConfigItem> resolveConfig( final String prefix, final ConfigDef def, final String propertyName) { if (!propertyName.startsWith(prefix)) { return Optional.empty(); } final String keyNoPrefix = stripPrefix(propertyName, prefix); final ConfigKey configKey = def.configKeys().get(keyNoPrefix); if (configKey == null) { return Optional.empty(); } return Optional.of(ConfigItem.resolved(configKey)); }
@Test public void shouldReturnEmptyForOtherConfigIfStrict() { assertThat(resolver.resolve("confluent.monitoring.interceptor.topic", true), is(Optional.empty())); }
@Before public void setUp() { resolver = new KsqlConfigResolver(); }
@Test public void shouldResolveProducerPrefixedProducerConfig() { assertThat(resolver.resolve( StreamsConfig.PRODUCER_PREFIX + ProducerConfig.BUFFER_MEMORY_CONFIG, true), is(resolvedItem(ProducerConfig.BUFFER_MEMORY_CONFIG, PRODUCER_CONFIG_DEF))); }
private static Optional<ConfigValue> resolveStreamsConfig( final String maybePrefixedKey, final Object value) { final String key = maybePrefixedKey.startsWith(KSQL_STREAMS_PREFIX) ? maybePrefixedKey.substring(KSQL_STREAMS_PREFIX.length()) : maybePrefixedKey; if (key.startsWith(KsqlConfig.KSQL_CONFIG_PROPERTY_PREFIX)) { return Optional.empty(); } return new KsqlConfigResolver().resolve(maybePrefixedKey, false) .map(configItem -> new ConfigValue(configItem, key, configItem.parseValue(value))); }
@Test public void shouldResolveKsqlPrefixedProducerConfig() { assertThat(resolver.resolve( KsqlConfig.KSQL_STREAMS_PREFIX + ProducerConfig.BUFFER_MEMORY_CONFIG, true), is(resolvedItem(ProducerConfig.BUFFER_MEMORY_CONFIG, PRODUCER_CONFIG_DEF))); }
private PropertiesList listProperties( final PreparedStatement<ListProperties> statement, final Map<String, Object> propertyOverrides ) { final KsqlConfigResolver resolver = new KsqlConfigResolver(); final Map<String, String> engineProperties = ksqlConfig.getAllConfigPropsWithSecretsObfuscated(); final Map<String, String> mergedProperties = ksqlConfig .cloneWithPropertyOverwrite(propertyOverrides) .getAllConfigPropsWithSecretsObfuscated(); final List<String> overwritten = mergedProperties.entrySet() .stream() .filter(e -> !Objects.equals(engineProperties.get(e.getKey()), e.getValue())) .map(Entry::getKey) .collect(Collectors.toList()); final List<String> defaultProps = mergedProperties.entrySet().stream() .filter(e -> resolver.resolve(e.getKey(), false) .map(resolved -> resolved.isDefaultValue(e.getValue())) .orElse(false)) .map(Entry::getKey) .collect(Collectors.toList()); return new PropertiesList( statement.getStatementText(), mergedProperties, overwritten, defaultProps); }
@Test public void shouldResolveProducerConfig() { assertThat(resolver.resolve(ProducerConfig.BUFFER_MEMORY_CONFIG, true), is(resolvedItem(ProducerConfig.BUFFER_MEMORY_CONFIG, PRODUCER_CONFIG_DEF))); }
@Test public void shouldResolveKsqlProperty() { assertThat(resolver.resolve(KsqlConfig.SINK_NUMBER_OF_PARTITIONS_PROPERTY, true), is(resolvedItem(KsqlConfig.SINK_NUMBER_OF_PARTITIONS_PROPERTY, KSQL_CONFIG_DEF))); }
@Test public void shouldResolveKnownKsqlFunctionProperty() { assertThat(resolver.resolve(KsqlConfig.KSQL_FUNCTIONS_SUBSTRING_LEGACY_ARGS_CONFIG, true), is(resolvedItem(KsqlConfig.KSQL_FUNCTIONS_SUBSTRING_LEGACY_ARGS_CONFIG, KSQL_CONFIG_DEF))); }
@Test public void shouldResolveKsqlConsumerPrefixedConsumerConfig() { assertThat(resolver.resolve( KsqlConfig.KSQL_STREAMS_PREFIX + StreamsConfig.CONSUMER_PREFIX + ConsumerConfig.FETCH_MIN_BYTES_CONFIG, true), is(resolvedItem(ConsumerConfig.FETCH_MIN_BYTES_CONFIG, CONSUMER_CONFIG_DEF))); }
@Test public void shouldResolveKsqlProducerPrefixedProducerConfig() { assertThat(resolver.resolve( KsqlConfig.KSQL_STREAMS_PREFIX + StreamsConfig.PRODUCER_PREFIX + ProducerConfig.BUFFER_MEMORY_CONFIG, true), is(resolvedItem(ProducerConfig.BUFFER_MEMORY_CONFIG, PRODUCER_CONFIG_DEF))); }
@Test public void shouldResolveKsqlStreamPrefixedStreamConfig() { assertThat(resolver.resolve( KsqlConfig.KSQL_STREAMS_PREFIX + StreamsConfig.COMMIT_INTERVAL_MS_CONFIG, true), is(resolvedItem(StreamsConfig.COMMIT_INTERVAL_MS_CONFIG, STREAMS_CONFIG_DEF))); }
@Test public void shouldResolveConsumerConfig() { assertThat(resolver.resolve(ConsumerConfig.FETCH_MIN_BYTES_CONFIG, true), is(resolvedItem(ConsumerConfig.FETCH_MIN_BYTES_CONFIG, CONSUMER_CONFIG_DEF))); }