diff --git a/pinot-controller/src/main/java/org/apache/pinot/controller/ControllerConf.java b/pinot-controller/src/main/java/org/apache/pinot/controller/ControllerConf.java
index c2c93df470b..c38812088cf 100644
--- a/pinot-controller/src/main/java/org/apache/pinot/controller/ControllerConf.java
+++ b/pinot-controller/src/main/java/org/apache/pinot/controller/ControllerConf.java
@@ -25,6 +25,7 @@
import java.util.Map;
import java.util.Optional;
import java.util.Random;
+import java.util.concurrent.TimeUnit;
import org.apache.commons.configuration.Configuration;
import org.apache.helix.controller.rebalancer.strategy.AutoRebalanceStrategy;
import org.apache.pinot.common.protocols.SegmentCompletionProtocol;
@@ -75,45 +76,87 @@ public enum ControllerMode {
public static class ControllerPeriodicTasksConf {
// frequency configs
- public static final String RETENTION_MANAGER_FREQUENCY_IN_SECONDS = "controller.retention.frequencyInSeconds";
+ // Deprecated as of 0.8.0
@Deprecated
- // The ValidationManager has been split up into 3 separate tasks, each having their own frequency config settings
- public static final String DEPRECATED_VALIDATION_MANAGER_FREQUENCY_IN_SECONDS =
- "controller.validation.frequencyInSeconds";
- public static final String OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS =
+ public static final String DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS =
+ "controller.retention.frequencyInSeconds";
+ public static final String RETENTION_MANAGER_FREQUENCY_PERIOD = "controller.retention.frequencyPeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS =
"controller.offline.segment.interval.checker.frequencyInSeconds";
- public static final String REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS =
+ public static final String OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_PERIOD =
+ "controller.offline.segment.interval.checker.frequencyPeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS =
"controller.realtime.segment.validation.frequencyInSeconds";
+ public static final String REALTIME_SEGMENT_VALIDATION_FREQUENCY_PERIOD =
+ "controller.realtime.segment.validation.frequencyPeriod";
public static final String REALTIME_SEGMENT_VALIDATION_INITIAL_DELAY_IN_SECONDS =
"controller.realtime.segment.validation.initialDelayInSeconds";
- public static final String BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS =
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS =
"controller.broker.resource.validation.frequencyInSeconds";
+ public static final String BROKER_RESOURCE_VALIDATION_FREQUENCY_PERIOD =
+ "controller.broker.resource.validation.frequencyPeriod";
public static final String BROKER_RESOURCE_VALIDATION_INITIAL_DELAY_IN_SECONDS =
"controller.broker.resource.validation.initialDelayInSeconds";
- public static final String STATUS_CHECKER_FREQUENCY_IN_SECONDS = "controller.statuschecker.frequencyInSeconds";
- public static final String STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS =
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_STATUS_CHECKER_FREQUENCY_IN_SECONDS =
+ "controller.statuschecker.frequencyInSeconds";
+ public static final String STATUS_CHECKER_FREQUENCY_PERIOD = "controller.statuschecker.frequencyPeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS =
"controller.statuschecker.waitForPushTimeInSeconds";
- public static final String TASK_MANAGER_FREQUENCY_IN_SECONDS = "controller.task.frequencyInSeconds";
- public static final String MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS =
+ public static final String STATUS_CHECKER_WAIT_FOR_PUSH_TIME_PERIOD =
+ "controller.statuschecker.waitForPushTimePeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_TASK_MANAGER_FREQUENCY_IN_SECONDS = "controller.task.frequencyInSeconds";
+ public static final String TASK_MANAGER_FREQUENCY_PERIOD = "controller.statuschecker.waitForPushTimePeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS =
"controller.minion.instances.cleanup.task.frequencyInSeconds";
+ public static final String MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_PERIOD =
+ "controller.minion.instances.cleanup.task.frequencyPeriod";
public static final String MINION_INSTANCES_CLEANUP_TASK_INITIAL_DELAY_SECONDS =
"controller.minion.instances.cleanup.task.initialDelaySeconds";
- public static final String MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS =
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS =
"controller.minion.instances.cleanup.task.minOfflineTimeBeforeDeletionSeconds";
- public static final String TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS =
+ public static final String MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_PERIOD =
+ "controller.minion.instances.cleanup.task.minOfflineTimeBeforeDeletionPeriod";
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS =
"controller.minion.task.metrics.emitter.frequencyInSeconds";
+ public static final String TASK_METRICS_EMITTER_FREQUENCY_PERIOD =
+ "controller.minion.task.metrics.emitter.frequencyPeriod";
public static final String PINOT_TASK_MANAGER_SCHEDULER_ENABLED = "controller.task.scheduler.enabled";
@Deprecated
// RealtimeSegmentRelocator has been rebranded as SegmentRelocator
public static final String DEPRECATED_REALTIME_SEGMENT_RELOCATOR_FREQUENCY =
"controller.realtime.segment.relocator.frequency";
- public static final String SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS =
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS =
"controller.segment.relocator.frequencyInSeconds";
+ public static final String SEGMENT_RELOCATOR_FREQUENCY_PERIOD = "controller.segment.relocator.frequencyPeriod";
// Because segment level validation is expensive and requires heavy ZK access, we run segment level validation with a
// separate interval
- public static final String SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS =
+ // Deprecated as of 0.8.0
+ @Deprecated
+ public static final String DEPRECATED_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS =
"controller.segment.level.validation.intervalInSeconds";
+ public static final String SEGMENT_LEVEL_VALIDATION_INTERVAL_PERIOD =
+ "controller.segment.level.validation.intervalPeriod";
// Initial delays
public static final String STATUS_CHECKER_INITIAL_DELAY_IN_SECONDS =
@@ -148,7 +191,8 @@ private static long getRandomInitialDelayInSeconds() {
private static final int DEFAULT_STATUS_CONTROLLER_WAIT_FOR_PUSH_TIME_IN_SECONDS = 10 * 60; // 10 minutes
private static final int DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS = -1; // Disabled
private static final int DEFAULT_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS = 60 * 60; // 1 Hour.
- private static final int DEFAULT_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_IN_SECONDS = 60 * 60; // 1 Hour.
+ private static final int DEFAULT_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_IN_SECONDS =
+ 60 * 60; // 1 Hour.
private static final int DEFAULT_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS = 24 * 60 * 60;
private static final int DEFAULT_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS = 60 * 60;
@@ -418,69 +462,79 @@ public String getControllerBrokerProtocol() {
}
public int getRetentionControllerFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.RETENTION_MANAGER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_RETENTION_CONTROLLER_FREQUENCY_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.RETENTION_MANAGER_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_RETENTION_CONTROLLER_FREQUENCY_IN_SECONDS));
}
public void setRetentionControllerFrequencyInSeconds(int retentionFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.RETENTION_MANAGER_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS,
Integer.toString(retentionFrequencyInSeconds));
}
/**
- * Returns the config value for controller.offline.segment.interval.checker.frequencyInSeconds if it exists.
- * If it doesn't exist, returns the segment level validation interval. This is done in order to retain the current behavior,
- * wherein the offline validation tasks were done at segment level validation interval frequency
- * The default value is the new DEFAULT_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS
- * @return
+ * Returns controller.offline.segment.interval.checker.frequencyPeriod
, or
+ * controller.offline.segment.interval.checker.frequencyPeriod
or the segment level
+ * validation interval, in the order of decreasing preference from left to right. Falls-back to
+ * the next config only if the current config is missing. This is done in order to retain the
+ * current behavior, wherein the offline validation tasks were done at segment level validation
+ * interval frequency The default value is the new DEFAULT_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS
+ *
+ * @return the supplied config in seconds
*/
public int getOfflineSegmentIntervalCheckerFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS);
+ return Optional
+ .ofNullable(getProperty(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(() -> getProperty(
+ ControllerPeriodicTasksConf.DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS));
}
public void setOfflineSegmentIntervalCheckerFrequencyInSeconds(int validationFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
Integer.toString(validationFrequencyInSeconds));
}
/**
- * Returns the config value for controller.realtime.segment.validation.frequencyInSeconds if it exists.
- * If it doesn't exist, returns the validation controller frequency. This is done in order to retain the current behavior,
- * wherein the realtime validation tasks were done at validation controller frequency
- * The default value is the new DEFAULT_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS
- * @return
+ * Returns controller.realtime.segment.validation.frequencyPeriod
or
+ * controller.realtime.segment.validation.frequencyInSeconds
or the default realtime segment
+ * validation frequncy, in the order of decreasing preference from left to right. This is done in
+ * order to retain the current behavior, wherein the realtime validation tasks were done at
+ * validation controller frequency The default value is the new DEFAULT_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS
+ *
+ * @return supplied config in seconds
*/
public int getRealtimeSegmentValidationFrequencyInSeconds() {
- return Optional.ofNullable(
- getProperty(ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS, Integer.class))
-
- .orElseGet(() -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_VALIDATION_MANAGER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS));
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS));
}
public void setRealtimeSegmentValidationFrequencyInSeconds(int validationFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS,
Integer.toString(validationFrequencyInSeconds));
}
/**
- * Returns the config value for controller.broker.resource.validation.frequencyInSeconds if it exists.
- * If it doesn't exist, returns the validation controller frequency. This is done in order to retain the current behavior,
- * wherein the broker resource validation tasks were done at validation controller frequency
- * The default value is the new DEFAULT_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS
- * @return
+ * Return controller.broker.resource.validation.frequencyPeriod
or
+ * controller.broker.resource.validation.frequencyInSeconds
or the default broker resource validation
+ * frequency, in order of decreasing preference from left to righ. This is done in order
+ * to retain the current behavior, wherein the broker resource validation tasks were done at
+ * validation controller frequency The default value is the new DEFAULT_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS
+ *
+ * @return the supplied config in seconds
*/
public int getBrokerResourceValidationFrequencyInSeconds() {
- return Optional.ofNullable(
- getProperty(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, Integer.class))
-
- .orElseGet(() -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_VALIDATION_MANAGER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS));
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS));
}
public void setBrokerResourceValidationFrequencyInSeconds(int validationFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS,
Integer.toString(validationFrequencyInSeconds));
}
@@ -490,56 +544,67 @@ public long getBrokerResourceValidationInitialDelayInSeconds() {
}
public int getStatusCheckerFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_STATUS_CONTROLLER_FREQUENCY_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_STATUS_CHECKER_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_STATUS_CONTROLLER_FREQUENCY_IN_SECONDS));
}
public void setStatusCheckerFrequencyInSeconds(int statusCheckerFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_STATUS_CHECKER_FREQUENCY_IN_SECONDS,
Integer.toString(statusCheckerFrequencyInSeconds));
}
public int getTaskMetricsEmitterFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.TASK_METRICS_EMITTER_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS));
}
public void setTaskMetricsEmitterFrequencyInSeconds(int taskMetricsEmitterFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS,
Integer.toString(taskMetricsEmitterFrequencyInSeconds));
}
public int getStatusCheckerWaitForPushTimeInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_STATUS_CONTROLLER_WAIT_FOR_PUSH_TIME_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_WAIT_FOR_PUSH_TIME_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_STATUS_CONTROLLER_WAIT_FOR_PUSH_TIME_IN_SECONDS));
}
public void setStatusCheckerWaitForPushTimeInSeconds(int statusCheckerWaitForPushTimeInSeconds) {
- setProperty(ControllerPeriodicTasksConf.STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS,
Integer.toString(statusCheckerWaitForPushTimeInSeconds));
}
/**
- * RealtimeSegmentRelocator has been rebranded to SegmentRelocator.
- * Check for SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS property, if not found, return REALTIME_SEGMENT_RELOCATOR_FREQUENCY
+ * RealtimeSegmentRelocator has been rebranded to SegmentRelocator. Returns
+ * controller.segment.relocator.frequencyInSeconds
or controller.segment.relocator.frequencyInSeconds
+ * or REALTIME_SEGMENT_RELOCATOR_FREQUENCY, in the order of decreasing perference (left ->
+ * right).
*/
public int getSegmentRelocatorFrequencyInSeconds() {
- Integer segmentRelocatorFreqSeconds =
- getProperty(ControllerPeriodicTasksConf.SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS, Integer.class);
- if (segmentRelocatorFreqSeconds == null) {
- String realtimeSegmentRelocatorPeriod =
- getProperty(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_RELOCATOR_FREQUENCY);
- if (realtimeSegmentRelocatorPeriod != null) {
- segmentRelocatorFreqSeconds = (int) convertPeriodToSeconds(realtimeSegmentRelocatorPeriod);
- } else {
- segmentRelocatorFreqSeconds = ControllerPeriodicTasksConf.DEFAULT_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS;
- }
- }
- return segmentRelocatorFreqSeconds;
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.SEGMENT_RELOCATOR_FREQUENCY_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(() -> {
+ Integer segmentRelocatorFreqSeconds =
+ getProperty(ControllerPeriodicTasksConf.DEPRECATED_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS, Integer.class);
+ if (segmentRelocatorFreqSeconds == null) {
+ String realtimeSegmentRelocatorPeriod =
+ getProperty(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_RELOCATOR_FREQUENCY);
+ if (realtimeSegmentRelocatorPeriod != null) {
+ segmentRelocatorFreqSeconds = (int) convertPeriodToSeconds(realtimeSegmentRelocatorPeriod);
+ } else {
+ segmentRelocatorFreqSeconds = ControllerPeriodicTasksConf.DEFAULT_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS;
+ }
+ }
+ return segmentRelocatorFreqSeconds;
+ });
}
public void setSegmentRelocatorFrequencyInSeconds(int segmentRelocatorFrequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS,
Integer.toString(segmentRelocatorFrequencyInSeconds));
}
@@ -568,21 +633,30 @@ public void setDeletedSegmentsRetentionInDays(int retentionInDays) {
}
public int getTaskManagerFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.TASK_MANAGER_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.TASK_MANAGER_FREQUENCY_PERIOD)).map(period -> {
+ //check if DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS is supplied. If yes, return it
+ if (period.equals(Integer.toString(ControllerPeriodicTasksConf.DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS))) {
+ return ControllerPeriodicTasksConf.DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS;
+ }
+ return (int) convertPeriodToSeconds(period);
+ }).orElseGet(() -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_TASK_MANAGER_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_TASK_MANAGER_FREQUENCY_IN_SECONDS));
}
public void setTaskManagerFrequencyInSeconds(int frequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.TASK_MANAGER_FREQUENCY_IN_SECONDS, Integer.toString(frequencyInSeconds));
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_TASK_MANAGER_FREQUENCY_IN_SECONDS,
+ Integer.toString(frequencyInSeconds));
}
public long getMinionInstancesCleanupTaskFrequencyInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_PERIOD))
+ .map(this::convertPeriodToSeconds).orElseGet(() -> (long) getProperty(
+ ControllerPeriodicTasksConf.DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS));
}
public void setMinionInstancesCleanupTaskFrequencyInSeconds(int frequencyInSeconds) {
- setProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS,
+ setProperty(ControllerPeriodicTasksConf.DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS,
Integer.toString(frequencyInSeconds));
}
@@ -597,12 +671,16 @@ public void setMinionInstancesCleanupTaskInitialDelaySeconds(int initialDelaySec
}
public int getMinionInstancesCleanupTaskMinOfflineTimeBeforeDeletionInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_IN_SECONDS);
+ return Optional.ofNullable(
+ getProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(() -> getProperty(
+ ControllerPeriodicTasksConf.DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_IN_SECONDS));
}
public void setMinionInstancesCleanupTaskMinOfflineTimeBeforeDeletionInSeconds(int maxOfflineTimeRangeInSeconds) {
- setProperty(ControllerPeriodicTasksConf.MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS,
+ setProperty(
+ ControllerPeriodicTasksConf.DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS,
Integer.toString(maxOfflineTimeRangeInSeconds));
}
@@ -651,8 +729,10 @@ public boolean getEnableBatchMessageMode() {
}
public int getSegmentLevelValidationIntervalInSeconds() {
- return getProperty(ControllerPeriodicTasksConf.SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS,
- ControllerPeriodicTasksConf.DEFAULT_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS);
+ return Optional.ofNullable(getProperty(ControllerPeriodicTasksConf.SEGMENT_LEVEL_VALIDATION_INTERVAL_PERIOD))
+ .map(period -> (int) convertPeriodToSeconds(period)).orElseGet(
+ () -> getProperty(ControllerPeriodicTasksConf.DEPRECATED_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS,
+ ControllerPeriodicTasksConf.DEFAULT_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS));
}
public long getStatusCheckerInitialDelayInSeconds() {
@@ -740,15 +820,12 @@ public List getTableConfigTunerPackages() {
.asList(getProperty(TABLE_CONFIG_TUNER_PACKAGES, DEFAULT_TABLE_CONFIG_TUNER_PACKAGES).split("\\s*,\\s*"));
}
- private long convertPeriodToSeconds(String timeStr) {
- long seconds;
- try {
- Long millis = TimeUtils.convertPeriodToMillis(timeStr);
- seconds = millis / 1000;
- } catch (Exception e) {
- throw new RuntimeException("Invalid time spec '" + timeStr + "' (Valid examples: '3h', '4h30m', '30m')", e);
- }
- return seconds;
+ private long convertPeriodToUnit(String period, TimeUnit timeUnitToConvertTo) {
+ return timeUnitToConvertTo.convert(TimeUtils.convertPeriodToMillis(period), TimeUnit.MILLISECONDS);
+ }
+
+ private long convertPeriodToSeconds(String period) {
+ return convertPeriodToUnit(period, TimeUnit.SECONDS);
}
private String getSupportedProtocol(String property) {
diff --git a/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerConfTest.java b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerConfTest.java
new file mode 100644
index 00000000000..f9e4dfc9337
--- /dev/null
+++ b/pinot-controller/src/test/java/org/apache/pinot/controller/ControllerConfTest.java
@@ -0,0 +1,197 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.pinot.controller;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.apache.pinot.spi.utils.TimeUtils;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import static org.apache.pinot.controller.ControllerConf.ControllerPeriodicTasksConf.*;
+
+
+public class ControllerConfTest {
+
+ private static final List DEPRECATED_CONFIGS = Arrays
+ .asList(DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS,
+ DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
+ DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS,
+ DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS,
+ DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, DEPRECATED_STATUS_CHECKER_FREQUENCY_IN_SECONDS,
+ DEPRECATED_TASK_MANAGER_FREQUENCY_IN_SECONDS, DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_IN_SECONDS,
+ DEPRECATED_MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_SECONDS,
+ DEPRECATED_TASK_METRICS_EMITTER_FREQUENCY_IN_SECONDS, DEPRECATED_SEGMENT_RELOCATOR_FREQUENCY_IN_SECONDS,
+ DEPRECATED_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS,
+ DEPRECATED_REALTIME_SEGMENT_RELOCATION_INITIAL_DELAY_IN_SECONDS,
+ DEPRECATED_STATUS_CHECKER_WAIT_FOR_PUSH_TIME_IN_SECONDS);
+
+ private static final List NEW_CONFIGS = Arrays
+ .asList(RETENTION_MANAGER_FREQUENCY_PERIOD, OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_PERIOD,
+ REALTIME_SEGMENT_VALIDATION_FREQUENCY_PERIOD, BROKER_RESOURCE_VALIDATION_FREQUENCY_PERIOD,
+ STATUS_CHECKER_FREQUENCY_PERIOD, TASK_MANAGER_FREQUENCY_PERIOD,
+ MINION_INSTANCES_CLEANUP_TASK_FREQUENCY_PERIOD,
+ MINION_INSTANCES_CLEANUP_TASK_MIN_OFFLINE_TIME_BEFORE_DELETION_PERIOD, TASK_METRICS_EMITTER_FREQUENCY_PERIOD,
+ SEGMENT_RELOCATOR_FREQUENCY_PERIOD, SEGMENT_LEVEL_VALIDATION_INTERVAL_PERIOD,
+ STATUS_CHECKER_WAIT_FOR_PUSH_TIME_PERIOD);
+
+ private static final Random RAND = new Random();
+
+ /**
+ * When config contains: 1. Both deprecated config and the corresponding new config. 2. All new
+ * configurations are valid. 3. Some deprecated configurations are invalid, then new configs
+ * override deprecated configs (invalid deprecated configs do not throw exceptions when
+ * corresponding valid new configs are supplied as well)
+ */
+ @Test
+ public void validNewConfigOverridesCorrespondingValidOrInvalidOldConfigOnRead() {
+ //setup
+ Map controllerConfig = new HashMap<>();
+ int durationInSeconds = getRandomDurationInSeconds();
+ DEPRECATED_CONFIGS.forEach(config -> controllerConfig.put(config, durationInSeconds));
+ //put some invalid deprecated configs
+ controllerConfig.put(DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS, getRandomString());
+ controllerConfig.put(DEPRECATED_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS, getRandomString());
+ //override all deprecated configs with valid new configs
+ String period = getRandomPeriodInMinutes();
+ NEW_CONFIGS.forEach(config -> controllerConfig.put(config, period));
+ ControllerConf conf = new ControllerConf(controllerConfig);
+ //execution and assertion
+ assertOnDurations(conf, TimeUnit.SECONDS.convert(TimeUtils.convertPeriodToMillis(period), TimeUnit.MILLISECONDS),
+ controllerConfig);
+ }
+
+ /**
+ * When config contains: 1. Both deprecated config and the corresponding new config. 2. All
+ * deprecated configurations are valid. 3. Some new configurations are invalid, then exceptions
+ * are thrown when invalid new configurations are read (there is no fall-back to the corresponding
+ * valid deprecated configuration). For all valid new configurations, they override the
+ * corresponding deprecated configuration.
+ */
+ @Test
+ public void invalidNewConfigShouldThrowExceptionOnReadWithoutFallbackToCorrespondingValidDeprecatedConfig() {
+ //setup
+ Map controllerConfig = new HashMap<>();
+ int durationInSeconds = getRandomDurationInSeconds();
+ //all deprecated configs should be valid
+ DEPRECATED_CONFIGS.forEach(config -> controllerConfig.put(config, durationInSeconds));
+ String randomPeriodInMinutes = getRandomPeriodInMinutes();
+ NEW_CONFIGS.forEach(config -> controllerConfig.put(config, randomPeriodInMinutes));
+ //put some invalid new configs
+ controllerConfig.put(RETENTION_MANAGER_FREQUENCY_PERIOD, getRandomString());
+ ControllerConf conf = new ControllerConf(controllerConfig);
+ Assert.assertThrows(IllegalArgumentException.class, conf::getRetentionControllerFrequencyInSeconds);
+ }
+
+ /**
+ * When only deprecated configs are supplied (new configs are not supplied), then the correct
+ * converted value is returned.
+ */
+ @Test
+ public void supplyingOnlyDeprecatedConfigsShouldReturnCorrectlyConvertedValue() {
+ //setup
+ Map controllerConfig = new HashMap<>();
+ int durationInSeconds = getRandomDurationInSeconds();
+ DEPRECATED_CONFIGS.forEach(config -> {
+ controllerConfig.put(config, durationInSeconds);
+ });
+ //pre-conditions: config should not contain any new config
+ NEW_CONFIGS.forEach(config -> Assert.assertFalse(controllerConfig.containsKey(config)));
+ ControllerConf conf = new ControllerConf(controllerConfig);
+ //execution and assertion
+ assertOnDurations(conf, durationInSeconds, controllerConfig);
+ }
+
+ /**
+ * When only new configs are supplied (deprecated configs are not supplied), then the correct
+ * converted value is returned.
+ */
+ @Test
+ public void supplyingOnlyNewConfigsShouldReturnCorrectlyConvertedValue() {
+ //setup
+ Map controllerConfig = new HashMap<>();
+ String period = getRandomPeriodInMinutes();
+ NEW_CONFIGS.forEach(config -> controllerConfig.put(config, period));
+ //pre-conditions: controller config should not contain any deprecated config
+ DEPRECATED_CONFIGS.forEach(config -> Assert.assertFalse(controllerConfig.containsKey(config)));
+ ControllerConf conf = new ControllerConf(controllerConfig);
+ //execution and assertion
+ assertOnDurations(conf, TimeUnit.SECONDS.convert(TimeUtils.convertPeriodToMillis(period), TimeUnit.MILLISECONDS),
+ controllerConfig);
+ }
+
+ @Test
+ public void shouldBeAbleToDisableUsingNewConfig() {
+ Map controllerConfig = new HashMap<>();
+ controllerConfig.put(TASK_MANAGER_FREQUENCY_PERIOD, "-1");
+ ControllerConf conf = new ControllerConf(controllerConfig);
+ int taskManagerFrequencyInSeconds = conf.getTaskManagerFrequencyInSeconds();
+ Assert.assertEquals(taskManagerFrequencyInSeconds, -1);
+ }
+
+ private void assertOnDurations(ControllerConf conf, long expectedDuration, Map controllerConfig) {
+ int segmentLevelValidationIntervalInSeconds = conf.getSegmentLevelValidationIntervalInSeconds();
+ int segmentRelocatorFrequencyInSeconds = conf.getSegmentRelocatorFrequencyInSeconds();
+ int taskMetricsEmitterFrequencyInSeconds = conf.getTaskMetricsEmitterFrequencyInSeconds();
+ int minionInstancesCleanupTaskMinOfflineTimeBeforeDeletionInSeconds =
+ conf.getMinionInstancesCleanupTaskMinOfflineTimeBeforeDeletionInSeconds();
+ long minionInstancesCleanupTaskFrequencyInSeconds = conf.getMinionInstancesCleanupTaskFrequencyInSeconds();
+ int taskManagerFrequencyInSeconds = conf.getTaskManagerFrequencyInSeconds();
+ int statusCheckerFrequencyInSeconds = conf.getStatusCheckerFrequencyInSeconds();
+ int brokerResourceValidationFrequencyInSeconds = conf.getBrokerResourceValidationFrequencyInSeconds();
+ int realtimeSegmentValidationFrequencyInSeconds = conf.getRealtimeSegmentValidationFrequencyInSeconds();
+ int offlineSegmentIntervalCheckerFrequencyInSeconds = conf.getOfflineSegmentIntervalCheckerFrequencyInSeconds();
+ int retentionControllerFrequencyInSeconds = conf.getRetentionControllerFrequencyInSeconds();
+ //then
+ String confAsString = controllerConfig.toString();
+ Assert.assertEquals(segmentLevelValidationIntervalInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(segmentRelocatorFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(taskMetricsEmitterFrequencyInSeconds, expectedDuration, confAsString);
+ Assert
+ .assertEquals(minionInstancesCleanupTaskMinOfflineTimeBeforeDeletionInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(minionInstancesCleanupTaskFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(taskManagerFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(statusCheckerFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(brokerResourceValidationFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(realtimeSegmentValidationFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(offlineSegmentIntervalCheckerFrequencyInSeconds, expectedDuration, confAsString);
+ Assert.assertEquals(retentionControllerFrequencyInSeconds, expectedDuration, confAsString);
+ }
+
+ private int getRandomDurationInSeconds() {
+ return RAND.nextInt(50);
+ }
+
+ private String getRandomPeriodInMinutes() {
+ return getRandomMinutes() + "m";
+ }
+
+ private int getRandomMinutes() {
+ return 1 + RAND.nextInt(10);
+ }
+
+ private String getRandomString() {
+ return RandomStringUtils.randomAlphanumeric(5);
+ }
+}
diff --git a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ControllerPeriodicTasksIntegrationTest.java b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ControllerPeriodicTasksIntegrationTest.java
index 812bd469dd8..1f5fe9c7191 100644
--- a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ControllerPeriodicTasksIntegrationTest.java
+++ b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/ControllerPeriodicTasksIntegrationTest.java
@@ -109,13 +109,13 @@ public void setUp()
Map properties = getDefaultControllerConfiguration();
properties.put(ControllerConf.CLUSTER_TENANT_ISOLATION_ENABLE, false);
properties.put(ControllerPeriodicTasksConf.STATUS_CHECKER_INITIAL_DELAY_IN_SECONDS, PERIODIC_TASK_INITIAL_DELAY_SECONDS);
- properties.put(ControllerPeriodicTasksConf.STATUS_CHECKER_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_STATUS_CHECKER_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
properties.put(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_RELOCATION_INITIAL_DELAY_IN_SECONDS, PERIODIC_TASK_INITIAL_DELAY_SECONDS);
properties.put(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_RELOCATOR_FREQUENCY, PERIODIC_TASK_FREQUENCY);
properties.put(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_INITIAL_DELAY_IN_SECONDS, PERIODIC_TASK_INITIAL_DELAY_SECONDS);
- properties.put(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
properties.put(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_INITIAL_DELAY_IN_SECONDS, PERIODIC_TASK_INITIAL_DELAY_SECONDS);
- properties.put(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS, PERIODIC_TASK_FREQUENCY_SECONDS);
startController(properties);
startBrokers(NUM_BROKERS);
diff --git a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/UpsertTableSegmentUploadIntegrationTest.java b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/UpsertTableSegmentUploadIntegrationTest.java
index 922f285b17e..fd7b604dd89 100644
--- a/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/UpsertTableSegmentUploadIntegrationTest.java
+++ b/pinot-integration-tests/src/test/java/org/apache/pinot/integration/tests/UpsertTableSegmentUploadIntegrationTest.java
@@ -152,8 +152,8 @@ protected void startController()
Map controllerConfig = getDefaultControllerConfiguration();
// Perform realtime segment validation every second with 1 second initial delay.
controllerConfig
- .put(ControllerConf.ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS, 1);
- controllerConfig.put(ControllerConf.ControllerPeriodicTasksConf.SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS, 1);
+ .put(ControllerConf.ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS, 1);
+ controllerConfig.put(ControllerConf.ControllerPeriodicTasksConf.DEPRECATED_SEGMENT_LEVEL_VALIDATION_INTERVAL_IN_SECONDS, 1);
controllerConfig
.put(ControllerConf.ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_INITIAL_DELAY_IN_SECONDS, 1);
startController(controllerConfig);
diff --git a/pinot-tools/src/main/java/org/apache/pinot/tools/utils/PinotConfigUtils.java b/pinot-tools/src/main/java/org/apache/pinot/tools/utils/PinotConfigUtils.java
index a08a587f360..ab089e295d8 100644
--- a/pinot-tools/src/main/java/org/apache/pinot/tools/utils/PinotConfigUtils.java
+++ b/pinot-tools/src/main/java/org/apache/pinot/tools/utils/PinotConfigUtils.java
@@ -64,10 +64,10 @@ public static Map generateControllerConf(String zkAddress, Strin
properties.put(ControllerConf.DATA_DIR, !StringUtils.isEmpty(dataDir) ? dataDir : TMP_DIR + String.format("Controller_%s_%s/controller/data", controllerHost, controllerPort));
properties.put(ControllerConf.CONTROLLER_VIP_HOST, controllerHost);
properties.put(ControllerConf.CLUSTER_TENANT_ISOLATION_ENABLE, tenantIsolation);
- properties.put(ControllerPeriodicTasksConf.RETENTION_MANAGER_FREQUENCY_IN_SECONDS, 3600 * 6);
- properties.put(ControllerPeriodicTasksConf.OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS, 3600);
- properties.put(ControllerPeriodicTasksConf.REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS, 3600);
- properties.put(ControllerPeriodicTasksConf.BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, 3600);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_RETENTION_MANAGER_FREQUENCY_IN_SECONDS, 3600 * 6);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_OFFLINE_SEGMENT_INTERVAL_CHECKER_FREQUENCY_IN_SECONDS, 3600);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_REALTIME_SEGMENT_VALIDATION_FREQUENCY_IN_SECONDS, 3600);
+ properties.put(ControllerPeriodicTasksConf.DEPRECATED_BROKER_RESOURCE_VALIDATION_FREQUENCY_IN_SECONDS, 3600);
properties.put(ControllerConf.CONTROLLER_MODE, controllerMode.toString());
return properties;