Merge

ndb/include/mgmapi/mgmapi.h:
  SCCS merged

mysql-test/ndb/basic.result

@@ -26,17 +26,17 @@ CONNECT [<connectstring>]              Connect to management server (reconnect i
 QUIT                                   Quit management client
 
 <severity> = ALERT | CRITICAL | ERROR | WARNING | INFO | DEBUG
-<category> = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | GREP | DEBUG | BACKUP
+<category> = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | CONGESTION | DEBUG | BACKUP
 <level>    = 0 - 15
 <id>       = ALL | Any database node id
 
 Connected to Management Server at: localhost:1186
-Node 1: started (Version 4.1.9)
-Node 2: started (Version 4.1.9)
+Node 1: started (Version 5.0.3)
+Node 2: started (Version 5.0.3)
 
-Node 1: started (Version 4.1.9)
+Node 1: started (Version 5.0.3)
 
-Node 2: started (Version 4.1.9)
+Node 2: started (Version 5.0.3)
 
 Executing CLUSTERLOG on node 1 OK!
 Executing CLUSTERLOG on node 2 OK!

mysql-test/ndb/restart.test

@@ -8,5 +8,5 @@ sleep 5
 all clusterlog connection=8
 sleep 1
 1 restart
-sleep 5
+sleep 10
 clusterlog on all

ndb/include/kernel/LogLevel.hpp

@@ -57,7 +57,7 @@ public:
     llInfo = CFG_LOGLEVEL_INFO - CFG_MIN_LOGLEVEL,
     llWarning = CFG_LOGLEVEL_WARNING - CFG_MIN_LOGLEVEL,
     llError = CFG_LOGLEVEL_ERROR - CFG_MIN_LOGLEVEL,
-    llGrep = CFG_LOGLEVEL_GREP - CFG_MIN_LOGLEVEL,
+    llCongestion = CFG_LOGLEVEL_CONGESTION - CFG_MIN_LOGLEVEL,
     llDebug = CFG_LOGLEVEL_DEBUG - CFG_MIN_LOGLEVEL
     ,llBackup = CFG_LOGLEVEL_BACKUP - CFG_MIN_LOGLEVEL
   };

ndb/include/mgmapi/mgmapi_config_parameters.h

@@ -94,7 +94,7 @@
 #define CFG_LOGLEVEL_INFO         256
 #define CFG_LOGLEVEL_WARNING      257
 #define CFG_LOGLEVEL_ERROR        258
-#define CFG_LOGLEVEL_GREP         259
+#define CFG_LOGLEVEL_CONGESTION   259
 #define CFG_LOGLEVEL_DEBUG        260
 #define CFG_LOGLEVEL_BACKUP       261
 #define CFG_MAX_LOGLEVEL          261

ndb/src/common/debugger/EventLogger.cpp

@@ -105,10 +105,6 @@ 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},
-
   // Backup
   { EventReport::BackupStarted, LogLevel::llBackup, 7, Logger::LL_INFO },
   { EventReport::BackupCompleted, LogLevel::llBackup, 7, Logger::LL_INFO },

ndb/src/mgmapi/mgmapi.cpp

@@ -916,67 +916,68 @@ ndb_mgm_restart(NdbMgmHandle handle, int no_of_nodes, const int *node_list)
   return ndb_mgm_restart2(handle, no_of_nodes, node_list, 0, 0, 0);
 }
 
-static const char *clusterlog_level_names[]=
+static const char *clusterlog_severity_names[]=
   { "enabled", "debug", "info", "warning", "error", "critical", "alert" };
 
