5d5dfbb6f7
Summary: During it's leadership, one peer can receive RPC messages from other peers that his reign is over. The problem is when this happens during a transaction commit. This is handled in the following way. If we're the current leader and we want to commit a transaction, we need to make sure the Raft Log is replicated before we can tell the client that the transaction is committed. During that wait, we can only notice that the replication takes too long, and we report that with `LOG(WARNING)` messages. If we change the Raft mode during the wait, our Raft implementation will internally commit this transaction, but won't be able to acquire the Raft lock because the `db.Reset` has been called. This is why there is an manual lock acquire. If we pick up that the `db.Reset` has been called, we throw an `UnexpectedLeaderChangeException` exception to the client. Another thing with long running transactions, if someone decides to kill a `memgraph_ha` instance during the commit, the transaction will have `abort` hint set. This will cause the `src/query/operator.cpp` to throw a `HintedAbortError`. We need to catch this during the shutdown, because the `memgraph_ha` isn't dead from the user perspective, and the transaction wasn't aborted because it took too long, but we can differentiate between those two. Reviewers: mferencevic, ipaljak Reviewed By: mferencevic, ipaljak Subscribers: pullbot Differential Revision: https://phabricator.memgraph.io/D1956
72 lines
1.6 KiB
C++
72 lines
1.6 KiB
C++
#include "gtest/gtest.h"
|
|
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
#include "durability/single_node_ha/state_delta.hpp"
|
|
#include "raft/raft_interface.hpp"
|
|
#include "transactions/single_node_ha/engine.hpp"
|
|
#include "transactions/transaction.hpp"
|
|
|
|
using namespace tx;
|
|
|
|
class RaftMock final : public raft::RaftInterface {
|
|
public:
|
|
bool Emplace(const database::StateDelta &delta) override {
|
|
log_[delta.transaction_id].emplace_back(std::move(delta));
|
|
return true;
|
|
}
|
|
|
|
bool SafeToCommit(const tx::TransactionId &) override {
|
|
return true;
|
|
}
|
|
|
|
bool IsLeader() override { return true; }
|
|
|
|
uint64_t TermId() override { return 1; }
|
|
|
|
std::vector<database::StateDelta> GetLogForTx(
|
|
const tx::TransactionId &tx_id) {
|
|
return log_[tx_id];
|
|
}
|
|
|
|
std::mutex &WithLock() override { return lock_; }
|
|
|
|
private:
|
|
std::unordered_map<tx::TransactionId, std::vector<database::StateDelta>> log_;
|
|
std::mutex lock_;
|
|
};
|
|
|
|
TEST(Engine, Reset) {
|
|
RaftMock raft;
|
|
Engine engine{&raft};
|
|
|
|
auto t0 = engine.Begin();
|
|
EXPECT_EQ(t0->id_, 1);
|
|
engine.Commit(*t0);
|
|
|
|
engine.Reset();
|
|
|
|
auto t1 = engine.Begin();
|
|
EXPECT_EQ(t1->id_, 1);
|
|
engine.Commit(*t1);
|
|
}
|
|
|
|
TEST(Engine, TxStateDelta) {
|
|
RaftMock raft;
|
|
Engine engine{&raft};
|
|
|
|
auto t0 = engine.Begin();
|
|
tx::TransactionId tx_id = t0->id_;
|
|
engine.Commit(*t0);
|
|
|
|
auto t0_log = raft.GetLogForTx(tx_id);
|
|
EXPECT_EQ(t0_log.size(), 2);
|
|
|
|
using Type = enum database::StateDelta::Type;
|
|
EXPECT_EQ(t0_log[0].type, Type::TRANSACTION_BEGIN);
|
|
EXPECT_EQ(t0_log[0].transaction_id, tx_id);
|
|
EXPECT_EQ(t0_log[1].type, Type::TRANSACTION_COMMIT);
|
|
EXPECT_EQ(t0_log[1].transaction_id, tx_id);
|
|
}
|