private void mapEntryListenerHandle(Node n, MapConfig mapConfig) { for (Node listenerNode : childElements(n)) { if ("entry-listener".equals(cleanNodeName(listenerNode))) { NamedNodeMap attrs = listenerNode.getAttributes(); boolean incValue = getBooleanValue(getTextContent(attrs.getNamedItem("include-value"))); boolean local = getBooleanValue(getTextContent(attrs.getNamedItem("local"))); String listenerClass = getTextContent(listenerNode); mapConfig.addEntryListenerConfig(new EntryListenerConfig(listenerClass, local, incValue)); } } }
String getAttribute(Node node, String attName) { return DomConfigHelper.getAttribute(node, attName, domLevel3); }
public static double getDoubleValue(final String parameterName, final String value, double defaultValue) { if (isNullOrEmpty(value)) { return defaultValue; } return getDoubleValue(parameterName, value); }
public static void fillProperties(final Node node, Properties properties, boolean domLevel3) { if (properties == null) { return; } for (Node n : childElements(node)) { final String name = cleanNodeName(n); final String propertyName = "property".equals(name) ? getTextContent(n.getAttributes().getNamedItem("name"), domLevel3).trim() // old way - probably should be deprecated : name; final String value = getTextContent(n, domLevel3).trim(); properties.setProperty(propertyName, value); } }
private void handleProxyFactories(Node node) { for (Node child : childElements(node)) { String nodeName = cleanNodeName(child); if ("proxy-factory".equals(nodeName)) { handleProxyFactory(child); } } }
private static String getTextContentOld(final Node node) { final Node child = node.getFirstChild(); if (child != null) { final Node next = child.getNextSibling(); if (next == null) { return hasTextContent(child) ? child.getNodeValue() : ""; } final StringBuilder buf = new StringBuilder(); appendTextContents(node, buf); return buf.toString(); } return ""; }
private void handleConnectionRetry(Node node, ClientConnectionStrategyConfig strategyConfig) { Node enabledNode = node.getAttributes().getNamedItem("enabled"); boolean enabled = enabledNode != null && getBooleanValue(getTextContent(enabledNode).trim()); if (!enabled) { LOGGER.warning("Exponential Connection Strategy is not enabled."); } ConnectionRetryConfig connectionRetryConfig = new ConnectionRetryConfig(); connectionRetryConfig.setEnabled(enabled); String initialBackoffMillis = "initial-backoff-millis"; String maxBackoffMillis = "max-backoff-millis"; String multiplier = "multiplier"; String jitter = "jitter"; for (Node child : childElements(node)) { String nodeName = cleanNodeName(child); String value = getTextContent(child).trim(); if (initialBackoffMillis.equals(nodeName)) { connectionRetryConfig.setInitialBackoffMillis(getIntegerValue(initialBackoffMillis, value)); } else if (maxBackoffMillis.equals(nodeName)) { connectionRetryConfig.setMaxBackoffMillis(getIntegerValue(maxBackoffMillis, value)); } else if (multiplier.equals(nodeName)) { connectionRetryConfig.setMultiplier(getIntegerValue(multiplier, value)); } else if ("fail-on-max-backoff".equals(nodeName)) { connectionRetryConfig.setFailOnMaxBackoff(getBooleanValue(value)); } else if (jitter.equals(nodeName)) { connectionRetryConfig.setJitter(getDoubleValue(jitter, value)); } } strategyConfig.setConnectionRetryConfig(connectionRetryConfig); }
private void handleCRDTReplication(Node root) { final CRDTReplicationConfig replicationConfig = new CRDTReplicationConfig(); final String replicationPeriodMillisName = "replication-period-millis"; final String maxConcurrentReplicationTargetsName = "max-concurrent-replication-targets"; for (Node n : childElements(root)) { final String name = cleanNodeName(n); if (replicationPeriodMillisName.equals(name)) { replicationConfig.setReplicationPeriodMillis( getIntegerValue(replicationPeriodMillisName, getTextContent(n))); } else if (maxConcurrentReplicationTargetsName.equals(name)) { replicationConfig.setMaxConcurrentReplicationTargets( getIntegerValue(maxConcurrentReplicationTargetsName, getTextContent(n))); } } this.config.setCRDTReplicationConfig(replicationConfig); }
private QuorumConfigBuilder handleProbabilisticQuorum(String name, Node node, int quorumSize) { QuorumConfigBuilder quorumConfigBuilder; long acceptableHeartPause = getLongValue("acceptable-heartbeat-pause-millis", getAttribute(node, "acceptable-heartbeat-pause-millis"), ProbabilisticQuorumConfigBuilder.DEFAULT_HEARTBEAT_PAUSE_MILLIS); double threshold = getDoubleValue("suspicion-threshold", getAttribute(node, "suspicion-threshold"), ProbabilisticQuorumConfigBuilder.DEFAULT_PHI_THRESHOLD); int maxSampleSize = getIntegerValue("max-sample-size", getAttribute(node, "max-sample-size"), ProbabilisticQuorumConfigBuilder.DEFAULT_SAMPLE_SIZE); long minStdDeviation = getLongValue("min-std-deviation-millis", getAttribute(node, "min-std-deviation-millis"), ProbabilisticQuorumConfigBuilder.DEFAULT_MIN_STD_DEVIATION); long heartbeatIntervalMillis = getLongValue("heartbeat-interval-millis", getAttribute(node, "heartbeat-interval-millis"), ProbabilisticQuorumConfigBuilder.DEFAULT_HEARTBEAT_INTERVAL_MILLIS); quorumConfigBuilder = QuorumConfig.newProbabilisticQuorumConfigBuilder(name, quorumSize) .withAcceptableHeartbeatPauseMillis(acceptableHeartPause) .withSuspicionThreshold(threshold) .withHeartbeatIntervalMillis(heartbeatIntervalMillis) .withMinStdDeviationMillis(minStdDeviation) .withMaxSampleSize(maxSampleSize); return quorumConfigBuilder; }
builder.addPropertyValue("entryListenerConfigs", listeners); } else if ("include-value".equals(nodeName)) { boolean includeValue = getBooleanValue(textContent); builder.addPropertyValue("includeValue", includeValue); } else if ("batch-size".equals(nodeName)) { int batchSize = getIntegerValue("batch-size", textContent.trim()); builder.addPropertyValue("batchSize", batchSize); } else if ("buffer-size".equals(nodeName)) { int bufferSize = getIntegerValue("buffer-size", textContent.trim()); builder.addPropertyValue("bufferSize", bufferSize); } else if ("delay-seconds".equals(nodeName)) { int delaySeconds = getIntegerValue("delay-seconds", textContent.trim() ); builder.addPropertyValue("delaySeconds", delaySeconds); builder.addPropertyValue("inMemoryFormat", InMemoryFormat.valueOf(upperCaseInternal(value))); } else if ("coalesce".equals(nodeName)) { boolean coalesce = getBooleanValue(textContent); builder.addPropertyValue("coalesce", coalesce); } else if ("populate".equals(nodeName)) { boolean populate = getBooleanValue(textContent); builder.addPropertyValue("populate", populate); } else if ("indexes".equals(nodeName)) {
private void handleWanConsumerConfig(WanConsumerConfig consumerConfig, Node targetChild) { String targetChildName = cleanNodeName(targetChild); if ("class-name".equals(targetChildName)) { consumerConfig.setClassName(getTextContent(targetChild)); } else if ("properties".equals(targetChildName)) { fillProperties(targetChild, consumerConfig.getProperties()); } else if ("persist-wan-replicated-data".equals(targetChildName)) { consumerConfig.setPersistWanReplicatedData(getBooleanValue(getTextContent(targetChild))); } }
protected String getTextContent(Node node) { return DomConfigHelper.getTextContent(node, domLevel3); }
private void handleWanPublisherConfig(WanPublisherConfig publisherConfig, Node targetChild) { String targetChildName = cleanNodeName(targetChild); if ("class-name".equals(targetChildName)) { publisherConfig.setClassName(getTextContent(targetChild)); } else if ("queue-full-behavior".equals(targetChildName)) { String queueFullBehavior = getTextContent(targetChild); publisherConfig.setQueueFullBehavior(WANQueueFullBehavior.valueOf(upperCaseInternal(queueFullBehavior))); } else if ("initial-publisher-state".equals(targetChildName)) { String initialPublisherState = getTextContent(targetChild); publisherConfig.setInitialPublisherState( WanPublisherState.valueOf(upperCaseInternal(initialPublisherState))); } else if ("queue-capacity".equals(targetChildName)) { int queueCapacity = getIntegerValue("queue-capacity", getTextContent(targetChild)); publisherConfig.setQueueCapacity(queueCapacity); } else if ("properties".equals(targetChildName)) { fillProperties(targetChild, publisherConfig.getProperties()); } else if (AliasedDiscoveryConfigUtils.supports(targetChildName)) { handleAliasedDiscoveryStrategy(publisherConfig, targetChild, targetChildName); } else if ("discovery-strategies".equals(targetChildName)) { handleDiscoveryStrategies(publisherConfig.getDiscoveryConfig(), targetChild); } else if ("wan-sync".equals(targetChildName)) { handleWanSync(publisherConfig.getWanSyncConfig(), targetChild); } }
public static int getIntegerValue(final String parameterName, final String value, int defaultValue) { if (isNullOrEmpty(value)) { return defaultValue; } return getIntegerValue(parameterName, value); }
private void handleLiteMember(Node node) { Node attrEnabled = node.getAttributes().getNamedItem("enabled"); boolean liteMember = attrEnabled != null && getBooleanValue(getTextContent(attrEnabled)); config.setLiteMember(liteMember); }
private ManagedList<BeanDefinition> getIndexes(Node node) { ManagedList<BeanDefinition> indexes = new ManagedList<BeanDefinition>(); for (Node indexNode : childElements(node)) { BeanDefinitionBuilder indexConfBuilder = createBeanBuilder(MapIndexConfig.class); fillAttributeValues(indexNode, indexConfBuilder); indexes.add(indexConfBuilder.getBeanDefinition()); } return indexes; }
public static long getLongValue(final String parameterName, final String value, long defaultValue) { if (isNullOrEmpty(value)) { return defaultValue; } return getLongValue(parameterName, value); }
private void replaceImportElementsWithActualFileContents(Node root) throws Exception { Document document = root.getOwnerDocument(); NodeList misplacedImports = (NodeList) xpath.evaluate( format("//hz:%s/parent::*[not(self::hz:%s)]", IMPORT.name, getXmlType().name), document, XPathConstants.NODESET); if (misplacedImports.getLength() > 0) { throw new InvalidConfigurationException("<import> element can appear only in the top level of the XML"); } NodeList importTags = (NodeList) xpath.evaluate( format("/hz:%s/hz:%s", getXmlType().name, IMPORT.name), document, XPathConstants.NODESET); for (Node node : asElementIterable(importTags)) { loadAndReplaceImportElement(root, node); } }
private void handleTcpIp(Node node) { NamedNodeMap attributes = node.getAttributes(); JoinConfig join = config.getNetworkConfig().getJoin(); TcpIpConfig tcpIpConfig = join.getTcpIpConfig(); for (int a = 0; a < attributes.getLength(); a++) { Node att = attributes.item(a); String value = getTextContent(att).trim(); if (att.getNodeName().equals("enabled")) { tcpIpConfig.setEnabled(getBooleanValue(value)); } else if (att.getNodeName().equals("connection-timeout-seconds")) { tcpIpConfig.setConnectionTimeoutSeconds(getIntegerValue("connection-timeout-seconds", value)); } } Set<String> memberTags = new HashSet<String>(Arrays.asList("interface", "member", "members")); for (Node n : childElements(node)) { String value = getTextContent(n).trim(); if (cleanNodeName(n).equals("member-list")) { handleMemberList(n); } else if (cleanNodeName(n).equals("required-member")) { if (tcpIpConfig.getRequiredMember() != null) { throw new InvalidConfigurationException("Duplicate required-member" + " definition found in XML configuration. "); } tcpIpConfig.setRequiredMember(value); } else if (memberTags.contains(cleanNodeName(n))) { tcpIpConfig.addMember(value); } } }
private void handleSecurityPermissionEndpoints(Node node, List<String> endpoints) { for (Node child : childElements(node)) { String nodeName = cleanNodeName(child); if ("endpoint".equals(nodeName)) { endpoints.add(getTextContent(child)); } } }