Skip to content

M
mariadb
Commit e77095bc authored by unknown's avatar unknown
Browse files
Options

Merge mysql.com:/home/stewart/Documents/MySQL/4.1/main 

into  mysql.com:/home/stewart/Documents/MySQL/4.1/mgmd
parents 66aef256 7d325ef2
Show whitespace changes
Inline Side-by-side
Showing with 661 additions and 2152 deletions
ndb/include/kernel/GlobalSignalNumbers.h
View file @ e77095bc
......@@ -553,7 +553,6 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
#define GSN_STATISTICS_CONF 454
#define GSN_START_ORD 455
/* 456 unused */
/* 457 unused */
#define GSN_EVENT_SUBSCRIBE_REQ 458
......@@ -835,14 +834,6 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
/* Start Global Replication */
#define GSN_GREP_REQ 656
/**
* Management server
*/
#define GSN_MGM_LOCK_CONFIG_REQ 657
#define GSN_MGM_LOCK_CONFIG_REP 658
#define GSN_MGM_UNLOCK_CONFIG_REQ 659
#define GSN_MGM_UNLOCK_CONFIG_REP 660
#define GSN_UTIL_CREATE_LOCK_REQ 132
#define GSN_UTIL_CREATE_LOCK_REF 133
#define GSN_UTIL_CREATE_LOCK_CONF 188
......@@ -900,6 +891,7 @@ extern const GlobalSignalNumber NO_OF_SIGNAL_NAMES;
#define GSN_RESUME_REQ 682
#define GSN_STOP_REQ 443
#define GSN_STOP_REF 444
#define GSN_STOP_CONF 456
#define GSN_API_VERSION_REQ 697
#define GSN_API_VERSION_CONF 698
......
ndb/include/kernel/signaldata/ApiVersion.hpp
View file @ e77095bc
......@@ -49,12 +49,11 @@ class ApiVersionConf {
*/
friend class MgmtSrv;
public:
STATIC_CONST( SignalLength = 3 );
STATIC_CONST( SignalLength = 4 );
Uint32 senderRef;
Uint32 nodeId; //api node id
Uint32 version; // Version of API node
Uint32 inet_addr;
};
#endif
ndb/include/kernel/signaldata/EventReport.hpp
View file @ e77095bc
......@@ -133,9 +133,9 @@ public:
CreateLogBytes = 48,
InfoEvent = 49,
//GREP
GrepSubscriptionInfo = 52,
GrepSubscriptionAlert = 53,
// SINGLE USER
SingleUser = 52,
/* unused 53 */
//BACKUP
BackupStarted = 54,
......
ndb/include/kernel/signaldata/StopReq.hpp
View file @ e77095bc
......@@ -67,6 +67,13 @@ public:
static bool getStopAbort(const Uint32 & requestInfo);
};
struct StopConf
{
STATIC_CONST( SignalLength = 2 );
Uint32 senderData;
Uint32 nodeState;
};
class StopRef
{
/**
......@@ -86,7 +93,8 @@ public:
OK = 0,
NodeShutdownInProgress = 1,
SystemShutdownInProgress = 2,
NodeShutdownWouldCauseSystemCrash = 3
NodeShutdownWouldCauseSystemCrash = 3,
TransactionAbortFailed = 4
};
public:
......
ndb/src/common/debugger/EventLogger.cpp
View file @ e77095bc
......@@ -105,9 +105,8 @@ const EventLoggerBase::EventRepLogLevelMatrix EventLoggerBase::matrix[] = {
{ EventReport::CreateLogBytes, LogLevel::llInfo, 11, Logger::LL_INFO },
{ EventReport::InfoEvent, LogLevel::llInfo, 2, Logger::LL_INFO },
//Global replication
{ EventReport::GrepSubscriptionInfo, LogLevel::llGrep, 7, Logger::LL_INFO},
{ EventReport::GrepSubscriptionAlert, LogLevel::llGrep, 7, Logger::LL_ALERT},
//Single User
{ EventReport::SingleUser, LogLevel::llInfo, 7, Logger::LL_INFO},
// Backup
{ EventReport::BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO },
......@@ -800,473 +799,29 @@ EventLogger::getText(char * m_text, size_t m_text_len,
);
break;
}
case EventReport::GrepSubscriptionInfo :
case EventReport::SingleUser :
{
GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1];
switch(event) {
case GrepEvent::GrepSS_CreateSubIdConf:
switch (theData[1])
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Created subscription id"
" (subId=%d,SubKey=%d)"
" Return code: %d.",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_CreateSubIdConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Created subscription id"
" (subId=%d,SubKey=%d)"
" Return code: %d.",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubCreateConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int nodegrp = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Created subscription using"
" (subId=%d,SubKey=%d)"
" in primary system. Primary system has %d nodegroup(s)."
" Return code: %d",
subId,
subKey,
nodegrp,
err);
break;
}
case GrepEvent::GrepPS_SubCreateConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have created "
"subscriptions"
" using (subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubStartMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging started on meta data changes."
" using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubStartMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
"logging meta data"
" changes on the subscription subId=%d,SubKey=%d) "
"(N.I yet)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubStartDataConf: {
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging started on table data changes "
" using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubStartDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started logging "
"table data changes on the subscription "
"subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubSyncMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
" synchronization on meta data (META SCAN) using "
"(subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubSyncMetaConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization started (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepPS_SubSyncDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have started "
"synchronization "
" on table data (DATA SCAN) using (subId=%d,SubKey=%d)."
" Return code: %d",
subId,
subKey,
err);
break;
}
case GrepEvent::GrepSS_SubSyncDataConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
case 0:
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization started (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d"
" Return code: %d",
subId,
subKey,
gci,
err);
"%sEntering single user mode", theNodeId);
break;
}
case GrepEvent::GrepPS_SubRemoveConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
case 1:
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: All participants have removed "
"subscription (subId=%d,SubKey=%d). I have cleaned "
"up resources I've used."
" Return code: %d",
subId,
subKey,
err);
"%sEntered single user mode %d", theNodeId, theData[2]);
break;
}
case GrepEvent::GrepSS_SubRemoveConf:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
case 2:
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Removed subscription "
"(subId=%d,SubKey=%d)"
" Return code: %d",
subId,
subKey,
err);
"%sExiting single user mode", theNodeId);
break;
}
default:
BaseString::snprintf(m_text,
m_text_len,
"%sUnknown GrepSubscriptonInfo event: %d",
theNodeId,
theData[1]);
}
break;
}
case EventReport::GrepSubscriptionAlert :
{
GrepEvent::Subscription event = (GrepEvent::Subscription)theData[1];
switch(event)
{
case GrepEvent::GrepSS_CreateSubIdRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord:Error code: %d Error message: %s"
" (subId=%d,SubKey=%d)",
err,
GrepError::getErrorDesc((GrepError::GE_Code)err),
subId,
subKey);
break;
}
case GrepEvent::GrepSS_SubCreateRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: FAILED to Created subscription using"
" (subId=%d,SubKey=%d)in primary system."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubStartMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging failed to start on meta "
"data changes."
" using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubStartDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Logging FAILED to start on table data "
" changes using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubSyncMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization FAILED (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepSS_SubSyncDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Synchronization FAILED (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d"
" Error code: %d Error Message: %s",
subId,
subKey,
gci,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
"%sUnknown single user report %d", theNodeId, theData[1]);
break;
}
case GrepEvent::GrepSS_SubRemoveRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::SSCoord: Failed to remove subscription "
"(subId=%d,SubKey=%d). "
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err)
);
break;
}
case GrepEvent::GrepPS_CreateSubIdRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Error code: %d Error Message: %s"
" (subId=%d,SubKey=%d)",
err,
GrepError::getErrorDesc((GrepError::GE_Code)err),
subId,
subKey);
break;
}
case GrepEvent::GrepPS_SubCreateRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: FAILED to Created subscription using"
" (subId=%d,SubKey=%d)in primary system."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubStartMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Logging failed to start on meta "
"data changes."
" using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubStartDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Logging FAILED to start on table data "
" changes using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubSyncMetaRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Synchronization FAILED (META SCAN) on "
" meta data using (subId=%d,SubKey=%d)"
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubSyncDataRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
const int gci = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Synchronization FAILED (DATA SCAN) on "
"table data using (subId=%d,SubKey=%d). GCI = %d. "
" Error code: %d Error Message: %s",
subId,
subKey,
gci,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::GrepPS_SubRemoveRef:
{
const int subId = theData[2];
const int subKey = theData[3];
const int err = theData[4];
BaseString::snprintf(m_text, m_text_len,
"Grep::PSCoord: Failed to remove subscription "
"(subId=%d,SubKey=%d)."
" Error code: %d Error Message: %s",
subId,
subKey,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
case GrepEvent::Rep_Disconnect:
{
const int err = theData[4];
const int nodeId = theData[5];
BaseString::snprintf(m_text, m_text_len,
"Rep: Node %d."
" Error code: %d Error Message: %s",
nodeId,
err,
GrepError::getErrorDesc((GrepError::GE_Code)err));
break;
}
default:
BaseString::snprintf(m_text,
m_text_len,
"%sUnknown GrepSubscriptionAlert event: %d",
theNodeId,
theData[1]);
break;
}
break;
}
case EventReport::BackupStarted:
BaseString::snprintf(m_text,
m_text_len,
......
ndb/src/kernel/blocks/ndbcntr/NdbcntrMain.cpp
View file @ e77095bc
......@@ -1966,6 +1966,11 @@ Ndbcntr::execRESUME_REQ(Signal* signal){
//ResumeRef * const ref = (ResumeRef *)&signal->theData[0];
jamEntry();
signal->theData[0] = EventReport::SingleUser;
signal->theData[1] = 2;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
//Uint32 senderData = req->senderData;
//BlockReference senderRef = req->senderRef;
NodeState newState(NodeState::SL_STARTED);
......@@ -2004,12 +2009,11 @@ Ndbcntr::execSTOP_REQ(Signal* signal){
return;
}
if(c_stopRec.stopReq.senderRef != 0 && !singleuser){
jam();
if(c_stopRec.stopReq.senderRef != 0){
/**
* Requested a system shutdown
*/
if(StopReq::getSystemStop(req->requestInfo)){
if(!singleuser && StopReq::getSystemStop(req->requestInfo)){
jam();
sendSignalWithDelay(reference(), GSN_STOP_REQ, signal, 100,
StopReq::SignalLength);
......@@ -2031,22 +2035,27 @@ Ndbcntr::execSTOP_REQ(Signal* signal){
c_stopRec.stopReq = * req;
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) && !singleuser) {
if(!singleuser) {
if(StopReq::getSystemStop(c_stopRec.stopReq.requestInfo)) {
jam();
if(StopReq::getPerformRestart(c_stopRec.stopReq.requestInfo)){
((Configuration&)theConfiguration).stopOnError(false);
}
}
if(!singleuser) {
if(!c_stopRec.checkNodeFail(signal)){
jam();
return;
}
}
signal->theData[0] = EventReport::NDBStopStarted;
signal->theData[1] = StopReq::getSystemStop(c_stopRec.stopReq.requestInfo) ? 1 : 0;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
else
{
signal->theData[0] = EventReport::SingleUser;
signal->theData[1] = 0;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 2, JBB);
}
NodeState newState(NodeState::SL_STOPPING_1,
StopReq::getSystemStop(c_stopRec.stopReq.requestInfo));
......@@ -2129,9 +2138,11 @@ Ndbcntr::StopRecord::checkNodeFail(Signal* signal){
stopReq.senderRef = 0;
if (cntr.getNodeState().startLevel != NodeState::SL_SINGLEUSER)
{
NodeState newState(NodeState::SL_STARTED);
cntr.updateNodeState(signal, newState);
}
signal->theData[0] = EventReport::NDBStopAborted;
cntr.sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 1, JBB);
......@@ -2227,12 +2238,24 @@ void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
jamEntry();
if(c_stopRec.stopReq.singleuser) {
jam();
NodeState newState(NodeState::SL_SINGLEUSER);
newState.setSingleUser(true);
newState.setSingleUserApi(c_stopRec.stopReq.singleUserApi);
updateNodeState(signal, newState);
c_stopRec.stopInitiatedTime = NdbTick_CurrentMillisecond();
StopConf * const stopConf = (StopConf *)&signal->theData[0];
stopConf->senderData = c_stopRec.stopReq.senderData;
stopConf->nodeState = (Uint32) NodeState::SL_SINGLEUSER;
sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_CONF, signal, StopConf::SignalLength, JBB);
c_stopRec.stopReq.senderRef = 0; // the command is done
signal->theData[0] = EventReport::SingleUser;
signal->theData[1] = 1;
signal->theData[2] = c_stopRec.stopReq.singleUserApi;
sendSignal(CMVMI_REF, GSN_EVENT_REP, signal, 3, JBB);
}
else
{
......@@ -2250,7 +2273,13 @@ void Ndbcntr::execABORT_ALL_CONF(Signal* signal){
void Ndbcntr::execABORT_ALL_REF(Signal* signal){
jamEntry();
ndbrequire(false);
AbortAllRef *abortAllRef = (AbortAllRef *)&signal->theData[0];
AbortAllRef::ErrorCode errorCode = (AbortAllRef::ErrorCode) abortAllRef->errorCode;
StopRef * const stopRef = (StopRef *)&signal->theData[0];
stopRef->senderData = c_stopRec.stopReq.senderData;
stopRef->errorCode = StopRef::TransactionAbortFailed;
sendSignal(c_stopRec.stopReq.senderRef, GSN_STOP_REF, signal, StopRef::SignalLength, JBB);
}
void
......
ndb/src/kernel/blocks/qmgr/QmgrMain.cpp
View file @ e77095bc
......@@ -2012,6 +2012,8 @@ Qmgr::execAPI_VERSION_REQ(Signal * signal) {
else
conf->version = 0;
conf->nodeId = nodeId;
struct in_addr in= globalTransporterRegistry.get_connect_address(nodeId);
conf->inet_addr= in.s_addr;
sendSignal(senderRef,
GSN_API_VERSION_CONF,
......
ndb/src/mgmclient/CommandInterpreter.cpp
View file @ e77095bc
......@@ -1430,9 +1430,8 @@ CommandInterpreter::executeEnterSingleUser(char* parameters)
ndbout_c("Entering single user mode for node %d failed", nodeId);
printError();
} else {
ndbout_c("Entering single user mode");
ndbout_c("Access will be granted for API node %d only.", nodeId);
ndbout_c("Use ALL STATUS to see when single user mode has been entered.");
ndbout_c("Single user mode entered");
ndbout_c("Access is granted for API node %d only.", nodeId);
}
}
......@@ -1445,7 +1444,7 @@ CommandInterpreter::executeExitSingleUser(char* parameters)
printError();
} else {
ndbout_c("Exiting single user mode in progress.");
ndbout_c("Use ALL STATUS to see when single user mode has been exited.");
ndbout_c("Use ALL STATUS or SHOW to see when single user mode has been exited.");
}
}
......
ndb/src/mgmsrv/Config.cpp
View file @ e77095bc
......@@ -179,90 +179,3 @@ void Config::printConfigFile(NdbOut &out) const {
}
#endif
}
Uint32
Config::getGenerationNumber() const {
#if 0
Uint32 ret;
const Properties *prop = NULL;
get("SYSTEM", &prop);
if(prop != NULL)
if(prop->get("ConfigGenerationNumber", &ret))
return ret;
return 0;
#else
return 0;
#endif
}
int
Config::setGenerationNumber(Uint32 gen) {
#if 0
Properties *prop = NULL;
getCopy("SYSTEM", &prop);
if(prop != NULL) {
MGM_REQUIRE(prop->put("ConfigGenerationNumber", gen, true));
MGM_REQUIRE(put("SYSTEM", prop, true));
return 0;
}
return -1;
#else
return -1;
#endif
}
bool
Config::change(const BaseString &section,
const BaseString &param,
const BaseString &value) {
#if 0
const char *name;
Properties::Iterator it(this);
for(name = it.first(); name != NULL; name = it.next()) {
Properties *prop = NULL;
if(strcasecmp(section.c_str(), name) == 0) {
getCopy(name, &prop);
if(prop == NULL) /* doesn't exist */
return false;
if(value == "") {
prop->remove(param.c_str());
put(section.c_str(), prop, true);
} else {
PropertiesType t;
if(!prop->getTypeOf(param.c_str(), &t)) /* doesn't exist */
return false;
switch(t) {
case PropertiesType_Uint32:
long val;
char *ep;
errno = 0;
val = strtol(value.c_str(), &ep, 0);
if(value.length() == 0 || *ep != '\0') /* not a number */
return false;
if(errno == ERANGE)
return false;
prop->put(param.c_str(), (unsigned int)val, true);
put(section.c_str(), prop, true);
break;
case PropertiesType_char:
prop->put(param.c_str(), value.c_str(), true);
put(section.c_str(), prop, true);
break;
default:
return false;
}
}
break;
}
}
return true;
#else
return false;
#endif
}
ndb/src/mgmsrv/Config.hpp
View file @ e77095bc
......@@ -60,16 +60,6 @@ public:
printConfigFile(ndb);
}
Uint32 getGenerationNumber() const;
int setGenerationNumber(Uint32);
/** Change configuration
*/
bool change(const BaseString &section,
const BaseString &param,
const BaseString &value);
/**
* Info
*/
......
ndb/src/mgmsrv/MgmtSrvr.cpp
View file @ e77095bc
......@@ -67,6 +67,16 @@
#define DEBUG(x)
#endif
#define INIT_SIGNAL_SENDER(ss,nodeId) \
SignalSender ss(theFacade); \
ss.lock(); /* lock will be released on exit */ \
{\
int result = okToSendTo(nodeId, true);\
if (result != 0) {\
return result;\
}\
}
extern int global_flag_send_heartbeat_now;
extern int g_no_nodeid_checks;
extern my_bool opt_core;
......@@ -90,55 +100,6 @@ MgmtSrvr::logLevelThread_C(void* m)
return 0;
}
void *
MgmtSrvr::signalRecvThread_C(void *m)
{
MgmtSrvr *mgm = (MgmtSrvr*)m;
mgm->signalRecvThreadRun();
return 0;
}
class SigMatch
{
public:
int gsn;
void (MgmtSrvr::* function)(NdbApiSignal *signal);
SigMatch() { gsn = 0; function = NULL; };
SigMatch(int _gsn,
void (MgmtSrvr::* _function)(NdbApiSignal *signal)) {
gsn = _gsn;
function = _function;
};
bool check(NdbApiSignal *signal) {
if(signal->readSignalNumber() == gsn)
return true;
return false;
};
};
void
MgmtSrvr::signalRecvThreadRun()
{
Vector<SigMatch> siglist;
siglist.push_back(SigMatch(GSN_MGM_LOCK_CONFIG_REQ,
&MgmtSrvr::handle_MGM_LOCK_CONFIG_REQ));
siglist.push_back(SigMatch(GSN_MGM_UNLOCK_CONFIG_REQ,
&MgmtSrvr::handle_MGM_UNLOCK_CONFIG_REQ));
while(!_isStopThread) {
SigMatch *handler = NULL;
NdbApiSignal *signal = NULL;
if(m_signalRecvQueue.waitFor(siglist, &handler, &signal, DEFAULT_TIMEOUT)) {
if(handler->function != 0)
(this->*handler->function)(signal);
}
}
}
extern EventLogger g_eventLogger;
static NdbOut&
......@@ -427,7 +388,6 @@ MgmtSrvr::MgmtSrvr(SocketServer *socket_server,
_isStopThread = false;
_logLevelThread = NULL;
_logLevelThreadSleep = 500;
m_signalRecvThread = NULL;
theFacade = 0;
......@@ -636,12 +596,6 @@ MgmtSrvr::start(BaseString &error_string)
"MgmtSrvr_Loglevel",
NDB_THREAD_PRIO_LOW);
m_signalRecvThread = NdbThread_Create(signalRecvThread_C,
(void **)this,
32768,
"MgmtSrvr_Service",
NDB_THREAD_PRIO_LOW);
DBUG_RETURN(true);
}
......@@ -650,10 +604,6 @@ MgmtSrvr::start(BaseString &error_string)
//****************************************************************************
MgmtSrvr::~MgmtSrvr()
{
while (theSignalIdleList != NULL) {
freeSignal();
}
if(theFacade != 0){
theFacade->stop_instance();
delete theFacade;
......@@ -681,10 +631,6 @@ MgmtSrvr::~MgmtSrvr()
NdbThread_Destroy(&_logLevelThread);
}
if (m_signalRecvThread != NULL) {
NdbThread_WaitFor(m_signalRecvThread, &res);
NdbThread_Destroy(&m_signalRecvThread);
}
if (m_config_retriever)
delete m_config_retriever;
}
......@@ -692,21 +638,21 @@ MgmtSrvr::~MgmtSrvr()
//****************************************************************************
//****************************************************************************
int MgmtSrvr::okToSendTo(NodeId processId, bool unCond)
int MgmtSrvr::okToSendTo(NodeId nodeId, bool unCond)
{
if(processId == 0)
if(nodeId == 0)
return 0;
if (getNodeType(processId) != NDB_MGM_NODE_TYPE_NDB)
if (getNodeType(nodeId) != NDB_MGM_NODE_TYPE_NDB)
return WRONG_PROCESS_TYPE;
// Check if we have contact with it
if(unCond){
if(theFacade->theClusterMgr->getNodeInfo(processId).connected)
if(theFacade->theClusterMgr->getNodeInfo(nodeId).connected)
return 0;
return NO_CONTACT_WITH_PROCESS;
}
if (theFacade->get_node_alive(processId) == 0) {
if (theFacade->get_node_alive(nodeId) == 0) {
return NO_CONTACT_WITH_PROCESS;
} else {
return 0;
......@@ -727,698 +673,499 @@ void report_unknown_signal(SimpleSignal *signal)
****************************************************************************/
int
MgmtSrvr::start(int processId)
MgmtSrvr::start(int nodeId)
{
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
StartOrd* const startOrd = CAST_PTR(StartOrd, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, CMVMI, GSN_START_ORD, StartOrd::SignalLength);
INIT_SIGNAL_SENDER(ss,nodeId);
SimpleSignal ssig;
StartOrd* const startOrd = CAST_PTR(StartOrd, ssig.getDataPtrSend());
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_START_ORD, StartOrd::SignalLength);
startOrd->restartInfo = 0;
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
/**
* Restart one database node
*/
/*****************************************************************************
* Version handling
*****************************************************************************/
int
MgmtSrvr::restartNode(int processId, bool nostart,
bool initalStart, bool abort,
StopCallback callback, void * anyData)
MgmtSrvr::versionNode(int nodeId, Uint32 &version, const char **address)
{
int result;
if(m_stopRec.singleUserMode)
return 5060;
if(m_stopRec.inUse){
return 5029;
version= 0;
if (getOwnNodeId() == nodeId)
{
/**
* If we're inquiring about our own node id,
* We know what version we are (version implies connected for mgm)
* but would like to find out from elsewhere what address they're using
* to connect to us. This means that secondary mgm servers
* can list ip addresses for mgm servers.
*
* If we don't get an address (i.e. no db nodes),
* we get the address from the configuration.
*/
sendVersionReq(nodeId, version, address);
version= NDB_VERSION;
if(!*address)
{
ndb_mgm_configuration_iterator
iter(*_config->m_configValues, CFG_SECTION_NODE);
unsigned tmp= 0;
for(iter.first();iter.valid();iter.next())
{
if(iter.get(CFG_NODE_ID, &tmp)) require(false);
if((unsigned)nodeId!=tmp)
continue;
if(iter.get(CFG_NODE_HOST, address)) require(false);
break;
}
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
StopReq* const stopReq = CAST_PTR(StopReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ, StopReq::SignalLength);
stopReq->requestInfo = 0;
StopReq::setSystemStop(stopReq->requestInfo, false);
StopReq::setPerformRestart(stopReq->requestInfo, true);
StopReq::setNoStart(stopReq->requestInfo, nostart);
StopReq::setInitialStart(stopReq->requestInfo, initalStart);
StopReq::setStopAbort(stopReq->requestInfo, abort);
stopReq->singleuser = 0;
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = _ownReference;
m_stopRec.singleUserMode = false;
m_stopRec.sentCount = 1;
m_stopRec.reply = 0;
m_stopRec.nodeId = processId;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
if(callback == NULL){
Uint32 timeOut = 0;
timeOut += stopReq->apiTimeout;
timeOut += stopReq->transactionTimeout;
timeOut += stopReq->readOperationTimeout;
timeOut += stopReq->operationTimeout;
timeOut *= 3;
result = sendRecSignal(processId, WAIT_STOP, signal, true, timeOut);
} else {
result = sendSignal(processId, NO_WAIT, signal, true);
else if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_NDB)
{
ClusterMgr::Node node= theFacade->theClusterMgr->getNodeInfo(nodeId);
if(node.connected)
version= node.m_info.m_version;
*address= get_connect_address(nodeId);
}
if (result == -1 && theWaitState != WAIT_NODEFAILURE) {
m_stopRec.inUse = false;
return SEND_OR_RECEIVE_FAILED;
else if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_API ||
getNodeType(nodeId) == NDB_MGM_NODE_TYPE_MGM)
{
return sendVersionReq(nodeId, version, address);
}
if(callback == 0){
m_stopRec.inUse = false;
return m_stopRec.reply;
} else {
return 0;
}
}
/**
* Restart all database nodes
*/
int
MgmtSrvr::restart(bool nostart, bool initalStart, bool abort,
int * stopCount, StopCallback callback, void * anyData)
MgmtSrvr::sendVersionReq(int v_nodeId, Uint32 &version, const char **address)
{
if(m_stopRec.singleUserMode)
return 5060;
if(m_stopRec.inUse){
return 5029;
}
SignalSender ss(theFacade);
ss.lock();
m_stopRec.singleUserMode = false;
m_stopRec.sentCount = 0;
m_stopRec.reply = 0;
m_stopRec.nodeId = 0;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
SimpleSignal ssig;
ApiVersionReq* req = CAST_PTR(ApiVersionReq, ssig.getDataPtrSend());
req->senderRef = ss.getOwnRef();
req->nodeId = v_nodeId;
ssig.set(ss, TestOrd::TraceAPI, QMGR, GSN_API_VERSION_REQ,
ApiVersionReq::SignalLength);
/**
* Restart all database nodes into idle ("no-started") state
*/
Uint32 timeOut = 0;
NodeId nodeId = 0;
NodeBitmask nodes;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
if(okToSendTo(nodeId, true) == 0){
int do_send = 1;
NodeId nodeId;
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
while (1)
{
if (do_send)
{
bool next;
nodeId = 0;
StopReq* const stopReq = CAST_PTR(StopReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ,
StopReq::SignalLength);
while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
okToSendTo(nodeId, true) != 0);
stopReq->requestInfo = 0;
stopReq->singleuser = 0;
StopReq::setSystemStop(stopReq->requestInfo, true);
StopReq::setPerformRestart(stopReq->requestInfo, true);
if (callback == 0) {
// Start node in idle ("no-started") state
StopReq::setNoStart(stopReq->requestInfo, 1);
} else {
StopReq::setNoStart(stopReq->requestInfo, nostart);
const ClusterMgr::Node &node=
theFacade->theClusterMgr->getNodeInfo(nodeId);
if(next && node.m_state.startLevel != NodeState::SL_STARTED)
{
NodeId tmp=nodeId;
while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
okToSendTo(nodeId, true) != 0);
if(!next)
nodeId= tmp;
}
StopReq::setInitialStart(stopReq->requestInfo, initalStart);
StopReq::setStopAbort(stopReq->requestInfo, abort);
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = _ownReference;
timeOut += stopReq->apiTimeout;
timeOut += stopReq->transactionTimeout;
timeOut += stopReq->readOperationTimeout;
timeOut += stopReq->operationTimeout;
timeOut *= 3;
m_stopRec.sentCount++;
int res;
if(callback == 0){
res = sendSignal(nodeId, WAIT_STOP, signal, true);
} else {
res = sendSignal(nodeId, NO_WAIT, signal, true);
}
if(!next) return NO_CONTACT_WITH_DB_NODES;
if(res != -1){
nodes.set(nodeId);
}
}
if (ss.sendSignal(nodeId, &ssig) != SEND_OK) {
return SEND_OR_RECEIVE_FAILED;
}
if(stopCount != 0){
* stopCount = m_stopRec.sentCount;
do_send = 0;
}
if(m_stopRec.sentCount == 0){
m_stopRec.inUse = false;
return 0;
}
SimpleSignal *signal = ss.waitFor();
if(callback != 0){
int gsn = signal->readSignalNumber();
switch (gsn) {
case GSN_API_VERSION_CONF: {
const ApiVersionConf * const conf =
CAST_CONSTPTR(ApiVersionConf, signal->getDataPtr());
assert(conf->nodeId == v_nodeId);
version = conf->version;
struct in_addr in;
in.s_addr= conf->inet_addr;
*address= inet_ntoa(in);
return 0;
}
theFacade->lock_mutex();
int waitTime = timeOut/m_stopRec.sentCount;
if (receiveOptimisedResponse(waitTime) != 0) {
m_stopRec.inUse = false;
return -1;
}
/**
* Here all nodes were correctly stopped,
* so we wait for all nodes to be contactable
*/
nodeId = 0;
NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB) && nodes.get(nodeId)) {
enum ndb_mgm_node_status s;
s = NDB_MGM_NODE_STATUS_NO_CONTACT;
while (s != NDB_MGM_NODE_STATUS_NOT_STARTED && waitTime > 0) {
Uint32 startPhase = 0, version = 0, dynamicId = 0, nodeGroup = 0;
Uint32 connectCount = 0;
bool system;
status(nodeId, &s, &version, &startPhase,
&system, &dynamicId, &nodeGroup, &connectCount);
NdbSleep_MilliSleep(100);
waitTime = (maxTime - NdbTick_CurrentMillisecond());
}
case GSN_NF_COMPLETEREP:{
const NFCompleteRep * const rep =
CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
if (rep->failedNodeId == nodeId)
do_send = 1; // retry with other node
continue;
}
if(nostart){
m_stopRec.inUse = false;
return 0;
case GSN_NODE_FAILREP:{
const NodeFailRep * const rep =
CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
if (NodeBitmask::get(rep->theNodes,nodeId))
do_send = 1; // retry with other node
continue;
}
/**
* Now we start all database nodes (i.e. we make them non-idle)
* We ignore the result we get from the start command.
*/
nodeId = 0;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB) && nodes.get(nodeId)) {
int result;
result = start(nodeId);
DEBUG("Starting node " << nodeId << " with result " << result);
/**
* Errors from this call are deliberately ignored.
* Maybe the user only wanted to restart a subset of the nodes.
* It is also easy for the user to check which nodes have
* started and which nodes have not.
*
* if (result != 0) {
* m_stopRec.inUse = false;
* return result;
* }
*/
default:
report_unknown_signal(signal);
return SEND_OR_RECEIVE_FAILED;
}
break;
} // while(1)
m_stopRec.inUse = false;
return 0;
}
/*****************************************************************************
* Version handling
*****************************************************************************/
/*
* Common method for handeling all STOP_REQ signalling that
* is used by Stopping, Restarting and Single user commands
*/
int
MgmtSrvr::versionNode(int processId, bool abort,
VersionCallback callback, void * anyData)
int MgmtSrvr::sendSTOP_REQ(NodeId nodeId,
NodeBitmask &stoppedNodes,
Uint32 singleUserNodeId,
bool abort,
bool stop,
bool restart,
bool nostart,
bool initialStart)
{
int version;
stoppedNodes.clear();
if(m_versionRec.inUse)
return OPERATION_IN_PROGRESS;
SignalSender ss(theFacade);
ss.lock(); // lock will be released on exit
m_versionRec.callback = callback;
m_versionRec.inUse = true ;
SimpleSignal ssig;
StopReq* const stopReq = CAST_PTR(StopReq, ssig.getDataPtrSend());
ssig.set(ss, TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ, StopReq::SignalLength);
if (getOwnNodeId() == processId)
stopReq->requestInfo = 0;
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = ss.getOwnRef();
if (singleUserNodeId)
{
version= NDB_VERSION;
stopReq->singleuser = 1;
stopReq->singleUserApi = singleUserNodeId;
StopReq::setSystemStop(stopReq->requestInfo, false);
StopReq::setPerformRestart(stopReq->requestInfo, false);
StopReq::setStopAbort(stopReq->requestInfo, false);
}
else if (getNodeType(processId) == NDB_MGM_NODE_TYPE_NDB)
{
ClusterMgr::Node node= theFacade->theClusterMgr->getNodeInfo(processId);
if(node.connected)
version= node.m_info.m_version;
else
version= 0;
}
else if (getNodeType(processId) == NDB_MGM_NODE_TYPE_API ||
getNodeType(processId) == NDB_MGM_NODE_TYPE_MGM)
{
return sendVersionReq(processId);
stopReq->singleuser = 0;
StopReq::setSystemStop(stopReq->requestInfo, stop);
StopReq::setPerformRestart(stopReq->requestInfo, restart);
StopReq::setStopAbort(stopReq->requestInfo, abort);
StopReq::setNoStart(stopReq->requestInfo, nostart);
StopReq::setInitialStart(stopReq->requestInfo, initialStart);
}
else
version= 0;
if(m_versionRec.callback != 0)
m_versionRec.callback(processId, version, this,0);
m_versionRec.inUse = false ;
m_versionRec.version[processId]= version;
return 0;
}
int
MgmtSrvr::sendVersionReq(int processId)
{
Uint32 ndbnode=0;
int result;
for(Uint32 i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_NDB) {
if(okToSendTo(i, true) == 0)
// send the signals
NodeBitmask nodes;
if (nodeId)
{
ndbnode = i;
break;
}
}
}
if (ndbnode == 0) {
m_versionRec.inUse = false;
if(m_versionRec.callback != 0)
m_versionRec.callback(processId, 0, this,0);
return NO_CONTACT_WITH_CLUSTER;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
m_versionRec.inUse = false;
if(m_versionRec.callback != 0)
m_versionRec.callback(processId, 0, this,0);
return COULD_NOT_ALLOCATE_MEMORY;
{
int r;
if((r = okToSendTo(nodeId, true)) != 0)
return r;
}
ApiVersionReq* req = CAST_PTR(ApiVersionReq, signal->getDataPtrSend());
req->senderRef = _ownReference;
req->nodeId = processId;
signal->set(TestOrd::TraceAPI, QMGR, GSN_API_VERSION_REQ,
ApiVersionReq::SignalLength);
// if(m_versionRec.callback == 0){
Uint32 timeOut = 0;
timeOut = 10000;
result = sendRecSignal(ndbnode, WAIT_VERSION, signal, true, timeOut);
//} else {
//result = sendSignal(processId, NO_WAIT, signal, true);
// }
if (result == -1) {
m_versionRec.inUse = false;
if(m_versionRec.callback != 0)
m_versionRec.callback(processId, 0, this,0);
m_versionRec.version[processId] = 0;
{
if (ss.sendSignal(nodeId, &ssig) != SEND_OK)
return SEND_OR_RECEIVE_FAILED;
}
m_versionRec.inUse = false;
return 0;
}
int
MgmtSrvr::version(int * stopCount, bool abort,
VersionCallback callback, void * anyData)
{
ClusterMgr::Node node;
int version;
if(m_versionRec.inUse)
return 1;
m_versionRec.callback = callback;
m_versionRec.inUse = true ;
Uint32 i;
for(i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_MGM) {
m_versionRec.callback(i, NDB_VERSION, this,0);
}
nodes.set(nodeId);
}
for(i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_NDB) {
node = theFacade->theClusterMgr->getNodeInfo(i);
version = node.m_info.m_version;
if(theFacade->theClusterMgr->getNodeInfo(i).connected)
m_versionRec.callback(i, version, this,0);
else
m_versionRec.callback(i, 0, this,0);
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB))
{
if(okToSendTo(nodeId, true) == 0)
{
SendStatus result = ss.sendSignal(nodeId, &ssig);
if (result == SEND_OK)
nodes.set(nodeId);
}
}
for(i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_API) {
return sendVersionReq(i);
// now wait for the replies
int error = 0;
while (!nodes.isclear())
{
SimpleSignal *signal = ss.waitFor();
int gsn = signal->readSignalNumber();
switch (gsn) {
case GSN_STOP_REF:{
const StopRef * const ref = CAST_CONSTPTR(StopRef, signal->getDataPtr());
const NodeId nodeId = refToNode(signal->header.theSendersBlockRef);
#ifdef VM_TRACE
ndbout_c("Node %d refused stop", nodeId);
#endif
assert(nodes.get(nodeId));
nodes.clear(nodeId);
error = translateStopRef(ref->errorCode);
break;
}
case GSN_STOP_CONF:{
const StopConf * const ref = CAST_CONSTPTR(StopConf, signal->getDataPtr());
const NodeId nodeId = refToNode(signal->header.theSendersBlockRef);
#ifdef VM_TRACE
ndbout_c("Node %d single user mode", nodeId);
#endif
assert(nodes.get(nodeId));
assert(singleUserNodeId != 0);
nodes.clear(nodeId);
stoppedNodes.set(nodeId);
break;
}
return 0;
}
int
MgmtSrvr::stopNode(int processId, bool abort, StopCallback callback,
void * anyData)
{
if(m_stopRec.singleUserMode)
return 5060;
if(m_stopRec.inUse)
return 5029;
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
case GSN_NF_COMPLETEREP:{
const NFCompleteRep * const rep =
CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
#ifdef VM_TRACE
ndbout_c("Node %d fail completed", rep->failedNodeId);
#endif
break;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
case GSN_NODE_FAILREP:{
const NodeFailRep * const rep =
CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
NodeBitmask failedNodes;
failedNodes.assign(NodeBitmask::Size, rep->theNodes);
#ifdef VM_TRACE
{
ndbout << "Failed nodes:";
for (unsigned i = 0; i < 32*NodeBitmask::Size; i++)
if(failedNodes.get(i))
ndbout << " " << i;
ndbout << endl;
}
StopReq* const stopReq = CAST_PTR(StopReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ, StopReq::SignalLength);
stopReq->requestInfo = 0;
stopReq->singleuser = 0;
StopReq::setPerformRestart(stopReq->requestInfo, false);
StopReq::setSystemStop(stopReq->requestInfo, false);
StopReq::setStopAbort(stopReq->requestInfo, abort);
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = _ownReference;
m_stopRec.sentCount = 1;
m_stopRec.reply = 0;
m_stopRec.nodeId = processId;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
if(callback == NULL){
Uint32 timeOut = 0;
timeOut += stopReq->apiTimeout;
timeOut += stopReq->transactionTimeout;
timeOut += stopReq->readOperationTimeout;
timeOut += stopReq->operationTimeout;
timeOut *= 3;
result = sendRecSignal(processId, WAIT_STOP, signal, true, timeOut);
} else {
result = sendSignal(processId, NO_WAIT, signal, true);
#endif
failedNodes.bitAND(nodes);
if (!failedNodes.isclear())
{
nodes.bitANDC(failedNodes); // clear the failed nodes
if (singleUserNodeId == 0)
stoppedNodes.bitOR(failedNodes);
}
if (result == -1) {
m_stopRec.inUse = false;
break;
}
default:
report_unknown_signal(signal);
#ifdef VM_TRACE
ndbout_c("Unknown signal %d", gsn);
#endif
return SEND_OR_RECEIVE_FAILED;
}
if(callback == 0){
m_stopRec.inUse = false;
return m_stopRec.reply;
} else {
return 0;
}
return error;
}
int
MgmtSrvr::stop(int * stopCount, bool abort, StopCallback callback,
void * anyData)
{
if(m_stopRec.singleUserMode)
return 5060;
if(m_stopRec.inUse){
return 5029;
}
m_stopRec.singleUserMode = false;
m_stopRec.sentCount = 0;
m_stopRec.reply = 0;
m_stopRec.nodeId = 0;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
NodeId nodeId = 0;
Uint32 timeOut = 0;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
if(okToSendTo(nodeId, true) == 0){
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
StopReq* const stopReq = CAST_PTR(StopReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ,
StopReq::SignalLength);
stopReq->requestInfo = 0;
stopReq->singleuser = 0;
StopReq::setSystemStop(stopReq->requestInfo, true);
StopReq::setPerformRestart(stopReq->requestInfo, false);
StopReq::setStopAbort(stopReq->requestInfo, abort);
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = _ownReference;
timeOut += stopReq->apiTimeout;
timeOut += stopReq->transactionTimeout;
timeOut += stopReq->readOperationTimeout;
timeOut += stopReq->operationTimeout;
timeOut *= 3;
m_stopRec.sentCount++;
if(callback == 0)
sendSignal(nodeId, WAIT_STOP, signal, true);
else
sendSignal(nodeId, NO_WAIT, signal, true);
}
}
/*
* Stop one node
*/
if(stopCount != 0)
* stopCount = m_stopRec.sentCount;
int MgmtSrvr::stopNode(int nodeId, bool abort)
{
NodeBitmask nodes;
return sendSTOP_REQ(nodeId,
nodes,
0,
abort,
false,
false,
false,
false);
}
if(m_stopRec.sentCount > 0){
if(callback == 0){
theFacade->lock_mutex();
receiveOptimisedResponse(timeOut / m_stopRec.sentCount);
} else {
return 0;
}
}
/*
* Perform system shutdown
*/
m_stopRec.inUse = false;
return m_stopRec.reply;
int MgmtSrvr::stop(int * stopCount, bool abort)
{
NodeBitmask nodes;
int ret = sendSTOP_REQ(0,
nodes,
0,
abort,
true,
false,
false,
false);
if (stopCount)
*stopCount = nodes.count();
return ret;
}
/*****************************************************************************
* Single user mode
****************************************************************************/
/*
* Enter single user mode on all live nodes
*/
int
MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId,
EnterSingleCallback callback, void * anyData)
int MgmtSrvr::enterSingleUser(int * stopCount, Uint32 singleUserNodeId)
{
if(m_stopRec.singleUserMode) {
return 5060;
}
if (getNodeType(singleUserNodeId) != NDB_MGM_NODE_TYPE_API) {
if (getNodeType(singleUserNodeId) != NDB_MGM_NODE_TYPE_API)
return 5062;
}
NodeId nodeId = 0;
ClusterMgr::Node node;
for(Uint32 i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_NDB) {
node = theFacade->theClusterMgr->getNodeInfo(i);
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB))
{
node = theFacade->theClusterMgr->getNodeInfo(nodeId);
if((node.m_state.startLevel != NodeState::SL_STARTED) &&
(node.m_state.startLevel != NodeState::SL_NOTHING)) {
(node.m_state.startLevel != NodeState::SL_NOTHING))
return 5063;
}
}
}
NodeBitmask nodes;
int ret = sendSTOP_REQ(0,
nodes,
singleUserNodeId,
false,
false,
false,
false,
false);
if (stopCount)
*stopCount = nodes.count();
return ret;
}
/*
* Perform node restart
*/
int MgmtSrvr::restartNode(int nodeId, bool nostart, bool initialStart,
bool abort)
{
NodeBitmask nodes;
return sendSTOP_REQ(nodeId,
nodes,
0,
abort,
false,
true,
nostart,
initialStart);
}
if(m_stopRec.inUse){
return 5029;
}
/*
* Perform system restart
*/
if(singleUserNodeId == 0)
return 1;
m_stopRec.singleUserMode = true;
m_stopRec.sentCount = 0;
m_stopRec.reply = 0;
m_stopRec.nodeId = 0;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
int MgmtSrvr::restart(bool nostart, bool initialStart,
bool abort, int * stopCount )
{
NodeBitmask nodes;
int ret = sendSTOP_REQ(0,
nodes,
0,
abort,
true,
true,
true,
initialStart);
NodeId nodeId = 0;
Uint32 timeOut = 0;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
if(okToSendTo(nodeId, true) == 0){
if (ret)
return ret;
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
if (stopCount)
*stopCount = nodes.count();
StopReq* const stopReq = CAST_PTR(StopReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_STOP_REQ,
StopReq::SignalLength);
#ifdef VM_TRACE
ndbout_c("Stopped %d nodes", nodes.count());
#endif
/**
* Here all nodes were correctly stopped,
* so we wait for all nodes to be contactable
*/
int waitTime = 12000;
NodeId nodeId = 0;
NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
stopReq->requestInfo = 0;
stopReq->singleuser = 1;
stopReq->singleUserApi = singleUserNodeId;
StopReq::setSystemStop(stopReq->requestInfo, false);
StopReq::setPerformRestart(stopReq->requestInfo, false);
StopReq::setStopAbort(stopReq->requestInfo, false);
ndbout_c(" %d", nodes.get(1));
ndbout_c(" %d", nodes.get(2));
stopReq->apiTimeout = 5000;
stopReq->transactionTimeout = 1000;
stopReq->readOperationTimeout = 1000;
stopReq->operationTimeout = 1000;
stopReq->senderData = 12;
stopReq->senderRef = _ownReference;
timeOut += stopReq->apiTimeout;
timeOut += stopReq->transactionTimeout;
timeOut += stopReq->readOperationTimeout;
timeOut += stopReq->operationTimeout;
timeOut *= 3;
m_stopRec.sentCount++;
if(callback == 0)
sendSignal(nodeId, WAIT_STOP, signal, true);
else
sendSignal(nodeId, NO_WAIT, signal, true);
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) {
if (!nodes.get(nodeId))
continue;
enum ndb_mgm_node_status s;
s = NDB_MGM_NODE_STATUS_NO_CONTACT;
#ifdef VM_TRACE
ndbout_c("Waiting for %d not started", nodeId);
#endif
while (s != NDB_MGM_NODE_STATUS_NOT_STARTED && waitTime > 0) {
Uint32 startPhase = 0, version = 0, dynamicId = 0, nodeGroup = 0;
Uint32 connectCount = 0;
bool system;
const char *address;
status(nodeId, &s, &version, &startPhase,
&system, &dynamicId, &nodeGroup, &connectCount, &address);
NdbSleep_MilliSleep(100);
waitTime = (maxTime - NdbTick_CurrentMillisecond());
}
}
if(stopCount != 0)
* stopCount = m_stopRec.sentCount;
if(callback == 0){
m_stopRec.inUse = false;
return 0;
// return m_stopRec.reply;
} else {
if(nostart)
return 0;
/**
* Now we start all database nodes (i.e. we make them non-idle)
* We ignore the result we get from the start command.
*/
nodeId = 0;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) {
if (!nodes.get(nodeId))
continue;
int result;
result = start(nodeId);
DEBUG("Starting node " << nodeId << " with result " << result);
/**
* Errors from this call are deliberately ignored.
* Maybe the user only wanted to restart a subset of the nodes.
* It is also easy for the user to check which nodes have
* started and which nodes have not.
*/
}
m_stopRec.inUse = false;
return m_stopRec.reply;
return 0;
}
int
MgmtSrvr::exitSingleUser(int * stopCount, bool abort,
ExitSingleCallback callback, void * anyData)
MgmtSrvr::exitSingleUser(int * stopCount, bool abort)
{
m_stopRec.sentCount = 0;
m_stopRec.reply = 0;
m_stopRec.nodeId = 0;
m_stopRec.anyData = anyData;
m_stopRec.callback = callback;
m_stopRec.inUse = true;
NodeId nodeId = 0;
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
if(okToSendTo(nodeId, true) == 0){
int count = 0;
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
SignalSender ss(theFacade);
ss.lock(); // lock will be released on exit
SimpleSignal ssig;
ResumeReq* const resumeReq =
CAST_PTR(ResumeReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, NDBCNTR, GSN_RESUME_REQ,
StopReq::SignalLength);
CAST_PTR(ResumeReq, ssig.getDataPtrSend());
ssig.set(ss,TestOrd::TraceAPI, NDBCNTR, GSN_RESUME_REQ,
ResumeReq::SignalLength);
resumeReq->senderData = 12;
resumeReq->senderRef = _ownReference;
resumeReq->senderRef = ss.getOwnRef();
m_stopRec.sentCount++;
if(callback == 0)
sendSignal(nodeId, WAIT_STOP, signal, true);
else
sendSignal(nodeId, NO_WAIT, signal, true);
while(getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)){
if(okToSendTo(nodeId, true) == 0){
SendStatus result = ss.sendSignal(nodeId, &ssig);
if (result == SEND_OK)
count++;
}
}
m_stopRec.singleUserMode = false;
if(stopCount != 0)
* stopCount = m_stopRec.sentCount;
* stopCount = count;
if(callback == 0){
m_stopRec.inUse = false;
return m_stopRec.reply;
} else {
return 0;
}
m_stopRec.inUse = false;
return m_stopRec.reply;
}
/*****************************************************************************
* Status
****************************************************************************/
......@@ -1426,32 +1173,32 @@ MgmtSrvr::exitSingleUser(int * stopCount, bool abort,
#include <ClusterMgr.hpp>
int
MgmtSrvr::status(int processId,
MgmtSrvr::status(int nodeId,
ndb_mgm_node_status * _status,
Uint32 * version,
Uint32 * _phase,
bool * _system,
Uint32 * dynamic,
Uint32 * nodegroup,
Uint32 * connectCount)
Uint32 * connectCount,
const char **address)
{
if (getNodeType(processId) == NDB_MGM_NODE_TYPE_API ||
getNodeType(processId) == NDB_MGM_NODE_TYPE_MGM) {
if(versionNode(processId, false,0,0) ==0)
* version = m_versionRec.version[processId];
else
* version = 0;
if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_API ||
getNodeType(nodeId) == NDB_MGM_NODE_TYPE_MGM) {
versionNode(nodeId, *version, address);
} else {
*address= get_connect_address(nodeId);
}
const ClusterMgr::Node node =
theFacade->theClusterMgr->getNodeInfo(processId);
theFacade->theClusterMgr->getNodeInfo(nodeId);
if(!node.connected){
* _status = NDB_MGM_NODE_STATUS_NO_CONTACT;
return 0;
}
if (getNodeType(processId) == NDB_MGM_NODE_TYPE_NDB) {
if (getNodeType(nodeId) == NDB_MGM_NODE_TYPE_NDB) {
* version = node.m_info.m_version;
}
......@@ -1514,67 +1261,81 @@ MgmtSrvr::status(int processId,
}
int
MgmtSrvr::setEventReportingLevelImpl(int processId,
MgmtSrvr::setEventReportingLevelImpl(int nodeId,
const EventSubscribeReq& ll)
{
INIT_SIGNAL_SENDER(ss,nodeId);
int result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal signal(_ownReference);
SimpleSignal ssig;
EventSubscribeReq * dst =
CAST_PTR(EventSubscribeReq, signal.getDataPtrSend());
* dst = ll;
signal.set(TestOrd::TraceAPI, CMVMI, GSN_EVENT_SUBSCRIBE_REQ,
CAST_PTR(EventSubscribeReq, ssig.getDataPtrSend());
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_EVENT_SUBSCRIBE_REQ,
EventSubscribeReq::SignalLength);
*dst = ll;
send(ss,ssig,nodeId,NODE_TYPE_DB);
theFacade->lock_mutex();
send(&signal, processId, NODE_TYPE_DB);
theFacade->unlock_mutex();
#if 0
while (1)
{
SimpleSignal *signal = ss.waitFor();
int gsn = signal->readSignalNumber();
switch (gsn) {
case GSN_EVENT_SUBSCRIBE_CONF:{
break;
}
case GSN_EVENT_SUBSCRIBE_REF:{
return SEND_OR_RECEIVE_FAILED;
}
case GSN_NF_COMPLETEREP:{
const NFCompleteRep * const rep =
CAST_CONSTPTR(NFCompleteRep, signal->getDataPtr());
if (rep->failedNodeId == nodeId)
return SEND_OR_RECEIVE_FAILED;
break;
}
case GSN_NODE_FAILREP:{
const NodeFailRep * const rep =
CAST_CONSTPTR(NodeFailRep, signal->getDataPtr());
if (NodeBitmask::get(rep->theNodes,nodeId))
return SEND_OR_RECEIVE_FAILED;
break;
}
default:
report_unknown_signal(signal);
return SEND_OR_RECEIVE_FAILED;
}
}
#endif
return 0;
}
//****************************************************************************
//****************************************************************************
int
MgmtSrvr::setNodeLogLevelImpl(int processId, const SetLogLevelOrd & ll)
MgmtSrvr::setNodeLogLevelImpl(int nodeId, const SetLogLevelOrd & ll)
{
int result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
INIT_SIGNAL_SENDER(ss,nodeId);
NdbApiSignal signal(_ownReference);
SetLogLevelOrd * dst = CAST_PTR(SetLogLevelOrd, signal.getDataPtrSend());
* dst = ll;
signal.set(TestOrd::TraceAPI, CMVMI, GSN_SET_LOGLEVELORD,
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_SET_LOGLEVELORD,
SetLogLevelOrd::SignalLength);
SetLogLevelOrd* const dst = CAST_PTR(SetLogLevelOrd, ssig.getDataPtrSend());
*dst = ll;
theFacade->lock_mutex();
theFacade->sendSignalUnCond(&signal, processId);
theFacade->unlock_mutex();
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
int
MgmtSrvr::send(NdbApiSignal* signal, Uint32 node, Uint32 node_type){
MgmtSrvr::send(SignalSender &ss, SimpleSignal &ssig, Uint32 node, Uint32 node_type){
Uint32 max = (node == 0) ? MAX_NODES : node + 1;
for(; node < max; node++){
while(nodeTypes[node] != (int)node_type && node < max) node++;
if(nodeTypes[node] != (int)node_type)
break;
theFacade->sendSignalUnCond(signal, node);
ss.sendSignal(node, &ssig);
}
return 0;
}
......@@ -1583,34 +1344,21 @@ MgmtSrvr::send(NdbApiSignal* signal, Uint32 node, Uint32 node_type){
//****************************************************************************
int
MgmtSrvr::insertError(int processId, int errorNo)
MgmtSrvr::insertError(int nodeId, int errorNo)
{
if (errorNo < 0) {
return INVALID_ERROR_NUMBER;
}
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
INIT_SIGNAL_SENDER(ss,nodeId);
TamperOrd* const tamperOrd = CAST_PTR(TamperOrd, signal->getDataPtrSend());
tamperOrd->errorNo = errorNo;
signal->set(TestOrd::TraceAPI, CMVMI, GSN_TAMPER_ORD,
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TAMPER_ORD,
TamperOrd::SignalLength);
TamperOrd* const tamperOrd = CAST_PTR(TamperOrd, ssig.getDataPtrSend());
tamperOrd->errorNo = errorNo;
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
......@@ -1619,37 +1367,23 @@ MgmtSrvr::insertError(int processId, int errorNo)
//****************************************************************************
int
MgmtSrvr::setTraceNo(int processId, int traceNo)
MgmtSrvr::setTraceNo(int nodeId, int traceNo)
{
if (traceNo < 0) {
return INVALID_TRACE_NUMBER;
}
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
INIT_SIGNAL_SENDER(ss,nodeId);
TestOrd* const testOrd = CAST_PTR(TestOrd, signal->getDataPtrSend());
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
testOrd->clear();
// Assume TRACE command causes toggling. Not really defined... ? TODO
testOrd->setTraceCommand(TestOrd::Toggle,
(TestOrd::TraceSpecification)traceNo);
signal->set(TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
//****************************************************************************
......@@ -1668,14 +1402,10 @@ MgmtSrvr::getBlockNumber(const BaseString &blockName)
//****************************************************************************
int
MgmtSrvr::setSignalLoggingMode(int processId, LogMode mode,
MgmtSrvr::setSignalLoggingMode(int nodeId, LogMode mode,
const Vector<BaseString>& blocks)
{
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
INIT_SIGNAL_SENDER(ss,nodeId);
// Convert from MgmtSrvr format...
......@@ -1710,12 +1440,10 @@ MgmtSrvr::setSignalLoggingMode(int processId, LogMode mode,
return -1;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
TestOrd* const testOrd = CAST_PTR(TestOrd, signal->getDataPtrSend());
TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
testOrd->clear();
if (blocks.size() == 0 || blocks[0] == "ALL") {
......@@ -1725,78 +1453,44 @@ MgmtSrvr::setSignalLoggingMode(int processId, LogMode mode,
for(unsigned i = 0; i < blocks.size(); i++){
int blockNumber = getBlockNumber(blocks[i]);
if (blockNumber == -1) {
releaseSignal(signal);
return INVALID_BLOCK_NAME;
}
testOrd->addSignalLoggerCommand(blockNumber, command, logSpec);
} // for
} // else
signal->set(TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
/*****************************************************************************
* Signal tracing
*****************************************************************************/
int MgmtSrvr::startSignalTracing(int processId)
int MgmtSrvr::startSignalTracing(int nodeId)
{
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
INIT_SIGNAL_SENDER(ss,nodeId);
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
TestOrd* const testOrd = CAST_PTR(TestOrd, signal->getDataPtrSend());
TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
testOrd->clear();
testOrd->setTestCommand(TestOrd::On);
signal->set(TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
int
MgmtSrvr::stopSignalTracing(int processId)
MgmtSrvr::stopSignalTracing(int nodeId)
{
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
INIT_SIGNAL_SENDER(ss,nodeId);
TestOrd* const testOrd = CAST_PTR(TestOrd, signal->getDataPtrSend());
SimpleSignal ssig;
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
TestOrd* const testOrd = CAST_PTR(TestOrd, ssig.getDataPtrSend());
testOrd->clear();
testOrd->setTestCommand(TestOrd::Off);
signal->set(TestOrd::TraceAPI, CMVMI, GSN_TEST_ORD, TestOrd::SignalLength);
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
......@@ -1805,7 +1499,7 @@ MgmtSrvr::stopSignalTracing(int processId)
*****************************************************************************/
int
MgmtSrvr::dumpState(int processId, const char* args)
MgmtSrvr::dumpState(int nodeId, const char* args)
{
// Convert the space separeted args
// string to an int array
......@@ -1827,29 +1521,20 @@ MgmtSrvr::dumpState(int processId, const char* args)
}
}
return dumpState(processId, args_array, numArgs);
return dumpState(nodeId, args_array, numArgs);
}
int
MgmtSrvr::dumpState(int processId, const Uint32 args[], Uint32 no)
MgmtSrvr::dumpState(int nodeId, const Uint32 args[], Uint32 no)
{
int result;
result = okToSendTo(processId, true);
if (result != 0) {
return result;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
INIT_SIGNAL_SENDER(ss,nodeId);
const Uint32 len = no > 25 ? 25 : no;
SimpleSignal ssig;
DumpStateOrd * const dumpOrd =
CAST_PTR(DumpStateOrd, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, CMVMI, GSN_DUMP_STATE_ORD, len);
CAST_PTR(DumpStateOrd, ssig.getDataPtrSend());
ssig.set(ss,TestOrd::TraceAPI, CMVMI, GSN_DUMP_STATE_ORD, len);
for(Uint32 i = 0; i<25; i++){
if (i < len)
dumpOrd->args[i] = args[i];
......@@ -1857,12 +1542,7 @@ MgmtSrvr::dumpState(int processId, const Uint32 args[], Uint32 no)
dumpOrd->args[i] = 0;
}
result = sendSignal(processId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
......@@ -1895,42 +1575,18 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
int gsn = signal->readSignalNumber();
switch (gsn) {
case GSN_API_VERSION_CONF: {
if (theWaitState == WAIT_VERSION) {
const ApiVersionConf * const conf =
CAST_CONSTPTR(ApiVersionConf, signal->getDataPtr());
if(m_versionRec.callback != 0)
m_versionRec.callback(conf->nodeId, conf->version, this, 0);
else {
m_versionRec.version[conf->nodeId]=conf->version;
}
} else return;
theWaitState = NO_WAIT;
}
break;
case GSN_EVENT_SUBSCRIBE_CONF:
break;
case GSN_EVENT_SUBSCRIBE_REF:
break;
case GSN_EVENT_REP:
eventReport(refToNode(signal->theSendersBlockRef), signal->getDataPtr());
break;
case GSN_STOP_REF:{
const StopRef * const ref = CAST_CONSTPTR(StopRef, signal->getDataPtr());
const NodeId nodeId = refToNode(signal->theSendersBlockRef);
handleStopReply(nodeId, ref->errorCode);
return;
}
case GSN_NF_COMPLETEREP:
break;
case GSN_MGM_LOCK_CONFIG_REP:
case GSN_MGM_LOCK_CONFIG_REQ:
case GSN_MGM_UNLOCK_CONFIG_REP:
case GSN_MGM_UNLOCK_CONFIG_REQ: {
m_signalRecvQueue.receive(new NdbApiSignal(*signal));
case GSN_NODE_FAILREP:
break;
}
default:
g_eventLogger.error("Unknown signal received. SignalNumber: "
......@@ -1945,75 +1601,6 @@ MgmtSrvr::handleReceivedSignal(NdbApiSignal* signal)
}
}
/**
* A database node was either stopped or there was some error
*/
void
MgmtSrvr::handleStopReply(NodeId nodeId, Uint32 errCode)
{
/**
* If we are in single user mode and get a stop reply from a
* DB node, then we have had a node crash.
* If all DB nodes are gone, and we are still in single user mode,
* the set m_stopRec.singleUserMode = false;
*/
if(m_stopRec.singleUserMode) {
ClusterMgr::Node node;
bool failure = true;
for(Uint32 i = 0; i<MAX_NODES; i++) {
if (getNodeType(i) == NDB_MGM_NODE_TYPE_NDB) {
node = theFacade->theClusterMgr->getNodeInfo(i);
if((node.m_state.startLevel == NodeState::SL_NOTHING))
failure = true;
else
failure = false;
}
}
if(failure) {
m_stopRec.singleUserMode = false;
}
}
if(m_stopRec.inUse == false)
return;
if(!(m_stopRec.nodeId == 0 || m_stopRec.nodeId == nodeId))
goto error;
if(m_stopRec.sentCount <= 0)
goto error;
if(!(theWaitState == WAIT_STOP || m_stopRec.callback != 0))
goto error;
if(errCode != 0)
m_stopRec.reply = translateStopRef(errCode);
m_stopRec.sentCount --;
if(m_stopRec.sentCount == 0){
if(theWaitState == WAIT_STOP){
theWaitState = NO_WAIT;
NdbCondition_Signal(theMgmtWaitForResponseCondPtr);
return;
}
if(m_stopRec.callback != 0){
m_stopRec.inUse = false;
StopCallback callback = m_stopRec.callback;
m_stopRec.callback = NULL;
(* callback)(m_stopRec.nodeId,
m_stopRec.anyData,
m_stopRec.reply);
return;
}
}
return;
error:
if(errCode != 0){
g_eventLogger.error("Unexpected signal received. SignalNumber: %i from %d",
GSN_STOP_REF, nodeId);
}
}
void
MgmtSrvr::handleStatus(NodeId nodeId, bool alive, bool nfComplete)
{
......@@ -2027,16 +1614,8 @@ MgmtSrvr::handleStatus(NodeId nodeId, bool alive, bool nfComplete)
theData[0] = EventReport::Disconnected;
if(nfComplete)
{
handleStopReply(nodeId, 0);
DBUG_VOID_RETURN;
}
if(theWaitNode == nodeId &&
theWaitState != NO_WAIT && theWaitState != WAIT_STOP)
{
theWaitState = WAIT_NODEFAILURE;
NdbCondition_Signal(theMgmtWaitForResponseCondPtr);
}
}
eventReport(_ownNodeId, theData);
......@@ -2381,6 +1960,7 @@ MgmtSrvr::eventReport(NodeId nodeId, const Uint32 * theData)
/***************************************************************************
* Backup
***************************************************************************/
int
MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
{
......@@ -2395,7 +1975,6 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
if(!next) return NO_CONTACT_WITH_DB_NODES;
SimpleSignal ssig;
BackupReq* req = CAST_PTR(BackupReq, ssig.getDataPtrSend());
ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_BACKUP_REQ,
BackupReq::SignalLength);
......@@ -2410,8 +1989,7 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
while (1) {
if (do_send)
{
SendStatus result = ss.sendSignal(nodeId, &ssig);
if (result != SEND_OK) {
if (ss.sendSignal(nodeId, &ssig) != SEND_OK) {
return SEND_OR_RECEIVE_FAILED;
}
if (waitCompleted == 0)
......@@ -2513,13 +2091,13 @@ MgmtSrvr::startBackup(Uint32& backupId, int waitCompleted)
return SEND_OR_RECEIVE_FAILED;
}
}
return 0;
}
int
MgmtSrvr::abortBackup(Uint32 backupId)
{
SignalSender ss(theFacade);
bool next;
NodeId nodeId = 0;
while((next = getNextNodeId(&nodeId, NDB_MGM_NODE_TYPE_NDB)) == true &&
......@@ -2529,25 +2107,17 @@ MgmtSrvr::abortBackup(Uint32 backupId)
return NO_CONTACT_WITH_DB_NODES;
}
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
return COULD_NOT_ALLOCATE_MEMORY;
}
SimpleSignal ssig;
AbortBackupOrd* ord = CAST_PTR(AbortBackupOrd, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI, BACKUP, GSN_ABORT_BACKUP_ORD,
AbortBackupOrd* ord = CAST_PTR(AbortBackupOrd, ssig.getDataPtrSend());
ssig.set(ss, TestOrd::TraceAPI, BACKUP, GSN_ABORT_BACKUP_ORD,
AbortBackupOrd::SignalLength);
ord->requestType = AbortBackupOrd::ClientAbort;
ord->senderData = 19;
ord->backupId = backupId;
int result = sendSignal(nodeId, NO_WAIT, signal, true);
if (result == -1) {
return SEND_OR_RECEIVE_FAILED;
}
return 0;
return ss.sendSignal(nodeId, &ssig) == SEND_OK ? 0 : SEND_OR_RECEIVE_FAILED;
}
......@@ -2562,26 +2132,6 @@ MgmtSrvr::repCommand(Uint32* repReqId, Uint32 request, bool waitCompleted)
return 0;
}
NodeId
MgmtSrvr::getPrimaryNode() const {
#if 0
Uint32 tmp;
const Properties *prop = NULL;
getConfig()->get("SYSTEM", &prop);
if(prop == NULL)
return 0;
prop->get("PrimaryMGMNode", &tmp);
return tmp;
#else
return 0;
#endif
}
MgmtSrvr::Allocated_resources::Allocated_resources(MgmtSrvr &m)
: m_mgmsrv(m)
{
......@@ -2721,11 +2271,6 @@ MgmtSrvr::setDbParameter(int node, int param, const char * value,
return 0;
}
template class Vector<SigMatch>;
#if __SUNPRO_CC != 0x560
template bool SignalQueue::waitFor<SigMatch>(Vector<SigMatch>&, SigMatch**, NdbApiSignal**, unsigned);
#endif
template class MutexVector<unsigned short>;
template class MutexVector<Ndb_mgmd_event_service::Event_listener>;
template class MutexVector<EventSubscribeReq>;
ndb/src/mgmsrv/MgmtSrvr.hpp
View file @ e77095bc
......@@ -22,15 +22,17 @@
#include <NdbCondition.h>
#include <mgmapi.h>
#include <NdbTCP.h>
#include <ConfigRetriever.hpp>
#include <Vector.hpp>
#include <NodeBitmask.hpp>
#include <signaldata/ManagementServer.hpp>
#include "SignalQueue.hpp"
#include <ndb_version.h>
#include <EventLogger.hpp>
#include <signaldata/EventSubscribeReq.hpp>
#include <SignalSender.hpp>
/**
* @desc Block number for Management server.
* @todo This should probably be somewhere else. I don't know where atm.
......@@ -199,51 +201,26 @@ public:
~MgmtSrvr();
int status(int processId,
/**
* Get status on a node.
* address may point to a common area (e.g. from inet_addr)
* There is no gaurentee that it is preserved across calls.
* Copy the string if you are not going to use it immediately.
*/
int status(int nodeId,
ndb_mgm_node_status * status,
Uint32 * version,
Uint32 * phase,
bool * systemShutdown,
Uint32 * dynamicId,
Uint32 * nodeGroup,
Uint32 * connectCount);
Uint32 * connectCount,
const char **address);
// All the functions below may return any of this error codes:
// NO_CONTACT_WITH_PROCESS, PROCESS_NOT_CONFIGURED, WRONG_PROCESS_TYPE,
// COULD_NOT_ALLOCATE_MEMORY, SEND_OR_RECEIVE_FAILED
typedef void (* StopCallback)(int nodeId, void * anyData, int errorCode);
typedef void (* VersionCallback)(int nodeId, int version,
void * anyData, int errorCode);
typedef void (* EnterSingleCallback)(int nodeId, void * anyData,
int errorCode);
typedef void (* ExitSingleCallback)(int nodeId, void * anyData,
int errorCode);
/**
* Lock configuration
*/
int lockConf();
/**
* Unlock configuration, and commit it if commit is true
*/
int unlockConf(bool commit);
/**
* Commit new configuration
*/
int commitConfig();
/**
* Rollback configuration
*/
int rollbackConfig();
/**
* Save a configuration to permanent storage
*/
......@@ -272,12 +249,12 @@ public:
* @param processId: Id of the DB process to stop
* @return 0 if succeeded, otherwise: as stated above, plus:
*/
int stopNode(int nodeId, bool abort = false, StopCallback = 0, void *any= 0);
int stopNode(int nodeId, bool abort = false);
/**
* Stop the system
*/
int stop(int * cnt = 0, bool abort = false, StopCallback = 0, void *any = 0);
int stop(int * cnt = 0, bool abort = false);
/**
* print version info about a node
......@@ -285,27 +262,18 @@ public:
* @param processId: Id of the DB process to stop
* @return 0 if succeeded, otherwise: as stated above, plus:
*/
int versionNode(int nodeId, bool abort = false,
VersionCallback = 0, void *any= 0);
/**
* print version info about all node in the system
*/
int version(int * cnt = 0, bool abort = false,
VersionCallback = 0, void *any = 0);
int versionNode(int nodeId, Uint32 &version, const char **address);
/**
* Maintenance on the system
*/
int enterSingleUser(int * cnt = 0, Uint32 singleuserNodeId = 0,
EnterSingleCallback = 0, void *any = 0);
int enterSingleUser(int * cnt = 0, Uint32 singleuserNodeId = 0);
/**
* Resume from maintenance on the system
*/
int exitSingleUser(int * cnt = 0, bool abort = false,
ExitSingleCallback = 0, void *any = 0);
int exitSingleUser(int * cnt = 0, bool abort = false);
/**
* Start DB process.
......@@ -319,15 +287,14 @@ public:
* @param processId: Id of the DB process to start
*/
int restartNode(int processId, bool nostart, bool initialStart,
bool abort = false,
StopCallback = 0, void * anyData = 0);
bool abort = false);
/**
* Restart the system
*/
int restart(bool nostart, bool initialStart,
bool abort = false,
int * stopCount = 0, StopCallback = 0, void * anyData = 0);
int * stopCount = 0);
struct BackupEvent {
enum Event {
......@@ -481,13 +448,6 @@ public:
*/
const Config * getConfig() const;
/**
* Change configuration paramter
*/
bool changeConfig(const BaseString &section,
const BaseString &param,
const BaseString &value);
/**
* Returns the node count for the specified node type.
*
......@@ -496,11 +456,6 @@ public:
*/
int getNodeCount(enum ndb_mgm_node_type type) const;
/**
* Returns the nodeId of the management master
*/
NodeId getPrimaryNode() const;
/**
* Returns the port number.
* @return port number.
......@@ -517,7 +472,16 @@ public:
private:
//**************************************************************************
int setEventReportingLevel(int processId, LogLevel::EventCategory, Uint32);
int send(SignalSender &ss, SimpleSignal &ssig, Uint32 node, Uint32 node_type);
int sendSTOP_REQ(NodeId nodeId,
NodeBitmask &stoppedNodes,
Uint32 singleUserNodeId,
bool abort,
bool stop,
bool restart,
bool nostart,
bool initialStart);
/**
* Check if it is possible to send a signal to a (DB) process
......@@ -582,9 +546,6 @@ private:
// Returns: -
//**************************************************************************
void handle_MGM_LOCK_CONFIG_REQ(NdbApiSignal *signal);
void handle_MGM_UNLOCK_CONFIG_REQ(NdbApiSignal *signal);
//**************************************************************************
// Specific signal handling data
//**************************************************************************
......@@ -608,60 +569,9 @@ private:
enum WaitSignalType {
NO_WAIT, // We don't expect to receive any signal
WAIT_SET_VAR, // Accept SET_VAR_CONF and SET_VAR_REF
WAIT_SUBSCRIBE_CONF, // Accept event subscription confirmation
WAIT_STOP,
WAIT_BACKUP_STARTED,
WAIT_BACKUP_COMPLETED,
WAIT_VERSION,
WAIT_NODEFAILURE
WAIT_SUBSCRIBE_CONF // Accept event subscription confirmation
};
/**
* Get an unused signal
* @return A signal if succeeded, NULL otherwise
*/
NdbApiSignal* getSignal();
/**
* Add a signal to the list of unused signals
* @param signal: The signal to add
*/
void releaseSignal(NdbApiSignal* signal);
/**
* Remove a signal from the list of unused signals and delete
* the memory for it.
*/
void freeSignal();
/**
* Send a signal
* @param processId: Id of the receiver process
* @param waitState: State denoting a set of signals we accept to receive
* @param signal: The signal to send
* @return 0 if succeeded, -1 otherwise
*/
int sendSignal(Uint16 processId, WaitSignalType waitState,
NdbApiSignal* signal, bool force = false);
/**
* Send a signal and wait for an answer signal
* @param processId: Id of the receiver process
* @param waitState: State denoting a set of signals we accept to receive.
* @param signal: The signal to send
* @return 0 if succeeded, -1 otherwise (for example failed to send or
* failed to receive expected signal).
*/
int sendRecSignal(Uint16 processId, WaitSignalType waitState,
NdbApiSignal* signal, bool force = false,
int waitTime = WAIT_FOR_RESPONSE_TIMEOUT);
/**
* Wait for a signal to arrive.
* @return 0 if signal arrived, -1 otherwise
*/
int receiveOptimisedResponse(int waitTime);
/**
* This function is called from "outside" of MgmtSrvr
* when a signal is sent to MgmtSrvr.
......@@ -708,31 +618,7 @@ private:
class TransporterFacade * theFacade;
class SignalQueue m_signalRecvQueue;
struct StopRecord {
StopRecord(){ inUse = false; callback = 0; singleUserMode = false;}
bool inUse;
bool singleUserMode;
int sentCount;
int reply;
int nodeId;
void * anyData;
StopCallback callback;
};
StopRecord m_stopRec;
struct VersionRecord {
VersionRecord(){ inUse = false; callback = 0;}
bool inUse;
Uint32 version[MAX_NODES];
VersionCallback callback;
};
VersionRecord m_versionRec;
int sendVersionReq( int processId);
void handleStopReply(NodeId nodeId, Uint32 errCode);
int sendVersionReq( int processId, Uint32 &version, const char **address);
int translateStopRef(Uint32 errCode);
bool _isStopThread;
......@@ -753,14 +639,8 @@ private:
static void *logLevelThread_C(void *);
void logLevelThreadRun();
struct NdbThread *m_signalRecvThread;
static void *signalRecvThread_C(void *);
void signalRecvThreadRun();
Config *_props;
int send(class NdbApiSignal* signal, Uint32 node, Uint32 node_type);
ConfigRetriever *m_config_retriever;
};
......
ndb/src/mgmsrv/MgmtSrvrConfig.cpp
View file @ e77095bc
......@@ -23,228 +23,6 @@
#include <ConfigRetriever.hpp>
#include <ndb_version.h>
void
MgmtSrvr::handle_MGM_LOCK_CONFIG_REQ(NdbApiSignal *signal) {
NodeId sender = refToNode(signal->theSendersBlockRef);
const MgmLockConfigReq * const req = CAST_CONSTPTR(MgmLockConfigReq, signal->getDataPtr());
NdbApiSignal *reply = getSignal();
if(signal == NULL)
return; /** @todo handle allocation failure */
reply->set(TestOrd::TraceAPI,
MGMSRV,
GSN_MGM_LOCK_CONFIG_REP,
MgmLockConfigRep::SignalLength);
MgmLockConfigRep *lockRep = CAST_PTR(MgmLockConfigRep, reply->getDataPtrSend());
lockRep->errorCode = MgmLockConfigRep::UNKNOWN_ERROR;
if(req->newConfigGeneration < m_nextConfigGenerationNumber) {
lockRep->errorCode = MgmLockConfigRep::GENERATION_MISMATCH;
goto done;
}
NdbMutex_Lock(m_configMutex);
m_nextConfigGenerationNumber = req->newConfigGeneration+1;
lockRep->errorCode = MgmLockConfigRep::OK;
done:
sendSignal(sender, NO_WAIT, reply, true);
NdbMutex_Unlock(m_configMutex);
return;
}
void
MgmtSrvr::handle_MGM_UNLOCK_CONFIG_REQ(NdbApiSignal *signal) {
NodeId sender = refToNode(signal->theSendersBlockRef);
const MgmUnlockConfigReq * const req = CAST_CONSTPTR(MgmUnlockConfigReq, signal->getDataPtr());
MgmUnlockConfigRep *unlockRep;
NdbApiSignal *reply = getSignal();
if(signal == NULL)
goto error; /** @todo handle allocation failure */
reply->set(TestOrd::TraceAPI,
MGMSRV,
GSN_MGM_UNLOCK_CONFIG_REP,
MgmUnlockConfigRep::SignalLength);
unlockRep = CAST_PTR(MgmUnlockConfigRep, reply->getDataPtrSend());
unlockRep->errorCode = MgmUnlockConfigRep::UNKNOWN_ERROR;
NdbMutex_Lock(m_configMutex);
if(req->commitConfig == 1) {
m_newConfig = fetchConfig();
commitConfig();
} else
rollbackConfig();
unlockRep->errorCode = MgmUnlockConfigRep::OK;
sendSignal(sender, NO_WAIT, reply, true);
error:
NdbMutex_Unlock(m_configMutex);
return;
}
/**
* Prepare all MGM nodes for configuration changes
*
* @returns 0 on success, or -1 on failure
*/
int
MgmtSrvr::lockConf() {
int result = -1;
MgmLockConfigReq* lockReq;
NodeId node = 0;
/* Check if this is the master node */
if(getPrimaryNode() != _ownNodeId)
goto done;
if(NdbMutex_Trylock(m_configMutex) != 0)
return -1;
m_newConfig = new Config(*_config); /* copy the existing config */
_config = m_newConfig;
m_newConfig = new Config(*_config);
m_nextConfigGenerationNumber++;
/* Make sure the new configuration _always_ is at least one step older */
if(m_nextConfigGenerationNumber < m_newConfig->getGenerationNumber()+1)
m_nextConfigGenerationNumber = _config->getGenerationNumber()+1;
m_newConfig->setGenerationNumber(m_nextConfigGenerationNumber);
node = 0;
while(getNextNodeId(&node, NDB_MGM_NODE_TYPE_MGM)) {
if(node != _ownNodeId) {
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
result = COULD_NOT_ALLOCATE_MEMORY;
goto done;
}
lockReq = CAST_PTR(MgmLockConfigReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI,
MGMSRV,
GSN_MGM_LOCK_CONFIG_REQ,
MgmLockConfigReq::SignalLength);
lockReq->newConfigGeneration = m_nextConfigGenerationNumber;
result = sendSignal(node, NO_WAIT, signal, true);
NdbApiSignal *reply =
m_signalRecvQueue.waitFor(GSN_MGM_LOCK_CONFIG_REP, 0);
if(reply == NULL) {
/** @todo handle timeout/error */
ndbout << __FILE__ << ":" << __LINE__ << endl;
result = -1;
goto done;
}
}
}
done:
NdbMutex_Unlock(m_configMutex);
return result;
}
/**
* Unlocks configuration
*
* @returns 0 on success, ! 0 on error
*/
int
MgmtSrvr::unlockConf(bool commit) {
int result = -1;
MgmUnlockConfigReq* unlockReq;
NodeId node = 0;
/* Check if this is the master node */
if(getPrimaryNode() != _ownNodeId)
goto done;
errno = 0;
if(NdbMutex_Lock(m_configMutex) != 0)
return -1;
if(commit)
commitConfig();
else
rollbackConfig();
node = 0;
while(getNextNodeId(&node, NDB_MGM_NODE_TYPE_MGM)) {
if(node != _ownNodeId) {
NdbApiSignal* signal = getSignal();
if (signal == NULL) {
result = COULD_NOT_ALLOCATE_MEMORY;
goto done;
}
unlockReq = CAST_PTR(MgmUnlockConfigReq, signal->getDataPtrSend());
signal->set(TestOrd::TraceAPI,
MGMSRV,
GSN_MGM_UNLOCK_CONFIG_REQ,
MgmUnlockConfigReq::SignalLength);
unlockReq->commitConfig = commit;
result = sendSignal(node, NO_WAIT, signal, true);
NdbApiSignal *reply =
m_signalRecvQueue.waitFor(GSN_MGM_UNLOCK_CONFIG_REP, 0);
if(reply == NULL) {
/** @todo handle timeout/error */
result = -1;
goto done;
}
}
}
done:
NdbMutex_Unlock(m_configMutex);
return result;
}
/**
* Commit the new configuration
*/
int
MgmtSrvr::commitConfig() {
int ret = saveConfig(m_newConfig);
delete _config;
_config = m_newConfig;
m_newConfig = NULL;
ndbout << "commit " << ret << endl;
return ret;
}
/**
* Rollback to the old configuration
*/
int
MgmtSrvr::rollbackConfig() {
delete m_newConfig;
m_newConfig = NULL;
ndbout << "rollback" << endl;
return saveConfig(_config);
}
/**
* Save a configuration to the running configuration file
*/
......@@ -288,12 +66,3 @@ MgmtSrvr::fetchConfig() {
}
return 0;
}
bool
MgmtSrvr::changeConfig(const BaseString &section,
const BaseString &param,
const BaseString &value) {
if(m_newConfig == NULL)
return false;
return m_newConfig->change(section, param, value);
}
ndb/src/mgmsrv/MgmtSrvrGeneralSignalHandling.cpp
View file @ e77095bc
......@@ -20,123 +20,3 @@
// Some kind of reuse should be preferred.
//******************************************************************************
#include "MgmtSrvr.hpp"
#include <NdbApiSignal.hpp>
#include <NdbTick.h>
NdbApiSignal*
MgmtSrvr::getSignal()
{
NdbApiSignal* tSignal;
tSignal = theSignalIdleList;
if (tSignal != NULL){
NdbApiSignal* tSignalNext = tSignal->next();
tSignal->next(NULL);
theSignalIdleList = tSignalNext;
return tSignal;
} else
{
tSignal = new NdbApiSignal(_ownReference);
if (tSignal != NULL)
tSignal->next(NULL);
}
return tSignal;
}
void
MgmtSrvr::releaseSignal(NdbApiSignal* aSignal)
{
aSignal->next(theSignalIdleList);
theSignalIdleList = aSignal;
}
void
MgmtSrvr::freeSignal()
{
NdbApiSignal* tSignal = theSignalIdleList;
theSignalIdleList = tSignal->next();
delete tSignal;
}
int
MgmtSrvr::sendSignal(Uint16 aNodeId,
WaitSignalType aWaitState,
NdbApiSignal* aSignal,
bool force)
{
int tReturnCode;
theFacade->lock_mutex();
if(force){
tReturnCode = theFacade->sendSignalUnCond(aSignal,
aNodeId);
} else {
tReturnCode = theFacade->sendSignal(aSignal,
aNodeId);
}
releaseSignal(aSignal);
if (tReturnCode == -1) {
theFacade->unlock_mutex();
return -1;
}
theWaitState = aWaitState;
theFacade->unlock_mutex();
return 0;
}
int
MgmtSrvr::sendRecSignal(Uint16 aNodeId,
WaitSignalType aWaitState,
NdbApiSignal* aSignal,
bool force,
int waitTime)
{
int tReturnCode;
theFacade->lock_mutex();
if(force){
tReturnCode = theFacade->sendSignalUnCond(aSignal, aNodeId);
} else {
tReturnCode = theFacade->sendSignalUnCond(aSignal, aNodeId);
}
releaseSignal(aSignal);
if (tReturnCode == -1) {
theFacade->unlock_mutex();
return -1;
}
theWaitState = aWaitState;
theWaitNode = aNodeId;
return receiveOptimisedResponse(waitTime);
}
int
MgmtSrvr::receiveOptimisedResponse(int waitTime)
{
int tResultCode;
theFacade->checkForceSend(_blockNumber);
NDB_TICKS maxTime = NdbTick_CurrentMillisecond() + waitTime;
while (theWaitState != NO_WAIT && theWaitState != WAIT_NODEFAILURE
&& waitTime > 0) {
NdbCondition_WaitTimeout(theMgmtWaitForResponseCondPtr,
theFacade->theMutexPtr,
waitTime);
if(theWaitState == NO_WAIT || theWaitState == WAIT_NODEFAILURE)
break;
waitTime = (maxTime - NdbTick_CurrentMillisecond());
}//while
if(theWaitState == NO_WAIT) {
tResultCode = 0;
} else {
tResultCode = -1;
}
theFacade->unlock_mutex();
return tResultCode;
}
ndb/src/mgmsrv/Services.cpp
View file @ e77095bc
......@@ -221,21 +221,6 @@ ParserRow<MgmApiSession> commands[] = {
MGM_ARG("level", Int, Mandatory, "Severety level"),
MGM_ARG("enable", Int, Mandatory, "1=disable, 0=enable, -1=toggle"),
MGM_CMD("config lock", &MgmApiSession::configLock, ""),
MGM_CMD("config unlock", &MgmApiSession::configUnlock, ""),
MGM_ARG("commit", Int, Mandatory, "Commit changes"),
MGM_CMD("config change", &MgmApiSession::configChange, ""),
MGM_ARG("section", String, Mandatory, "Section"),
MGM_ARG("parameter", String, Mandatory, "Parameter"),
MGM_ARG("value", String, Mandatory, "Value"),
MGM_CMD("config lock", &MgmApiSession::configLock, ""),
MGM_CMD("config unlock", &MgmApiSession::configUnlock, ""),
MGM_ARG("commit", Int, Mandatory, "Commit changes"),
MGM_CMD("set parameter", &MgmApiSession::setParameter, ""),
MGM_ARG("node", String, Mandatory, "Node"),
MGM_ARG("parameter", String, Mandatory, "Parameter"),
......@@ -918,8 +903,10 @@ printNodeStatus(OutputStream *output,
nodeGroup = 0,
connectCount = 0;
bool system;
const char *address= NULL;
mgmsrv.status(nodeId, &status, &version, &startPhase,
&system, &dynamicId, &nodeGroup, &connectCount);
&system, &dynamicId, &nodeGroup, &connectCount,
&address);
output->println("node.%d.type: %s",
nodeId,
ndb_mgm_get_node_type_string(type));
......@@ -931,7 +918,7 @@ printNodeStatus(OutputStream *output,
output->println("node.%d.dynamic_id: %d", nodeId, dynamicId);
output->println("node.%d.node_group: %d", nodeId, nodeGroup);
output->println("node.%d.connect_count: %d", nodeId, connectCount);
output->println("node.%d.address: %s", nodeId, mgmsrv.get_connect_address(nodeId));
output->println("node.%d.address: %s", nodeId, address);
}
}
......@@ -1200,42 +1187,6 @@ MgmApiSession::setLogFilter(Parser_t::Context &ctx,
m_output->println("");
}
void
MgmApiSession::configLock(Parser_t::Context &,
Properties const &) {
int ret = m_mgmsrv.lockConf();
m_output->println("config lock reply");
m_output->println("result: %d", ret);
m_output->println("");
}
void
MgmApiSession::configUnlock(Parser_t::Context &,
Properties const &args) {
Uint32 commit;
args.get("commit", &commit);
int ret = m_mgmsrv.unlockConf(commit == 1);
m_output->println("config unlock reply");
m_output->println("result: %d", ret);
m_output->println("");
}
void
MgmApiSession::configChange(Parser_t::Context &,
Properties const &args) {
BaseString section, param, value;
args.get("section", section);
args.get("parameter", param);
args.get("value", value);
int ret = m_mgmsrv.changeConfig(section.c_str(),
param.c_str(),
value.c_str());
m_output->println("config change reply");
m_output->println("result: %d", ret);
m_output->println("");
}
static NdbOut&
operator<<(NdbOut& out, const LogLevel & ll)
{
......
ndb/src/mgmsrv/Services.hpp
View file @ e77095bc
......@@ -83,9 +83,6 @@ public:
void setClusterLogLevel(Parser_t::Context &ctx,
const class Properties &args);
void setLogFilter(Parser_t::Context &ctx, const class Properties &args);
void configLock(Parser_t::Context &ctx, const class Properties &args);
void configUnlock(Parser_t::Context &ctx, const class Properties &args);
void configChange(Parser_t::Context &ctx, const class Properties &args);
void setParameter(Parser_t::Context &ctx, const class Properties &args);
void listen_event(Parser_t::Context &ctx, const class Properties &args);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7