config.value(value); parsed.put(name, value); for (String dependent: key.dependents) {
@Test public void testCanAddInternalConfig() throws Exception { final String configName = "internal.config"; final ConfigDef configDef = new ConfigDef().defineInternal(configName, Type.STRING, "", Importance.LOW); final HashMap<String, String> properties = new HashMap<>(); properties.put(configName, "value"); final List<ConfigValue> results = configDef.validate(properties); final ConfigValue configValue = results.get(0); assertEquals("value", configValue.value()); assertEquals(configName, configValue.name()); }
private <T> void validateField(Config config, Field field, T expectedValue) { assertNoConfigurationErrors(config, field); Object actualValue = configValue(config, field.name()).value(); if (actualValue == null) { actualValue = field.defaultValue(); } if (expectedValue == null) { assertThat(actualValue).isNull(); } else { if (expectedValue instanceof EnumeratedValue) { assertThat(((EnumeratedValue) expectedValue).getValue()).isEqualTo(actualValue.toString()); } else { assertThat(expectedValue).isEqualTo(actualValue); } } }
@Override public List<Map<String, String>> taskConfigs(int maxTasks) { Map<String, String> ret = configValues.entrySet().stream() .filter(a -> a.getValue().value() != null) .collect(Collectors.toMap(a -> a.getKey(), a -> a.getValue().value().toString())); ret.put(PROPERTY_TAGS, ((List<String>) configValues.get(PROPERTY_TAGS).value()).stream().collect(Collectors.joining(","))); return Collections.singletonList(ret); }
@Override public void start(Map<String, String> props) { //shallow copy configValues = config().validate(props).stream().collect(Collectors.toMap(ConfigValue::name, Function.identity())); logger.info("Starting OPC-DA connector (version {}) on server {} reading tags {}", version(), configValues.get(PROPERTY_HOST).value(), configValues.get(PROPERTY_TAGS).value()); }
@Override public void stop() { logger.info("Stopping OPC-DA connector (version {}) on server {}", version(), configValues.get(PROPERTY_HOST).value()); }
@Override public void stop() { logger.info("Stopping OPC-UA connector (version {}) on server {}", version(), configValues.get(PROPERTY_SERVER_URI).value()); }
@Override public void start(Map<String, String> props) { //shallow copy configValues = config().validate(props).stream().collect(Collectors.toMap(ConfigValue::name, Function.identity())); logger.info("Starting OPC-UA connector (version {}) on server {} reading tags {}", version(), configValues.get(PROPERTY_SERVER_URI).value(), configValues.get(PROPERTY_TAGS).value()); }
@Override public List<Map<String, String>> taskConfigs(int maxTasks) { Long defaultRefreshPeriod = (Long) configValues.get(PROPERTY_DEFAULT_REFRESH_PERIOD).value(); //first partition tags per refresh period Map<Long, List<String>> tagPartitions = ((List<String>) configValues.get(PROPERTY_TAGS).value()) .stream().collect(Collectors.groupingBy(tag -> CommonUtils.parseTag(tag, defaultRefreshPeriod).getValue())); List<List<String>> tags = new ArrayList<>(tagPartitions.values()); int maxPartitions = Math.min(maxTasks, tags.size()); int batchSize = (int) Math.ceil((double) tags.size() / maxPartitions); //then find the ideal partition size and flatten tag list into a comma separated string (since config is a map of string,string) return IntStream.range(0, maxPartitions) .mapToObj(i -> tags.subList(i * batchSize, Math.min((i + 1) * batchSize, tags.size()))) .map(l -> { Map<String, String> ret = configValues.entrySet().stream() .filter(a -> a.getValue().value() != null) .collect(Collectors.toMap(a -> a.getKey(), a -> a.getValue().value().toString())); ret.put(PROPERTY_TAGS, Utils.join(l.stream().flatMap(List::stream).collect(Collectors.toList()), ",")); return ret; }) .collect(Collectors.toList()); }
@Named public class ConfigProducer { //@Inject // Initialize this parameter somehow Map<String,String> configurationMap; @PostConstructor public void doInit() { // TODO: Get the configuration map here if it needs explicit initialization } // In general, I would discourage using this method, since it can be difficult to control exactly the order in which beans initialize at runtime. public void setConfigurationMap(Map<String,String> configurationMap) { this.configurationMap = configurationMap; } @Produces @ConfigValue("") @Dependent public String configValueProducer(InjectionPoint ip) { // We know this annotation WILL be present as WELD won't call us otherwise, so no null checking is required. ConfigValue configValue = ip.getAnnotated().getAnnotation(ConfigValue.class); // This could potentially return a null, so the function is annotated @Dependent to avoid a WELD error. return configurationMap.get(configValue.value()); } }
@Override protected Map<String, ConfigValue> validateBasicConnectorConfig(Connector connector, ConfigDef configDef, Map<String, String> config) { Map<String, ConfigValue> validatedConfig = super.validateBasicConnectorConfig(connector, configDef, config); if (connector instanceof SinkConnector) { ConfigValue validatedName = validatedConfig.get(ConnectorConfig.NAME_CONFIG); String name = (String) validatedName.value(); if (workerGroupId.equals(SinkUtils.consumerGroupId(name))) { validatedName.addErrorMessage("Consumer group for sink connector named " + name + " conflicts with Connect worker group " + workerGroupId); } } return validatedConfig; }
private static ConfigValueInfo convertConfigValue(ConfigValue configValue, Type type) { String value = ConfigDef.convertToString(configValue.value(), type); List<String> recommendedValues = new LinkedList<>(); if (type == Type.LIST) { for (Object object: configValue.recommendedValues()) { recommendedValues.add(ConfigDef.convertToString(object, Type.STRING)); } } else { for (Object object : configValue.recommendedValues()) { recommendedValues.add(ConfigDef.convertToString(object, type)); } } return new ConfigValueInfo(configValue.name(), value, recommendedValues, configValue.errorMessages(), configValue.visible()); }
private <T> void validateField(Config config, Field field, T expectedValue) { assertNoConfigurationErrors(config, field); Object actualValue = configValue(config, field.name()).value(); if (actualValue == null) { actualValue = field.defaultValue(); } if (expectedValue == null) { assertThat(actualValue).isNull(); } else { if (expectedValue instanceof EnumeratedValue) { assertThat(((EnumeratedValue) expectedValue).getValue()).isEqualTo(actualValue.toString()); } else { assertThat(expectedValue).isEqualTo(actualValue); } } }