getReplicas()
+ {
+ return Sets.newHashSet(myReplicas);
+ }
+}
+
diff --git a/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/package-info.java b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/package-info.java
new file mode 100644
index 00000000..2fbd63bc
--- /dev/null
+++ b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/package-info.java
@@ -0,0 +1,18 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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.
+ */
+/**
+ * Contains the implementations and resources for vnode repairs.
+ */
+package com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode;
diff --git a/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableRepairJob.java b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableRepairJob.java
new file mode 100644
index 00000000..af26e341
--- /dev/null
+++ b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableRepairJob.java
@@ -0,0 +1,502 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.table;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.RepairGroup;
+import com.ericsson.bss.cassandra.ecchronos.core.jmx.DistributedJmxProxyFactory;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledRepairJob;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledRepairJobView;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledTask;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateSnapshot;
+import com.ericsson.bss.cassandra.ecchronos.core.state.ReplicaRepairGroup;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairStates;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableRepairMetrics;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableRepairPolicy;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableStorageStates;
+import com.ericsson.bss.cassandra.ecchronos.data.repairhistory.RepairHistoryService;
+import com.google.common.base.Preconditions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Predicate;
+
+/**
+ * A scheduled job that keeps track of the repair status of a single table. The table is considered repaired for this
+ * node if all the ranges this node is responsible for is repaired within the minimum run interval.
+ *
+ * When run this job will create {@link com.ericsson.bss.cassandra.ecchronos.core.impl.repair.RepairTask RepairTasks} that repairs the table.
+ */
+public class TableRepairJob extends ScheduledRepairJob
+{
+ private static final Logger LOG = LoggerFactory.getLogger(TableRepairJob.class);
+ private static final int DAYS_IN_A_WEEK = 7;
+ private final Node myNode;
+ private final RepairState myRepairState;
+ private final TableStorageStates myTableStorageStates;
+ private final RepairHistoryService myRepairHistory;
+
+ TableRepairJob(final Builder builder)
+ {
+ super(builder.configuration, builder.tableReference.getId(), builder.tableReference, builder.jmxProxyFactory,
+ builder.repairConfiguration, builder.repairPolicies,
+ builder.tableRepairMetrics);
+ myNode = Preconditions.checkNotNull(builder.myNode,
+ "Node must be set");
+ myRepairState = Preconditions.checkNotNull(builder.repairState,
+ "Repair state must be set");
+ myTableStorageStates = builder.tableStorageStates;
+ myRepairHistory = Preconditions.checkNotNull(builder.repairHistory,
+ "Repair history must be set");
+ }
+
+ /**
+ * Get scheduled repair job view.
+ *
+ * @return ScheduledRepairJobView
+ */
+ @Override
+ public ScheduledRepairJobView getView()
+ {
+ long now = System.currentTimeMillis();
+ return new ScheduledRepairJobView(getId(), getTableReference(), getRepairConfiguration(),
+ myRepairState.getSnapshot(),
+ getStatus(now), getProgress(now), getNextRunInMs(), getRepairConfiguration().getRepairType());
+ }
+
+ private long getNextRunInMs()
+ {
+ return (getLastSuccessfulRun() + getRepairConfiguration().getRepairIntervalInMs()) - getRunOffset();
+ }
+
+ private double getProgress(final long timestamp)
+ {
+ long interval = getRepairConfiguration().getRepairIntervalInMs();
+ Collection states = myRepairState.getSnapshot().getVnodeRepairStates().getVnodeRepairStates();
+
+ long nRepaired = states.stream()
+ .filter(isRepaired(timestamp, interval))
+ .count();
+
+ return states.isEmpty()
+ ? 0
+ : (double) nRepaired / states.size();
+ }
+
+ private Predicate isRepaired(final long timestamp, final long interval)
+ {
+ return state -> timestamp - state.lastRepairedAt() <= interval;
+ }
+
+ private ScheduledRepairJobView.Status getStatus(final long timestamp)
+ {
+ if (getRealPriority() != -1 && !super.runnable())
+ {
+ return ScheduledRepairJobView.Status.BLOCKED;
+ }
+ long repairedAt = myRepairState.getSnapshot().lastCompletedAt();
+ long msSinceLastRepair = timestamp - repairedAt;
+ RepairConfiguration config = getRepairConfiguration();
+
+ if (msSinceLastRepair >= config.getRepairErrorTimeInMs())
+ {
+ return ScheduledRepairJobView.Status.OVERDUE;
+ }
+ if (msSinceLastRepair >= config.getRepairWarningTimeInMs())
+ {
+ return ScheduledRepairJobView.Status.LATE;
+ }
+ if (msSinceLastRepair >= (config.getRepairIntervalInMs() - getRunOffset()))
+ {
+ return ScheduledRepairJobView.Status.ON_TIME;
+ }
+ return ScheduledRepairJobView.Status.COMPLETED;
+ }
+
+ /**
+ * Iterator for scheduled tasks built up by repair groups.
+ *
+ * @return Scheduled task iterator
+ */
+ @Override
+ public Iterator iterator()
+ {
+ RepairStateSnapshot repairStateSnapshot = myRepairState.getSnapshot();
+ if (repairStateSnapshot.canRepair())
+ {
+ List taskList = new ArrayList<>();
+
+ BigInteger tokensPerRepair = getTokensPerRepair(repairStateSnapshot.getVnodeRepairStates());
+
+ for (ReplicaRepairGroup replicaRepairGroup : repairStateSnapshot.getRepairGroups())
+ {
+ RepairGroup.Builder builder = RepairGroup.newBuilder()
+ .withTableReference(getTableReference())
+ .withRepairConfiguration(getRepairConfiguration())
+ .withReplicaRepairGroup(replicaRepairGroup)
+ .withJmxProxyFactory(getJmxProxyFactory())
+ .withTableRepairMetrics(getTableRepairMetrics())
+ .withTokensPerRepair(tokensPerRepair)
+ .withRepairPolicies(getRepairPolicies())
+ .withRepairHistory(myRepairHistory)
+ .withJobId(getId())
+ .withNode(myNode);
+
+ taskList.add(builder.build(getRealPriority(replicaRepairGroup.getLastCompletedAt())));
+ }
+
+ return taskList.iterator();
+ }
+ else
+ {
+ return Collections.emptyIterator();
+ }
+ }
+
+ /**
+ * Update the state and set if the task was successful.
+ *
+ * @param successful
+ * If the job ran successfully.
+ */
+ @Override
+ public void postExecute(final boolean successful)
+ {
+ try
+ {
+ myRepairState.update();
+ }
+ catch (Exception e)
+ {
+ LOG.warn("Unable to check repair history, {}", this, e);
+ }
+
+ super.postExecute(successful);
+ }
+
+ /**
+ * Get last successful run.
+ *
+ * @return long
+ */
+ @Override
+ public long getLastSuccessfulRun()
+ {
+ return myRepairState.getSnapshot().lastCompletedAt();
+ }
+
+ /**
+ * Get run offset.
+ *
+ * @return long
+ */
+ @Override
+ public long getRunOffset()
+ {
+ return myRepairState.getSnapshot().getEstimatedRepairTime();
+ }
+
+ /**
+ * Runnable.
+ *
+ * @return boolean
+ */
+ @Override
+ public boolean runnable()
+ {
+ return myRepairState.getSnapshot().canRepair() && super.runnable();
+ }
+
+ /**
+ * Refresh the repair state.
+ */
+ @Override
+ public void refreshState()
+ {
+ try
+ {
+ myRepairState.update();
+ }
+ catch (Exception e)
+ {
+ LOG.warn("Unable to check repair history, {}", this, e);
+ }
+ }
+
+ /**
+ * Calculate real priority based on available tasks.
+ * @return priority
+ */
+ @Override
+ public final int getRealPriority()
+ {
+ RepairStateSnapshot repairStateSnapshot = myRepairState.getSnapshot();
+ int priority = -1;
+ if (repairStateSnapshot.canRepair())
+ {
+ long minRepairedAt = System.currentTimeMillis();
+ for (ReplicaRepairGroup replicaRepairGroup : repairStateSnapshot.getRepairGroups())
+ {
+ long replicaGroupCompletedAt = replicaRepairGroup.getLastCompletedAt();
+ if (replicaGroupCompletedAt < minRepairedAt)
+ {
+ minRepairedAt = replicaGroupCompletedAt;
+ }
+ }
+ priority = getRealPriority(minRepairedAt);
+ }
+ return priority;
+ }
+
+ /**
+ * String representation.
+ *
+ * @return String
+ */
+ @Override
+ public String toString()
+ {
+ return String.format("Repair job of %s", getTableReference());
+ }
+
+ private BigInteger getTokensPerRepair(final VnodeRepairStates vnodeRepairStates)
+ {
+ BigInteger tokensPerRepair = LongTokenRange.FULL_RANGE;
+
+ if (getRepairConfiguration().getTargetRepairSizeInBytes() != RepairConfiguration.FULL_REPAIR_SIZE)
+ {
+ BigInteger tableSizeInBytes = BigInteger.valueOf(myTableStorageStates.getDataSize(myNode.getHostId(), getTableReference()));
+
+ if (!BigInteger.ZERO.equals(tableSizeInBytes))
+ {
+ BigInteger fullRangeSize = vnodeRepairStates.getVnodeRepairStates().stream()
+ .map(VnodeRepairState::getTokenRange)
+ .map(LongTokenRange::rangeSize)
+ .reduce(BigInteger.ZERO, BigInteger::add);
+
+ BigInteger targetSizeInBytes = BigInteger.valueOf(
+ getRepairConfiguration().getTargetRepairSizeInBytes());
+
+ if (tableSizeInBytes.compareTo(targetSizeInBytes) > 0)
+ {
+ BigInteger targetRepairs = tableSizeInBytes.divide(targetSizeInBytes);
+ tokensPerRepair = fullRangeSize.divide(targetRepairs);
+ }
+ }
+ }
+
+ return tokensPerRepair;
+ }
+
+ @Override
+ public final boolean equals(final Object o)
+ {
+ if (this == o)
+ {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass())
+ {
+ return false;
+ }
+ if (!super.equals(o))
+ {
+ return false;
+ }
+ TableRepairJob that = (TableRepairJob) o;
+ return Objects.equals(myRepairState, that.myRepairState) && Objects.equals(myTableStorageStates,
+ that.myTableStorageStates) && Objects.equals(myRepairHistory, that.myRepairHistory);
+ }
+
+ @Override
+ public final int hashCode()
+ {
+ return Objects.hash(super.hashCode(), myRepairState, myTableStorageStates, myRepairHistory);
+ }
+
+ @SuppressWarnings("VisibilityModifier")
+ public static class Builder
+ {
+ Configuration configuration = new ConfigurationBuilder()
+ .withPriority(Priority.LOW)
+ .withRunInterval(DAYS_IN_A_WEEK, TimeUnit.DAYS)
+ .build();
+ private Node myNode;
+ private TableReference tableReference;
+ private DistributedJmxProxyFactory jmxProxyFactory;
+ private RepairState repairState;
+ private TableRepairMetrics tableRepairMetrics = null;
+ private RepairConfiguration repairConfiguration = RepairConfiguration.DEFAULT;
+ private TableStorageStates tableStorageStates;
+ private final List repairPolicies = new ArrayList<>();
+ private RepairHistoryService repairHistory;
+
+ /**
+ * Build table repair job with configuration.
+ *
+ * @param theConfiguration
+ * Configuration.
+ * @return Builder
+ */
+ public Builder withConfiguration(final Configuration theConfiguration)
+ {
+ this.configuration = theConfiguration;
+ return this;
+ }
+
+ /**
+ * Build table repair job with table reference.
+ *
+ * @param theTableReference
+ * Table reference.
+ * @return Builder
+ */
+ public Builder withTableReference(final TableReference theTableReference)
+ {
+ this.tableReference = theTableReference;
+ return this;
+ }
+
+ /**
+ * Build with configuration.
+ *
+ * @param node
+ * Node.
+ * @return Builder
+ */
+ public Builder withNode(final Node node)
+ {
+ myNode = node;
+ return this;
+ }
+
+ /**
+ * Build table repair job with JMX proxy factory.
+ *
+ * @param aJMXProxyFactory
+ * JMX proxy factory.
+ * @return Builder
+ */
+ public Builder withJmxProxyFactory(final DistributedJmxProxyFactory aJMXProxyFactory)
+ {
+ this.jmxProxyFactory = aJMXProxyFactory;
+ return this;
+ }
+
+ /**
+ * Build table repair job with repair state.
+ *
+ * @param theRepairState
+ * Repair state.
+ * @return Builder
+ */
+ public Builder withRepairState(final RepairState theRepairState)
+ {
+ this.repairState = theRepairState;
+ return this;
+ }
+
+ /**
+ * Build table repair job with table repair metrics.
+ *
+ * @param theTableRepairMetrics
+ * Table repair metrics.
+ * @return Builder
+ */
+ public Builder withTableRepairMetrics(final TableRepairMetrics theTableRepairMetrics)
+ {
+ this.tableRepairMetrics = theTableRepairMetrics;
+ return this;
+ }
+
+ /**
+ * Build table repair job with repair configuration.
+ *
+ * @param theRepairConfiguration
+ * The repair confiuration.
+ * @return Builder
+ */
+ public Builder withRepairConfiguration(final RepairConfiguration theRepairConfiguration)
+ {
+ this.repairConfiguration = theRepairConfiguration;
+ return this;
+ }
+
+ /**
+ * Build table repair job with table storage states.
+ *
+ * @param theTableStorageStates
+ * Table storage states.
+ * @return Builder
+ */
+ public Builder withTableStorageStates(final TableStorageStates theTableStorageStates)
+ {
+ this.tableStorageStates = theTableStorageStates;
+ return this;
+ }
+
+ /**
+ * Build table repair job with repair policies.
+ *
+ * @param tableRepairPolicies
+ * The table repair policies.
+ * @return Builder
+ */
+ public Builder withRepairPolices(final Collection tableRepairPolicies)
+ {
+ this.repairPolicies.addAll(tableRepairPolicies);
+ return this;
+ }
+
+ /**
+ * Build table repair job with repair history.
+ *
+ * @param aRepairHistory
+ * Repair history.
+ * @return Builder
+ */
+ public Builder withRepairHistory(final RepairHistoryService aRepairHistory)
+ {
+ this.repairHistory = aRepairHistory;
+ return this;
+ }
+
+ /**
+ * Build table repair job.
+ *
+ * @return TableRepairJob
+ */
+ public TableRepairJob build()
+ {
+ Preconditions.checkNotNull(tableReference, "Table reference must be set");
+
+ return new TableRepairJob(this);
+ }
+ }
+}
+
diff --git a/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableStorageStatesImpl.java b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableStorageStatesImpl.java
new file mode 100644
index 00000000..5c53d26c
--- /dev/null
+++ b/core.impl/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/impl/table/TableStorageStatesImpl.java
@@ -0,0 +1,239 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.table;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.connection.DistributedNativeConnectionProvider;
+import com.ericsson.bss.cassandra.ecchronos.core.jmx.DistributedJmxProxy;
+import com.ericsson.bss.cassandra.ecchronos.core.jmx.DistributedJmxProxyFactory;
+import com.ericsson.bss.cassandra.ecchronos.core.table.ReplicatedTableProvider;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableStorageStates;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+
+public final class TableStorageStatesImpl implements TableStorageStates, Closeable
+{
+ private static final Logger LOG = LoggerFactory.getLogger(TableStorageStatesImpl.class);
+
+ private static final long DEFAULT_UPDATE_DELAY_IN_MS = TimeUnit.SECONDS.toMillis(60);
+
+ private final AtomicReference>> myTableSizes = new AtomicReference<>();
+ private final ScheduledExecutorService myScheduledExecutorService;
+
+ private final ReplicatedTableProvider myReplicatedTableProvider;
+ private final DistributedJmxProxyFactory myJmxProxyFactory;
+ private final DistributedNativeConnectionProvider myNativeConnectionProvider;
+
+ private TableStorageStatesImpl(final Builder builder)
+ {
+ myReplicatedTableProvider = builder.myReplicatedTableProvider;
+ myJmxProxyFactory = builder.myJmxProxyFactory;
+ myNativeConnectionProvider = builder.myNativeConnectionProvider;
+
+ initializeEmptyTableSizeMap();
+
+ myScheduledExecutorService = Executors.newSingleThreadScheduledExecutor(
+ new ThreadFactoryBuilder().setNameFormat("TableStateUpdater-%d").build());
+ myScheduledExecutorService.scheduleAtFixedRate(this::updateTableStates,
+ builder.myInitialDelayInMs,
+ builder.myUpdateDelayInMs,
+ TimeUnit.MILLISECONDS);
+ }
+
+ private void initializeEmptyTableSizeMap()
+ {
+ for (Node node : myNativeConnectionProvider.getNodes())
+ {
+ UUID nodeID = node.getHostId();
+ initializeEmptyNodeMap(nodeID);
+ }
+ }
+
+ private void initializeEmptyNodeMap(final UUID nodeID)
+ {
+ Map> emptyNewEntry = new HashMap<>();
+ Map emptyDataSizes = new HashMap<>();
+ ImmutableMap emptyTableSize = ImmutableMap.copyOf(emptyDataSizes);
+ emptyNewEntry.put(nodeID, emptyTableSize);
+ myTableSizes.set(emptyNewEntry);
+ }
+
+ @Override
+ public long getDataSize(final UUID nodeID, final TableReference tableReference)
+ {
+ Map> dataSizes = myTableSizes.get();
+
+ if (!dataSizes.containsKey(nodeID))
+ {
+ initializeEmptyNodeMap(nodeID);
+ }
+
+ if (dataSizes.get(nodeID).containsKey(tableReference))
+ {
+ return dataSizes.get(nodeID).get(tableReference);
+ }
+ return 0;
+ }
+
+ @Override
+ public long getDataSize(final UUID nodeID)
+ {
+ Map> dataSizesMap = myTableSizes.get();
+
+ if (!dataSizesMap.containsKey(nodeID))
+ {
+ initializeEmptyNodeMap(nodeID);
+ }
+
+ ImmutableMap dataSizes = dataSizesMap.get(nodeID);
+
+ if (dataSizes != null && !dataSizes.isEmpty())
+ {
+ return dataSizes.values().stream().mapToLong(e -> e).sum();
+ }
+
+ return 0;
+ }
+
+ @Override
+ public void close()
+ {
+ myScheduledExecutorService.shutdown();
+
+ myTableSizes.set(null);
+ }
+
+ public static Builder builder()
+ {
+ return new Builder();
+ }
+
+ public static class Builder
+ {
+ private ReplicatedTableProvider myReplicatedTableProvider;
+ private DistributedJmxProxyFactory myJmxProxyFactory;
+ private DistributedNativeConnectionProvider myNativeConnectionProvider;
+
+ private long myInitialDelayInMs = 0;
+ private long myUpdateDelayInMs = DEFAULT_UPDATE_DELAY_IN_MS;
+
+ public final Builder withReplicatedTableProvider(final ReplicatedTableProvider replicatedTableProvider)
+ {
+ myReplicatedTableProvider = replicatedTableProvider;
+ return this;
+ }
+
+ public final Builder withJmxProxyFactory(final DistributedJmxProxyFactory jmxProxyFactory)
+ {
+ myJmxProxyFactory = jmxProxyFactory;
+ return this;
+ }
+
+ public final Builder withConnectionProvider(final DistributedNativeConnectionProvider nativeConnectionProvider)
+ {
+ myNativeConnectionProvider = nativeConnectionProvider;
+ return this;
+ }
+
+ public final Builder withInitialDelay(final long initialDelay, final TimeUnit timeUnit)
+ {
+ myInitialDelayInMs = timeUnit.toMillis(initialDelay);
+ return this;
+ }
+
+ public final Builder withUpdateDelay(final long updateDelay, final TimeUnit timeUnit)
+ {
+ myUpdateDelayInMs = timeUnit.toMillis(updateDelay);
+ return this;
+ }
+
+ public final TableStorageStatesImpl build()
+ {
+ if (myReplicatedTableProvider == null)
+ {
+ throw new IllegalArgumentException("Replicated table provider cannot be null");
+ }
+
+ if (myJmxProxyFactory == null)
+ {
+ throw new IllegalArgumentException("JMX proxy factory cannot be null");
+ }
+
+ if (myNativeConnectionProvider == null)
+ {
+ throw new IllegalArgumentException("Native connection provider cannot be null");
+ }
+
+ return new TableStorageStatesImpl(this);
+ }
+ }
+
+ @VisibleForTesting
+ void updateTableStates()
+ {
+ if (myJmxProxyFactory != null)
+ {
+ for (UUID nodeID : myTableSizes.get().keySet())
+ {
+ try (DistributedJmxProxy jmxProxy = myJmxProxyFactory.connect())
+ {
+ Map> newEntry = new HashMap<>();
+ ImmutableMap tableSize = getTableSizes(nodeID, jmxProxy);
+ newEntry.put(nodeID, tableSize);
+
+ myTableSizes.set(newEntry);
+ }
+ catch (IOException e)
+ {
+ LOG.error("Unable to update table sizes, future metrics might contain stale data", e);
+ }
+ }
+ }
+ }
+
+ private ImmutableMap getTableSizes(final UUID nodeID, final DistributedJmxProxy jmxProxy)
+ {
+ Map dataSizes = new HashMap<>();
+
+ if (myReplicatedTableProvider != null)
+ {
+ for (TableReference tableReference : myReplicatedTableProvider.getAll())
+ {
+ long diskSpaceUsed = jmxProxy.liveDiskSpaceUsed(nodeID, tableReference);
+
+ LOG.debug("{} -> {}", tableReference, diskSpaceUsed);
+ dataSizes.put(tableReference, diskSpaceUsed);
+ }
+ }
+
+ return ImmutableMap.copyOf(dataSizes);
+ }
+}
+
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestRepairGroup.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestRepairGroup.java
index a8812d5f..15c995bb 100644
--- a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestRepairGroup.java
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestRepairGroup.java
@@ -23,16 +23,20 @@
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
+import static org.mockito.ArgumentMatchers.any;
+import com.datastax.oss.driver.api.core.metadata.Node;
import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.incremental.IncrementalRepairTask;
import com.ericsson.bss.cassandra.ecchronos.core.jmx.DistributedJmxProxyFactory;
import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairHistory;
import com.ericsson.bss.cassandra.ecchronos.core.state.ReplicaRepairGroup;
import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
import com.ericsson.bss.cassandra.ecchronos.core.table.TableRepairMetrics;
+import com.ericsson.bss.cassandra.ecchronos.data.repairhistory.RepairHistoryService;
import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairParallelism;
import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairType;
import com.ericsson.bss.cassandra.ecchronos.utils.exceptions.ScheduledJobException;
@@ -68,13 +72,26 @@ public class TestRepairGroup
@Mock
private TableRepairMetrics myTableRepairMetrics;
+ @Mock
+ private RepairHistoryService myRepairHistoryService;
+
+ @Mock
+ private RepairHistory.RepairSession myRepairSession;
+
+ @Mock
+ private Node mockNode;
+
private final UUID myNodeID = UUID.randomUUID();
+ private final UUID myJobId = UUID.randomUUID();
+
private RepairConfiguration myRepairConfiguration;
@Before
public void init()
{
+ when(mockNode.getHostId()).thenReturn(myNodeID);
+ when(myRepairHistoryService.newSession(any(), any(), any(), any(), any())).thenReturn(myRepairSession);
myRepairConfiguration = RepairConfiguration.newBuilder()
.withParallelism(RepairParallelism.PARALLEL)
.withRepairWarningTime(RUN_INTERVAL_IN_DAYS * 2, TimeUnit.DAYS)
@@ -125,7 +142,7 @@ public void testExecuteAllTasksSuccessful() throws ScheduledJobException
ImmutableSet nodes = ImmutableSet.of(node);
ReplicaRepairGroup replicaRepairGroup = new ReplicaRepairGroup(nodes, ImmutableList.of(range), System.currentTimeMillis());
- RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).build(PRIORITY));
+ RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).withNode(mockNode).build(PRIORITY));
RepairTask repairTask1 = mock(RepairTask.class);
RepairTask repairTask2 = mock(RepairTask.class);
RepairTask repairTask3 = mock(RepairTask.class);
@@ -151,7 +168,7 @@ public void testExecuteAllTasksFailed() throws ScheduledJobException
ImmutableSet nodes = ImmutableSet.of(node);
ReplicaRepairGroup replicaRepairGroup = new ReplicaRepairGroup(nodes, ImmutableList.of(range), System.currentTimeMillis());
- RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).build(PRIORITY));
+ RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).withNode(mockNode).build(PRIORITY));
RepairTask repairTask1 = mock(RepairTask.class);
RepairTask repairTask2 = mock(RepairTask.class);
RepairTask repairTask3 = mock(RepairTask.class);
@@ -177,7 +194,7 @@ public void testExecuteSomeTasksFailed() throws ScheduledJobException
ImmutableSet nodes = ImmutableSet.of(node);
ReplicaRepairGroup replicaRepairGroup = new ReplicaRepairGroup(nodes, ImmutableList.of(range), System.currentTimeMillis());
- RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).build(PRIORITY));
+ RepairGroup repairGroup = spy(builderFor(replicaRepairGroup).withNode(mockNode).build(PRIORITY));
RepairTask repairTask1 = mock(RepairTask.class);
RepairTask repairTask2 = mock(RepairTask.class);
RepairTask repairTask3 = mock(RepairTask.class);
@@ -201,7 +218,9 @@ private RepairGroup.Builder builderFor(ReplicaRepairGroup replicaRepairGroup)
.withRepairConfiguration(myRepairConfiguration)
.withReplicaRepairGroup(replicaRepairGroup)
.withJmxProxyFactory(myJmxProxyFactory)
- .withTableRepairMetrics(myTableRepairMetrics);
+ .withTableRepairMetrics(myTableRepairMetrics)
+ .withRepairHistory(myRepairHistoryService)
+ .withJobId(myJobId);
}
private DriverNode mockNode(String dataCenter)
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestUtils.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestUtils.java
new file mode 100644
index 00000000..e6d76bbc
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/TestUtils.java
@@ -0,0 +1,206 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair;
+
+import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode.VnodeRepairStatesImpl;
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledRepairJobView;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateSnapshot;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairStates;
+import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairParallelism;
+import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairType;
+import com.google.common.collect.ImmutableSet;
+import org.assertj.core.util.Preconditions;
+import org.mockito.internal.util.collections.Sets;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import static com.ericsson.bss.cassandra.ecchronos.core.impl.table.MockTableReferenceFactory.tableReference;
+
+
+public class TestUtils
+{
+ public static RepairStateSnapshot generateRepairStateSnapshot(long lastRepairedAt, VnodeRepairStates vnodeRepairStates)
+ {
+ return RepairStateSnapshot.newBuilder()
+ .withLastCompletedAt(lastRepairedAt)
+ .withVnodeRepairStates(vnodeRepairStates)
+ .withReplicaRepairGroups(Collections.emptyList())
+ .build();
+ }
+
+ public static RepairConfiguration generateRepairConfiguration(long repairIntervalInMs)
+ {
+ return RepairConfiguration.newBuilder().withRepairInterval(repairIntervalInMs, TimeUnit.MILLISECONDS).build();
+ }
+
+ public static RepairConfiguration createRepairConfiguration(long interval, double unwindRatio, int warningTime, int errorTime)
+ {
+ return RepairConfiguration.newBuilder()
+ .withRepairInterval(interval, TimeUnit.MILLISECONDS)
+ .withParallelism(RepairParallelism.PARALLEL)
+ .withRepairUnwindRatio(unwindRatio)
+ .withRepairWarningTime(warningTime, TimeUnit.MILLISECONDS)
+ .withRepairErrorTime(errorTime, TimeUnit.MILLISECONDS)
+ .build();
+ }
+
+ public static class ScheduledRepairJobBuilder
+ {
+ private UUID id = UUID.randomUUID();
+ private String keyspace;
+ private String table;
+ private long lastRepairedAt = 0;
+ private long repairInterval = 0;
+ private ImmutableSet replicas = ImmutableSet.of();
+ private LongTokenRange longTokenRange = new LongTokenRange(1, 2);
+ private Collection vnodeRepairStateSet;
+ private RepairConfiguration repairConfiguration;
+ private double progress = 0;
+ private ScheduledRepairJobView.Status status = ScheduledRepairJobView.Status.ON_TIME;
+ private RepairType repairType = RepairType.VNODE;
+
+ public ScheduledRepairJobBuilder withId(UUID id)
+ {
+ this.id = id;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withKeyspace(String keyspace)
+ {
+ this.keyspace = keyspace;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withTable(String table)
+ {
+ this.table = table;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withLastRepairedAt(long lastRepairedAt)
+ {
+ this.lastRepairedAt = lastRepairedAt;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withRepairInterval(long repairInterval)
+ {
+ this.repairInterval = repairInterval;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withVnodeRepairStateSet(Collection vnodeRepairStateSet)
+ {
+ this.vnodeRepairStateSet = vnodeRepairStateSet;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withStatus(ScheduledRepairJobView.Status status)
+ {
+ this.status = status;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withProgress(double progress)
+ {
+ this.progress = progress;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withRepairConfiguration(RepairConfiguration repairConfiguration)
+ {
+ this.repairConfiguration = repairConfiguration;
+ return this;
+ }
+
+ public ScheduledRepairJobBuilder withRepairType(RepairType repairType)
+ {
+ this.repairType = repairType;
+ return this;
+ }
+
+
+ public ScheduledRepairJobView build()
+ {
+ Preconditions.checkNotNull(keyspace, "Keyspace cannot be null");
+ Preconditions.checkNotNull(table, "Table cannot be null");
+ Preconditions.checkArgument(lastRepairedAt > 0, "Last repaired not set");
+ Preconditions.checkArgument(repairInterval > 0, "Repair interval not set");
+ VnodeRepairStates vnodeRepairStates;
+ if ( vnodeRepairStateSet != null)
+ {
+ vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(vnodeRepairStateSet).build();
+ }
+ else
+ {
+ VnodeRepairState vnodeRepairState = createVnodeRepairState(longTokenRange, replicas, lastRepairedAt);
+ vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(Sets.newSet(vnodeRepairState)).build();
+ }
+
+ if (repairConfiguration == null)
+ {
+ this.repairConfiguration = generateRepairConfiguration(repairInterval);
+ }
+ return new ScheduledRepairJobView(id, tableReference(keyspace, table), repairConfiguration,
+ generateRepairStateSnapshot(lastRepairedAt, vnodeRepairStates), status,progress, lastRepairedAt + repairInterval, repairType);
+ }
+ }
+
+
+
+ public static VnodeRepairState createVnodeRepairState(long startToken, long endToken, ImmutableSet replicas,
+ long lastRepairedAt)
+ {
+ return createVnodeRepairState(new LongTokenRange(startToken, endToken), replicas, lastRepairedAt);
+ }
+
+ public static VnodeRepairState createVnodeRepairState(LongTokenRange longTokenRange, ImmutableSet replicas,
+ long lastRepairedAt)
+ {
+ return new VnodeRepairState(longTokenRange, replicas, lastRepairedAt);
+ }
+
+ public static String getFailedRepairMessage(LongTokenRange... ranges)
+ {
+ Collection rangeCollection = Arrays.asList(ranges);
+ return String.format("Repair session RepairSession for range %s failed with error ...", rangeCollection);
+ }
+
+ public static String getRepairMessage(LongTokenRange... ranges)
+ {
+ Collection rangeCollection = Arrays.asList(ranges);
+ return String.format("Repair session RepairSession for range %s finished", rangeCollection);
+ }
+
+ public static Map getNotificationData(int type, int progressCount, int total)
+ {
+ Map data = new HashMap<>();
+ data.put("type", type);
+ data.put("progressCount", progressCount);
+ data.put("total", total);
+ return data;
+ }
+}
+
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/scheduler/TestRepairSchedulerImpl.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/scheduler/TestRepairSchedulerImpl.java
index a708c5e7..8b2120a9 100644
--- a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/scheduler/TestRepairSchedulerImpl.java
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/scheduler/TestRepairSchedulerImpl.java
@@ -16,17 +16,27 @@
import com.datastax.oss.driver.api.core.metadata.Node;
import com.ericsson.bss.cassandra.ecchronos.core.impl.metrics.CassandraMetrics;
+import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.TestUtils;
import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.incremental.IncrementalRepairJob;
+import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode.VnodeRepairStatesImpl;
+import com.ericsson.bss.cassandra.ecchronos.core.impl.table.TableRepairJob;
import com.ericsson.bss.cassandra.ecchronos.core.jmx.DistributedJmxProxyFactory;
import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.RepairScheduler;
import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduleManager;
import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledJob;
import com.ericsson.bss.cassandra.ecchronos.core.repair.scheduler.ScheduledRepairJobView;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateFactory;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateSnapshot;
import com.ericsson.bss.cassandra.ecchronos.core.state.ReplicationState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
import com.ericsson.bss.cassandra.ecchronos.core.table.TableRepairMetrics;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableStorageStates;
+import com.ericsson.bss.cassandra.ecchronos.data.repairhistory.RepairHistoryService;
import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairType;
+import com.google.common.collect.ImmutableSet;
import java.util.*;
import org.junit.Before;
import org.junit.Test;
@@ -45,6 +55,8 @@ public class TestRepairSchedulerImpl
{
private static final TableReference TABLE_REFERENCE1 = tableReference("keyspace", "table1");
private static final TableReference TABLE_REFERENCE2 = tableReference("keyspace", "table2");
+ private static final VnodeRepairState VNODE_REPAIR_STATE = TestUtils.createVnodeRepairState(1, 2, ImmutableSet.of(), System.currentTimeMillis());
+
@Mock
private DistributedJmxProxyFactory jmxProxyFactory;
@@ -64,63 +76,89 @@ public class TestRepairSchedulerImpl
@Mock
private Node mockNode;
+ @Mock
+ private RepairStateFactory myRepairStateFactory;
+
+ @Mock
+ private RepairState myRepairState;
+
+ @Mock
+ private RepairStateSnapshot myRepairStateSnapshot;
+
+ @Mock
+ private TableStorageStates myTableStorageStates;
+
+ @Mock
+ private RepairHistoryService myRepairHistory;
+
private final UUID mockNodeID = UUID.randomUUID();
@Before
public void setup()
{
when(mockNode.getHostId()).thenReturn(mockNodeID);
+ when(myRepairState.getSnapshot()).thenReturn(myRepairStateSnapshot);
+ when(myRepairStateFactory.create(eq(mockNode), eq(TABLE_REFERENCE1), any(), any())).thenReturn(myRepairState);
+ when(myRepairStateFactory.create(eq(mockNode), eq(TABLE_REFERENCE2), any(), any())).thenReturn(myRepairState);
+ VnodeRepairStatesImpl vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(Arrays.asList(VNODE_REPAIR_STATE)).build();
+ when(myRepairStateSnapshot.getVnodeRepairStates()).thenReturn(vnodeRepairStates);
}
@Test
public void testConfigureNewTable()
{
- RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder()
- .withReplicationState(myReplicationState).build();
+ RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().build();
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1,
Collections.singleton(RepairConfiguration.DEFAULT));
verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
assertOneTableViewExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT);
repairSchedulerImpl.close();
verify(scheduleManager).deschedule(eq(mockNodeID), any(ScheduledJob.class));
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@Test
public void testConfigureTwoTables()
{
- RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder()
- .withReplicationState(myReplicationState).build();
+ RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().build();
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(RepairConfiguration.DEFAULT));
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE2, Collections.singleton(RepairConfiguration.DEFAULT));
verify(scheduleManager, timeout(1000).times(2)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE2), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
repairSchedulerImpl.close();
verify(scheduleManager, times(1)).deschedule(eq(mockNodeID), any(ScheduledJob.class));
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@Test
public void testRemoveTableConfiguration()
{
- RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder()
- .withReplicationState(myReplicationState).build();
+ RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().build();
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(RepairConfiguration.DEFAULT));
verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
assertOneTableViewExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT);
repairSchedulerImpl.removeConfiguration(mockNode, TABLE_REFERENCE1);
@@ -129,14 +167,14 @@ public void testRemoveTableConfiguration()
repairSchedulerImpl.close();
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@Test
public void testUpdateTableConfiguration()
{
- RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder()
- .withReplicationState(myReplicationState).build();
+ RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().build();
long expectedUpdatedRepairInterval = TimeUnit.DAYS.toMillis(1);
@@ -148,12 +186,17 @@ public void testUpdateTableConfiguration()
verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
assertOneTableViewExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT);
- repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(updatedRepairConfiguration));
+ repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1,
+ Collections.singleton(updatedRepairConfiguration));
verify(scheduleManager, timeout(1000).times(2)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, timeout(1000)).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(updatedRepairConfiguration), any());
+ verify(myRepairState, atLeastOnce()).update();
assertOneTableViewExist(repairSchedulerImpl, TABLE_REFERENCE1, updatedRepairConfiguration);
repairSchedulerImpl.close();
@@ -161,19 +204,21 @@ public void testUpdateTableConfiguration()
assertThat(repairSchedulerImpl.getCurrentRepairJobs()).isEmpty();
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@Test
public void testUpdateTableConfigurationToSame()
{
- RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder()
- .withReplicationState(myReplicationState).build();
+ RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().build();
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(RepairConfiguration.DEFAULT));
verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(ScheduledJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
assertOneTableViewExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT);
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(RepairConfiguration.DEFAULT));
@@ -185,6 +230,7 @@ public void testUpdateTableConfigurationToSame()
assertThat(repairSchedulerImpl.getCurrentRepairJobs()).isEmpty();
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@@ -200,16 +246,22 @@ public void testConfigureTwoSchedulesForOneTable()
repairConfigurations.add(incrementalRepairConfiguration);
repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, repairConfigurations);
- verify(scheduleManager, timeout(1000).times(2)).schedule(eq(mockNodeID), any(IncrementalRepairJob.class));
+ verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(TableRepairJob.class));
+ verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(IncrementalRepairJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT),
+ any());
+ verify(myRepairState, atLeastOnce()).update();
- assertTableViewsExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT, incrementalRepairConfiguration);
+ assertTableViewsExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT,
+ incrementalRepairConfiguration);
repairSchedulerImpl.close();
verify(scheduleManager, times(2)).deschedule(eq(mockNodeID), any(ScheduledJob.class));
assertThat(repairSchedulerImpl.getCurrentRepairJobs()).isEmpty();
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@@ -217,27 +269,32 @@ public void testConfigureTwoSchedulesForOneTable()
public void testScheduleChangesToIncremental()
{
RepairSchedulerImpl repairSchedulerImpl = defaultRepairSchedulerImplBuilder().withReplicationState(myReplicationState).build();
- repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(RepairConfiguration.DEFAULT));
+ repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1,
+ Collections.singleton(RepairConfiguration.DEFAULT));
- // Should change to TableRepairJob.class when implemented
- verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(IncrementalRepairJob.class));
+ verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(TableRepairJob.class));
verify(scheduleManager, never()).deschedule(eq(mockNodeID), any(ScheduledJob.class));
+ verify(myRepairStateFactory).create(eq(mockNode), eq(TABLE_REFERENCE1), eq(RepairConfiguration.DEFAULT), any());
+ verify(myRepairState, atLeastOnce()).update();
assertTableViewsExist(repairSchedulerImpl, TABLE_REFERENCE1, RepairConfiguration.DEFAULT);
RepairConfiguration incrementalRepairConfiguration = RepairConfiguration.newBuilder().withRepairType(
RepairType.INCREMENTAL).build();
- repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1, Collections.singleton(incrementalRepairConfiguration));
+ repairSchedulerImpl.putConfigurations(mockNode, TABLE_REFERENCE1,
+ Collections.singleton(incrementalRepairConfiguration));
- verify(scheduleManager, timeout(1000).times(2)).schedule(eq(mockNodeID), any(IncrementalRepairJob.class));
+ verify(scheduleManager, timeout(1000)).schedule(eq(mockNodeID), any(IncrementalRepairJob.class));
+ verify(scheduleManager).deschedule(eq(mockNodeID), any(TableRepairJob.class));
assertTableViewsExist(repairSchedulerImpl, TABLE_REFERENCE1, incrementalRepairConfiguration);
repairSchedulerImpl.close();
- verify(scheduleManager, times(2)).deschedule(eq(mockNodeID), any(IncrementalRepairJob.class));
+ verify(scheduleManager).deschedule(eq(mockNodeID), any(IncrementalRepairJob.class));
assertThat(repairSchedulerImpl.getCurrentRepairJobs()).isEmpty();
verifyNoMoreInteractions(ignoreStubs(myTableRepairMetrics));
+ verifyNoMoreInteractions(myRepairStateFactory);
verifyNoMoreInteractions(scheduleManager);
}
@@ -278,6 +335,9 @@ private RepairSchedulerImpl.Builder defaultRepairSchedulerImplBuilder()
.withJmxProxyFactory(jmxProxyFactory)
.withTableRepairMetrics(myTableRepairMetrics)
.withScheduleManager(scheduleManager)
- .withCassandraMetrics(myCassandraMetrics);
+ .withRepairStateFactory(myRepairStateFactory)
+ .withTableStorageStates(myTableStorageStates)
+ .withCassandraMetrics(myCassandraMetrics)
+ .withRepairHistory(myRepairHistory);
}
}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/state/TestAlarmPostUpdateHook.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/state/TestAlarmPostUpdateHook.java
new file mode 100644
index 00000000..479a612f
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/state/TestAlarmPostUpdateHook.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair.state;
+
+import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateSnapshot;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+import com.ericsson.bss.cassandra.ecchronos.fm.RepairFaultReporter;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.time.Clock;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static com.ericsson.bss.cassandra.ecchronos.core.impl.table.MockTableReferenceFactory.tableReference;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestAlarmPostUpdateHook
+{
+ private static final String keyspaceName = "keyspace";
+ private static final String tableName = "table";
+
+ private static final long RUN_INTERVAL_IN_DAYS = 1;
+ private static final long GC_GRACE_DAYS = 10;
+
+ @Mock
+ private RepairStateSnapshot myRepairStateSnapshot;
+
+ @Mock
+ private RepairFaultReporter myFaultReporter;
+
+ @Mock
+ private Clock myClock;
+
+ private AlarmPostUpdateHook myPostUpdateHook;
+
+ private final TableReference myTableReference = tableReference(keyspaceName, tableName);
+
+ @Before
+ public void startup()
+ {
+ RepairConfiguration repairConfiguration = RepairConfiguration.newBuilder()
+ .withRepairWarningTime(RUN_INTERVAL_IN_DAYS * 2, TimeUnit.DAYS)
+ .withRepairErrorTime(GC_GRACE_DAYS, TimeUnit.DAYS)
+ .build();
+ myPostUpdateHook = new AlarmPostUpdateHook(myTableReference, repairConfiguration, myFaultReporter);
+
+ myPostUpdateHook.setClock(myClock);
+ }
+
+ @Test
+ public void testThatWarningAlarmIsSentAndCeased()
+ {
+ // setup - not repaired
+ long daysSinceLastRepair = 2;
+ long start = System.currentTimeMillis();
+ long lastRepaired = start - TimeUnit.DAYS.toMillis(daysSinceLastRepair);
+
+ Map expectedData = new HashMap<>();
+ expectedData.put(RepairFaultReporter.FAULT_KEYSPACE, keyspaceName);
+ expectedData.put(RepairFaultReporter.FAULT_TABLE, tableName);
+
+ // mock - not repaired
+ doReturn(lastRepaired).when(myRepairStateSnapshot).lastCompletedAt();
+ when(myClock.millis()).thenReturn(start);
+
+ myPostUpdateHook.postUpdate(myRepairStateSnapshot);
+
+ // verify - not repaired
+ verify(myFaultReporter).raise(eq(RepairFaultReporter.FaultCode.REPAIR_WARNING), eq(expectedData));
+
+ // setup - repaired
+ lastRepaired = start;
+ start = System.currentTimeMillis();
+
+ // mock - repaired
+ doReturn(lastRepaired).when(myRepairStateSnapshot).lastCompletedAt();
+ when(myClock.millis()).thenReturn(start);
+
+ myPostUpdateHook.postUpdate(myRepairStateSnapshot);
+
+ // verify alarm ceased in preValidate
+ verify(myFaultReporter).cease(eq(RepairFaultReporter.FaultCode.REPAIR_WARNING), eq(expectedData));
+ reset(myFaultReporter);
+
+ myPostUpdateHook.postUpdate(myRepairStateSnapshot);
+
+ // verify - repaired
+ verify(myFaultReporter).cease(eq(RepairFaultReporter.FaultCode.REPAIR_WARNING), eq(expectedData));
+ }
+
+ @Test
+ public void testThatErrorAlarmIsSentAndCeased()
+ {
+ // setup - not repaired
+ long daysSinceLastRepair = GC_GRACE_DAYS;
+ long start = System.currentTimeMillis();
+ long lastRepaired = start - TimeUnit.DAYS.toMillis(daysSinceLastRepair);
+
+ Map expectedData = new HashMap<>();
+ expectedData.put(RepairFaultReporter.FAULT_KEYSPACE, keyspaceName);
+ expectedData.put(RepairFaultReporter.FAULT_TABLE, tableName);
+
+ // mock - not repaired
+ doReturn(lastRepaired).when(myRepairStateSnapshot).lastCompletedAt();
+ when(myClock.millis()).thenReturn(start);
+
+ myPostUpdateHook.postUpdate(myRepairStateSnapshot);
+
+ // verify - not repaired
+ verify(myFaultReporter).raise(eq(RepairFaultReporter.FaultCode.REPAIR_ERROR), eq(expectedData));
+
+ // setup - repaired
+ lastRepaired = start;
+ start = System.currentTimeMillis();
+
+ // mock - repaired
+ doReturn(lastRepaired).when(myRepairStateSnapshot).lastCompletedAt();
+ when(myClock.millis()).thenReturn(start);
+
+ myPostUpdateHook.postUpdate(myRepairStateSnapshot);
+
+ // verify - repaired
+ verify(myFaultReporter).cease(eq(RepairFaultReporter.FaultCode.REPAIR_WARNING), eq(expectedData));
+ }
+}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedBaseRange.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedBaseRange.java
new file mode 100644
index 00000000..ccb63477
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedBaseRange.java
@@ -0,0 +1,242 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode;
+
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.google.common.collect.ImmutableSet;
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.math.BigInteger;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestNormalizedBaseRange
+{
+ private static final BigInteger START = BigInteger.ZERO;
+
+ @Mock
+ DriverNode mockNode;
+
+ @Test
+ public void testTransformBaseRange()
+ {
+ VnodeRepairState vnodeRepairState = withVnode(1L, 10L, 1234L, 1235L);
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(vnodeRepairState);
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(vnodeRepairState);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(vnodeRepairState);
+ }
+
+ @Test
+ public void testTransformMaxTokenAsStart()
+ {
+ VnodeRepairState vnodeRepairState = withVnode(Long.MAX_VALUE, Long.MIN_VALUE, 1234L, 1235L);
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(vnodeRepairState);
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, START, bi(1L), 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(vnodeRepairState);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(vnodeRepairState);
+ }
+
+ @Test
+ public void testTransformMaxTokenAsEnd()
+ {
+ VnodeRepairState vnodeRepairState = withVnode(-5L, Long.MAX_VALUE, 1234L, 1235L);
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(vnodeRepairState);
+
+ BigInteger end = bi(Long.MAX_VALUE).add(BigInteger.valueOf(5));
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, START, end, 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(vnodeRepairState);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(vnodeRepairState);
+ }
+
+ @Test
+ public void testTransformBaseRangeFullRange()
+ {
+ VnodeRepairState vnodeRepairState = withVnode(Long.MIN_VALUE, Long.MIN_VALUE, 1234L, 1235L);
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(vnodeRepairState);
+
+ assertThat(normalizedBaseRange.end).isEqualTo(LongTokenRange.FULL_RANGE);
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, START, LongTokenRange.FULL_RANGE, 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(vnodeRepairState);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(vnodeRepairState);
+ }
+
+ @Test
+ public void testTransformSimpleRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(1L, 10L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(2L, 5L, 1235L, 1236L);
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, bi(1L), bi(4L), 1235L, 1236L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(subRange);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(subRange);
+ }
+
+ @Test
+ public void testTransformWraparoundRangeBeforeWraparound()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(-5L, -6L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(55L, 1000L, 1234L, 1235L);
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, bi(60L), bi(1005L), 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(subRange);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(subRange);
+ }
+
+ @Test
+ public void testTransformWraparoundRangeAfterWraparound()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(-5L, -6L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(-20L, -10L, 1234L, 1235L);
+
+ BigInteger start = LongTokenRange.FULL_RANGE.subtract(bi(15L));
+ BigInteger end = LongTokenRange.FULL_RANGE.subtract(bi(5L));
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, start, end, 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(subRange);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(subRange);
+ }
+
+ @Test
+ public void testTransformWraparoundRangeInTheMiddle()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(-5L, -6L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(Long.MAX_VALUE - 5L, Long.MAX_VALUE - 4L, 1234L, 1235L);
+
+ BigInteger start = bi(Long.MAX_VALUE);
+ BigInteger end = start.add(bi(1L));
+
+ NormalizedRange expectedRange = new NormalizedRange(normalizedBaseRange, start, end, 1234L, 1235L);
+
+ NormalizedRange actualRange = normalizedBaseRange.transform(subRange);
+
+ assertThat(actualRange).isEqualTo(expectedRange);
+
+ VnodeRepairState actualVnode = normalizedBaseRange.transform(actualRange);
+ assertThat(actualVnode).isEqualTo(subRange);
+ }
+
+ @Test
+ public void testTransformRangeIntersectingEnd()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(45L, 100L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(90L, 120L, 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> normalizedBaseRange.transform(subRange));
+ }
+
+ @Test
+ public void testTransformRangeIntersectingStart()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(-50L, 15L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(-100L, -30L, 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> normalizedBaseRange.transform(subRange));
+ }
+
+ @Test
+ public void testTransformRangeOutsideBoundary()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 200L, 1234L, 1235L));
+ VnodeRepairState subRange = withVnode(300L, 400L, 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> normalizedBaseRange.transform(subRange));
+ }
+
+ @Test
+ public void testInRangeBoundary()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 150L, 1234L, 1235L));
+
+ assertThat(normalizedBaseRange.inRange(bi(0L))).isTrue();
+ assertThat(normalizedBaseRange.inRange(bi(26L))).isTrue();
+ assertThat(normalizedBaseRange.inRange(bi(50L))).isTrue();
+ }
+
+ @Test
+ public void testOutsideBoundary()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 150L, 1234L, 1235L));
+
+ assertThat(normalizedBaseRange.inRange(bi(-1L))).isFalse();
+ assertThat(normalizedBaseRange.inRange(bi(51L))).isFalse();
+ }
+
+ private BigInteger bi(long token)
+ {
+ return BigInteger.valueOf(token);
+ }
+
+ @Test
+ public void testEqualsContract()
+ {
+ EqualsVerifier.forClass(NormalizedBaseRange.class).usingGetClass()
+ .withPrefabValues(
+ VnodeRepairState.class, withVnode(0L, 0L, 1234L, 1235L), withVnode(0L, 1L, 1234L, 1235L))
+ .withNonnullFields("baseVnode", "end")
+ .verify();
+ }
+
+ private VnodeRepairState withVnode(long start, long end, long startedAt, long finishedAt)
+ {
+ return new VnodeRepairState(new LongTokenRange(start, end), ImmutableSet.of(mockNode), startedAt, finishedAt);
+ }
+}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedRange.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedRange.java
new file mode 100644
index 00000000..4f1a5a57
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestNormalizedRange.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode;
+
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.google.common.collect.ImmutableSet;
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.math.BigInteger;
+
+
+import static com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode.NormalizedRange.UNKNOWN_REPAIR_TIME;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestNormalizedRange
+{
+ private static final BigInteger START = BigInteger.ZERO;
+
+ @Mock
+ DriverNode mockNode;
+
+ @Test
+ public void testMutateStart()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 109L, 1234L, 1235L));
+ NormalizedRange normalizedRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ NormalizedRange withNewStart = normalizedRange.mutateStart(bi(8L));
+ assertThat(withNewStart.start()).isEqualTo(bi(8L));
+ assertThat(withNewStart.end()).isEqualTo(bi(9L));
+ assertThat(withNewStart.getStartedAt()).isEqualTo(1234L);
+ assertThat(withNewStart.getFinishedAt()).isEqualTo(1235L);
+ assertThat(withNewStart.getRepairTime()).isEqualTo(UNKNOWN_REPAIR_TIME);
+ }
+
+ @Test
+ public void testMutateStartOutsideBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 109L, 1234L, 1235L));
+ NormalizedRange normalizedRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> normalizedRange.mutateStart(bi(13L)));
+ }
+
+ @Test
+ public void testMutateEnd()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 109L, 1234L, 1235L));
+ NormalizedRange normalizedRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ NormalizedRange withNewEnd = normalizedRange.mutateEnd(bi(8L));
+ assertThat(withNewEnd.start()).isEqualTo(START);
+ assertThat(withNewEnd.end()).isEqualTo(bi(8L));
+ assertThat(withNewEnd.getStartedAt()).isEqualTo(1234L);
+ assertThat(withNewEnd.getFinishedAt()).isEqualTo(1235L);
+ assertThat(withNewEnd.getRepairTime()).isEqualTo(UNKNOWN_REPAIR_TIME);
+ }
+
+ @Test
+ public void testMutateEndOutsideBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 109L, 1234L, 1235L));
+ NormalizedRange normalizedRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> normalizedRange.mutateEnd(bi(13)));
+ }
+
+ @Test
+ public void testBetween()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(13L), bi(15L), 1235L, 1236L);
+
+ NormalizedRange between = firstRange.between(secondRange, 1236L, 1237L);
+ assertThat(between.start()).isEqualTo(bi(9L));
+ assertThat(between.end()).isEqualTo(bi(13L));
+ assertThat(between.getStartedAt()).isEqualTo(1236L);
+ assertThat(between.getFinishedAt()).isEqualTo(1237L);
+ assertThat(between.getRepairTime()).isEqualTo(UNKNOWN_REPAIR_TIME);
+ }
+
+ @Test
+ public void testBetweenDifferentBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 130L, 1234L, 1235L));
+ NormalizedBaseRange normalizedBaseRange2 = new NormalizedBaseRange(withVnode(0L, 31L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange2, bi(13L), bi(15L), 1235L, 1236L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.between(secondRange, 1236L, 1237L));
+ }
+
+ @Test
+ public void testBetweenWrongOrder()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(13L), bi(15L), 1235L, 1236L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.between(secondRange, 1236L, 1237L));
+ }
+
+ @Test
+ public void testBetweenAdjacent()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1235L, 1236L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(9L), bi(13L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.between(secondRange, 1236L, 1237L));
+ }
+
+ @Test
+ public void testSplitEnd()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(9L), bi(15L), 1235L, 1236L);
+
+ NormalizedRange splitted = firstRange.splitEnd(secondRange);
+ assertThat(splitted.start()).isEqualTo(bi(9L));
+ assertThat(splitted.end()).isEqualTo(bi(13L));
+ assertThat(splitted.getStartedAt()).isEqualTo(1235L);
+ assertThat(splitted.getFinishedAt()).isEqualTo(1235L);
+ assertThat(splitted.getRepairTime()).isEqualTo(UNKNOWN_REPAIR_TIME);
+ }
+
+ @Test
+ public void testSplitEndDifferentBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedBaseRange normalizedBaseRange2 = new NormalizedBaseRange(withVnode(100L, 116L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange2, bi(9L), bi(15L), 1235L, 1236L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.splitEnd(secondRange));
+ }
+
+ @Test
+ public void testSplitEndWrongOrder()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(9L), bi(15L), 1235L, 1236L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.splitEnd(secondRange));
+ }
+
+ @Test
+ public void testSplitEndAdjacent()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(9L), 1235L, 1236L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(9L), bi(13L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.splitEnd(secondRange));
+ }
+
+ @Test
+ public void testCombine()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(13L), bi(15L), 1235L, 1236L);
+
+ NormalizedRange combined = firstRange.combine(secondRange);
+ assertThat(combined.start()).isEqualTo(START);
+ assertThat(combined.end()).isEqualTo(bi(15L));
+ assertThat(combined.getStartedAt()).isEqualTo(1234L);
+ assertThat(combined.getFinishedAt()).isEqualTo(1236L);
+ assertThat(combined.getRepairTime()).isEqualTo(2L);
+ }
+
+ @Test
+ public void testCombineDifferentBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedBaseRange normalizedBaseRange2 = new NormalizedBaseRange(withVnode(100L, 116L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange2, bi(13L), bi(15L), 1235L, 1236L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.combine(secondRange));
+ }
+
+ @Test
+ public void testCombineWrongOrder()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(13L), bi(15L), 1235L, 1236L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.combine(secondRange));
+ }
+
+ @Test
+ public void testIsCovering()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(10L), bi(12L), 1235L, 1236L);
+
+ assertThat(firstRange.isCovering(secondRange)).isTrue();
+ }
+
+ @Test
+ public void testIsCoveringSameStart()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, START, bi(12L), 1235L, 1236L);
+
+ assertThat(firstRange.isCovering(secondRange)).isTrue();
+ }
+
+ @Test
+ public void testIsCoveringSameEnd()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(10L), bi(13L), 1235L, 1236L);
+
+ assertThat(firstRange.isCovering(secondRange)).isTrue();
+ }
+
+ @Test
+ public void testIsCoveringOutsideStart()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(4L), bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(3L), bi(12L), 1235L, 1236L);
+
+ assertThat(firstRange.isCovering(secondRange)).isFalse();
+ }
+
+ @Test
+ public void testIsCoveringOutsideEnd()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(4L), bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, bi(5L), bi(15L), 1235L, 1236L);
+
+ assertThat(firstRange.isCovering(secondRange)).isFalse();
+ }
+
+ @Test
+ public void testIsCoveringDifferentBaseRange()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedBaseRange normalizedBaseRange2 = new NormalizedBaseRange(withVnode(100L, 116L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange2, bi(10L), bi(12L), 1235L, 1236L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> firstRange.isCovering(secondRange));
+ }
+
+ @Test
+ public void testIsCoveringReverse()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 115L, 1234L, 1235L));
+ NormalizedRange firstRange = new NormalizedRange(normalizedBaseRange, bi(10L), bi(12L), 1235L, 1235L);
+ NormalizedRange secondRange = new NormalizedRange(normalizedBaseRange, START, bi(13L), 1234L, 1235L);
+
+ assertThat(firstRange.isCovering(secondRange)).isFalse();
+ }
+
+ @Test
+ public void testCompareSimpleFirst()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 99L, 1234L, 1235L));
+ NormalizedRange range1 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+ NormalizedRange range2 = new NormalizedRange(normalizedBaseRange, bi(5L), bi(10L), 1234L, 1235L);
+
+ assertThat(range1.compareTo(range2)).isLessThan(0);
+ }
+
+ @Test
+ public void testCompareSimpleAfter()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 99L, 1234L, 1235L));
+ NormalizedRange range1 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+ NormalizedRange range2 = new NormalizedRange(normalizedBaseRange, bi(5L), bi(10L), 1234L, 1235L);
+
+ assertThat(range2.compareTo(range1)).isGreaterThan(0);
+ }
+
+ @Test
+ public void testCompareSame()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 99L, 1234L, 1235L));
+ NormalizedRange range1 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+ NormalizedRange range2 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+
+ assertThat(range2.compareTo(range1)).isEqualTo(0);
+ }
+
+ @Test
+ public void testCompareSameStart()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 99L, 1234L, 1235L));
+ NormalizedRange range1 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+ NormalizedRange range2 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(10L), 1234L, 1235L);
+
+ assertThat(range2.compareTo(range1)).isLessThan(0);
+ }
+
+ @Test
+ public void testCompareDifferentBaseRanges()
+ {
+ NormalizedBaseRange normalizedBaseRange = new NormalizedBaseRange(withVnode(100L, 99L, 1234L, 1235L));
+ NormalizedBaseRange normalizedBaseRange2 = new NormalizedBaseRange(withVnode(100L, Long.MAX_VALUE, 1234L, 1235L));
+ NormalizedRange range1 = new NormalizedRange(normalizedBaseRange, bi(1L), bi(5L), 1234L, 1235L);
+ NormalizedRange range2 = new NormalizedRange(normalizedBaseRange2, bi(1L), bi(10L), 1234L, 1235L);
+
+ assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> range1.compareTo(range2));
+ }
+
+ @Test
+ public void testEqualsContract()
+ {
+ EqualsVerifier.forClass(NormalizedRange.class).usingGetClass()
+ .withPrefabValues(
+ VnodeRepairState.class, withVnode(0L, 0L, 1234L, 1235L), withVnode(0L, 1L, 1234L, 1236L))
+ .withNonnullFields("base", "start", "end")
+ .verify();
+ }
+
+ private BigInteger bi(long token)
+ {
+ return BigInteger.valueOf(token);
+ }
+
+ private VnodeRepairState withVnode(long start, long end, long startedAt, long finishedAt)
+ {
+ return new VnodeRepairState(new LongTokenRange(start, end), ImmutableSet.of(mockNode), startedAt, finishedAt);
+ }
+}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateFactoryImpl.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateFactoryImpl.java
new file mode 100644
index 00000000..b8ca5bfe
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateFactoryImpl.java
@@ -0,0 +1,815 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode;
+
+import static com.ericsson.bss.cassandra.ecchronos.core.impl.table.MockTableReferenceFactory.tableReference;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairEntry;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairHistoryProvider;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairStateSnapshot;
+import com.ericsson.bss.cassandra.ecchronos.core.state.ReplicationState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairStateFactory;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairStates;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+import com.google.common.collect.AbstractIterator;
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableSet;
+
+@RunWith(MockitoJUnitRunner.Silent.class)
+public class TestVnodeRepairStateFactoryImpl
+{
+ private static final TableReference TABLE_REFERENCE = tableReference("ks", "tb");
+
+ @Mock
+ private ReplicationState mockReplicationState;
+
+ private Map> tokenToNodeMap = new TreeMap<>(
+ Comparator.comparingLong(l -> l.start));
+
+ @Mock
+ private Node myMockNode;
+
+ private RepairHistoryProvider repairHistoryProvider;
+
+ private List repairHistory = new ArrayList<>();
+
+ @Before
+ public void setup()
+ {
+ repairHistoryProvider = new MockedRepairHistoryProvider(myMockNode, TABLE_REFERENCE);
+ when(mockReplicationState.getTokenRangeToReplicas(eq(TABLE_REFERENCE), eq(myMockNode))).thenReturn(tokenToNodeMap);
+ when(mockReplicationState.getTokenRanges(eq(TABLE_REFERENCE), eq(myMockNode))).thenReturn(tokenToNodeMap);
+ }
+
+ @Test
+ public void testEmptyHistoryNoPreviousIsUnrepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ assertNewStateSameForVnodeAndSubrange(newUnrepairedState(range(1, 2)),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testCalculateStateEmptyHistoryIsUnrepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ assertStateSameForVnodeAndSubrange(1234L, 1235L, newUnrepairedState(range(1, 2)),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testCalculateStateClusterWideEmptyHistoryIsUnrepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ assertClusterWideStateSameForVnodeAndSubrange(1234L, 1235L, newUnrepairedState(range(1, 2)),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testEmptyHistoryWithPreviousKeepsRepairedAt() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ RepairStateSnapshot previousSnapshot = snapshot(1234L,
+ newState(range(1, 2), 1234L, 1235L),
+ newState(range(2, 3), 2345L, 2346L));
+
+ assertNewVnodeStates(previousSnapshot,
+ newState(range(1, 2), 1234L, 1235L),
+ newState(range(2, 3), 2345L, 2346L));
+ assertNewSubRangeStates(previousSnapshot, newState(range(1, 2), 1234L, -1L),
+ newState(range(2, 3), 2345L, 2346L));
+ }
+
+ @Test
+ public void testWithHistoryNoPreviousIsRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ withSuccessfulRepairHistory(range(1, 2), 1234L, 1235L);
+ withSuccessfulRepairHistory(range(2, 3), 2345L, 2346L);
+
+ assertNewStateSameForVnodeAndSubrange(newState(range(1, 2), 1234L, 1235L),
+ newState(range(2, 3), 2345L, 2346L));
+ }
+
+ @Test
+ public void testCalculateStateWithHistoryIsRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ withSuccessfulRepairHistory(range(1, 2), 1234L, 1235L);
+ withSuccessfulRepairHistory(range(2, 3), 2345L, 2346L);
+
+ assertStateSameForVnodeAndSubrange(2346L, 1234L,
+ newState(range(1, 2), 1234L, 1235L),
+ newState(range(2, 3), 2345L, 2346L));
+ }
+
+ @Test
+ public void testCalculateClusterWideStateWithHistoryIsRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ withSuccessfulRepairHistory(range(1, 2), 1234L, 1235L);
+ withSuccessfulRepairHistory(range(2, 3), 2345L, 2346L);
+
+ assertClusterWideStateSameForVnodeAndSubrange(2346L, 1234L,
+ newState(range(1, 2), 1234L, 1235L),
+ newState(range(2, 3), 2345L, 2346L));
+ }
+
+ @Test
+ public void testWithSubRangeHistoryNoPreviousIsRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 5), node1, node2);
+ withRange(range(5, 10), node1, node2);
+
+ long range1StartedAt = TimeUnit.DAYS.toMillis(10);
+ long range1FinishedAt = TimeUnit.DAYS.toMillis(11);
+ long range2StartedAt = TimeUnit.DAYS.toMillis(11);
+ long range2FinishedAt = TimeUnit.DAYS.toMillis(12);
+
+ withSubRangeSuccessfulRepairHistory(range(1, 3), range1StartedAt, range1FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(3, 5), range1StartedAt, range1FinishedAt);
+
+ withSubRangeSuccessfulRepairHistory(range(5, 8), range2StartedAt, range2FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(8, 10), range2StartedAt, range2FinishedAt);
+
+ assertNewVnodeStates(newUnrepairedState(range(1, 5)),
+ newUnrepairedState(range(5, 10)));
+ assertNewSubRangeStates(newState(range(1, 5), range1StartedAt, range1FinishedAt, (range1FinishedAt-range1StartedAt) + (range1FinishedAt-range1StartedAt)),
+ newState(range(5, 10), range2StartedAt, range2FinishedAt, (range2FinishedAt-range2StartedAt) + (range2FinishedAt-range2StartedAt)));
+ }
+
+ @Test
+ public void testWithSubRangeHistoryNoPreviousIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 5), node1, node2);
+ withRange(range(5, 10), node1, node2);
+
+ long range1StartedAt = TimeUnit.DAYS.toMillis(10);
+ long range1FinishedAt = TimeUnit.DAYS.toMillis(10);
+ long range2StartedAt = TimeUnit.DAYS.toMillis(11);
+ long range2FinishedAt = TimeUnit.DAYS.toMillis(11);
+
+ withSubRangeSuccessfulRepairHistory(range(1, 3), range1StartedAt, range1FinishedAt);
+
+ withSubRangeSuccessfulRepairHistory(range(5, 8), range2StartedAt, range2FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(8, 10), range2StartedAt, range2FinishedAt);
+
+ assertNewVnodeStates(newUnrepairedState(range(1, 5)),
+ newUnrepairedState(range(5, 10)));
+ assertNewSubRangeStates(newSubRangeState(range(1, 3), range1StartedAt, range1FinishedAt),
+ newSubRangeUnrepairedState(range(3, 5)),
+ newState(range(5, 10), range2StartedAt, range2FinishedAt));
+ }
+
+ @Test
+ public void testCalculateStateWithSubRangeHistoryIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 5), node1, node2);
+ withRange(range(5, 10), node1, node2);
+
+ long range1StartedAt = TimeUnit.DAYS.toMillis(10);
+ long range1FinishedAt = TimeUnit.DAYS.toMillis(10);
+ long range2StartedAt = TimeUnit.DAYS.toMillis(11);
+ long range2FinishedAt = TimeUnit.DAYS.toMillis(11);
+
+ withSubRangeSuccessfulRepairHistory(range(1, 3), range1StartedAt, range1FinishedAt);
+
+ withSubRangeSuccessfulRepairHistory(range(5, 8), range2StartedAt, range2FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(8, 10), range2StartedAt, range2FinishedAt);
+
+ assertVnodeStates(range1StartedAt, range2FinishedAt, newUnrepairedState(range(1, 5)),
+ newUnrepairedState(range(5, 10)));
+ assertSubRangeStates(range2FinishedAt, range1StartedAt,
+ newSubRangeState(range(1, 3), range1StartedAt, range1FinishedAt),
+ newSubRangeUnrepairedState(range(3, 5)),
+ newState(range(5, 10), range2StartedAt, range2FinishedAt));
+ }
+
+ @Test
+ public void testCalculateClusterWideStateWithSubRangeHistoryIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 5), node1, node2);
+ withRange(range(5, 10), node1, node2);
+
+ long range1StartedAt = TimeUnit.DAYS.toMillis(10);
+ long range1FinishedAt = TimeUnit.DAYS.toMillis(10);
+ long range2StartedAt = TimeUnit.DAYS.toMillis(11);
+ long range2FinishedAt = TimeUnit.DAYS.toMillis(11);
+
+ withSubRangeSuccessfulRepairHistory(range(1, 3), range1StartedAt, range1FinishedAt);
+
+ withSubRangeSuccessfulRepairHistory(range(5, 8), range2StartedAt, range2FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(8, 10), range2StartedAt, range2FinishedAt);
+
+ assertClusterWideVnodeStates(range1StartedAt, range2FinishedAt, newUnrepairedState(range(1, 5)),
+ newUnrepairedState(range(5, 10)));
+ assertClusterWideSubRangeStates(range2FinishedAt, range1StartedAt,
+ newSubRangeState(range(1, 3), range1StartedAt, range1FinishedAt),
+ newSubRangeUnrepairedState(range(3, 5)),
+ newState(range(5, 10), range2StartedAt, range2FinishedAt));
+ }
+
+ @Test
+ public void testWithSubRangeHistoryAndPreviousIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ long firstStartedAt = TimeUnit.DAYS.toMillis(8);
+ long firstFinishedAt = TimeUnit.DAYS.toMillis(8);
+ long range1StartedAt = TimeUnit.DAYS.toMillis(10);
+ long range1FinishedAt = TimeUnit.DAYS.toMillis(10);
+ long range2StartedAt = TimeUnit.DAYS.toMillis(11);
+ long range2FinishedAt = TimeUnit.DAYS.toMillis(11);
+
+ withRange(range(1, 5), node1, node2);
+ withRange(range(5, 10), node1, node2);
+
+ withSubRangeSuccessfulRepairHistory(range(1, 3), range1StartedAt, range1FinishedAt);
+
+ withSubRangeSuccessfulRepairHistory(range(5, 8), range2StartedAt, range2FinishedAt);
+ withSubRangeSuccessfulRepairHistory(range(8, 10), range2StartedAt, range2FinishedAt);
+
+ RepairStateSnapshot previousSnapshot = snapshot(firstStartedAt,
+ newState(range(1, 5), firstStartedAt, firstFinishedAt),
+ newState(range(5, 10), firstStartedAt, firstFinishedAt));
+
+ assertNewVnodeStates(previousSnapshot,
+ newState(range(1, 5), firstStartedAt, firstFinishedAt),
+ newState(range(5, 10), firstStartedAt, firstFinishedAt));
+
+ assertNewSubRangeStates(previousSnapshot,
+ newSubRangeState(range(1, 3), range1StartedAt, range1FinishedAt),
+ newSubRangeState(range(3, 5), firstStartedAt, VnodeRepairState.UNREPAIRED),
+ newSubRangeState(range(5, 10), range2StartedAt, range2FinishedAt));
+ }
+
+ @Test
+ public void testWithHistoryNoPreviousIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ long range1StartedAt = 1;
+ long range1FinishedAt = 2;
+ long range2StartedAt = 3;
+
+ withSuccessfulRepairHistory(range(1, 2), range1StartedAt, range1FinishedAt);
+ withFailedRepairHistory(range(2, 3), range2StartedAt);
+
+ assertNewStateSameForVnodeAndSubrange(newState(range(1, 2), range1StartedAt, range1FinishedAt),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testCalculateStateWithHistoryIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ long range1StartedAt = 1;
+ long range1FinishedAt = 2;
+ long range2StartedAt = 3;
+
+ withSuccessfulRepairHistory(range(1, 2), range1StartedAt, range1FinishedAt);
+ withFailedRepairHistory(range(2, 3), range2StartedAt);
+
+ assertStateSameForVnodeAndSubrange(range2StartedAt, range1StartedAt, newState(range(1, 2), range1StartedAt, range1FinishedAt),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testCalculateClusterWideStateWithHistoryIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node2);
+
+ long range1StartedAt = 1;
+ long range1FinishedAt = 2;
+ long range2StartedAt = 3;
+
+ withSuccessfulRepairHistory(range(1, 2), range1StartedAt, range1FinishedAt);
+ withFailedRepairHistory(range(2, 3), range2StartedAt);
+
+ assertClusterWideStateSameForVnodeAndSubrange(range2StartedAt, range1StartedAt, newState(range(1, 2),
+ range1StartedAt, range1FinishedAt), newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testWithOldHistoryNoPreviousIsPartiallyRepaired() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+ DriverNode node3 = withNode("127.0.0.3");
+
+ long range1StartedAt = 1;
+ long range1FinishedAt = 2;
+ long range2StartedAt = 3;
+ long range2FinishedAt = 4;
+
+ withRange(range(1, 2), node1, node2);
+ withRange(range(2, 3), node1, node3);
+ withSuccessfulRepairHistory(range(2, 3), range2StartedAt, range2FinishedAt); // Previous replication
+
+ replaceRange(range(2, 3), range(2, 3), node1, node2);
+
+ withSuccessfulRepairHistory(range(1, 2), range1StartedAt, range1FinishedAt);
+
+ assertNewStateSameForVnodeAndSubrange(newState(range(1, 2), range1StartedAt, range1FinishedAt),
+ newUnrepairedState(range(2, 3)));
+ }
+
+ @Test
+ public void testWithHistoryAndPreviousAfterScaleOut() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+ DriverNode node3 = withNode("127.0.0.3");
+
+ withRange(range(1, 4), node1, node2);
+ withRange(range(5, 0), node1, node2);
+
+ replaceRange(range(1, 4), range(1, 2), node1, node3);
+
+ RepairStateSnapshot previousSnapshot = snapshot(1234L,
+ newState(range(1, 4), 1234L, 1235L),
+ newState(range(5, 0), 1236L, 1237L));
+
+ assertNewStateSameForVnodeAndSubrange(previousSnapshot,
+ newState(range(1, 2), 1234L, VnodeRepairState.UNREPAIRED),
+ newState(range(5, 0), 1236L, 1237L));
+ }
+
+ @Test
+ public void testWithHistoryAndPreviousOnlyIteratesOverDiff() throws UnknownHostException
+ {
+ DriverNode node1 = withNode("127.0.0.1");
+ DriverNode node2 = withNode("127.0.0.2");
+
+ LongTokenRange longTokenRange1 = range(1, 2);
+ LongTokenRange longTokenRange2 = range(2, 3);
+ withRange(longTokenRange1, node1, node2);
+ withRange(longTokenRange2, node1, node2);
+ ImmutableSet replicas = ImmutableSet.of(node1, node2);
+
+ Map> tokenToHostMap = new HashMap<>();
+ tokenToHostMap.put(longTokenRange1, replicas);
+ tokenToHostMap.put(longTokenRange2, replicas);
+
+ long range1RepairedAt = 1;
+ long range2RepairedAt = 2;
+ RepairEntry repairEntry1 = new RepairEntry(longTokenRange1, range1RepairedAt, range1RepairedAt, replicas, "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(longTokenRange2, range2RepairedAt, range2RepairedAt, replicas, "SUCCESS");
+ List firstIterateRepairEntries = new ArrayList<>();
+ firstIterateRepairEntries.add(repairEntry1);
+ firstIterateRepairEntries.add(repairEntry2);
+
+ when(mockReplicationState.getTokenRangeToReplicas(eq(TABLE_REFERENCE), eq(myMockNode))).thenReturn(tokenToHostMap);
+ repairHistoryProvider = mock(RepairHistoryProvider.class);
+ when(repairHistoryProvider.iterate(eq(myMockNode), eq(TABLE_REFERENCE), any(long.class), any(Predicate.class))).thenReturn(
+ firstIterateRepairEntries.iterator());
+
+ assertNewVnodeStates(newState(range(1, 2), range1RepairedAt, range1RepairedAt),
+ newState(range(2, 3), range2RepairedAt, range2RepairedAt));
+
+ // Check that vnodes keep their states from old snapshot even if iterator is empty
+ long firstSnapshotCreatedAt = 3;
+ RepairStateSnapshot firstRepairStateSnapshot = snapshot(range1RepairedAt, firstSnapshotCreatedAt,
+ newState(range(1, 2), range1RepairedAt, range1RepairedAt),
+ newState(range(2, 3), range2RepairedAt, range2RepairedAt));
+ List secondIterateRepairEntries = new ArrayList<>();
+
+ when(repairHistoryProvider.iterate(eq(myMockNode), eq(TABLE_REFERENCE), any(long.class), eq(firstSnapshotCreatedAt),
+ any(Predicate.class))).thenReturn(secondIterateRepairEntries.iterator());
+
+ assertNewVnodeStates(firstRepairStateSnapshot, newState(range(1, 2), range1RepairedAt, range1RepairedAt),
+ newState(range(2, 3), range2RepairedAt, range2RepairedAt));
+
+ // Check that vnodes get updated for the new repair entries and old are kept from old snapshot
+ long secondSnapshotCreatedAt = 5;
+ RepairStateSnapshot secondRepairStateSnapshot = snapshot(range1RepairedAt, secondSnapshotCreatedAt,
+ newState(range(1, 2), range1RepairedAt, range1RepairedAt),
+ newState(range(2, 3), range2RepairedAt, range2RepairedAt));
+ long updateRange1RepairedAt = 4;
+ RepairEntry repairEntry3 = new RepairEntry(longTokenRange1, updateRange1RepairedAt, updateRange1RepairedAt, replicas, "SUCCESS");
+ List thirdIterateRepairEntries = new ArrayList<>();
+ thirdIterateRepairEntries.add(repairEntry3);
+
+ when(repairHistoryProvider.iterate(eq(myMockNode), eq(TABLE_REFERENCE), any(long.class), eq(secondSnapshotCreatedAt),
+ any(Predicate.class))).thenReturn(thirdIterateRepairEntries.iterator());
+ assertNewVnodeStates(secondRepairStateSnapshot, newState(range(1, 2), updateRange1RepairedAt, updateRange1RepairedAt),
+ newState(range(2, 3), range2RepairedAt, range2RepairedAt));
+ }
+
+ private RepairStateSnapshot snapshot(long repairedAt, VnodeRepairState... states)
+ {
+ return snapshot(repairedAt, repairedAt, states);
+ }
+
+ private RepairStateSnapshot snapshot(long repairedAt, long createdAt, VnodeRepairState... states)
+ {
+ return RepairStateSnapshot.newBuilder()
+ .withLastCompletedAt(repairedAt)
+ .withReplicaRepairGroups(Collections.emptyList())
+ .withVnodeRepairStates(vnodeRepairStates(states))
+ .withCreatedAt(createdAt)
+ .build();
+ }
+
+ private VnodeRepairStates vnodeRepairStates(VnodeRepairState... states)
+ {
+ return VnodeRepairStatesImpl.newBuilder(Arrays.asList(states)).build();
+ }
+
+ private void withSubRangeSuccessfulRepairHistory(LongTokenRange range, long startedAt, long finishedAt)
+ {
+ ImmutableSet replicas = getKnownReplicasForSubRange(range);
+ withRepairHistory(range, startedAt, finishedAt, replicas, "SUCCESS");
+ }
+
+ private void withSuccessfulRepairHistory(LongTokenRange range, long startedAt, long finishedAt)
+ {
+ ImmutableSet replicas = getKnownReplicas(range);
+ withRepairHistory(range, startedAt, finishedAt, replicas, "SUCCESS");
+ }
+
+ private void withFailedRepairHistory(LongTokenRange range, long startedAt)
+ {
+ ImmutableSet replicas = getKnownReplicas(range);
+ withRepairHistory(range, startedAt, VnodeRepairState.UNREPAIRED, replicas, "FAILED");
+ }
+
+ private void withRepairHistory(LongTokenRange range, long startedAt, long finishedAt, ImmutableSet replicas, String status)
+ {
+ RepairEntry repairEntry = new RepairEntry(range, startedAt, finishedAt, replicas, status);
+ repairHistory.add(repairEntry);
+ }
+
+ private VnodeRepairState newUnrepairedState(LongTokenRange range)
+ {
+ return newState(range, VnodeRepairState.UNREPAIRED, VnodeRepairState.UNREPAIRED);
+ }
+
+ private VnodeRepairState newState(LongTokenRange range, long startedAt, long finishedAt)
+ {
+ return new VnodeRepairState(range, getKnownReplicas(range), startedAt, finishedAt);
+ }
+
+ private VnodeRepairState newState(LongTokenRange range, long startedAt, long finishedAt, long repairTime)
+ {
+ return new VnodeRepairState(range, getKnownReplicas(range), startedAt, finishedAt, repairTime);
+ }
+
+ private VnodeRepairState newSubRangeUnrepairedState(LongTokenRange range)
+ {
+ return newSubRangeState(range, VnodeRepairState.UNREPAIRED, VnodeRepairState.UNREPAIRED);
+ }
+
+ private VnodeRepairState newSubRangeState(LongTokenRange range, long startedAt, long finishedAt)
+ {
+ return new VnodeRepairState(range, getKnownReplicasForSubRange(range), startedAt, finishedAt);
+ }
+
+ private ImmutableSet getKnownReplicasForSubRange(LongTokenRange range)
+ {
+ ImmutableSet replicas = tokenToNodeMap.get(range);
+ if (replicas == null)
+ {
+ for (LongTokenRange vnode : tokenToNodeMap.keySet())
+ {
+ if (vnode.isCovering(range))
+ {
+ replicas = tokenToNodeMap.get(vnode);
+ break;
+ }
+ }
+
+ assertThat(replicas).isNotNull();
+ }
+
+ return replicas;
+ }
+
+ private ImmutableSet getKnownReplicas(LongTokenRange range)
+ {
+ ImmutableSet replicas = tokenToNodeMap.get(range);
+ assertThat(replicas).isNotNull();
+ return replicas;
+ }
+
+ private LongTokenRange range(long start, long end)
+ {
+ return new LongTokenRange(start, end);
+ }
+
+ private void withRange(LongTokenRange range, DriverNode... replicas)
+ {
+ tokenToNodeMap.put(range, ImmutableSet.copyOf(replicas));
+ }
+
+ private void replaceRange(LongTokenRange previousRange, LongTokenRange newRange, DriverNode... newReplicas)
+ {
+ tokenToNodeMap.remove(previousRange);
+ withRange(newRange, newReplicas);
+ }
+
+ private DriverNode withNode(String inetAddress) throws UnknownHostException
+ {
+ DriverNode node = mock(DriverNode.class);
+ InetAddress nodeAddress = InetAddress.getByName(inetAddress);
+ when(node.getPublicAddress()).thenReturn(nodeAddress);
+ return node;
+ }
+
+ private void assertNewVnodeStates(VnodeRepairState... states)
+ {
+ assertNewVnodeStates(null, states);
+ }
+
+ private void assertNewVnodeStates(RepairStateSnapshot previous, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory vnodeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, false);
+ assertNewState(vnodeRepairStateFactory, previous, VnodeRepairStatesImpl.class, states);
+ }
+
+ private void assertNewSubRangeStates(VnodeRepairState... states)
+ {
+ assertNewSubRangeStates(null, states);
+ }
+
+ private void assertNewSubRangeStates(RepairStateSnapshot previous, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory subRangeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, true);
+ assertNewState(subRangeRepairStateFactory, previous, SubRangeRepairStates.class, states);
+ }
+
+ private void assertNewStateSameForVnodeAndSubrange(VnodeRepairState... states)
+ {
+ assertNewStateSameForVnodeAndSubrange(null, states);
+ }
+
+ private void assertNewStateSameForVnodeAndSubrange(RepairStateSnapshot previous, VnodeRepairState... states)
+ {
+ assertNewVnodeStates(previous, states);
+ assertNewSubRangeStates(previous, states);
+ }
+
+ private void assertNewState(VnodeRepairStateFactory factory, RepairStateSnapshot previous, Class expectedClass, VnodeRepairState... expectedStates)
+ {
+ assertNewState(factory, previous, expectedClass, Arrays.asList(expectedStates));
+ }
+
+ private void assertNewState(VnodeRepairStateFactory factory, RepairStateSnapshot previous, Class expectedClass, Collection expectedStates)
+ {
+ VnodeRepairStates newStates = factory.calculateNewState(myMockNode, TABLE_REFERENCE, previous, System.currentTimeMillis());
+ assertThat(newStates).isInstanceOf(expectedClass);
+
+ Collection vnodeRepairStates = newStates.getVnodeRepairStates();
+ assertThat(vnodeRepairStates).containsOnlyElementsOf(expectedStates);
+ }
+
+ private void assertClusterWideStateSameForVnodeAndSubrange(long to, long from, VnodeRepairState... states)
+ {
+ assertClusterWideVnodeStates(to, from, states);
+ assertClusterWideSubRangeStates(to, from, states);
+ }
+
+ private void assertClusterWideVnodeStates(long to, long from, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory vnodeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, false);
+ assertClusterWideState(vnodeRepairStateFactory, to, from, VnodeRepairStatesImpl.class, states);
+ }
+
+ private void assertClusterWideSubRangeStates(long to, long from, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory subRangeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, true);
+ assertClusterWideState(subRangeRepairStateFactory, to, from, SubRangeRepairStates.class, states);
+ }
+
+ private void assertClusterWideState(VnodeRepairStateFactory factory, long to, long from, Class expectedClass, VnodeRepairState... expectedStates)
+ {
+ assertClusterWideState(factory, to, from, expectedClass, Arrays.asList(expectedStates));
+ }
+
+ private void assertClusterWideState(VnodeRepairStateFactory factory, long to, long from, Class expectedClass, Collection expectedStates)
+ {
+ VnodeRepairStates states = factory.calculateClusterWideState(myMockNode, TABLE_REFERENCE, to, from);
+ assertThat(states).isInstanceOf(expectedClass);
+
+ Collection vnodeRepairStates = states.getVnodeRepairStates();
+ assertThat(vnodeRepairStates).containsOnlyElementsOf(expectedStates);
+ }
+
+ private void assertStateSameForVnodeAndSubrange(long to, long from, VnodeRepairState... states)
+ {
+ assertVnodeStates(to, from, states);
+ assertSubRangeStates(to, from, states);
+ }
+
+ private void assertVnodeStates(long to, long from, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory vnodeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, false);
+ assertState(vnodeRepairStateFactory, to, from, VnodeRepairStatesImpl.class, states);
+ }
+
+ private void assertSubRangeStates(long to, long from, VnodeRepairState... states)
+ {
+ VnodeRepairStateFactory subRangeRepairStateFactory = new VnodeRepairStateFactoryImpl(mockReplicationState, repairHistoryProvider, true);
+ assertState(subRangeRepairStateFactory, to, from, SubRangeRepairStates.class, states);
+ }
+
+ private void assertState(VnodeRepairStateFactory factory, long to, long from, Class expectedClass, VnodeRepairState... expectedStates)
+ {
+ assertState(factory, to, from, expectedClass, Arrays.asList(expectedStates));
+ }
+
+ private void assertState(VnodeRepairStateFactory factory, long to, long from, Class expectedClass, Collection expectedStates)
+ {
+ VnodeRepairStates newStates = factory.calculateClusterWideState(myMockNode, TABLE_REFERENCE, to, from);
+ assertThat(newStates).isInstanceOf(expectedClass);
+
+ Collection vnodeRepairStates = newStates.getVnodeRepairStates();
+ assertThat(vnodeRepairStates).containsOnlyElementsOf(expectedStates);
+ }
+
+ private class MockedRepairHistoryProvider implements RepairHistoryProvider
+ {
+ private final TableReference myTableReference;
+ private final Node myNode;
+
+ public MockedRepairHistoryProvider(Node node, TableReference tableReference)
+ {
+ myNode = node;
+ myTableReference = tableReference;
+ }
+
+ @Override
+ public Iterator iterate(Node node, TableReference tableReference, long to, Predicate predicate)
+ {
+ assertThat(tableReference).isEqualTo(myTableReference);
+
+ if (node != null)
+ {
+ assertThat(node).isEqualTo(myNode);
+ }
+
+ return new MockedRepairEntryIterator(repairHistory.iterator(), predicate, to, -1L);
+ }
+
+ @Override
+ public Iterator iterate(Node node, TableReference tableReference, long to, long from, Predicate predicate)
+ {
+ assertThat(tableReference).isEqualTo(myTableReference);
+
+ if (node != null)
+ {
+ assertThat(node).isEqualTo(myNode);
+ }
+
+ return new MockedRepairEntryIterator(repairHistory.iterator(), predicate, to, from);
+ }
+ }
+
+ private static class MockedRepairEntryIterator extends AbstractIterator
+ {
+ private final Iterator myBaseIterator;
+ private final Predicate myPredicate;
+ private final long myTo;
+ private final long myFrom;
+
+ MockedRepairEntryIterator(Iterator baseIterator, Predicate predicate, long to, long from)
+ {
+ myBaseIterator = baseIterator;
+ myPredicate = predicate;
+ myTo = to;
+ myFrom = from;
+ }
+
+ @Override
+ protected RepairEntry computeNext()
+ {
+ while(myBaseIterator.hasNext())
+ {
+ RepairEntry next = myBaseIterator.next();
+ if (next.getFinishedAt() <= myTo)
+ {
+ if (myFrom != -1L)
+ {
+ if (next.getStartedAt() >= myFrom && myPredicate.apply(next))
+ {
+ return next;
+ }
+ }
+ else
+ {
+ if (myPredicate.apply(next))
+ {
+ return next;
+ }
+ }
+ }
+ }
+
+ return endOfData();
+ }
+ }
+}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateSummarizer.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateSummarizer.java
new file mode 100644
index 00000000..b05292ae
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/repair/vnode/TestVnodeRepairStateSummarizer.java
@@ -0,0 +1,388 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode;
+
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestVnodeRepairStateSummarizer
+{
+ @Mock
+ DriverNode mockNode;
+
+ @Test
+ public void summarizeSingleTokenNoPartial()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+ List baseVnodes = Collections.singletonList(baseVnode);
+
+ List actualVnodeRepairStates = summarize(baseVnode);
+
+ assertThat(actualVnodeRepairStates).isEqualTo(baseVnodes);
+ }
+
+ @Test
+ public void summarizeSingleTokenFullPartial()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+ VnodeRepairState partialVnode = withVnode(500, 3000, dateToTimestamp("2020-03-13T16:00:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode);
+
+ assertThat(actualVnodeRepairStates).containsExactly(partialVnode);
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialSequential()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(500, 1800, dateToTimestamp("2020-03-13T15:30:00"));
+ VnodeRepairState partialVnode2 = withVnode(1800, 2500, dateToTimestamp("2020-03-13T16:15:00"));
+ VnodeRepairState partialVnode3 = withVnode(2500, 3000, dateToTimestamp("2020-03-13T16:29:59"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3);
+
+ assertThat(actualVnodeRepairStates).containsExactly(withVnode(500, 3000, dateToTimestamp("2020-03-13T15:30:00")));
+ }
+
+ @Test
+ public void summarizeMultipleAdjacentTokenMultiplePartialSequential()
+ {
+ VnodeRepairState baseVnode1 = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+ VnodeRepairState baseVnode2 = withVnode(3000, 5500, dateToTimestamp("2020-03-12T16:05:00"));
+
+ // Base1
+ VnodeRepairState partialVnode1 = withVnode(500, 1800, dateToTimestamp("2020-03-13T15:30:00"));
+ VnodeRepairState partialVnode2 = withVnode(1800, 2500, dateToTimestamp("2020-03-13T16:15:00"));
+ VnodeRepairState partialVnode3 = withVnode(2500, 3000, dateToTimestamp("2020-03-13T16:29:59"));
+
+ // Base2
+ VnodeRepairState partialVnode4 = withVnode(3000, 3800, dateToTimestamp("2020-03-13T15:45:00"));
+ VnodeRepairState partialVnode5 = withVnode(3800, 4500, dateToTimestamp("2020-03-13T16:15:00"));
+ VnodeRepairState partialVnode6 = withVnode(4500, 5500, dateToTimestamp("2020-03-13T16:29:59"));
+
+ List actualVnodeRepairStates = summarize(Arrays.asList(baseVnode1, baseVnode2),
+ partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactlyInAnyOrder(
+ withVnode(500, 3000, dateToTimestamp("2020-03-13T15:30:00"))
+ ,withVnode(3000, 5500, dateToTimestamp("2020-03-13T15:45:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialSequentialMoreThanOneHour()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(500, 1800, dateToTimestamp("2020-03-13T15:30:00"));
+ VnodeRepairState partialVnode2 = withVnode(1800, 2500, dateToTimestamp("2020-03-13T16:15:00"));
+ VnodeRepairState partialVnode3 = withVnode(2500, 2800, dateToTimestamp("2020-03-13T16:30:01"));
+ VnodeRepairState partialVnode4 = withVnode(2800, 3000, dateToTimestamp("2020-03-13T16:31:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(500, 2500, dateToTimestamp("2020-03-13T15:30:00")),
+ withVnode(2500, 3000, dateToTimestamp("2020-03-13T16:30:01"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialNonSequential()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(600, 1800, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(2000, 2800, dateToTimestamp("2020-03-13T16:05:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(500, 600, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(600, 1800, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(1800, 2000, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(2000, 2800, dateToTimestamp("2020-03-13T16:05:00")),
+ withVnode(2800, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialOverlapping()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(600, 1800, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(1600, 2800, dateToTimestamp("2020-03-13T16:05:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(500, 600, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(600, 2800, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(2800, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialOverlappingMoreThanOneHour()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(600, 1800, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(1600, 2800, dateToTimestamp("2020-03-13T17:00:01"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(500, 600, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(600, 1600, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(1600, 2800, dateToTimestamp("2020-03-13T17:00:01")),
+ withVnode(2800, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialOverlappingMoreThanOneHourBefore()
+ {
+ VnodeRepairState baseVnode = withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(600, 1800, dateToTimestamp("2020-03-13T17:00:01"));
+ VnodeRepairState partialVnode2 = withVnode(1600, 2800, dateToTimestamp("2020-03-13T16:00:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(500, 600, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(600, 1800, dateToTimestamp("2020-03-13T17:00:01")),
+ withVnode(1800, 2800, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(2800, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialWrapAroundSequential()
+ {
+ VnodeRepairState baseVnode = withVnode(30000, 15000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(40000, 50000, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(-5000, 10000, dateToTimestamp("2020-03-13T16:05:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(30000, 40000, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(40000, 50000, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(50000, -5000, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(-5000, 10000, dateToTimestamp("2020-03-13T16:05:00")),
+ withVnode(10000, 15000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeSingleTokenMultiplePartialOverlappingWrapAround()
+ {
+ VnodeRepairState baseVnode = withVnode(5000, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(600, 1800, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(1600, 2800, dateToTimestamp("2020-03-13T16:05:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(5000, 600, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(600, 2800, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(2800, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeMultipleCoveringAndIntersectingRanges()
+ {
+ VnodeRepairState baseVnode = withVnode(100, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(100, 500, dateToTimestamp("2020-03-13T16:00:00")); // 100 -> 250
+ VnodeRepairState partialVnode2 = withVnode(200, 300, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode3 = withVnode(250, 450, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(250, 600, dateToTimestamp("2020-03-13T17:05:00")); // 250 -> 600
+ VnodeRepairState partialVnode5 = withVnode(400, 500, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode6 = withVnode(400, 3000, dateToTimestamp("2020-03-12T16:05:00")); // 600 -> 3000
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(100, 250, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(250, 600, dateToTimestamp("2020-03-13T17:05:00")),
+ withVnode(600, 3000, dateToTimestamp("2020-03-12T16:05:00"))
+ );
+ }
+
+ @Test
+ public void summarizeMultipleIntersectingRanges()
+ {
+ VnodeRepairState baseVnode = withVnode(100, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(200, 300, dateToTimestamp("2020-03-12T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(200, 400, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode3 = withVnode(200, 500, dateToTimestamp("2020-03-13T16:00:00")); // 100 -> 500
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(100, 200, dateToTimestamp("2020-03-12T16:00:00")),
+ withVnode(200, 500, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(500, 3000, dateToTimestamp("2020-03-12T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeMultipleCoveringAndIntersectingRangesWithLaterRepairedAt()
+ {
+ VnodeRepairState baseVnode = withVnode(100, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(100, 500, dateToTimestamp("2020-03-13T16:00:00")); // 100 -> 200
+ VnodeRepairState partialVnode2 = withVnode(200, 300, dateToTimestamp("2020-03-14T16:05:00")); // 200 -> 500 (1)
+ VnodeRepairState partialVnode3 = withVnode(250, 450, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(250, 600, dateToTimestamp("2020-03-13T17:05:00")); // 500 -> 600
+ VnodeRepairState partialVnode5 = withVnode(400, 500, dateToTimestamp("2020-03-14T16:05:00")); // 200 -> 500 (2)
+ VnodeRepairState partialVnode6 = withVnode(400, 3000, dateToTimestamp("2020-03-13T16:05:00")); // 600 -> 3000
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(100, 200, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(200, 500, dateToTimestamp("2020-03-14T16:05:00")),
+ withVnode(500, 600, dateToTimestamp("2020-03-13T17:05:00")),
+ withVnode(600, 3000, dateToTimestamp("2020-03-13T16:05:00"))
+ );
+ }
+
+ @Test
+ public void summarizeMultipleCoveringAndIntersectingRangesWithEarlierRepairedAt()
+ {
+ VnodeRepairState baseVnode = withVnode(100, 3000, dateToTimestamp("2020-03-15T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(100, 500, dateToTimestamp("2020-03-13T16:00:00"));
+ VnodeRepairState partialVnode2 = withVnode(200, 300, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode3 = withVnode(250, 450, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(250, 600, dateToTimestamp("2020-03-13T17:05:00"));
+ VnodeRepairState partialVnode5 = withVnode(400, 500, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode6 = withVnode(400, 3000, dateToTimestamp("2020-03-13T16:05:00"));
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(100, 3000, dateToTimestamp("2020-03-15T16:00:00"))
+ );
+ }
+
+ @Test
+ public void summarizeWraparoundMultipleCoveringAndIntersectingRanges()
+ {
+ VnodeRepairState baseVnode = withVnode(5000, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(5000, -12000, dateToTimestamp("2020-03-13T16:00:00")); // 5000 -> 7000
+ VnodeRepairState partialVnode2 = withVnode(6000, -14000, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode3 = withVnode(7000, -13000, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(7000, -10000, dateToTimestamp("2020-03-13T17:05:00")); // 7000 -> -10000
+ VnodeRepairState partialVnode5 = withVnode(-15000, -12000, dateToTimestamp("2020-03-12T16:05:00"));
+ VnodeRepairState partialVnode6 = withVnode(-15000, 3000, dateToTimestamp("2020-03-12T16:05:00")); // -10000 -> 3000
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(5000, 7000, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(7000, -10000, dateToTimestamp("2020-03-13T17:05:00")),
+ withVnode(-10000, 3000, dateToTimestamp("2020-03-12T16:05:00"))
+ );
+ }
+
+ @Test
+ public void summarizeWraparoundMultipleCoveringAndIntersectingRangesWithLaterRepairedAt()
+ {
+ VnodeRepairState baseVnode = withVnode(5000, 3000, dateToTimestamp("2020-03-12T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(5000, -12000, dateToTimestamp("2020-03-13T16:00:00")); // 5000 -> 6000
+ VnodeRepairState partialVnode2 = withVnode(6000, -14000, dateToTimestamp("2020-03-14T16:05:00")); // 6000 -> -12000
+ VnodeRepairState partialVnode3 = withVnode(7000, -13000, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(7000, -10000, dateToTimestamp("2020-03-13T17:05:00")); // -12000 -> -10000
+ VnodeRepairState partialVnode5 = withVnode(-15000, -12000, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode6 = withVnode(-15000, 3000, dateToTimestamp("2020-03-13T16:05:00")); // -10000 -> 3000
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(5000, 6000, dateToTimestamp("2020-03-13T16:00:00")),
+ withVnode(6000, -12000, dateToTimestamp("2020-03-14T16:05:00")),
+ withVnode(-12000, -10000, dateToTimestamp("2020-03-13T17:05:00")),
+ withVnode(-10000, 3000, dateToTimestamp("2020-03-13T16:05:00"))
+ );
+ }
+
+ @Test
+ public void summarizeWraparoundMultipleCoveringAndIntersectingRangesWithEarlierRepairedAt()
+ {
+ VnodeRepairState baseVnode = withVnode(5000, 3000, dateToTimestamp("2020-03-15T16:00:00"));
+
+ VnodeRepairState partialVnode1 = withVnode(5000, -12000, dateToTimestamp("2020-03-13T16:00:00")); // 5000 -> 6000
+ VnodeRepairState partialVnode2 = withVnode(6000, -14000, dateToTimestamp("2020-03-14T16:05:00")); // 6000 -> -12000
+ VnodeRepairState partialVnode3 = withVnode(7000, -13000, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode4 = withVnode(7000, -10000, dateToTimestamp("2020-03-13T17:05:00")); // -12000 -> -10000
+ VnodeRepairState partialVnode5 = withVnode(-15000, -12000, dateToTimestamp("2020-03-14T16:05:00"));
+ VnodeRepairState partialVnode6 = withVnode(-15000, 3000, dateToTimestamp("2020-03-13T16:05:00")); // -10000 -> 3000
+
+ List actualVnodeRepairStates = summarize(baseVnode, partialVnode2, partialVnode1, partialVnode3, partialVnode4, partialVnode5, partialVnode6);
+
+ assertThat(actualVnodeRepairStates).containsExactly(
+ withVnode(5000, 3000, dateToTimestamp("2020-03-15T16:00:00"))
+ );
+ }
+
+ private List summarize(VnodeRepairState baseVnode, VnodeRepairState... partialVnodes)
+ {
+ return summarize(Collections.singletonList(baseVnode), partialVnodes);
+ }
+
+ private List summarize(List baseVnodes, VnodeRepairState... partialVnodes)
+ {
+ return VnodeRepairStateSummarizer.summarizePartialVnodes(baseVnodes, Arrays.asList(partialVnodes));
+ }
+
+ private VnodeRepairState withVnode(long start, long end, long lastRepairedAt)
+ {
+ return new VnodeRepairState(new LongTokenRange(start, end), ImmutableSet.of(mockNode), lastRepairedAt);
+ }
+
+ private long dateToTimestamp(String date)
+ {
+ return LocalDateTime.parse(date).toEpochSecond(ZoneOffset.UTC) * 1000;
+ }
+}
diff --git a/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/state/TestRepairedAt.java b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/state/TestRepairedAt.java
new file mode 100644
index 00000000..ab027085
--- /dev/null
+++ b/core.impl/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/impl/state/TestRepairedAt.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.impl.state;
+
+import com.ericsson.bss.cassandra.ecchronos.core.impl.repair.vnode.VnodeRepairStatesImpl;
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.state.LongTokenRange;
+import com.ericsson.bss.cassandra.ecchronos.core.state.RepairedAt;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairState;
+import com.ericsson.bss.cassandra.ecchronos.core.state.VnodeRepairStates;
+import com.google.common.collect.ImmutableSet;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+public class TestRepairedAt
+{
+ @Test
+ public void testRepaired()
+ {
+ LongTokenRange range = new LongTokenRange(1, 2);
+ LongTokenRange range2 = new LongTokenRange(2, 3);
+ DriverNode node1 = mock(DriverNode.class);
+
+ VnodeRepairState vnodeRepairState = new VnodeRepairState(range, ImmutableSet.of(node1), 1234L);
+ VnodeRepairState vnodeRepairState2 = new VnodeRepairState(range2, ImmutableSet.of(node1), 1235L);
+
+ VnodeRepairStates vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(Arrays.asList(vnodeRepairState, vnodeRepairState2))
+ .build();
+
+ RepairedAt repairedAt = RepairedAt.generate(vnodeRepairStates);
+
+ assertThat(repairedAt.isRepaired()).isTrue();
+ assertThat(repairedAt.isPartiallyRepaired()).isFalse();
+ assertThat(repairedAt.getMaxRepairedAt()).isEqualTo(1235L);
+ assertThat(repairedAt.getMinRepairedAt()).isEqualTo(1234L);
+ }
+
+ @Test
+ public void testPartiallyRepaired()
+ {
+ LongTokenRange range = new LongTokenRange(1, 2);
+ LongTokenRange range2 = new LongTokenRange(2, 3);
+ DriverNode node1 = mock(DriverNode.class);
+
+ VnodeRepairState vnodeRepairState = new VnodeRepairState(range, ImmutableSet.of(node1), 1234L);
+ VnodeRepairState vnodeRepairState2 = new VnodeRepairState(range2, ImmutableSet.of(node1), VnodeRepairState.UNREPAIRED);
+
+ VnodeRepairStates vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(Arrays.asList(vnodeRepairState, vnodeRepairState2))
+ .build();
+
+ RepairedAt repairedAt = RepairedAt.generate(vnodeRepairStates);
+
+ assertThat(repairedAt.isRepaired()).isFalse();
+ assertThat(repairedAt.isPartiallyRepaired()).isTrue();
+ assertThat(repairedAt.getMaxRepairedAt()).isEqualTo(1234L);
+ assertThat(repairedAt.getMinRepairedAt()).isEqualTo(VnodeRepairState.UNREPAIRED);
+ }
+
+ @Test
+ public void testNotRepaired()
+ {
+ LongTokenRange range = new LongTokenRange(1, 2);
+ LongTokenRange range2 = new LongTokenRange(2, 3);
+ DriverNode node1 = mock(DriverNode.class);
+
+ VnodeRepairState vnodeRepairState = new VnodeRepairState(range, ImmutableSet.of(node1), VnodeRepairState.UNREPAIRED);
+ VnodeRepairState vnodeRepairState2 = new VnodeRepairState(range2, ImmutableSet.of(node1), VnodeRepairState.UNREPAIRED);
+
+ VnodeRepairStates vnodeRepairStates = VnodeRepairStatesImpl.newBuilder(Arrays.asList(vnodeRepairState, vnodeRepairState2))
+ .build();
+
+ RepairedAt repairedAt = RepairedAt.generate(vnodeRepairStates);
+
+ assertThat(repairedAt.isRepaired()).isFalse();
+ assertThat(repairedAt.isPartiallyRepaired()).isFalse();
+ assertThat(repairedAt.getMaxRepairedAt()).isEqualTo(VnodeRepairState.UNREPAIRED);
+ assertThat(repairedAt.getMinRepairedAt()).isEqualTo(VnodeRepairState.UNREPAIRED);
+ }
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/metadata/DriverNode.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/metadata/DriverNode.java
index 6399e782..f7a3ee56 100644
--- a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/metadata/DriverNode.java
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/metadata/DriverNode.java
@@ -64,6 +64,15 @@ public String getDatacenter()
return node.getDatacenter();
}
+ /**
+ * Get the whole node object.
+ *
+ * @return the node.
+ */
+ public Node getNode()
+ {
+ return node;
+ }
/**
* Check for equality.
*/
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/HostStates.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/HostStates.java
new file mode 100644
index 00000000..5ca373e6
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/HostStates.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+
+/**
+ * Interface used to determine node statuses.
+ */
+public interface HostStates
+{
+ /**
+ * Check if a host is up.
+ *
+ * @param node The node.
+ * @return True if the host is up. False will be returned if the state is unknown or if the host is down.
+ */
+ boolean isUp(Node node);
+
+ /**
+ * Check if a node is up.
+ *
+ * @param node The node.
+ * @return True if the node is up. False will be returned if the state is unknown or if the node is down.
+ */
+ boolean isUp(DriverNode node);
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/PostUpdateHook.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/PostUpdateHook.java
new file mode 100644
index 00000000..d58cb150
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/PostUpdateHook.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+/**
+ * Interface for injecting code to be executed after {@link RepairState#update()}.
+ */
+@FunctionalInterface
+public interface PostUpdateHook
+{
+ /**
+ * Runs each time the {@link RepairState} is updated.
+ *
+ * @param repairStateSnapshot The current repair state snapshot
+ */
+ void postUpdate(RepairStateSnapshot repairStateSnapshot);
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairEntry.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairEntry.java
new file mode 100644
index 00000000..79f6b47c
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairEntry.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairStatus;
+import java.util.Collections;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * An entry from the repair history.
+ */
+public final class RepairEntry
+{
+ private final LongTokenRange myRange;
+ private final long myStartedAt;
+ private final Set myParticipants;
+ private final RepairStatus myStatus;
+ private final long myFinishedAt;
+
+ /**
+ * Constructor.
+ *
+ * @param range Token range.
+ * @param startedAt Start timestamp.
+ * @param finishedAt End timestamp.
+ * @param participants Node participants.
+ * @param status The status.
+ */
+ public RepairEntry(final LongTokenRange range,
+ final long startedAt,
+ final long finishedAt,
+ final Set participants,
+ final String status)
+ {
+ myRange = range;
+ myStartedAt = startedAt;
+ myFinishedAt = finishedAt;
+ myParticipants = Collections.unmodifiableSet(participants);
+ myStatus = RepairStatus.getFromStatus(status);
+ }
+
+ /**
+ * Get range.
+ *
+ * @return LongTokenRange
+ */
+ public LongTokenRange getRange()
+ {
+ return myRange;
+ }
+
+ /**
+ * Get started at.
+ *
+ * @return long
+ */
+ public long getStartedAt()
+ {
+ return myStartedAt;
+ }
+
+ /**
+ * Get finished at.
+ *
+ * @return long
+ */
+ public long getFinishedAt()
+ {
+ return myFinishedAt;
+ }
+
+ /**
+ * Get participants.
+ *
+ * @return The participants
+ */
+ public Set getParticipants()
+ {
+ return myParticipants;
+ }
+
+ /**
+ * Get status.
+ *
+ * @return RepairStatus
+ */
+ public RepairStatus getStatus()
+ {
+ return myStatus;
+ }
+
+ /**
+ * Equality.
+ *
+ * @param o The object to test equality with.
+ * @return boolean
+ */
+ @Override
+ public boolean equals(final Object o)
+ {
+ if (this == o)
+ {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass())
+ {
+ return false;
+ }
+ RepairEntry that = (RepairEntry) o;
+ return myStartedAt == that.myStartedAt
+ && myFinishedAt == that.myFinishedAt
+ && Objects.equals(myRange, that.myRange)
+ && Objects.equals(myParticipants, that.myParticipants)
+ && myStatus == that.myStatus;
+ }
+
+ /**
+ * Hash representation.
+ *
+ * @return int
+ */
+ @Override
+ public int hashCode()
+ {
+ return Objects.hash(myRange, myStartedAt, myFinishedAt, myParticipants, myStatus);
+ }
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistory.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistory.java
new file mode 100644
index 00000000..8e90ac07
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistory.java
@@ -0,0 +1,81 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairStatus;
+import java.util.Set;
+import java.util.UUID;
+
+public interface RepairHistory
+{
+ RepairHistory NO_OP = new NoOpRepairHistory();
+
+ RepairSession newSession(
+ Node node,
+ TableReference tableReference,
+ UUID jobId,
+ LongTokenRange range,
+ Set participants);
+
+ interface RepairSession
+ {
+ void start();
+
+ void finish(RepairStatus repairStatus);
+ }
+
+ class NoOpRepairHistory implements RepairHistory
+ {
+ private static final RepairSession NO_OP = new NoOpRepairSession();
+
+ /**
+ * New session.
+ */
+ @Override
+ public RepairSession newSession(
+ final Node node,
+ final TableReference tableReference,
+ final UUID jobId,
+ final LongTokenRange range,
+ final Set participants)
+ {
+ return NO_OP;
+ }
+ }
+
+ class NoOpRepairSession implements RepairSession
+ {
+ /**
+ * Start.
+ */
+ @Override
+ public void start()
+ {
+ // Do nothing
+ }
+
+ /**
+ * End.
+ */
+ @Override
+ public void finish(final RepairStatus repairStatus)
+ {
+ // Do nothing
+ }
+ }
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistoryProvider.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistoryProvider.java
new file mode 100644
index 00000000..a55c18c6
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairHistoryProvider.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import java.util.Iterator;
+import com.google.common.base.Predicate;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+
+/**
+ * Interface used to retrieve repair history.
+ */
+public interface RepairHistoryProvider
+{
+ /**
+ * Iterate the repair history for the provided table starting from the {@code from} and going backwards.
+ * The predicate is used to decide which repair entries should be filtered out of the result.
+ *
+ * @param tableReference The table for which the history should be iterated.
+ * @param to The latest point in time to iterate to.
+ * @param predicate The predicate used to filter out entries in the iterator results.
+ * @return A filtered iterator for the repair history of the table.
+ */
+ Iterator iterate(Node node, TableReference tableReference, long to, Predicate predicate);
+
+ /**
+ * Iterate the repair history for the provided table starting from the {@code from} and going backwards until
+ * {@code to}. The predicate is used to decide which repair entries should be filtered out of the result.
+ *
+ * @param tableReference The table for which the history should be iterated.
+ * @param to The last point in time to iterate to.
+ * @param from The point in time to start iterating from.
+ * @param predicate The predicate used to filter out entries in the iterator results.
+ * @return A filtered iterator for the repair history of the table.
+ */
+ Iterator iterate(Node node, TableReference tableReference, long to, long from, Predicate predicate);
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairState.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairState.java
new file mode 100644
index 00000000..2c410237
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairState.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+/**
+ * Interface used by TableRepairJob to update and get a snapshot of the current repair state of a table.
+ *
+ * @see RepairStateSnapshot
+ */
+public interface RepairState
+{
+ /**
+ * Update the repair state for the table in the specified node.
+ */
+ void update();
+
+ /**
+ * Get an immutable copy of the current repair state.
+ *
+ * @return The immutable copy.
+ */
+ RepairStateSnapshot getSnapshot();
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairStateFactory.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairStateFactory.java
new file mode 100644
index 00000000..312f305a
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairStateFactory.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.repair.config.RepairConfiguration;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+
+public interface RepairStateFactory
+{
+ RepairState create(
+ Node node,
+ TableReference tableReference,
+ RepairConfiguration repairConfiguration,
+ PostUpdateHook postUpdateHook);
+}
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairedAt.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairedAt.java
new file mode 100644
index 00000000..8af2c2ff
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/RepairedAt.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import java.util.Collection;
+
+/**
+ * Utility class to determine collective repaired at information for {@link VnodeRepairStates}.
+ *
+ * A value of {@link Long#MAX_VALUE} indicates that no repair information is available.
+ * A value of {@link VnodeRepairState#UNREPAIRED} indicates that the status is unknown.
+ */
+public final class RepairedAt
+{
+ private final long myMinRepairedAt;
+ private final long myMaxRepairedAt;
+
+ private RepairedAt(final long minRepairedAt, final long maxRepairedAt)
+ {
+ myMinRepairedAt = minRepairedAt;
+ myMaxRepairedAt = maxRepairedAt;
+ }
+
+ /**
+ * Check if all vnodes have repaired at information.
+ *
+ * @return True if all vnodes have repaired at information.
+ */
+ public boolean isRepaired()
+ {
+ return myMinRepairedAt != Long.MAX_VALUE && myMinRepairedAt != VnodeRepairState.UNREPAIRED;
+ }
+
+ /**
+ * Check if only some vnodes have repaired at information.
+ *
+ * @return True if some vnodes have been repaired but not all.
+ */
+ public boolean isPartiallyRepaired()
+ {
+ return myMinRepairedAt == VnodeRepairState.UNREPAIRED && myMaxRepairedAt != myMinRepairedAt;
+ }
+
+ /**
+ * Get the highest repaired at for the vnodes.
+ *
+ * @return The highest repaired at.
+ */
+ public long getMaxRepairedAt()
+ {
+ return myMaxRepairedAt;
+ }
+
+ /**
+ * Get the lowest repaired at for the vnodes.
+ *
+ * @return The lowest repaired at.
+ */
+ public long getMinRepairedAt()
+ {
+ return myMinRepairedAt;
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.format("(min=%d,max=%d,isRepaired=%b,isPartiallyRepaired=%b)",
+ getMinRepairedAt(), getMaxRepairedAt(), isRepaired(), isPartiallyRepaired());
+ }
+
+ /**
+ * Generate a repaired at.
+ *
+ * @param vnodeRepairStates Vnode repair states.
+ * @return RepairedAt
+ */
+ public static RepairedAt generate(final VnodeRepairStates vnodeRepairStates)
+ {
+ return RepairedAt.generate(vnodeRepairStates.getVnodeRepairStates());
+ }
+
+ public static RepairedAt generate(final Collection vnodeRepairStates)
+ {
+ long minRepairedAt = Long.MAX_VALUE;
+ long maxRepairedAt = Long.MIN_VALUE;
+
+ for (VnodeRepairState vnodeRepairState : vnodeRepairStates)
+ {
+ long repairedAt = vnodeRepairState.lastRepairedAt();
+
+ if (repairedAt > maxRepairedAt)
+ {
+ maxRepairedAt = repairedAt;
+ }
+
+ if (repairedAt < minRepairedAt)
+ {
+ minRepairedAt = repairedAt;
+ }
+ }
+
+ return new RepairedAt(minRepairedAt, maxRepairedAt);
+ }
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/ReplicaRepairGroupFactory.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/ReplicaRepairGroupFactory.java
new file mode 100644
index 00000000..4612eff0
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/ReplicaRepairGroupFactory.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import java.util.List;
+
+/**
+ * A factory interface that creates {@link ReplicaRepairGroup ReplicaRepairGroups} based on the currently repairable
+ * vnodes.
+ */
+public interface ReplicaRepairGroupFactory
+{
+ /**
+ * Generate a sorted list of {@link ReplicaRepairGroup} based on the provided {@link VnodeRepairState}.
+ *
+ * It is assumed that all vnodes passed to this method should be repaired (now).
+ *
+ * Which vnodes/replicas are included in the {@link ReplicaRepairGroup} is up to the specific implementation but
+ * the list should be sorted with the most urgent {@link ReplicaRepairGroup} first.
+ *
+ * @param availableVnodeRepairStates The currently repairable vnodes.
+ * @return The repair groups based on the provided vnodes.
+ */
+ List generateReplicaRepairGroups(List availableVnodeRepairStates);
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/TokenSubRangeUtil.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/TokenSubRangeUtil.java
new file mode 100644
index 00000000..526be86f
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/TokenSubRangeUtil.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.ericsson.bss.cassandra.ecchronos.utils.exceptions.InternalException;
+import com.google.common.collect.Lists;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility class to split a token range into smaller sub-ranges.
+ */
+public class TokenSubRangeUtil
+{
+ private static final Logger LOG = LoggerFactory.getLogger(TokenSubRangeUtil.class);
+
+ private final LongTokenRange tokenRange;
+ private final BigInteger tokenStart;
+ private final BigInteger totalRangeSize;
+
+ public TokenSubRangeUtil(final LongTokenRange aTokenRange)
+ {
+ this.tokenRange = aTokenRange;
+ this.tokenStart = BigInteger.valueOf(aTokenRange.start);
+ this.totalRangeSize = this.tokenRange.rangeSize();
+ }
+
+ /**
+ * Generates a number of sub ranges of mostly equal size.
+ * The last sub range can be slightly smaller than the others
+ * due to rounding.
+ *
+ * @param tokenPerSubRange The number of wanted tokens per subrange
+ * @return The sub ranges containing the full range.
+ */
+ public List generateSubRanges(final BigInteger tokenPerSubRange)
+ {
+ if (totalRangeSize.compareTo(tokenPerSubRange) <= 0)
+ {
+ return Lists.newArrayList(tokenRange); // Full range is smaller than wanted tokens
+ }
+
+ long actualSubRangeCount = totalRangeSize.divide(tokenPerSubRange).longValueExact();
+ if (totalRangeSize.remainder(tokenPerSubRange).compareTo(BigInteger.ZERO) > 0)
+ {
+ actualSubRangeCount++;
+ }
+
+ List subRanges = new ArrayList<>();
+ for (long l = 0; l < actualSubRangeCount - 1; l++)
+ {
+ subRanges.add(newSubRange(tokenPerSubRange, l));
+ }
+
+ LongTokenRange lastRange = subRanges.get(subRanges.size() - 1);
+ subRanges.add(new LongTokenRange(lastRange.end, tokenRange.end));
+
+ // Verify sub range size match full range size
+ validateSubRangeSize(subRanges);
+
+ return subRanges;
+ }
+
+ private void validateSubRangeSize(final List subRanges)
+ {
+ BigInteger subRangeSize = BigInteger.ZERO;
+
+ for (LongTokenRange range : subRanges)
+ {
+ subRangeSize = subRangeSize.add(range.rangeSize());
+ }
+
+ if (subRangeSize.compareTo(totalRangeSize) != 0)
+ {
+ BigInteger difference = totalRangeSize.subtract(subRangeSize).abs();
+ String msg = String.format(
+ "Unexpected sub-range generation for %s. Difference: %s. Sub-ranges generated: %s",
+ tokenRange,
+ difference,
+ subRanges);
+
+ LOG.error(msg);
+ throw new InternalException(msg);
+ }
+ }
+
+ private LongTokenRange newSubRange(final BigInteger rangeSize, final long rangeId)
+ {
+ BigInteger rangeOffset = rangeSize.multiply(BigInteger.valueOf(rangeId));
+ BigInteger rangeStartTmp = tokenStart.add(rangeOffset);
+ BigInteger rangeEndTmp = rangeStartTmp.add(rangeSize);
+
+ long rangeStart = enforceValidBounds(rangeStartTmp);
+ long rangeEnd = enforceValidBounds(rangeEndTmp);
+
+ return new LongTokenRange(rangeStart, rangeEnd);
+ }
+
+ private long enforceValidBounds(final BigInteger tokenValue)
+ {
+ if (tokenValue.compareTo(LongTokenRange.RANGE_END) > 0)
+ {
+ return tokenValue.subtract(LongTokenRange.FULL_RANGE).longValueExact();
+ }
+
+ return tokenValue.longValueExact();
+ }
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/VnodeRepairStateFactory.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/VnodeRepairStateFactory.java
new file mode 100644
index 00000000..b52f072c
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/state/VnodeRepairStateFactory.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.ericsson.bss.cassandra.ecchronos.core.table.TableReference;
+
+/**
+ * A factory to create {@link VnodeRepairStates} for a specific table.
+ */
+public interface VnodeRepairStateFactory
+{
+ /**
+ * Calculate the current repair state based on the previous.
+ *
+ * If the previous repair state is unknown it should be calculated from start.
+ *
+ * @param tableReference The table to calculate the new repair state for vnodes.
+ * @param previous The previous repair state or null if non exists.
+ * @param iterateToTime The time to iterate repair entries to.
+ * @return The calculated repair state.
+ */
+ VnodeRepairStates calculateNewState(
+ Node node,
+ TableReference tableReference, RepairStateSnapshot previous,
+ long iterateToTime);
+
+ /**
+ * Calculate the repair state for a time window.
+ *
+ * @param tableReference The table to calculate the repair state for vnodes.
+ * @param to Timestamp from when the repair state should start
+ * @param from Timestamp to when the repair state should stop
+ * @return The repair state during the specified time window.
+ */
+ VnodeRepairStates calculateClusterWideState(Node node, TableReference tableReference, long to, long from);
+}
+
diff --git a/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/table/TableStorageStates.java b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/table/TableStorageStates.java
new file mode 100644
index 00000000..ed8d2bea
--- /dev/null
+++ b/core/src/main/java/com/ericsson/bss/cassandra/ecchronos/core/table/TableStorageStates.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.table;
+
+import java.util.UUID;
+
+/**
+ * Interface for retrieving storage usage for all tables this nodes should repair.
+ */
+public interface TableStorageStates
+{
+ /**
+ * Get the data size of the provided table on the local node.
+ *
+ * @param tableReference The table to get the data size of.
+ * @return The data size of the provided table on this node.
+ */
+ long getDataSize(UUID nodeID, TableReference tableReference);
+
+ /**
+ * Get the total data size of all tables on the local node.
+ *
+ * @return The data size of all tables on this node.
+ */
+ long getDataSize(UUID nodeID);
+}
diff --git a/core/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/state/TestRepairEntry.java b/core/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/state/TestRepairEntry.java
new file mode 100644
index 00000000..763bf1bf
--- /dev/null
+++ b/core/src/test/java/com/ericsson/bss/cassandra/ecchronos/core/state/TestRepairEntry.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2024 Telefonaktiebolaget LM Ericsson
+ *
+ * Licensed 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 com.ericsson.bss.cassandra.ecchronos.core.state;
+
+import com.ericsson.bss.cassandra.ecchronos.core.metadata.DriverNode;
+import com.ericsson.bss.cassandra.ecchronos.utils.enums.repair.RepairStatus;
+import com.google.common.collect.Sets;
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestRepairEntry
+{
+ @Mock
+ private DriverNode mockNode;
+
+ @Test
+ public void testGetters()
+ {
+ LongTokenRange expectedLongTokenRange = new LongTokenRange(0, 1);
+ long expectedStartedAt = 5;
+ long expectedFinishedAt = expectedStartedAt + 5;
+ Set expectedParticipants = Sets.newHashSet(mockNode);
+ RepairStatus expectedStatus = RepairStatus.SUCCESS;
+
+ RepairEntry repairEntry = new RepairEntry(expectedLongTokenRange, expectedStartedAt, expectedFinishedAt, expectedParticipants, expectedStatus.toString());
+
+ assertThat(repairEntry.getRange()).isEqualTo(expectedLongTokenRange);
+ assertThat(repairEntry.getStartedAt()).isEqualTo(expectedStartedAt);
+ assertThat(repairEntry.getFinishedAt()).isEqualTo(expectedFinishedAt);
+ assertThat(repairEntry.getParticipants()).isEqualTo(expectedParticipants);
+ assertThat(repairEntry.getStatus()).isEqualTo(expectedStatus);
+ }
+
+ @Test
+ public void testRepairEntriesAreEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+
+ assertThat(repairEntry).isEqualTo(repairEntry2);
+ assertThat(repairEntry.hashCode()).isEqualTo(repairEntry2.hashCode());
+ }
+
+ @Test
+ public void testRepairEntriesWithDifferentRangeAreNotEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(1, 2), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+
+ assertThat(repairEntry).isNotEqualTo(repairEntry2);
+ }
+
+ @Test
+ public void testRepairEntriesWithDifferentStartedAtAreNotEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 7, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(0, 1), 6, 7, Sets.newHashSet(mockNode), "SUCCESS");
+
+ assertThat(repairEntry).isNotEqualTo(repairEntry2);
+ }
+
+ @Test
+ public void testRepairEntriesWithDifferentFinishedAtAreNotEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 6, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(0, 1), 5, 7, Sets.newHashSet(mockNode), "SUCCESS");
+
+ assertThat(repairEntry).isNotEqualTo(repairEntry2);
+ }
+
+ @Test
+ public void testRepairEntriesWithDifferentParticipantsAreNotEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(), "SUCCESS");
+
+ assertThat(repairEntry).isNotEqualTo(repairEntry2);
+ }
+
+ @Test
+ public void testRepairEntriesWithDifferentStatusAreNotEqual()
+ {
+ RepairEntry repairEntry = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "SUCCESS");
+ RepairEntry repairEntry2 = new RepairEntry(new LongTokenRange(0, 1), 5, 5, Sets.newHashSet(mockNode), "FAILED");
+
+ assertThat(repairEntry).isNotEqualTo(repairEntry2);
+ }
+
+ @Test
+ public void testEqualsContract()
+ {
+ EqualsVerifier.forClass(RepairEntry.class).usingGetClass().verify();
+ }
+}
diff --git a/data/pom.xml b/data/pom.xml
index 135d7d9b..015d6dbd 100644
--- a/data/pom.xml
+++ b/data/pom.xml
@@ -35,6 +35,12 @@
${project.version}