bdeggleston commented on a change in pull request #1:
URL: https://github.com/apache/cassandra-accord/pull/1#discussion_r799636063
##########
File path: accord-core/src/main/java/accord/topology/TopologyManager.java
##########
@@ -0,0 +1,325 @@
+package accord.topology;
+
+import accord.api.ConfigurationService;
+import accord.coordinate.tracking.QuorumTracker;
+import accord.local.Node;
+import accord.messages.Request;
+import accord.messages.TxnRequest;
+import accord.messages.TxnRequestScope;
+import accord.txn.Keys;
+import accord.txn.Txn;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+
+import java.util.*;
+import java.util.function.LongConsumer;
+
+/**
+ * Manages topology state changes and update bookkeeping
+ *
+ * Each time the topology changes we need to:
+ * * confirm previous owners of ranges we replicate are aware of the new config
+ * * learn of any outstanding operations for ranges we replicate
+ * * clean up obsolete data
+ *
+ * Assumes a topology service that won't report epoch n without having n-1 etc
also available
+ */
+public class TopologyManager implements ConfigurationService.Listener
+{
+ class EpochState
+ {
+ private final Topology global;
+ private final Topology local;
+ private final QuorumTracker syncTracker;
+ private boolean syncComplete = false;
+ private boolean prevSynced;
+
+ private boolean updateState(boolean prevSynced)
+ {
+ this.prevSynced = prevSynced;
+ if (!syncComplete)
+ {
+ syncComplete = syncTracker.hasReachedQuorum();
+ return syncComplete;
+ }
+ return false;
+ }
+
+ EpochState(Topology global, boolean prevSynced)
+ {
+ Preconditions.checkArgument(!global.isSubset());
+ this.global = global;
+ this.local = global.forNode(node);
+ this.syncTracker = new QuorumTracker(new
Topologies.Singleton(global, false));
+ this.prevSynced = prevSynced;
+ updateState(prevSynced);
+ }
+
+ public boolean recordSyncComplete(Node.Id node, boolean prevSynced)
+ {
+ syncTracker.recordSuccess(node);
+ return updateState(prevSynced);
+ }
+
+ long epoch()
+ {
+ return global.epoch;
+ }
+
+ boolean syncComplete()
+ {
+ return prevSynced && syncComplete;
+ }
+
+ /**
+ * determine if sync has completed for all shards intersecting with
the given keys
+ */
+ boolean syncCompleteFor(Keys keys)
+ {
+ if (!prevSynced)
+ return false;
+ if (syncComplete)
+ return true;
+ Boolean result = global.accumulateForKeys(keys, (i, shard, acc) ->
{
+ if (acc == Boolean.FALSE)
+ return acc;
+ return
Boolean.valueOf(syncTracker.unsafeGet(i).hasReachedQuorum());
+ }, Boolean.TRUE);
+ return result == Boolean.TRUE;
+ }
+
+ boolean shardIsUnsynced(int idx, Shard shard)
+ {
+ return !syncTracker.unsafeGet(idx).hasReachedQuorum();
+ }
+ }
+
+ private class Epochs
+ {
+ private final long maxEpoch;
+ private final long minEpoch;
+ private final EpochState[] epochs;
+ private final List<Set<Node.Id>> pendingSyncComplete;
+
+ private Epochs(EpochState[] epochs, List<Set<Node.Id>>
pendingSyncComplete)
+ {
+ this.maxEpoch = epochs.length > 0 ? epochs[0].epoch() : 0;
+ this.pendingSyncComplete = pendingSyncComplete;
+ for (int i=1; i<epochs.length; i++)
+ Preconditions.checkArgument(epochs[i].epoch() ==
epochs[i-1].epoch() - 1);
+ this.minEpoch = epochs.length > 0 ? epochs[epochs.length -
1].epoch() : 0;
+ this.epochs = epochs;
+ }
+
+ private Epochs(EpochState[] epochs)
+ {
+ this(epochs, new ArrayList<>());
+ }
+
+ public long nextEpoch()
+ {
+ return current().epoch + 1;
+ }
+
+ public Topology current()
+ {
+ return epochs.length > 0 ? epochs[0].global : Topology.EMPTY;
+ }
+
+ public Epochs add(Topology topology)
+ {
+ Preconditions.checkArgument(topology.epoch == nextEpoch());
+ EpochState[] nextEpochs = new EpochState[epochs.length + 1];
+ List<Set<Node.Id>> pendingSync = pendingSyncComplete;
+ if (!pendingSync.isEmpty())
+ {
+ boolean prevSynced = epochs.length <= 1 ||
epochs[1].syncComplete();
+ EpochState currentEpoch = epochs[0];
+ pendingSync.remove(0).forEach(id ->
currentEpoch.recordSyncComplete(id, prevSynced));
Review comment:
pendingSync is indexed with the current epoch at 0, plus epochs we
haven't seen yet indexed after that. So if the current epoch is 5, the epochs
represented in pending sync would be [5, 6, 7]. If we receive a new epoch
topology (6), the pending sync entry representing epoch 5 must be removed for
this indexing assumption to be valid
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
