From 06216f6a737df6b14b53a9588cf9dac13f8e8cb8 Mon Sep 17 00:00:00 2001 From: "tomas@poseidon.ndb.mysql.com" <> Date: Sun, 9 Jan 2005 23:02:06 +0100 Subject: [PATCH] updated ndb_mgm test removed grep event and added congestion event more docs changed some naming, expecially regarding severities added config param for logevel for congestion --- mysql-test/ndb/basic.result | 10 +- mysql-test/ndb/restart.test | 2 +- ndb/include/kernel/LogLevel.hpp | 2 +- ndb/include/mgmapi/mgmapi.h | 170 ++++++++++++------ ndb/include/mgmapi/mgmapi_config_parameters.h | 2 +- ndb/src/common/debugger/EventLogger.cpp | 4 - ndb/src/mgmapi/mgmapi.cpp | 110 ++++++------ ndb/src/mgmsrv/ConfigInfo.cpp | 12 ++ ndb/src/mgmsrv/Services.cpp | 6 +- 9 files changed, 193 insertions(+), 125 deletions(-) diff --git a/mysql-test/ndb/basic.result b/mysql-test/ndb/basic.result index 5ebd20a7f83..9d2b18881b9 100644 --- a/mysql-test/ndb/basic.result +++ b/mysql-test/ndb/basic.result @@ -26,17 +26,17 @@ CONNECT [] Connect to management server (reconnect i QUIT Quit management client = ALERT | CRITICAL | ERROR | WARNING | INFO | DEBUG - = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | GREP | DEBUG | BACKUP + = STARTUP | SHUTDOWN | STATISTICS | CHECKPOINT | NODERESTART | CONNECTION | INFO | ERROR | CONGESTION | DEBUG | BACKUP = 0 - 15 = 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! diff --git a/mysql-test/ndb/restart.test b/mysql-test/ndb/restart.test index 6ea9e919368..4b4584dd739 100644 --- a/mysql-test/ndb/restart.test +++ b/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 diff --git a/ndb/include/kernel/LogLevel.hpp b/ndb/include/kernel/LogLevel.hpp index 3c2f349e0e1..382016ee761 100644 --- a/ndb/include/kernel/LogLevel.hpp +++ b/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 }; diff --git a/ndb/include/mgmapi/mgmapi.h b/ndb/include/mgmapi/mgmapi.h index 0e8ccdcb06f..24971b26461 100644 --- a/ndb/include/mgmapi/mgmapi.h +++ b/ndb/include/mgmapi/mgmapi.h @@ -27,7 +27,7 @@ * - Control the NDB Cluster log * - Perform other administrative tasks * - * @section General Concepts + * @section secMgmApiGeneral General Concepts * * Each MGM API function needs a management server handle * of type @ref NdbMgmHandle. @@ -64,6 +64,27 @@ * free((void*)state); * ndb_mgm_destroy_handle(&handle); * @endcode + * + * @section secLogEvents Log Events + * + * The database nodes and management server(s) regularly and on specific + * occations report on various log events that occurs in the cluster. These + * log events are written to the cluster log. Optionally a mgmapi client + * may listen to these events by using the method ndb_mgm_listen_event(). + * Each log event belongs to a category, @ref ndb_mgm_event_category, and + * has a severity, @ref ndb_mgm_event_severity, associated with it. Each + * log event also has a level (0-15) associated with it. + * + * Which log events that come out is controlled with ndb_mgm_listen_event(), + * ndb_mgm_set_clusterlog_loglevel(), and + * ndb_mgm_set_clusterlog_severity_filter(). + * + * Below is an example of how to listen to events related to backup. + * + * @code + * int filter[] = { 15, NDB_MGM_EVENT_CATEGORY_BACKUP, 0 }; + * int fd = ndb_mgm_listen_event(handle, filter); + * @endcode */ /** @addtogroup MGM_C_API @@ -325,92 +346,90 @@ extern "C" { #endif /** - * Log severities (used to filter the cluster log) + * Log event severities (used to filter the cluster log, + * ndb_mgm_set_clusterlog_severity_filter(), and filter listening to events + * ndb_mgm_listen_event()) */ - enum ndb_mgm_clusterlog_level { - NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1, + enum ndb_mgm_event_severity { + NDB_MGM_ILLEGAL_EVENT_SEVERITY = -1, /* must range from 0 and up, indexes into an array */ - /** Cluster log on*/ - NDB_MGM_CLUSTERLOG_ON = 0, + /** Cluster log on */ + NDB_MGM_EVENT_SEVERITY_ON = 0, /** Used in NDB Cluster developement */ - NDB_MGM_CLUSTERLOG_DEBUG = 1, + NDB_MGM_EVENT_SEVERITY_DEBUG = 1, /** Informational messages*/ - NDB_MGM_CLUSTERLOG_INFO = 2, + NDB_MGM_EVENT_SEVERITY_INFO = 2, /** Conditions that are not error condition, but might require handling */ - NDB_MGM_CLUSTERLOG_WARNING = 3, + NDB_MGM_EVENT_SEVERITY_WARNING = 3, /** Conditions that should be corrected */ - NDB_MGM_CLUSTERLOG_ERROR = 4, + NDB_MGM_EVENT_SEVERITY_ERROR = 4, /** Critical conditions, like device errors or out of resources */ - NDB_MGM_CLUSTERLOG_CRITICAL = 5, + NDB_MGM_EVENT_SEVERITY_CRITICAL = 5, /** A condition that should be corrected immediately, * such as a corrupted system */ - NDB_MGM_CLUSTERLOG_ALERT = 6, + NDB_MGM_EVENT_SEVERITY_ALERT = 6, /* must be next number, works as bound in loop */ /** All severities */ - NDB_MGM_CLUSTERLOG_ALL = 7 + NDB_MGM_EVENT_SEVERITY_ALL = 7 }; /** - * Log categories, used to set filter on the clusterlog using - * ndb_mgm_set_loglevel_clusterlog() + * Log event categories, used to set filter level on the log events using + * ndb_mgm_set_clusterlog_loglevel() and ndb_mgm_listen_event() */ enum ndb_mgm_event_category { /** - * Invalid + * Invalid log event category */ NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1, /** - * Events during all kinds of startups + * Log events during all kinds of startups */ NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP, /** - * Events during shutdown + * Log events during shutdown */ NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN, /** - * Transaction statistics (Job level, TCP/IP speed) + * Statistics log events */ NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS, /** - * Events regarding checkpoints + * Log events related to checkpoints */ NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT, /** - * Events during node restart + * Log events during node restart */ NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART, /** - * Events on connection between cluster nodes + * Log events related to connections between cluster nodes */ NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION, /** - * Backup events + * Backup related log events */ NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP, + /** + * Congestion related log events + */ + NDB_MGM_EVENT_CATEGORY_CONGESTION = CFG_LOGLEVEL_CONGESTION, +#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL /** * Loglevel debug */ NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG, +#endif /** - * Loglevel info + * Uncategorized log events (severity info) */ NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO, /** - * Loglevel warning - */ - NDB_MGM_EVENT_CATEGORY_WARNING = CFG_LOGLEVEL_WARNING, - /** - * Loglevel error + * Uncategorized log events (severity warning or higher) */ NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR, -#ifndef DOXYGEN_SHOULD_SKIP_INTERNAL - /** - * - */ - NDB_MGM_EVENT_CATEGORY_GREP = CFG_LOGLEVEL_GREP, -#endif #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL, NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL @@ -614,7 +633,7 @@ extern "C" { */ const char * ndb_mgm_get_node_status_string(enum ndb_mgm_node_status status); - const char * ndb_mgm_get_clusterlog_level_string(enum ndb_mgm_clusterlog_level); + const char * ndb_mgm_get_event_severity_string(enum ndb_mgm_event_severity); ndb_mgm_event_category ndb_mgm_match_event_category(const char *); const char * ndb_mgm_get_event_category_string(enum ndb_mgm_event_category); #endif @@ -740,27 +759,26 @@ extern "C" { /** @} *********************************************************************/ /** - * @name Functions: Logging + * @name Functions: Controlling Clusterlog output * @{ */ /** - * Filter cluster log + * Filter cluster log severities * * @param handle NDB management handle. - * @param level A cluster log level to filter. - * @param enable set 1=enable 0=disable + * @param severity A cluster log severity to filter. + * @param enable set 1=enable, 0=disable * @param reply Reply message. * * @return -1 on error. */ - int ndb_mgm_filter_clusterlog(NdbMgmHandle handle, - enum ndb_mgm_clusterlog_level level, - int enable, - struct ndb_mgm_reply* reply); - + int ndb_mgm_set_clusterlog_severity_filter(NdbMgmHandle handle, + enum ndb_mgm_event_severity severity, + int enable, + struct ndb_mgm_reply* reply); /** - * Get log filter + * Get clusterlog severity filter * * @param handle NDB management handle * @@ -768,14 +786,14 @@ extern "C" { * where each element contains * 1 if a severity is enabled and 0 if not. * A severity is stored at position - * ndb_mgm_clusterlog_level, - * for example the "error" level is stored in position - * [NDB_MGM_CLUSTERLOG_ERROR-1]. - * The first element in the vector signals - * whether the clusterlog - * is disabled or enabled. + * ndb_mgm_event_severity, + * for example the "error" severity is stored in + * position [NDB_MGM_EVENT_SEVERITY_ERROR]. + * The first element [NDB_MGM_EVENT_SEVERITY_ON] + * in the vector signals + * whether the clusterlog is disabled or enabled. */ - unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle handle); + const unsigned int *ndb_mgm_get_clusterlog_severity_filter(NdbMgmHandle handle); /** * Set log category and levels for the cluster log @@ -787,21 +805,29 @@ extern "C" { * @param reply Reply message. * @return -1 on error. */ - int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle handle, + int ndb_mgm_set_clusterlog_loglevel(NdbMgmHandle handle, int nodeId, enum ndb_mgm_event_category category, int level, struct ndb_mgm_reply* reply); + /** @} *********************************************************************/ /** - * Listen to log events + * @name Functions: Listening to log events + * @{ + */ + + /** + * Listen to log events. The are read from the return file descriptor + * and the format is textual, and the same as in the cluster log. * + * @param handle NDB management handle. * @param filter pairs of { level, ndb_mgm_event_category } that will be - * pushed to fd, level=0 ends lists + * pushed to fd, level=0 ends list. * * @return fd which events will be pushed to */ - int ndb_mgm_listen_event(NdbMgmHandle handle, int filter[]); + int ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[]); #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL /** @@ -941,6 +967,36 @@ extern "C" { int ndb_mgm_check_connection(NdbMgmHandle handle); #endif +#ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED + enum ndb_mgm_clusterlog_level { + NDB_MGM_ILLEGAL_CLUSTERLOG_LEVEL = -1, + NDB_MGM_CLUSTERLOG_ON = 0, + NDB_MGM_CLUSTERLOG_DEBUG = 1, + NDB_MGM_CLUSTERLOG_INFO = 2, + NDB_MGM_CLUSTERLOG_WARNING = 3, + NDB_MGM_CLUSTERLOG_ERROR = 4, + NDB_MGM_CLUSTERLOG_CRITICAL = 5, + NDB_MGM_CLUSTERLOG_ALERT = 6, + NDB_MGM_CLUSTERLOG_ALL = 7 + }; + inline + int ndb_mgm_filter_clusterlog(NdbMgmHandle h, + enum ndb_mgm_clusterlog_level s, + int e, struct ndb_mgm_reply* r) + { return ndb_mgm_set_clusterlog_severity_filter(h,(ndb_mgm_event_severity)s, + e,r); } + + inline + const unsigned int *ndb_mgm_get_logfilter(NdbMgmHandle h) + { return ndb_mgm_get_clusterlog_severity_filter(h); } + + inline + int ndb_mgm_set_loglevel_clusterlog(NdbMgmHandle h, int n, + enum ndb_mgm_event_category c, + int l, struct ndb_mgm_reply* r) + { return ndb_mgm_set_clusterlog_loglevel(h,n,c,l,r); } +#endif + #ifdef __cplusplus } #endif diff --git a/ndb/include/mgmapi/mgmapi_config_parameters.h b/ndb/include/mgmapi/mgmapi_config_parameters.h index 406bdb1a110..62fa24d3c04 100644 --- a/ndb/include/mgmapi/mgmapi_config_parameters.h +++ b/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 diff --git a/ndb/src/common/debugger/EventLogger.cpp b/ndb/src/common/debugger/EventLogger.cpp index 97945394690..fe11d776208 100644 --- a/ndb/src/common/debugger/EventLogger.cpp +++ b/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 }, diff --git a/ndb/src/mgmapi/mgmapi.cpp b/ndb/src/mgmapi/mgmapi.cpp index a5e01919781..9825185f88b 100644 --- a/ndb/src/mgmapi/mgmapi.cpp +++ b/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 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 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 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 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; } diff --git a/ndb/src/mgmsrv/ConfigInfo.cpp b/ndb/src/mgmsrv/ConfigInfo.cpp index 800ffe2e361..3dff1bea8ec 100644 --- a/ndb/src/mgmsrv/ConfigInfo.cpp +++ b/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", diff --git a/ndb/src/mgmsrv/Services.cpp b/ndb/src/mgmsrv/Services.cpp index 6295d82b3be..447bc8bdc2b 100644 --- a/ndb/src/mgmsrv/Services.cpp +++ b/ndb/src/mgmsrv/Services.cpp @@ -1184,13 +1184,13 @@ MgmApiSession::startAll(Parser::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);