sikkienl/dash
1
0
Fork 0
mirror of https://github.com/dashpay/dash.git synced 2024-12-25 12:02:48 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: make QuorumPhase a enum class, remove QuorumPhase_None, use optional instead, adjust WaitForNextPhase (#4722)

Browse Source
This commit is contained in:
PastaPastaPasta 2022-03-13 15:56:31 -05:00 committed by GitHub
parent 9e648f5d70
commit 8e8b0d3d1a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 44 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/llmq/dkgsessionhandler.cpp
View File

@ -92,12 +92,12 @@ void CDKGSessionHandler::UpdatedBlockTip(const CBlockIndex* pindexNew)
bool fNewPhase = (quorumStageInt % params.dkgPhaseBlocks) == 0; bool fNewPhase = (quorumStageInt % params.dkgPhaseBlocks) == 0;
int phaseInt = quorumStageInt / params.dkgPhaseBlocks + 1; int phaseInt = quorumStageInt / params.dkgPhaseBlocks + 1;
QuorumPhase oldPhase = phase; QuorumPhase oldPhase = phase;
if (fNewPhase && phaseInt >= QuorumPhase_Initialized && phaseInt <= QuorumPhase_Idle) { if (fNewPhase && phaseInt >= int(QuorumPhase::Initialized) && phaseInt <= int(QuorumPhase::Idle)) {
phase = static_cast<QuorumPhase>(phaseInt); phase = static_cast<QuorumPhase>(phaseInt);
} }
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionHandler::%s -- %s - currentHeight=%d, pQuorumBaseBlockIndex->nHeight=%d, oldPhase=%d, newPhase=%d\n", __func__, LogPrint(BCLog::LLMQ_DKG, "CDKGSessionHandler::%s -- %s - currentHeight=%d, pQuorumBaseBlockIndex->nHeight=%d, oldPhase=%d, newPhase=%d\n", __func__,
params.name, currentHeight, pQuorumBaseBlockIndex->nHeight, oldPhase, phase); params.name, currentHeight, pQuorumBaseBlockIndex->nHeight, int(oldPhase), int(phase));
} }
void CDKGSessionHandler::ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv) void CDKGSessionHandler::ProcessMessage(CNode* pfrom, const std::string& strCommand, CDataStream& vRecv)
@ -159,38 +159,38 @@ std::pair<QuorumPhase, uint256> CDKGSessionHandler::GetPhaseAndQuorumHash() cons
class AbortPhaseException : public std::exception { class AbortPhaseException : public std::exception {
}; };
void CDKGSessionHandler::WaitForNextPhase(QuorumPhase curPhase, void CDKGSessionHandler::WaitForNextPhase(std::optional<QuorumPhase> curPhase,
QuorumPhase nextPhase, QuorumPhase nextPhase,
const uint256& expectedQuorumHash, const uint256& expectedQuorumHash,
const WhileWaitFunc& runWhileWaiting) const const WhileWaitFunc& shouldNotWait) const
{ {
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase, nextPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase.has_value() ? int(*curPhase) : -1, int(nextPhase));
while (true) { while (true) {
if (stopRequested) { if (stopRequested) {
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due to stop/shutdown requested\n", __func__, params.name); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due to stop/shutdown requested\n", __func__, params.name);
throw AbortPhaseException(); throw AbortPhaseException();
} }
auto p = GetPhaseAndQuorumHash(); auto [_phase, _quorumHash] = GetPhaseAndQuorumHash();
if (!expectedQuorumHash.IsNull() && p.second != expectedQuorumHash) { if (!expectedQuorumHash.IsNull() && _quorumHash != expectedQuorumHash) {
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due unexpected expectedQuorumHash change\n", __func__, params.name); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due unexpected expectedQuorumHash change\n", __func__, params.name);
throw AbortPhaseException(); throw AbortPhaseException();
} }
if (p.first == nextPhase) { if (_phase == nextPhase) {
break; break;
} }
if (curPhase != QuorumPhase_None && p.first != curPhase) { if (curPhase.has_value() && _phase != curPhase) {
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due unexpected phase change\n", __func__, params.name); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - aborting due unexpected phase change\n", __func__, params.name);
throw AbortPhaseException(); throw AbortPhaseException();
} }
if (!runWhileWaiting()) { if (!shouldNotWait()) {
UninterruptibleSleep(std::chrono::milliseconds{100}); UninterruptibleSleep(std::chrono::milliseconds{100});
} }
} }
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase, nextPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase.has_value() ? int(*curPhase) : -1, int(nextPhase));
if (nextPhase == QuorumPhase_Initialized) { if (nextPhase == QuorumPhase::Initialized) {
quorumDKGDebugManager->ResetLocalSessionStatus(params.type); quorumDKGDebugManager->ResetLocalSessionStatus(params.type);
} else { } else {
quorumDKGDebugManager->UpdateLocalSessionStatus(params.type, [&](CDKGDebugSessionStatus& status) { quorumDKGDebugManager->UpdateLocalSessionStatus(params.type, [&](CDKGDebugSessionStatus& status) {
@ -256,7 +256,7 @@ void CDKGSessionHandler::SleepBeforePhase(QuorumPhase curPhase,
heightTmp = heightStart = currentHeight; heightTmp = heightStart = currentHeight;
} }
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting sleep for %d ms, curPhase=%d\n", __func__, params.name, sleepTime, curPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting sleep for %d ms, curPhase=%d\n", __func__, params.name, sleepTime, int(curPhase));
while (GetTimeMillis() < endTime) { while (GetTimeMillis() < endTime) {
if (stopRequested) { if (stopRequested) {
@ -285,7 +285,7 @@ void CDKGSessionHandler::SleepBeforePhase(QuorumPhase curPhase,
} }
} }
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d\n", __func__, params.name, curPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d\n", __func__, params.name, int(curPhase));
} }
void CDKGSessionHandler::HandlePhase(QuorumPhase curPhase, void CDKGSessionHandler::HandlePhase(QuorumPhase curPhase,
@ -295,13 +295,13 @@ void CDKGSessionHandler::HandlePhase(QuorumPhase curPhase,
const StartPhaseFunc& startPhaseFunc, const StartPhaseFunc& startPhaseFunc,
const WhileWaitFunc& runWhileWaiting) const WhileWaitFunc& runWhileWaiting)
{ {
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase, nextPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - starting, curPhase=%d, nextPhase=%d\n", __func__, params.name, int(curPhase), int(nextPhase));
SleepBeforePhase(curPhase, expectedQuorumHash, randomSleepFactor, runWhileWaiting); SleepBeforePhase(curPhase, expectedQuorumHash, randomSleepFactor, runWhileWaiting);
startPhaseFunc(); startPhaseFunc();
WaitForNextPhase(curPhase, nextPhase, expectedQuorumHash, runWhileWaiting); WaitForNextPhase(curPhase, nextPhase, expectedQuorumHash, runWhileWaiting);
LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, curPhase, nextPhase); LogPrint(BCLog::LLMQ_DKG, "CDKGSessionManager::%s -- %s - done, curPhase=%d, nextPhase=%d\n", __func__, params.name, int(curPhase), int(nextPhase));
} }
// returns a set of NodeIds which sent invalid messages // returns a set of NodeIds which sent invalid messages
@ -458,7 +458,7 @@ void CDKGSessionHandler::HandleDKGRound()
{ {
uint256 curQuorumHash; uint256 curQuorumHash;
WaitForNextPhase(QuorumPhase_None, QuorumPhase_Initialized, uint256(), []{return false;}); WaitForNextPhase(std::nullopt, QuorumPhase::Initialized);
{ {
LOCK(cs); LOCK(cs);
@ -478,8 +478,8 @@ void CDKGSessionHandler::HandleDKGRound()
} }
quorumDKGDebugManager->UpdateLocalSessionStatus(params.type, [&](CDKGDebugSessionStatus& status) { quorumDKGDebugManager->UpdateLocalSessionStatus(params.type, [&](CDKGDebugSessionStatus& status) {
bool changed = status.phase != (uint8_t) QuorumPhase_Initialized; bool changed = status.phase != (uint8_t) QuorumPhase::Initialized;
status.phase = (uint8_t) QuorumPhase_Initialized; status.phase = (uint8_t) QuorumPhase::Initialized;
return changed; return changed;
}); });
@ -488,7 +488,7 @@ void CDKGSessionHandler::HandleDKGRound()
CLLMQUtils::AddQuorumProbeConnections(params, pQuorumBaseBlockIndex, curSession->myProTxHash); CLLMQUtils::AddQuorumProbeConnections(params, pQuorumBaseBlockIndex, curSession->myProTxHash);
} }
WaitForNextPhase(QuorumPhase_Initialized, QuorumPhase_Contribute, curQuorumHash, []{return false;}); WaitForNextPhase(QuorumPhase::Initialized, QuorumPhase::Contribute, curQuorumHash);
// Contribute // Contribute
auto fContributeStart = [this]() { auto fContributeStart = [this]() {
@ -497,7 +497,7 @@ void CDKGSessionHandler::HandleDKGRound()
auto fContributeWait = [this] { auto fContributeWait = [this] {
return ProcessPendingMessageBatch<CDKGContribution, MSG_QUORUM_CONTRIB>(*curSession, pendingContributions, 8); return ProcessPendingMessageBatch<CDKGContribution, MSG_QUORUM_CONTRIB>(*curSession, pendingContributions, 8);
}; };
HandlePhase(QuorumPhase_Contribute, QuorumPhase_Complain, curQuorumHash, 0.05, fContributeStart, fContributeWait); HandlePhase(QuorumPhase::Contribute, QuorumPhase::Complain, curQuorumHash, 0.05, fContributeStart, fContributeWait);
// Complain // Complain
auto fComplainStart = [this]() { auto fComplainStart = [this]() {
@ -506,7 +506,7 @@ void CDKGSessionHandler::HandleDKGRound()
auto fComplainWait = [this] { auto fComplainWait = [this] {
return ProcessPendingMessageBatch<CDKGComplaint, MSG_QUORUM_COMPLAINT>(*curSession, pendingComplaints, 8); return ProcessPendingMessageBatch<CDKGComplaint, MSG_QUORUM_COMPLAINT>(*curSession, pendingComplaints, 8);
}; };
HandlePhase(QuorumPhase_Complain, QuorumPhase_Justify, curQuorumHash, 0.05, fComplainStart, fComplainWait); HandlePhase(QuorumPhase::Complain, QuorumPhase::Justify, curQuorumHash, 0.05, fComplainStart, fComplainWait);
// Justify // Justify
auto fJustifyStart = [this]() { auto fJustifyStart = [this]() {
@ -515,7 +515,7 @@ void CDKGSessionHandler::HandleDKGRound()
auto fJustifyWait = [this] { auto fJustifyWait = [this] {
return ProcessPendingMessageBatch<CDKGJustification, MSG_QUORUM_JUSTIFICATION>(*curSession, pendingJustifications, 8); return ProcessPendingMessageBatch<CDKGJustification, MSG_QUORUM_JUSTIFICATION>(*curSession, pendingJustifications, 8);
}; };
HandlePhase(QuorumPhase_Justify, QuorumPhase_Commit, curQuorumHash, 0.05, fJustifyStart, fJustifyWait); HandlePhase(QuorumPhase::Justify, QuorumPhase::Commit, curQuorumHash, 0.05, fJustifyStart, fJustifyWait);
// Commit // Commit
auto fCommitStart = [this]() { auto fCommitStart = [this]() {
@ -524,7 +524,7 @@ void CDKGSessionHandler::HandleDKGRound()
auto fCommitWait = [this] { auto fCommitWait = [this] {
return ProcessPendingMessageBatch<CDKGPrematureCommitment, MSG_QUORUM_PREMATURE_COMMITMENT>(*curSession, pendingPrematureCommitments, 8); return ProcessPendingMessageBatch<CDKGPrematureCommitment, MSG_QUORUM_PREMATURE_COMMITMENT>(*curSession, pendingPrematureCommitments, 8);
}; };
HandlePhase(QuorumPhase_Commit, QuorumPhase_Finalize, curQuorumHash, 0.1, fCommitStart, fCommitWait); HandlePhase(QuorumPhase::Commit, QuorumPhase::Finalize, curQuorumHash, 0.1, fCommitStart, fCommitWait);
auto finalCommitments = curSession->FinalizeCommitments(); auto finalCommitments = curSession->FinalizeCommitments();
for (const auto& fqc : finalCommitments) { for (const auto& fqc : finalCommitments) {

27
src/llmq/dkgsessionhandler.h
View File

@ -18,15 +18,14 @@ namespace llmq
class CDKGSession; class CDKGSession;
class CDKGSessionManager; class CDKGSessionManager;
enum QuorumPhase { enum class QuorumPhase {
QuorumPhase_None = -1, Initialized = 1,
QuorumPhase_Initialized = 1, Contribute,
QuorumPhase_Contribute, Complain,
QuorumPhase_Complain, Justify,
QuorumPhase_Justify, Commit,
QuorumPhase_Commit, Finalize,
QuorumPhase_Finalize, Idle,
QuorumPhase_Idle,
}; };
/** /**
@ -111,7 +110,7 @@ private:
CBLSWorker& blsWorker; CBLSWorker& blsWorker;
CDKGSessionManager& dkgManager; CDKGSessionManager& dkgManager;
QuorumPhase phase GUARDED_BY(cs) {QuorumPhase_Idle}; QuorumPhase phase GUARDED_BY(cs) {QuorumPhase::Idle};
int currentHeight GUARDED_BY(cs) {-1}; int currentHeight GUARDED_BY(cs) {-1};
uint256 quorumHash GUARDED_BY(cs); uint256 quorumHash GUARDED_BY(cs);
@ -154,7 +153,13 @@ private:
using StartPhaseFunc = std::function<void()>; using StartPhaseFunc = std::function<void()>;
using WhileWaitFunc = std::function<bool()>; using WhileWaitFunc = std::function<bool()>;
void WaitForNextPhase(QuorumPhase curPhase, QuorumPhase nextPhase, const uint256& expectedQuorumHash, const WhileWaitFunc& runWhileWaiting) const; /**
* @param curPhase current QuorumPhase
* @param nextPhase next QuorumPhase
* @param expectedQuorumHash expected QuorumHash, defaults to null
* @param shouldNotWait function that returns bool, defaults to function that returns false. If the function returns false, we will wait in the loop, if true, we don't wait
*/
void WaitForNextPhase(std::optional<QuorumPhase> curPhase, QuorumPhase nextPhase, const uint256& expectedQuorumHash=uint256(), const WhileWaitFunc& shouldNotWait=[]{return false;}) const;
void WaitForNewQuorum(const uint256& oldQuorumHash) const; void WaitForNewQuorum(const uint256& oldQuorumHash) const;
void SleepBeforePhase(QuorumPhase curPhase, const uint256& expectedQuorumHash, double randomSleepFactor, const WhileWaitFunc& runWhileWaiting) const; void SleepBeforePhase(QuorumPhase curPhase, const uint256& expectedQuorumHash, double randomSleepFactor, const WhileWaitFunc& runWhileWaiting) const;
void HandlePhase(QuorumPhase curPhase, QuorumPhase nextPhase, const uint256& expectedQuorumHash, double randomSleepFactor, const StartPhaseFunc& startPhaseFunc, const WhileWaitFunc& runWhileWaiting); void HandlePhase(QuorumPhase curPhase, QuorumPhase nextPhase, const uint256& expectedQuorumHash, double randomSleepFactor, const StartPhaseFunc& startPhaseFunc, const WhileWaitFunc& runWhileWaiting);

8
src/llmq/dkgsessionmgr.cpp
View File

@ -213,7 +213,7 @@ bool CDKGSessionManager::GetContribution(const uint256& hash, CDKGContribution&
for (const auto& p : dkgSessionHandlers) { for (const auto& p : dkgSessionHandlers) {
auto& dkgType = p.second; auto& dkgType = p.second;
LOCK(dkgType.cs); LOCK(dkgType.cs);
if (dkgType.phase < QuorumPhase_Initialized || dkgType.phase > QuorumPhase_Contribute) { if (dkgType.phase < QuorumPhase::Initialized || dkgType.phase > QuorumPhase::Contribute) {
continue; continue;
} }
LOCK(dkgType.curSession->invCs); LOCK(dkgType.curSession->invCs);
@ -234,7 +234,7 @@ bool CDKGSessionManager::GetComplaint(const uint256& hash, CDKGComplaint& ret) c
for (const auto& p : dkgSessionHandlers) { for (const auto& p : dkgSessionHandlers) {
auto& dkgType = p.second; auto& dkgType = p.second;
LOCK(dkgType.cs); LOCK(dkgType.cs);
if (dkgType.phase < QuorumPhase_Contribute || dkgType.phase > QuorumPhase_Complain) { if (dkgType.phase < QuorumPhase::Contribute || dkgType.phase > QuorumPhase::Complain) {
continue; continue;
} }
LOCK(dkgType.curSession->invCs); LOCK(dkgType.curSession->invCs);
@ -255,7 +255,7 @@ bool CDKGSessionManager::GetJustification(const uint256& hash, CDKGJustification
for (const auto& p : dkgSessionHandlers) { for (const auto& p : dkgSessionHandlers) {
auto& dkgType = p.second; auto& dkgType = p.second;
LOCK(dkgType.cs); LOCK(dkgType.cs);
if (dkgType.phase < QuorumPhase_Complain || dkgType.phase > QuorumPhase_Justify) { if (dkgType.phase < QuorumPhase::Complain || dkgType.phase > QuorumPhase::Justify) {
continue; continue;
} }
LOCK(dkgType.curSession->invCs); LOCK(dkgType.curSession->invCs);
@ -276,7 +276,7 @@ bool CDKGSessionManager::GetPrematureCommitment(const uint256& hash, CDKGPrematu
for (const auto& p : dkgSessionHandlers) { for (const auto& p : dkgSessionHandlers) {
auto& dkgType = p.second; auto& dkgType = p.second;
LOCK(dkgType.cs); LOCK(dkgType.cs);
if (dkgType.phase < QuorumPhase_Justify || dkgType.phase > QuorumPhase_Commit) { if (dkgType.phase < QuorumPhase::Justify || dkgType.phase > QuorumPhase::Commit) {
continue; continue;
} }
LOCK(dkgType.curSession->invCs); LOCK(dkgType.curSession->invCs);