Below is the list of changes that have just been committed into a local
5.1 repository of jonas. When jonas does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html
ChangeSet
1.2298 06/04/06 16:25:19 jonas@stripped +2 -0
Merge perch.ndb.mysql.com:/home/jonas/src/50-work
into perch.ndb.mysql.com:/home/jonas/src/51-work
storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
1.30 06/04/06 16:25:16 jonas@stripped +3 -4
merge
storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
1.13 06/04/06 16:25:16 jonas@stripped +2 -3
merge
storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
1.13.13.2 06/04/06 16:23:08 jonas@stripped +0 -0
Merge rename: ndb/src/kernel/blocks/qmgr/QmgrMain.cpp -> storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
1.3.7.2 06/04/06 16:23:08 jonas@stripped +0 -0
Merge rename: ndb/src/kernel/blocks/qmgr/Qmgr.hpp -> storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp
# This is a BitKeeper patch. What follows are the unified diffs for the
# set of deltas contained in the patch. The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User: jonas
# Host: perch.ndb.mysql.com
# Root: /home/jonas/src/51-work/RESYNC
--- 1.3.7.1/ndb/src/kernel/blocks/qmgr/Qmgr.hpp 2006-04-06 16:19:19 +02:00
+++ 1.13/storage/ndb/src/kernel/blocks/qmgr/Qmgr.hpp 2006-04-06 16:25:16 +02:00
@@ -29,6 +29,10 @@
#include <signaldata/CmRegSignalData.hpp>
#include <signaldata/ApiRegSignalData.hpp>
#include <signaldata/FailRep.hpp>
+#include <signaldata/AllocNodeId.hpp>
+
+#include <SafeCounter.hpp>
+#include <RequestTracker.hpp>
#include <signaldata/StopReq.hpp>
#include "timer.hpp"
@@ -202,7 +206,7 @@
};
public:
- Qmgr(const class Configuration &);
+ Qmgr(Block_context&);
virtual ~Qmgr();
private:
@@ -254,6 +258,12 @@
void execAPI_VERSION_REQ(Signal* signal);
void execAPI_BROADCAST_REP(Signal* signal);
+ void execNODE_FAILREP(Signal *);
+ void execALLOC_NODEID_REQ(Signal *);
+ void execALLOC_NODEID_CONF(Signal *);
+ void execALLOC_NODEID_REF(Signal *);
+ void completeAllocNodeIdReq(Signal *);
+
// Arbitration signals
void execARBIT_CFG(Signal* signal);
void execARBIT_PREPREQ(Signal* signal);
@@ -423,6 +433,15 @@
Uint16 cfailedNodes[MAX_NDB_NODES];
Uint16 cprepFailedNodes[MAX_NDB_NODES];
Uint16 ccommitFailedNodes[MAX_NDB_NODES];
+
+ struct OpAllocNodeIdReq {
+ RequestTracker m_tracker;
+ AllocNodeIdReq m_req;
+ Uint32 m_connectCount;
+ Uint32 m_error;
+ };
+
+ struct OpAllocNodeIdReq opAllocNodeIdReq;
StopReq c_stopReq;
bool check_multi_node_shutdown(Signal* signal);
--- 1.13.13.1/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp 2006-04-06 16:19:19 +02:00
+++ 1.30/storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp 2006-04-06 16:25:16 +02:00
@@ -228,7 +228,7 @@
Uint32 senderData = req->senderData;
const ndb_mgm_configuration_iterator * p =
- theConfiguration.getOwnConfigIterator();
+ m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
ReadConfigConf * conf = (ReadConfigConf*)signal->getDataPtrSend();
@@ -2007,7 +2007,7 @@
* Timeouts
*/
const ndb_mgm_configuration_iterator * p =
- theConfiguration.getOwnConfigIterator();
+ m_ctx.m_config.getOwnConfigIterator();
ndbrequire(p != 0);
Uint32 hbDBDB = 1500;
@@ -2056,7 +2056,7 @@
sd->ticket.clear();
sd->mask.clear();
ndb_mgm_configuration_iterator * iter =
- theConfiguration.getClusterConfigIterator();
+ m_ctx.m_config.getClusterConfigIterator();
for (ndb_mgm_first(iter); ndb_mgm_valid(iter); ndb_mgm_next(iter)) {
Uint32 tmp = 0;
if (ndb_mgm_get_int_parameter(iter, CFG_NODE_ARBIT_RANK, &tmp) == 0 &&
@@ -2613,9 +2613,6 @@
case NodeInfo::MGM:
compatability_check = ndbCompatible_ndb_mgmt(NDB_VERSION, version);
break;
- case NodeInfo::REP:
- // compatability_check = ndbCompatible_ndb_api(NDB_VERSION, version);
- // break;
case NodeInfo::DB:
case NodeInfo::INVALID:
default:
@@ -2646,7 +2643,7 @@
apiRegConf->qmgrRef = reference();
apiRegConf->apiHeartbeatFrequency = (chbApiDelay / 10);
apiRegConf->version = NDB_VERSION;
- apiRegConf->nodeState = getNodeState();
+ NodeState state= apiRegConf->nodeState = getNodeState();
{
NodeRecPtr nodePtr;
nodePtr.i = getOwnNodeId();
@@ -2664,9 +2661,12 @@
sendSignal(ref, GSN_API_REGCONF, signal, ApiRegConf::SignalLength, JBB);
- if ((getNodeState().startLevel == NodeState::SL_STARTED ||
- getNodeState().getSingleUserMode())
- && apiNodePtr.p->phase == ZAPI_INACTIVE) {
+ if (apiNodePtr.p->phase == ZAPI_INACTIVE &&
+ (state.startLevel == NodeState::SL_STARTED ||
+ state.getSingleUserMode() ||
+ (state.startLevel == NodeState::SL_STARTING &&
+ state.starting.startPhase >= 100)))
+ {
jam();
/**----------------------------------------------------------------------
* THE API NODE IS REGISTERING. WE WILL ACCEPT IT BY CHANGING STATE AND
@@ -2676,6 +2676,9 @@
apiNodePtr.p->blockRef = ref;
signal->theData[0] = apiNodePtr.i;
sendSignal(CMVMI_REF, GSN_ENABLE_COMORD, signal, 1, JBA);
+
+ signal->theData[0] = apiNodePtr.i;
+ EXECUTE_DIRECT(NDBCNTR, GSN_API_START_REP, signal, 1);
}
return;
}//Qmgr::execAPI_REGREQ()
@@ -4720,6 +4723,170 @@
}
void
+Qmgr::execNODE_FAILREP(Signal * signal)
+{
+ jamEntry();
+ // make sure any distributed signals get acknowledged
+ // destructive of the signal
+ c_counterMgr.execNODE_FAILREP(signal);
+}
+
+void
+Qmgr::execALLOC_NODEID_REQ(Signal * signal)
+{
+ jamEntry();
+ const AllocNodeIdReq * req = (AllocNodeIdReq*)signal->getDataPtr();
+ Uint32 senderRef = req->senderRef;
+ Uint32 nodeId = req->nodeId;
+ Uint32 error = 0;
+
+ if (refToBlock(senderRef) != QMGR) // request from management server
+ {
+ /* master */
+
+ if (getOwnNodeId() != cpresident)
+ error = AllocNodeIdRef::NotMaster;
+ else if (!opAllocNodeIdReq.m_tracker.done())
+ error = AllocNodeIdRef::Busy;
+ else if (c_connectedNodes.get(nodeId))
+ error = AllocNodeIdRef::NodeConnected;
+
+ if (error)
+ {
+ jam();
+ AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend();
+ ref->senderRef = reference();
+ ref->errorCode = error;
+ ref->masterRef = numberToRef(QMGR, cpresident);
+ sendSignal(senderRef, GSN_ALLOC_NODEID_REF, signal,
+ AllocNodeIdRef::SignalLength, JBB);
+ return;
+ }
+
+ opAllocNodeIdReq.m_req = *req;
+ opAllocNodeIdReq.m_error = 0;
+ opAllocNodeIdReq.m_connectCount = getNodeInfo(refToNode(senderRef)).m_connectCount;
+
+ jam();
+ AllocNodeIdReq * req = (AllocNodeIdReq*)signal->getDataPtrSend();
+ req->senderRef = reference();
+ NodeReceiverGroup rg(QMGR, c_clusterNodes);
+ RequestTracker & p = opAllocNodeIdReq.m_tracker;
+ p.init<AllocNodeIdRef>(c_counterMgr, rg, GSN_ALLOC_NODEID_REF, 0);
+
+ sendSignal(rg, GSN_ALLOC_NODEID_REQ, signal,
+ AllocNodeIdReq::SignalLength, JBB);
+ return;
+ }
+
+ /* participant */
+
+ if (c_connectedNodes.get(nodeId))
+ error = AllocNodeIdRef::NodeConnected;
+ else
+ {
+ NodeRecPtr nodePtr;
+ nodePtr.i = nodeId;
+ ptrAss(nodePtr, nodeRec);
+ if (nodePtr.p->failState != NORMAL)
+ error = AllocNodeIdRef::NodeFailureHandlingNotCompleted;
+ }
+
+ if (error)
+ {
+ AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend();
+ ref->senderRef = reference();
+ ref->errorCode = error;
+ sendSignal(senderRef, GSN_ALLOC_NODEID_REF, signal,
+ AllocNodeIdRef::SignalLength, JBB);
+ return;
+ }
+
+ AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtrSend();
+ conf->senderRef = reference();
+ sendSignal(senderRef, GSN_ALLOC_NODEID_CONF, signal,
+ AllocNodeIdConf::SignalLength, JBB);
+}
+
+void
+Qmgr::execALLOC_NODEID_CONF(Signal * signal)
+{
+ /* master */
+
+ jamEntry();
+ const AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtr();
+ opAllocNodeIdReq.m_tracker.reportConf(c_counterMgr,
+ refToNode(conf->senderRef));
+ completeAllocNodeIdReq(signal);
+}
+
+
+void
+Qmgr::execALLOC_NODEID_REF(Signal * signal)
+{
+ /* master */
+
+ jamEntry();
+ const AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtr();
+ if (ref->errorCode == AllocNodeIdRef::NF_FakeErrorREF)
+ {
+ opAllocNodeIdReq.m_tracker.ignoreRef(c_counterMgr,
+ refToNode(ref->senderRef));
+ }
+ else
+ {
+ opAllocNodeIdReq.m_tracker.reportRef(c_counterMgr,
+ refToNode(ref->senderRef));
+ if (opAllocNodeIdReq.m_error == 0)
+ opAllocNodeIdReq.m_error = ref->errorCode;
+ }
+ completeAllocNodeIdReq(signal);
+}
+
+void
+Qmgr::completeAllocNodeIdReq(Signal *signal)
+{
+ /* master */
+
+ if (!opAllocNodeIdReq.m_tracker.done())
+ {
+ jam();
+ return;
+ }
+
+ if (opAllocNodeIdReq.m_connectCount !=
+ getNodeInfo(refToNode(opAllocNodeIdReq.m_req.senderRef)).m_connectCount)
+ {
+ // management server not same version as the original requester
+ jam();
+ return;
+ }
+
+ if (opAllocNodeIdReq.m_tracker.hasRef())
+ {
+ jam();
+ AllocNodeIdRef * ref = (AllocNodeIdRef*)signal->getDataPtrSend();
+ ref->senderRef = reference();
+ ref->senderData = opAllocNodeIdReq.m_req.senderData;
+ ref->nodeId = opAllocNodeIdReq.m_req.nodeId;
+ ref->errorCode = opAllocNodeIdReq.m_error;
+ ref->masterRef = numberToRef(QMGR, cpresident);
+ ndbassert(AllocNodeIdRef::SignalLength == 5);
+ sendSignal(opAllocNodeIdReq.m_req.senderRef, GSN_ALLOC_NODEID_REF, signal,
+ AllocNodeIdRef::SignalLength, JBB);
+ return;
+ }
+ jam();
+ AllocNodeIdConf * conf = (AllocNodeIdConf*)signal->getDataPtrSend();
+ conf->senderRef = reference();
+ conf->senderData = opAllocNodeIdReq.m_req.senderData;
+ conf->nodeId = opAllocNodeIdReq.m_req.nodeId;
+ ndbassert(AllocNodeIdConf::SignalLength == 3);
+ sendSignal(opAllocNodeIdReq.m_req.senderRef, GSN_ALLOC_NODEID_CONF, signal,
+ AllocNodeIdConf::SignalLength, JBB);
+}
+
+void
Qmgr::execSTOP_REQ(Signal* signal)
{
jamEntry();
@@ -4727,6 +4894,7 @@
if (c_stopReq.senderRef)
{
+ jam();
ndbrequire(NdbNodeBitmask::get(c_stopReq.nodes, getOwnNodeId()));
StopConf *conf = (StopConf*)signal->getDataPtrSend();
| Thread |
|---|
| • bk commit into 5.1 tree (jonas:1.2298) | jonas | 6 Apr |
