From f9f6971336c26e1bcae4110f5e0926b3e92b4565 Mon Sep 17 00:00:00 2001 From: jaydeepkumar1984 Date: Wed, 20 Nov 2024 21:01:04 -0800 Subject: [PATCH] Rename AutoRepair --> UnifiedRepair --- .../pages/managing/operating/metrics.adoc | 14 +- .../org/apache/cassandra/config/Config.java | 4 +- .../cassandra/config/DatabaseDescriptor.java | 6 +- .../statements/schema/TableAttributes.java | 8 +- .../metrics/CassandraMetricsRegistry.java | 2 +- ...Metrics.java => UnifiedRepairMetrics.java} | 44 +- ....java => UnifiedRepairMetricsManager.java} | 10 +- .../DefaultUnifiedRepairTokenSplitter.java} | 12 +- .../IUnifiedRepairTokenRangeSplitter.java} | 10 +- .../UnifiedRepair.java} | 120 +++--- .../UnifiedRepairConfig.java} | 46 +- .../UnifiedRepairState.java} | 38 +- .../UnifiedRepairUtils.java} | 186 ++++----- .../cassandra/schema/SchemaKeyspace.java | 10 +- .../schema/SystemDistributedKeyspace.java | 44 +- .../apache/cassandra/schema/TableParams.java | 76 ++-- ...irParams.java => UnifiedRepairParams.java} | 30 +- .../cassandra/service/CassandraDaemon.java | 2 +- .../cassandra/service/StorageService.java | 14 +- ...Service.java => UnifiedRepairService.java} | 50 +-- ...an.java => UnifiedRepairServiceMBean.java} | 20 +- .../tcm/sequences/BootstrapAndJoin.java | 4 +- .../tcm/sequences/BootstrapAndReplace.java | 4 +- .../tcm/sequences/ReplaceSameAddress.java | 4 +- .../org/apache/cassandra/tools/NodeProbe.java | 94 ++--- .../org/apache/cassandra/tools/NodeTool.java | 6 +- ...onfig.java => GetUnifiedRepairConfig.java} | 22 +- ...onfig.java => SetUnifiedRepairConfig.java} | 28 +- ...irStatus.java => UnifiedRepairStatus.java} | 14 +- .../apache/cassandra/utils/FBUtilities.java | 12 +- ...t.java => UnifiedRepairSchedulerTest.java} | 34 +- test/unit/org/apache/cassandra/Util.java | 8 +- .../config/DatabaseDescriptorRefTest.java | 16 +- .../config/YamlConfigurationLoaderTest.java | 14 +- .../SSTableRepairedAtTest.java | 6 +- .../UnifiedRepairConfigTest.java} | 78 ++-- ...efaultTokenSplitterParameterizedTest.java} | 28 +- .../UnifiedRepairKeyspaceTest.java} | 10 +- .../UnifiedRepairParameterizedTest.java} | 394 +++++++++--------- .../UnifiedRepairStateFactoryTest.java} | 12 +- .../UnifiedRepairStateTest.java} | 84 ++-- .../UnifiedRepairTest.java} | 36 +- .../UnifiedRepairUtilsTest.java} | 174 ++++---- .../service/AutoRepairServiceBasicTest.java | 118 ------ .../UnifiedRepairServiceBasicTest.java | 118 ++++++ ...> UnifiedRepairServiceRepairTypeTest.java} | 26 +- ...va => UnifiedRepairServiceSetterTest.java} | 60 +-- .../cassandra/tools/JMXStandardsTest.java | 6 +- ...t.java => SetUnifiedRepairConfigTest.java} | 64 +-- ...Test.java => UnifiedRepairStatusTest.java} | 24 +- 50 files changed, 1122 insertions(+), 1122 deletions(-) rename src/java/org/apache/cassandra/metrics/{AutoRepairMetrics.java => UnifiedRepairMetrics.java} (76%) rename src/java/org/apache/cassandra/metrics/{AutoRepairMetricsManager.java => UnifiedRepairMetricsManager.java} (70%) rename src/java/org/apache/cassandra/repair/{autorepair/DefaultAutoRepairTokenSplitter.java => unifiedrepair/DefaultUnifiedRepairTokenSplitter.java} (82%) rename src/java/org/apache/cassandra/repair/{autorepair/IAutoRepairTokenRangeSplitter.java => unifiedrepair/IUnifiedRepairTokenRangeSplitter.java} (87%) rename src/java/org/apache/cassandra/repair/{autorepair/AutoRepair.java => unifiedrepair/UnifiedRepair.java} (78%) rename src/java/org/apache/cassandra/repair/{autorepair/AutoRepairConfig.java => unifiedrepair/UnifiedRepairConfig.java} (91%) rename src/java/org/apache/cassandra/repair/{autorepair/AutoRepairState.java => unifiedrepair/UnifiedRepairState.java} (88%) rename src/java/org/apache/cassandra/repair/{autorepair/AutoRepairUtils.java => unifiedrepair/UnifiedRepairUtils.java} (83%) rename src/java/org/apache/cassandra/schema/{AutoRepairParams.java => UnifiedRepairParams.java} (74%) rename src/java/org/apache/cassandra/service/{AutoRepairService.java => UnifiedRepairService.java} (72%) rename src/java/org/apache/cassandra/service/{AutoRepairServiceMBean.java => UnifiedRepairServiceMBean.java} (74%) rename src/java/org/apache/cassandra/tools/nodetool/{GetAutoRepairConfig.java => GetUnifiedRepairConfig.java} (82%) rename src/java/org/apache/cassandra/tools/nodetool/{SetAutoRepairConfig.java => SetUnifiedRepairConfig.java} (83%) rename src/java/org/apache/cassandra/tools/nodetool/{AutoRepairStatus.java => UnifiedRepairStatus.java} (82%) rename test/distributed/org/apache/cassandra/distributed/test/repair/{AutoRepairSchedulerTest.java => UnifiedRepairSchedulerTest.java} (83%) rename test/unit/org/apache/cassandra/repair/{autorepair => unifiedrepair}/SSTableRepairedAtTest.java (97%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairConfigTest.java => unifiedrepair/UnifiedRepairConfigTest.java} (77%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairDefaultTokenSplitterParameterizedTest.java => unifiedrepair/UnifiedRepairDefaultTokenSplitterParameterizedTest.java} (84%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairKeyspaceTest.java => unifiedrepair/UnifiedRepairKeyspaceTest.java} (87%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairParameterizedTest.java => unifiedrepair/UnifiedRepairParameterizedTest.java} (52%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairStateFactoryTest.java => unifiedrepair/UnifiedRepairStateFactoryTest.java} (76%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairStateTest.java => unifiedrepair/UnifiedRepairStateTest.java} (72%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairTest.java => unifiedrepair/UnifiedRepairTest.java} (79%) rename test/unit/org/apache/cassandra/repair/{autorepair/AutoRepairUtilsTest.java => unifiedrepair/UnifiedRepairUtilsTest.java} (70%) delete mode 100644 test/unit/org/apache/cassandra/service/AutoRepairServiceBasicTest.java create mode 100644 test/unit/org/apache/cassandra/service/UnifiedRepairServiceBasicTest.java rename test/unit/org/apache/cassandra/service/{AutoRepairServiceRepairTypeTest.java => UnifiedRepairServiceRepairTypeTest.java} (72%) rename test/unit/org/apache/cassandra/service/{AutoRepairServiceSetterTest.java => UnifiedRepairServiceSetterTest.java} (59%) rename test/unit/org/apache/cassandra/tools/nodetool/{SetAutoRepairConfigTest.java => SetUnifiedRepairConfigTest.java} (79%) rename test/unit/org/apache/cassandra/tools/nodetool/{AutoRepairStatusTest.java => UnifiedRepairStatusTest.java} (76%) diff --git a/doc/modules/cassandra/pages/managing/operating/metrics.adoc b/doc/modules/cassandra/pages/managing/operating/metrics.adoc index 2abeaefa6d39..8a5c286f37a6 100644 --- a/doc/modules/cassandra/pages/managing/operating/metrics.adoc +++ b/doc/modules/cassandra/pages/managing/operating/metrics.adoc @@ -1078,16 +1078,16 @@ partitions processed per logged batch partitions processed per unlogged batch |=== -== Automated Repair Metrics +== Unified Repair Metrics -Metrics specifc to automated repair. +Metrics specifc to unified repair. Reported name format: *Metric Name*:: -`org.apache.cassandra.metrics.AutoRepair.` +`org.apache.cassandra.metrics.UnifiedRepair.` *JMX MBean*:: -`org.apache.cassandra.metrics:type=AutoRepair name= repairType=` +`org.apache.cassandra.metrics:type=UnifiedRepair name= repairType=` [cols=",,",options="header",] |=== @@ -1118,15 +1118,15 @@ on the node views considered on the node |TotalDisabledRepairTables |Gauge |Number of tables on which -the automated repair has been disabled on the node +the unified repair has been disabled on the node |RepairTurnMyTurn |Counter |Represents the node's turn to repair |RepairTurnMyTurnDueToPriority |Counter |Represents the node's turn to repair -due to priority set in the automated repair +due to priority set in the unified repair |RepairTurnMyTurnForceRepair |Counter |Represents the node's turn to repair -due to force repair set in the automated repair +due to force repair set in the unified repair |=== diff --git a/src/java/org/apache/cassandra/config/Config.java b/src/java/org/apache/cassandra/config/Config.java index cbe1b64bcac9..25dc67a01c3f 100644 --- a/src/java/org/apache/cassandra/config/Config.java +++ b/src/java/org/apache/cassandra/config/Config.java @@ -33,7 +33,7 @@ import com.google.common.collect.ImmutableSet; import com.google.common.collect.Sets; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -957,7 +957,7 @@ public static void setClientMode(boolean clientMode) public volatile boolean password_validator_reconfiguration_enabled = true; public volatile CustomGuardrailConfig password_validator = new CustomGuardrailConfig(); - public volatile AutoRepairConfig auto_repair = new AutoRepairConfig(); + public volatile UnifiedRepairConfig unified_repair = new UnifiedRepairConfig(); /** * The variants of paxos implementation and semantics supported by Cassandra. diff --git a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java index af35ba246092..a35465c59751 100644 --- a/src/java/org/apache/cassandra/config/DatabaseDescriptor.java +++ b/src/java/org/apache/cassandra/config/DatabaseDescriptor.java @@ -107,7 +107,7 @@ import org.apache.cassandra.locator.InetAddressAndPort; import org.apache.cassandra.locator.Replica; import org.apache.cassandra.locator.SeedProvider; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.security.AbstractCryptoProvider; import org.apache.cassandra.security.EncryptionContext; import org.apache.cassandra.security.JREProvider; @@ -5361,9 +5361,9 @@ public static boolean isPasswordValidatorReconfigurationEnabled() return conf.password_validator_reconfiguration_enabled; } - public static AutoRepairConfig getAutoRepairConfig() + public static UnifiedRepairConfig getUnifiedRepairConfig() { - return conf.auto_repair; + return conf.unified_repair; } public static double getIncrementalRepairDiskHeadroomRejectRatio() diff --git a/src/java/org/apache/cassandra/cql3/statements/schema/TableAttributes.java b/src/java/org/apache/cassandra/cql3/statements/schema/TableAttributes.java index f47b7e4ba722..3b173a6514e4 100644 --- a/src/java/org/apache/cassandra/cql3/statements/schema/TableAttributes.java +++ b/src/java/org/apache/cassandra/cql3/statements/schema/TableAttributes.java @@ -25,8 +25,8 @@ import org.apache.cassandra.cql3.statements.PropertyDefinitions; import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.schema.AutoRepairParams; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.schema.UnifiedRepairParams; import org.apache.cassandra.schema.CachingParams; import org.apache.cassandra.schema.CompactionParams; import org.apache.cassandra.schema.CompressionParams; @@ -154,10 +154,10 @@ private TableParams build(TableParams.Builder builder) builder.readRepair(ReadRepairStrategy.fromString(getString(READ_REPAIR))); if (hasOption(Option.REPAIR_FULL)) - builder.automatedRepairFull(AutoRepairParams.fromMap(AutoRepairConfig.RepairType.full, getMap(Option.REPAIR_FULL))); + builder.unifiedRepairFull(UnifiedRepairParams.fromMap(UnifiedRepairConfig.RepairType.full, getMap(Option.REPAIR_FULL))); if (hasOption(Option.REPAIR_INCREMENTAL)) - builder.automatedRepairIncremental(AutoRepairParams.fromMap(AutoRepairConfig.RepairType.incremental, getMap(Option.REPAIR_INCREMENTAL))); + builder.unifiedRepairIncremental(UnifiedRepairParams.fromMap(UnifiedRepairConfig.RepairType.incremental, getMap(Option.REPAIR_INCREMENTAL))); return builder.build(); } diff --git a/src/java/org/apache/cassandra/metrics/CassandraMetricsRegistry.java b/src/java/org/apache/cassandra/metrics/CassandraMetricsRegistry.java index 919d3163e317..f9d96585715d 100644 --- a/src/java/org/apache/cassandra/metrics/CassandraMetricsRegistry.java +++ b/src/java/org/apache/cassandra/metrics/CassandraMetricsRegistry.java @@ -150,7 +150,7 @@ public class CassandraMetricsRegistry extends MetricRegistry .add(ThreadPoolMetrics.TYPE_NAME) .add(TrieMemtableMetricsView.TYPE_NAME) .add(UnweightedCacheMetrics.TYPE_NAME) - .add(AutoRepairMetrics.TYPE_NAME) + .add(UnifiedRepairMetrics.TYPE_NAME) .build(); } diff --git a/src/java/org/apache/cassandra/metrics/AutoRepairMetrics.java b/src/java/org/apache/cassandra/metrics/UnifiedRepairMetrics.java similarity index 76% rename from src/java/org/apache/cassandra/metrics/AutoRepairMetrics.java rename to src/java/org/apache/cassandra/metrics/UnifiedRepairMetrics.java index b097dd3414c4..d4929cbfefb0 100644 --- a/src/java/org/apache/cassandra/metrics/AutoRepairMetrics.java +++ b/src/java/org/apache/cassandra/metrics/UnifiedRepairMetrics.java @@ -20,19 +20,19 @@ import com.codahale.metrics.Counter; import com.codahale.metrics.Gauge; import com.google.common.annotations.VisibleForTesting; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; -import org.apache.cassandra.repair.autorepair.AutoRepair; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepair; import static org.apache.cassandra.metrics.CassandraMetricsRegistry.Metrics; import static org.apache.cassandra.utils.LocalizeString.toLowerCaseLocalized; /** - * Metrics related to AutoRepair. + * Metrics related to UnifiedRepair. */ -public class AutoRepairMetrics +public class UnifiedRepairMetrics { - public static final String TYPE_NAME = "autorepair"; + public static final String TYPE_NAME = "unifiedrepair"; public Gauge repairsInProgress; public Gauge nodeRepairTimeInSec; public Gauge clusterRepairTimeInSec; @@ -47,15 +47,15 @@ public class AutoRepairMetrics public Gauge totalMVTablesConsideredForRepair; public Gauge totalDisabledRepairTables; - public AutoRepairMetrics(RepairType repairType) + public UnifiedRepairMetrics(RepairType repairType) { - AutoRepairMetricsFactory factory = new AutoRepairMetricsFactory(repairType); + UnifiedRepairMetricsFactory factory = new UnifiedRepairMetricsFactory(repairType); repairsInProgress = Metrics.register(factory.createMetricName("RepairsInProgress"), new Gauge() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).isRepairInProgress() ? 1 : 0; + return UnifiedRepair.instance.getRepairState(repairType).isRepairInProgress() ? 1 : 0; } }); @@ -63,7 +63,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getNodeRepairTimeInSec(); + return UnifiedRepair.instance.getRepairState(repairType).getNodeRepairTimeInSec(); } }); @@ -71,7 +71,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getClusterRepairTimeInSec(); + return UnifiedRepair.instance.getRepairState(repairType).getClusterRepairTimeInSec(); } }); @@ -79,7 +79,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getSkippedTokenRangesCount(); + return UnifiedRepair.instance.getRepairState(repairType).getSkippedTokenRangesCount(); } }); @@ -87,7 +87,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getSkippedTablesCount(); + return UnifiedRepair.instance.getRepairState(repairType).getSkippedTablesCount(); } }); @@ -96,7 +96,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getLongestUnrepairedSec(); + return UnifiedRepair.instance.getRepairState(repairType).getLongestUnrepairedSec(); } }); @@ -104,7 +104,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getSucceededTokenRangesCount(); + return UnifiedRepair.instance.getRepairState(repairType).getSucceededTokenRangesCount(); } }); @@ -112,7 +112,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getFailedTokenRangesCount(); + return UnifiedRepair.instance.getRepairState(repairType).getFailedTokenRangesCount(); } }); @@ -124,7 +124,7 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getTotalMVTablesConsideredForRepair(); + return UnifiedRepair.instance.getRepairState(repairType).getTotalMVTablesConsideredForRepair(); } }); @@ -132,12 +132,12 @@ public Integer getValue() { public Integer getValue() { - return AutoRepair.instance.getRepairState(repairType).getTotalDisabledTablesRepairCount(); + return UnifiedRepair.instance.getRepairState(repairType).getTotalDisabledTablesRepairCount(); } }); } - public void recordTurn(AutoRepairUtils.RepairTurn turn) + public void recordTurn(UnifiedRepairUtils.RepairTurn turn) { switch (turn) { @@ -156,13 +156,13 @@ public void recordTurn(AutoRepairUtils.RepairTurn turn) } @VisibleForTesting - protected static class AutoRepairMetricsFactory implements MetricNameFactory + protected static class UnifiedRepairMetricsFactory implements MetricNameFactory { - private static final String TYPE = "AutoRepair"; + private static final String TYPE = "UnifiedRepair"; @VisibleForTesting protected final String repairType; - protected AutoRepairMetricsFactory(RepairType repairType) + protected UnifiedRepairMetricsFactory(RepairType repairType) { this.repairType = toLowerCaseLocalized(repairType.toString()); } diff --git a/src/java/org/apache/cassandra/metrics/AutoRepairMetricsManager.java b/src/java/org/apache/cassandra/metrics/UnifiedRepairMetricsManager.java similarity index 70% rename from src/java/org/apache/cassandra/metrics/AutoRepairMetricsManager.java rename to src/java/org/apache/cassandra/metrics/UnifiedRepairMetricsManager.java index e293945c9846..e8057595944d 100644 --- a/src/java/org/apache/cassandra/metrics/AutoRepairMetricsManager.java +++ b/src/java/org/apache/cassandra/metrics/UnifiedRepairMetricsManager.java @@ -18,17 +18,17 @@ package org.apache.cassandra.metrics; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; -public class AutoRepairMetricsManager +public class UnifiedRepairMetricsManager { - private static final Map metrics = new ConcurrentHashMap<>(); + private static final Map metrics = new ConcurrentHashMap<>(); - public static AutoRepairMetrics getMetrics(RepairType repairType) + public static UnifiedRepairMetrics getMetrics(RepairType repairType) { - return metrics.computeIfAbsent(repairType, k -> new AutoRepairMetrics(repairType)); + return metrics.computeIfAbsent(repairType, k -> new UnifiedRepairMetrics(repairType)); } } diff --git a/src/java/org/apache/cassandra/repair/autorepair/DefaultAutoRepairTokenSplitter.java b/src/java/org/apache/cassandra/repair/unifiedrepair/DefaultUnifiedRepairTokenSplitter.java similarity index 82% rename from src/java/org/apache/cassandra/repair/autorepair/DefaultAutoRepairTokenSplitter.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/DefaultUnifiedRepairTokenSplitter.java index 9a884f61c581..98dc09f8ad7d 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/DefaultAutoRepairTokenSplitter.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/DefaultUnifiedRepairTokenSplitter.java @@ -15,7 +15,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.ArrayList; @@ -23,20 +23,20 @@ import java.util.Collections; import java.util.List; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.dht.Range; import org.apache.cassandra.dht.Token; import org.apache.cassandra.service.StorageService; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.splitEvenly; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.splitEvenly; -public class DefaultAutoRepairTokenSplitter implements IAutoRepairTokenRangeSplitter +public class DefaultUnifiedRepairTokenSplitter implements IUnifiedRepairTokenRangeSplitter { @Override - public List getRepairAssignments(AutoRepairConfig.RepairType repairType, boolean primaryRangeOnly, String keyspaceName, List tableNames) + public List getRepairAssignments(UnifiedRepairConfig.RepairType repairType, boolean primaryRangeOnly, String keyspaceName, List tableNames) { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); List repairAssignments = new ArrayList<>(); Collection> tokens = StorageService.instance.getPrimaryRanges(keyspaceName); diff --git a/src/java/org/apache/cassandra/repair/autorepair/IAutoRepairTokenRangeSplitter.java b/src/java/org/apache/cassandra/repair/unifiedrepair/IUnifiedRepairTokenRangeSplitter.java similarity index 87% rename from src/java/org/apache/cassandra/repair/autorepair/IAutoRepairTokenRangeSplitter.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/IUnifiedRepairTokenRangeSplitter.java index 169600eca405..251e6b96ec56 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/IAutoRepairTokenRangeSplitter.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/IUnifiedRepairTokenRangeSplitter.java @@ -15,7 +15,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.List; @@ -24,22 +24,22 @@ import org.apache.cassandra.dht.Range; import org.apache.cassandra.dht.Token; -public interface IAutoRepairTokenRangeSplitter +public interface IUnifiedRepairTokenRangeSplitter { /** * Split the token range you wish to repair into multiple assignments. - * The autorepair framework will repair the list of returned subrange in a sequence. + * The unifiedrepair framework will repair the list of returned subrange in a sequence. * @param repairType The type of repair being executed * @param primaryRangeOnly Whether to repair only this node's primary ranges or all of its ranges. * @param keyspaceName The keyspace being repaired * @param tableNames The tables to repair * @return repair assignments broken up by range, keyspace and tables. */ - List getRepairAssignments(AutoRepairConfig.RepairType repairType, boolean primaryRangeOnly, String keyspaceName, List tableNames); + List getRepairAssignments(UnifiedRepairConfig.RepairType repairType, boolean primaryRangeOnly, String keyspaceName, List tableNames); /** - * Defines a repair assignment to be issued by the autorepair framework. + * Defines a repair assignment to be issued by the unifiedrepair framework. */ class RepairAssignment { diff --git a/src/java/org/apache/cassandra/repair/autorepair/AutoRepair.java b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepair.java similarity index 78% rename from src/java/org/apache/cassandra/repair/autorepair/AutoRepair.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepair.java index 1abb71d69cac..02db8951fa64 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/AutoRepair.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepair.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.ArrayList; import java.util.EnumMap; @@ -40,7 +40,7 @@ import org.apache.cassandra.config.DurationSpec; import org.apache.cassandra.exceptions.ConfigurationException; import org.apache.cassandra.utils.Clock; -import org.apache.cassandra.repair.autorepair.IAutoRepairTokenRangeSplitter.RepairAssignment; +import org.apache.cassandra.repair.unifiedrepair.IUnifiedRepairTokenRangeSplitter.RepairAssignment; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -53,35 +53,35 @@ import org.apache.cassandra.dht.Token; import org.apache.cassandra.schema.TableMetadata; import org.apache.cassandra.schema.Tables; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.utils.FBUtilities; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn; import org.apache.cassandra.utils.concurrent.Future; import static org.apache.cassandra.concurrent.ExecutorFactory.Global.executorFactory; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN_DUE_TO_PRIORITY; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN_FORCE_REPAIR; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN_DUE_TO_PRIORITY; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN_FORCE_REPAIR; -public class AutoRepair +public class UnifiedRepair { - private static final Logger logger = LoggerFactory.getLogger(AutoRepair.class); + private static final Logger logger = LoggerFactory.getLogger(UnifiedRepair.class); @VisibleForTesting protected static Supplier timeFunc = Clock.Global::currentTimeMillis; - public static AutoRepair instance = new AutoRepair(); + public static UnifiedRepair instance = new UnifiedRepair(); // Sleep for 5 seconds if repair finishes quickly to flush JMX metrics; it happens only for Cassandra nodes with tiny amount of data. public static DurationSpec.IntSecondsBound SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("5s"); @VisibleForTesting - protected final Map repairExecutors; + protected final Map repairExecutors; - protected final Map repairRunnableExecutors; + protected final Map repairRunnableExecutors; @VisibleForTesting - protected final Map repairStates; + protected final Map repairStates; @VisibleForTesting protected static Consumer> shuffleFunc = java.util.Collections::shuffle; @@ -89,23 +89,23 @@ public class AutoRepair @VisibleForTesting protected static BiConsumer sleepFunc = Uninterruptibles::sleepUninterruptibly; - protected final Map tokenRangeSplitters = new EnumMap<>(AutoRepairConfig.RepairType.class); + protected final Map tokenRangeSplitters = new EnumMap<>(UnifiedRepairConfig.RepairType.class); private boolean isSetupDone = false; @VisibleForTesting - protected AutoRepair() + protected UnifiedRepair() { - AutoRepairConfig config = DatabaseDescriptor.getAutoRepairConfig(); - repairExecutors = new EnumMap<>(AutoRepairConfig.RepairType.class); - repairRunnableExecutors = new EnumMap<>(AutoRepairConfig.RepairType.class); - repairStates = new EnumMap<>(AutoRepairConfig.RepairType.class); - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) + UnifiedRepairConfig config = DatabaseDescriptor.getUnifiedRepairConfig(); + repairExecutors = new EnumMap<>(UnifiedRepairConfig.RepairType.class); + repairRunnableExecutors = new EnumMap<>(UnifiedRepairConfig.RepairType.class); + repairStates = new EnumMap<>(UnifiedRepairConfig.RepairType.class); + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { - repairExecutors.put(repairType, executorFactory().scheduled(false, "AutoRepair-Repair-" + repairType, Thread.NORM_PRIORITY)); - repairRunnableExecutors.put(repairType, executorFactory().scheduled(false, "AutoRepair-RepairRunnable-" + repairType, Thread.NORM_PRIORITY)); - repairStates.put(repairType, AutoRepairConfig.RepairType.getAutoRepairState(repairType)); - tokenRangeSplitters.put(repairType, FBUtilities.newAutoRepairTokenRangeSplitter(config.getTokenRangeSplitter(repairType))); + repairExecutors.put(repairType, executorFactory().scheduled(false, "UnifiedRepair-Repair-" + repairType, Thread.NORM_PRIORITY)); + repairRunnableExecutors.put(repairType, executorFactory().scheduled(false, "UnifiedRepair-RepairRunnable-" + repairType, Thread.NORM_PRIORITY)); + repairStates.put(repairType, UnifiedRepairConfig.RepairType.getUnifiedRepairState(repairType)); + tokenRangeSplitters.put(repairType, FBUtilities.newUnifiedRepairTokenRangeSplitter(config.getTokenRangeSplitter(repairType))); } } @@ -119,13 +119,13 @@ public void setup() { return; } - AutoRepairConfig config = DatabaseDescriptor.getAutoRepairConfig(); - AutoRepairUtils.setup(); + UnifiedRepairConfig config = DatabaseDescriptor.getUnifiedRepairConfig(); + UnifiedRepairUtils.setup(); - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { - if (config.isAutoRepairEnabled(repairType)) - AutoRepairService.instance.checkCanRun(repairType); + if (config.isUnifiedRepairEnabled(repairType)) + UnifiedRepairService.instance.checkCanRun(repairType); repairExecutors.get(repairType).scheduleWithFixedDelay( () -> repair(repairType), @@ -138,26 +138,26 @@ public void setup() } // repairAsync runs a repair session of the given type asynchronously. - public void repairAsync(AutoRepairConfig.RepairType repairType) + public void repairAsync(UnifiedRepairConfig.RepairType repairType) { - if (!AutoRepairService.instance.getAutoRepairConfig().isAutoRepairEnabled(repairType)) + if (!UnifiedRepairService.instance.getUnifiedRepairConfig().isUnifiedRepairEnabled(repairType)) { - throw new ConfigurationException("Auto-repair is disabled for repair type " + repairType); + throw new ConfigurationException("Unified-repair is disabled for repair type " + repairType); } repairExecutors.get(repairType).submit(() -> repair(repairType)); } // repair runs a repair session of the given type synchronously. - public void repair(AutoRepairConfig.RepairType repairType) + public void repair(UnifiedRepairConfig.RepairType repairType) { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); - if (!config.isAutoRepairEnabled(repairType)) + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); + if (!config.isUnifiedRepairEnabled(repairType)) { - logger.debug("Auto-repair is disabled for repair type {}", repairType); + logger.debug("Unified-repair is disabled for repair type {}", repairType); return; } - AutoRepairService.instance.checkCanRun(repairType); - AutoRepairState repairState = repairStates.get(repairType); + UnifiedRepairService.instance.checkCanRun(repairType); + UnifiedRepairState repairState = repairStates.get(repairType); try { String localDC = DatabaseDescriptor.getLocalDataCenter(); @@ -168,16 +168,16 @@ public void repair(AutoRepairConfig.RepairType repairType) } // refresh the longest unrepaired node - repairState.setLongestUnrepairedNode(AutoRepairUtils.getHostWithLongestUnrepairTime(repairType)); + repairState.setLongestUnrepairedNode(UnifiedRepairUtils.getHostWithLongestUnrepairTime(repairType)); //consistency level to use for local query UUID myId = StorageService.instance.getHostIdForEndpoint(FBUtilities.getBroadcastAddressAndPort()); - RepairTurn turn = AutoRepairUtils.myTurnToRunRepair(repairType, myId); + RepairTurn turn = UnifiedRepairUtils.myTurnToRunRepair(repairType, myId); if (turn == MY_TURN || turn == MY_TURN_DUE_TO_PRIORITY || turn == MY_TURN_FORCE_REPAIR) { repairState.recordTurn(turn); - // For normal auto repair, we will use primary range only repairs (Repair with -pr option). - // For some cases, we may set the auto_repair_primary_token_range_only flag to false then we will do repair + // For normal unified repair, we will use primary range only repairs (Repair with -pr option). + // For some cases, we may set the unified_repair_primary_token_range_only flag to false then we will do repair // without -pr. We may also do force repair for certain node that we want to repair all the data on one node // When doing force repair, we want to repair without -pr. boolean primaryRangeOnly = config.getRepairPrimaryTokenRangeOnly(repairType) @@ -190,7 +190,7 @@ public void repair(AutoRepairConfig.RepairType repairType) long startTime = timeFunc.get(); logger.info("My host id: {}, my turn to run repair...repair primary-ranges only? {}", myId, config.getRepairPrimaryTokenRangeOnly(repairType)); - AutoRepairUtils.updateStartAutoRepairHistory(repairType, myId, timeFunc.get(), turn); + UnifiedRepairUtils.updateStartUnifiedRepairHistory(repairType, myId, timeFunc.get(), turn); repairState.setRepairKeyspaceCount(0); repairState.setRepairInProgress(true); @@ -201,13 +201,13 @@ public void repair(AutoRepairConfig.RepairType repairType) List keyspaces = new ArrayList<>(); Keyspace.all().forEach(keyspaces::add); - // Auto-repair is likely to be run on multiple nodes independently, we want to avoid running multiple repair + // Unified-repair is likely to be run on multiple nodes independently, we want to avoid running multiple repair // sessions on overlapping datasets at the same time. Shuffling keyspaces reduces the likelihood of this happening. shuffleFunc.accept(keyspaces); for (Keyspace keyspace : keyspaces) { - if (!AutoRepairUtils.checkNodeContainsKeyspaceReplica(keyspace)) + if (!UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(keyspace)) { continue; } @@ -237,20 +237,20 @@ public void repair(AutoRepairConfig.RepairType repairType) tableStartTime = timeFunc.get(); } previousAssignment = curRepairAssignment; - if (!config.isAutoRepairEnabled(repairType)) + if (!config.isUnifiedRepairEnabled(repairType)) { - logger.error("Auto-repair for type {} is disabled hence not running repair", repairType); + logger.error("Unified-repair for type {} is disabled hence not running repair", repairType); repairState.setRepairInProgress(false); return; } - if (AutoRepairUtils.keyspaceMaxRepairTimeExceeded(repairType, keyspaceStartTime, tablesToBeRepairedList.size())) + if (UnifiedRepairUtils.keyspaceMaxRepairTimeExceeded(repairType, keyspaceStartTime, tablesToBeRepairedList.size())) { collectectedRepairStats.skippedTokenRanges += totalRepairAssignments - totalProcessedAssignments; logger.info("Keyspace took too much time to repair hence skipping it {}", keyspaceName); break; } - if (repairOneTableAtATime && AutoRepairUtils.tableMaxRepairTimeExceeded(repairType, tableStartTime)) + if (repairOneTableAtATime && UnifiedRepairUtils.tableMaxRepairTimeExceeded(repairType, tableStartTime)) { collectectedRepairStats.skippedTokenRanges += 1; logger.info("Table took too much time to repair hence skipping it table name {}.{}, token range {}", @@ -339,17 +339,17 @@ else if (retryCount < config.getRepairMaxRetries()) } catch (Exception e) { - logger.error("Exception in autorepair:", e); + logger.error("Exception in unifiedrepair:", e); } } - private boolean tooSoonToRunRepair(AutoRepairConfig.RepairType repairType, AutoRepairState repairState, AutoRepairConfig config, UUID myId) + private boolean tooSoonToRunRepair(UnifiedRepairConfig.RepairType repairType, UnifiedRepairState repairState, UnifiedRepairConfig config, UUID myId) { if (repairState.getLastRepairTime() == 0) { // the node has either just boooted or has not run repair before, // we should check for the node's repair history in the DB - repairState.setLastRepairTime(AutoRepairUtils.getLastRepairTimeForNode(repairType, myId)); + repairState.setLastRepairTime(UnifiedRepairUtils.getLastRepairTimeForNode(repairType, myId)); } /** check if it is too soon to run repair. one of the reason we * should not run frequent repair is that repair triggers @@ -365,7 +365,7 @@ private boolean tooSoonToRunRepair(AutoRepairConfig.RepairType repairType, AutoR return false; } - private List retrieveTablesToBeRepaired(Keyspace keyspace, AutoRepairConfig config, AutoRepairConfig.RepairType repairType, AutoRepairState repairState, CollectectedRepairStats collectectedRepairStats) + private List retrieveTablesToBeRepaired(Keyspace keyspace, UnifiedRepairConfig config, UnifiedRepairConfig.RepairType repairType, UnifiedRepairState repairState, CollectectedRepairStats collectectedRepairStats) { Tables tables = keyspace.getMetadata().tables; List tablesToBeRepaired = new ArrayList<>(); @@ -377,7 +377,7 @@ private List retrieveTablesToBeRepaired(Keyspace keyspace, AutoRepairCon String tableName = tableMetadata.name; ColumnFamilyStore columnFamilyStore = keyspace.getColumnFamilyStore(tableName); - if (!columnFamilyStore.metadata().params.automatedRepair.get(repairType).repairEnabled()) + if (!columnFamilyStore.metadata().params.unifiedRepair.get(repairType).repairEnabled()) { logger.info("Repair is disabled for keyspace {} for tables: {}", keyspace.getName(), tableName); repairState.setTotalDisabledTablesRepairCount(repairState.getTotalDisabledTablesRepairCount() + 1); @@ -385,7 +385,7 @@ private List retrieveTablesToBeRepaired(Keyspace keyspace, AutoRepairCon continue; } - // this is done to make autorepair safe as running repair on table with more sstables + // this is done to make unifiedrepair safe as running repair on table with more sstables // may have its own challenges int totalSSTables = columnFamilyStore.getLiveSSTables().size(); if (totalSSTables > config.getRepairSSTableCountHigherThreshold(repairType)) @@ -399,7 +399,7 @@ private List retrieveTablesToBeRepaired(Keyspace keyspace, AutoRepairCon tablesToBeRepaired.add(tableName); // See if we should repair MVs as well that are associated with this given table - List mvs = AutoRepairUtils.getAllMVs(repairType, keyspace, tableMetadata); + List mvs = UnifiedRepairUtils.getAllMVs(repairType, keyspace, tableMetadata); if (!mvs.isEmpty()) { tablesToBeRepaired.addAll(mvs); @@ -409,14 +409,14 @@ private List retrieveTablesToBeRepaired(Keyspace keyspace, AutoRepairCon return tablesToBeRepaired; } - private void cleanupAndUpdateStats(RepairTurn turn, AutoRepairConfig.RepairType repairType, AutoRepairState repairState, UUID myId, + private void cleanupAndUpdateStats(RepairTurn turn, UnifiedRepairConfig.RepairType repairType, UnifiedRepairState repairState, UUID myId, long startTime, CollectectedRepairStats collectectedRepairStats) throws InterruptedException { //if it was due to priority then remove it now if (turn == MY_TURN_DUE_TO_PRIORITY) { logger.info("Remove current host from priority list"); - AutoRepairUtils.removePriorityStatus(repairType, myId); + UnifiedRepairUtils.removePriorityStatus(repairType, myId); } repairState.setFailedTokenRangesCount(collectectedRepairStats.failedTokenRanges); @@ -446,10 +446,10 @@ private void cleanupAndUpdateStats(RepairTurn turn, AutoRepairConfig.RepairType Thread.sleep(SLEEP_IF_REPAIR_FINISHES_QUICKLY.toMilliseconds()); } repairState.setRepairInProgress(false); - AutoRepairUtils.updateFinishAutoRepairHistory(repairType, myId, timeFunc.get()); + UnifiedRepairUtils.updateFinishUnifiedRepairHistory(repairType, myId, timeFunc.get()); } - public AutoRepairState getRepairState(AutoRepairConfig.RepairType repairType) + public UnifiedRepairState getRepairState(UnifiedRepairConfig.RepairType repairType) { return repairStates.get(repairType); } diff --git a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairConfig.java b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfig.java similarity index 91% rename from src/java/org/apache/cassandra/repair/autorepair/AutoRepairConfig.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfig.java index a80a875125a9..33f37b8f57ee 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairConfig.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfig.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.io.Serializable; import java.util.ArrayList; @@ -34,9 +34,9 @@ import org.apache.cassandra.config.DurationSpec; import org.apache.cassandra.config.ParameterizedClass; -public class AutoRepairConfig implements Serializable +public class UnifiedRepairConfig implements Serializable { - // enable/disable auto repair globally, overrides all other settings. Cannot be modified dynamically. + // enable/disable unified repair globally, overrides all other settings. Cannot be modified dynamically. // if it is set to false, then no repair will be scheduled, including full and incremental repairs by this framework. // if it is set to true, then this repair scheduler will consult another config available for each RepairType, and based on that config, it will schedule repairs. public volatile Boolean enabled; @@ -61,7 +61,7 @@ public enum RepairType implements Serializable full, incremental; - public static AutoRepairState getAutoRepairState(RepairType repairType) + public static UnifiedRepairState getUnifiedRepairState(RepairType repairType) { switch (repairType) { @@ -78,12 +78,12 @@ public static AutoRepairState getAutoRepairState(RepairType repairType) // repair_type_overrides overrides the global_settings for a specific repair type public volatile Map repair_type_overrides = new EnumMap<>(RepairType.class); - public AutoRepairConfig() + public UnifiedRepairConfig() { this(false); } - public AutoRepairConfig(boolean enabled) + public UnifiedRepairConfig(boolean enabled) { this.enabled = enabled; global_settings = Options.getDefaultOptions(); @@ -98,12 +98,12 @@ public DurationSpec.IntSecondsBound getRepairCheckInterval() return repair_check_interval; } - public boolean isAutoRepairSchedulingEnabled() + public boolean isUnifiedRepairSchedulingEnabled() { return enabled; } - public DurationSpec.IntSecondsBound getAutoRepairHistoryClearDeleteHostsBufferInterval() + public DurationSpec.IntSecondsBound getUnifiedRepairHistoryClearDeleteHostsBufferInterval() { return history_clear_delete_hosts_buffer_interval; } @@ -111,10 +111,10 @@ public DurationSpec.IntSecondsBound getAutoRepairHistoryClearDeleteHostsBufferIn public void startScheduler() { enabled = true; - AutoRepair.instance.setup(); + UnifiedRepair.instance.setup(); } - public void setAutoRepairHistoryClearDeleteHostsBufferInterval(String duration) + public void setUnifiedRepairHistoryClearDeleteHostsBufferInterval(String duration) { history_clear_delete_hosts_buffer_interval = new DurationSpec.IntSecondsBound(duration); } @@ -139,12 +139,12 @@ public void setRepairRetryBackoff(String interval) repair_retry_backoff = new DurationSpec.LongSecondsBound(interval); } - public boolean isAutoRepairEnabled(RepairType repairType) + public boolean isUnifiedRepairEnabled(RepairType repairType) { return enabled && applyOverrides(repairType, opt -> opt.enabled); } - public void setAutoRepairEnabled(RepairType repairType, boolean enabled) + public void setUnifiedRepairEnabled(RepairType repairType, boolean enabled) { ensureOverrides(repairType); repair_type_overrides.get(repairType).enabled = enabled; @@ -205,15 +205,15 @@ public void setRepairSSTableCountHigherThreshold(RepairType repairType, int ssta repair_type_overrides.get(repairType).sstable_upper_threshold = sstableHigherThreshold; } - public DurationSpec.IntSecondsBound getAutoRepairTableMaxRepairTime(RepairType repairType) + public DurationSpec.IntSecondsBound getUnifiedRepairTableMaxRepairTime(RepairType repairType) { return applyOverrides(repairType, opt -> opt.table_max_repair_time); } - public void setAutoRepairTableMaxRepairTime(RepairType repairType, String autoRepairTableMaxRepairTime) + public void setUnifiedRepairTableMaxRepairTime(RepairType repairType, String unifiedRepairTableMaxRepairTime) { ensureOverrides(repairType); - repair_type_overrides.get(repairType).table_max_repair_time = new DurationSpec.IntSecondsBound(autoRepairTableMaxRepairTime); + repair_type_overrides.get(repairType).table_max_repair_time = new DurationSpec.IntSecondsBound(unifiedRepairTableMaxRepairTime); } public Set getIgnoreDCs(RepairType repairType) @@ -309,11 +309,11 @@ public void setRepairSessionTimeout(RepairType repairType, String repairSessionT repair_type_overrides.get(repairType).repair_session_timeout = new DurationSpec.IntSecondsBound(repairSessionTimeout); } - // Options configures auto-repair behavior for a given repair type. + // Options configures unified-repair behavior for a given repair type. // All fields can be modified dynamically. public static class Options implements Serializable { - // defaultOptions defines the default auto-repair behavior when no overrides are defined + // defaultOptions defines the default unified-repair behavior when no overrides are defined @VisibleForTesting protected static final Options defaultOptions = getDefaultOptions(); @@ -339,16 +339,16 @@ protected static Options getDefaultOptions() opts.force_repair_new_node = false; opts.table_max_repair_time = new DurationSpec.IntSecondsBound("6h"); opts.mv_repair_enabled = false; - opts.token_range_splitter = new ParameterizedClass(DefaultAutoRepairTokenSplitter.class.getName(), Collections.emptyMap()); + opts.token_range_splitter = new ParameterizedClass(DefaultUnifiedRepairTokenSplitter.class.getName(), Collections.emptyMap()); opts.initial_scheduler_delay = new DurationSpec.IntSecondsBound("5m"); // 5 minutes opts.repair_session_timeout = new DurationSpec.IntSecondsBound("3h"); // 3 hours return opts; } - // enable/disable auto repair for the given repair type + // enable/disable unified repair for the given repair type public volatile Boolean enabled; - // auto repair is default repair table by table, if this is enabled, the framework will repair all the tables in a keyspace in one go. + // unified repair is default repair table by table, if this is enabled, the framework will repair all the tables in a keyspace in one go. public volatile Boolean repair_by_keyspace; // the number of subranges to split each to-be-repaired token range into, // the higher this number, the smaller the repair sessions will be @@ -387,7 +387,7 @@ protected static Options getDefaultOptions() // specifies a denylist of datacenters to repair // This is useful if you want to completely avoid running repairs in one or more data centers. By default, it is empty, i.e., the framework will repair nodes in all the datacenters. public volatile Set ignore_dcs; - // Set this 'true' if AutoRepair should repair only the primary ranges owned by this node; else, 'false' + // Set this 'true' if UnifiedRepair should repair only the primary ranges owned by this node; else, 'false' // It is the same as -pr in nodetool repair options. public volatile Boolean repair_primary_token_range_only; // configures whether to force immediate repair on new nodes @@ -401,9 +401,9 @@ protected static Options getDefaultOptions() // So, the idea here is to penalize the outliers instead of good candidates. This can easily be configured with a higher value if we want to disable the functionality. public volatile DurationSpec.IntSecondsBound table_max_repair_time; // the default is 'true'. - // This flag determines whether the auto-repair framework needs to run anti-entropy, a.k.a, repair on the MV table or not. + // This flag determines whether the unified-repair framework needs to run anti-entropy, a.k.a, repair on the MV table or not. public volatile Boolean mv_repair_enabled; - // the default is DefaultAutoRepairTokenSplitter. The class should implement IAutoRepairTokenRangeSplitter. + // the default is DefaultUnifiedRepairTokenSplitter. The class should implement IUnifiedRepairTokenRangeSplitter. // The default implementation splits the tokens based on the token ranges owned by this node divided by the number of 'number_of_subranges' public volatile ParameterizedClass token_range_splitter; // the minimum delay after a node starts before the scheduler starts running repair diff --git a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairState.java b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairState.java similarity index 88% rename from src/java/org/apache/cassandra/repair/autorepair/AutoRepairState.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairState.java index 84701ca78fbc..035906289592 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairState.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairState.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import com.google.common.annotations.VisibleForTesting; @@ -26,14 +26,14 @@ import org.apache.cassandra.db.view.TableViews; import org.apache.cassandra.dht.Range; import org.apache.cassandra.dht.Token; -import org.apache.cassandra.metrics.AutoRepairMetricsManager; -import org.apache.cassandra.metrics.AutoRepairMetrics; +import org.apache.cassandra.metrics.UnifiedRepairMetricsManager; +import org.apache.cassandra.metrics.UnifiedRepairMetrics; import org.apache.cassandra.repair.RepairCoordinator; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils.AutoRepairHistory; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.UnifiedRepairHistory; import org.apache.cassandra.repair.RepairParallelism; import org.apache.cassandra.repair.messages.RepairOption; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.streaming.PreviewKind; import org.apache.cassandra.utils.Clock; @@ -55,10 +55,10 @@ import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; import static org.apache.cassandra.utils.concurrent.Condition.newOneTimeCondition; -// AutoRepairState represents the state of automated repair for a given repair type. -public abstract class AutoRepairState implements ProgressListener +// UnifiedRepairState represents the state of unified repair for a given repair type. +public abstract class UnifiedRepairState implements ProgressListener { - protected static final Logger logger = LoggerFactory.getLogger(AutoRepairState.class); + protected static final Logger logger = LoggerFactory.getLogger(UnifiedRepairState.class); private final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS"); @VisibleForTesting protected static Supplier timeFunc = Clock.Global::currentTimeMillis; @@ -93,16 +93,16 @@ public abstract class AutoRepairState implements ProgressListener protected int skippedTablesCount = 0; @VisibleForTesting - protected AutoRepairHistory longestUnrepairedNode; + protected UnifiedRepairHistory longestUnrepairedNode; @VisibleForTesting protected Condition condition = newOneTimeCondition(); @VisibleForTesting protected boolean success = true; - protected final AutoRepairMetrics metrics; + protected final UnifiedRepairMetrics metrics; - protected AutoRepairState(RepairType repairType) + protected UnifiedRepairState(RepairType repairType) { - metrics = AutoRepairMetricsManager.getMetrics(repairType); + metrics = UnifiedRepairMetricsManager.getMetrics(repairType); this.repairType = repairType; } @@ -229,7 +229,7 @@ public int getRepairKeyspaceCount() return repairKeyspaceCount; } - public void setLongestUnrepairedNode(AutoRepairHistory longestUnrepairedNode) + public void setLongestUnrepairedNode(UnifiedRepairHistory longestUnrepairedNode) { this.longestUnrepairedNode = longestUnrepairedNode; } @@ -279,7 +279,7 @@ public boolean isSuccess() return success; } - public void recordTurn(AutoRepairUtils.RepairTurn turn) + public void recordTurn(UnifiedRepairUtils.RepairTurn turn) { metrics.recordTurn(turn); } @@ -300,7 +300,7 @@ public void resetWaitCondition() } } -class IncrementalRepairState extends AutoRepairState +class IncrementalRepairState extends UnifiedRepairState { public IncrementalRepairState() { @@ -311,7 +311,7 @@ public IncrementalRepairState() public RepairCoordinator getRepairRunnable(String keyspace, List tables, Set> ranges, boolean primaryRangeOnly) { RepairOption option = new RepairOption(RepairParallelism.PARALLEL, primaryRangeOnly, true, false, - AutoRepairService.instance.getAutoRepairConfig().getRepairThreads(repairType), ranges, + UnifiedRepairService.instance.getUnifiedRepairConfig().getRepairThreads(repairType), ranges, !ranges.isEmpty(), false, false, PreviewKind.NONE, true, true, false, false); option.getColumnFamilies().addAll(filterOutUnsafeTables(keyspace, tables)); @@ -345,7 +345,7 @@ protected List filterOutUnsafeTables(String keyspaceName, List t } } -class FullRepairState extends AutoRepairState +class FullRepairState extends UnifiedRepairState { public FullRepairState() { @@ -356,7 +356,7 @@ public FullRepairState() public RepairCoordinator getRepairRunnable(String keyspace, List tables, Set> ranges, boolean primaryRangeOnly) { RepairOption option = new RepairOption(RepairParallelism.PARALLEL, primaryRangeOnly, false, false, - AutoRepairService.instance.getAutoRepairConfig().getRepairThreads(repairType), ranges, + UnifiedRepairService.instance.getUnifiedRepairConfig().getRepairThreads(repairType), ranges, !ranges.isEmpty(), false, false, PreviewKind.NONE, true, true, false, false); option.getColumnFamilies().addAll(tables); diff --git a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairUtils.java b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtils.java similarity index 83% rename from src/java/org/apache/cassandra/repair/autorepair/AutoRepairUtils.java rename to src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtils.java index 8849b7847aef..2738aa6dc8de 100644 --- a/src/java/org/apache/cassandra/repair/autorepair/AutoRepairUtils.java +++ b/src/java/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtils.java @@ -15,7 +15,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.ArrayList; import java.util.Arrays; @@ -60,7 +60,7 @@ import org.apache.cassandra.schema.ViewMetadata; import org.apache.cassandra.serializers.SetSerializer; import org.apache.cassandra.serializers.UUIDSerializer; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.service.ClientState; import org.apache.cassandra.service.QueryState; import org.apache.cassandra.service.StorageService; @@ -72,21 +72,21 @@ import org.apache.cassandra.transport.messages.ResultMessage; import org.apache.cassandra.utils.ByteBufferUtil; import org.apache.cassandra.utils.FBUtilities; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN_DUE_TO_PRIORITY; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.NOT_MY_TURN; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.MY_TURN_FORCE_REPAIR; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN_DUE_TO_PRIORITY; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.NOT_MY_TURN; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.MY_TURN_FORCE_REPAIR; import static org.apache.cassandra.utils.Clock.Global.currentTimeMillis; /** - * This class serves as a utility class for AutoRepair. It contains various helper APIs + * This class serves as a utility class for UnifiedRepair. It contains various helper APIs * to store/retrieve repair status, decide whose turn is next, etc. */ -public class AutoRepairUtils +public class UnifiedRepairUtils { - private static final Logger logger = LoggerFactory.getLogger(AutoRepairUtils.class); + private static final Logger logger = LoggerFactory.getLogger(UnifiedRepairUtils.class); static final String COL_REPAIR_TYPE = "repair_type"; static final String COL_HOST_ID = "host_id"; static final String COL_REPAIR_START_TS = "repair_start_ts"; @@ -99,56 +99,56 @@ public class AutoRepairUtils final static String SELECT_REPAIR_HISTORY = String.format( "SELECT * FROM %s.%s WHERE %s = ?", SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, - SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_TYPE); + SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_TYPE); final static String SELECT_REPAIR_PRIORITY = String.format( "SELECT * FROM %s.%s WHERE %s = ?", SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, - SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, COL_REPAIR_TYPE); + SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, COL_REPAIR_TYPE); final static String DEL_REPAIR_PRIORITY = String.format( "DELETE %s[?] FROM %s.%s WHERE %s = ?", COL_REPAIR_PRIORITY, SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, - SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, COL_REPAIR_TYPE); + SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, COL_REPAIR_TYPE); final static String ADD_PRIORITY_HOST = String.format( "UPDATE %s.%s SET %s = %s + ? WHERE %s = ?", SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, - SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, COL_REPAIR_PRIORITY, COL_REPAIR_PRIORITY, COL_REPAIR_TYPE); + SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, COL_REPAIR_PRIORITY, COL_REPAIR_PRIORITY, COL_REPAIR_TYPE); final static String INSERT_NEW_REPAIR_HISTORY = String.format( "INSERT INTO %s.%s (%s, %s, %s, %s, %s, %s) values (?, ? ,?, ?, {}, ?) IF NOT EXISTS", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_TYPE, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_TYPE, COL_HOST_ID, COL_REPAIR_START_TS, COL_REPAIR_FINISH_TS, COL_DELETE_HOSTS, COL_DELETE_HOSTS_UPDATE_TIME); final static String ADD_HOST_ID_TO_DELETE_HOSTS = String.format( "UPDATE %s.%s SET %s = %s + ?, %s = ? WHERE %s = ? AND %s = ? IF EXISTS" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_DELETE_HOSTS, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_DELETE_HOSTS, COL_DELETE_HOSTS, COL_DELETE_HOSTS_UPDATE_TIME, COL_REPAIR_TYPE, COL_HOST_ID); - final static String DEL_AUTO_REPAIR_HISTORY = String.format( + final static String DEL_UNIFIED_REPAIR_HISTORY = String.format( "DELETE FROM %s.%s WHERE %s = ? AND %s = ?" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_TYPE, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_TYPE, COL_HOST_ID); final static String RECORD_START_REPAIR_HISTORY = String.format( "UPDATE %s.%s SET %s= ?, repair_turn = ? WHERE %s = ? AND %s = ?" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_START_TS, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_START_TS, COL_REPAIR_TYPE, COL_HOST_ID); final static String RECORD_FINISH_REPAIR_HISTORY = String.format( "UPDATE %s.%s SET %s= ?, %s=false WHERE %s = ? AND %s = ?" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_FINISH_TS, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_FINISH_TS, COL_FORCE_REPAIR, COL_REPAIR_TYPE, COL_HOST_ID); final static String CLEAR_DELETE_HOSTS = String.format( "UPDATE %s.%s SET %s= {} WHERE %s = ? AND %s = ?" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_DELETE_HOSTS, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_DELETE_HOSTS, COL_REPAIR_TYPE, COL_HOST_ID); final static String SET_FORCE_REPAIR = String.format( "UPDATE %s.%s SET %s=true WHERE %s = ? AND %s = ?" - , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_FORCE_REPAIR, + , SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_FORCE_REPAIR, COL_REPAIR_TYPE, COL_HOST_ID); final static String SELECT_LAST_REPAIR_TIME_FOR_NODE = String.format( "SELECT %s FROM %s.%s WHERE %s = ? AND %s = ?", COL_REPAIR_FINISH_TS, SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, - SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, COL_REPAIR_TYPE, COL_HOST_ID); + SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, COL_REPAIR_TYPE, COL_HOST_ID); static ModificationStatement delStatementRepairHistory; static SelectStatement selectStatementRepairHistory; @@ -198,14 +198,14 @@ public static void setup() .forInternalCalls()); clearDeleteHostsStatement = (ModificationStatement) QueryProcessor.getStatement(CLEAR_DELETE_HOSTS, ClientState .forInternalCalls()); - delStatementRepairHistory = (ModificationStatement) QueryProcessor.getStatement(DEL_AUTO_REPAIR_HISTORY, ClientState + delStatementRepairHistory = (ModificationStatement) QueryProcessor.getStatement(DEL_UNIFIED_REPAIR_HISTORY, ClientState .forInternalCalls()); - Keyspace autoRepairKS = Schema.instance.getKeyspaceInstance(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME); - internalQueryCL = autoRepairKS.getReplicationStrategy().getClass() == NetworkTopologyStrategy.class ? + Keyspace unifiedRepairKS = Schema.instance.getKeyspaceInstance(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME); + internalQueryCL = unifiedRepairKS.getReplicationStrategy().getClass() == NetworkTopologyStrategy.class ? ConsistencyLevel.LOCAL_QUORUM : ConsistencyLevel.ONE; } - public static class AutoRepairHistory + public static class UnifiedRepairHistory { UUID hostId; String repairTurn; @@ -215,8 +215,8 @@ public static class AutoRepairHistory long deleteHostsUpdateTime; boolean forceRepair; - public AutoRepairHistory(UUID hostId, String repairTurn, long lastRepairStartTime, long lastRepairFinishTime, - Set deleteHosts, long deleteHostsUpateTime, boolean forceRepair) + public UnifiedRepairHistory(UUID hostId, String repairTurn, long lastRepairStartTime, long lastRepairFinishTime, + Set deleteHosts, long deleteHostsUpateTime, boolean forceRepair) { this.hostId = hostId; this.repairTurn = repairTurn; @@ -259,15 +259,15 @@ public static class CurrentRepairStatus public Set hostIdsWithOnGoingRepair; // hosts that is running repair public Set hostIdsWithOnGoingForceRepair; // hosts that is running repair because of force repair Set priority; - List historiesWithoutOnGoingRepair; // hosts that is NOT running repair + List historiesWithoutOnGoingRepair; // hosts that is NOT running repair - public CurrentRepairStatus(List repairHistories, Set priority) + public CurrentRepairStatus(List repairHistories, Set priority) { hostIdsWithOnGoingRepair = new HashSet<>(); hostIdsWithOnGoingForceRepair = new HashSet<>(); historiesWithoutOnGoingRepair = new ArrayList<>(); - for (AutoRepairHistory history : repairHistories) + for (UnifiedRepairHistory history : repairHistories) { if (history.isRepairRunning()) { @@ -300,7 +300,7 @@ public String toString() } @VisibleForTesting - public static List getAutoRepairHistory(RepairType repairType) + public static List getUnifiedRepairHistory(RepairType repairType) { UntypedResultSet repairHistoryResult; @@ -308,7 +308,7 @@ public static List getAutoRepairHistory(RepairType repairType QueryOptions.forInternalCalls(internalQueryCL, Lists.newArrayList(ByteBufferUtil.bytes(repairType.toString()))), Dispatcher.RequestTime.forImmediateExecution()); repairHistoryResult = UntypedResultSet.create(repairStatusRows.result); - List repairHistories = new ArrayList<>(); + List repairHistories = new ArrayList<>(); if (repairHistoryResult.size() > 0) { for (UntypedResultSet.Row row : repairHistoryResult) @@ -322,8 +322,8 @@ public static List getAutoRepairHistory(RepairType repairType Set deleteHosts = row.getSet(COL_DELETE_HOSTS, UUIDType.instance); long deleteHostsUpdateTime = row.getLong(COL_DELETE_HOSTS_UPDATE_TIME, 0); Boolean forceRepair = row.has(COL_FORCE_REPAIR) ? row.getBoolean(COL_FORCE_REPAIR) : false; - repairHistories.add(new AutoRepairHistory(hostId, repairTurn, lastRepairStartTime, lastRepairFinishTime, - deleteHosts, deleteHostsUpdateTime, forceRepair)); + repairHistories.add(new UnifiedRepairHistory(hostId, repairTurn, lastRepairStartTime, lastRepairFinishTime, + deleteHosts, deleteHostsUpdateTime, forceRepair)); } return repairHistories; } @@ -373,8 +373,8 @@ public static void setForceRepair(RepairType repairType, UUID hostId) public static CurrentRepairStatus getCurrentRepairStatus(RepairType repairType) { - List autoRepairHistories = getAutoRepairHistory(repairType); - return getCurrentRepairStatus(repairType, autoRepairHistories); + List unifiedRepairHistories = getUnifiedRepairHistory(repairType); + return getCurrentRepairStatus(repairType, unifiedRepairHistories); } public static long getLastRepairTimeForNode(RepairType repairType, UUID hostId) @@ -396,11 +396,11 @@ public static long getLastRepairTimeForNode(RepairType repairType, UUID hostId) return repairTime.one().getLong(COL_REPAIR_FINISH_TS); } - public static CurrentRepairStatus getCurrentRepairStatus(RepairType repairType, List autoRepairHistories) + public static CurrentRepairStatus getCurrentRepairStatus(RepairType repairType, List unifiedRepairHistories) { - if (autoRepairHistories != null) + if (unifiedRepairHistories != null) { - CurrentRepairStatus status = new CurrentRepairStatus(autoRepairHistories, getPriorityHostIds(repairType)); + CurrentRepairStatus status = new CurrentRepairStatus(unifiedRepairHistories, getPriorityHostIds(repairType)); return status; } @@ -414,7 +414,7 @@ protected static TreeSet getHostIdsInCurrentRing(RepairType repairType, Se for (NodeAddresses node : allNodesInRing) { String nodeDC = DatabaseDescriptor.getEndpointSnitch().getDatacenter(node.broadcastAddress); - if (AutoRepairService.instance.getAutoRepairConfig().getIgnoreDCs(repairType).contains(nodeDC)) + if (UnifiedRepairService.instance.getUnifiedRepairConfig().getIgnoreDCs(repairType).contains(nodeDC)) { logger.info("Ignore node {} because its datacenter is {}", node, nodeDC); continue; @@ -442,39 +442,39 @@ public static TreeSet getHostIdsInCurrentRing(RepairType repairType) } // This function will return the host ID for the node which has not been repaired for longest time - public static AutoRepairHistory getHostWithLongestUnrepairTime(RepairType repairType) + public static UnifiedRepairHistory getHostWithLongestUnrepairTime(RepairType repairType) { - List autoRepairHistories = getAutoRepairHistory(repairType); - return getHostWithLongestUnrepairTime(autoRepairHistories); + List unifiedRepairHistories = getUnifiedRepairHistory(repairType); + return getHostWithLongestUnrepairTime(unifiedRepairHistories); } - private static AutoRepairHistory getHostWithLongestUnrepairTime(List autoRepairHistories) + private static UnifiedRepairHistory getHostWithLongestUnrepairTime(List unifiedRepairHistories) { - if (autoRepairHistories == null) + if (unifiedRepairHistories == null) { return null; } - AutoRepairHistory rst = null; + UnifiedRepairHistory rst = null; long oldestTimestamp = Long.MAX_VALUE; - for (AutoRepairHistory autoRepairHistory : autoRepairHistories) + for (UnifiedRepairHistory unifiedRepairHistory : unifiedRepairHistories) { - if (autoRepairHistory.lastRepairFinishTime < oldestTimestamp) + if (unifiedRepairHistory.lastRepairFinishTime < oldestTimestamp) { - rst = autoRepairHistory; - oldestTimestamp = autoRepairHistory.lastRepairFinishTime; + rst = unifiedRepairHistory; + oldestTimestamp = unifiedRepairHistory.lastRepairFinishTime; } } return rst; } - public static int getMaxNumberOfNodeRunAutoRepair(RepairType repairType, int groupSize) + public static int getMaxNumberOfNodeRunUnifiedRepair(RepairType repairType, int groupSize) { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); if (groupSize == 0) { return Math.max(config.getParallelRepairCount(repairType), 1); } - // we will use the max number from config between auto_repair_parallel_repair_count_in_group and auto_repair_parallel_repair_percentage_in_group + // we will use the max number from config between unified_repair_parallel_repair_count_in_group and unified_repair_parallel_repair_percentage_in_group int value = Math.max(groupSize * config.getParallelRepairPercentage(repairType) / 100, config.getParallelRepairCount(repairType)); // make sure at least one node getting repaired @@ -491,33 +491,33 @@ public static RepairTurn myTurnToRunRepair(RepairType repairType, UUID myId) TreeSet hostIdsInCurrentRing = getHostIdsInCurrentRing(repairType, allNodesInRing); logger.info("Total nodes qualified for repair {}", hostIdsInCurrentRing.size()); - List autoRepairHistories = getAutoRepairHistory(repairType); - Set autoRepairHistoryIds = new HashSet<>(); + List unifiedRepairHistories = getUnifiedRepairHistory(repairType); + Set unifiedRepairHistoryIds = new HashSet<>(); // 1. Remove any node that is not part of group based on goissip info - if (autoRepairHistories != null) + if (unifiedRepairHistories != null) { - for (AutoRepairHistory nodeHistory : autoRepairHistories) + for (UnifiedRepairHistory nodeHistory : unifiedRepairHistories) { - autoRepairHistoryIds.add(nodeHistory.hostId); + unifiedRepairHistoryIds.add(nodeHistory.hostId); // clear delete_hosts if the node's delete hosts is not growing for more than two hours - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); if (nodeHistory.deleteHosts.size() > 0 - && config.getAutoRepairHistoryClearDeleteHostsBufferInterval().toSeconds() < TimeUnit.MILLISECONDS.toSeconds( + && config.getUnifiedRepairHistoryClearDeleteHostsBufferInterval().toSeconds() < TimeUnit.MILLISECONDS.toSeconds( currentTimeMillis() - nodeHistory.deleteHostsUpdateTime )) { clearDeleteHosts(repairType, nodeHistory.hostId); logger.info("Delete hosts for {} for repair type {} has not been updated for more than {} seconds. Delete hosts has been cleared. Delete hosts before clear {}" - , nodeHistory.hostId, repairType, config.getAutoRepairHistoryClearDeleteHostsBufferInterval(), nodeHistory.deleteHosts); + , nodeHistory.hostId, repairType, config.getUnifiedRepairHistoryClearDeleteHostsBufferInterval(), nodeHistory.deleteHosts); } else if (!hostIdsInCurrentRing.contains(nodeHistory.hostId)) { if (nodeHistory.deleteHosts.size() > Math.max(2, hostIdsInCurrentRing.size() * 0.5)) { // More than half of the groups thinks the record should be deleted - logger.info("{} think {} is orphan node, will delete auto repair history for repair type {}.", nodeHistory.deleteHosts, nodeHistory.hostId, repairType); - deleteAutoRepairHistory(repairType, nodeHistory.hostId); + logger.info("{} think {} is orphan node, will delete unified repair history for repair type {}.", nodeHistory.deleteHosts, nodeHistory.hostId, repairType); + deleteUnifiedRepairHistory(repairType, nodeHistory.hostId); } else { @@ -529,23 +529,23 @@ else if (!hostIdsInCurrentRing.contains(nodeHistory.hostId)) } } - // 2. Add node to auto repair history table if a node is in gossip info + // 2. Add node to unified repair history table if a node is in gossip info for (UUID hostId : hostIdsInCurrentRing) { - if (!autoRepairHistoryIds.contains(hostId)) + if (!unifiedRepairHistoryIds.contains(hostId)) { - logger.info("{} for repair type {} doesn't exist in the auto repair history table, insert a new record.", repairType, hostId); + logger.info("{} for repair type {} doesn't exist in the unified repair history table, insert a new record.", repairType, hostId); insertNewRepairHistory(repairType, hostId, currentTimeMillis(), currentTimeMillis()); } } //get current repair status - CurrentRepairStatus currentRepairStatus = getCurrentRepairStatus(repairType, autoRepairHistories); + CurrentRepairStatus currentRepairStatus = getCurrentRepairStatus(repairType, unifiedRepairHistories); if (currentRepairStatus != null) { logger.info("Latest repair status {}", currentRepairStatus); //check if I am forced to run repair - for (AutoRepairHistory history : currentRepairStatus.historiesWithoutOnGoingRepair) + for (UnifiedRepairHistory history : currentRepairStatus.historiesWithoutOnGoingRepair) { if (history.forceRepair && history.hostId.equals(myId)) { @@ -554,24 +554,24 @@ else if (!hostIdsInCurrentRing.contains(nodeHistory.hostId)) } } - int parallelRepairNumber = getMaxNumberOfNodeRunAutoRepair(repairType, - autoRepairHistories == null ? 0 : autoRepairHistories.size()); + int parallelRepairNumber = getMaxNumberOfNodeRunUnifiedRepair(repairType, + unifiedRepairHistories == null ? 0 : unifiedRepairHistories.size()); logger.info("Will run repairs concurrently on {} node(s)", parallelRepairNumber); if (currentRepairStatus == null || parallelRepairNumber > currentRepairStatus.hostIdsWithOnGoingRepair.size()) { // more repairs can be run, I might be the new one - if (autoRepairHistories != null) + if (unifiedRepairHistories != null) { - logger.info("Auto repair history table has {} records", autoRepairHistories.size()); + logger.info("Unified repair history table has {} records", unifiedRepairHistories.size()); } else { // try to fetch again - autoRepairHistories = getAutoRepairHistory(repairType); - currentRepairStatus = getCurrentRepairStatus(repairType, autoRepairHistories); - if (autoRepairHistories == null || currentRepairStatus == null) + unifiedRepairHistories = getUnifiedRepairHistory(repairType); + currentRepairStatus = getCurrentRepairStatus(repairType, unifiedRepairHistories); + if (unifiedRepairHistories == null || currentRepairStatus == null) { logger.error("No record found"); return NOT_MY_TURN; @@ -611,7 +611,7 @@ else if (!hostIdsInCurrentRing.contains(nodeHistory.hostId)) } // get the longest unrepaired node from the nodes which are not running repair - AutoRepairHistory defaultNodeToBeRepaired = getHostWithLongestUnrepairTime(currentRepairStatus.historiesWithoutOnGoingRepair); + UnifiedRepairHistory defaultNodeToBeRepaired = getHostWithLongestUnrepairTime(currentRepairStatus.historiesWithoutOnGoingRepair); //check who is next, which is helpful for debugging logger.info("Next node to be repaired for repair type {} by default: {}", repairType, defaultNodeToBeRepaired); if (defaultNodeToBeRepaired != null && defaultNodeToBeRepaired.hostId.equals(myId)) @@ -633,7 +633,7 @@ else if (currentRepairStatus.hostIdsWithOnGoingForceRepair.contains(myId)) return NOT_MY_TURN; } - static void deleteAutoRepairHistory(RepairType repairType, UUID hostId) + static void deleteUnifiedRepairHistory(RepairType repairType, UUID hostId) { //delete the given hostId delStatementRepairHistory.execute(QueryState.forInternalCalls(), @@ -642,7 +642,7 @@ static void deleteAutoRepairHistory(RepairType repairType, UUID hostId) ByteBufferUtil.bytes(hostId))), Dispatcher.RequestTime.forImmediateExecution()); } - static void updateStartAutoRepairHistory(RepairType repairType, UUID myId, long timestamp, RepairTurn turn) + static void updateStartUnifiedRepairHistory(RepairType repairType, UUID myId, long timestamp, RepairTurn turn) { recordStartRepairHistoryStatement.execute(QueryState.forInternalCalls(), QueryOptions.forInternalCalls(internalQueryCL, @@ -653,7 +653,7 @@ static void updateStartAutoRepairHistory(RepairType repairType, UUID myId, long )), Dispatcher.RequestTime.forImmediateExecution()); } - static void updateFinishAutoRepairHistory(RepairType repairType, UUID myId, long timestamp) + static void updateFinishUnifiedRepairHistory(RepairType repairType, UUID myId, long timestamp) { recordFinishRepairHistoryStatement.execute(QueryState.forInternalCalls(), QueryOptions.forInternalCalls(internalQueryCL, @@ -662,15 +662,15 @@ static void updateFinishAutoRepairHistory(RepairType repairType, UUID myId, long ByteBufferUtil.bytes(myId) )), Dispatcher.RequestTime.forImmediateExecution()); // Do not remove beblow log, the log is used by dtest - logger.info("Auto repair finished for {}", myId); + logger.info("Unified repair finished for {}", myId); } public static void insertNewRepairHistory(RepairType repairType, UUID hostId, long startTime, long finishTime) { try { - Keyspace autoRepairKS = Schema.instance.getKeyspaceInstance(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME); - ConsistencyLevel cl = autoRepairKS.getReplicationStrategy().getClass() == NetworkTopologyStrategy.class ? + Keyspace unifiedRepairKS = Schema.instance.getKeyspaceInstance(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME); + ConsistencyLevel cl = unifiedRepairKS.getReplicationStrategy().getClass() == NetworkTopologyStrategy.class ? ConsistencyLevel.LOCAL_SERIAL : null; UntypedResultSet resultSet; @@ -687,7 +687,7 @@ public static void insertNewRepairHistory(RepairType repairType, UUID hostId, lo boolean applied = resultSet.one().getBoolean(ModificationStatement.CAS_RESULT_COLUMN.toString()); if (applied) { - logger.info("Successfully inserted a new auto repair history record for host id: {}", hostId); + logger.info("Successfully inserted a new unified repair history record for host id: {}", hostId); } else { @@ -810,21 +810,21 @@ public static boolean tableMaxRepairTimeExceeded(RepairType repairType, long sta { long tableRepairTimeSoFar = TimeUnit.MILLISECONDS.toSeconds (currentTimeMillis() - startTime); - return AutoRepairService.instance.getAutoRepairConfig().getAutoRepairTableMaxRepairTime(repairType).toSeconds() < + return UnifiedRepairService.instance.getUnifiedRepairConfig().getUnifiedRepairTableMaxRepairTime(repairType).toSeconds() < tableRepairTimeSoFar; } public static boolean keyspaceMaxRepairTimeExceeded(RepairType repairType, long startTime, int numOfTablesToBeRepaired) { long keyspaceRepairTimeSoFar = TimeUnit.MILLISECONDS.toSeconds((currentTimeMillis() - startTime)); - return (long) AutoRepairService.instance.getAutoRepairConfig().getAutoRepairTableMaxRepairTime(repairType).toSeconds() * + return (long) UnifiedRepairService.instance.getUnifiedRepairConfig().getUnifiedRepairTableMaxRepairTime(repairType).toSeconds() * numOfTablesToBeRepaired < keyspaceRepairTimeSoFar; } public static List getAllMVs(RepairType repairType, Keyspace keyspace, TableMetadata tableMetadata) { List allMvs = new ArrayList<>(); - if (AutoRepairService.instance.getAutoRepairConfig().getMVRepairEnabled(repairType) && keyspace.getMetadata().views != null) + if (UnifiedRepairService.instance.getUnifiedRepairConfig().getMVRepairEnabled(repairType) && keyspace.getMetadata().views != null) { Iterator views = keyspace.getMetadata().views.forTable(tableMetadata.id).iterator(); while (views.hasNext()) @@ -839,12 +839,12 @@ public static List getAllMVs(RepairType repairType, Keyspace keyspace, T public static void runRepairOnNewlyBootstrappedNodeIfEnabled() { - AutoRepairConfig repairConfig = DatabaseDescriptor.getAutoRepairConfig(); - if (repairConfig.isAutoRepairSchedulingEnabled()) + UnifiedRepairConfig repairConfig = DatabaseDescriptor.getUnifiedRepairConfig(); + if (repairConfig.isUnifiedRepairSchedulingEnabled()) { - for (AutoRepairConfig.RepairType rType : AutoRepairConfig.RepairType.values()) - if (repairConfig.isAutoRepairEnabled(rType) && repairConfig.getForceRepairNewNode(rType)) - AutoRepairUtils.setForceRepairNewNode(rType); + for (UnifiedRepairConfig.RepairType rType : UnifiedRepairConfig.RepairType.values()) + if (repairConfig.isUnifiedRepairEnabled(rType) && repairConfig.getForceRepairNewNode(rType)) + UnifiedRepairUtils.setForceRepairNewNode(rType); } } diff --git a/src/java/org/apache/cassandra/schema/SchemaKeyspace.java b/src/java/org/apache/cassandra/schema/SchemaKeyspace.java index fe9a35f74519..796e5d819e3f 100644 --- a/src/java/org/apache/cassandra/schema/SchemaKeyspace.java +++ b/src/java/org/apache/cassandra/schema/SchemaKeyspace.java @@ -44,7 +44,7 @@ import org.apache.cassandra.db.partitions.*; import org.apache.cassandra.db.rows.*; import org.apache.cassandra.exceptions.InvalidRequestException; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.service.reads.SpeculativeRetryPolicy; import org.apache.cassandra.schema.ColumnMetadata.ClusteringOrder; import org.apache.cassandra.schema.Keyspaces.KeyspacesDiff; @@ -565,8 +565,8 @@ private static void addTableParamsToRowBuilder(TableParams params, Row.SimpleBui .add("compression", params.compression.asMap()) .add("read_repair", params.readRepair.toString()) .add("extensions", params.extensions) - .add("repair_full", params.automatedRepair.get(AutoRepairConfig.RepairType.full).asMap()) - .add("repair_incremental", params.automatedRepair.get(AutoRepairConfig.RepairType.incremental).asMap()); + .add("repair_full", params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full).asMap()) + .add("repair_incremental", params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).asMap()); // Only add CDC-enabled flag to schema if it's enabled on the node. This is to work around RTE's post-8099 if a 3.8+ @@ -1051,8 +1051,8 @@ static TableParams createTableParamsFromRow(UntypedResultSet.Row row) SpeculativeRetryPolicy.fromString("99PERCENTILE")) .cdc(row.has("cdc") && row.getBoolean("cdc")) .readRepair(getReadRepairStrategy(row)) - .automatedRepairFull(AutoRepairParams.fromMap(AutoRepairConfig.RepairType.full, row.getFrozenTextMap("repair_full"))) - .automatedRepairIncremental(AutoRepairParams.fromMap(AutoRepairConfig.RepairType.incremental, row.getFrozenTextMap("repair_incremental"))); + .unifiedRepairFull(UnifiedRepairParams.fromMap(UnifiedRepairConfig.RepairType.full, row.getFrozenTextMap("repair_full"))) + .unifiedRepairIncremental(UnifiedRepairParams.fromMap(UnifiedRepairConfig.RepairType.incremental, row.getFrozenTextMap("repair_incremental"))); // allow_auto_snapshot column was introduced in 4.2 if (row.has("allow_auto_snapshot")) diff --git a/src/java/org/apache/cassandra/schema/SystemDistributedKeyspace.java b/src/java/org/apache/cassandra/schema/SystemDistributedKeyspace.java index 9411f94c1924..0189cdac952a 100644 --- a/src/java/org/apache/cassandra/schema/SystemDistributedKeyspace.java +++ b/src/java/org/apache/cassandra/schema/SystemDistributedKeyspace.java @@ -96,11 +96,11 @@ private SystemDistributedKeyspace() public static final String PARTITION_DENYLIST_TABLE = "partition_denylist"; - public static final String AUTO_REPAIR_HISTORY = "auto_repair_history"; + public static final String UNIFIED_REPAIR_HISTORY = "unified_repair_history"; - public static final String AUTO_REPAIR_PRIORITY = "auto_repair_priority"; + public static final String UNIFIED_REPAIR_PRIORITY = "unified_repair_priority"; - public static final Set TABLE_NAMES = ImmutableSet.of(REPAIR_HISTORY, PARENT_REPAIR_HISTORY, VIEW_BUILD_STATUS, PARTITION_DENYLIST_TABLE, AUTO_REPAIR_HISTORY, AUTO_REPAIR_PRIORITY); + public static final Set TABLE_NAMES = ImmutableSet.of(REPAIR_HISTORY, PARENT_REPAIR_HISTORY, VIEW_BUILD_STATUS, PARTITION_DENYLIST_TABLE, UNIFIED_REPAIR_HISTORY, UNIFIED_REPAIR_PRIORITY); public static final String REPAIR_HISTORY_CQL = "CREATE TABLE IF NOT EXISTS %s (" + "keyspace_name text," @@ -163,27 +163,27 @@ private SystemDistributedKeyspace() private static final TableMetadata PartitionDenylistTable = parse(PARTITION_DENYLIST_TABLE, "Partition keys which have been denied access", PARTITION_DENYLIST_CQL).build(); - public static final String AUTO_REPAIR_HISTORY_CQL = "CREATE TABLE IF NOT EXISTS %s (" - + "host_id uuid," - + "repair_type text," - + "repair_turn text," - + "repair_start_ts timestamp," - + "repair_finish_ts timestamp," - + "delete_hosts set," - + "delete_hosts_update_time timestamp," - + "force_repair boolean," - + "PRIMARY KEY (repair_type, host_id))"; + public static final String UNIFIED_REPAIR_HISTORY_CQL = "CREATE TABLE IF NOT EXISTS %s (" + + "host_id uuid," + + "repair_type text," + + "repair_turn text," + + "repair_start_ts timestamp," + + "repair_finish_ts timestamp," + + "delete_hosts set," + + "delete_hosts_update_time timestamp," + + "force_repair boolean," + + "PRIMARY KEY (repair_type, host_id))"; - private static final TableMetadata AutoRepairHistoryTable = - parse(AUTO_REPAIR_HISTORY, "Auto repair history for each node", AUTO_REPAIR_HISTORY_CQL).build(); + private static final TableMetadata UnifiedRepairHistoryTable = + parse(UNIFIED_REPAIR_HISTORY, "Unified repair history for each node", UNIFIED_REPAIR_HISTORY_CQL).build(); - public static final String AUTO_REPAIR_PRIORITY_CQL = "CREATE TABLE IF NOT EXISTS %s (" - + "repair_type text," - + "repair_priority set," - + "PRIMARY KEY (repair_type))"; + public static final String UNIFIED_REPAIR_PRIORITY_CQL = "CREATE TABLE IF NOT EXISTS %s (" + + "repair_type text," + + "repair_priority set," + + "PRIMARY KEY (repair_type))"; - private static final TableMetadata AutoRepairPriorityTable = - parse(AUTO_REPAIR_PRIORITY, "Auto repair priority for each group", AUTO_REPAIR_PRIORITY_CQL).build(); + private static final TableMetadata UnifiedRepairPriorityTable = + parse(UNIFIED_REPAIR_PRIORITY, "Unified repair priority for each group", UNIFIED_REPAIR_PRIORITY_CQL).build(); private static TableMetadata.Builder parse(String table, String description, String cql) @@ -198,7 +198,7 @@ public static KeyspaceMetadata metadata() { return KeyspaceMetadata.create(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, KeyspaceParams.simple(Math.max(DEFAULT_RF, DatabaseDescriptor.getDefaultKeyspaceRF())), - Tables.of(RepairHistory, ParentRepairHistory, ViewBuildStatus, PartitionDenylistTable, AutoRepairHistoryTable, AutoRepairPriorityTable)); + Tables.of(RepairHistory, ParentRepairHistory, ViewBuildStatus, PartitionDenylistTable, UnifiedRepairHistoryTable, UnifiedRepairPriorityTable)); } public static void startParentRepair(TimeUUID parent_id, String keyspaceName, String[] cfnames, RepairOption options) diff --git a/src/java/org/apache/cassandra/schema/TableParams.java b/src/java/org/apache/cassandra/schema/TableParams.java index 9f698ecb9114..8794fca25389 100644 --- a/src/java/org/apache/cassandra/schema/TableParams.java +++ b/src/java/org/apache/cassandra/schema/TableParams.java @@ -35,7 +35,7 @@ import org.apache.cassandra.io.util.DataOutputPlus; import org.apache.cassandra.tcm.serialization.MetadataSerializer; import org.apache.cassandra.tcm.serialization.Version; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.service.reads.PercentileSpeculativeRetryPolicy; import org.apache.cassandra.service.reads.SpeculativeRetryPolicy; import org.apache.cassandra.service.reads.repair.ReadRepairStrategy; @@ -102,7 +102,7 @@ public String toString() public final boolean cdc; public final ReadRepairStrategy readRepair; - public final Map automatedRepair; + public final Map unifiedRepair; private TableParams(Builder builder) { @@ -127,11 +127,11 @@ private TableParams(Builder builder) extensions = builder.extensions; cdc = builder.cdc; readRepair = builder.readRepair; - automatedRepair = new EnumMap(AutoRepairConfig.RepairType.class) + unifiedRepair = new EnumMap(UnifiedRepairConfig.RepairType.class) { { - put(AutoRepairConfig.RepairType.full, builder.automatedRepairFull); - put(AutoRepairConfig.RepairType.incremental, builder.automatedRepairIncremental); + put(UnifiedRepairConfig.RepairType.full, builder.unifiedRepairFull); + put(UnifiedRepairConfig.RepairType.incremental, builder.unifiedRepairIncremental); } }; } @@ -162,8 +162,8 @@ public static Builder builder(TableParams params) .extensions(params.extensions) .cdc(params.cdc) .readRepair(params.readRepair) - .automatedRepairFull(params.automatedRepair.get(AutoRepairConfig.RepairType.full)) - .automatedRepairIncremental(params.automatedRepair.get(AutoRepairConfig.RepairType.incremental)) + .unifiedRepairFull(params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full)) + .unifiedRepairIncremental(params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental)) ; } @@ -220,7 +220,7 @@ public void validate() if (cdc && memtable.factory().writesShouldSkipCommitLog()) fail("CDC cannot work if writes skip the commit log. Check your memtable configuration."); - for (Map.Entry entry : automatedRepair.entrySet()) + for (Map.Entry entry : unifiedRepair.entrySet()) { entry.getValue().validate(); } @@ -243,25 +243,25 @@ public boolean equals(Object o) TableParams p = (TableParams) o; return comment.equals(p.comment) - && additionalWritePolicy.equals(p.additionalWritePolicy) - && allowAutoSnapshot == p.allowAutoSnapshot - && bloomFilterFpChance == p.bloomFilterFpChance - && crcCheckChance == p.crcCheckChance - && gcGraceSeconds == p.gcGraceSeconds - && incrementalBackups == p.incrementalBackups - && defaultTimeToLive == p.defaultTimeToLive - && memtableFlushPeriodInMs == p.memtableFlushPeriodInMs - && minIndexInterval == p.minIndexInterval - && maxIndexInterval == p.maxIndexInterval - && speculativeRetry.equals(p.speculativeRetry) - && caching.equals(p.caching) - && compaction.equals(p.compaction) - && compression.equals(p.compression) - && memtable.equals(p.memtable) - && extensions.equals(p.extensions) - && cdc == p.cdc - && readRepair == p.readRepair - && automatedRepair.equals(p.automatedRepair); + && additionalWritePolicy.equals(p.additionalWritePolicy) + && allowAutoSnapshot == p.allowAutoSnapshot + && bloomFilterFpChance == p.bloomFilterFpChance + && crcCheckChance == p.crcCheckChance + && gcGraceSeconds == p.gcGraceSeconds + && incrementalBackups == p.incrementalBackups + && defaultTimeToLive == p.defaultTimeToLive + && memtableFlushPeriodInMs == p.memtableFlushPeriodInMs + && minIndexInterval == p.minIndexInterval + && maxIndexInterval == p.maxIndexInterval + && speculativeRetry.equals(p.speculativeRetry) + && caching.equals(p.caching) + && compaction.equals(p.compaction) + && compression.equals(p.compression) + && memtable.equals(p.memtable) + && extensions.equals(p.extensions) + && cdc == p.cdc + && readRepair == p.readRepair + && unifiedRepair.equals(p.unifiedRepair); } @Override @@ -286,7 +286,7 @@ public int hashCode() extensions, cdc, readRepair, - automatedRepair); + unifiedRepair); } @Override @@ -312,8 +312,8 @@ public String toString() .add(EXTENSIONS.toString(), extensions) .add(CDC.toString(), cdc) .add(READ_REPAIR.toString(), readRepair) - .add(Option.REPAIR_FULL.toString(), automatedRepair.get(AutoRepairConfig.RepairType.full)) - .add(Option.REPAIR_INCREMENTAL.toString(), automatedRepair.get(AutoRepairConfig.RepairType.incremental)) + .add(Option.REPAIR_FULL.toString(), unifiedRepair.get(UnifiedRepairConfig.RepairType.full)) + .add(Option.REPAIR_INCREMENTAL.toString(), unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental)) .toString(); } @@ -367,9 +367,9 @@ public void appendCqlTo(CqlBuilder builder, boolean isView) .newLine() .append("AND speculative_retry = ").appendWithSingleQuotes(speculativeRetry.toString()) .newLine() - .append("AND repair_full = ").append(automatedRepair.get(AutoRepairConfig.RepairType.full).asMap()) + .append("AND repair_full = ").append(unifiedRepair.get(UnifiedRepairConfig.RepairType.full).asMap()) .newLine() - .append("AND repair_incremental = ").append(automatedRepair.get(AutoRepairConfig.RepairType.incremental).asMap()); + .append("AND repair_incremental = ").append(unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).asMap()); } public static final class Builder @@ -394,8 +394,8 @@ public static final class Builder private boolean cdc; private ReadRepairStrategy readRepair = ReadRepairStrategy.BLOCKING; - private AutoRepairParams automatedRepairFull = new AutoRepairParams(AutoRepairConfig.RepairType.full); - private AutoRepairParams automatedRepairIncremental = new AutoRepairParams(AutoRepairConfig.RepairType.incremental); + private UnifiedRepairParams unifiedRepairFull = new UnifiedRepairParams(UnifiedRepairConfig.RepairType.full); + private UnifiedRepairParams unifiedRepairIncremental = new UnifiedRepairParams(UnifiedRepairConfig.RepairType.incremental); public Builder() { @@ -520,15 +520,15 @@ public Builder extensions(Map val) return this; } - public Builder automatedRepairFull(AutoRepairParams val) + public Builder unifiedRepairFull(UnifiedRepairParams val) { - automatedRepairFull = val; + unifiedRepairFull = val; return this; } - public Builder automatedRepairIncremental(AutoRepairParams val) + public Builder unifiedRepairIncremental(UnifiedRepairParams val) { - automatedRepairIncremental = val; + unifiedRepairIncremental = val; return this; } } diff --git a/src/java/org/apache/cassandra/schema/AutoRepairParams.java b/src/java/org/apache/cassandra/schema/UnifiedRepairParams.java similarity index 74% rename from src/java/org/apache/cassandra/schema/AutoRepairParams.java rename to src/java/org/apache/cassandra/schema/UnifiedRepairParams.java index ea3802db93d2..27459ad30be0 100644 --- a/src/java/org/apache/cassandra/schema/AutoRepairParams.java +++ b/src/java/org/apache/cassandra/schema/UnifiedRepairParams.java @@ -26,12 +26,12 @@ import org.apache.commons.lang3.StringUtils; import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import static java.lang.String.format; import static org.apache.cassandra.utils.LocalizeString.toLowerCaseLocalized; -public final class AutoRepairParams +public final class UnifiedRepairParams { public enum Option { @@ -44,23 +44,23 @@ public String toString() } } - public static final Map> DEFAULT_OPTIONS = - ImmutableMap.of(AutoRepairConfig.RepairType.full, ImmutableMap.of(Option.ENABLED.toString(), Boolean.toString(true)), - AutoRepairConfig.RepairType.incremental, ImmutableMap.of(Option.ENABLED.toString(), Boolean.toString(true))); + public static final Map> DEFAULT_OPTIONS = + ImmutableMap.of(UnifiedRepairConfig.RepairType.full, ImmutableMap.of(Option.ENABLED.toString(), Boolean.toString(true)), + UnifiedRepairConfig.RepairType.incremental, ImmutableMap.of(Option.ENABLED.toString(), Boolean.toString(true))); - public final AutoRepairConfig.RepairType type; + public final UnifiedRepairConfig.RepairType type; - private Map> options = DEFAULT_OPTIONS; + private Map> options = DEFAULT_OPTIONS; - AutoRepairParams(AutoRepairConfig.RepairType type) + UnifiedRepairParams(UnifiedRepairConfig.RepairType type) { this.type = type; } - public static AutoRepairParams create(AutoRepairConfig.RepairType repairType, Map options) + public static UnifiedRepairParams create(UnifiedRepairConfig.RepairType repairType, Map options) { - Map> optionsMap = new HashMap<>(); - for (Map.Entry> entry : DEFAULT_OPTIONS.entrySet()) + Map> optionsMap = new HashMap<>(); + for (Map.Entry> entry : DEFAULT_OPTIONS.entrySet()) { optionsMap.put(entry.getKey(), new HashMap<>(entry.getValue())); } @@ -75,7 +75,7 @@ public static AutoRepairParams create(AutoRepairConfig.RepairType repairType, Ma optionsMap.get(repairType).put(entry.getKey(), entry.getValue()); } } - AutoRepairParams repairParams = new AutoRepairParams(repairType); + UnifiedRepairParams repairParams = new UnifiedRepairParams(repairType); repairParams.options = optionsMap; return repairParams; } @@ -109,7 +109,7 @@ public Map options() return options.get(type); } - public static AutoRepairParams fromMap(AutoRepairConfig.RepairType repairType, Map map) + public static UnifiedRepairParams fromMap(UnifiedRepairConfig.RepairType repairType, Map map) { return create(repairType, map); } @@ -133,10 +133,10 @@ public boolean equals(Object o) if (this == o) return true; - if (!(o instanceof AutoRepairParams)) + if (!(o instanceof UnifiedRepairParams)) return false; - AutoRepairParams cp = (AutoRepairParams) o; + UnifiedRepairParams cp = (UnifiedRepairParams) o; return options.equals(cp.options); } diff --git a/src/java/org/apache/cassandra/service/CassandraDaemon.java b/src/java/org/apache/cassandra/service/CassandraDaemon.java index 35197c3e1866..3df8b57a9671 100644 --- a/src/java/org/apache/cassandra/service/CassandraDaemon.java +++ b/src/java/org/apache/cassandra/service/CassandraDaemon.java @@ -405,7 +405,7 @@ protected void setup() AuditLogManager.instance.initialize(); - StorageService.instance.doAutoRepairSetup(); + StorageService.instance.doUnifiedRepairSetup(); // schedule periodic background compaction task submission. this is simply a backstop against compactions stalling // due to scheduling errors or race conditions diff --git a/src/java/org/apache/cassandra/service/StorageService.java b/src/java/org/apache/cassandra/service/StorageService.java index 7eb10e0542b0..3af0889a46aa 100644 --- a/src/java/org/apache/cassandra/service/StorageService.java +++ b/src/java/org/apache/cassandra/service/StorageService.java @@ -76,7 +76,7 @@ import com.google.common.util.concurrent.Uninterruptibles; import org.apache.cassandra.io.sstable.format.SSTableReader; -import org.apache.cassandra.repair.autorepair.AutoRepair; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepair; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -1130,15 +1130,15 @@ public void doAuthSetup(boolean async) } } - public void doAutoRepairSetup() + public void doUnifiedRepairSetup() { - AutoRepairService.setup(); - if (DatabaseDescriptor.getAutoRepairConfig().isAutoRepairSchedulingEnabled()) + UnifiedRepairService.setup(); + if (DatabaseDescriptor.getUnifiedRepairConfig().isUnifiedRepairSchedulingEnabled()) { - logger.info("Enable auto-repair scheduling"); - AutoRepair.instance.setup(); + logger.info("Enable unified-repair scheduling"); + UnifiedRepair.instance.setup(); } - logger.info("AutoRepair setup complete!"); + logger.info("UnifiedRepair setup complete!"); } diff --git a/src/java/org/apache/cassandra/service/AutoRepairService.java b/src/java/org/apache/cassandra/service/UnifiedRepairService.java similarity index 72% rename from src/java/org/apache/cassandra/service/AutoRepairService.java rename to src/java/org/apache/cassandra/service/UnifiedRepairService.java index 7a8342c2a7a4..489dd6873011 100644 --- a/src/java/org/apache/cassandra/service/AutoRepairService.java +++ b/src/java/org/apache/cassandra/service/UnifiedRepairService.java @@ -20,9 +20,9 @@ import org.apache.cassandra.config.DatabaseDescriptor; import org.apache.cassandra.exceptions.ConfigurationException; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.apache.cassandra.utils.MBeanWrapper; import java.util.HashSet; @@ -32,23 +32,23 @@ import com.google.common.annotations.VisibleForTesting; -public class AutoRepairService implements AutoRepairServiceMBean +public class UnifiedRepairService implements UnifiedRepairServiceMBean { - public static final String MBEAN_NAME = "org.apache.cassandra.db:type=AutoRepairService"; + public static final String MBEAN_NAME = "org.apache.cassandra.db:type=UnifiedRepairService"; @VisibleForTesting - protected AutoRepairConfig config; + protected UnifiedRepairConfig config; - public static final AutoRepairService instance = new AutoRepairService(); + public static final UnifiedRepairService instance = new UnifiedRepairService(); @VisibleForTesting - protected AutoRepairService() + protected UnifiedRepairService() { } public static void setup() { - instance.config = DatabaseDescriptor.getAutoRepairConfig(); + instance.config = DatabaseDescriptor.getUnifiedRepairConfig(); } static @@ -58,8 +58,8 @@ public static void setup() public void checkCanRun(RepairType repairType) { - if (!config.isAutoRepairSchedulingEnabled()) - throw new ConfigurationException("Auto-repair scheduller is disabled."); + if (!config.isUnifiedRepairSchedulingEnabled()) + throw new ConfigurationException("Unified-repair scheduller is disabled."); if (repairType != RepairType.incremental) return; @@ -72,16 +72,16 @@ public void checkCanRun(RepairType repairType) } @Override - public AutoRepairConfig getAutoRepairConfig() + public UnifiedRepairConfig getUnifiedRepairConfig() { return config; } @Override - public void setAutoRepairEnabled(RepairType repairType, boolean enabled) + public void setUnifiedRepairEnabled(RepairType repairType, boolean enabled) { checkCanRun(repairType); - config.setAutoRepairEnabled(repairType, enabled); + config.setUnifiedRepairEnabled(repairType, enabled); } @Override @@ -93,18 +93,18 @@ public void setRepairThreads(RepairType repairType, int repairThreads) @Override public void setRepairPriorityForHosts(RepairType repairType, Set hosts) { - AutoRepairUtils.addPriorityHosts(repairType, hosts); + UnifiedRepairUtils.addPriorityHosts(repairType, hosts); } @Override public Set getRepairHostPriority(RepairType repairType) { - return AutoRepairUtils.getPriorityHosts(repairType); + return UnifiedRepairUtils.getPriorityHosts(repairType); } @Override public void setForceRepairForHosts(RepairType repairType, Set hosts) { - AutoRepairUtils.setForceRepair(repairType, hosts); + UnifiedRepairUtils.setForceRepair(repairType, hosts); } @Override @@ -125,19 +125,19 @@ public void startScheduler() config.startScheduler(); } - public void setAutoRepairHistoryClearDeleteHostsBufferDuration(String duration) + public void setUnifiedRepairHistoryClearDeleteHostsBufferDuration(String duration) { - config.setAutoRepairHistoryClearDeleteHostsBufferInterval(duration); + config.setUnifiedRepairHistoryClearDeleteHostsBufferInterval(duration); } @Override - public void setAutoRepairMaxRetriesCount(int retries) + public void setUnifiedRepairMaxRetriesCount(int retries) { config.setRepairMaxRetries(retries); } @Override - public void setAutoRepairRetryBackoff(String interval) + public void setUnifiedRepairRetryBackoff(String interval) { config.setRepairRetryBackoff(interval); } @@ -149,9 +149,9 @@ public void setRepairSSTableCountHigherThreshold(RepairType repairType, int ssta } @Override - public void setAutoRepairTableMaxRepairTime(RepairType repairType, String autoRepairTableMaxRepairTime) + public void setUnifiedRepairTableMaxRepairTime(RepairType repairType, String unifiedRepairTableMaxRepairTime) { - config.setAutoRepairTableMaxRepairTime(repairType, autoRepairTableMaxRepairTime); + config.setUnifiedRepairTableMaxRepairTime(repairType, unifiedRepairTableMaxRepairTime); } @Override @@ -192,12 +192,12 @@ public void setRepairSessionTimeout(RepairType repairType, String timeout) public Set getOnGoingRepairHostIds(RepairType rType) { Set hostIds = new HashSet<>(); - List histories = AutoRepairUtils.getAutoRepairHistory(rType); + List histories = UnifiedRepairUtils.getUnifiedRepairHistory(rType); if (histories == null) { return hostIds; } - AutoRepairUtils.CurrentRepairStatus currentRepairStatus = new AutoRepairUtils.CurrentRepairStatus(histories, AutoRepairUtils.getPriorityHostIds(rType)); + UnifiedRepairUtils.CurrentRepairStatus currentRepairStatus = new UnifiedRepairUtils.CurrentRepairStatus(histories, UnifiedRepairUtils.getPriorityHostIds(rType)); for (UUID id : currentRepairStatus.hostIdsWithOnGoingRepair) { hostIds.add(id.toString()); diff --git a/src/java/org/apache/cassandra/service/AutoRepairServiceMBean.java b/src/java/org/apache/cassandra/service/UnifiedRepairServiceMBean.java similarity index 74% rename from src/java/org/apache/cassandra/service/AutoRepairServiceMBean.java rename to src/java/org/apache/cassandra/service/UnifiedRepairServiceMBean.java index 121c9a480303..ec5a71bdcddd 100644 --- a/src/java/org/apache/cassandra/service/AutoRepairServiceMBean.java +++ b/src/java/org/apache/cassandra/service/UnifiedRepairServiceMBean.java @@ -18,17 +18,17 @@ package org.apache.cassandra.service; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import java.util.Set; -public interface AutoRepairServiceMBean +public interface UnifiedRepairServiceMBean { /** - * Enable or disable auto-repair for a given repair type + * Enable or disable unified-repair for a given repair type */ - public void setAutoRepairEnabled(RepairType repairType, boolean enabled); + public void setUnifiedRepairEnabled(RepairType repairType, boolean enabled); public void setRepairThreads(RepairType repairType, int repairThreads); @@ -44,15 +44,15 @@ public interface AutoRepairServiceMBean void startScheduler(); - public void setAutoRepairHistoryClearDeleteHostsBufferDuration(String duration); + public void setUnifiedRepairHistoryClearDeleteHostsBufferDuration(String duration); - public void setAutoRepairMaxRetriesCount(int retries); + public void setUnifiedRepairMaxRetriesCount(int retries); - public void setAutoRepairRetryBackoff(String interval); + public void setUnifiedRepairRetryBackoff(String interval); public void setRepairSSTableCountHigherThreshold(RepairType repairType, int ssTableHigherThreshold); - public void setAutoRepairTableMaxRepairTime(RepairType repairType, String autoRepairTableMaxRepairTime); + public void setUnifiedRepairTableMaxRepairTime(RepairType repairType, String unifiedRepairTableMaxRepairTime); public void setIgnoreDCs(RepairType repairType, Set ignorDCs); @@ -64,7 +64,7 @@ public interface AutoRepairServiceMBean public void setMVRepairEnabled(RepairType repairType, boolean enabled); - public AutoRepairConfig getAutoRepairConfig(); + public UnifiedRepairConfig getUnifiedRepairConfig(); public void setRepairSessionTimeout(RepairType repairType, String timeout); diff --git a/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndJoin.java b/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndJoin.java index d3ffb9f92cf0..9119892af483 100644 --- a/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndJoin.java +++ b/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndJoin.java @@ -39,7 +39,7 @@ import org.apache.cassandra.locator.EndpointsByReplica; import org.apache.cassandra.locator.InetAddressAndPort; import org.apache.cassandra.locator.Replica; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.apache.cassandra.schema.Schema; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.streaming.StreamState; @@ -219,7 +219,7 @@ public SequenceState executeNext() return halted(); } // this node might have just bootstrapped; check if we should run repair immediately - AutoRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); + UnifiedRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); SystemKeyspace.setBootstrapState(SystemKeyspace.BootstrapState.COMPLETED); } else diff --git a/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndReplace.java b/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndReplace.java index 93251b354f2f..a827bfcf7c12 100644 --- a/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndReplace.java +++ b/src/java/org/apache/cassandra/tcm/sequences/BootstrapAndReplace.java @@ -43,7 +43,7 @@ import org.apache.cassandra.io.util.DataOutputPlus; import org.apache.cassandra.locator.EndpointsByReplica; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.apache.cassandra.schema.Schema; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.tcm.ClusterMetadata; @@ -218,7 +218,7 @@ public SequenceState executeNext() return halted(); } // this node might have just bootstrapped; check if we should run repair immediately - AutoRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); + UnifiedRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); SystemKeyspace.setBootstrapState(SystemKeyspace.BootstrapState.COMPLETED); } else diff --git a/src/java/org/apache/cassandra/tcm/sequences/ReplaceSameAddress.java b/src/java/org/apache/cassandra/tcm/sequences/ReplaceSameAddress.java index aad049ae7fa2..19d57af35d24 100644 --- a/src/java/org/apache/cassandra/tcm/sequences/ReplaceSameAddress.java +++ b/src/java/org/apache/cassandra/tcm/sequences/ReplaceSameAddress.java @@ -29,7 +29,7 @@ import org.apache.cassandra.gms.Gossiper; import org.apache.cassandra.locator.EndpointsByReplica; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.apache.cassandra.schema.Schema; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.tcm.ClusterMetadata; @@ -87,7 +87,7 @@ public static void streamData(NodeId nodeId, ClusterMetadata metadata, boolean s throw new IllegalStateException("Could not finish join for during replacement"); } // this node might have just bootstrapped; check if we should run repair immediately - AutoRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); + UnifiedRepairUtils.runRepairOnNewlyBootstrappedNodeIfEnabled(); } if (finishJoiningRing) diff --git a/src/java/org/apache/cassandra/tools/NodeProbe.java b/src/java/org/apache/cassandra/tools/NodeProbe.java index 987616ddb338..30aeaf63aa6e 100644 --- a/src/java/org/apache/cassandra/tools/NodeProbe.java +++ b/src/java/org/apache/cassandra/tools/NodeProbe.java @@ -101,10 +101,10 @@ import org.apache.cassandra.metrics.ThreadPoolMetrics; import org.apache.cassandra.net.MessagingService; import org.apache.cassandra.net.MessagingServiceMBean; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.service.ActiveRepairServiceMBean; -import org.apache.cassandra.service.AutoRepairService; -import org.apache.cassandra.service.AutoRepairServiceMBean; +import org.apache.cassandra.service.UnifiedRepairService; +import org.apache.cassandra.service.UnifiedRepairServiceMBean; import org.apache.cassandra.service.CacheService; import org.apache.cassandra.service.CacheServiceMBean; import org.apache.cassandra.tcm.CMSOperationsMBean; @@ -176,7 +176,7 @@ public class NodeProbe implements AutoCloseable protected CIDRGroupsMappingManagerMBean cmbProxy; protected PermissionsCacheMBean pcProxy; protected RolesCacheMBean rcProxy; - protected AutoRepairServiceMBean autoRepairProxy; + protected UnifiedRepairServiceMBean unifiedRepairProxy; protected Output output; private boolean failed; @@ -319,8 +319,8 @@ protected void connect() throws IOException name = new ObjectName(CIDRFilteringMetricsTable.MBEAN_NAME); cfmProxy = JMX.newMBeanProxy(mbeanServerConn, name, CIDRFilteringMetricsTableMBean.class); - name = new ObjectName(AutoRepairService.MBEAN_NAME); - autoRepairProxy = JMX.newMBeanProxy(mbeanServerConn, name, AutoRepairServiceMBean.class); + name = new ObjectName(UnifiedRepairService.MBEAN_NAME); + unifiedRepairProxy = JMX.newMBeanProxy(mbeanServerConn, name, UnifiedRepairServiceMBean.class); } catch (MalformedObjectNameException e) { @@ -2416,95 +2416,95 @@ public void abortBootstrap(String nodeId, String endpoint) ssProxy.abortBootstrap(nodeId, endpoint); } - public AutoRepairConfig getAutoRepairConfig() { - return autoRepairProxy.getAutoRepairConfig(); + public UnifiedRepairConfig getUnifiedRepairConfig() { + return unifiedRepairProxy.getUnifiedRepairConfig(); } - public void setAutoRepairEnabled(AutoRepairConfig.RepairType repairType, boolean enabled) + public void setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType repairType, boolean enabled) { - autoRepairProxy.setAutoRepairEnabled(repairType, enabled); + unifiedRepairProxy.setUnifiedRepairEnabled(repairType, enabled); } - public void setRepairThreads(AutoRepairConfig.RepairType repairType, int repairThreads) + public void setRepairThreads(UnifiedRepairConfig.RepairType repairType, int repairThreads) { - autoRepairProxy.setRepairThreads(repairType, repairThreads); + unifiedRepairProxy.setRepairThreads(repairType, repairThreads); } - public void setRepairPriorityForHosts(AutoRepairConfig.RepairType repairType, Set hosts) + public void setRepairPriorityForHosts(UnifiedRepairConfig.RepairType repairType, Set hosts) { - autoRepairProxy.setRepairPriorityForHosts(repairType, hosts); + unifiedRepairProxy.setRepairPriorityForHosts(repairType, hosts); } - public Set getRepairPriorityForHosts(AutoRepairConfig.RepairType repairType) + public Set getRepairPriorityForHosts(UnifiedRepairConfig.RepairType repairType) { - return autoRepairProxy.getRepairHostPriority(repairType); + return unifiedRepairProxy.getRepairHostPriority(repairType); } - public void setForceRepairForHosts(AutoRepairConfig.RepairType repairType, Set hosts){ - autoRepairProxy.setForceRepairForHosts(repairType, hosts); + public void setForceRepairForHosts(UnifiedRepairConfig.RepairType repairType, Set hosts){ + unifiedRepairProxy.setForceRepairForHosts(repairType, hosts); } - public void setRepairSubRangeNum(AutoRepairConfig.RepairType repairType, int repairSubRanges) + public void setRepairSubRangeNum(UnifiedRepairConfig.RepairType repairType, int repairSubRanges) { - autoRepairProxy.setRepairSubRangeNum(repairType, repairSubRanges); + unifiedRepairProxy.setRepairSubRangeNum(repairType, repairSubRanges); } - public void setRepairMinInterval(AutoRepairConfig.RepairType repairType, String minRepairInterval) + public void setRepairMinInterval(UnifiedRepairConfig.RepairType repairType, String minRepairInterval) { - autoRepairProxy.setRepairMinInterval(repairType, minRepairInterval); + unifiedRepairProxy.setRepairMinInterval(repairType, minRepairInterval); } - public void setAutoRepairHistoryClearDeleteHostsBufferDuration(String duration) + public void setUnifiedRepairHistoryClearDeleteHostsBufferDuration(String duration) { - autoRepairProxy.setAutoRepairHistoryClearDeleteHostsBufferDuration(duration); + unifiedRepairProxy.setUnifiedRepairHistoryClearDeleteHostsBufferDuration(duration); } public void startScheduler() { - autoRepairProxy.startScheduler(); + unifiedRepairProxy.startScheduler(); } - public void setAutoRepairMaxRetriesCount(int retries) + public void setUnifiedRepairMaxRetriesCount(int retries) { - autoRepairProxy.setAutoRepairMaxRetriesCount(retries); + unifiedRepairProxy.setUnifiedRepairMaxRetriesCount(retries); } - public void setAutoRepairRetryBackoff(String interval) + public void setUnifiedRepairRetryBackoff(String interval) { - autoRepairProxy.setAutoRepairRetryBackoff(interval); + unifiedRepairProxy.setUnifiedRepairRetryBackoff(interval); } - public void setRepairSSTableCountHigherThreshold(AutoRepairConfig.RepairType repairType, int ssTableHigherThreshold) + public void setRepairSSTableCountHigherThreshold(UnifiedRepairConfig.RepairType repairType, int ssTableHigherThreshold) { - autoRepairProxy.setRepairSSTableCountHigherThreshold(repairType, ssTableHigherThreshold); + unifiedRepairProxy.setRepairSSTableCountHigherThreshold(repairType, ssTableHigherThreshold); } - public void setAutoRepairTableMaxRepairTime(AutoRepairConfig.RepairType repairType, String autoRepairTableMaxRepairTime) + public void setUnifiedRepairTableMaxRepairTime(UnifiedRepairConfig.RepairType repairType, String unifiedRepairTableMaxRepairTime) { - autoRepairProxy.setAutoRepairTableMaxRepairTime(repairType, autoRepairTableMaxRepairTime); + unifiedRepairProxy.setUnifiedRepairTableMaxRepairTime(repairType, unifiedRepairTableMaxRepairTime); } - public void setAutoRepairIgnoreDCs(AutoRepairConfig.RepairType repairType, Set ignoreDCs) + public void setUnifiedRepairIgnoreDCs(UnifiedRepairConfig.RepairType repairType, Set ignoreDCs) { - autoRepairProxy.setIgnoreDCs(repairType, ignoreDCs); + unifiedRepairProxy.setIgnoreDCs(repairType, ignoreDCs); } - public void setParallelRepairPercentage(AutoRepairConfig.RepairType repairType, int percentage) { - autoRepairProxy.setParallelRepairPercentage(repairType, percentage); + public void setParallelRepairPercentage(UnifiedRepairConfig.RepairType repairType, int percentage) { + unifiedRepairProxy.setParallelRepairPercentage(repairType, percentage); } - public void setParallelRepairCount(AutoRepairConfig.RepairType repairType, int count) { - autoRepairProxy.setParallelRepairCount(repairType, count); + public void setParallelRepairCount(UnifiedRepairConfig.RepairType repairType, int count) { + unifiedRepairProxy.setParallelRepairCount(repairType, count); } - public void setPrimaryTokenRangeOnly(AutoRepairConfig.RepairType repairType, boolean primaryTokenRangeOnly) + public void setPrimaryTokenRangeOnly(UnifiedRepairConfig.RepairType repairType, boolean primaryTokenRangeOnly) { - autoRepairProxy.setPrimaryTokenRangeOnly(repairType, primaryTokenRangeOnly); + unifiedRepairProxy.setPrimaryTokenRangeOnly(repairType, primaryTokenRangeOnly); } - public void setMVRepairEnabled(AutoRepairConfig.RepairType repairType, boolean enabled) + public void setMVRepairEnabled(UnifiedRepairConfig.RepairType repairType, boolean enabled) { - autoRepairProxy.setMVRepairEnabled(repairType, enabled); + unifiedRepairProxy.setMVRepairEnabled(repairType, enabled); } public List mutateSSTableRepairedState(boolean repair, boolean preview, String keyspace, List tables) throws InvalidRequestException @@ -2516,14 +2516,14 @@ public List getTablesForKeyspace(String keyspace) { return ssProxy.getTablesForKeyspace(keyspace); } - public void setRepairSessionTimeout(AutoRepairConfig.RepairType repairType, String timeout) + public void setRepairSessionTimeout(UnifiedRepairConfig.RepairType repairType, String timeout) { - autoRepairProxy.setRepairSessionTimeout(repairType, timeout); + unifiedRepairProxy.setRepairSessionTimeout(repairType, timeout); } - public Set getOnGoingRepairHostIds(AutoRepairConfig.RepairType type) + public Set getOnGoingRepairHostIds(UnifiedRepairConfig.RepairType type) { - return autoRepairProxy.getOnGoingRepairHostIds(type); + return unifiedRepairProxy.getOnGoingRepairHostIds(type); } } diff --git a/src/java/org/apache/cassandra/tools/NodeTool.java b/src/java/org/apache/cassandra/tools/NodeTool.java index 80f8ed8f09e1..9c002f877e06 100644 --- a/src/java/org/apache/cassandra/tools/NodeTool.java +++ b/src/java/org/apache/cassandra/tools/NodeTool.java @@ -95,7 +95,6 @@ public int execute(String... args) { List> commands = newArrayList( AbortBootstrap.class, - AutoRepairStatus.class, Assassinate.class, CassHelp.class, CIDRFilteringStats.class, @@ -135,7 +134,6 @@ public int execute(String... args) GcStats.class, GetAuditLog.class, GetAuthCacheConfig.class, - GetAutoRepairConfig.class, GetBatchlogReplayTrottle.class, GetCIDRGroupsOfIP.class, GetColumnIndexSize.class, @@ -156,6 +154,7 @@ public int execute(String... args) GetStreamThroughput.class, GetTimeout.class, GetTraceProbability.class, + GetUnifiedRepairConfig.class, GossipInfo.class, Import.class, Info.class, @@ -198,7 +197,6 @@ public int execute(String... args) Ring.class, Scrub.class, SetAuthCacheConfig.class, - SetAutoRepairConfig.class, SetBatchlogReplayThrottle.class, SetCacheCapacity.class, SetCacheKeysToSave.class, @@ -217,6 +215,7 @@ public int execute(String... args) SetStreamThroughput.class, SetTimeout.class, SetTraceProbability.class, + SetUnifiedRepairConfig.class, Sjk.class, Snapshot.class, SSTableRepairedSet.class, @@ -233,6 +232,7 @@ public int execute(String... args) TopPartitions.class, TpStats.class, TruncateHints.class, + UnifiedRepairStatus.class, UpdateCIDRGroup.class, UpgradeSSTable.class, Verify.class, diff --git a/src/java/org/apache/cassandra/tools/nodetool/GetAutoRepairConfig.java b/src/java/org/apache/cassandra/tools/nodetool/GetUnifiedRepairConfig.java similarity index 82% rename from src/java/org/apache/cassandra/tools/nodetool/GetAutoRepairConfig.java rename to src/java/org/apache/cassandra/tools/nodetool/GetUnifiedRepairConfig.java index 48f8d54de3f6..336063eb2405 100644 --- a/src/java/org/apache/cassandra/tools/nodetool/GetAutoRepairConfig.java +++ b/src/java/org/apache/cassandra/tools/nodetool/GetUnifiedRepairConfig.java @@ -20,15 +20,15 @@ import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Joiner; import io.airlift.airline.Command; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import org.apache.cassandra.tools.NodeProbe; import org.apache.cassandra.tools.NodeTool.NodeToolCmd; import java.io.PrintStream; -@Command(name = "getautorepairconfig", description = "Print autorepair configurations") -public class GetAutoRepairConfig extends NodeToolCmd +@Command(name = "getunifiedrepairconfig", description = "Print unifiedrepair configurations") +public class GetUnifiedRepairConfig extends NodeToolCmd { @VisibleForTesting protected static PrintStream out = System.out; @@ -36,17 +36,17 @@ public class GetAutoRepairConfig extends NodeToolCmd @Override public void execute(NodeProbe probe) { - AutoRepairConfig config = probe.getAutoRepairConfig(); - if (config == null || !config.isAutoRepairSchedulingEnabled()) + UnifiedRepairConfig config = probe.getUnifiedRepairConfig(); + if (config == null || !config.isUnifiedRepairSchedulingEnabled()) { - out.println("Auto-repair is not enabled"); + out.println("Unified-repair is not enabled"); return; } StringBuilder sb = new StringBuilder(); sb.append("repair scheduler configuration:"); sb.append("\n\trepair eligibility check interval: " + config.getRepairCheckInterval()); - sb.append("\n\tTTL for repair history for dead nodes: " + config.getAutoRepairHistoryClearDeleteHostsBufferInterval()); + sb.append("\n\tTTL for repair history for dead nodes: " + config.getUnifiedRepairHistoryClearDeleteHostsBufferInterval()); sb.append("\n\tmax retries for repair: " + config.getRepairMaxRetries()); sb.append("\n\tretry backoff: " + config.getRepairRetryBackoff()); for (RepairType repairType : RepairType.values()) @@ -57,17 +57,17 @@ public void execute(NodeProbe probe) out.println(sb); } - private String formatRepairTypeConfig(NodeProbe probe, RepairType repairType, AutoRepairConfig config) + private String formatRepairTypeConfig(NodeProbe probe, RepairType repairType, UnifiedRepairConfig config) { StringBuilder sb = new StringBuilder(); sb.append("\nconfiguration for repair type: " + repairType); - sb.append("\n\tenabled: " + config.isAutoRepairEnabled(repairType)); + sb.append("\n\tenabled: " + config.isUnifiedRepairEnabled(repairType)); sb.append("\n\tminimum repair interval: " + config.getRepairMinInterval(repairType)); sb.append("\n\trepair threads: " + config.getRepairThreads(repairType)); sb.append("\n\tnumber of repair subranges: " + config.getRepairSubRangeNum(repairType)); sb.append("\n\tpriority hosts: " + Joiner.on(',').skipNulls().join(probe.getRepairPriorityForHosts(repairType))); sb.append("\n\tsstable count higher threshold: " + config.getRepairSSTableCountHigherThreshold(repairType)); - sb.append("\n\ttable max repair time in sec: " + config.getAutoRepairTableMaxRepairTime(repairType)); + sb.append("\n\ttable max repair time in sec: " + config.getUnifiedRepairTableMaxRepairTime(repairType)); sb.append("\n\tignore datacenters: " + Joiner.on(',').skipNulls().join(config.getIgnoreDCs(repairType))); sb.append("\n\trepair primary token-range: " + config.getRepairPrimaryTokenRangeOnly(repairType)); sb.append("\n\tnumber of parallel repairs within group: " + config.getParallelRepairCount(repairType)); diff --git a/src/java/org/apache/cassandra/tools/nodetool/SetAutoRepairConfig.java b/src/java/org/apache/cassandra/tools/nodetool/SetUnifiedRepairConfig.java similarity index 83% rename from src/java/org/apache/cassandra/tools/nodetool/SetAutoRepairConfig.java rename to src/java/org/apache/cassandra/tools/nodetool/SetUnifiedRepairConfig.java index 2929c944442a..fe123c3de1ac 100644 --- a/src/java/org/apache/cassandra/tools/nodetool/SetAutoRepairConfig.java +++ b/src/java/org/apache/cassandra/tools/nodetool/SetUnifiedRepairConfig.java @@ -24,7 +24,7 @@ import io.airlift.airline.Command; import io.airlift.airline.Option; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import org.apache.cassandra.tools.NodeProbe; import org.apache.cassandra.tools.NodeTool.NodeToolCmd; @@ -37,12 +37,12 @@ import static com.google.common.base.Preconditions.checkArgument; -@Command(name = "setautorepairconfig", description = "sets the autorepair configuration") -public class SetAutoRepairConfig extends NodeToolCmd +@Command(name = "setunifiedrepairconfig", description = "sets the unifiedrepair configuration") +public class SetUnifiedRepairConfig extends NodeToolCmd { @VisibleForTesting - @Arguments(title = " ", usage = " ", - description = "autorepair param and value.\nPossible autorepair parameters are as following: " + + @Arguments(title = " ", usage = " ", + description = "unifiedrepair param and value.\nPossible unifiedrepair parameters are as following: " + "[start_scheduler|number_of_repair_threads|number_of_subranges|min_repair_interval|sstable_upper_threshold" + "|enabled|table_max_repair_time|priority_hosts|forcerepair_hosts|ignore_dcs" + "|history_clear_delete_hosts_buffer_interval|repair_primary_token_range_only" + @@ -60,13 +60,13 @@ public class SetAutoRepairConfig extends NodeToolCmd @Override public void execute(NodeProbe probe) { - checkArgument(args.size() == 2, "setautorepairconfig requires param-type, and value args."); + checkArgument(args.size() == 2, "setunifiedrepairconfig requires param-type, and value args."); String paramType = args.get(0); String paramVal = args.get(1); - if (!probe.getAutoRepairConfig().isAutoRepairSchedulingEnabled() && !paramType.equalsIgnoreCase("start_scheduler")) + if (!probe.getUnifiedRepairConfig().isUnifiedRepairSchedulingEnabled() && !paramType.equalsIgnoreCase("start_scheduler")) { - out.println("Auto-repair is not enabled"); + out.println("Unified-repair is not enabled"); return; } @@ -80,13 +80,13 @@ public void execute(NodeProbe probe) } return; case "history_clear_delete_hosts_buffer_interval": - probe.setAutoRepairHistoryClearDeleteHostsBufferDuration(paramVal); + probe.setUnifiedRepairHistoryClearDeleteHostsBufferDuration(paramVal); return; case "repair_max_retries": - probe.setAutoRepairMaxRetriesCount(Integer.parseInt(paramVal)); + probe.setUnifiedRepairMaxRetriesCount(Integer.parseInt(paramVal)); return; case "repair_retry_backoff": - probe.setAutoRepairRetryBackoff(paramVal); + probe.setUnifiedRepairRetryBackoff(paramVal); return; default: // proceed to options that require --repair-type option @@ -99,7 +99,7 @@ public void execute(NodeProbe probe) switch (paramType) { case "enabled": - probe.setAutoRepairEnabled(repairType, Boolean.parseBoolean(paramVal)); + probe.setUnifiedRepairEnabled(repairType, Boolean.parseBoolean(paramVal)); break; case "number_of_repair_threads": probe.setRepairThreads(repairType, Integer.parseInt(paramVal)); @@ -114,7 +114,7 @@ public void execute(NodeProbe probe) probe.setRepairSSTableCountHigherThreshold(repairType, Integer.parseInt(paramVal)); break; case "table_max_repair_time": - probe.setAutoRepairTableMaxRepairTime(repairType, paramVal); + probe.setUnifiedRepairTableMaxRepairTime(repairType, paramVal); break; case "priority_hosts": hosts = retrieveHosts(paramVal); @@ -136,7 +136,7 @@ public void execute(NodeProbe probe) { ignoreDCs.add(dc); } - probe.setAutoRepairIgnoreDCs(repairType, ignoreDCs); + probe.setUnifiedRepairIgnoreDCs(repairType, ignoreDCs); break; case "repair_primary_token_range_only": probe.setPrimaryTokenRangeOnly(repairType, Boolean.parseBoolean(paramVal)); diff --git a/src/java/org/apache/cassandra/tools/nodetool/AutoRepairStatus.java b/src/java/org/apache/cassandra/tools/nodetool/UnifiedRepairStatus.java similarity index 82% rename from src/java/org/apache/cassandra/tools/nodetool/AutoRepairStatus.java rename to src/java/org/apache/cassandra/tools/nodetool/UnifiedRepairStatus.java index 7b96102c6698..b40fe887e5d8 100644 --- a/src/java/org/apache/cassandra/tools/nodetool/AutoRepairStatus.java +++ b/src/java/org/apache/cassandra/tools/nodetool/UnifiedRepairStatus.java @@ -25,19 +25,19 @@ import io.airlift.airline.Command; import io.airlift.airline.Option; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.tools.NodeProbe; import org.apache.cassandra.tools.NodeTool; import org.apache.cassandra.tools.nodetool.formatter.TableBuilder; import static com.google.common.base.Preconditions.checkArgument; -@Command(name = "autorepairstatus", description = "Print autorepair status") -public class AutoRepairStatus extends NodeTool.NodeToolCmd +@Command(name = "unifiedrepairstatus", description = "Print unifiedrepair status") +public class UnifiedRepairStatus extends NodeTool.NodeToolCmd { @VisibleForTesting @Option(title = "repair type", name = { "-t", "--repair-type" }, description = "Repair type") - protected AutoRepairConfig.RepairType repairType; + protected UnifiedRepairConfig.RepairType repairType; @Override public void execute(NodeProbe probe) @@ -45,10 +45,10 @@ public void execute(NodeProbe probe) checkArgument(repairType != null, "--repair-type is required."); PrintStream out = probe.output().out; - AutoRepairConfig config = probe.getAutoRepairConfig(); - if (config == null || !config.isAutoRepairSchedulingEnabled()) + UnifiedRepairConfig config = probe.getUnifiedRepairConfig(); + if (config == null || !config.isUnifiedRepairSchedulingEnabled()) { - out.println("Auto-repair is not enabled"); + out.println("Unified-repair is not enabled"); return; } diff --git a/src/java/org/apache/cassandra/utils/FBUtilities.java b/src/java/org/apache/cassandra/utils/FBUtilities.java index b2dcedde48d4..d5332ec76953 100644 --- a/src/java/org/apache/cassandra/utils/FBUtilities.java +++ b/src/java/org/apache/cassandra/utils/FBUtilities.java @@ -69,7 +69,7 @@ import org.apache.cassandra.config.ParameterizedClass; import org.apache.cassandra.io.util.File; -import org.apache.cassandra.repair.autorepair.IAutoRepairTokenRangeSplitter; +import org.apache.cassandra.repair.unifiedrepair.IUnifiedRepairTokenRangeSplitter; import org.apache.commons.lang3.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -721,11 +721,11 @@ public static AbstractCryptoProvider newCryptoProvider(String className, Map parameters = parameterizedClass.parameters != null ? parameterizedClass.parameters : Collections.emptyMap(); // first attempt to initialize with Map arguments. - return (IAutoRepairTokenRangeSplitter) tokenRangeSplitterClass.getConstructor(Map.class).newInstance(parameters); + return (IUnifiedRepairTokenRangeSplitter) tokenRangeSplitterClass.getConstructor(Map.class).newInstance(parameters); } catch (NoSuchMethodException nsme) { // fall back on no argument constructor. - return (IAutoRepairTokenRangeSplitter) tokenRangeSplitterClass.getConstructor().newInstance(); + return (IUnifiedRepairTokenRangeSplitter) tokenRangeSplitterClass.getConstructor().newInstance(); } } catch (Exception ex) { - throw new ConfigurationException("Unable to create instance of IAutoRepairTokenRangeSplitter for " + className, ex); + throw new ConfigurationException("Unable to create instance of IUnifiedRepairTokenRangeSplitter for " + className, ex); } } diff --git a/test/distributed/org/apache/cassandra/distributed/test/repair/AutoRepairSchedulerTest.java b/test/distributed/org/apache/cassandra/distributed/test/repair/UnifiedRepairSchedulerTest.java similarity index 83% rename from test/distributed/org/apache/cassandra/distributed/test/repair/AutoRepairSchedulerTest.java rename to test/distributed/org/apache/cassandra/distributed/test/repair/UnifiedRepairSchedulerTest.java index 9b583f006507..8460ec119cee 100644 --- a/test/distributed/org/apache/cassandra/distributed/test/repair/AutoRepairSchedulerTest.java +++ b/test/distributed/org/apache/cassandra/distributed/test/repair/UnifiedRepairSchedulerTest.java @@ -35,14 +35,14 @@ import org.apache.cassandra.distributed.Cluster; import org.apache.cassandra.distributed.api.ConsistencyLevel; import org.apache.cassandra.distributed.test.TestBaseImpl; -import org.apache.cassandra.repair.autorepair.AutoRepair; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepair; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.service.UnifiedRepairService; import static org.apache.cassandra.schema.SchemaConstants.DISTRIBUTED_KEYSPACE_NAME; import static org.junit.Assert.assertEquals; -public class AutoRepairSchedulerTest extends TestBaseImpl +public class UnifiedRepairSchedulerTest extends TestBaseImpl { private static Cluster cluster; @@ -57,25 +57,25 @@ public static void init() throws IOException sdf = new SimpleDateFormat(pattern); sdf.setLenient(false); cluster = Cluster.build(3).withConfig(config -> config - .set("auto_repair", + .set("unified_repair", ImmutableMap.of( "repair_type_overrides", - ImmutableMap.of(AutoRepairConfig.RepairType.full.toString(), - ImmutableMap.of( + ImmutableMap.of(UnifiedRepairConfig.RepairType.full.toString(), + ImmutableMap.of( "initial_scheduler_delay", "5s", "enabled", "true", "parallel_repair_count", "1", "parallel_repair_percentage", "0", "min_repair_interval", "1s"), - AutoRepairConfig.RepairType.incremental.toString(), - ImmutableMap.of( + UnifiedRepairConfig.RepairType.incremental.toString(), + ImmutableMap.of( "initial_scheduler_delay", "5s", "enabled", "true", "parallel_repair_count", "1", "parallel_repair_percentage", "0", "min_repair_interval", "1s")))) - .set("auto_repair.enabled", "true") - .set("auto_repair.repair_check_interval", "10s")).start(); + .set("unified_repair.enabled", "true") + .set("unified_repair.repair_check_interval", "10s")).start(); cluster.schemaChange("CREATE KEYSPACE IF NOT EXISTS " + KEYSPACE + " WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};"); cluster.schemaChange(withKeyspace("CREATE TABLE %s.tbl (pk int, ck text, v1 int, v2 int, PRIMARY KEY (pk, ck)) WITH read_repair='NONE'")); @@ -85,7 +85,7 @@ public static void init() throws IOException public void testScheduler() throws ParseException { // ensure there was no history of previous repair runs through the scheduler - Object[][] rows = cluster.coordinator(1).execute(String.format("SELECT repair_type, host_id, repair_start_ts, repair_finish_ts, repair_turn FROM %s.%s", DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY), ConsistencyLevel.QUORUM); + Object[][] rows = cluster.coordinator(1).execute(String.format("SELECT repair_type, host_id, repair_start_ts, repair_finish_ts, repair_turn FROM %s.%s", DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY), ConsistencyLevel.QUORUM); assertEquals(0, rows.length); cluster.forEach(i -> i.runOnInstance(() -> { @@ -93,9 +93,9 @@ public void testScheduler() throws ParseException { DatabaseDescriptor.setCDCOnRepairEnabled(false); DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); - AutoRepairService.instance.setup(); + UnifiedRepairService.instance.setup(); DatabaseDescriptor.setCDCOnRepairEnabled(false); - AutoRepair.instance.setup(); + UnifiedRepair.instance.setup(); } catch (Exception e) { @@ -105,13 +105,13 @@ public void testScheduler() throws ParseException // wait for a couple of minutes for repair to go through on all three nodes Uninterruptibles.sleepUninterruptibly(2, TimeUnit.MINUTES); - validate(AutoRepairConfig.RepairType.full.toString()); - validate(AutoRepairConfig.RepairType.incremental.toString()); + validate(UnifiedRepairConfig.RepairType.full.toString()); + validate(UnifiedRepairConfig.RepairType.incremental.toString()); } private void validate(String repairType) throws ParseException { - Object[][] rows = cluster.coordinator(1).execute(String.format("SELECT repair_type, host_id, repair_start_ts, repair_finish_ts, repair_turn FROM %s.%s where repair_type='%s'", DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, repairType), ConsistencyLevel.QUORUM); + Object[][] rows = cluster.coordinator(1).execute(String.format("SELECT repair_type, host_id, repair_start_ts, repair_finish_ts, repair_turn FROM %s.%s where repair_type='%s'", DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType), ConsistencyLevel.QUORUM); assertEquals(3, rows.length); for (int node = 0; node < rows.length; node++) { diff --git a/test/unit/org/apache/cassandra/Util.java b/test/unit/org/apache/cassandra/Util.java index 74fe87dbaf16..71fa6c46175b 100644 --- a/test/unit/org/apache/cassandra/Util.java +++ b/test/unit/org/apache/cassandra/Util.java @@ -62,7 +62,7 @@ import org.apache.cassandra.io.util.File; import org.apache.cassandra.config.Config; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.commons.lang3.StringUtils; import org.junit.Assume; import org.slf4j.Logger; @@ -1288,11 +1288,11 @@ public static RuntimeException testMustBeImplementedForSSTableFormat() return new UnsupportedOperationException("Test must be implemented for sstable format " + DatabaseDescriptor.getSelectedSSTableFormat().getClass().getName()); } - // Replaces the global auto-repair config with a new config where auto-repair schedulling is enabled/disabled - public static void setAutoRepairEnabled(boolean enabled) throws Exception + // Replaces the global unified-repair config with a new config where unified-repair schedulling is enabled/disabled + public static void setUnifiedRepairEnabled(boolean enabled) throws Exception { Config config = DatabaseDescriptor.getRawConfig(); - config.auto_repair = new AutoRepairConfig(enabled); + config.unified_repair = new UnifiedRepairConfig(enabled); Field configField = DatabaseDescriptor.class.getDeclaredField("conf"); configField.setAccessible(true); configField.set(null, config); diff --git a/test/unit/org/apache/cassandra/config/DatabaseDescriptorRefTest.java b/test/unit/org/apache/cassandra/config/DatabaseDescriptorRefTest.java index 490f2534baf2..42aa930968f6 100644 --- a/test/unit/org/apache/cassandra/config/DatabaseDescriptorRefTest.java +++ b/test/unit/org/apache/cassandra/config/DatabaseDescriptorRefTest.java @@ -103,14 +103,14 @@ public class DatabaseDescriptorRefTest "org.apache.cassandra.config.ConfigurationLoader", "org.apache.cassandra.config.Config$CorruptedTombstoneStrategy", "org.apache.cassandra.config.Config$BatchlogEndpointStrategy", - "org.apache.cassandra.repair.autorepair.AutoRepairConfig", - "org.apache.cassandra.repair.autorepair.AutoRepairConfig$Options", - "org.apache.cassandra.repair.autorepair.DefaultAutoRepairTokenSplitter", - "org.apache.cassandra.repair.autorepair.IAutoRepairTokenRangeSplitter", - "org.apache.cassandra.repair.autorepair.FullRepairState", - "org.apache.cassandra.repair.autorepair.IncrementalRepairState", - "org.apache.cassandra.repair.autorepair.AutoRepairConfig$RepairType", - "org.apache.cassandra.repair.autorepair.AutoRepairState", + "org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig", + "org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig$Options", + "org.apache.cassandra.repair.unifiedrepair.DefaultUnifiedRepairTokenSplitter", + "org.apache.cassandra.repair.unifiedrepair.IUnifiedRepairTokenRangeSplitter", + "org.apache.cassandra.repair.unifiedrepair.FullRepairState", + "org.apache.cassandra.repair.unifiedrepair.IncrementalRepairState", + "org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig$RepairType", + "org.apache.cassandra.repair.unifiedrepair.UnifiedRepairState", "org.apache.cassandra.config.DatabaseDescriptor$ByteUnit", "org.apache.cassandra.config.DataRateSpec", "org.apache.cassandra.config.DataRateSpec$DataRateUnit", diff --git a/test/unit/org/apache/cassandra/config/YamlConfigurationLoaderTest.java b/test/unit/org/apache/cassandra/config/YamlConfigurationLoaderTest.java index 141c762ba461..946496cfe0bf 100644 --- a/test/unit/org/apache/cassandra/config/YamlConfigurationLoaderTest.java +++ b/test/unit/org/apache/cassandra/config/YamlConfigurationLoaderTest.java @@ -42,7 +42,7 @@ import static org.apache.cassandra.config.YamlConfigurationLoader.SYSTEM_PROPERTY_PREFIX; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -273,7 +273,7 @@ public void fromMapTest() Map encryptionOptions = ImmutableMap.of("cipher_suites", Collections.singletonList("FakeCipher"), "optional", false, "enabled", true); - Map autoRepairConfig = ImmutableMap.of("enabled", true, + Map unifiedRepairConfig = ImmutableMap.of("enabled", true, "global_settings", ImmutableMap.of("number_of_repair_threads", 1), "repair_type_overrides", ImmutableMap.of( @@ -287,7 +287,7 @@ public void fromMapTest() .put("internode_socket_send_buffer_size", "5B") .put("internode_socket_receive_buffer_size", "5B") .put("commitlog_sync_group_window_in_ms", "42") - .put("auto_repair", autoRepairConfig) + .put("unified_repair", unifiedRepairConfig) .build(); Config config = YamlConfigurationLoader.fromMap(map, Config.class); @@ -298,9 +298,9 @@ public void fromMapTest() assertEquals(true, config.client_encryption_options.enabled); // Check a nested object assertEquals(new DataStorageSpec.IntBytesBound("5B"), config.internode_socket_send_buffer_size); // Check names backward compatibility (CASSANDRA-17141 and CASSANDRA-15234) assertEquals(new DataStorageSpec.IntBytesBound("5B"), config.internode_socket_receive_buffer_size); // Check names backward compatibility (CASSANDRA-17141 and CASSANDRA-15234) - assertEquals(true, config.auto_repair.enabled); - assertEquals(new DurationSpec.IntSecondsBound("6h"), config.auto_repair.getAutoRepairTableMaxRepairTime(AutoRepairConfig.RepairType.incremental)); - config.auto_repair.setMVRepairEnabled(AutoRepairConfig.RepairType.incremental, false); + assertEquals(true, config.unified_repair.enabled); + assertEquals(new DurationSpec.IntSecondsBound("6h"), config.unified_repair.getUnifiedRepairTableMaxRepairTime(UnifiedRepairConfig.RepairType.incremental)); + config.unified_repair.setMVRepairEnabled(UnifiedRepairConfig.RepairType.incremental, false); } @Test @@ -497,4 +497,4 @@ public static Config load(String path) } return new YamlConfigurationLoader().loadConfig(url); } -} \ No newline at end of file +} diff --git a/test/unit/org/apache/cassandra/repair/autorepair/SSTableRepairedAtTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/SSTableRepairedAtTest.java similarity index 97% rename from test/unit/org/apache/cassandra/repair/autorepair/SSTableRepairedAtTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/SSTableRepairedAtTest.java index bd14eea805b3..14011f85896d 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/SSTableRepairedAtTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/SSTableRepairedAtTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.net.UnknownHostException; import java.util.Arrays; @@ -55,8 +55,8 @@ public class SSTableRepairedAtTest extends CQLTester public static void setUp() throws ConfigurationException, UnknownHostException { requireNetwork(); - AutoRepairUtils.setup(); - StorageService.instance.doAutoRepairSetup(); + UnifiedRepairUtils.setup(); + StorageService.instance.doUnifiedRepairSetup(); DatabaseDescriptor.setCDCEnabled(false); } diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairConfigTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfigTest.java similarity index 77% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairConfigTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfigTest.java index 4f1dd029ef5e..e7ce54a1cea5 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairConfigTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairConfigTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.EnumMap; import java.util.Objects; @@ -35,7 +35,7 @@ import org.apache.cassandra.config.ParameterizedClass; import org.apache.cassandra.cql3.CQLTester; import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.Options; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.Options; import org.apache.cassandra.utils.FBUtilities; import static org.junit.Assert.assertEquals; @@ -44,79 +44,79 @@ import static org.junit.Assert.assertTrue; @RunWith(Parameterized.class) -public class AutoRepairConfigTest extends CQLTester +public class UnifiedRepairConfigTest extends CQLTester { - private AutoRepairConfig config; + private UnifiedRepairConfig config; private Set testSet = ImmutableSet.of("dc1"); @Parameterized.Parameter - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; @Parameterized.Parameters public static Object[] repairTypes() { - return AutoRepairConfig.RepairType.values(); + return UnifiedRepairConfig.RepairType.values(); } @Before public void setUp() { - config = new AutoRepairConfig(true); + config = new UnifiedRepairConfig(true); config.repair_type_overrides = null; - AutoRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); + UnifiedRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); } @Test - public void autoRepairConfigDefaultsAreNotNull() + public void unifiedRepairConfigDefaultsAreNotNull() { - AutoRepairConfig config = new AutoRepairConfig(); + UnifiedRepairConfig config = new UnifiedRepairConfig(); assertNotNull(config.global_settings); } @Test - public void autoRepairConfigRepairTypesAreNotNull() + public void unifiedRepairConfigRepairTypesAreNotNull() { - AutoRepairConfig config = new AutoRepairConfig(); - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) + UnifiedRepairConfig config = new UnifiedRepairConfig(); + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { assertNotNull(config.repair_type_overrides.get(repairType)); } } @Test - public void testIsAutoRepairEnabledReturnsTrueWhenRepairIsEnabled() + public void testIsUnifiedRepairEnabledReturnsTrueWhenRepairIsEnabled() { config.global_settings.enabled = true; - assertTrue(config.isAutoRepairEnabled(repairType)); + assertTrue(config.isUnifiedRepairEnabled(repairType)); } @Test - public void testIsAutoRepairEnabledReturnsTrueWhenRepairIsDisabledGlobally() + public void testIsUnifiedRepairEnabledReturnsTrueWhenRepairIsDisabledGlobally() { - config = new AutoRepairConfig(false); + config = new UnifiedRepairConfig(false); config.global_settings.enabled = true; - assertFalse(config.isAutoRepairEnabled(repairType)); + assertFalse(config.isUnifiedRepairEnabled(repairType)); } @Test - public void testIsAutoRepairEnabledReturnsTrueWhenRepairIsDisabledForRepairType() + public void testIsUnifiedRepairEnabledReturnsTrueWhenRepairIsDisabledForRepairType() { config.global_settings.enabled = true; - config.repair_type_overrides = new EnumMap<>(AutoRepairConfig.RepairType.class); + config.repair_type_overrides = new EnumMap<>(UnifiedRepairConfig.RepairType.class); config.repair_type_overrides.put(repairType, new Options()); config.repair_type_overrides.get(repairType).enabled = false; - assertFalse(config.isAutoRepairEnabled(repairType)); + assertFalse(config.isUnifiedRepairEnabled(repairType)); } @Test - public void testSetAutoRepairEnabledNoMVOrCDC() + public void testSetUnifiedRepairEnabledNoMVOrCDC() { DatabaseDescriptor.setCDCEnabled(false); DatabaseDescriptor.setMaterializedViewsEnabled(false); - config.setAutoRepairEnabled(repairType, true); + config.setUnifiedRepairEnabled(repairType, true); assertTrue(config.repair_type_overrides.get(repairType).enabled); } @@ -194,19 +194,19 @@ public void testSetRepairMinFrequencyInHours() } @Test - public void testGetAutoRepairHistoryClearDeleteHostsBufferInSec() + public void testGetUnifiedRepairHistoryClearDeleteHostsBufferInSec() { config.history_clear_delete_hosts_buffer_interval = new DurationSpec.IntSecondsBound("5s"); - int result = config.getAutoRepairHistoryClearDeleteHostsBufferInterval().toSeconds(); + int result = config.getUnifiedRepairHistoryClearDeleteHostsBufferInterval().toSeconds(); assertEquals(5, result); } @Test - public void testSetAutoRepairHistoryClearDeleteHostsBufferInSec() + public void testSetUnifiedRepairHistoryClearDeleteHostsBufferInSec() { - config.setAutoRepairHistoryClearDeleteHostsBufferInterval("5s"); + config.setUnifiedRepairHistoryClearDeleteHostsBufferInterval("5s"); assert Objects.equals(config.history_clear_delete_hosts_buffer_interval, new DurationSpec.IntSecondsBound("5s")); } @@ -230,19 +230,19 @@ public void testSetRepairSSTableCountHigherThreshold() } @Test - public void testGetAutoRepairTableMaxRepairTimeInSec() + public void testGetUnifiedRepairTableMaxRepairTimeInSec() { config.global_settings.table_max_repair_time = new DurationSpec.IntSecondsBound("5s"); - DurationSpec.IntSecondsBound result = config.getAutoRepairTableMaxRepairTime(repairType); + DurationSpec.IntSecondsBound result = config.getUnifiedRepairTableMaxRepairTime(repairType); assertEquals(5, result.toSeconds()); } @Test - public void testSetAutoRepairTableMaxRepairTimeInSec() + public void testSetUnifiedRepairTableMaxRepairTimeInSec() { - config.setAutoRepairTableMaxRepairTime(repairType, "5s"); + config.setUnifiedRepairTableMaxRepairTime(repairType, "5s"); assert config.repair_type_overrides.get(repairType).table_max_repair_time.toSeconds() == 5; } @@ -356,19 +356,19 @@ public void testGetForceRepairNewNode() } @Test - public void testIsAutoRepairSchedulingEnabledDefault() + public void testIsUnifiedRepairSchedulingEnabledDefault() { - config = new AutoRepairConfig(); + config = new UnifiedRepairConfig(); - boolean result = config.isAutoRepairSchedulingEnabled(); + boolean result = config.isUnifiedRepairSchedulingEnabled(); assertFalse(result); } @Test - public void testIsAutoRepairSchedulingEnabledTrue() + public void testIsUnifiedRepairSchedulingEnabledTrue() { - boolean result = config.isAutoRepairSchedulingEnabled(); + boolean result = config.isUnifiedRepairSchedulingEnabled(); assertTrue(result); } @@ -386,16 +386,16 @@ public void testGetDefaultOptionsTokenRangeSplitter() { Options defaultOptions = Options.getDefaultOptions(); - ParameterizedClass expectedDefault = new ParameterizedClass(DefaultAutoRepairTokenSplitter.class.getName(), Collections.emptyMap()); + ParameterizedClass expectedDefault = new ParameterizedClass(DefaultUnifiedRepairTokenSplitter.class.getName(), Collections.emptyMap()); assertEquals(expectedDefault, defaultOptions.token_range_splitter); - assertEquals(DefaultAutoRepairTokenSplitter.class.getName(), FBUtilities.newAutoRepairTokenRangeSplitter(defaultOptions.token_range_splitter).getClass().getName()); + assertEquals(DefaultUnifiedRepairTokenSplitter.class.getName(), FBUtilities.newUnifiedRepairTokenRangeSplitter(defaultOptions.token_range_splitter).getClass().getName()); } @Test(expected = ConfigurationException.class) public void testInvalidTokenRangeSplitter() { - FBUtilities.newAutoRepairTokenRangeSplitter(new ParameterizedClass("invalid-class", Collections.emptyMap())); + FBUtilities.newUnifiedRepairTokenRangeSplitter(new ParameterizedClass("invalid-class", Collections.emptyMap())); } @Test diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairDefaultTokenSplitterParameterizedTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairDefaultTokenSplitterParameterizedTest.java similarity index 84% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairDefaultTokenSplitterParameterizedTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairDefaultTokenSplitterParameterizedTest.java index 804d0a712b48..f14f6acefeac 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairDefaultTokenSplitterParameterizedTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairDefaultTokenSplitterParameterizedTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.ArrayList; import java.util.Arrays; @@ -37,8 +37,8 @@ import org.apache.cassandra.dht.Range; import org.apache.cassandra.dht.Token; import org.apache.cassandra.index.sai.disk.format.Version; -import org.apache.cassandra.repair.autorepair.IAutoRepairTokenRangeSplitter.RepairAssignment; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.repair.unifiedrepair.IUnifiedRepairTokenRangeSplitter.RepairAssignment; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.service.StorageService; import org.apache.cassandra.tcm.ClusterMetadata; @@ -48,7 +48,7 @@ import static org.junit.Assert.assertEquals; @RunWith(Parameterized.class) -public class AutoRepairDefaultTokenSplitterParameterizedTest +public class UnifiedRepairDefaultTokenSplitterParameterizedTest { private static final String KEYSPACE = "ks"; private static final String TABLE1 = "tbl1"; @@ -56,12 +56,12 @@ public class AutoRepairDefaultTokenSplitterParameterizedTest private static final String TABLE3 = "tbl3"; @Parameterized.Parameter() - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; @Parameterized.Parameters(name = "repairType={0}") - public static Collection repairTypes() + public static Collection repairTypes() { - return Arrays.asList(AutoRepairConfig.RepairType.values()); + return Arrays.asList(UnifiedRepairConfig.RepairType.values()); } @BeforeClass @@ -83,7 +83,7 @@ public static void setupClass() throws Exception ServerTestUtils.registerLocal(tokens); // Ensure that the on-disk format statics are loaded before the test run Version.LATEST.onDiskFormat(); - StorageService.instance.doAutoRepairSetup(); + StorageService.instance.doUnifiedRepairSetup(); SYSTEM_DISTRIBUTED_DEFAULT_RF.setInt(1); QueryProcessor.executeInternal(String.format("CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}", KEYSPACE)); @@ -111,7 +111,7 @@ private static void appendExpectedTokens(long left, long right, int numberOfSpli @Test public void testTokenRangesSplitByTable() { - AutoRepairService.instance.getAutoRepairConfig().setRepairByKeyspace(repairType, false); + UnifiedRepairService.instance.getUnifiedRepairConfig().setRepairByKeyspace(repairType, false); int totalTokenRanges = 3; Collection> tokens = StorageService.instance.getPrimaryRanges(KEYSPACE); assertEquals(totalTokenRanges, tokens.size()); @@ -125,9 +125,9 @@ public void testTokenRangesSplitByTable() appendExpectedTokens(256, 1024, numberOfSplits, expectedToken); } - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setRepairSubRangeNum(repairType, numberOfSplits); - List assignments = new DefaultAutoRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, tables); + List assignments = new DefaultUnifiedRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, tables); assertEquals(totalTokenRanges * numberOfSplits * tables.size(), assignments.size()); assertEquals(expectedToken.size(), assignments.size()); @@ -146,7 +146,7 @@ public void testTokenRangesSplitByTable() @Test public void testTokenRangesSplitByKeyspace() { - AutoRepairService.instance.getAutoRepairConfig().setRepairByKeyspace(repairType, true); + UnifiedRepairService.instance.getUnifiedRepairConfig().setRepairByKeyspace(repairType, true); int totalTokenRanges = 3; Collection> tokens = StorageService.instance.getPrimaryRanges(KEYSPACE); assertEquals(totalTokenRanges, tokens.size()); @@ -157,9 +157,9 @@ public void testTokenRangesSplitByKeyspace() appendExpectedTokens(0, 256, numberOfSplits, expectedToken); appendExpectedTokens(256, 1024, numberOfSplits, expectedToken); - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setRepairSubRangeNum(repairType, numberOfSplits); - List assignments = new DefaultAutoRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, tables); + List assignments = new DefaultUnifiedRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, tables); assertEquals(totalTokenRanges * numberOfSplits, assignments.size()); assertEquals(expectedToken.size(), assignments.size()); diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairKeyspaceTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairKeyspaceTest.java similarity index 87% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairKeyspaceTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairKeyspaceTest.java index 1337cf3dd2d3..748cc88b2a2e 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairKeyspaceTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairKeyspaceTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.HashSet; import java.util.Iterator; @@ -29,7 +29,7 @@ import org.apache.cassandra.config.DatabaseDescriptor; -public class AutoRepairKeyspaceTest +public class UnifiedRepairKeyspaceTest { @BeforeClass public static void setupDatabaseDescriptor() @@ -38,7 +38,7 @@ public static void setupDatabaseDescriptor() } @Test - public void testEnsureAutoRepairTablesArePresent() + public void testEnsureUnifiedRepairTablesArePresent() { KeyspaceMetadata keyspaceMetadata = SystemDistributedKeyspace.metadata(); Iterator iter = keyspaceMetadata.tables.iterator(); @@ -48,7 +48,7 @@ public void testEnsureAutoRepairTablesArePresent() actualDistributedTablesIter.add(iter.next().name); } - Assert.assertTrue(actualDistributedTablesIter.contains(SystemDistributedKeyspace.AUTO_REPAIR_HISTORY)); - Assert.assertTrue(actualDistributedTablesIter.contains(SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY)); + Assert.assertTrue(actualDistributedTablesIter.contains(SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY)); + Assert.assertTrue(actualDistributedTablesIter.contains(SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY)); } } diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairParameterizedTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairParameterizedTest.java similarity index 52% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairParameterizedTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairParameterizedTest.java index 3ec202f23e19..4a8d375f5988 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairParameterizedTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairParameterizedTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.ArrayList; import java.util.Arrays; @@ -37,7 +37,7 @@ import org.apache.cassandra.dht.Token; import org.apache.cassandra.repair.RepairCoordinator; import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.repair.autorepair.IAutoRepairTokenRangeSplitter.RepairAssignment; +import org.apache.cassandra.repair.unifiedrepair.IUnifiedRepairTokenRangeSplitter.RepairAssignment; import org.apache.cassandra.schema.SystemDistributedKeyspace; import org.apache.cassandra.service.StorageService; @@ -56,20 +56,20 @@ import org.apache.cassandra.db.ColumnFamilyStore; import org.apache.cassandra.db.Keyspace; import org.apache.cassandra.io.sstable.format.SSTableReader; -import org.apache.cassandra.metrics.AutoRepairMetricsManager; -import org.apache.cassandra.metrics.AutoRepairMetrics; +import org.apache.cassandra.metrics.UnifiedRepairMetricsManager; +import org.apache.cassandra.metrics.UnifiedRepairMetrics; import org.apache.cassandra.schema.SchemaConstants; import org.apache.cassandra.schema.TableMetadata; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.utils.FBUtilities; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.MockitoAnnotations; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.apache.cassandra.config.CassandraRelevantProperties.SYSTEM_DISTRIBUTED_DEFAULT_RF; import static org.apache.cassandra.metrics.CassandraMetricsRegistry.Metrics; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.RepairTurn.NOT_MY_TURN; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.RepairTurn.NOT_MY_TURN; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -81,43 +81,43 @@ import static org.mockito.Mockito.when; @RunWith(Parameterized.class) -public class AutoRepairParameterizedTest extends CQLTester +public class UnifiedRepairParameterizedTest extends CQLTester { private static final String KEYSPACE = "ks"; private static final String TABLE = "tbl"; - private static final String TABLE_DISABLED_AUTO_REPAIR = "tbl_disabled_auto_repair"; + private static final String TABLE_DISABLED_UNIFIED_REPAIR = "tbl_disabled_unified_repair"; private static final String MV = "mv"; private static TableMetadata cfm; - private static TableMetadata cfmDisabledAutoRepair; + private static TableMetadata cfmDisabledUnifiedRepair; private static Keyspace keyspace; private static int timeFuncCalls; @Mock ScheduledExecutorPlus mockExecutor; @Mock - AutoRepairState autoRepairState; + UnifiedRepairState unifiedRepairState; @Mock RepairCoordinator repairRunnable; - private static AutoRepairConfig defaultConfig; + private static UnifiedRepairConfig defaultConfig; @Parameterized.Parameter() - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; @Parameterized.Parameters(name = "repairType={0}") - public static Collection repairTypes() + public static Collection repairTypes() { - return Arrays.asList(AutoRepairConfig.RepairType.values()); + return Arrays.asList(UnifiedRepairConfig.RepairType.values()); } @BeforeClass public static void setupClass() throws Exception { SYSTEM_DISTRIBUTED_DEFAULT_RF.setInt(1); - AutoRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); - setAutoRepairEnabled(true); + UnifiedRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); + setUnifiedRepairEnabled(true); requireNetwork(); - AutoRepairUtils.setup(); - StorageService.instance.doAutoRepairSetup(); + UnifiedRepairUtils.setup(); + StorageService.instance.doUnifiedRepairSetup(); DatabaseDescriptor.setCDCEnabled(false); } @@ -127,7 +127,7 @@ public void setup() SYSTEM_DISTRIBUTED_DEFAULT_RF.setInt(1); QueryProcessor.executeInternal(String.format("CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}", KEYSPACE)); QueryProcessor.executeInternal(String.format("CREATE TABLE %s.%s (k text, s text static, i int, v text, primary key(k,i))", KEYSPACE, TABLE)); - QueryProcessor.executeInternal(String.format("CREATE TABLE %s.%s (k text, s text static, i int, v text, primary key(k,i)) WITH repair_full = {'enabled': 'false'} AND repair_incremental = {'enabled': 'false'}", KEYSPACE, TABLE_DISABLED_AUTO_REPAIR)); + QueryProcessor.executeInternal(String.format("CREATE TABLE %s.%s (k text, s text static, i int, v text, primary key(k,i)) WITH repair_full = {'enabled': 'false'} AND repair_incremental = {'enabled': 'false'}", KEYSPACE, TABLE_DISABLED_UNIFIED_REPAIR)); QueryProcessor.executeInternal(String.format("CREATE MATERIALIZED VIEW %s.%s AS SELECT i, k from %s.%s " + "WHERE k IS NOT null AND i IS NOT null PRIMARY KEY (i, k)", KEYSPACE, MV, KEYSPACE, TABLE)); @@ -142,23 +142,23 @@ public void setup() Keyspace.open(KEYSPACE).getColumnFamilyStore(MV).truncateBlocking(); Keyspace.open(KEYSPACE).getColumnFamilyStore(MV).disableAutoCompaction(); - Keyspace.open(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME).getColumnFamilyStore(SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY).truncateBlocking(); - Keyspace.open(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME).getColumnFamilyStore(SystemDistributedKeyspace.AUTO_REPAIR_HISTORY).truncateBlocking(); + Keyspace.open(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME).getColumnFamilyStore(SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY).truncateBlocking(); + Keyspace.open(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME).getColumnFamilyStore(SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY).truncateBlocking(); - AutoRepair.instance = new AutoRepair(); + UnifiedRepair.instance = new UnifiedRepair(); executeCQL(); timeFuncCalls = 0; - AutoRepair.timeFunc = System::currentTimeMillis; + UnifiedRepair.timeFunc = System::currentTimeMillis; resetCounters(); resetConfig(); - AutoRepair.shuffleFunc = java.util.Collections::shuffle; + UnifiedRepair.shuffleFunc = java.util.Collections::shuffle; keyspace = Keyspace.open(KEYSPACE); cfm = Keyspace.open(KEYSPACE).getColumnFamilyStore(TABLE).metadata(); - cfmDisabledAutoRepair = Keyspace.open(KEYSPACE).getColumnFamilyStore(TABLE_DISABLED_AUTO_REPAIR).metadata(); + cfmDisabledUnifiedRepair = Keyspace.open(KEYSPACE).getColumnFamilyStore(TABLE_DISABLED_UNIFIED_REPAIR).metadata(); DatabaseDescriptor.setCDCOnRepairEnabled(false); } @@ -170,7 +170,7 @@ public void tearDown() private void resetCounters() { - AutoRepairMetrics metrics = AutoRepairMetricsManager.getMetrics(repairType); + UnifiedRepairMetrics metrics = UnifiedRepairMetricsManager.getMetrics(repairType); Metrics.removeMatching((name, metric) -> name.startsWith("repairTurn")); metrics.repairTurnMyTurn = Metrics.counter(String.format("repairTurnMyTurn-%s", repairType)); metrics.repairTurnMyTurnForceRepair = Metrics.counter(String.format("repairTurnMyTurnForceRepair-%s", repairType)); @@ -180,15 +180,15 @@ private void resetCounters() private void resetConfig() { // prepare a fresh default config - defaultConfig = new AutoRepairConfig(true); - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) + defaultConfig = new UnifiedRepairConfig(true); + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { - defaultConfig.setAutoRepairEnabled(repairType, true); + defaultConfig.setUnifiedRepairEnabled(repairType, true); defaultConfig.setMVRepairEnabled(repairType, false); } - // reset the AutoRepairService config to default - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + // reset the UnifiedRepairService config to default + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.repair_type_overrides = defaultConfig.repair_type_overrides; config.global_settings = defaultConfig.global_settings; config.history_clear_delete_hosts_buffer_interval = defaultConfig.history_clear_delete_hosts_buffer_interval; @@ -200,24 +200,24 @@ private void executeCQL() QueryProcessor.executeInternal("INSERT INTO ks.tbl (k, s) VALUES ('k', 's')"); QueryProcessor.executeInternal("SELECT s FROM ks.tbl WHERE k='k'"); Keyspace.open(SchemaConstants.DISTRIBUTED_KEYSPACE_NAME) - .getColumnFamilyStore(SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY) + .getColumnFamilyStore(SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY) .forceBlockingFlush(ColumnFamilyStore.FlushReason.UNIT_TESTS); } @Test(expected = ConfigurationException.class) public void testRepairAsyncWithRepairTypeDisabled() { - AutoRepairService.instance.getAutoRepairConfig().setAutoRepairEnabled(repairType, false); + UnifiedRepairService.instance.getUnifiedRepairConfig().setUnifiedRepairEnabled(repairType, false); - AutoRepair.instance.repairAsync(repairType); + UnifiedRepair.instance.repairAsync(repairType); } @Test public void testRepairAsync() { - AutoRepair.instance.repairExecutors.put(repairType, mockExecutor); + UnifiedRepair.instance.repairExecutors.put(repairType, mockExecutor); - AutoRepair.instance.repairAsync(repairType); + UnifiedRepair.instance.repairAsync(repairType); verify(mockExecutor, Mockito.times(1)).submit(any(Runnable.class)); } @@ -226,17 +226,17 @@ public void testRepairAsync() public void testRepairTurn() { UUID myId = StorageService.instance.getHostIdForEndpoint(FBUtilities.getBroadcastAddressAndPort()); - Assert.assertTrue("Expected my turn for the repair", AutoRepairUtils.myTurnToRunRepair(repairType, myId) != NOT_MY_TURN); + Assert.assertTrue("Expected my turn for the repair", UnifiedRepairUtils.myTurnToRunRepair(repairType, myId) != NOT_MY_TURN); } @Test public void testRepair() { - AutoRepairService.instance.getAutoRepairConfig().setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repair(repairType); - assertEquals(0, AutoRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); - long lastRepairTime = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + UnifiedRepairService.instance.getUnifiedRepairConfig().setRepairMinInterval(repairType, "0s"); + UnifiedRepair.instance.repair(repairType); + assertEquals(0, UnifiedRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + long lastRepairTime = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); //if repair was done then lastRepairTime should be non-zero Assert.assertTrue(String.format("Expected lastRepairTime > 0, actual value lastRepairTime %d", lastRepairTime), lastRepairTime > 0); @@ -245,113 +245,113 @@ public void testRepair() @Test public void testTooFrequentRepairs() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); //in the first round let repair run config.setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repair(repairType); - long lastRepairTime1 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); - int consideredTables = AutoRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair(); + UnifiedRepair.instance.repair(repairType); + long lastRepairTime1 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); + int consideredTables = UnifiedRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair(); Assert.assertNotSame(String.format("Expected total repaired tables > 0, actual value %s ", consideredTables), consideredTables, 0); //if repair was done in last 24 hours then it should not trigger another repair config.setRepairMinInterval(repairType, "24h"); - AutoRepair.instance.repair(repairType); - long lastRepairTime2 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + UnifiedRepair.instance.repair(repairType); + long lastRepairTime2 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); Assert.assertEquals(String.format("Expected repair time to be same, actual value lastRepairTime1 %d, " + "lastRepairTime2 %d", lastRepairTime1, lastRepairTime2), lastRepairTime1, lastRepairTime2); - assertEquals(0, AutoRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + assertEquals(0, UnifiedRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); } @Test public void testNonFrequentRepairs() { - Integer prevMetricsCount = AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); - AutoRepairState state = AutoRepair.instance.repairStates.get(repairType); + Integer prevMetricsCount = UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); + UnifiedRepairState state = UnifiedRepair.instance.repairStates.get(repairType); long prevCount = state.getTotalMVTablesConsideredForRepair(); - AutoRepairService.instance.getAutoRepairConfig().setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repair(repairType); - long lastRepairTime1 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + UnifiedRepairService.instance.getUnifiedRepairConfig().setRepairMinInterval(repairType, "0s"); + UnifiedRepair.instance.repair(repairType); + long lastRepairTime1 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); Assert.assertTrue(String.format("Expected lastRepairTime1 > 0, actual value lastRepairTime1 %d", lastRepairTime1), lastRepairTime1 > 0); UUID myId = StorageService.instance.getHostIdForEndpoint(FBUtilities.getBroadcastAddressAndPort()); Assert.assertTrue("Expected my turn for the repair", - AutoRepairUtils.myTurnToRunRepair(repairType, myId) != NOT_MY_TURN); - AutoRepair.instance.repair(repairType); - long lastRepairTime2 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + UnifiedRepairUtils.myTurnToRunRepair(repairType, myId) != NOT_MY_TURN); + UnifiedRepair.instance.repair(repairType); + long lastRepairTime2 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); Assert.assertNotSame(String.format("Expected repair time to be same, actual value lastRepairTime1 %d, " + "lastRepairTime2 ", lastRepairTime1, lastRepairTime2), lastRepairTime1, lastRepairTime2); assertEquals(prevCount, state.getTotalMVTablesConsideredForRepair()); - assertEquals(prevMetricsCount, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); + assertEquals(prevMetricsCount, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); } @Test public void testGetPriorityHosts() { - Integer prevMetricsCount = AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); - AutoRepairState state = AutoRepair.instance.repairStates.get(repairType); + Integer prevMetricsCount = UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); + UnifiedRepairState state = UnifiedRepair.instance.repairStates.get(repairType); long prevCount = state.getTotalMVTablesConsideredForRepair(); - AutoRepairService.instance.getAutoRepairConfig().setRepairMinInterval(repairType, "0s"); + UnifiedRepairService.instance.getUnifiedRepairConfig().setRepairMinInterval(repairType, "0s"); Assert.assertSame(String.format("Priority host count is not same, actual value %d, expected value %d", - AutoRepairUtils.getPriorityHosts(repairType).size(), 0), AutoRepairUtils.getPriorityHosts(repairType).size(), 0); + UnifiedRepairUtils.getPriorityHosts(repairType).size(), 0), UnifiedRepairUtils.getPriorityHosts(repairType).size(), 0); UUID myId = StorageService.instance.getHostIdForEndpoint(FBUtilities.getBroadcastAddressAndPort()); - Assert.assertTrue("Expected my turn for the repair", AutoRepairUtils.myTurnToRunRepair(repairType, myId) != + Assert.assertTrue("Expected my turn for the repair", UnifiedRepairUtils.myTurnToRunRepair(repairType, myId) != NOT_MY_TURN); - AutoRepair.instance.repair(repairType); - AutoRepairUtils.addPriorityHosts(repairType, Sets.newHashSet(FBUtilities.getBroadcastAddressAndPort())); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); + UnifiedRepairUtils.addPriorityHosts(repairType, Sets.newHashSet(FBUtilities.getBroadcastAddressAndPort())); + UnifiedRepair.instance.repair(repairType); Assert.assertSame(String.format("Priority host count is not same actual value %d, expected value %d", - AutoRepairUtils.getPriorityHosts(repairType).size(), 0), AutoRepairUtils.getPriorityHosts(repairType).size(), 0); + UnifiedRepairUtils.getPriorityHosts(repairType).size(), 0), UnifiedRepairUtils.getPriorityHosts(repairType).size(), 0); assertEquals(prevCount, state.getTotalMVTablesConsideredForRepair()); - assertEquals(prevMetricsCount, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); + assertEquals(prevMetricsCount, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); } @Test - public void testCheckAutoRepairStartStop() throws Throwable + public void testCheckUnifiedRepairStartStop() throws Throwable { - Integer prevMetricsCount = AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); - AutoRepairState state = AutoRepair.instance.repairStates.get(repairType); - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + Integer prevMetricsCount = UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue(); + UnifiedRepairState state = UnifiedRepair.instance.repairStates.get(repairType); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); long prevCount = state.getTotalMVTablesConsideredForRepair(); config.setRepairMinInterval(repairType, "0s"); - config.setAutoRepairEnabled(repairType, false); - long lastRepairTime1 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); - AutoRepair.instance.repair(repairType); - long lastRepairTime2 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + config.setUnifiedRepairEnabled(repairType, false); + long lastRepairTime1 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); + UnifiedRepair.instance.repair(repairType); + long lastRepairTime2 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); //Since repair has not happened, both the last repair times should be same Assert.assertEquals(String.format("Expected lastRepairTime1 %d, and lastRepairTime2 %d to be same", lastRepairTime1, lastRepairTime2), lastRepairTime1, lastRepairTime2); - config.setAutoRepairEnabled(repairType, true); - AutoRepair.instance.repair(repairType); + config.setUnifiedRepairEnabled(repairType, true); + UnifiedRepair.instance.repair(repairType); //since repair is done now, so lastRepairTime1/lastRepairTime2 and lastRepairTime3 should not be same - long lastRepairTime3 = AutoRepair.instance.repairStates.get(repairType).getLastRepairTime(); + long lastRepairTime3 = UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime(); Assert.assertNotSame(String.format("Expected lastRepairTime1 %d, and lastRepairTime3 %d to be not same", lastRepairTime1, lastRepairTime2), lastRepairTime1, lastRepairTime3); assertEquals(prevCount, state.getTotalMVTablesConsideredForRepair()); - assertEquals(prevMetricsCount, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); + assertEquals(prevMetricsCount, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue()); } @Test public void testRepairPrimaryRangesByDefault() { Assert.assertTrue("Expected primary range repair only", - AutoRepairService.instance.getAutoRepairConfig().getRepairPrimaryTokenRangeOnly(repairType)); + UnifiedRepairService.instance.getUnifiedRepairConfig().getRepairPrimaryTokenRangeOnly(repairType)); } @Test public void testGetAllMVs() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setMVRepairEnabled(repairType, false); assertFalse(config.getMVRepairEnabled(repairType)); - assertEquals(0, AutoRepairUtils.getAllMVs(repairType, keyspace, cfm).size()); + assertEquals(0, UnifiedRepairUtils.getAllMVs(repairType, keyspace, cfm).size()); config.setMVRepairEnabled(repairType, true); assertTrue(config.getMVRepairEnabled(repairType)); - assertEquals(Arrays.asList(MV), AutoRepairUtils.getAllMVs(repairType, keyspace, cfm)); + assertEquals(Arrays.asList(MV), UnifiedRepairUtils.getAllMVs(repairType, keyspace, cfm)); config.setMVRepairEnabled(repairType, false); } @@ -359,32 +359,32 @@ public void testGetAllMVs() @Test public void testMVRepair() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setMVRepairEnabled(repairType, true); config.setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); - AutoRepair.instance.repair(repairType); - assertEquals(1, AutoRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + UnifiedRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); + UnifiedRepair.instance.repair(repairType); + assertEquals(1, UnifiedRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); config.setMVRepairEnabled(repairType, false); - AutoRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); - AutoRepair.instance.repair(repairType); - assertEquals(0, AutoRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + UnifiedRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); + UnifiedRepair.instance.repair(repairType); + assertEquals(0, UnifiedRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); config.setMVRepairEnabled(repairType, true); - AutoRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); - AutoRepair.instance.repair(repairType); - assertEquals(1, AutoRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + UnifiedRepair.instance.repairStates.get(repairType).setLastRepairTime(System.currentTimeMillis()); + UnifiedRepair.instance.repair(repairType); + assertEquals(1, UnifiedRepair.instance.repairStates.get(repairType).getTotalMVTablesConsideredForRepair()); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); } @Test public void testSkipRepairSSTableCountHigherThreshold() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); - AutoRepairState state = AutoRepair.instance.repairStates.get(repairType); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); + UnifiedRepairState state = UnifiedRepair.instance.repairStates.get(repairType); ColumnFamilyStore cfsBaseTable = Keyspace.open(KEYSPACE).getColumnFamilyStore(TABLE); ColumnFamilyStore cfsMVTable = Keyspace.open(KEYSPACE).getColumnFamilyStore(MV); Set preBaseTable = cfsBaseTable.getLiveSSTables(); @@ -412,89 +412,89 @@ public void testSkipRepairSSTableCountHigherThreshold() config.setMVRepairEnabled(repairType, true); config.setRepairSSTableCountHigherThreshold(repairType, 9); assertEquals(0, state.getSkippedTokenRangesCount()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); state.setLastRepairTime(0); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); assertEquals(0, state.getTotalMVTablesConsideredForRepair()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); // skipping both the tables - one table is due to its repair has been disabled, and another one due to high sstable count assertEquals(0, state.getSkippedTokenRangesCount()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); assertEquals(2, state.getSkippedTablesCount()); - assertEquals(2, AutoRepairMetricsManager.getMetrics(repairType).skippedTablesCount.getValue().intValue()); + assertEquals(2, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTablesCount.getValue().intValue()); // set it to higher value, and this time, the tables should not be skipped config.setRepairSSTableCountHigherThreshold(repairType, beforeCount); state.setLastRepairTime(0); state.setSkippedTablesCount(0); state.setTotalMVTablesConsideredForRepair(0); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); assertEquals(1, state.getTotalMVTablesConsideredForRepair()); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); assertEquals(0, state.getSkippedTokenRangesCount()); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); assertEquals(1, state.getSkippedTablesCount()); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).skippedTablesCount.getValue().intValue()); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTablesCount.getValue().intValue()); } @Test public void testGetRepairState() { - assertEquals(0, AutoRepair.instance.repairStates.get(repairType).getRepairKeyspaceCount()); + assertEquals(0, UnifiedRepair.instance.repairStates.get(repairType).getRepairKeyspaceCount()); - AutoRepairState state = AutoRepair.instance.getRepairState(repairType); + UnifiedRepairState state = UnifiedRepair.instance.getRepairState(repairType); state.setRepairKeyspaceCount(100); - assertEquals(100L, AutoRepair.instance.getRepairState(repairType).getRepairKeyspaceCount()); + assertEquals(100L, UnifiedRepair.instance.getRepairState(repairType).getRepairKeyspaceCount()); } @Test public void testMetrics() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setMVRepairEnabled(repairType, true); config.setRepairMinInterval(repairType, "0s"); - config.setAutoRepairTableMaxRepairTime(repairType, "0s"); - AutoRepair.timeFunc = () -> { + config.setUnifiedRepairTableMaxRepairTime(repairType, "0s"); + UnifiedRepair.timeFunc = () -> { timeFuncCalls++; return timeFuncCalls * 1000L; }; - AutoRepair.instance.repairStates.get(repairType).setLastRepairTime(1000L); + UnifiedRepair.instance.repairStates.get(repairType).setLastRepairTime(1000L); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).nodeRepairTimeInSec.getValue() > 0); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).clusterRepairTimeInSec.getValue() > 0); - assertEquals(1, AutoRepairMetricsManager.getMetrics(repairType).repairTurnMyTurn.getCount()); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue() > 0); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).longestUnrepairedSec.getValue().intValue()); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).totalMVTablesConsideredForRepair.getValue().intValue()); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).nodeRepairTimeInSec.getValue() > 0); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).clusterRepairTimeInSec.getValue() > 0); + assertEquals(1, UnifiedRepairMetricsManager.getMetrics(repairType).repairTurnMyTurn.getCount()); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue() > 0); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).longestUnrepairedSec.getValue().intValue()); - config.setAutoRepairTableMaxRepairTime(repairType, String.valueOf(Integer.MAX_VALUE-1) + 's'); - AutoRepair.instance.repairStates.put(repairType, autoRepairState); - when(autoRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())) + config.setUnifiedRepairTableMaxRepairTime(repairType, String.valueOf(Integer.MAX_VALUE - 1) + 's'); + UnifiedRepair.instance.repairStates.put(repairType, unifiedRepairState); + when(unifiedRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())) .thenReturn(repairRunnable); - when(autoRepairState.getFailedTokenRangesCount()).thenReturn(10); - when(autoRepairState.getSucceededTokenRangesCount()).thenReturn(11); - when(autoRepairState.getLongestUnrepairedSec()).thenReturn(10); + when(unifiedRepairState.getFailedTokenRangesCount()).thenReturn(10); + when(unifiedRepairState.getSucceededTokenRangesCount()).thenReturn(11); + when(unifiedRepairState.getLongestUnrepairedSec()).thenReturn(10); - AutoRepair.instance.repair(repairType); - assertEquals(0, AutoRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).failedTokenRangesCount.getValue() > 0); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).succeededTokenRangesCount.getValue() > 0); - assertTrue(AutoRepairMetricsManager.getMetrics(repairType).longestUnrepairedSec.getValue() > 0); + UnifiedRepair.instance.repair(repairType); + assertEquals(0, UnifiedRepairMetricsManager.getMetrics(repairType).skippedTokenRangesCount.getValue().intValue()); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).failedTokenRangesCount.getValue() > 0); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).succeededTokenRangesCount.getValue() > 0); + assertTrue(UnifiedRepairMetricsManager.getMetrics(repairType).longestUnrepairedSec.getValue() > 0); } @Test public void testRepairWaitsForRepairToFinishBeforeSchedullingNewSession() throws Exception { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setMVRepairEnabled(repairType, false); config.setRepairRetryBackoff("0s"); - when(autoRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())) + when(unifiedRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())) .thenReturn(repairRunnable); - AutoRepair.instance.repairStates.put(repairType, autoRepairState); - when(autoRepairState.getLastRepairTime()).thenReturn((long) 0); + UnifiedRepair.instance.repairStates.put(repairType, unifiedRepairState); + when(unifiedRepairState.getLastRepairTime()).thenReturn((long) 0); AtomicInteger resetWaitConditionCalls = new AtomicInteger(); AtomicInteger waitForRepairCompletedCalls = new AtomicInteger(); doAnswer(invocation -> { @@ -502,36 +502,36 @@ public void testRepairWaitsForRepairToFinishBeforeSchedullingNewSession() throws assertEquals("waitForRepairToComplete was called before resetWaitCondition", resetWaitConditionCalls.get(), waitForRepairCompletedCalls.get() + 1); return null; - }).when(autoRepairState).resetWaitCondition(); + }).when(unifiedRepairState).resetWaitCondition(); doAnswer(invocation -> { waitForRepairCompletedCalls.getAndIncrement(); assertEquals("resetWaitCondition was not called before waitForRepairToComplete", resetWaitConditionCalls.get(), waitForRepairCompletedCalls.get()); return null; - }).when(autoRepairState).waitForRepairToComplete(config.getRepairSessionTimeout(repairType)); + }).when(unifiedRepairState).waitForRepairToComplete(config.getRepairSessionTimeout(repairType)); - AutoRepair.instance.repair(repairType); - AutoRepair.instance.repair(repairType); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); } @Test - public void testDisabledAutoRepairForATableThroughTableLevelConfiguration() + public void testDisabledUnifiedRepairForATableThroughTableLevelConfiguration() { - Assert.assertTrue(cfm.params.automatedRepair.get(AutoRepairConfig.RepairType.full).repairEnabled()); - Assert.assertTrue(cfm.params.automatedRepair.get(AutoRepairConfig.RepairType.incremental).repairEnabled()); - Assert.assertFalse(cfmDisabledAutoRepair.params.automatedRepair.get(AutoRepairConfig.RepairType.full).repairEnabled()); - Assert.assertFalse(cfmDisabledAutoRepair.params.automatedRepair.get(AutoRepairConfig.RepairType.incremental).repairEnabled()); + Assert.assertTrue(cfm.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full).repairEnabled()); + Assert.assertTrue(cfm.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).repairEnabled()); + Assert.assertFalse(cfmDisabledUnifiedRepair.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full).repairEnabled()); + Assert.assertFalse(cfmDisabledUnifiedRepair.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).repairEnabled()); - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setRepairMinInterval(repairType, "0s"); - int disabledTablesRepairCountBefore = AutoRepair.instance.repairStates.get(repairType).getTotalDisabledTablesRepairCount(); - AutoRepair.instance.repair(repairType); - int consideredTables = AutoRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair(); + int disabledTablesRepairCountBefore = UnifiedRepair.instance.repairStates.get(repairType).getTotalDisabledTablesRepairCount(); + UnifiedRepair.instance.repair(repairType); + int consideredTables = UnifiedRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair(); Assert.assertNotSame(String.format("Expected total repaired tables > 0, actual value %s ", consideredTables), consideredTables, 0); - int disabledTablesRepairCountAfter = AutoRepair.instance.repairStates.get(repairType).getTotalDisabledTablesRepairCount(); - Assert.assertTrue(String.format("A table %s should be skipped from auto repair, expected value: %d, actual value %d ", TABLE_DISABLED_AUTO_REPAIR, disabledTablesRepairCountBefore + 1, disabledTablesRepairCountAfter), + int disabledTablesRepairCountAfter = UnifiedRepair.instance.repairStates.get(repairType).getTotalDisabledTablesRepairCount(); + Assert.assertTrue(String.format("A table %s should be skipped from unified repair, expected value: %d, actual value %d ", TABLE_DISABLED_UNIFIED_REPAIR, disabledTablesRepairCountBefore + 1, disabledTablesRepairCountAfter), disabledTablesRepairCountBefore < disabledTablesRepairCountAfter); } @@ -542,7 +542,7 @@ public void testTokenRangesNoSplit() assertEquals(1, tokens.size()); List> expectedToken = new ArrayList<>(tokens); - List assignments = new DefaultAutoRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, Collections.singletonList(TABLE)); + List assignments = new DefaultUnifiedRepairTokenSplitter().getRepairAssignments(repairType, true, KEYSPACE, Collections.singletonList(TABLE)); assertEquals(1, assignments.size()); assertEquals(expectedToken.get(0).left, assignments.get(0).getTokenRange().left); assertEquals(expectedToken.get(0).right, assignments.get(0).getTokenRange().right); @@ -556,12 +556,12 @@ public void testTableAttribute() } @Test - public void testDefaultAutomatedRepair() + public void testDefaultUnifiedRepair() { - Assert.assertTrue(cfm.params.automatedRepair.get(AutoRepairConfig.RepairType.full).repairEnabled()); - Assert.assertTrue(cfm.params.automatedRepair.get(AutoRepairConfig.RepairType.incremental).repairEnabled()); - Assert.assertFalse(cfmDisabledAutoRepair.params.automatedRepair.get(AutoRepairConfig.RepairType.full).repairEnabled()); - Assert.assertFalse(cfmDisabledAutoRepair.params.automatedRepair.get(AutoRepairConfig.RepairType.incremental).repairEnabled()); + Assert.assertTrue(cfm.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full).repairEnabled()); + Assert.assertTrue(cfm.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).repairEnabled()); + Assert.assertFalse(cfmDisabledUnifiedRepair.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.full).repairEnabled()); + Assert.assertFalse(cfmDisabledUnifiedRepair.params.unifiedRepair.get(UnifiedRepairConfig.RepairType.incremental).repairEnabled()); } @Test @@ -569,7 +569,7 @@ public void testRepairShufflesKeyspacesAndTables() { AtomicInteger shuffleKeyspacesCall = new AtomicInteger(); AtomicInteger shuffleTablesCall = new AtomicInteger(); - AutoRepair.shuffleFunc = (List list) -> { + UnifiedRepair.shuffleFunc = (List list) -> { if (!list.isEmpty()) { assertTrue(list.get(0) instanceof Keyspace || list.get(0) instanceof String); @@ -585,9 +585,9 @@ else if (list.get(0) instanceof String) } }; - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); assertEquals(1, shuffleKeyspacesCall.get()); assertEquals(5, shuffleTablesCall.get()); @@ -596,88 +596,88 @@ else if (list.get(0) instanceof String) @Test public void testRepairTakesLastRepairTimeFromDB() { - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); config.setMVRepairEnabled(repairType, true); long lastRepairTime = System.currentTimeMillis() - 1000; - AutoRepairUtils.insertNewRepairHistory(repairType, 0, lastRepairTime); - AutoRepair.instance.repairStates.get(repairType).setLastRepairTime(0); + UnifiedRepairUtils.insertNewRepairHistory(repairType, 0, lastRepairTime); + UnifiedRepair.instance.repairStates.get(repairType).setLastRepairTime(0); config.setRepairMinInterval(repairType, "1h"); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); // repair scheduler should not attempt to run repair as last repair time in DB is current time - 1s - assertEquals(0, AutoRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair()); + assertEquals(0, UnifiedRepair.instance.repairStates.get(repairType).getTotalTablesConsideredForRepair()); // repair scheduler should load the repair time from the DB - assertEquals(lastRepairTime, AutoRepair.instance.repairStates.get(repairType).getLastRepairTime()); + assertEquals(lastRepairTime, UnifiedRepair.instance.repairStates.get(repairType).getLastRepairTime()); } @Test public void testRepairMaxRetries() { - when(autoRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())).thenReturn(repairRunnable); - when(autoRepairState.isSuccess()).thenReturn(false); - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + when(unifiedRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())).thenReturn(repairRunnable); + when(unifiedRepairState.isSuccess()).thenReturn(false); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); AtomicInteger sleepCalls = new AtomicInteger(); - AutoRepair.sleepFunc = (Long duration, TimeUnit unit) -> { + UnifiedRepair.sleepFunc = (Long duration, TimeUnit unit) -> { sleepCalls.getAndIncrement(); assertEquals(TimeUnit.SECONDS, unit); assertEquals(config.getRepairRetryBackoff().toSeconds(), (long) duration); }; config.setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repairStates.put(repairType, autoRepairState); + UnifiedRepair.instance.repairStates.put(repairType, unifiedRepairState); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); //system_auth.role_permissions,system_auth.network_permissions,system_auth.role_members,system_auth.roles, // system_auth.resource_role_permissons_index,system_traces.sessions,system_traces.events,ks.tbl, - // system_distributed.auto_repair_priority,system_distributed.repair_history,system_distributed.auto_repair_history, + // system_distributed.unified_repair_priority,system_distributed.repair_history,system_distributed.unified_repair_history, // system_distributed.view_build_status,system_distributed.parent_repair_history,system_distributed.partition_denylist int exptedTablesGoingThroughRepair = 18; assertEquals(config.getRepairMaxRetries()*exptedTablesGoingThroughRepair, sleepCalls.get()); - verify(autoRepairState, Mockito.times(1)).setSucceededTokenRangesCount(0); - verify(autoRepairState, Mockito.times(1)).setSkippedTokenRangesCount(0); - verify(autoRepairState, Mockito.times(1)).setFailedTokenRangesCount(exptedTablesGoingThroughRepair); + verify(unifiedRepairState, Mockito.times(1)).setSucceededTokenRangesCount(0); + verify(unifiedRepairState, Mockito.times(1)).setSkippedTokenRangesCount(0); + verify(unifiedRepairState, Mockito.times(1)).setFailedTokenRangesCount(exptedTablesGoingThroughRepair); } @Test public void testRepairSuccessAfterRetry() { - when(autoRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())).thenReturn(repairRunnable); + when(unifiedRepairState.getRepairRunnable(any(), any(), any(), anyBoolean())).thenReturn(repairRunnable); - AutoRepairConfig config = AutoRepairService.instance.getAutoRepairConfig(); + UnifiedRepairConfig config = UnifiedRepairService.instance.getUnifiedRepairConfig(); AtomicInteger sleepCalls = new AtomicInteger(); - AutoRepair.sleepFunc = (Long duration, TimeUnit unit) -> { + UnifiedRepair.sleepFunc = (Long duration, TimeUnit unit) -> { sleepCalls.getAndIncrement(); assertEquals(TimeUnit.SECONDS, unit); assertEquals(config.getRepairRetryBackoff().toSeconds(), (long) duration); }; - when(autoRepairState.isSuccess()).then((invocationOnMock) -> { + when(unifiedRepairState.isSuccess()).then((invocationOnMock) -> { if (sleepCalls.get() == 0) { return false; } return true; }); config.setRepairMinInterval(repairType, "0s"); - AutoRepair.instance.repairStates.put(repairType, autoRepairState); - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repairStates.put(repairType, unifiedRepairState); + UnifiedRepair.instance.repair(repairType); assertEquals(1, sleepCalls.get()); - verify(autoRepairState, Mockito.times(1)).setSucceededTokenRangesCount(18); - verify(autoRepairState, Mockito.times(1)).setSkippedTokenRangesCount(0); - verify(autoRepairState, Mockito.times(1)).setFailedTokenRangesCount(0); + verify(unifiedRepairState, Mockito.times(1)).setSucceededTokenRangesCount(18); + verify(unifiedRepairState, Mockito.times(1)).setSkippedTokenRangesCount(0); + verify(unifiedRepairState, Mockito.times(1)).setFailedTokenRangesCount(0); } @Test public void testRepairThrowsForIRWithMVReplay() { - AutoRepair.instance.setup(); + UnifiedRepair.instance.setup(); DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(true); - if (repairType == AutoRepairConfig.RepairType.incremental) + if (repairType == UnifiedRepairConfig.RepairType.incremental) { try { - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); fail("Expected ConfigurationException"); } catch (ConfigurationException ignored) @@ -686,7 +686,7 @@ public void testRepairThrowsForIRWithMVReplay() } else { - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); } } @@ -694,14 +694,14 @@ public void testRepairThrowsForIRWithMVReplay() @Test public void testRepairThrowsForIRWithCDCReplay() { - AutoRepair.instance.setup(); + UnifiedRepair.instance.setup(); DatabaseDescriptor.setCDCOnRepairEnabled(true); - if (repairType == AutoRepairConfig.RepairType.incremental) + if (repairType == UnifiedRepairConfig.RepairType.incremental) { try { - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); fail("Expected ConfigurationException"); } catch (ConfigurationException ignored) @@ -710,7 +710,7 @@ public void testRepairThrowsForIRWithCDCReplay() } else { - AutoRepair.instance.repair(repairType); + UnifiedRepair.instance.repair(repairType); } } } diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateFactoryTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateFactoryTest.java similarity index 76% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateFactoryTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateFactoryTest.java index a0e5bdc45294..c1ee56e1065d 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateFactoryTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateFactoryTest.java @@ -16,24 +16,24 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import org.junit.Test; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; -public class AutoRepairStateFactoryTest +public class UnifiedRepairStateFactoryTest { @Test public void testGetRepairState() { - AutoRepairState state = RepairType.getAutoRepairState(RepairType.full); + UnifiedRepairState state = RepairType.getUnifiedRepairState(RepairType.full); assert state instanceof FullRepairState; - state = RepairType.getAutoRepairState(RepairType.incremental); + state = RepairType.getUnifiedRepairState(RepairType.incremental); assert state instanceof IncrementalRepairState; } @@ -42,7 +42,7 @@ public void testGetRepairState() { public void testGetRepairStateSupportsAllRepairTypes() { for (RepairType repairType : RepairType.values()) { try { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); assertNotNull(state); } catch (IllegalArgumentException e) { assertNull(e); diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateTest.java similarity index 72% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateTest.java index f0974dd83c1a..df60ffc4e484 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairStateTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairStateTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.Arrays; import java.util.Collection; @@ -33,9 +33,9 @@ import org.apache.cassandra.config.DurationSpec; import org.apache.cassandra.cql3.CQLTester; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils.AutoRepairHistory; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.UnifiedRepairHistory; +import org.apache.cassandra.service.UnifiedRepairService; import org.apache.cassandra.utils.concurrent.Condition; import org.apache.cassandra.utils.progress.ProgressEvent; import org.apache.cassandra.utils.progress.ProgressEventType; @@ -50,7 +50,7 @@ import static org.mockito.MockitoAnnotations.initMocks; @RunWith(Parameterized.class) -public class AutoRepairStateTest extends CQLTester +public class UnifiedRepairStateTest extends CQLTester { private static final String testTable = "test"; @@ -68,15 +68,15 @@ public static Collection repairTypes() @Before public void setUp() { - AutoRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); + UnifiedRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); initMocks(this); createTable(String.format("CREATE TABLE IF NOT EXISTS %s.%s (pk int PRIMARY KEY, v int)", KEYSPACE, testTable)); } @Test public void testGetRepairRunnable() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); - AutoRepairService.setup(); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); + UnifiedRepairService.setup(); Runnable runnable = state.getRepairRunnable(KEYSPACE, ImmutableList.of(testTable), ImmutableSet.of(), false); @@ -86,7 +86,7 @@ public void testGetRepairRunnable() { @Test public void testProgressError() throws InterruptedException { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); when(progressEvent.getType()).thenReturn(ProgressEventType.ERROR); state.progress("test", progressEvent); @@ -98,7 +98,7 @@ public void testProgressError() throws InterruptedException @Test public void testProgress_progress() throws InterruptedException { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); when(progressEvent.getType()).thenReturn(ProgressEventType.PROGRESS); state.progress("test", progressEvent); @@ -111,7 +111,7 @@ public void testProgress_progress() throws InterruptedException @Test public void testProgress_complete() throws InterruptedException { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); when(progressEvent.getType()).thenReturn(ProgressEventType.COMPLETE); state.progress("test", progressEvent); @@ -123,7 +123,7 @@ public void testProgress_complete() throws InterruptedException @Test public void testWaitForRepairToComplete() throws Exception { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.condition.signalAll(); Condition finishedCondition = Condition.newOneTimeCondition(); Callable waitForRepairToComplete = () -> { @@ -139,7 +139,7 @@ public void testWaitForRepairToComplete() throws Exception @Test public void testGetLastRepairTime() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.lastRepairTimeInMs = 1; assertEquals(1, state.getLastRepairTime()); @@ -147,7 +147,7 @@ public void testGetLastRepairTime() { @Test public void testSetTotalTablesConsideredForRepair() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setTotalTablesConsideredForRepair(1); @@ -156,7 +156,7 @@ public void testSetTotalTablesConsideredForRepair() { @Test public void testGetTotalTablesConsideredForRepair() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.totalTablesConsideredForRepair = 1; assertEquals(1, state.getTotalTablesConsideredForRepair()); @@ -164,7 +164,7 @@ public void testGetTotalTablesConsideredForRepair() { @Test public void testSetLastRepairTimeInMs() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setLastRepairTime(1); @@ -173,7 +173,7 @@ public void testSetLastRepairTimeInMs() { @Test public void testGetClusterRepairTimeInSec() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.clusterRepairTimeInSec = 1; assertEquals(1, state.getClusterRepairTimeInSec()); @@ -181,7 +181,7 @@ public void testGetClusterRepairTimeInSec() { @Test public void testGetNodeRepairTimeInSec() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.nodeRepairTimeInSec = 1; assertEquals(1, state.getNodeRepairTimeInSec()); @@ -189,7 +189,7 @@ public void testGetNodeRepairTimeInSec() { @Test public void testSetRepairInProgress() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setRepairInProgress(true); @@ -198,7 +198,7 @@ public void testSetRepairInProgress() { @Test public void testIsRepairInProgress() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.repairInProgress = true; assertTrue(state.isRepairInProgress()); @@ -206,7 +206,7 @@ public void testIsRepairInProgress() { @Test public void testSetSkippedTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setSkippedTokenRangesCount(1); @@ -215,7 +215,7 @@ public void testSetSkippedTokenRangesCount() { @Test public void testGetSkippedTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.skippedTokenRangesCount = 1; assertEquals(1, state.getSkippedTokenRangesCount()); @@ -223,7 +223,7 @@ public void testGetSkippedTokenRangesCount() { @Test public void testGetLongestUnrepairedSecNull() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.longestUnrepairedNode = null; try @@ -236,10 +236,10 @@ public void testGetLongestUnrepairedSecNull() { @Test public void testGetLongestUnrepairedSec() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); - state.longestUnrepairedNode = new AutoRepairHistory(UUID.randomUUID(), "", 0, 1000, - null, 0, false); - AutoRepairState.timeFunc = () -> 2000L; + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); + state.longestUnrepairedNode = new UnifiedRepairHistory(UUID.randomUUID(), "", 0, 1000, + null, 0, false); + UnifiedRepairState.timeFunc = () -> 2000L; try { @@ -251,7 +251,7 @@ public void testGetLongestUnrepairedSec() { @Test public void testSetTotalMVTablesConsideredForRepair() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setTotalMVTablesConsideredForRepair(1); @@ -260,7 +260,7 @@ public void testSetTotalMVTablesConsideredForRepair() { @Test public void testGetTotalMVTablesConsideredForRepair() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.totalMVTablesConsideredForRepair = 1; assertEquals(1, state.getTotalMVTablesConsideredForRepair()); @@ -268,7 +268,7 @@ public void testGetTotalMVTablesConsideredForRepair() { @Test public void testSetNodeRepairTimeInSec() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setNodeRepairTimeInSec(1); @@ -277,7 +277,7 @@ public void testSetNodeRepairTimeInSec() { @Test public void testSetClusterRepairTimeInSec() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setClusterRepairTimeInSec(1); @@ -286,7 +286,7 @@ public void testSetClusterRepairTimeInSec() { @Test public void testSetRepairKeyspaceCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setRepairKeyspaceCount(1); @@ -294,7 +294,7 @@ public void testSetRepairKeyspaceCount() { } @Test public void testGetRepairKeyspaceCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.repairKeyspaceCount = 1; assertEquals(1, state.getRepairKeyspaceCount()); @@ -302,8 +302,8 @@ public void testGetRepairKeyspaceCount() { @Test public void testSetLongestUnrepairedNode() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); - AutoRepairHistory history = new AutoRepairHistory(UUID.randomUUID(), "", 0, 0, null, 0, false); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); + UnifiedRepairHistory history = new UnifiedRepairHistory(UUID.randomUUID(), "", 0, 0, null, 0, false); state.setLongestUnrepairedNode(history); @@ -312,7 +312,7 @@ public void testSetLongestUnrepairedNode() { @Test public void testSetSucceededTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setSucceededTokenRangesCount(1); @@ -321,7 +321,7 @@ public void testSetSucceededTokenRangesCount() { @Test public void testGetSucceededTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.succeededTokenRangesCount = 1; assertEquals(1, state.getSucceededTokenRangesCount()); @@ -329,7 +329,7 @@ public void testGetSucceededTokenRangesCount() { @Test public void testSetFailedTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.setFailedTokenRangesCount(1); @@ -338,7 +338,7 @@ public void testSetFailedTokenRangesCount() { @Test public void testGetFailedTokenRangesCount() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.failedTokenRangesCount = 1; assertEquals(1, state.getFailedTokenRangesCount()); @@ -346,7 +346,7 @@ public void testGetFailedTokenRangesCount() { @Test public void isSuccess() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.success = true; assertTrue(state.isSuccess()); @@ -359,7 +359,7 @@ public void isSuccess() { @Test public void testWaitForRepairToCompleteDoesNotSetSuccessWhenProgressReceivesError() throws InterruptedException { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); when(progressEvent.getType()).thenReturn(ProgressEventType.ERROR); state.progress("test", progressEvent); @@ -372,7 +372,7 @@ public void testWaitForRepairToCompleteDoesNotSetSuccessWhenProgressReceivesErro @Test public void testResetWaitCondition() { - AutoRepairState state = RepairType.getAutoRepairState(repairType); + UnifiedRepairState state = RepairType.getUnifiedRepairState(repairType); state.condition.signalAll(); assertTrue(state.condition.isSignalled()); diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairTest.java similarity index 79% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairTest.java index df9f105b615f..4e6e755a09f4 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.HashMap; import java.util.Map; @@ -34,38 +34,38 @@ import org.apache.cassandra.schema.KeyspaceMetadata; import org.apache.cassandra.schema.KeyspaceParams; import org.apache.cassandra.schema.ReplicationParams; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; import org.apache.cassandra.schema.SchemaTestUtil; -import org.apache.cassandra.service.AutoRepairService; +import org.apache.cassandra.service.UnifiedRepairService; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertTrue; -public class AutoRepairTest extends CQLTester +public class UnifiedRepairTest extends CQLTester { @BeforeClass public static void setupClass() throws Exception { - setAutoRepairEnabled(true); + setUnifiedRepairEnabled(true); requireNetwork(); } @Before public void setup() { - AutoRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); + UnifiedRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); DatabaseDescriptor.setCDCOnRepairEnabled(false); DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(RepairType.full, true); - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(RepairType.incremental, true); - AutoRepairService.setup(); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(RepairType.full, true); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(RepairType.incremental, true); + UnifiedRepairService.setup(); } @Test public void testSetup() { - AutoRepair instance = new AutoRepair(); + UnifiedRepair instance = new UnifiedRepair(); instance.setup(); assertEquals(RepairType.values().length, instance.repairExecutors.size()); @@ -81,7 +81,7 @@ public void testSetup() @Test public void testSafeGuardSetupCall() { - AutoRepair instance = new AutoRepair(); + UnifiedRepair instance = new UnifiedRepair(); // only one should be setup, and rest should be ignored instance.setup(); @@ -101,22 +101,22 @@ public void testSafeGuardSetupCall() @Test(expected = ConfigurationException.class) public void testSetupFailsWhenIREnabledWithCDCReplay() { - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(RepairType.incremental, true); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(RepairType.incremental, true); DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(true); DatabaseDescriptor.setCDCEnabled(true); DatabaseDescriptor.setCDCOnRepairEnabled(true); - AutoRepair instance = new AutoRepair(); + UnifiedRepair instance = new UnifiedRepair(); instance.setup(); } @Test(expected = ConfigurationException.class) public void testSetupFailsWhenIREnabledWithMVReplay() { - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(RepairType.incremental, true); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(RepairType.incremental, true); DatabaseDescriptor.setCDCOnRepairEnabled(false); DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(true); - AutoRepair instance = new AutoRepair(); + UnifiedRepair instance = new UnifiedRepair(); instance.setup(); } @@ -141,14 +141,14 @@ public void testCheckNTSreplicationNodeInsideOutsideDC() // case 1 : // node reside in "datacenter1" // keyspace has replica in "datacenter1" - Assert.assertTrue(AutoRepairUtils.checkNodeContainsKeyspaceReplica(ks)); + Assert.assertTrue(UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(ks)); } else if (ks.getName().equals(ksname2)) { // case 2 : // node reside in "datacenter1" // keyspace has replica in "datacenter2" - Assert.assertFalse(AutoRepairUtils.checkNodeContainsKeyspaceReplica(ks)); + Assert.assertFalse(UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(ks)); } } } diff --git a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairUtilsTest.java b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtilsTest.java similarity index 70% rename from test/unit/org/apache/cassandra/repair/autorepair/AutoRepairUtilsTest.java rename to test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtilsTest.java index 9a3c551c9bf6..2b6bd0e14114 100644 --- a/test/unit/org/apache/cassandra/repair/autorepair/AutoRepairUtilsTest.java +++ b/test/unit/org/apache/cassandra/repair/unifiedrepair/UnifiedRepairUtilsTest.java @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.cassandra.repair.autorepair; +package org.apache.cassandra.repair.unifiedrepair; import java.util.List; import java.util.Set; @@ -36,9 +36,9 @@ import org.apache.cassandra.db.marshal.UUIDType; import org.apache.cassandra.locator.IEndpointSnitch; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig.RepairType; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils.AutoRepairHistory; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils.CurrentRepairStatus; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig.RepairType; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.UnifiedRepairHistory; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.CurrentRepairStatus; import org.apache.cassandra.cql3.CQLTester; import org.apache.cassandra.cql3.QueryProcessor; @@ -49,14 +49,14 @@ import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.apache.cassandra.config.CassandraRelevantProperties.SYSTEM_DISTRIBUTED_DEFAULT_RF; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_DELETE_HOSTS; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_FORCE_REPAIR; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_REPAIR_FINISH_TS; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_REPAIR_PRIORITY; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_REPAIR_START_TS; -import static org.apache.cassandra.repair.autorepair.AutoRepairUtils.COL_REPAIR_TURN; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_DELETE_HOSTS; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_FORCE_REPAIR; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_REPAIR_FINISH_TS; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_REPAIR_PRIORITY; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_REPAIR_START_TS; +import static org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils.COL_REPAIR_TURN; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -64,7 +64,7 @@ import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.when; -public class AutoRepairUtilsTest extends CQLTester +public class UnifiedRepairUtilsTest extends CQLTester { static RepairType repairType = RepairType.incremental; static UUID hostId; @@ -80,12 +80,12 @@ public class AutoRepairUtilsTest extends CQLTester public static void setupClass() throws Exception { SYSTEM_DISTRIBUTED_DEFAULT_RF.setInt(1); - setAutoRepairEnabled(true); + setUnifiedRepairEnabled(true); requireNetwork(); defaultSnitch = DatabaseDescriptor.getEndpointSnitch(); localEndpoint = FBUtilities.getBroadcastAddressAndPort(); hostId = StorageService.instance.getHostIdForEndpoint(localEndpoint); - StorageService.instance.doAutoRepairSetup(); + StorageService.instance.doUnifiedRepairSetup(); } @Before @@ -95,15 +95,15 @@ public void setup() QueryProcessor.executeInternal(String.format("CREATE KEYSPACE %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}", "ks")); QueryProcessor.executeInternal(String.format("CREATE TABLE %s.%s (k text, s text static, i int, v text, primary key(k,i))", "ks", "tbl")); - AutoRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); + UnifiedRepair.SLEEP_IF_REPAIR_FINISHES_QUICKLY = new DurationSpec.IntSecondsBound("0s"); MockitoAnnotations.initMocks(this); DatabaseDescriptor.setEndpointSnitch(defaultSnitch); QueryProcessor.executeInternal(String.format( "TRUNCATE %s.%s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY)); + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY)); QueryProcessor.executeInternal(String.format( "TRUNCATE %s.%s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY)); + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY)); } @Test @@ -111,14 +111,14 @@ public void testSetForceRepair() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, force_repair) VALUES ('%s', %s, false)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); - AutoRepairUtils.setForceRepair(repairType, ImmutableSet.of(localEndpoint)); + UnifiedRepairUtils.setForceRepair(repairType, ImmutableSet.of(localEndpoint)); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT force_repair FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(1, result.size()); @@ -128,11 +128,11 @@ public void testSetForceRepair() @Test public void testSetForceRepairNewNode() { - AutoRepairUtils.setForceRepairNewNode(repairType); + UnifiedRepairUtils.setForceRepairNewNode(repairType); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT force_repair FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(1, result.size()); @@ -145,14 +145,14 @@ public void testClearDeleteHosts() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, delete_hosts, delete_hosts_update_time) VALUES ('%s', %s, { %s }, toTimestamp(now()))", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId, hostId)); - AutoRepairUtils.clearDeleteHosts(repairType, hostId); + UnifiedRepairUtils.clearDeleteHosts(repairType, hostId); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT delete_hosts FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(1, result.size()); @@ -161,23 +161,23 @@ public void testClearDeleteHosts() } @Test - public void testGetAutoRepairHistoryForLocalGroup() + public void testGetUnifiedRepairHistoryForLocalGroup() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, force_repair) VALUES ('%s', %s, false)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); - List history = AutoRepairUtils.getAutoRepairHistory(repairType); + List history = UnifiedRepairUtils.getUnifiedRepairHistory(repairType); assertNotNull(history); assertEquals(1, history.size()); assertEquals(hostId, history.get(0).hostId); } @Test - public void testGetAutoRepairHistoryForLocalGroup_empty_history() + public void testGetUnifiedRepairHistoryForLocalGroup_empty_history() { - List history = AutoRepairUtils.getAutoRepairHistory(repairType); + List history = UnifiedRepairUtils.getUnifiedRepairHistory(repairType); assertNull(history); } @@ -189,22 +189,22 @@ public void testGetCurrentRepairStatus() UUID regularRepair = UUID.randomUUID(); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, force_repair, repair_start_ts) VALUES ('%s', %s, true, toTimestamp(now()))", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), forceRepair)); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, repair_start_ts) VALUES ('%s', %s, toTimestamp(now()))", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), regularRepair)); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, repair_priority) VALUES ('%s', { %s })", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, repairType.toString(), regularRepair)); - CurrentRepairStatus status = AutoRepairUtils.getCurrentRepairStatus(repairType); + CurrentRepairStatus status = UnifiedRepairUtils.getCurrentRepairStatus(repairType); assertNotNull(status); assertEquals(1, status.historiesWithoutOnGoingRepair.size()); @@ -220,7 +220,7 @@ public void testGetCurrentRepairStatus() @Test public void testGetHostIdsInCurrentRing() { - TreeSet hosts = AutoRepairUtils.getHostIdsInCurrentRing(repairType); + TreeSet hosts = UnifiedRepairUtils.getHostIdsInCurrentRing(repairType); assertNotNull(hosts); assertEquals(1, hosts.size()); @@ -232,13 +232,13 @@ public void testGetHostIdsInCurrentRing_multiple_nodes() { InetAddressAndPort ignoredEndpoint = localEndpoint.withPort(localEndpoint.getPort() + 1); InetAddressAndPort deadEndpoint = localEndpoint.withPort(localEndpoint.getPort() + 2); - DatabaseDescriptor.getAutoRepairConfig().setIgnoreDCs(repairType, ImmutableSet.of("dc2")); + DatabaseDescriptor.getUnifiedRepairConfig().setIgnoreDCs(repairType, ImmutableSet.of("dc2")); DatabaseDescriptor.setEndpointSnitch(snitchMock); when(snitchMock.getDatacenter(localEndpoint)).thenReturn("dc1"); when(snitchMock.getDatacenter(ignoredEndpoint)).thenReturn("dc2"); when(snitchMock.getDatacenter(deadEndpoint)).thenReturn("dc1"); - TreeSet hosts = AutoRepairUtils.getHostIdsInCurrentRing(repairType, ImmutableSet.of(new NodeAddresses(localEndpoint), new NodeAddresses(ignoredEndpoint), new NodeAddresses(deadEndpoint))); + TreeSet hosts = UnifiedRepairUtils.getHostIdsInCurrentRing(repairType, ImmutableSet.of(new NodeAddresses(localEndpoint), new NodeAddresses(ignoredEndpoint), new NodeAddresses(deadEndpoint))); assertNotNull(hosts); assertEquals(1, hosts.size()); @@ -251,93 +251,93 @@ public void testGetHostWithLongestUnrepairTime() UUID otherHostId = UUID.randomUUID(); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id, repair_finish_ts) VALUES ('%s', %s, toTimestamp(now()))", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), otherHostId)); - AutoRepairHistory history = AutoRepairUtils.getHostWithLongestUnrepairTime(repairType); + UnifiedRepairHistory history = UnifiedRepairUtils.getHostWithLongestUnrepairTime(repairType); assertEquals(hostId, history.hostId); } @Test - public void testGetMaxNumberOfNodeRunAutoRepairInGroup_0_group_size() + public void testGetMaxNumberOfNodeRunUnifiedRepairInGroup_0_group_size() { - DatabaseDescriptor.getAutoRepairConfig().setParallelRepairCount(repairType, 2); + DatabaseDescriptor.getUnifiedRepairConfig().setParallelRepairCount(repairType, 2); - int count = AutoRepairUtils.getMaxNumberOfNodeRunAutoRepair(repairType, 0); + int count = UnifiedRepairUtils.getMaxNumberOfNodeRunUnifiedRepair(repairType, 0); assertEquals(2, count); } @Test - public void testGetMaxNumberOfNodeRunAutoRepairInGroup_percentage() + public void testGetMaxNumberOfNodeRunUnifiedRepairInGroup_percentage() { - DatabaseDescriptor.getAutoRepairConfig().setParallelRepairCount(repairType, 2); - DatabaseDescriptor.getAutoRepairConfig().setParallelRepairPercentage(repairType, 50); + DatabaseDescriptor.getUnifiedRepairConfig().setParallelRepairCount(repairType, 2); + DatabaseDescriptor.getUnifiedRepairConfig().setParallelRepairPercentage(repairType, 50); - int count = AutoRepairUtils.getMaxNumberOfNodeRunAutoRepair(repairType, 10); + int count = UnifiedRepairUtils.getMaxNumberOfNodeRunUnifiedRepair(repairType, 10); assertEquals(5, count); } @Test - public void testDeleteAutoRepairHistory() + public void testDeleteUnifiedRepairHistory() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); - AutoRepairUtils.deleteAutoRepairHistory(repairType, hostId); + UnifiedRepairUtils.deleteUnifiedRepairHistory(repairType, hostId); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT * FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(0, result.size()); } @Test - public void testUpdateStartAutoRepairHistory() + public void testUpdateStartUnifiedRepairHistory() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); - AutoRepairUtils.updateStartAutoRepairHistory(repairType, hostId, 123, AutoRepairUtils.RepairTurn.MY_TURN); + UnifiedRepairUtils.updateStartUnifiedRepairHistory(repairType, hostId, 123, UnifiedRepairUtils.RepairTurn.MY_TURN); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT repair_start_ts, repair_turn FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(1, result.size()); UntypedResultSet.Row row = result.one(); assertEquals(123, row.getLong(COL_REPAIR_START_TS, 0)); - assertEquals(AutoRepairUtils.RepairTurn.MY_TURN.toString(), row.getString(COL_REPAIR_TURN)); + assertEquals(UnifiedRepairUtils.RepairTurn.MY_TURN.toString(), row.getString(COL_REPAIR_TURN)); } @Test - public void testUpdateFinishAutoRepairHistory() + public void testUpdateFinishUnifiedRepairHistory() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); - AutoRepairUtils.updateFinishAutoRepairHistory(repairType, hostId, 123); + UnifiedRepairUtils.updateFinishUnifiedRepairHistory(repairType, hostId, 123); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT repair_finish_ts FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), hostId)); assertNotNull(result); assertEquals(1, result.size()); @@ -350,14 +350,14 @@ public void testAddHostIdToDeleteHosts() UUID otherHostId = UUID.randomUUID(); QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, host_id) VALUES ('%s', %s)", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), otherHostId)); - AutoRepairUtils.addHostIdToDeleteHosts(repairType, hostId, otherHostId); + UnifiedRepairUtils.addHostIdToDeleteHosts(repairType, hostId, otherHostId); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT * FROM %s.%s WHERE repair_type = '%s' AND host_id = %s", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, repairType.toString(), otherHostId)); assertNotNull(result); assertEquals(1, result.size()); @@ -370,11 +370,11 @@ public void testAddHostIdToDeleteHosts() @Test public void testAddPriorityHost() { - AutoRepairUtils.addPriorityHosts(repairType, ImmutableSet.of(localEndpoint)); + UnifiedRepairUtils.addPriorityHosts(repairType, ImmutableSet.of(localEndpoint)); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT * FROM %s.%s WHERE repair_type = '%s'", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, repairType.toString())); assertNotNull(result); assertEquals(1, result.size()); @@ -389,14 +389,14 @@ public void testRemovePriorityStatus() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, repair_priority) VALUES ('%s', { %s })", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, repairType.toString(), hostId)); - AutoRepairUtils.removePriorityStatus(repairType, hostId); + UnifiedRepairUtils.removePriorityStatus(repairType, hostId); UntypedResultSet result = QueryProcessor.executeInternal(String.format( "SELECT * FROM %s.%s WHERE repair_type = '%s'", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, repairType.toString())); assertNotNull(result); assertEquals(1, result.size()); @@ -409,10 +409,10 @@ public void testGetPriorityHosts() { QueryProcessor.executeInternal(String.format( "INSERT INTO %s.%s (repair_type, repair_priority) VALUES ('%s', { %s })", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_PRIORITY, + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_PRIORITY, repairType.toString(), hostId)); - Set hosts = AutoRepairUtils.getPriorityHosts(repairType); + Set hosts = UnifiedRepairUtils.getPriorityHosts(repairType); assertNotNull(hosts); assertEquals(1, hosts.size()); @@ -424,29 +424,29 @@ public void testCheckNodeContainsKeyspaceReplica() { Keyspace ks = Keyspace.open("ks"); - assertTrue(AutoRepairUtils.checkNodeContainsKeyspaceReplica(ks)); + assertTrue(UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(ks)); } @Test public void testTableMaxRepairTimeExceeded() { - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairTableMaxRepairTime(repairType, "0s"); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairTableMaxRepairTime(repairType, "0s"); - assertTrue(AutoRepairUtils.tableMaxRepairTimeExceeded(repairType, 0)); + assertTrue(UnifiedRepairUtils.tableMaxRepairTimeExceeded(repairType, 0)); } @Test public void testKeyspaceMaxRepairTimeExceeded() { - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairTableMaxRepairTime(repairType, "0s"); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairTableMaxRepairTime(repairType, "0s"); - assertTrue(AutoRepairUtils.keyspaceMaxRepairTimeExceeded(repairType, 0, 1)); + assertTrue(UnifiedRepairUtils.keyspaceMaxRepairTimeExceeded(repairType, 0, 1)); } @Test public void testGetLastRepairFinishTime() { - AutoRepairHistory history = new AutoRepairHistory(UUID.randomUUID(), "", 0, 0, null, 0, false); + UnifiedRepairHistory history = new UnifiedRepairHistory(UUID.randomUUID(), "", 0, 0, null, 0, false); assertEquals(0, history.getLastRepairFinishTime()); @@ -460,21 +460,21 @@ public void testMyTurnToRunRepairShouldReturnMyTurnWhenRepairOngoing() { UUID myID = UUID.randomUUID(); UUID otherID = UUID.randomUUID(); - DatabaseDescriptor.getAutoRepairConfig().setParallelRepairCount(repairType, 5); + DatabaseDescriptor.getUnifiedRepairConfig().setParallelRepairCount(repairType, 5); long currentMillis = System.currentTimeMillis(); // finish time less than start time means that repair is ongoing - AutoRepairUtils.insertNewRepairHistory(repairType, myID, currentMillis, currentMillis - 100); + UnifiedRepairUtils.insertNewRepairHistory(repairType, myID, currentMillis, currentMillis - 100); // finish time is larger than start time means that repair for other node is finished - AutoRepairUtils.insertNewRepairHistory(repairType, otherID, currentMillis, currentMillis + 100); + UnifiedRepairUtils.insertNewRepairHistory(repairType, otherID, currentMillis, currentMillis + 100); - assertEquals(AutoRepairUtils.RepairTurn.MY_TURN, AutoRepairUtils.myTurnToRunRepair(repairType, myID)); + assertEquals(UnifiedRepairUtils.RepairTurn.MY_TURN, UnifiedRepairUtils.myTurnToRunRepair(repairType, myID)); } @Test public void testLocalStrategyAndNetworkKeyspace() { - assertFalse(AutoRepairUtils.checkNodeContainsKeyspaceReplica(Keyspace.open("system"))); - assertTrue(AutoRepairUtils.checkNodeContainsKeyspaceReplica(Keyspace.open(KEYSPACE))); + assertFalse(UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(Keyspace.open("system"))); + assertTrue(UnifiedRepairUtils.checkNodeContainsKeyspaceReplica(Keyspace.open(KEYSPACE))); } @Test @@ -483,10 +483,10 @@ public void testGetLastRepairTimeForNode() UUID myID = UUID.randomUUID(); UUID otherID = UUID.randomUUID(); long currentMillis = System.currentTimeMillis(); - AutoRepairUtils.insertNewRepairHistory(repairType, myID, currentMillis, currentMillis - 100); - AutoRepairUtils.insertNewRepairHistory(repairType, otherID, currentMillis, currentMillis + 100); + UnifiedRepairUtils.insertNewRepairHistory(repairType, myID, currentMillis, currentMillis - 100); + UnifiedRepairUtils.insertNewRepairHistory(repairType, otherID, currentMillis, currentMillis + 100); - assertEquals(currentMillis - 100, AutoRepairUtils.getLastRepairTimeForNode(repairType, myID)); + assertEquals(currentMillis - 100, UnifiedRepairUtils.getLastRepairTimeForNode(repairType, myID)); } @Test @@ -494,6 +494,6 @@ public void testGetLastRepairTimeForNodeWhenHistoryIsEmpty() { UUID myID = UUID.randomUUID(); - assertEquals(0, AutoRepairUtils.getLastRepairTimeForNode(repairType, myID)); + assertEquals(0, UnifiedRepairUtils.getLastRepairTimeForNode(repairType, myID)); } } diff --git a/test/unit/org/apache/cassandra/service/AutoRepairServiceBasicTest.java b/test/unit/org/apache/cassandra/service/AutoRepairServiceBasicTest.java deleted file mode 100644 index 054f136dad75..000000000000 --- a/test/unit/org/apache/cassandra/service/AutoRepairServiceBasicTest.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * 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.cassandra.service; - -import org.junit.Before; -import org.junit.Test; - -import org.apache.cassandra.config.DatabaseDescriptor; -import org.apache.cassandra.cql3.CQLTester; -import org.apache.cassandra.exceptions.ConfigurationException; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; - -import static org.junit.Assert.assertEquals; - -public class AutoRepairServiceBasicTest extends CQLTester { - private static AutoRepairService autoRepairService; - private static AutoRepairConfig config; - - @Before - public void setUp() { - DatabaseDescriptor.setCDCOnRepairEnabled(false); - DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); - DatabaseDescriptor.setMaterializedViewsEnabled(false); - DatabaseDescriptor.setCDCEnabled(false); - config = new AutoRepairConfig(); - autoRepairService = new AutoRepairService(); - autoRepairService.config = config; - } - - @Test - public void testSetup() { - AutoRepairService.instance.config = null; - - AutoRepairService.setup(); - - assertEquals(DatabaseDescriptor.getAutoRepairConfig(), AutoRepairService.instance.config); - } - - @Test - public void testGetAutoRepairConfigReturnsConfig() { - assertEquals(config, autoRepairService.getAutoRepairConfig()); - } - - @Test - public void testsetAutoRepairHistoryClearDeleteHostsBufferInSecV2() { - autoRepairService.setAutoRepairHistoryClearDeleteHostsBufferDuration("100s"); - - assertEquals(100, config.getAutoRepairHistoryClearDeleteHostsBufferInterval().toSeconds()); - } - - - @Test - public void testsetAutoRepairMaxRetriesCount() { - autoRepairService.setAutoRepairMaxRetriesCount(101); - - assertEquals(101, config.getRepairMaxRetries()); - } - - - @Test - public void testsetAutoRepairRetryBackoffInSec() { - autoRepairService.setAutoRepairRetryBackoff("102s"); - - assertEquals(102, config.getRepairRetryBackoff().toSeconds()); - } - - @Test(expected = ConfigurationException.class) - public void testSetAutoRepairEnabledThrowsWithSchedulerDisabled() { - autoRepairService.config = new AutoRepairConfig(false); - - autoRepairService.setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - } - - @Test(expected = ConfigurationException.class) - public void testSetAutoRepairEnabledThrowsForIRWithMVReplay() { - autoRepairService.config = new AutoRepairConfig(true); - DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(true); - autoRepairService.setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - } - - @Test - public void testSetAutoRepairEnabledDoesNotThrowForIRWithMVReplayDisabled() { - autoRepairService.config = new AutoRepairConfig(true); - DatabaseDescriptor.setMaterializedViewsEnabled(true); - DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); - autoRepairService.setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - } - - @Test(expected = ConfigurationException.class) - public void testSetAutoRepairEnabledThrowsForIRWithCDCReplay() { - autoRepairService.config = new AutoRepairConfig(true); - DatabaseDescriptor.setCDCOnRepairEnabled(true); - autoRepairService.setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - } - - @Test - public void testSetAutoRepairEnabledDoesNotThrowForIRWithCDCReplayDisabled() { - autoRepairService.config = new AutoRepairConfig(true); - DatabaseDescriptor.setCDCEnabled(true); - autoRepairService.setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - } -} diff --git a/test/unit/org/apache/cassandra/service/UnifiedRepairServiceBasicTest.java b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceBasicTest.java new file mode 100644 index 000000000000..dc7c91d0edef --- /dev/null +++ b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceBasicTest.java @@ -0,0 +1,118 @@ +/* + * 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.cassandra.service; + +import org.junit.Before; +import org.junit.Test; + +import org.apache.cassandra.config.DatabaseDescriptor; +import org.apache.cassandra.cql3.CQLTester; +import org.apache.cassandra.exceptions.ConfigurationException; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; + +import static org.junit.Assert.assertEquals; + +public class UnifiedRepairServiceBasicTest extends CQLTester { + private static UnifiedRepairService unifiedRepairService; + private static UnifiedRepairConfig config; + + @Before + public void setUp() { + DatabaseDescriptor.setCDCOnRepairEnabled(false); + DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); + DatabaseDescriptor.setMaterializedViewsEnabled(false); + DatabaseDescriptor.setCDCEnabled(false); + config = new UnifiedRepairConfig(); + unifiedRepairService = new UnifiedRepairService(); + unifiedRepairService.config = config; + } + + @Test + public void testSetup() { + UnifiedRepairService.instance.config = null; + + UnifiedRepairService.setup(); + + assertEquals(DatabaseDescriptor.getUnifiedRepairConfig(), UnifiedRepairService.instance.config); + } + + @Test + public void testGetUnifiedRepairConfigReturnsConfig() { + assertEquals(config, unifiedRepairService.getUnifiedRepairConfig()); + } + + @Test + public void testsetUnifiedRepairHistoryClearDeleteHostsBufferInSecV2() { + unifiedRepairService.setUnifiedRepairHistoryClearDeleteHostsBufferDuration("100s"); + + assertEquals(100, config.getUnifiedRepairHistoryClearDeleteHostsBufferInterval().toSeconds()); + } + + + @Test + public void testsetUnifiedRepairMaxRetriesCount() { + unifiedRepairService.setUnifiedRepairMaxRetriesCount(101); + + assertEquals(101, config.getRepairMaxRetries()); + } + + + @Test + public void testsetUnifiedRepairRetryBackoffInSec() { + unifiedRepairService.setUnifiedRepairRetryBackoff("102s"); + + assertEquals(102, config.getRepairRetryBackoff().toSeconds()); + } + + @Test(expected = ConfigurationException.class) + public void testSetUnifiedRepairEnabledThrowsWithSchedulerDisabled() { + unifiedRepairService.config = new UnifiedRepairConfig(false); + + unifiedRepairService.setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + } + + @Test(expected = ConfigurationException.class) + public void testSetUnifiedRepairEnabledThrowsForIRWithMVReplay() { + unifiedRepairService.config = new UnifiedRepairConfig(true); + DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(true); + unifiedRepairService.setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + } + + @Test + public void testSetUnifiedRepairEnabledDoesNotThrowForIRWithMVReplayDisabled() { + unifiedRepairService.config = new UnifiedRepairConfig(true); + DatabaseDescriptor.setMaterializedViewsEnabled(true); + DatabaseDescriptor.setMaterializedViewsOnRepairEnabled(false); + unifiedRepairService.setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + } + + @Test(expected = ConfigurationException.class) + public void testSetUnifiedRepairEnabledThrowsForIRWithCDCReplay() { + unifiedRepairService.config = new UnifiedRepairConfig(true); + DatabaseDescriptor.setCDCOnRepairEnabled(true); + unifiedRepairService.setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + } + + @Test + public void testSetUnifiedRepairEnabledDoesNotThrowForIRWithCDCReplayDisabled() { + unifiedRepairService.config = new UnifiedRepairConfig(true); + DatabaseDescriptor.setCDCEnabled(true); + unifiedRepairService.setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + } +} diff --git a/test/unit/org/apache/cassandra/service/AutoRepairServiceRepairTypeTest.java b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceRepairTypeTest.java similarity index 72% rename from test/unit/org/apache/cassandra/service/AutoRepairServiceRepairTypeTest.java rename to test/unit/org/apache/cassandra/service/UnifiedRepairServiceRepairTypeTest.java index 7c8645149adc..d91c89ee8619 100644 --- a/test/unit/org/apache/cassandra/service/AutoRepairServiceRepairTypeTest.java +++ b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceRepairTypeTest.java @@ -20,8 +20,8 @@ import com.google.common.collect.ImmutableSet; import org.apache.cassandra.cql3.CQLTester; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; @@ -33,44 +33,44 @@ import java.util.Set; import java.util.UUID; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.apache.cassandra.config.CassandraRelevantProperties.SYSTEM_DISTRIBUTED_DEFAULT_RF; import static org.junit.Assert.assertEquals; @RunWith(Parameterized.class) -public class AutoRepairServiceRepairTypeTest extends CQLTester { +public class UnifiedRepairServiceRepairTypeTest extends CQLTester { @Parameterized.Parameter() - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; private final UUID host1 = UUID.fromString("00000000-0000-0000-0000-000000000001"); private final UUID host2 = UUID.fromString("00000000-0000-0000-0000-000000000002"); - private AutoRepairService instance; + private UnifiedRepairService instance; @Parameterized.Parameters(name = "repairType={0}") - public static Collection repairTypes() { - return Arrays.asList(AutoRepairConfig.RepairType.values()); + public static Collection repairTypes() { + return Arrays.asList(UnifiedRepairConfig.RepairType.values()); } @BeforeClass public static void setupClass() throws Exception { SYSTEM_DISTRIBUTED_DEFAULT_RF.setInt(1); - setAutoRepairEnabled(true); + setUnifiedRepairEnabled(true); requireNetwork(); } @Before public void setUpTest() { - AutoRepairUtils.setup(); - instance = new AutoRepairService(); + UnifiedRepairUtils.setup(); + instance = new UnifiedRepairService(); } @Test public void testGetOnGoingRepairHostIdsTest() { long now = System.currentTimeMillis(); - AutoRepairUtils.insertNewRepairHistory(repairType, host1, now, now - 1000000); - AutoRepairUtils.insertNewRepairHistory(repairType, host2, now, now - 1000000); + UnifiedRepairUtils.insertNewRepairHistory(repairType, host1, now, now - 1000000); + UnifiedRepairUtils.insertNewRepairHistory(repairType, host2, now, now - 1000000); Set hosts = instance.getOnGoingRepairHostIds(repairType); diff --git a/test/unit/org/apache/cassandra/service/AutoRepairServiceSetterTest.java b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceSetterTest.java similarity index 59% rename from test/unit/org/apache/cassandra/service/AutoRepairServiceSetterTest.java rename to test/unit/org/apache/cassandra/service/UnifiedRepairServiceSetterTest.java index f34e1f0a7071..57b5500b665e 100644 --- a/test/unit/org/apache/cassandra/service/AutoRepairServiceSetterTest.java +++ b/test/unit/org/apache/cassandra/service/UnifiedRepairServiceSetterTest.java @@ -24,8 +24,8 @@ import org.apache.cassandra.cql3.QueryProcessor; import org.apache.cassandra.cql3.UntypedResultSet; import org.apache.cassandra.locator.InetAddressAndPort; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; -import org.apache.cassandra.repair.autorepair.AutoRepairUtils; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairUtils; import org.apache.cassandra.schema.SchemaConstants; import org.apache.cassandra.schema.SystemDistributedKeyspace; import org.junit.Before; @@ -43,48 +43,48 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.junit.Assert.assertEquals; @RunWith(Parameterized.class) -public class AutoRepairServiceSetterTest extends CQLTester { - private static final AutoRepairConfig config = new AutoRepairConfig(true); +public class UnifiedRepairServiceSetterTest extends CQLTester { + private static final UnifiedRepairConfig config = new UnifiedRepairConfig(true); @Parameterized.Parameter - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; @Parameterized.Parameter(1) public T arg; @Parameterized.Parameter(2) - public BiConsumer setter; + public BiConsumer setter; @Parameterized.Parameter(3) - public Function getter; + public Function getter; @Parameterized.Parameters(name = "{index}: repairType={0}, arg={1}") public static Collection testCases() { DatabaseDescriptor.setConfig(DatabaseDescriptor.loadConfig()); return Stream.of( - forEachRepairType(true, AutoRepairService.instance::setAutoRepairEnabled, config::isAutoRepairEnabled), - forEachRepairType(100, AutoRepairService.instance::setRepairThreads, config::getRepairThreads), - forEachRepairType(200, AutoRepairService.instance::setRepairSubRangeNum, config::getRepairSubRangeNum), - forEachRepairType(400, AutoRepairService.instance::setRepairSSTableCountHigherThreshold, config::getRepairSSTableCountHigherThreshold), - forEachRepairType(ImmutableSet.of("dc1", "dc2"), AutoRepairService.instance::setIgnoreDCs, config::getIgnoreDCs), - forEachRepairType(true, AutoRepairService.instance::setPrimaryTokenRangeOnly, config::getRepairPrimaryTokenRangeOnly), - forEachRepairType(600, AutoRepairService.instance::setParallelRepairPercentage, config::getParallelRepairPercentage), - forEachRepairType(700, AutoRepairService.instance::setParallelRepairCount, config::getParallelRepairCount), - forEachRepairType(true, AutoRepairService.instance::setMVRepairEnabled, config::getMVRepairEnabled), - forEachRepairType(ImmutableSet.of(InetAddressAndPort.getLocalHost()), AutoRepairService.instance::setRepairPriorityForHosts, AutoRepairUtils::getPriorityHosts), - forEachRepairType(ImmutableSet.of(InetAddressAndPort.getLocalHost()), AutoRepairService.instance::setForceRepairForHosts, AutoRepairServiceSetterTest::isLocalHostForceRepair) + forEachRepairType(true, UnifiedRepairService.instance::setUnifiedRepairEnabled, config::isUnifiedRepairEnabled), + forEachRepairType(100, UnifiedRepairService.instance::setRepairThreads, config::getRepairThreads), + forEachRepairType(200, UnifiedRepairService.instance::setRepairSubRangeNum, config::getRepairSubRangeNum), + forEachRepairType(400, UnifiedRepairService.instance::setRepairSSTableCountHigherThreshold, config::getRepairSSTableCountHigherThreshold), + forEachRepairType(ImmutableSet.of("dc1", "dc2"), UnifiedRepairService.instance::setIgnoreDCs, config::getIgnoreDCs), + forEachRepairType(true, UnifiedRepairService.instance::setPrimaryTokenRangeOnly, config::getRepairPrimaryTokenRangeOnly), + forEachRepairType(600, UnifiedRepairService.instance::setParallelRepairPercentage, config::getParallelRepairPercentage), + forEachRepairType(700, UnifiedRepairService.instance::setParallelRepairCount, config::getParallelRepairCount), + forEachRepairType(true, UnifiedRepairService.instance::setMVRepairEnabled, config::getMVRepairEnabled), + forEachRepairType(ImmutableSet.of(InetAddressAndPort.getLocalHost()), UnifiedRepairService.instance::setRepairPriorityForHosts, UnifiedRepairUtils::getPriorityHosts), + forEachRepairType(ImmutableSet.of(InetAddressAndPort.getLocalHost()), UnifiedRepairService.instance::setForceRepairForHosts, UnifiedRepairServiceSetterTest::isLocalHostForceRepair) ).flatMap(Function.identity()).collect(Collectors.toList()); } - private static Set isLocalHostForceRepair(AutoRepairConfig.RepairType type) { + private static Set isLocalHostForceRepair(UnifiedRepairConfig.RepairType type) { UUID hostId = StorageService.instance.getHostIdForEndpoint(InetAddressAndPort.getLocalHost()); UntypedResultSet resultSet = QueryProcessor.executeInternal(String.format( - "SELECT force_repair FROM %s.%s WHERE host_id = %s and repair_type = '%s'", - SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.AUTO_REPAIR_HISTORY, hostId, type)); + "SELECT force_repair FROM %s.%s WHERE host_id = %s and repair_type = '%s'", + SchemaConstants.DISTRIBUTED_KEYSPACE_NAME, SystemDistributedKeyspace.UNIFIED_REPAIR_HISTORY, hostId, type)); if (!resultSet.isEmpty() && resultSet.one().getBoolean("force_repair")) { return ImmutableSet.of(InetAddressAndPort.getLocalHost()); @@ -92,9 +92,9 @@ private static Set isLocalHostForceRepair(AutoRepairConfig.R return ImmutableSet.of(); } - private static Stream forEachRepairType(T arg, BiConsumer setter, Function getter) { - Object[][] testCases = new Object[AutoRepairConfig.RepairType.values().length][4]; - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) { + private static Stream forEachRepairType(T arg, BiConsumer setter, Function getter) { + Object[][] testCases = new Object[UnifiedRepairConfig.RepairType.values().length][4]; + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { testCases[repairType.ordinal()] = new Object[]{repairType, arg, setter, getter}; } @@ -104,22 +104,22 @@ private static Stream forEachRepairType(T arg, BiConsumer verifyFunc; + public Consumer verifyFunc; @Parameterized.Parameters(name = "repairType={0},paramType={1}") public static Collection testCases() { return Stream.of( - forEachRepairType("enabled", "true", (type) -> verify(probe, times(1)).setAutoRepairEnabled(type, true)), + forEachRepairType("enabled", "true", (type) -> verify(probe, times(1)).setUnifiedRepairEnabled(type, true)), forEachRepairType("number_of_repair_threads", "1", (type) -> verify(probe, times(1)).setRepairThreads(type, 1)), forEachRepairType("number_of_subranges", "2", (type) -> verify(probe, times(1)).setRepairSubRangeNum(type, 2)), forEachRepairType("min_repair_interval", "3h", (type) -> verify(probe, times(1)).setRepairMinInterval(type, "3h")), forEachRepairType("sstable_upper_threshold", "4", (type) -> verify(probe, times(1)).setRepairSSTableCountHigherThreshold(type, 4)), - forEachRepairType("table_max_repair_time", "5s", (type) -> verify(probe, times(1)).setAutoRepairTableMaxRepairTime(type, "5s")), + forEachRepairType("table_max_repair_time", "5s", (type) -> verify(probe, times(1)).setUnifiedRepairTableMaxRepairTime(type, "5s")), forEachRepairType("repair_primary_token_range_only", "true", (type) -> verify(probe, times(1)).setPrimaryTokenRangeOnly(type, true)), forEachRepairType("parallel_repair_count", "6", (type) -> verify(probe, times(1)).setParallelRepairCount(type, 6)), forEachRepairType("parallel_repair_percentage", "7", (type) -> verify(probe, times(1)).setParallelRepairPercentage(type, 7)), forEachRepairType("mv_repair_enabled", "true", (type) -> verify(probe, times(1)).setMVRepairEnabled(type, true)), - forEachRepairType("ignore_dcs", "dc1,dc2", (type) -> verify(probe, times(1)).setAutoRepairIgnoreDCs(type, ImmutableSet.of("dc1", "dc2"))) + forEachRepairType("ignore_dcs", "dc1,dc2", (type) -> verify(probe, times(1)).setUnifiedRepairIgnoreDCs(type, ImmutableSet.of("dc1", "dc2"))) ).flatMap(Function.identity()).collect(Collectors.toList()); } - private static Stream forEachRepairType(String paramType, String paramVal, Consumer verifyFunc) + private static Stream forEachRepairType(String paramType, String paramVal, Consumer verifyFunc) { - Object[][] testCases = new Object[AutoRepairConfig.RepairType.values().length][4]; - for (AutoRepairConfig.RepairType repairType : AutoRepairConfig.RepairType.values()) + Object[][] testCases = new Object[UnifiedRepairConfig.RepairType.values().length][4]; + for (UnifiedRepairConfig.RepairType repairType : UnifiedRepairConfig.RepairType.values()) { testCases[repairType.ordinal()] = new Object[]{ repairType, paramType, paramVal, verifyFunc }; } @@ -316,12 +316,12 @@ public void test() verifyFunc.accept(repairType); - // test scenario when auto repair is disabled - when(probe.getAutoRepairConfig()).thenReturn(new AutoRepairConfig(false)); + // test scenario when unified repair is disabled + when(probe.getUnifiedRepairConfig()).thenReturn(new UnifiedRepairConfig(false)); cmd.execute(probe); - // test new calls are not made when auto repair is disabled + // test new calls are not made when unified repair is disabled verifyFunc.accept(repairType); } } diff --git a/test/unit/org/apache/cassandra/tools/nodetool/AutoRepairStatusTest.java b/test/unit/org/apache/cassandra/tools/nodetool/UnifiedRepairStatusTest.java similarity index 76% rename from test/unit/org/apache/cassandra/tools/nodetool/AutoRepairStatusTest.java rename to test/unit/org/apache/cassandra/tools/nodetool/UnifiedRepairStatusTest.java index 16b12ee2350e..a84e24a3a9ae 100644 --- a/test/unit/org/apache/cassandra/tools/nodetool/AutoRepairStatusTest.java +++ b/test/unit/org/apache/cassandra/tools/nodetool/UnifiedRepairStatusTest.java @@ -30,33 +30,33 @@ import org.junit.runners.Parameterized; import org.apache.cassandra.config.DatabaseDescriptor; -import org.apache.cassandra.repair.autorepair.AutoRepairConfig; +import org.apache.cassandra.repair.unifiedrepair.UnifiedRepairConfig; import org.apache.cassandra.tools.NodeProbe; import org.apache.cassandra.tools.Output; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import static org.apache.cassandra.Util.setAutoRepairEnabled; +import static org.apache.cassandra.Util.setUnifiedRepairEnabled; import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.when; @RunWith(Parameterized.class) -public class AutoRepairStatusTest +public class UnifiedRepairStatusTest { @Mock private static NodeProbe probe; private ByteArrayOutputStream cmdOutput; - private static AutoRepairStatus cmd; + private static UnifiedRepairStatus cmd; @Parameterized.Parameter() - public AutoRepairConfig.RepairType repairType; + public UnifiedRepairConfig.RepairType repairType; @Parameterized.Parameters(name = "repairType={0}") - public static Collection repairTypes() + public static Collection repairTypes() { - return Arrays.asList(AutoRepairConfig.RepairType.values()); + return Arrays.asList(UnifiedRepairConfig.RepairType.values()); } @Before @@ -66,13 +66,13 @@ public void setUp() throws Exception cmdOutput = new ByteArrayOutputStream(); PrintStream out = new PrintStream(cmdOutput); when(probe.output()).thenReturn(new Output(out, out)); - cmd = new AutoRepairStatus(); + cmd = new UnifiedRepairStatus(); DatabaseDescriptor.daemonInitialization(); DatabaseDescriptor.loadConfig(); - setAutoRepairEnabled(true); - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(AutoRepairConfig.RepairType.full, true); - DatabaseDescriptor.getAutoRepairConfig().setAutoRepairEnabled(AutoRepairConfig.RepairType.incremental, true); - when(probe.getAutoRepairConfig()).thenReturn(DatabaseDescriptor.getAutoRepairConfig()); + setUnifiedRepairEnabled(true); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.full, true); + DatabaseDescriptor.getUnifiedRepairConfig().setUnifiedRepairEnabled(UnifiedRepairConfig.RepairType.incremental, true); + when(probe.getUnifiedRepairConfig()).thenReturn(DatabaseDescriptor.getUnifiedRepairConfig()); } @Test(expected = IllegalArgumentException.class)