public static int getIntegerValue(final String parameterName, final String value, int defaultValue) { if (isNullOrEmpty(value)) { return defaultValue; } return getIntegerValue(parameterName, value); }
private QuorumConfigBuilder handleRecentlyActiveQuorum(String name, Node node, int quorumSize) { QuorumConfigBuilder quorumConfigBuilder; int heartbeatToleranceMillis = getIntegerValue("heartbeat-tolerance-millis", getAttribute(node, "heartbeat-tolerance-millis"), RecentlyActiveQuorumConfigBuilder.DEFAULT_HEARTBEAT_TOLERANCE_MILLIS); quorumConfigBuilder = QuorumConfig.newRecentlyActiveQuorumConfigBuilder(name, quorumSize, heartbeatToleranceMillis); return quorumConfigBuilder; }
private QuorumConfigBuilder handleRecentlyActiveQuorum(String name, Node node, int quorumSize) { QuorumConfigBuilder quorumConfigBuilder; int heartbeatToleranceMillis = getIntegerValue("heartbeat-tolerance-millis", getAttribute(node, "heartbeat-tolerance-millis"), RecentlyActiveQuorumConfigBuilder.DEFAULT_HEARTBEAT_TOLERANCE_MILLIS); quorumConfigBuilder = QuorumConfig.newRecentlyActiveQuorumConfigBuilder(name, quorumSize, heartbeatToleranceMillis); return quorumConfigBuilder; }
private void handleSemaphore(Node node) { Node attName = node.getAttributes().getNamedItem("name"); String name = getTextContent(attName); SemaphoreConfig sConfig = new SemaphoreConfig(); sConfig.setName(name); for (Node n : childElements(node)) { String nodeName = cleanNodeName(n); String value = getTextContent(n).trim(); if ("initial-permits".equals(nodeName)) { sConfig.setInitialPermits(getIntegerValue("initial-permits", value)); } else if ("backup-count".equals(nodeName)) { sConfig.setBackupCount(getIntegerValue("backup-count" , value)); } else if ("async-backup-count".equals(nodeName)) { sConfig.setAsyncBackupCount(getIntegerValue("async-backup-count" , value)); } else if ("quorum-ref".equals(nodeName)) { sConfig.setQuorumName(value); } } config.addSemaphoreConfig(sConfig); }
private MergePolicyConfig createMergePolicyConfig(Node node) { MergePolicyConfig mergePolicyConfig = new MergePolicyConfig(); String policyString = getTextContent(node).trim(); mergePolicyConfig.setPolicy(policyString); final String att = getAttribute(node, "batch-size"); if (att != null) { mergePolicyConfig.setBatchSize(getIntegerValue("batch-size", att)); } return mergePolicyConfig; }
String value = getTextContent(n).trim(); if ("max-thread-size".equals(nodeName)) { jConfig.setMaxThreadSize(getIntegerValue("max-thread-size", value)); } else if ("queue-size".equals(nodeName)) { jConfig.setQueueSize(getIntegerValue("queue-size", value)); } else if ("retry-count".equals(nodeName)) { jConfig.setRetryCount(getIntegerValue("retry-count", value)); } else if ("chunk-size".equals(nodeName)) { jConfig.setChunkSize(getIntegerValue("chunk-size", value)); } else if ("communicate-stats".equals(nodeName)) { jConfig.setCommunicateStats(value.length() == 0 ? DEFAULT_COMMUNICATE_STATS : parseBoolean(value));
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); }
queryCacheConfig.setIncludeValue(includeValue); } else if ("batch-size".equals(nodeName)) { int batchSize = getIntegerValue("batch-size", textContent.trim() ); queryCacheConfig.setBatchSize(batchSize); } else if ("buffer-size".equals(nodeName)) { int bufferSize = getIntegerValue("buffer-size", textContent.trim() ); queryCacheConfig.setBufferSize(bufferSize); } else if ("delay-seconds".equals(nodeName)) { int delaySeconds = getIntegerValue("delay-seconds", textContent.trim() ); queryCacheConfig.setDelaySeconds(delaySeconds);
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 handleHotRestartPersistence(Node hrRoot) { HotRestartPersistenceConfig hrConfig = new HotRestartPersistenceConfig() .setEnabled(getBooleanValue(getAttribute(hrRoot, "enabled"))); String parallelismName = "parallelism"; String validationTimeoutName = "validation-timeout-seconds"; String dataLoadTimeoutName = "data-load-timeout-seconds"; String clusterDataRecoveryPolicyName = "cluster-data-recovery-policy"; String autoRemoveStaleDataName = "auto-remove-stale-data"; for (Node n : childElements(hrRoot)) { String name = cleanNodeName(n); String value = getTextContent(n); if ("base-dir".equals(name)) { hrConfig.setBaseDir(new File(value).getAbsoluteFile()); } else if ("backup-dir".equals(name)) { hrConfig.setBackupDir(new File(value).getAbsoluteFile()); } else if (parallelismName.equals(name)) { hrConfig.setParallelism(getIntegerValue(parallelismName, value)); } else if (validationTimeoutName.equals(name)) { hrConfig.setValidationTimeoutSeconds(getIntegerValue(validationTimeoutName, value)); } else if (dataLoadTimeoutName.equals(name)) { hrConfig.setDataLoadTimeoutSeconds(getIntegerValue(dataLoadTimeoutName, value)); } else if (clusterDataRecoveryPolicyName.equals(name)) { hrConfig.setClusterDataRecoveryPolicy(HotRestartClusterDataRecoveryPolicy .valueOf(upperCaseInternal(value))); } else if (autoRemoveStaleDataName.equals(name)) { hrConfig.setAutoRemoveStaleData(getBooleanValue(value)); } } config.setHotRestartPersistenceConfig(hrConfig); }
private void handleManagementCenterConfig(Node node) { NamedNodeMap attrs = node.getAttributes(); Node enabledNode = attrs.getNamedItem("enabled"); boolean enabled = enabledNode != null && getBooleanValue(getTextContent(enabledNode)); Node intervalNode = attrs.getNamedItem("update-interval"); int interval = intervalNode != null ? getIntegerValue("update-interval", getTextContent(intervalNode)) : ManagementCenterConfig.UPDATE_INTERVAL; ManagementCenterConfig managementCenterConfig = config.getManagementCenterConfig(); managementCenterConfig.setEnabled(enabled); managementCenterConfig.setUpdateInterval(interval); Node scriptingEnabledNode = attrs.getNamedItem("scripting-enabled"); if (scriptingEnabledNode != null) { managementCenterConfig.setScriptingEnabled(getBooleanValue(getTextContent(scriptingEnabledNode))); } handleManagementCenterChildElements(node, managementCenterConfig); }
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); } } }
String value = getTextContent(n).trim(); if ("max-size".equals(nodeName)) { qConfig.setMaxSize(getIntegerValue("max-size", value)); } else if ("backup-count".equals(nodeName)) { qConfig.setBackupCount(getIntegerValue("backup-count", value)); } else if ("async-backup-count".equals(nodeName)) { qConfig.setAsyncBackupCount(getIntegerValue("async-backup-count", value)); } else if ("item-listeners".equals(nodeName)) { for (Node listenerNode : childElements(n)) { qConfig.setQuorumName(value); } else if ("empty-queue-ttl".equals(nodeName)) { qConfig.setEmptyQueueTtl(getIntegerValue("empty-queue-ttl", value)); } else if ("merge-policy".equals(nodeName)) { MergePolicyConfig mergePolicyConfig = createMergePolicyConfig(n);
String value = getTextContent(n).trim(); if ("max-size".equals(nodeName)) { sConfig.setMaxSize(getIntegerValue("max-size", value)); } else if ("backup-count".equals(nodeName)) { sConfig.setBackupCount(getIntegerValue("backup-count", value)); } else if ("async-backup-count".equals(nodeName)) { sConfig.setAsyncBackupCount(getIntegerValue("async-backup-count", value)); } else if ("item-listeners".equals(nodeName)) { for (Node listenerNode : childElements(n)) {
String value = getTextContent(n).trim(); if ("max-size".equals(nodeName)) { lConfig.setMaxSize(getIntegerValue("max-size", value)); } else if ("backup-count".equals(nodeName)) { lConfig.setBackupCount(getIntegerValue("backup-count", value)); } else if ("async-backup-count".equals(nodeName)) { lConfig.setAsyncBackupCount(getIntegerValue("async-backup-count", value)); } else if ("item-listeners".equals(nodeName)) { for (Node listenerNode : childElements(n)) {
private NearCachePreloaderConfig getNearCachePreloaderConfig(Node node) { NearCachePreloaderConfig preloaderConfig = new NearCachePreloaderConfig(); String enabled = getAttribute(node, "enabled"); String directory = getAttribute(node, "directory"); String storeInitialDelaySeconds = getAttribute(node, "store-initial-delay-seconds"); String storeIntervalSeconds = getAttribute(node, "store-interval-seconds"); if (enabled != null) { preloaderConfig.setEnabled(getBooleanValue(enabled)); } if (directory != null) { preloaderConfig.setDirectory(directory); } if (storeInitialDelaySeconds != null) { preloaderConfig.setStoreInitialDelaySeconds(getIntegerValue("storage-initial-delay-seconds", storeInitialDelaySeconds)); } if (storeIntervalSeconds != null) { preloaderConfig.setStoreIntervalSeconds(getIntegerValue("storage-interval-seconds", storeIntervalSeconds)); } return preloaderConfig; }
private void handleReliableTopic(Node node) { Node attName = node.getAttributes().getNamedItem("name"); String name = getTextContent(attName); ReliableTopicConfig topicConfig = new ReliableTopicConfig(name); for (Node n : childElements(node)) { String nodeName = cleanNodeName(n); if ("read-batch-size".equals(nodeName)) { String batchSize = getTextContent(n); topicConfig.setReadBatchSize(getIntegerValue("read-batch-size", batchSize)); } else if ("statistics-enabled".equals(nodeName)) { topicConfig.setStatisticsEnabled(getBooleanValue(getTextContent(n))); } else if ("topic-overload-policy".equals(nodeName)) { TopicOverloadPolicy topicOverloadPolicy = TopicOverloadPolicy.valueOf(upperCaseInternal(getTextContent(n))); topicConfig.setTopicOverloadPolicy(topicOverloadPolicy); } else if ("message-listeners".equals(nodeName)) { for (Node listenerNode : childElements(n)) { if ("message-listener".equals(cleanNodeName(listenerNode))) { topicConfig.addMessageListenerConfig(new ListenerConfig(getTextContent(listenerNode))); } } } } config.addReliableTopicConfig(topicConfig); }
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); } }
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; }
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; }