-struct ndb_mgm_clusterlog_levels 
+struct ndb_mgm_event_severities 
 {
   const char* name;
-  enum ndb_mgm_clusterlog_level level;
-} clusterlog_levels[] = {
-  { clusterlog_level_names[0], NDB_MGM_CLUSTERLOG_ON },
-  { clusterlog_level_names[1], NDB_MGM_CLUSTERLOG_DEBUG },
-  { clusterlog_level_names[2], NDB_MGM_CLUSTERLOG_INFO },
-  { clusterlog_level_names[3], NDB_MGM_CLUSTERLOG_WARNING },
-  { clusterlog_level_names[4], NDB_MGM_CLUSTERLOG_ERROR },
-  { clusterlog_level_names[5], NDB_MGM_CLUSTERLOG_CRITICAL },
-  { clusterlog_level_names[6], NDB_MGM_CLUSTERLOG_ALERT },
-  { "all",                     NDB_MGM_CLUSTERLOG_ALL },
-  { 0,                         NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL },
+  enum ndb_mgm_event_severity severity;
+} clusterlog_severities[] = {
+  { clusterlog_severity_names[0], NDB_MGM_EVENT_SEVERITY_ON },
+  { clusterlog_severity_names[1], NDB_MGM_EVENT_SEVERITY_DEBUG },
+  { clusterlog_severity_names[2], NDB_MGM_EVENT_SEVERITY_INFO },
+  { clusterlog_severity_names[3], NDB_MGM_EVENT_SEVERITY_WARNING },
+  { clusterlog_severity_names[4], NDB_MGM_EVENT_SEVERITY_ERROR },
+  { clusterlog_severity_names[5], NDB_MGM_EVENT_SEVERITY_CRITICAL },
+  { clusterlog_severity_names[6], NDB_MGM_EVENT_SEVERITY_ALERT },
+  { "all",                        NDB_MGM_EVENT_SEVERITY_ALL },
+  { 0,                            NDB_MGM_ILLEGAL_EVENT_SEVERITY },
 };
 
 extern "C"
-ndb_mgm_clusterlog_level
-ndb_mgm_match_clusterlog_level(const char * name)
+ndb_mgm_event_severity
+ndb_mgm_match_event_severity(const char * name)
 {
   if(name == 0)
-    return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
+    return NDB_MGM_ILLEGAL_EVENT_SEVERITY;
   
-  for(int i = 0; clusterlog_levels[i].name !=0 ; i++)
-    if(strcasecmp(name, clusterlog_levels[i].name) == 0)
-      return clusterlog_levels[i].level;
+  for(int i = 0; clusterlog_severities[i].name !=0 ; i++)
+    if(strcasecmp(name, clusterlog_severities[i].name) == 0)
+      return clusterlog_severities[i].severity;
 
-  return NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
+  return NDB_MGM_ILLEGAL_EVENT_SEVERITY;
 }
 
 extern "C"
 const char * 
-ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level level)
+ndb_mgm_get_event_severity_string(enum ndb_mgm_event_severity severity)
 {
-  int i= (int)level;
-  if (i >= 0 && i < (int)NDB_MGM_CLUSTERLOG_ALL)
-    return clusterlog_level_names[i];
-  for(i = (int)NDB_MGM_CLUSTERLOG_ALL; clusterlog_levels[i].name != 0; i++)
-    if(clusterlog_levels[i].level == level)
-      return clusterlog_levels[i].name;
+  int i= (int)severity;
+  if (i >= 0 && i < (int)NDB_MGM_EVENT_SEVERITY_ALL)
+    return clusterlog_severity_names[i];
+  for(i = (int)NDB_MGM_EVENT_SEVERITY_ALL; clusterlog_severities[i].name != 0; i++)
+    if(clusterlog_severities[i].severity == severity)
+      return clusterlog_severities[i].name;
   return 0;
 }
 
 extern "C"
