int MasterStateMachine :: UpdateByCheckpoint(const std::string & sCPBuffer, bool & bChange)
{
if (sCPBuffer.size() == 0)
{
return 0;
}
MasterVariables oVariables;
bool bSucc = oVariables.ParseFromArray(sCPBuffer.data(), sCPBuffer.size());
if (!bSucc)
{
PLG1Err("Variables.ParseFromArray fail, bufferlen %zu", sCPBuffer.size());
return -1;
}
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
if (oVariables.version() <= m_llMasterVersion
&& m_llMasterVersion != (uint64_t)-1)
{
PLG1Imp("lag checkpoint, no need update, cp.version %lu now.version %lu",
oVariables.version(), m_llMasterVersion);
return 0;
}
int ret = UpdateMasterToStore(oVariables.masternodeid(), oVariables.version(), oVariables.leasetime());
if (ret != 0)
{
return -1;
}
PLG1Head("ok, cp.version %lu cp.masternodeid %lu old.version %lu old.masternodeid %lu",
oVariables.version(), oVariables.masternodeid(),
m_llMasterVersion, m_iMasterNodeID);
m_llMasterVersion = oVariables.version();
if (oVariables.masternodeid() == m_iMyNodeID)
{
m_iMasterNodeID = nullnode;
m_llAbsExpireTime = 0;
}
else
{
m_iMasterNodeID = oVariables.masternodeid();
m_llAbsExpireTime = Time::GetSteadyClockMS() + oVariables.leasetime();
}
return 0;
}
void MasterStateMachine :: SafeGetMaster(nodeid_t & iMasterNodeID, uint64_t & llMasterVersion)
{
ScopedLock<Mutex> oLockGuard(m_oMutex);
if (Time::GetTimestampMS() >= m_llAbsExpireTime)
{
iMasterNodeID = nullnode;
}
else
{
iMasterNodeID = m_iMasterNodeID;
}
llMasterVersion = m_llMasterVersion;
}
MessageEvent * TcpClient :: GetEvent(const std::string & sIP, const int iPort)
{
uint32_t iIP = (uint32_t)inet_addr(sIP.c_str());
uint64_t llNodeID = (((uint64_t)iIP) << 32) | iPort;
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
auto it = m_mapEvent.find(llNodeID);
if (it != end(m_mapEvent))
{
return it->second;
}
return CreateEvent(llNodeID, sIP, iPort);
}
void MasterStateMachine :: BeforePropose(const int iGroupIdx, std::string & sValue)
{
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
MasterOperator oMasterOper;
bool bSucc = oMasterOper.ParseFromArray(sValue.data(), sValue.size());
if (!bSucc)
{
return;
}
oMasterOper.set_lastversion(m_llMasterVersion);
sValue.clear();
bSucc = oMasterOper.SerializeToString(&sValue);
assert(bSucc == true);
}
void MasterStateMachine :: SafeGetMaster(nodeid_t & iMasterNodeID, uint64_t & llMasterVersion)
{
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
if (Time::GetSteadyClockMS() >= m_llAbsExpireTime)
{
iMasterNodeID = nullnode;
}
else
{
iMasterNodeID = m_iMasterNodeID;
}
llMasterVersion = m_llMasterVersion;
}
int MasterStateMachine :: LearnMaster(
const uint64_t llInstanceID,
const MasterOperator & oMasterOper,
const uint64_t llAbsMasterTimeout)
{
ScopedLock<Mutex> oLockGuard(m_oMutex);
if (oMasterOper.version() != m_llMasterVersion)
{
PLG1Err("version conflit, op version %lu now master version %lu",
oMasterOper.version(), m_llMasterVersion);
return 0;
}
int ret = UpdateMasterToStore(oMasterOper.nodeid(), llInstanceID, oMasterOper.timeout());
if (ret != 0)
{
PLG1Err("UpdateMasterToStore fail, ret %d", ret);
return -1;
}
m_iMasterNodeID = oMasterOper.nodeid();
if (m_iMasterNodeID == m_iMyNodeID)
{
//self be master
//use local abstimeout
m_llAbsExpireTime = llAbsMasterTimeout;
PLG1Head("Be master success, absexpiretime %lu", m_llAbsExpireTime);
}
else
{
//other be master
//use new start timeout
m_llAbsExpireTime = Time::GetTimestampMS() + oMasterOper.timeout();
PLG1Head("Ohter be master, absexpiretime %lu", m_llAbsExpireTime);
}
m_iLeaseTime = oMasterOper.timeout();
m_llMasterVersion = llInstanceID;
PLG1Imp("OK, masternodeid %lu version %lu abstimeout %lu",
m_iMasterNodeID, m_llMasterVersion, m_llAbsExpireTime);
return 0;
}
int MasterStateMachine :: GetCheckpointBuffer(std::string & sCPBuffer)
{
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
if (m_llMasterVersion == (uint64_t)-1)
{
return 0;
}
MasterVariables oVariables;
oVariables.set_masternodeid(m_iMasterNodeID);
oVariables.set_version(m_llMasterVersion);
oVariables.set_leasetime(m_iLeaseTime);
bool sSucc = oVariables.SerializeToString(&sCPBuffer);
if (!sSucc)
{
PLG1Err("Variables.Serialize fail");
return -1;
}
return 0;
}
int MasterStateMachine :: LearnMaster(
const uint64_t llInstanceID,
const MasterOperator & oMasterOper,
const uint64_t llAbsMasterTimeout)
{
std::lock_guard<std::mutex> oLockGuard(m_oMutex);
PLG1Debug("my last version %lu other last version %lu this version %lu instanceid %lu",
m_llMasterVersion, oMasterOper.lastversion(), oMasterOper.version(), llInstanceID);
if (oMasterOper.lastversion() != 0
&& llInstanceID > m_llMasterVersion
&& oMasterOper.lastversion() != m_llMasterVersion)
{
BP->GetMasterBP()->MasterSMInconsistent();
PLG1Err("other last version %lu not same to my last version %lu, instanceid %lu",
oMasterOper.lastversion(), m_llMasterVersion, llInstanceID);
PLG1Err("try to fix, set my master version %lu as other last version %lu, instanceid %lu",
m_llMasterVersion, oMasterOper.lastversion(), llInstanceID);
m_llMasterVersion = oMasterOper.lastversion();
}
if (oMasterOper.version() != m_llMasterVersion)
{
PLG1Debug("version conflit, op version %lu now master version %lu",
oMasterOper.version(), m_llMasterVersion);
return 0;
}
int ret = UpdateMasterToStore(oMasterOper.nodeid(), llInstanceID, oMasterOper.timeout());
if (ret != 0)
{
PLG1Err("UpdateMasterToStore fail, ret %d", ret);
return -1;
}
bool bMasterChange = false;
if (m_iMasterNodeID != oMasterOper.nodeid())
{
bMasterChange = true;
}
m_iMasterNodeID = oMasterOper.nodeid();
if (m_iMasterNodeID == m_iMyNodeID)
{
//self be master
//use local abstimeout
m_llAbsExpireTime = llAbsMasterTimeout;
BP->GetMasterBP()->SuccessBeMaster();
PLG1Head("Be master success, absexpiretime %lu", m_llAbsExpireTime);
}
else
{
//other be master
//use new start timeout
m_llAbsExpireTime = Time::GetSteadyClockMS() + oMasterOper.timeout();
BP->GetMasterBP()->OtherBeMaster();
PLG1Head("Ohter be master, absexpiretime %lu", m_llAbsExpireTime);
}
m_iLeaseTime = oMasterOper.timeout();
m_llMasterVersion = llInstanceID;
if (bMasterChange)
{
if (m_pMasterChangeCallback != nullptr)
{
m_pMasterChangeCallback(m_iMyGroupIdx, NodeInfo(m_iMasterNodeID), m_llMasterVersion);
}
}
PLG1Imp("OK, masternodeid %lu version %lu abstimeout %lu",
m_iMasterNodeID, m_llMasterVersion, m_llAbsExpireTime);
return 0;
}
