This is an automated email from the ASF dual-hosted git repository.
mcvsubbu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-pinot.git
The following commit(s) were added to refs/heads/master by this push:
new 4c04e1f [7156] Human Readable Controller Configs (#7173)
4c04e1f is described below
commit 4c04e1f73798db2b739ae151c030ef2564be8367
Author: suddendust <[email protected]>
AuthorDate: Fri Jul 23 21:39:37 2021 +0530
[7156] Human Readable Controller Configs (#7173)
* Initial commit:
1. Created period variables.
2. Modified getters of some 'inSeconds' variables to read the period config
and fallback to the 'inSeconds' config is the former is missing.
* Marked older configs as deprecated, added convertPeriodToUnit and
convertPeriodToSeconds
* Refactored multiple optionals code
* Added UT for ControllerConf.java
* Minor refactoring
* Removed DELETED_SEGMENTS_RETENTION_PERIOD to remove ambiguity in units
* Used correct method signature from getProperty(name, clazz) to
getProperty(name) to get properties of type strings
* Added UT to test when valid unit and invalid period configs are specified
* Addresses comments:
1. Rolled-back changes to controller.realtime.segment.commit.timeoutPeriod
and server.request.timeoutPeriod.
2. Corrected documentation of getters.
* Replaced List.of with Arrays.asList to make it compatible with JDK8
* spotless
* Addressed comments:
1. Prefixed DEPRECATED configs with DEPRECATED_
2. Handled disabling using -1 for controller.task.frequencyPeriod.
3. Un-did changes to controller.statuschecker.waitForPushTimePeriod.
4. Enhanced unit tests.
* Added license
* Removed changes to intial delay configs
* Removed unchanged configs from UT
* Fixed breaking integration test
* Marked deprecated configs with build version
* Addressed PR comments:
1. Removed DEPRECATED_VALIDATION_MANAGER_FREQUENCY_IN_SECONDS.
2. Printed the configuration under test for failing assertions.
---
.../apache/pinot/controller/ControllerConf.java | 263 +++++++++++++--------
.../pinot/controller/ControllerConfTest.java | 197 +++++++++++++++
.../ControllerPeriodicTasksIntegrationTest.java | 6 +-
.../UpsertTableSegmentUploadIntegrationTest.java | 4 +-
.../apache/pinot/tools/utils/PinotConfigUtils.java | 8 +-
5 files changed, 376 insertions(+), 102 deletions(-)
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 c2c93df..c388120 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.List;
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 class ControllerConf extends PinotConfiguration {
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 @@ public class ControllerConf extends PinotConfiguration {
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 class ControllerConf extends PinotConfiguration {
}
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
<code>controller.offline.segment.interval.checker.frequencyPeriod</code>, or
+ * <code>controller.offline.segment.interval.checker.frequencyPeriod</code>
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
<code>controller.realtime.segment.validation.frequencyPeriod</code> or
+ * <code>controller.realtime.segment.validation.frequencyInSeconds</code> 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 <code>controller.broker.resource.validation.frequencyPeriod</code>
or
+ * <code>controller.broker.resource.validation.frequencyInSeconds</code> 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 class ControllerConf extends PinotConfiguration {
}
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
+ * <code>controller.segment.relocator.frequencyInSeconds</code> or
<code>controller.segment.relocator.frequencyInSeconds</code>
+ * 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 class ControllerConf extends PinotConfiguration {
}
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 class ControllerConf extends PinotConfiguration {
}
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 class ControllerConf extends PinotConfiguration {
}
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 class ControllerConf extends PinotConfiguration {
.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 0000000..f9e4dfc
--- /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<String> 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<String> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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 812bd46..1f5fe9c 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 class ControllerPeriodicTasksIntegrationTest
extends BaseClusterIntegrati
Map<String, Object> 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 922f285..fd7b604 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 @@ public class UpsertTableSegmentUploadIntegrationTest
extends BaseClusterIntegrat
Map<String, Object> 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 a08a587..ab089e2 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 class PinotConfigUtils {
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;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