-unsigned int *
-ndb_mgm_get_logfilter(NdbMgmHandle handle) 
+const unsigned int *
+ndb_mgm_get_clusterlog_severity_filter(NdbMgmHandle handle) 
 {
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_logfilter");
-  static Uint32 enabled[(int)NDB_MGM_CLUSTERLOG_ALL] = {0,0,0,0,0,0,0};
+  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_get_clusterlog_severity_filter");
+  static unsigned int enabled[(int)NDB_MGM_EVENT_SEVERITY_ALL]=
+    {0,0,0,0,0,0,0};
   const ParserRow<ParserDummy> getinfo_reply[] = {
     MGM_CMD("clusterlog", NULL, ""),
-    MGM_ARG(clusterlog_level_names[0], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[1], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[2], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[3], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[4], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[5], Int, Mandatory, ""),
-    MGM_ARG(clusterlog_level_names[6], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[0], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[1], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[2], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[3], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[4], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[5], Int, Mandatory, ""),
+    MGM_ARG(clusterlog_severity_names[6], Int, Mandatory, ""),
   };
   CHECK_HANDLE(handle, NULL);
   CHECK_CONNECTED(handle, NULL);
@@ -986,20 +987,21 @@ ndb_mgm_get_logfilter(NdbMgmHandle handle)
   reply = ndb_mgm_call(handle, getinfo_reply, "get info clusterlog", &args);
   CHECK_REPLY(reply, NULL);
   
-  for(int i=0; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) {
-    reply->get(clusterlog_level_names[i], &enabled[i]);
+  for(int i=0; i < (int)NDB_MGM_EVENT_SEVERITY_ALL; i++) {
+    reply->get(clusterlog_severity_names[i], &enabled[i]);
   }
   return enabled;
 }
 
 extern "C"
 int 
-ndb_mgm_filter_clusterlog(NdbMgmHandle handle, 
-			  enum ndb_mgm_clusterlog_level level,
-			  int enable,
-			  struct ndb_mgm_reply* /*reply*/) 
+ndb_mgm_set_clusterlog_severity_filter(NdbMgmHandle handle, 
+				       enum ndb_mgm_event_severity severity,
+				       int enable,
+				       struct ndb_mgm_reply* /*reply*/) 
 {
-  SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_filter_clusterlog");
+  SET_ERROR(handle, NDB_MGM_NO_ERROR,
+	    "Executing: ndb_mgm_set_clusterlog_severity_filter");
   const ParserRow<ParserDummy> filter_reply[] = {
     MGM_CMD("set logfilter reply", NULL, ""),
     MGM_ARG("result", String, Mandatory, "Error message"),
@@ -1010,7 +1012,7 @@ ndb_mgm_filter_clusterlog(NdbMgmHandle handle,
   CHECK_CONNECTED(handle, -1);
 
   Properties args;
-  args.put("level", level);
+  args.put("level", severity);
   args.put("enable", enable);
   
   const Properties *reply;
@@ -1045,10 +1047,9 @@ struct ndb_mgm_event_categories
   { "CHECKPOINT", NDB_MGM_EVENT_CATEGORY_CHECKPOINT },
   { "DEBUG", NDB_MGM_EVENT_CATEGORY_DEBUG },
   { "INFO", NDB_MGM_EVENT_CATEGORY_INFO },
-  { "WARNING", NDB_MGM_EVENT_CATEGORY_WARNING },
   { "ERROR", NDB_MGM_EVENT_CATEGORY_ERROR },
-  { "GREP", NDB_MGM_EVENT_CATEGORY_GREP },
   { "BACKUP", NDB_MGM_EVENT_CATEGORY_BACKUP },
+  { "CONGESTION", NDB_MGM_EVENT_CATEGORY_CONGESTION },
   { 0, NDB_MGM_ILLEGAL_EVENT_CATEGORY }
 };
 
@@ -1080,13 +1081,13 @@ ndb_mgm_get_event_category_string(enum ndb_mgm_event_category status)
 
 extern "C"
 int 
-ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int nodeId,
+ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle, int nodeId,
 				enum ndb_mgm_event_category cat,
 				int level,
 				struct ndb_mgm_reply* /*reply*/) 
 {
   SET_ERROR(handle, NDB_MGM_NO_ERROR, 
-	    "Executing: ndb_mgm_set_loglevel_clusterlog");
+	    "Executing: ndb_mgm_set_clusterlog_loglevel");
   const ParserRow<ParserDummy> clusterlog_reply[] = {
     MGM_CMD("set cluster loglevel reply", NULL, ""),
     MGM_ARG("result", String, Mandatory, "Error message"),
@@ -1105,7 +1106,7 @@ ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, int nodeId,
 		       "set cluster loglevel", &args);
   CHECK_REPLY(reply, -1);
   
-  DBUG_ENTER("ndb_mgm_set_loglevel_clusterlog");
+  DBUG_ENTER("ndb_mgm_set_clusterlog_loglevel");
   DBUG_PRINT("enter",("node=%d, category=%d, level=%d", nodeId, cat, level));
 
   BaseString result;
@@ -1157,7 +1158,7 @@ ndb_mgm_set_loglevel_node(NdbMgmHandle handle, int nodeId,
 
 extern "C"
 int
-ndb_mgm_listen_event(NdbMgmHandle handle, int filter[])
+ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
 {
   SET_ERROR(handle, NDB_MGM_NO_ERROR, "Executing: ndb_mgm_listen_event");
   const ParserRow<ParserDummy> stat_reply[] = {
@@ -1195,7 +1196,10 @@ ndb_mgm_listen_event(NdbMgmHandle handle, int filter[])
   
   handle->socket = tmp;
   
-  CHECK_REPLY(reply, -1);
+  if(reply == NULL) {
+    close(sockfd);
+    CHECK_REPLY(reply, -1);
+  }
   return sockfd;
 }
 

ndb/src/mgmclient/CommandInterpreter.cpp

@@ -1246,7 +1246,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
     DBUG_VOID_RETURN;
   }
 
-  enum ndb_mgm_clusterlog_level severity = NDB_MGM_CLUSTERLOG_ALL;
+  enum ndb_mgm_event_severity severity = NDB_MGM_EVENT_SEVERITY_ALL;
     
   char * tmpString = my_strdup(parameters,MYF(MY_WME));
   My_auto_ptr<char> ap1(tmpString);
@@ -1254,7 +1254,7 @@ CommandInterpreter::executeClusterLog(char* parameters)
   char * item = strtok_r(tmpString, " ", &tmpPtr);
   int enable;
 
-  Uint32 *enabled = ndb_mgm_get_logfilter(m_mgmsrv);
+  const unsigned int *enabled= ndb_mgm_get_logfilter(m_mgmsrv);
   if(enabled == NULL) {
     ndbout << "Couldn't get status" << endl;
     printError();
@@ -1276,8 +1276,8 @@ CommandInterpreter::executeClusterLog(char* parameters)
       printf("enabled[%d] = %d\n", i, enabled[i]);
 #endif
     ndbout << "Severities enabled: ";
-    for(i = 1; i < (int)NDB_MGM_CLUSTERLOG_ALL; i++) {
-      const char *str= ndb_mgm_get_clusterlog_level_string((ndb_mgm_clusterlog_level)i);
+    for(i = 1; i < (int)NDB_MGM_EVENT_SEVERITY_ALL; i++) {
+      const char *str= ndb_mgm_get_event_severity_string((ndb_mgm_event_severity)i);
       if (str == 0)
       {
 	DBUG_ASSERT(false);
@@ -1311,8 +1311,10 @@ CommandInterpreter::executeClusterLog(char* parameters)
   int res_enable;
   item = strtok_r(NULL, " ", &tmpPtr);
   if (item == NULL) {
-    res_enable= ndb_mgm_filter_clusterlog(m_mgmsrv,
-					  NDB_MGM_CLUSTERLOG_ON, enable, NULL);
+    res_enable=
+      ndb_mgm_set_clusterlog_severity_filter(m_mgmsrv,
+					     NDB_MGM_EVENT_SEVERITY_ON,
+					     enable, NULL);
     if (res_enable < 0)
     {
       ndbout << "Couldn't set filter" << endl;
@@ -1324,32 +1326,33 @@ CommandInterpreter::executeClusterLog(char* parameters)
   }
 
   do {
-    severity= NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL;
+    severity= NDB_MGM_ILLEGAL_EVENT_SEVERITY;
     if (strcasecmp(item, "ALL") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_ALL;	
+      severity = NDB_MGM_EVENT_SEVERITY_ALL;	
     } else if (strcasecmp(item, "ALERT") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_ALERT;
+      severity = NDB_MGM_EVENT_SEVERITY_ALERT;
     } else if (strcasecmp(item, "CRITICAL") == 0) { 
-      severity = NDB_MGM_CLUSTERLOG_CRITICAL;
+      severity = NDB_MGM_EVENT_SEVERITY_CRITICAL;
     } else if (strcasecmp(item, "ERROR") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_ERROR;
+      severity = NDB_MGM_EVENT_SEVERITY_ERROR;
     } else if (strcasecmp(item, "WARNING") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_WARNING;
+      severity = NDB_MGM_EVENT_SEVERITY_WARNING;
     } else if (strcasecmp(item, "INFO") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_INFO;
+      severity = NDB_MGM_EVENT_SEVERITY_INFO;
     } else if (strcasecmp(item, "DEBUG") == 0) {
-      severity = NDB_MGM_CLUSTERLOG_DEBUG;
+      severity = NDB_MGM_EVENT_SEVERITY_DEBUG;
     } else if (strcasecmp(item, "OFF") == 0 ||
 	       strcasecmp(item, "ON") == 0) {
       if (enable < 0) // only makes sense with toggle
-	severity = NDB_MGM_CLUSTERLOG_ON;
+	severity = NDB_MGM_EVENT_SEVERITY_ON;
     }
-    if (severity == NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL) {
+    if (severity == NDB_MGM_ILLEGAL_EVENT_SEVERITY) {
       ndbout << "Invalid severity level: " << item << endl;
       DBUG_VOID_RETURN;
     }
 
-    res_enable = ndb_mgm_filter_clusterlog(m_mgmsrv, severity, enable, NULL);
+    res_enable= ndb_mgm_set_clusterlog_severity_filter(m_mgmsrv, severity,
+						       enable, NULL);
     if (res_enable < 0)
     {
       ndbout << "Couldn't set filter" << endl;

ndb/src/mgmsrv/ConfigInfo.cpp

@@ -1105,6 +1105,18 @@ const ConfigInfo::ParamInfo ConfigInfo::m_ParamInfo[] = {
     "0",
     "15" },
 
+  {
+    CFG_LOGLEVEL_CONGESTION,
+    "LogLevelCongestion",
+    DB_TOKEN,
+    "Congestion info printed on stdout",
+    ConfigInfo::CI_USED,
+    false,
+    ConfigInfo::CI_INT,
+    "0",
+    "0",
+    "15" },
+
   {
     CFG_LOGLEVEL_ERROR,
     "LogLevelError",

ndb/src/mgmsrv/Services.cpp

@@ -1184,13 +1184,13 @@ MgmApiSession::startAll(Parser<MgmApiSession>::Context &,
 void
 MgmApiSession::setLogFilter(Parser_t::Context &ctx,
 			    const class Properties &args) {
-  Uint32 level;
+  Uint32 severity;
   Uint32 enable;
 
-  args.get("level", &level);
+  args.get("level", &severity);
   args.get("enable", &enable);
 
-  int result = m_mgmsrv.setEventLogFilter(level, enable);
+  int result = m_mgmsrv.setEventLogFilter(severity, enable);
 
   m_output->println("set logfilter reply");
   m_output->println("result: %d", result);