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;