Renamed commitIndex to currentCommitIndex in waitForResult.

arangodb · maierlars · Sep 1, 2021 · Aug 17, 2021 · Aug 17, 2021 · Aug 17, 2021
commit b7c6eaaf2f945325afbc7534829e4d95a2122690
diff --git a/arangod/Replication2/ReplicatedLog/ILogParticipant.cpp b/arangod/Replication2/ReplicatedLog/ILogParticipant.cpp
@@ -72,16 +72,16 @@ auto replicated_log::LogUnconfiguredParticipant::release(LogIndex doneWithIdx) -
 
 replicated_log::WaitForResult::WaitForResult(LogIndex index,
                                              std::shared_ptr<QuorumData const> quorum)
-    : commitIndex(index), quorum(std::move(quorum)) {}
+    : currentCommitIndex(index), quorum(std::move(quorum)) {}
 
 void replicated_log::WaitForResult::toVelocyPack(velocypack::Builder& builder) const {
   VPackObjectBuilder ob(&builder);
-  builder.add(StaticStrings::CommitIndex, VPackValue(commitIndex));
+  builder.add(StaticStrings::CommitIndex, VPackValue(currentCommitIndex));
   builder.add(VPackValue("quorum"));
   quorum->toVelocyPack(builder);
 }
 
 replicated_log::WaitForResult::WaitForResult(velocypack::Slice s) {
-  commitIndex = s.get(StaticStrings::CommitIndex).extract<LogIndex>();
+  currentCommitIndex = s.get(StaticStrings::CommitIndex).extract<LogIndex>();
   quorum = std::make_shared<QuorumData>(s.get("quorum"));
 }
diff --git a/arangod/Replication2/ReplicatedLog/ILogParticipant.h b/arangod/Replication2/ReplicatedLog/ILogParticipant.h
@@ -44,7 +44,7 @@ struct LogStatus;
 
 struct WaitForResult {
   /// @brief contains the _current_ commit index. (Not the index waited for)
-  LogIndex commitIndex;
+  LogIndex currentCommitIndex;
   /// @brief Quorum information
   std::shared_ptr<QuorumData const> quorum;
 

diff --git a/arangod/Replication2/Streams/LogMultiplexer.tpp b/arangod/Replication2/Streams/LogMultiplexer.tpp
@@ -140,10 +140,8 @@ struct LogMultiplexerImplementationBase {
   template <typename StreamDescriptor, typename T = stream_descriptor_type_t<StreamDescriptor>,
             typename E = StreamEntryView<T>>
   auto getIteratorInternal() -> std::unique_ptr<TypedLogRangeIterator<E>> {
-    using BlockType = StreamInformationBlock<StreamDescriptor>;
-
     return _guardedData.template doUnderLock([](MultiplexerData<Spec>& self) {
-      auto& block = std::get<BlockType>(self._blocks);
+      auto& block = self.template getBlockForDescriptor<StreamDescriptor>();
       return block.getIterator();
     });
   }
@@ -216,9 +214,8 @@ struct LogDemultiplexerImplementation
     : LogDemultiplexer<Spec>,  // implement the actual class
       ProxyStreamDispatcher<LogDemultiplexerImplementation<Spec, Interface>, Spec, Stream>,  // use a proxy stream dispatcher
       LogMultiplexerImplementationBase<LogDemultiplexerImplementation<Spec, Interface>, Spec, Stream, Interface> {
-  using SelfClass = LogDemultiplexerImplementation<Spec, Interface>;
   explicit LogDemultiplexerImplementation(std::shared_ptr<Interface> interface)
-      : LogMultiplexerImplementationBase<LogDemultiplexerImplementation<Spec, Interface>, Spec, Stream, Interface>(
+      : LogMultiplexerImplementationBase<LogDemultiplexerImplementation, Spec, Stream, Interface>(
             std::move(interface)) {}
 
   auto digestIterator(LogRangeIterator& iter) -> void override {
@@ -244,7 +241,7 @@ struct LogDemultiplexerImplementation
     this->_interface->waitForIterator(waitForIndex)
         .thenValue([weak = this->weak_from_this()](std::unique_ptr<LogRangeIterator>&& iter) {
           if (auto locked = weak.lock(); locked) {
-            auto that = std::static_pointer_cast<SelfClass>(locked);
+            auto that = std::static_pointer_cast<LogDemultiplexerImplementation>(locked);
             auto [nextIndex, promiseSets] = that->_guardedData.doUnderLock([&](auto& self) {
               self._firstUncommittedIndex = iter->range().second;
               self.digestIterator(*iter);
@@ -314,8 +311,8 @@ struct LogMultiplexerImplementation
           self._pendingWaitFor = false;
 
           // find out what the commit index is
-          self._firstUncommittedIndex = result.commitIndex + 1;
-          return std::make_pair(self.getWaitForResolveSetAll(result.commitIndex),
+          self._firstUncommittedIndex = result.currentCommitIndex + 1;
+          return std::make_pair(self.getWaitForResolveSetAll(result.currentCommitIndex),
                                 self.checkWaitFor());
         });
 

diff --git a/tests/Replication2/ReplicatedLog/MultiTermTest.cpp b/tests/Replication2/ReplicatedLog/MultiTermTest.cpp
@@ -252,7 +252,7 @@ TEST_F(MultiTermTest, resign_leader_append_entries) {
     ASSERT_TRUE(f2.isReady());
     {
       auto result = f2.get();
-      EXPECT_EQ(result.commitIndex, LogIndex{3});
+      EXPECT_EQ(result.currentCommitIndex, LogIndex{3});
       EXPECT_EQ(result.quorum->index, LogIndex{3});
       EXPECT_EQ(result.quorum->term, LogTerm{2});
       EXPECT_EQ(result.quorum->quorum,

diff --git a/tests/Replication2/ReplicatedLog/SimpleInsertTests.cpp b/tests/Replication2/ReplicatedLog/SimpleInsertTests.cpp
@@ -171,7 +171,7 @@ TEST_F(ReplicatedLogTest, write_single_entry_to_follower) {
       // Expect the quorum to consist of the follower only
       ASSERT_TRUE(f.isReady());
       auto result = f.get();
-      EXPECT_EQ(result.commitIndex, LogIndex{2});
+      EXPECT_EQ(result.currentCommitIndex, LogIndex{2});
       EXPECT_EQ(result.quorum->index, LogIndex{2});
       EXPECT_EQ(result.quorum->term, LogTerm{1});
       EXPECT_EQ(result.quorum->quorum, (std::vector<ParticipantId>{leaderId, followerId}));
@@ -382,7 +382,7 @@ TEST_F(ReplicatedLogTest, multiple_follower) {
   {
     ASSERT_TRUE(future.isReady());
     auto result = future.get();
-    EXPECT_EQ(result.commitIndex, LogIndex{2});
+    EXPECT_EQ(result.currentCommitIndex, LogIndex{2});
     EXPECT_EQ(result.quorum->term, LogTerm{1});
     EXPECT_EQ(result.quorum->index, LogIndex{2});
     EXPECT_EQ(result.quorum->quorum, (std::vector{leaderId, followerId_1, followerId_2}));