4044 jonas oreland 2010-12-03
ndb - move checks from TransporterFacade::sendSignal to NdbImpl::sendSignal
modified:
storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp
storage/ndb/src/ndbapi/NdbImpl.hpp
storage/ndb/src/ndbapi/Ndbif.cpp
storage/ndb/src/ndbapi/TransporterFacade.cpp
storage/ndb/src/ndbapi/TransporterFacade.hpp
storage/ndb/src/ndbapi/trp_client.hpp
4043 jonas oreland 2010-12-02 [merge]
ndb - merge 63 to 70
modified:
storage/ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
=== modified file 'storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp'
--- a/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp 2010-11-28 11:34:01 +0000
+++ b/storage/ndb/src/ndbapi/NdbDictionaryImpl.cpp 2010-12-03 05:53:47 +0000
@@ -2240,8 +2240,8 @@ NdbDictInterface::dictSignal(NdbApiSigna
DBUG_RETURN(-1);
}
int res = (ptr ?
- getTransporter()->sendFragmentedSignal(sig, node, ptr, secs):
- getTransporter()->sendSignal(sig, node));
+ m_impl->sendFragmentedSignal(sig, node, ptr, secs):
+ m_impl->sendSignal(sig, node));
if(res != 0){
DBUG_PRINT("info", ("dictSignal failed to send signal"));
m_error.code = 4007;
@@ -5599,7 +5599,7 @@ NdbDictInterface::listObjects(NdbApiSign
m_error.code= 4009;
return -1;
}
- NodeInfo info = getTransporter()->theClusterMgr->getNodeInfo(aNodeId).m_info;
+ NodeInfo info = m_impl->getNodeInfo(aNodeId).m_info;
if (ndbd_LIST_TABLES_CONF_long_signal(info.m_version))
{
/*
@@ -5617,7 +5617,7 @@ NdbDictInterface::listObjects(NdbApiSign
return -1;
}
- if (getTransporter()->sendSignal(signal, aNodeId) != 0) {
+ if (m_impl->sendSignal(signal, aNodeId) != 0) {
continue;
}
m_error.code= 0;
@@ -5639,7 +5639,7 @@ NdbDictInterface::execLIST_TABLES_CONF(c
const LinearSectionPtr ptr[3])
{
Uint16 nodeId = refToNode(signal->theSendersBlockRef);
- NodeInfo info = getTransporter()->theClusterMgr->getNodeInfo(nodeId).m_info;
+ NodeInfo info = m_impl->getNodeInfo(nodeId).m_info;
if (!ndbd_LIST_TABLES_CONF_long_signal(info.m_version))
{
/*
@@ -5760,7 +5760,7 @@ NdbDictInterface::forceGCPWait(int type)
m_error.code= 4009;
return -1;
}
- if (getTransporter()->sendSignal(&tSignal, aNodeId) != 0)
+ if (m_impl->sendSignal(&tSignal, aNodeId) != 0)
{
continue;
}
@@ -5788,20 +5788,20 @@ NdbDictInterface::forceGCPWait(int type)
const Uint32 RETRIES = 100;
for (Uint32 i = 0; i < RETRIES; i++)
{
- getTransporter()->lock_mutex();
+ m_impl->lock();
Uint16 aNodeId = getTransporter()->get_an_alive_node();
if (aNodeId == 0) {
m_error.code= 4009;
- getTransporter()->unlock_mutex();
+ m_impl->unlock();
return -1;
}
- if (getTransporter()->sendSignal(&tSignal, aNodeId) != 0) {
- getTransporter()->unlock_mutex();
+ if (m_impl->sendSignal(&tSignal, aNodeId) != 0) {
+ m_impl->unlock();
continue;
}
- getTransporter()->forceSend(refToBlock(m_reference));
- getTransporter()->unlock_mutex();
+ m_impl->forceSend();
+ m_impl->unlock();
}
return m_error.code == 0 ? 0 : -1;
}
=== modified file 'storage/ndb/src/ndbapi/NdbImpl.hpp'
--- a/storage/ndb/src/ndbapi/NdbImpl.hpp 2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/NdbImpl.hpp 2010-12-03 05:53:47 +0000
@@ -164,6 +164,16 @@ public:
Uint32 getNodeNdbVersion(NodeId nodeId) const;
Uint32 getMinDbNodeVersion() const;
bool check_send_size(Uint32 node_id, Uint32 send_size) const { return true;}
+
+ int sendSignal(NdbApiSignal*, Uint32 nodeId);
+ int sendSignal(NdbApiSignal*, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
+ int sendSignal(NdbApiSignal*, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs);
+ int sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
+ int sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs);
};
#ifdef VM_TRACE
@@ -443,4 +453,63 @@ NdbImpl::getNodeNdbVersion(NodeId n) con
return getNodeInfo(n).m_info.m_version;
}
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId)
+{
+ if (getIsNodeSendable(nodeId))
+ {
+ return raw_sendSignal(signal, nodeId);
+ }
+ return -1;
+}
+
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs)
+{
+ if (getIsNodeSendable(nodeId))
+ {
+ return raw_sendSignal(signal, nodeId, ptr, secs);
+ }
+ return -1;
+}
+
+inline
+int
+NdbImpl::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs)
+{
+ if (getIsNodeSendable(nodeId))
+ {
+ return raw_sendSignal(signal, nodeId, ptr, secs);
+ }
+ return -1;
+}
+
+inline
+int
+NdbImpl::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs)
+{
+ if (getIsNodeSendable(nodeId))
+ {
+ return raw_sendFragmentedSignal(signal, nodeId, ptr, secs);
+ }
+ return -1;
+}
+
+inline
+int
+NdbImpl::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs)
+{
+ if (getIsNodeSendable(nodeId))
+ {
+ return raw_sendFragmentedSignal(signal, nodeId, ptr, secs);
+ }
+ return -1;
+}
+
#endif
=== modified file 'storage/ndb/src/ndbapi/Ndbif.cpp'
--- a/storage/ndb/src/ndbapi/Ndbif.cpp 2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/Ndbif.cpp 2010-12-03 05:53:47 +0000
@@ -1418,7 +1418,7 @@ NdbImpl::send_event_report(bool has_lock
int ret = 0;
if (!has_lock)
{
- tp->lock_mutex();
+ lock();
}
Uint32 tNode;
Ndb_cluster_connection_node_iter node_iter;
@@ -1427,7 +1427,7 @@ NdbImpl::send_event_report(bool has_lock
{
if(get_node_alive(tNode))
{
- sendSignal(&aSignal, tNode);
+ tp->sendSignal(&aSignal, tNode);
goto done;
}
}
@@ -1436,7 +1436,7 @@ NdbImpl::send_event_report(bool has_lock
done:
if (!has_lock)
{
- tp->unlock_mutex();
+ unlock();
}
return ret;
}
=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.cpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.cpp 2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.cpp 2010-12-03 05:53:47 +0000
@@ -857,47 +857,47 @@ TransporterFacade::checkForceSend(Uint32
* SEND SIGNAL METHODS
*****************************************************************************/
int
-TransporterFacade::sendSignal(NdbApiSignal * aSignal, NodeId aNode){
+TransporterFacade::sendSignal(NdbApiSignal * aSignal, NodeId aNode)
+{
Uint32* tDataPtr = aSignal->getDataPtrSend();
Uint32 Tlen = aSignal->theLength;
Uint32 TBno = aSignal->theReceiversBlockNumber;
- if(getIsNodeSendable(aNode) == true){
#ifdef API_TRACE
- if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
- Uint32 tmp = aSignal->theSendersBlockRef;
- aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
- LinearSectionPtr ptr[3];
- signalLogger.sendSignal(* aSignal,
- 1,
- tDataPtr,
- aNode, ptr, 0);
- signalLogger.flushSignalLog();
- aSignal->theSendersBlockRef = tmp;
- }
+ if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+ Uint32 tmp = aSignal->theSendersBlockRef;
+ aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+ LinearSectionPtr ptr[3];
+ signalLogger.sendSignal(* aSignal,
+ 1,
+ tDataPtr,
+ aNode, ptr, 0);
+ signalLogger.flushSignalLog();
+ aSignal->theSendersBlockRef = tmp;
+ }
#endif
- if ((Tlen != 0) && (Tlen <= 25) && (TBno != 0)) {
- SendStatus ss = theTransporterRegistry->prepareSend(aSignal,
- 1, // JBB
- tDataPtr,
- aNode,
- (LinearSectionPtr*)0);
- //if (ss != SEND_OK) ndbout << ss << endl;
- return (ss == SEND_OK ? 0 : -1);
- } else {
- ndbout << "ERR: SigLen = " << Tlen << " BlockRec = " << TBno;
- ndbout << " SignalNo = " << aSignal->theVerId_signalNumber << endl;
- assert(0);
- }//if
+ if ((Tlen != 0) && (Tlen <= 25) && (TBno != 0)) {
+ SendStatus ss = theTransporterRegistry->prepareSend(aSignal,
+ 1, // JBB
+ tDataPtr,
+ aNode,
+ (LinearSectionPtr*)0);
+ //if (ss != SEND_OK) ndbout << ss << endl;
+ return (ss == SEND_OK ? 0 : -1);
}
- //const ClusterMgr::Node & node = theClusterMgr->getNodeInfo(aNode);
- //const Uint32 startLevel = node.m_state.startLevel;
+ else
+ {
+ ndbout << "ERR: SigLen = " << Tlen << " BlockRec = " << TBno;
+ ndbout << " SignalNo = " << aSignal->theVerId_signalNumber << endl;
+ assert(0);
+ }//if
return -1; // Node Dead
}
int
TransporterFacade::sendSignalUnCond(NdbApiSignal * aSignal,
NodeId aNode,
- Uint32 prio){
+ Uint32 prio)
+{
Uint32* tDataPtr = aSignal->getDataPtrSend();
assert(prio <= 1);
#ifdef API_TRACE
@@ -1151,7 +1151,7 @@ public:
int
TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal,
NodeId aNode,
- const GenericSectionPtr ptr[3],
+ const GenericSectionPtr ptr[3],
Uint32 secs)
{
unsigned i;
@@ -1163,10 +1163,6 @@ TransporterFacade::sendFragmentedSignal(
if (totalSectionLength <= CHUNK_SZ)
return sendSignal(aSignal, aNode, ptr, secs);
- /* We will fragment */
- if(getIsNodeSendable(aNode) != true)
- return -1;
-
// TODO : Consider tracing fragment signals?
#ifdef API_TRACE
if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
@@ -1333,8 +1329,8 @@ TransporterFacade::sendFragmentedSignal(
}
int
-TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal, NodeId aNode,
- const LinearSectionPtr ptr[3],
+TransporterFacade::sendFragmentedSignal(NdbApiSignal* aSignal, NodeId aNode,
+ const LinearSectionPtr ptr[3],
Uint32 secs)
{
/* Use the GenericSection variant of sendFragmentedSignal */
@@ -1363,70 +1359,64 @@ TransporterFacade::sendFragmentedSignal(
int
-TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode,
- const LinearSectionPtr ptr[3], Uint32 secs){
+TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode,
+ const LinearSectionPtr ptr[3], Uint32 secs)
+{
aSignal->m_noOfSections = secs;
- if(getIsNodeSendable(aNode) == true){
#ifdef API_TRACE
- if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
- Uint32 tmp = aSignal->theSendersBlockRef;
- aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
- signalLogger.sendSignal(* aSignal,
- 1,
- aSignal->getDataPtrSend(),
- aNode,
- ptr, secs);
- signalLogger.flushSignalLog();
- aSignal->theSendersBlockRef = tmp;
- }
-#endif
- SendStatus ss = theTransporterRegistry->prepareSend
- (aSignal,
- 1, // JBB
- aSignal->getDataPtrSend(),
- aNode,
- ptr);
- assert(ss != SEND_MESSAGE_TOO_BIG);
- aSignal->m_noOfSections = 0;
- return (ss == SEND_OK ? 0 : -1);
+ if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+ Uint32 tmp = aSignal->theSendersBlockRef;
+ aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+ signalLogger.sendSignal(* aSignal,
+ 1,
+ aSignal->getDataPtrSend(),
+ aNode,
+ ptr, secs);
+ signalLogger.flushSignalLog();
+ aSignal->theSendersBlockRef = tmp;
}
+#endif
+ SendStatus ss = theTransporterRegistry->prepareSend
+ (aSignal,
+ 1, // JBB
+ aSignal->getDataPtrSend(),
+ aNode,
+ ptr);
+ assert(ss != SEND_MESSAGE_TOO_BIG);
aSignal->m_noOfSections = 0;
- return -1;
+ return (ss == SEND_OK ? 0 : -1);
}
int
TransporterFacade::sendSignal(NdbApiSignal* aSignal, NodeId aNode,
- const GenericSectionPtr ptr[3], Uint32 secs){
+ const GenericSectionPtr ptr[3], Uint32 secs)
+{
aSignal->m_noOfSections = secs;
- if(getIsNodeSendable(aNode) == true){
#ifdef API_TRACE
- if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
- Uint32 tmp = aSignal->theSendersBlockRef;
- aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
- signalLogger.sendSignal(* aSignal,
- 1,
- aSignal->getDataPtrSend(),
- aNode,
- ptr, secs);
- signalLogger.flushSignalLog();
- aSignal->theSendersBlockRef = tmp;
- }
- /* Reset section iterators */
- for(Uint32 s=0; s < secs; s++)
- ptr[s].sectionIter->reset();
-#endif
- SendStatus ss = theTransporterRegistry->prepareSend
- (aSignal,
- 1, // JBB
- aSignal->getDataPtrSend(),
- aNode,
- ptr);
- assert(ss != SEND_MESSAGE_TOO_BIG);
- aSignal->m_noOfSections = 0;
- return (ss == SEND_OK ? 0 : -1);
+ if(setSignalLog() && TRACE_GSN(aSignal->theVerId_signalNumber)){
+ Uint32 tmp = aSignal->theSendersBlockRef;
+ aSignal->theSendersBlockRef = numberToRef(tmp, theOwnId);
+ signalLogger.sendSignal(* aSignal,
+ 1,
+ aSignal->getDataPtrSend(),
+ aNode,
+ ptr, secs);
+ signalLogger.flushSignalLog();
+ aSignal->theSendersBlockRef = tmp;
}
+ /* Reset section iterators */
+ for(Uint32 s=0; s < secs; s++)
+ ptr[s].sectionIter->reset();
+#endif
+ SendStatus ss = theTransporterRegistry->prepareSend
+ (aSignal,
+ 1, // JBB
+ aSignal->getDataPtrSend(),
+ aNode,
+ ptr);
+ assert(ss != SEND_MESSAGE_TOO_BIG);
aSignal->m_noOfSections = 0;
- return -1;
+ return (ss == SEND_OK ? 0 : -1);
}
/******************************************************************************
@@ -1719,7 +1709,8 @@ template class Vector<trp_client*>;
#include "SignalSender.hpp"
SendStatus
-SignalSender::sendSignal(Uint16 nodeId, const SimpleSignal * s){
+SignalSender::sendSignal(Uint16 nodeId, const SimpleSignal * s)
+{
#ifdef API_TRACE
if(setSignalLog() && TRACE_GSN(s->header.theVerId_signalNumber)){
SignalHeader tmp = s->header;
=== modified file 'storage/ndb/src/ndbapi/TransporterFacade.hpp'
--- a/storage/ndb/src/ndbapi/TransporterFacade.hpp 2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/TransporterFacade.hpp 2010-12-03 05:53:47 +0000
@@ -83,12 +83,12 @@ public:
// Only sends to nodes which are alive
private:
int sendSignal(NdbApiSignal * signal, NodeId nodeId);
- int sendSignal(NdbApiSignal*, NodeId,
- const LinearSectionPtr ptr[3], Uint32 secs);
+ int sendSignal(NdbApiSignal*, NodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
int sendSignal(NdbApiSignal*, NodeId,
const GenericSectionPtr ptr[3], Uint32 secs);
- int sendFragmentedSignal(NdbApiSignal*, NodeId,
- const LinearSectionPtr ptr[3], Uint32 secs);
+ int sendFragmentedSignal(NdbApiSignal*, NodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
int sendFragmentedSignal(NdbApiSignal*, NodeId,
const GenericSectionPtr ptr[3], Uint32 secs);
public:
@@ -206,11 +206,10 @@ private:
friend class ArbitMgr;
friend class MgmtSrvr;
friend class SignalSender;
- friend class Ndb;
friend class Ndb_cluster_connection;
friend class Ndb_cluster_connection_impl;
+ friend class NdbImpl;
friend class NdbTransaction;
- friend class NdbDictInterface;
int sendSignalUnCond(NdbApiSignal *, NodeId nodeId, Uint32 prio = 0);
@@ -327,21 +326,6 @@ TransporterFacade::hb_received(NodeId n)
}
inline
-bool
-TransporterFacade::getIsNodeSendable(NodeId n) const {
- const trp_node & node = theClusterMgr->getNodeInfo(n);
- const Uint32 startLevel = node.m_state.startLevel;
- const NodeInfo::NodeType node_type = node.m_info.getType();
- assert(node_type == NodeInfo::DB ||
- node_type == NodeInfo::MGM);
-
- return node.compatible && (startLevel == NodeState::SL_STARTED ||
- startLevel == NodeState::SL_STOPPING_1 ||
- node.m_state.getSingleUserMode() ||
- node_type == NodeInfo::MGM);
-}
-
-inline
Uint32
TransporterFacade::getMinDbNodeVersion() const
{
=== modified file 'storage/ndb/src/ndbapi/trp_client.hpp'
--- a/storage/ndb/src/ndbapi/trp_client.hpp 2010-11-09 20:40:03 +0000
+++ b/storage/ndb/src/ndbapi/trp_client.hpp 2010-12-03 05:53:47 +0000
@@ -47,13 +47,15 @@ public:
void forceSend(int val = 1);
- int sendSignal(NdbApiSignal * signal, Uint32 nodeId);
- int sendSignal(NdbApiSignal*, Uint32, const LinearSectionPtr p[3], Uint32 s);
- int sendSignal(NdbApiSignal*, Uint32, const GenericSectionPtr p[3], Uint32 s);
- int sendFragmentedSignal(NdbApiSignal*, Uint32,
- const LinearSectionPtr ptr[3], Uint32 secs);
- int sendFragmentedSignal(NdbApiSignal*, Uint32,
- const GenericSectionPtr ptr[3], Uint32 secs);
+ int raw_sendSignal(NdbApiSignal*, Uint32 nodeId);
+ int raw_sendSignal(NdbApiSignal*, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
+ int raw_sendSignal(NdbApiSignal*, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs);
+ int raw_sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs);
+ int raw_sendFragmentedSignal(NdbApiSignal*, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs);
const trp_node & getNodeInfo(Uint32 i) const;
@@ -126,40 +128,46 @@ trp_client::unlock()
inline
int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId)
{
+ assert(m_poll.m_locked);
return m_facade->sendSignal(signal, nodeId);
}
inline
int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
- const LinearSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs)
{
+ assert(m_poll.m_locked);
return m_facade->sendSignal(signal, nodeId, ptr, secs);
}
inline
int
-trp_client::sendSignal(NdbApiSignal * signal, Uint32 nodeId,
- const GenericSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const GenericSectionPtr ptr[3], Uint32 secs)
{
+ assert(m_poll.m_locked);
return m_facade->sendSignal(signal, nodeId, ptr, secs);
}
inline
int
-trp_client::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
- const LinearSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const LinearSectionPtr ptr[3], Uint32 secs)
{
+ assert(m_poll.m_locked);
return m_facade->sendFragmentedSignal(signal, nodeId, ptr, secs);
}
inline
int
-trp_client::sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
- const GenericSectionPtr ptr[3], Uint32 secs)
+trp_client::raw_sendFragmentedSignal(NdbApiSignal * signal, Uint32 nodeId,
+ const GenericSectionPtr ptr[3],
+ Uint32 secs)
{
+ assert(m_poll.m_locked);
return m_facade->sendFragmentedSignal(signal, nodeId, ptr, secs);
}
No bundle (reason: useless for push emails).
| Thread |
|---|
| • bzr push into mysql-5.1-telco-7.0 branch (jonas:4043 to 4044) | jonas oreland | 3 Dec |
