MySQL Lists: commits: bk commit into 5.1 tree (mtaylor:1.2552)

List:	Commits	« Previous Message Next Message »
From:	Monty Taylor	Date:	March 15 2008 7:06pm
Subject:	bk commit into 5.1 tree (mtaylor:1.2552)
View as plain text
Below is the list of changes that have just been committed into a local
5.1 repository of mtaylor.  When mtaylor does a push these changes
will be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet@stripped, 2008-03-15 11:06:42-07:00, mtaylor@solace.(none) +13 -0
  Removed events and modified code to use the new and improved ndb_logevent.h.

  BitKeeper/deleted/.del-events.hpp@stripped, 2008-03-15 10:57:29-07:00, mtaylor@solace.(none)
+0 -0
    Delete: storage/ndb/include/mgmapi/events.hpp

  BitKeeper/deleted/.del-events.i@stripped, 2008-03-15 10:56:52-07:00, mtaylor@solace.(none) +0
-0
    Delete: storage/ndb/swig/mgmapi/events.i

  storage/ndb/include/Makefile.am@stripped, 2008-03-15 11:06:39-07:00, mtaylor@solace.(none)
+0 -1
    Removed events.h.

  storage/ndb/include/mgmapi/listeners.hpp@stripped, 2008-03-15 11:06:39-07:00,
mtaylor@solace.(none) +122 -123
    Removed events.h.
    Renamed event objects.

  storage/ndb/include/mgmapi/ndb_logevent.h@stripped, 2008-03-15 11:06:39-07:00,
mtaylor@solace.(none) +204 -204
    Removed events.h.
    Renamed event objects.

  storage/ndb/src/mgmapi/Makefile.am@stripped, 2008-03-15 11:06:39-07:00,
mtaylor@solace.(none) +1 -1
    Removed events.h.
    Renamed event objects.

  storage/ndb/swig/globals.i@stripped, 2008-03-15 11:06:39-07:00, mtaylor@solace.(none) +1 -1
    Renamed NdbMgmException to MgmApiException

  storage/ndb/swig/mgmapi/NdbLogEvent.i@stripped, 2008-03-15 11:06:39-07:00,
mtaylor@solace.(none) +117 -54
    Removed duplicated defines. 

  storage/ndb/swig/mgmapi/NdbLogEventManager.i@stripped, 2008-03-15 11:06:40-07:00,
mtaylor@solace.(none) +6 -6
    Renamed NdbMgmException to MgmApiException

  storage/ndb/swig/mgmapi/NdbMgm.i@stripped, 2008-03-15 11:06:40-07:00, mtaylor@solace.(none)
+19 -19
    Renamed NdbMgmException to MgmApiException

  storage/ndb/swig/mgmapi/NdbMgmFactory.i@stripped, 2008-03-15 11:06:40-07:00,
mtaylor@solace.(none) +2 -2
    Renamed NdbMgmException to MgmApiException

  storage/ndb/swig/mgmapi/listeners.i@stripped, 2008-03-15 11:06:40-07:00,
mtaylor@solace.(none) +1 -3
    Removed references to events.hpp. 
    Changed include path.

  storage/ndb/swig/mgmapi/mgmglobals.i@stripped, 2008-03-15 11:06:40-07:00,
mtaylor@solace.(none) +1 -329
    Removed extra unneeded definitions. 

diff -Nrup a/storage/ndb/include/Makefile.am b/storage/ndb/include/Makefile.am
--- a/storage/ndb/include/Makefile.am	2008-03-11 10:26:59 -07:00
+++ b/storage/ndb/include/Makefile.am	2008-03-15 11:06:39 -07:00
@@ -52,7 +52,6 @@ mgmapi/mgmapi_config_parameters.h \
 mgmapi/mgmapi_config_parameters_debug.h \
 mgmapi/ndb_logevent.h \
 mgmapi/ndbd_exit_codes.h \
-mgmapi/events.h \
 mgmapi/listeners.h \
 mgmapi/NdbEventListener.h
 
diff -Nrup a/storage/ndb/include/mgmapi/events.hpp b/storage/ndb/include/mgmapi/events.hpp
--- a/storage/ndb/include/mgmapi/events.hpp	2008-03-13 10:44:27 -07:00
+++ /dev/null	Wed Dec 31 16:00:00 196900
@@ -1,562 +0,0 @@
-/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2008 MySQL, Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-#ifndef events_hpp
-#define events_hpp
-
-#include "ndb_init.h"
-#include "mgmapi.h"
-#include "mgmapi_debug.h"
-
-class BaseEvent {
-  Ndb_logevent_type theType;
-  int theSourceNodeId;
-  Uint32 theEventTime;
-  ndb_mgm_event_category theCategory;
-  ndb_mgm_event_severity theSeverity;
-protected:
-  BaseEvent();
-public:
-  ndb_logevent event;
-  explicit BaseEvent(const ndb_logevent & theEvent);
-  Ndb_logevent_type getType();
-  int getSourceNodeId();
-  Uint32 getEventTime();
-  ndb_mgm_event_category getEventCategory();
-  ndb_mgm_event_severity getEventSeverity();
-};
-
-
-
-class Connected : public BaseEvent {
-public:
-  explicit Connected(const ndb_logevent & theEvent);
-  unsigned node;
-};
-
-class Disconnected : public BaseEvent {
-public:
-  explicit Disconnected(const ndb_logevent & theEvent);
-  unsigned node;
-};
-
-class CommunicationOpened : public BaseEvent {
-public:
-  explicit CommunicationOpened(const ndb_logevent & theEvent);
-  unsigned node;
-};
-
-class CommunicationClosed : public BaseEvent {
-public:
-  explicit CommunicationClosed(const ndb_logevent & theEvent);
-  unsigned node;
-};
-
-class ConnectedApiVersion : public BaseEvent {
-public:
-  explicit ConnectedApiVersion(const ndb_logevent & theEvent);
-  unsigned node;
-  unsigned version;
-};
-
-
-class GlobalCheckpointStarted : public BaseEvent {
-public:
-
-  unsigned gci;
-
-  explicit GlobalCheckpointStarted(const ndb_logevent & theEvent);
-};
-
-class GlobalCheckpointCompleted : public BaseEvent {
-public:
-
-  unsigned gci;
-
-  explicit GlobalCheckpointCompleted(const ndb_logevent & theEvent);
-};
-
-
-class LocalCheckpointStarted : public BaseEvent {
-public:
-
-  unsigned lci;
-  unsigned keepGci;
-  unsigned restoreGci;
-
-  explicit LocalCheckpointStarted(const ndb_logevent & theEvent);
-};
-
-class LocalCheckpointCompleted : public BaseEvent {
-public:
-
-  unsigned lci;
-
-  explicit LocalCheckpointCompleted(const ndb_logevent & theEvent);
-};
-
-class LCPStoppedInCalcKeepGci : public BaseEvent {
-public:
-  unsigned data;
-
-  explicit LCPStoppedInCalcKeepGci(const ndb_logevent & theEvent);
-};
-
-class LCPFragmentCompleted : public BaseEvent {
-public:
-  unsigned node;
-  unsigned tableId;
-  unsigned fragmentId;
-
-  explicit LCPFragmentCompleted(const ndb_logevent & theEvent);
-};
-
-class UndoLogBlocked : public BaseEvent {
-public:
-  unsigned accCount;
-  unsigned tupCount;
-
-  explicit UndoLogBlocked(const ndb_logevent & theEvent);
-};
-
-class NdbStartStarted : public BaseEvent {
-public:
-  unsigned version;
-
-  explicit NdbStartStarted(const ndb_logevent & theEvent);
-};
-
-class NdbStartCompleted : public BaseEvent {
-public:
-  unsigned version;
-
-  explicit NdbStartCompleted(const ndb_logevent & theEvent);
-};
-
-class STTORRYRecieved : public BaseEvent {
-public:
-  explicit STTORRYRecieved(const ndb_logevent & theEvent);
-};
-
-class StartPhaseCompleted : public BaseEvent {
-public:
-  unsigned phase;
-  unsigned startType;
-
-  explicit StartPhaseCompleted(const ndb_logevent & theEvent);
-};
-
-class CmRegConf : public BaseEvent {
-public:
-  unsigned ownId;
-  unsigned presidentId;
-  unsigned dynamicId;
-
-  explicit CmRegConf(const ndb_logevent & theEvent);
-};
-
-class CmRegRef : public BaseEvent {
-public:
-  unsigned ownId;
-  unsigned otherId;
-  unsigned cause;
-
-  explicit CmRegRef(const ndb_logevent & theEvent);
-};
-
-class FindNeighbours : public BaseEvent {
-public:
-  unsigned ownId;
-  unsigned leftId;
-  unsigned rightId;
-  unsigned dynamicId;
-
-  explicit FindNeighbours(const ndb_logevent & theEvent);
-};
-
-class NdbStopStarted : public BaseEvent {
-public:
-  unsigned stopType;
-
-  explicit NdbStopStarted(const ndb_logevent & theEvent);
-};
-
-class NdbStopCompleted : public BaseEvent {
-public:
-  unsigned action;
-  unsigned sigNum;
-
-  explicit NdbStopCompleted(const ndb_logevent & theEvent);
-};
-
-class NdbStopForced : public BaseEvent {
-public:
-  unsigned action;
-  unsigned signum;
-  unsigned error;
-  unsigned sphase;
-  unsigned extra;
-
-  explicit NdbStopForced(const ndb_logevent & theEvent);
-};
-
-class NdbStopAborted : public BaseEvent {
-public:
-
-  explicit NdbStopAborted(const ndb_logevent & theEvent);
-};
-
-class StartREDOLog : public BaseEvent {
-public:
-  unsigned node;
-  unsigned keepGci;
-  unsigned completedGci;
-  unsigned restorableGci;
-
-  explicit StartREDOLog(const ndb_logevent & theEvent);
-};
-
-class StartLog : public BaseEvent {
-public:
-  unsigned logPart;
-  unsigned startMb;
-  unsigned stopMb;
-  unsigned gci;
-
-  explicit StartLog(const ndb_logevent & theEvent);
-};
-
-class UNDORecordsExecuted : public BaseEvent {
-public:
-  unsigned block;
-  unsigned data1;
-  unsigned data2;
-  unsigned data3;
-  unsigned data4;
-  unsigned data5;
-  unsigned data6;
-  unsigned data7;
-  unsigned data8;
-  unsigned data9;
-  unsigned data10;
-
-  explicit UNDORecordsExecuted(const ndb_logevent & theEvent);
-};
-
-class NRCopyDict : public BaseEvent {
-public:
-
-  explicit  NRCopyDict(const ndb_logevent & theEvent);
-};
-
-class NRCopyDistr : public BaseEvent {
-public:
-
-  explicit NRCopyDistr(const ndb_logevent & theEvent);
-};
-
-class NRCopyFragsStarted : public BaseEvent {
-public:
-  unsigned destNode;
-
-  explicit NRCopyFragsStarted(const ndb_logevent & theEvent);
-};
-
-class NRCopyFragDone : public BaseEvent {
-public:
-  unsigned destNode;
-  unsigned tableId;
-  unsigned fragmentId;
-
-  explicit NRCopyFragDone(const ndb_logevent & theEvent);
-
-};
-
-class NRCopyFragsCompleted : public BaseEvent {
-public:
-  unsigned destNode;
-
-  explicit NRCopyFragsCompleted(const ndb_logevent & theEvent);
-
-};
-
-class NodeFailCompleted : public BaseEvent {
-public:
-  unsigned block; /* 0 = all */
-  unsigned failedNode;
-  unsigned completingNode; /* 0 = all */
-
-  explicit NodeFailCompleted(const ndb_logevent & theEvent);
-
-};
-
-class NodeFailReported : public BaseEvent {
-public:
-  unsigned failedNode;
-  unsigned failureState;
-
-  explicit NodeFailReported(const ndb_logevent & theEvent);
-
-};
-
-class ArbitState : public BaseEvent {
-public:
-
-  unsigned code;                /* const code & state & << 16 ; */
-  unsigned arbitNode;
-  unsigned ticket0;
-  unsigned ticket1;
-
-  explicit ArbitState(const ndb_logevent & theEvent);
-
-};
-
-class ArbitResult : public BaseEvent {
-public:
-  unsigned code;                /* code & state << 16 */
-  unsigned arbitNode;
-  unsigned ticket0;
-  unsigned ticket1;
-
-  explicit ArbitResult(const ndb_logevent & theEvent);
-
-};
-
-class GCPTakeoverStarted : public BaseEvent {
-public:
-
-  explicit GCPTakeoverStarted(const ndb_logevent & theEvent);
-};
-
-class GCPTakeoverCompleted : public BaseEvent {
-public:
-
-  explicit GCPTakeoverCompleted(const ndb_logevent & theEvent);
-};
-
-class LCPTakeoverStarted : public BaseEvent {
-public:
-
-  explicit LCPTakeoverStarted(const ndb_logevent & theEvent);
-};
-
-class LCPTakeoverCompleted : public BaseEvent {
-public:
-  unsigned state;
-
-  explicit LCPTakeoverCompleted(const ndb_logevent & theEvent);
-};
-
-class TransReportCounters : public BaseEvent {
-public:
-  unsigned transCount;
-  unsigned commitCount;
-  unsigned readCount;
-  unsigned simpleReadCount;
-  unsigned writeCount;
-  unsigned attrinfoCount;
-  unsigned concOpCount;
-  unsigned abortCount;
-  unsigned scanCount;
-  unsigned rangeScanCount;
-
-  explicit TransReportCounters(const ndb_logevent & theEvent);
-
-};
-
-class OperationReportCounters : public BaseEvent {
-public:
-  unsigned ops;
-
-  explicit OperationReportCounters(const ndb_logevent & theEvent);
-
-};
-
-class TableCreated : public BaseEvent {
-public:
-  unsigned tableId;
-
-  explicit TableCreated(const ndb_logevent & theEvent);
-};
-
-class JobStatistic : public BaseEvent {
-public:
-  unsigned meanLoopCount;
-
-  explicit JobStatistic(const ndb_logevent & theEvent);
-};
-
-class SendBytesStatistic : public BaseEvent {
-public:
-  unsigned toNode;
-  unsigned meanSentBytes;
-
-  explicit SendBytesStatistic(const ndb_logevent & theEvent);
-};
-
-class ReceiveBytesStatistic : public BaseEvent {
-public:
-  unsigned fromNode;
-  unsigned meanReceivedBytes;
-
-  explicit ReceiveBytesStatistic(const ndb_logevent & theEvent);
-};
-
-class MemoryUsage : public BaseEvent {
-public:
-  int      gth;
-  unsigned pageSizeKb;
-  unsigned pagesUsed;
-  unsigned pagesTotal;
-  unsigned block;
-
-  explicit MemoryUsage(const ndb_logevent & theEvent);
-};
-
-class TransporterError : public BaseEvent {
-public:
-  unsigned toNode;
-  unsigned code;
-
-  explicit TransporterError(const ndb_logevent & theEvent);
-};
-
-class TransporterWarning : public BaseEvent {
-public:
-  unsigned toNode;
-  unsigned code;
-
-  explicit TransporterWarning(const ndb_logevent & theEvent);
-};
-
-class MissedHeartbeat : public BaseEvent {
-public:
-  unsigned node;
-  unsigned count;
-
-  explicit MissedHeartbeat(const ndb_logevent & theEvent);
-};
-
-class DeadDueToHeartbeat : public BaseEvent {
-public:
-  unsigned node;
-
-  explicit DeadDueToHeartbeat(const ndb_logevent & theEvent);
-};
-
-class Warning : public BaseEvent {
-public:
-
-  explicit Warning(const ndb_logevent & theEvent);
-};
-
-class SentHeartbeat : public BaseEvent {
-public:
-  unsigned node;
-
-  explicit SentHeartbeat(const ndb_logevent & theEvent);
-};
-
-class CreateLogBytes : public BaseEvent {
-public:
-  unsigned node;
-
-  explicit CreateLogBytes(const ndb_logevent & theEvent);
-};
-
-class InfoEvent : public BaseEvent {
-public:
-
-  explicit InfoEvent(const ndb_logevent & theEvent);
-};
-
-class EventBufferStatus : public BaseEvent {
-public:
-  unsigned usage;
-  unsigned alloc;
-  unsigned max;
-  unsigned applyGciL;
-  unsigned applyGciH;
-  unsigned latestGciL;
-  unsigned latestGciH;
-
-  explicit EventBufferStatus(const ndb_logevent & theEvent);
-};
-
-
-class BackupStarted : public BaseEvent {
-public:
-  unsigned startingNode;
-  unsigned backupId;
-
-  explicit BackupStarted(const ndb_logevent & theEvent);
-};
-
-class BackupFailedToStart : public BaseEvent {
-public:
-  unsigned startingNode;
-  unsigned error;
-
-  explicit BackupFailedToStart(const ndb_logevent & theEvent);
-};
-
-class BackupCompleted : public BaseEvent {
-public:
-  unsigned startingNode;
-  unsigned backupId;
-  unsigned startGci;
-  unsigned stopGci;
-  unsigned numRecords;
-  unsigned numLogRecords;
-  unsigned numBytes;
-  unsigned numLogBytes;
-
-  explicit BackupCompleted(const ndb_logevent & theEvent);
-};
-
-class BackupAborted : public BaseEvent {
-public:
-  unsigned startingNode;
-  unsigned backupId;
-  unsigned error;
-
-  explicit BackupAborted(const ndb_logevent & theEvent);
-};
-
-class SingleUser : public BaseEvent {
-public:
-  unsigned eventType;
-  unsigned nodeId;
-
-  explicit SingleUser(const ndb_logevent & theEvent);
-};
-
-class StartReport : public BaseEvent {
-public:
-  unsigned reportType;
-  unsigned remainingTime;
-  unsigned bitmaskSize;
-  //unsigned bitmaskData[1];
-
-  explicit StartReport(const ndb_logevent & theEvent);
-};
-
-
-#endif
diff -Nrup a/storage/ndb/include/mgmapi/listeners.hpp
b/storage/ndb/include/mgmapi/listeners.hpp
--- a/storage/ndb/include/mgmapi/listeners.hpp	2008-03-13 10:44:27 -07:00
+++ b/storage/ndb/include/mgmapi/listeners.hpp	2008-03-15 11:06:39 -07:00
@@ -25,7 +25,6 @@
 #include "mgmapi.h"
 #include "mgmapi_debug.h"
 
-#include "events.hpp"
 #include "NdbEventListener.hpp"
 
 
@@ -33,11 +32,11 @@ class ArbitResultTypeListener : public N
 
 private:
 
-  ArbitResult * wrappedEvent;
+  ArbitResultEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(ArbitResult * event) {};
+  virtual void handleEvent(ArbitResultEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -49,11 +48,11 @@ class  ArbitStateTypeListener : public N
 
 private:
 
-  ArbitState * wrappedEvent;
+  ArbitStateEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(ArbitState * event) {};
+  virtual void handleEvent(ArbitStateEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -65,11 +64,11 @@ class BackupAbortedTypeListener : public
 
 private:
 
-  BackupAborted * wrappedEvent;
+  BackupAbortedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(BackupAborted * event) {};
+  virtual void handleEvent(BackupAbortedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -79,11 +78,11 @@ class BackupCompletedTypeListener : publ
 
 private:
 
-  BackupCompleted * wrappedEvent;
+  BackupCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(BackupCompleted * event) {};
+  virtual void handleEvent(BackupCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -93,11 +92,11 @@ class BackupFailedToStartTypeListener : 
 
 private:
 
-  BackupFailedToStart * wrappedEvent;
+  BackupFailedToStartEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(BackupFailedToStart * event) {};
+  virtual void handleEvent(BackupFailedToStartEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -107,11 +106,11 @@ class BackupStartedTypeListener : public
 
 private:
 
-  BackupStarted * wrappedEvent;
+  BackupStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(BackupStarted * event) {};
+  virtual void handleEvent(BackupStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -121,11 +120,11 @@ class CmRegConfTypeListener : public Ndb
 
 private:
 
-  CmRegConf * wrappedEvent;
+  CmRegConfEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(CmRegConf * event) {};
+  virtual void handleEvent(CmRegConfEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -135,11 +134,11 @@ class CmRegRefTypeListener : public NdbL
 
 private:
 
-  CmRegRef * wrappedEvent;
+  CmRegRefEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(CmRegRef * event) {};
+  virtual void handleEvent(CmRegRefEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -149,11 +148,11 @@ class CommunicationClosedTypeListener : 
 
 private:
 
-  CommunicationClosed * wrappedEvent;
+  CommunicationClosedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(CommunicationClosed * event) {};
+  virtual void handleEvent(CommunicationClosedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -163,11 +162,11 @@ class CommunicationOpenedTypeListener : 
 
 private:
 
-  CommunicationOpened * wrappedEvent;
+  CommunicationOpenedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(CommunicationOpened * event) {};
+  virtual void handleEvent(CommunicationOpenedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -177,11 +176,11 @@ class ConnectedApiVersionTypeListener : 
 
 private:
 
-  ConnectedApiVersion * wrappedEvent;
+  ConnectedApiVersionEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(ConnectedApiVersion * event) {};
+  virtual void handleEvent(ConnectedApiVersionEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -191,11 +190,11 @@ class CreateLogBytesTypeListener : publi
 
 private:
 
-  CreateLogBytes * wrappedEvent;
+  CreateLogBytesEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(CreateLogBytes * event) {};
+  virtual void handleEvent(CreateLogBytesEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -205,11 +204,11 @@ class DeadDueToHeartbeatTypeListener : p
 
 private:
 
-  DeadDueToHeartbeat * wrappedEvent;
+  DeadDueToHeartbeatEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(DeadDueToHeartbeat * event) {};
+  virtual void handleEvent(DeadDueToHeartbeatEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -219,11 +218,11 @@ class ConnectedTypeListener : public Ndb
 
 private:
 
-  Connected * wrappedEvent;
+  ConnectedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(Connected * event) {};
+  virtual void handleEvent(ConnectedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -232,11 +231,11 @@ class DisconnectedTypeListener : public 
 
 private:
 
-  Disconnected * wrappedEvent;
+  DisconnectedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(Disconnected * event) {};
+  virtual void handleEvent(DisconnectedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -246,11 +245,11 @@ class EventBufferStatusTypeListener : pu
 
 private:
 
-  EventBufferStatus * wrappedEvent;
+  EventBufferStatusEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(EventBufferStatus * event) {};
+  virtual void handleEvent(EventBufferStatusEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -260,11 +259,11 @@ class FindNeighboursTypeListener : publi
 
 private:
 
-  FindNeighbours * wrappedEvent;
+  FindNeighboursEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(FindNeighbours * event) {};
+  virtual void handleEvent(FindNeighboursEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -274,11 +273,11 @@ class GCPTakeoverCompletedTypeListener :
 
 private:
 
-  GCPTakeoverCompleted * wrappedEvent;
+  GCPTakeoverCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(GCPTakeoverCompleted * event) {};
+  virtual void handleEvent(GCPTakeoverCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -288,11 +287,11 @@ class GCPTakeoverStartedTypeListener : p
 
 private:
 
-  GCPTakeoverStarted * wrappedEvent;
+  GCPTakeoverStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(GCPTakeoverStarted * event) {};
+  virtual void handleEvent(GCPTakeoverStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -302,11 +301,11 @@ class GlobalCheckpointCompletedTypeListe
 
 private:
 
-  GlobalCheckpointCompleted * wrappedEvent;
+  GlobalCheckpointCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(GlobalCheckpointCompleted * event) {};
+  virtual void handleEvent(GlobalCheckpointCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -316,11 +315,11 @@ class GlobalCheckpointStartedTypeListene
 
 private:
 
-  GlobalCheckpointStarted * wrappedEvent;
+  GlobalCheckpointStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(GlobalCheckpointStarted * event) {};
+  virtual void handleEvent(GlobalCheckpointStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -330,11 +329,11 @@ class InfoEventTypeListener : public Ndb
 
 private:
 
-  InfoEvent * wrappedEvent;
+  InfoEventEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(InfoEvent * event) {};
+  virtual void handleEvent(InfoEventEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -344,11 +343,11 @@ class JobStatisticTypeListener : public 
 
 private:
 
-  JobStatistic * wrappedEvent;
+  JobStatisticEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(JobStatistic * event) {};
+  virtual void handleEvent(JobStatisticEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -358,11 +357,11 @@ class LCPFragmentCompletedTypeListener :
 
 private:
 
-  LCPFragmentCompleted * wrappedEvent;
+  LCPFragmentCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LCPFragmentCompleted * event) {};
+  virtual void handleEvent(LCPFragmentCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -372,11 +371,11 @@ class LCPStoppedInCalcKeepGciTypeListene
 
 private:
 
-  LCPStoppedInCalcKeepGci * wrappedEvent;
+  LCPStoppedInCalcKeepGciEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LCPStoppedInCalcKeepGci * event) {};
+  virtual void handleEvent(LCPStoppedInCalcKeepGciEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -386,11 +385,11 @@ class LCPTakeoverCompletedTypeListener :
 
 private:
 
-  LCPTakeoverCompleted * wrappedEvent;
+  LCPTakeoverCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LCPTakeoverCompleted * event) {};
+  virtual void handleEvent(LCPTakeoverCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -400,11 +399,11 @@ class LCPTakeoverStartedTypeListener : p
 
 private:
 
-  LCPTakeoverStarted * wrappedEvent;
+  LCPTakeoverStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LCPTakeoverStarted * event) {};
+  virtual void handleEvent(LCPTakeoverStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -414,11 +413,11 @@ class LocalCheckpointCompletedTypeListen
 
 private:
 
-  LocalCheckpointCompleted * wrappedEvent;
+  LocalCheckpointCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LocalCheckpointCompleted * event) {};
+  virtual void handleEvent(LocalCheckpointCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -428,11 +427,11 @@ class LocalCheckpointStartedTypeListener
 
 private:
 
-  LocalCheckpointStarted * wrappedEvent;
+  LocalCheckpointStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(LocalCheckpointStarted * event) {};
+  virtual void handleEvent(LocalCheckpointStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -442,11 +441,11 @@ class MemoryUsageTypeListener : public N
 
 private:
 
-  MemoryUsage * wrappedEvent;
+  MemoryUsageEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(MemoryUsage * event) {};
+  virtual void handleEvent(MemoryUsageEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -456,11 +455,11 @@ class MissedHeartbeatTypeListener : publ
 
 private:
 
-  MissedHeartbeat * wrappedEvent;
+  MissedHeartbeatEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(MissedHeartbeat * event) {};
+  virtual void handleEvent(MissedHeartbeatEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -470,11 +469,11 @@ class NdbStartCompletedTypeListener : pu
 
 private:
 
-  NdbStartCompleted * wrappedEvent;
+  NdbStartCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStartCompleted * event) {};
+  virtual void handleEvent(NdbStartCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -484,11 +483,11 @@ class NdbStartStartedTypeListener : publ
 
 private:
 
-  NdbStartStarted * wrappedEvent;
+  NdbStartStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStartStarted * event) {};
+  virtual void handleEvent(NdbStartStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -498,11 +497,11 @@ class NdbStopAbortedTypeListener : publi
 
 private:
 
-  NdbStopAborted * wrappedEvent;
+  NdbStopAbortedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStopAborted * event) {};
+  virtual void handleEvent(NdbStopAbortedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -512,11 +511,11 @@ class NdbStopCompletedTypeListener : pub
 
 private:
 
-  NdbStopCompleted * wrappedEvent;
+  NdbStopCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStopCompleted * event) {};
+  virtual void handleEvent(NdbStopCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -526,11 +525,11 @@ class NdbStopForcedTypeListener : public
 
 private:
 
-  NdbStopForced * wrappedEvent;
+  NdbStopForcedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStopForced * event) {};
+  virtual void handleEvent(NdbStopForcedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -540,11 +539,11 @@ class NdbStopStartedTypeListener : publi
 
 private:
 
-  NdbStopStarted * wrappedEvent;
+  NdbStopStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NdbStopStarted * event) {};
+  virtual void handleEvent(NdbStopStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -554,11 +553,11 @@ class NodeFailCompletedTypeListener : pu
 
 private:
 
-  NodeFailCompleted * wrappedEvent;
+  NodeFailCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NodeFailCompleted * event) {};
+  virtual void handleEvent(NodeFailCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -568,11 +567,11 @@ class NodeFailReportedTypeListener : pub
 
 private:
 
-  NodeFailReported * wrappedEvent;
+  NodeFailReportedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NodeFailReported * event) {};
+  virtual void handleEvent(NodeFailReportedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -582,11 +581,11 @@ class NRCopyDictTypeListener : public Nd
 
 private:
 
-  NRCopyDict * wrappedEvent;
+  NRCopyDictEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NRCopyDict * event) {};
+  virtual void handleEvent(NRCopyDictEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -596,11 +595,11 @@ class NRCopyDistrTypeListener : public N
 
 private:
 
-  NRCopyDistr * wrappedEvent;
+  NRCopyDistrEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NRCopyDistr * event) {};
+  virtual void handleEvent(NRCopyDistrEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -610,11 +609,11 @@ class NRCopyFragDoneTypeListener : publi
 
 private:
 
-  NRCopyFragDone * wrappedEvent;
+  NRCopyFragDoneEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NRCopyFragDone * event) {};
+  virtual void handleEvent(NRCopyFragDoneEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -624,11 +623,11 @@ class NRCopyFragsCompletedTypeListener :
 
 private:
 
-  NRCopyFragsCompleted * wrappedEvent;
+  NRCopyFragsCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NRCopyFragsCompleted * event) {};
+  virtual void handleEvent(NRCopyFragsCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -638,11 +637,11 @@ class NRCopyFragsStartedTypeListener : p
 
 private:
 
-  NRCopyFragsStarted * wrappedEvent;
+  NRCopyFragsStartedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(NRCopyFragsStarted * event) {};
+  virtual void handleEvent(NRCopyFragsStartedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -652,11 +651,11 @@ class OperationReportCountersTypeListene
 
 private:
 
-  OperationReportCounters * wrappedEvent;
+  OperationReportCountersEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(OperationReportCounters * event) {};
+  virtual void handleEvent(OperationReportCountersEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -666,11 +665,11 @@ class ReceiveBytesStatisticTypeListener 
 
 private:
 
-  ReceiveBytesStatistic * wrappedEvent;
+  ReceiveBytesStatisticEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(ReceiveBytesStatistic * event) {};
+  virtual void handleEvent(ReceiveBytesStatisticEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -680,11 +679,11 @@ class SendBytesStatisticTypeListener : p
 
 private:
 
-  SendBytesStatistic * wrappedEvent;
+  SendBytesStatisticEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(SendBytesStatistic * event) {};
+  virtual void handleEvent(SendBytesStatisticEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -694,11 +693,11 @@ class SentHeartbeatTypeListener : public
 
 private:
 
-  SentHeartbeat * wrappedEvent;
+  SentHeartbeatEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(SentHeartbeat * event) {};
+  virtual void handleEvent(SentHeartbeatEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -708,11 +707,11 @@ class SingleUserTypeListener : public Nd
 
 private:
 
-  SingleUser * wrappedEvent;
+  SingleUserEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(SingleUser * event) {};
+  virtual void handleEvent(SingleUserEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -722,11 +721,11 @@ class StartLogTypeListener : public NdbL
 
 private:
 
-  StartLog * wrappedEvent;
+  StartLogEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(StartLog * event) {};
+  virtual void handleEvent(StartLogEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -736,11 +735,11 @@ class StartPhaseCompletedTypeListener : 
 
 private:
 
-  StartPhaseCompleted * wrappedEvent;
+  StartPhaseCompletedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(StartPhaseCompleted * event) {};
+  virtual void handleEvent(StartPhaseCompletedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -750,11 +749,11 @@ class StartREDOLogTypeListener : public 
 
 private:
 
-  StartREDOLog * wrappedEvent;
+  StartREDOLogEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(StartREDOLog * event) {};
+  virtual void handleEvent(StartREDOLogEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -764,11 +763,11 @@ class StartReportTypeListener : public N
 
 private:
 
-  StartReport * wrappedEvent;
+  StartReportEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(StartReport * event) {};
+  virtual void handleEvent(StartReportEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -778,11 +777,11 @@ class STTORRYRecievedTypeListener : publ
 
 private:
 
-  STTORRYRecieved * wrappedEvent;
+  STTORRYRecievedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(STTORRYRecieved * event) {};
+  virtual void handleEvent(STTORRYRecievedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -792,11 +791,11 @@ class TableCreatedTypeListener : public 
 
 private:
 
-  TableCreated * wrappedEvent;
+  TableCreatedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(TableCreated * event) {};
+  virtual void handleEvent(TableCreatedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -806,11 +805,11 @@ class TransporterErrorTypeListener : pub
 
 private:
 
-  TransporterError * wrappedEvent;
+  TransporterErrorEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(TransporterError * event) {};
+  virtual void handleEvent(TransporterErrorEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -820,11 +819,11 @@ class TransporterWarningTypeListener : p
 
 private:
 
-  TransporterWarning * wrappedEvent;
+  TransporterWarningEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(TransporterWarning * event) {};
+  virtual void handleEvent(TransporterWarningEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -834,11 +833,11 @@ class TransReportCountersTypeListener : 
 
 private:
 
-  TransReportCounters * wrappedEvent;
+  TransReportCountersEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(TransReportCounters * event) {};
+  virtual void handleEvent(TransReportCountersEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -848,11 +847,11 @@ class UndoLogBlockedTypeListener : publi
 
 private:
 
-  UndoLogBlocked * wrappedEvent;
+  UndoLogBlockedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(UndoLogBlocked * event) {};
+  virtual void handleEvent(UndoLogBlockedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -862,11 +861,11 @@ class UNDORecordsExecutedTypeListener : 
 
 private:
 
-  UNDORecordsExecuted * wrappedEvent;
+  UNDORecordsExecutedEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(UNDORecordsExecuted * event) {};
+  virtual void handleEvent(UNDORecordsExecutedEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
@@ -875,11 +874,11 @@ public:
 class WarningTypeListener : public NdbLogEventTypeListener {
 
 
-  Warning * wrappedEvent;
+  WarningEventEvent * wrappedEvent;
 
 public:
 
-  virtual void handleEvent(Warning * event) {};
+  virtual void handleEvent(WarningEventEvent * event) {};
   void le_handleEvent(const ndb_logevent & event);
   Ndb_logevent_type getEventType();
 
diff -Nrup a/storage/ndb/include/mgmapi/ndb_logevent.h
b/storage/ndb/include/mgmapi/ndb_logevent.h
--- a/storage/ndb/include/mgmapi/ndb_logevent.h	2008-03-12 09:09:15 -07:00
+++ b/storage/ndb/include/mgmapi/ndb_logevent.h	2008-03-15 11:06:39 -07:00
@@ -293,138 +293,138 @@ extern "C" {
 
   /* CONNECT */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct st_Connected {
+  typedef struct st_Connected {
     unsigned node;
-  };
+  } ConnectedEvent;
 
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_Disconnected {
+  typedef struct  st_Disconnected {
     unsigned node;
-  };
+  } DisconnectedEvent;
 
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_CommunicationClosed {
+  typedef struct  st_CommunicationClosed {
     unsigned node;
-  };
+  } CommunicationClosedEvent;
 
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_CommunicationOpened {
+  typedef struct  st_CommunicationOpened {
     unsigned node;
-  };
+  } CommunicationOpenedEvent;
 
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_ConnectedApiVersion{
+  typedef struct  st_ConnectedApiVersion{
     unsigned node;
     unsigned version;
-  };
+  } ConnectedApiVersionEvent;
 
   /* CHECKPOINT */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_GlobalCheckpointStarted{
+  typedef struct  st_GlobalCheckpointStarted{
     unsigned gci;
-  };
+  } GlobalCheckpointStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_GlobalCheckpointCompleted{
+  typedef struct  st_GlobalCheckpointCompleted{
     unsigned gci;
-  };
+  } GlobalCheckpointCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LocalCheckpointStarted{
+  typedef struct  st_LocalCheckpointStarted{
     unsigned lci;
     unsigned keep_gci;
     unsigned restore_gci;
-  };
+  } LocalCheckpointStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LocalCheckpointCompleted{
+  typedef struct  st_LocalCheckpointCompleted{
     unsigned lci;
-  };
+  } LocalCheckpointCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LCPStoppedInCalcKeepGci{
+  typedef struct  st_LCPStoppedInCalcKeepGci{
     unsigned data;
-  };
+  } LCPStoppedInCalcKeepGciEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LCPFragmentCompleted{
+  typedef struct  st_LCPFragmentCompleted{
     unsigned node;
     unsigned table_id;
     unsigned fragment_id;
-  };
+  } LCPFragmentCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_UndoLogBlocked{
+  typedef struct  st_UndoLogBlocked{
     unsigned acc_count;
     unsigned tup_count;
-  };
+  } UndoLogBlockedEvent;
 
   /* STARTUP */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStartStarted{
+  typedef struct  st_NDBStartStarted{
     unsigned version;
-  };
+  } NDBStartStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStartCompleted{
+  typedef struct  st_NDBStartCompleted{
     unsigned version;
-  };
+  } NDBStartCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_STTORRYRecieved{
-  };
+  typedef struct  st_STTORRYRecieved{
+  } STTORRYRecievedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_StartPhaseCompleted{
+  typedef struct  st_StartPhaseCompleted{
     unsigned phase;
     unsigned starttype;
-  };
+  } StartPhaseCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_CM_REGCONF{
+  typedef struct  st_CM_REGCONF{
     unsigned own_id;
     unsigned president_id;
     unsigned dynamic_id;
-  };
+  } CM_REGCONFEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_CM_REGREF{
+  typedef struct  st_CM_REGREF{
     unsigned own_id;
     unsigned other_id;
     unsigned cause;
-  };
+  } CM_REGREFEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_FIND_NEIGHBOURS{
+  typedef struct  st_FIND_NEIGHBOURS{
     unsigned own_id;
     unsigned left_id;
     unsigned right_id;
     unsigned dynamic_id;
-  };
+  } FIND_NEIGHBOURSEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStopStarted{
+  typedef struct  st_NDBStopStarted{
     unsigned stoptype;
-  };
+  } NDBStopStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStopCompleted{
+  typedef struct  st_NDBStopCompleted{
     unsigned action;
     unsigned signum;
-  };
+  } NDBStopCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStopForced{
+  typedef struct  st_NDBStopForced{
     unsigned action;
     unsigned signum;
     unsigned error;
     unsigned sphase;
     unsigned extra;
-  };
+  } NDBStopForcedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NDBStopAborted{
-  };
+  typedef struct  st_NDBStopAborted{
+  } NDBStopAbortedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_StartREDOLog{
+  typedef struct  st_StartREDOLog{
     unsigned node;
     unsigned keep_gci;
     unsigned completed_gci;
     unsigned restorable_gci;
-  };
+  } StartREDOLogEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_StartLog{
+  typedef struct  st_StartLog{
     unsigned log_part;
     unsigned start_mb;
     unsigned stop_mb;
     unsigned gci;
-  };
+  } StartLogEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_UNDORecordsExecuted{
+  typedef struct  st_UNDORecordsExecuted{
     unsigned block;
     unsigned data1;
     unsigned data2;
@@ -436,74 +436,74 @@ extern "C" {
     unsigned data8;
     unsigned data9;
     unsigned data10;
-  };
+  } UNDORecordsExecutedEvent;
 
   /* NODERESTART */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NR_CopyDict{
-  };
+  typedef struct  st_NR_CopyDict{
+  } NR_CopyDictEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NR_CopyDistr{
-  };
+  typedef struct  st_NR_CopyDistr{
+  } NR_CopyDistrEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NR_CopyFragsStarted{
+  typedef struct  st_NR_CopyFragsStarted{
     unsigned dest_node;
-  };
+  } NR_CopyFragsStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NR_CopyFragDone{
+  typedef struct  st_NR_CopyFragDone{
     unsigned dest_node;
     unsigned table_id;
     unsigned fragment_id;
-  };
+  } NR_CopyFragDoneEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NR_CopyFragsCompleted{
+  typedef struct  st_NR_CopyFragsCompleted{
     unsigned dest_node;
-  };
+  } NR_CopyFragsCompletedEvent;
 
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NodeFailCompleted{
+  typedef struct  st_NodeFailCompleted{
     unsigned block; /* 0 = all */
     unsigned failed_node;
     unsigned completing_node; /* 0 = all */
-  };
+  } NodeFailCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_NODE_FAILREP{
+  typedef struct  st_NODE_FAILREP{
     unsigned failed_node;
     unsigned failure_state;
-  };
+  } NODE_FAILREPEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_ArbitState{
+  typedef struct  st_ArbitState{
     unsigned code;                /* code & state << 16 */
     unsigned arbit_node;
     unsigned ticket_0;
     unsigned ticket_1;
     /* TODO */
-  };
+  } ArbitStateEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_ArbitResult{
+  typedef struct  st_ArbitResult{
     unsigned code;                /* code & state << 16 */
     unsigned arbit_node;
     unsigned ticket_0;
     unsigned ticket_1;
     /* TODO */
-  };
+  } ArbitResultEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_GCP_TakeoverStarted{
-  };
+  typedef struct  st_GCP_TakeoverStarted{
+  } GCP_TakeoverStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_GCP_TakeoverCompleted{
-  };
+  typedef struct  st_GCP_TakeoverCompleted{
+  } GCP_TakeoverCompletedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LCP_TakeoverStarted{
-  };
+  typedef struct  st_LCP_TakeoverStarted{
+  } LCP_TakeoverStartedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_LCP_TakeoverCompleted{
+  typedef struct  st_LCP_TakeoverCompleted{
     unsigned state;
-  };
+  } LCP_TakeoverCompletedEvent;
 
   /* STATISTIC */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_TransReportCounters{
+  typedef struct  st_TransReportCounters{
     unsigned trans_count;
     unsigned commit_count;
     unsigned read_count;
@@ -514,31 +514,31 @@ extern "C" {
     unsigned abort_count;
     unsigned scan_count;
     unsigned range_scan_count;
-  };
+  } TransReportCountersEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_OperationReportCounters{
+  typedef struct  st_OperationReportCounters{
     unsigned ops;
-  };
+  } OperationReportCountersEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_TableCreated{
+  typedef struct  st_TableCreated{
     unsigned table_id;
-  };
+  } TableCreatedEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_JobStatistic{
+  typedef struct  st_JobStatistic{
     unsigned mean_loop_count;
-  };
+  } JobStatisticEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_SendBytesStatistic{
+  typedef struct  st_SendBytesStatistic{
     unsigned to_node;
     unsigned mean_sent_bytes;
-  };
+  } SendBytesStatisticEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_ReceiveBytesStatistic{
+  typedef struct  st_ReceiveBytesStatistic{
     unsigned from_node;
     unsigned mean_received_bytes;
-  };
+  } ReceiveBytesStatisticEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_MemoryUsage{
+  typedef struct  st_MemoryUsage{
     int      gth;
     /* union is for compatibility backward.
      * page_size_kb member variable should be removed in the future
@@ -550,48 +550,48 @@ extern "C" {
     unsigned pages_used;
     unsigned pages_total;
     unsigned block;
-  };
+  } MemoryUsageEvent;
 
   /* ERROR */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_TransporterError{
+  typedef struct  st_TransporterError{
     unsigned to_node;
     unsigned code;
-  };
+  } TransporterErrorEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_TransporterWarning{
+  typedef struct  st_TransporterWarning{
     unsigned to_node;
     unsigned code;
-  };
+  } TransporterWarningEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_MissedHeartbeat{
+  typedef struct  st_MissedHeartbeat{
     unsigned node;
     unsigned count;
-  };
+  } MissedHeartbeatEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_DeadDueToHeartbeat{
+  typedef struct  st_DeadDueToHeartbeat{
     unsigned node;
-  };
+  } DeadDueToHeartbeatEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_WarningEvent{
+  typedef struct  st_WarningEventEvent{
     /* TODO */
-  };
+  } WarningEventEvent;
 
   /* INFO */
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_SentHeartbeat{
+  typedef struct  st_SentHeartbeat{
     unsigned node;
-  };
+  } SentHeartbeatEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_CreateLogBytes{
+  typedef struct  st_CreateLogBytes{
     unsigned node;
-  };
+  } CreateLogBytesEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_InfoEvent{
+  typedef struct  st_InfoEventEvent{
     /* TODO */
-  };
+  } InfoEventEvent;
   /** Log event specific data for for corresponding NDB_LE_ log event */
-  struct  st_EventBufferStatus{
+  typedef struct  st_EventBufferStatus{
     unsigned usage;
     unsigned alloc;
     unsigned max;
@@ -599,20 +599,20 @@ extern "C" {
     unsigned apply_gci_h;
     unsigned latest_gci_l;
     unsigned latest_gci_h;
-  };
+  } EventBufferStatusEvent;
 
   /** Log event data for @ref NDB_LE_BackupStarted */
-  struct  st_BackupStarted{
+  typedef struct  st_BackupStarted{
     unsigned starting_node;
     unsigned backup_id;
-  };
+  } BackupStartedEvent;
   /** Log event data @ref NDB_LE_BackupFailedToStart */
-  struct  st_BackupFailedToStart{
+  typedef struct  st_BackupFailedToStart{
     unsigned starting_node;
     unsigned error;
-  };
+  } BackupFailedToStartEvent;
   /** Log event data @ref NDB_LE_BackupCompleted */
-  struct  st_BackupCompleted{
+  typedef struct  st_BackupCompleted{
     unsigned starting_node;
     unsigned backup_id;
     unsigned start_gci;
@@ -625,9 +625,9 @@ extern "C" {
     unsigned n_log_records_hi;
     unsigned n_bytes_hi;
     unsigned n_log_bytes_hi;
-  };
+  } BackupCompletedEvent;
   /** Log event data @ref NDB_LE_BackupStatus */
-  struct  st_BackupStatus{
+  typedef struct  st_BackupStatus{
     unsigned starting_node;
     unsigned backup_id;
     unsigned n_records_lo;
@@ -638,20 +638,20 @@ extern "C" {
     unsigned n_bytes_hi;
     unsigned n_log_bytes_lo;
     unsigned n_log_bytes_hi;
-  };
+  } BackupStatusEvent;
   /** Log event data @ref NDB_LE_BackupAborted */
-  struct  st_BackupAborted{
+  typedef struct  st_BackupAborted{
     unsigned starting_node;
     unsigned backup_id;
     unsigned error;
-  };
+  } BackupAbortedEvent;
   /** Log event data @ref NDB_LE_RestoreStarted */
-  struct  st_RestoreStarted{
+  typedef struct  st_RestoreStarted{
     unsigned backup_id;
     unsigned node_id;
-  };
+  } RestoreStartedEvent;
   /** Log event data @ref NDB_LE_RestoreMetaData */
-  struct  st_RestoreMetaData{
+  typedef struct  st_RestoreMetaData{
     unsigned backup_id;
     unsigned node_id;
     unsigned n_tables;
@@ -659,47 +659,47 @@ extern "C" {
     unsigned n_logfilegroups;
     unsigned n_datafiles;
     unsigned n_undofiles;
-  };
+  } RestoreMetaDataEvent;
   /** Log event data @ref NDB_LE_RestoreData */
-  struct  st_RestoreData{
+  typedef struct  st_RestoreData{
     unsigned backup_id;
     unsigned node_id;
     unsigned n_records_lo;
     unsigned n_records_hi;
     unsigned n_bytes_lo;
     unsigned n_bytes_hi;
-  };
+  } RestoreDataEvent;
   /** Log event data @ref NDB_LE_RestoreLog */
-  struct  st_RestoreLog{
+  typedef struct  st_RestoreLog{
     unsigned backup_id;
     unsigned node_id;
     unsigned n_records_lo;
     unsigned n_records_hi;
     unsigned n_bytes_lo;
     unsigned n_bytes_hi;
-  };
+  } RestoreLogEvent;
   /** Log event data @ref NDB_LE_RestoreCompleted */
-  struct  st_RestoreCompleted{
+  typedef struct  st_RestoreCompleted{
     unsigned backup_id;
     unsigned node_id;
-  };
+  } RestoreCompletedEvent;
   /** Log event data @ref NDB_LE_SingleUser */
-  struct  st_SingleUser{
+  typedef struct  st_SingleUser{
     unsigned type;
     unsigned node_id;
-  };
+  } SingleUserEvent;
   /** Log even data @ref NDB_LE_StartReport */
-  struct  st_StartReport{
+  typedef struct  st_StartReport{
     unsigned report_type;
     unsigned remaining_time;
     unsigned bitmask_size;
     unsigned bitmask_data[1];
-  };
+  } StartReportEvent;
   /** Log event data @ref NDB_LE_SubscriptionStatus */
-  struct  st_SubscriptionStatus {
+  typedef struct  st_SubscriptionStatus {
     unsigned report_type;
     unsigned node_id;
-  };
+  } SubscriptionStatusEvent;
 
 
   /**
@@ -735,86 +735,86 @@ extern "C" {
      */
     union {
       /* CONNECT */
-      struct st_Connected Connected;
-      struct st_Disconnected Disconnected;
-      struct st_CommunicationClosed CommunicationClosed;
-      struct st_CommunicationOpened CommunicationOpened;
-      struct st_ConnectedApiVersion ConnectedApiVersion;
+      ConnectedEvent Connected;
+      DisconnectedEvent Disconnected;
+      CommunicationClosedEvent CommunicationClosed;
+      CommunicationOpenedEvent CommunicationOpened;
+      ConnectedApiVersionEvent ConnectedApiVersion;
 
       /* CHECKPOINT */
-      struct st_GlobalCheckpointStarted  GlobalCheckpointStarted;
-      struct st_GlobalCheckpointCompleted  GlobalCheckpointCompleted;
-      struct st_LocalCheckpointStarted  LocalCheckpointStarted;
-      struct st_LocalCheckpointCompleted  LocalCheckpointCompleted;
-      struct st_LCPStoppedInCalcKeepGci  LCPStoppedInCalcKeepGci;
-      struct st_LCPFragmentCompleted  LCPFragmentCompleted;
-      struct st_UndoLogBlocked  UndoLogBlocked;
+      GlobalCheckpointStartedEvent  GlobalCheckpointStarted;
+      GlobalCheckpointCompletedEvent  GlobalCheckpointCompleted;
+      LocalCheckpointStartedEvent  LocalCheckpointStarted;
+      LocalCheckpointCompletedEvent  LocalCheckpointCompleted;
+      LCPStoppedInCalcKeepGciEvent  LCPStoppedInCalcKeepGci;
+      LCPFragmentCompletedEvent  LCPFragmentCompleted;
+      UndoLogBlockedEvent  UndoLogBlocked;
 
       /* STARTUP */
-      struct st_NDBStartStarted  NDBStartStarted;
-      struct st_NDBStartCompleted  NDBStartCompleted;
-      struct st_STTORRYRecieved  STTORRYRecieved;
-      struct st_StartPhaseCompleted  StartPhaseCompleted;
-      struct st_CM_REGCONF  CM_REGCONF;
-      struct st_CM_REGREF  CM_REGREF;
-      struct st_FIND_NEIGHBOURS  FIND_NEIGHBOURS;
-      struct st_NDBStopStarted  NDBStopStarted;
-      struct st_NDBStopCompleted  NDBStopCompleted;
-      struct st_NDBStopForced  NDBStopForced;
-      struct st_NDBStopAborted  NDBStopAborted;
-      struct st_StartREDOLog  StartREDOLog;
-      struct st_StartLog  StartLog;
-      struct st_UNDORecordsExecuted  UNDORecordsExecuted;
+      NDBStartStartedEvent  NDBStartStarted;
+      NDBStartCompletedEvent  NDBStartCompleted;
+      STTORRYRecievedEvent  STTORRYRecieved;
+      StartPhaseCompletedEvent  StartPhaseCompleted;
+      CM_REGCONFEvent  CM_REGCONF;
+      CM_REGREFEvent  CM_REGREF;
+      FIND_NEIGHBOURSEvent  FIND_NEIGHBOURS;
+      NDBStopStartedEvent  NDBStopStarted;
+      NDBStopCompletedEvent  NDBStopCompleted;
+      NDBStopForcedEvent  NDBStopForced;
+      NDBStopAbortedEvent  NDBStopAborted;
+      StartREDOLogEvent  StartREDOLog;
+      StartLogEvent  StartLog;
+      UNDORecordsExecutedEvent  UNDORecordsExecuted;
 
       /* NODERESTART */
-      struct st_NR_CopyDict  NR_CopyDict;
-      struct st_NR_CopyDistr  NR_CopyDistr;
-      struct st_NR_CopyFragsStarted  NR_CopyFragsStarted;
-      struct st_NR_CopyFragDone  NR_CopyFragDone;
-      struct st_NR_CopyFragsCompleted  NR_CopyFragsCompleted;
-      struct st_NodeFailCompleted  NodeFailCompleted;
-      struct st_NODE_FAILREP  NODE_FAILREP;
-      struct st_ArbitState  ArbitState;
-      struct st_ArbitResult  ArbitResult;
-      struct st_GCP_TakeoverStarted  GCP_TakeoverStarted;
-      struct st_GCP_TakeoverCompleted  GCP_TakeoverCompleted;
-      struct st_LCP_TakeoverStarted  LCP_TakeoverStarted;
-      struct st_LCP_TakeoverCompleted  LCP_TakeoverCompleted;
+      NR_CopyDictEvent  NR_CopyDict;
+      NR_CopyDistrEvent  NR_CopyDistr;
+      NR_CopyFragsStartedEvent  NR_CopyFragsStarted;
+      NR_CopyFragDoneEvent  NR_CopyFragDone;
+      NR_CopyFragsCompletedEvent  NR_CopyFragsCompleted;
+      NodeFailCompletedEvent  NodeFailCompleted;
+      NODE_FAILREPEvent  NODE_FAILREP;
+      ArbitStateEvent  ArbitState;
+      ArbitResultEvent  ArbitResult;
+      GCP_TakeoverStartedEvent  GCP_TakeoverStarted;
+      GCP_TakeoverCompletedEvent  GCP_TakeoverCompleted;
+      LCP_TakeoverStartedEvent  LCP_TakeoverStarted;
+      LCP_TakeoverCompletedEvent  LCP_TakeoverCompleted;
 
       /* STATISTIC */
-      struct st_TransReportCounters  TransReportCounters;
-      struct st_OperationReportCounters  OperationReportCounters;
-      struct st_TableCreated  TableCreated;
-      struct st_JobStatistic  JobStatistic;
-      struct st_SendBytesStatistic  SendBytesStatistic;
-      struct st_ReceiveBytesStatistic  ReceiveBytesStatistic;
-      struct st_MemoryUsage  MemoryUsage;
+      TransReportCountersEvent  TransReportCounters;
+      OperationReportCountersEvent  OperationReportCounters;
+      TableCreatedEvent  TableCreated;
+      JobStatisticEvent  JobStatistic;
+      SendBytesStatisticEvent  SendBytesStatistic;
+      ReceiveBytesStatisticEvent  ReceiveBytesStatistic;
+      MemoryUsageEvent  MemoryUsage;
 
       /* ERROR */
-      struct st_TransporterError  TransporterError;
-      struct st_TransporterWarning  TransporterWarning;
-      struct st_MissedHeartbeat  MissedHeartbeat;
-      struct st_DeadDueToHeartbeat  DeadDueToHeartbeat;
-      struct st_WarningEvent  WarningEvent;
+      TransporterErrorEvent  TransporterError;
+      TransporterWarningEvent  TransporterWarning;
+      MissedHeartbeatEvent  MissedHeartbeat;
+      DeadDueToHeartbeatEvent  DeadDueToHeartbeat;
+      WarningEventEvent  WarningEvent;
 
       /* INFO */
-      struct st_SentHeartbeat  SentHeartbeat;
-      struct st_CreateLogBytes  CreateLogBytes;
-      struct st_InfoEvent  InfoEvent;
-      struct st_EventBufferStatus  EventBufferStatus;
-      struct st_BackupStarted  BackupStarted;
-      struct st_BackupFailedToStart  BackupFailedToStart;
-      struct st_BackupCompleted  BackupCompleted;
-      struct st_BackupStatus  BackupStatus;
-      struct st_BackupAborted  BackupAborted;
-      struct st_RestoreStarted  RestoreStarted;
-      struct st_RestoreMetaData  RestoreMetaData;
-      struct st_RestoreData  RestoreData;
-      struct st_RestoreLog  RestoreLog;
-      struct st_RestoreCompleted  RestoreCompleted;
-      struct st_SingleUser  SingleUser;
-      struct st_StartReport  StartReport;
-      struct st_SubscriptionStatus  SubscriptionStatus;
+      SentHeartbeatEvent  SentHeartbeat;
+      CreateLogBytesEvent  CreateLogBytes;
+      InfoEventEvent  InfoEvent;
+      EventBufferStatusEvent  EventBufferStatus;
+      BackupStartedEvent  BackupStarted;
+      BackupFailedToStartEvent  BackupFailedToStart;
+      BackupCompletedEvent  BackupCompleted;
+      BackupStatusEvent  BackupStatus;
+      BackupAbortedEvent  BackupAborted;
+      RestoreStartedEvent  RestoreStarted;
+      RestoreMetaDataEvent  RestoreMetaData;
+      RestoreDataEvent  RestoreData;
+      RestoreLogEvent  RestoreLog;
+      RestoreCompletedEvent  RestoreCompleted;
+      SingleUserEvent  SingleUser;
+      StartReportEvent  StartReport;
+      SubscriptionStatusEvent  SubscriptionStatus;
 #ifndef DOXYGEN_FIX
     };
 #else
diff -Nrup a/storage/ndb/src/mgmapi/Makefile.am b/storage/ndb/src/mgmapi/Makefile.am
--- a/storage/ndb/src/mgmapi/Makefile.am	2008-03-11 10:26:59 -07:00
+++ b/storage/ndb/src/mgmapi/Makefile.am	2008-03-15 11:06:39 -07:00
@@ -17,7 +17,7 @@ MYSQLCLUSTERdir=        .
 
 noinst_LTLIBRARIES = libmgmapi.la
 
-libmgmapi_la_SOURCES = mgmapi.cpp ndb_logevent.cpp mgmapi_configuration.cpp
LocalConfig.cpp ../kernel/error/ndbd_exit_codes.c ../mgmsrv/ConfigInfo.cpp events.cpp
listeners.cpp NdbEventListener.cpp 
+libmgmapi_la_SOURCES = mgmapi.cpp ndb_logevent.cpp mgmapi_configuration.cpp
LocalConfig.cpp ../kernel/error/ndbd_exit_codes.c ../mgmsrv/ConfigInfo.cpp 
 
 INCLUDES_LOC = -I$(top_srcdir)/storage/ndb/include/mgmapi
 
diff -Nrup a/storage/ndb/swig/globals.i b/storage/ndb/swig/globals.i
--- a/storage/ndb/swig/globals.i	2008-03-11 08:27:22 -07:00
+++ b/storage/ndb/swig/globals.i	2008-03-15 11:06:39 -07:00
@@ -64,7 +64,7 @@
     NoSuchColumnException,
     NoSuchIndexException,
     NoSuchTableException,
-    NdbMgmException,
+    MgmApiException,
     InvalidSchemaObjectVersionException,
   };
   %}
diff -Nrup a/storage/ndb/swig/mgmapi/NdbLogEvent.i b/storage/ndb/swig/mgmapi/NdbLogEvent.i
--- a/storage/ndb/swig/mgmapi/NdbLogEvent.i	2008-03-11 08:27:23 -07:00
+++ b/storage/ndb/swig/mgmapi/NdbLogEvent.i	2008-03-15 11:06:39 -07:00
@@ -18,69 +18,132 @@
  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-/** Log event specific data for for corresponding NDB_LE_ log event */
-
 /**
  * The NdbLogevent
  */
 %rename ndb_logevent NdbLogEvent;
-
-class ndb_logevent {
-
-  /** NdbLogEventHandle (to be used for comparing only)
-   *  set in ndb_logevent_get_next()
-   */
-  void *handle;
-
-  /** Which event */
-  enum Ndb_logevent_type type;
-
-  /** Time when log event was registred at the management server */
-  unsigned time;
-
-  /** Category of log event */
-  enum ndb_mgm_event_category category;
-
-  /** Severity of log event */
-  enum ndb_mgm_event_severity severity;
-
-  /** Level (0-15) of log event */
-  unsigned level;
-
-  /** Node ID of the node that reported the log event */
-  unsigned source_nodeid;
-
-};
+%rename ndb_logevent_detail NdbLogEventDetail;
+%rename ndb_logevent_handle_error NdbLogEventHandleError;
+%rename source_nodeid sourceNodeId;
+
+
+%rename FIND_NEIGHBOURS FindNeighbours;
+%rename CM_REGCONF CmRegConf;
+%rename CM_REGREF CmRegRef;
+%rename NODE_FAILREP NodeFailReport;
+%rename GCPTakeoverStarted GCP_TakeoverStarted;
+%rename GCPTakeoverCompleted GCP_TakeoverCompleted;
+%rename LCPTakeoverStarted LCP_TakeoverStarted;
+%rename LCPTakeoverCompleted LCP_TakeoverCompleted;
+
+%immutable;
+%include "ndb_logevent.h"
+%mutable;
+
+
+%define %EVENT(event)
+event ## Event * get ## event () {
+  if ($self->type == NDB_LE_ ## event) {
+    return &($self->event);
+  }
+  return NULL;
+ }
+%enddef
 
 %extend ndb_logevent {
 
 public:
 
-  Ndb_logevent_type getEventType() {
-    return $self->type;
-  }
-
-  ndb_mgm_event_category getEventCategory() {
-    return $self->category;
-  }
-
-  ndb_mgm_event_severity getEventSeverity() {
-    return $self->severity;
-  }
-
-  Uint32 getSourceNodeId() {
-    return $self->source_nodeid;
-  }
-
-  Uint32 getEventTime() {
-    return $self->time;
-  }
-
-  Uint32 getEventLevel() {
-    return $self->level;
-  }
-
-};
+  %ndbexception("MgmApiException") {
+     $action
+       if (result == NULL) {
+         NDB_exception(MgmApiException,
+                       "Invalid method called for this event type");
+       }
+   }
+
+  %EVENT(Connected);
+  %EVENT(Disconnected);
+  %EVENT(CommunicationClosed);
+  %EVENT(CommunicationOpened);
+  %EVENT(ConnectedApiVersion);
+
+  /* CHECKPOINT */
+  %EVENT(GlobalCheckpointStarted);
+  %EVENT(GlobalCheckpointCompleted);
+  %EVENT(LocalCheckpointStarted);
+  %EVENT(LocalCheckpointCompleted);
+  %EVENT(LCPStoppedInCalcKeepGci);
+  %EVENT(LCPFragmentCompleted);
+  %EVENT(UndoLogBlocked);
+
+  /* STARTUP */
+  %EVENT(NDBStartStarted);
+  %EVENT(NDBStartCompleted);
+  %EVENT(STTORRYRecieved);
+  %EVENT(StartPhaseCompleted);
+  %EVENT(CM_REGCONF);
+  %EVENT(CM_REGREF);
+  %EVENT(FIND_NEIGHBOURS);
+  %EVENT(NDBStopStarted);
+  %EVENT(NDBStopCompleted);
+  %EVENT(NDBStopForced);
+  %EVENT(NDBStopAborted);
+  %EVENT(StartREDOLog);
+  %EVENT(StartLog);
+  %EVENT(UNDORecordsExecuted);
+
+  /* NODERESTART */
+  %EVENT(NR_CopyDict);
+  %EVENT(NR_CopyDistr);
+  %EVENT(NR_CopyFragsStarted);
+  %EVENT(NR_CopyFragDone);
+  %EVENT(NR_CopyFragsCompleted);
+  %EVENT(NodeFailCompleted);
+  %EVENT(NODE_FAILREP);
+  %EVENT(ArbitState);
+  %EVENT(ArbitResult);
+  %EVENT(GCP_TakeoverStarted);
+  %EVENT(GCP_TakeoverCompleted);
+  %EVENT(LCP_TakeoverStarted);
+  %EVENT(LCP_TakeoverCompleted);
+
+  /* STATISTIC */
+  %EVENT(TransReportCounters);
+  %EVENT(OperationReportCounters);
+  %EVENT(TableCreated);
+  %EVENT(JobStatistic);
+  %EVENT(SendBytesStatistic);
+  %EVENT(ReceiveBytesStatistic);
+  %EVENT(MemoryUsage);
+
+  /* ERROR */
+  %EVENT(TransporterError);
+  %EVENT(TransporterWarning);
+  %EVENT(MissedHeartbeat);
+  %EVENT(DeadDueToHeartbeat);
+  %EVENT(WarningEvent);
+
+  /* INFO */
+  %EVENT(SentHeartbeat);
+  %EVENT(CreateLogBytes);
+  %EVENT(InfoEvent);
+  %EVENT(EventBufferStatus);
+  %EVENT(BackupStarted);
+  %EVENT(BackupFailedToStart);
+  %EVENT(BackupCompleted);
+  %EVENT(BackupStatus);
+  %EVENT(BackupAborted);
+  %EVENT(RestoreStarted);
+  %EVENT(RestoreMetaData);
+  %EVENT(RestoreData);
+  %EVENT(RestoreLog);
+  %EVENT(RestoreCompleted);
+  %EVENT(SingleUser);
+  %EVENT(StartReport);
+  %EVENT(SubscriptionStatus);
 
+  %ndbnoexception
 
+ };
 
diff -Nrup a/storage/ndb/swig/mgmapi/NdbLogEventManager.i
b/storage/ndb/swig/mgmapi/NdbLogEventManager.i
--- a/storage/ndb/swig/mgmapi/NdbLogEventManager.i	2008-03-11 08:27:24 -07:00
+++ b/storage/ndb/swig/mgmapi/NdbLogEventManager.i	2008-03-15 11:06:40 -07:00
@@ -57,28 +57,28 @@ public:
   bool unregisterListener(NdbLogEventTypeListener * listener);
   bool unregisterListener(NdbLogEventCategoryListener * listener);
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result < 0) {
-        NDB_exception(NdbMgmException,"Must deregister handler before adding a new one");
+        NDB_exception(MgmApiException,"Must deregister handler before adding a new one");
       }
   }
   int registerListener(NdbLogEventTypeListener * listener);
   int registerListener(NdbLogEventCategoryListener * listener);
 
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result->ret < 0) {
-        NDB_exception(NdbMgmException,arg1->getMgmError());
+        NDB_exception(MgmApiException,arg1->getMgmError());
       }
   }
   BaseEventWrapper * getLogEvent(unsigned timeout_in_milliseconds);
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result < 0) {
-        NDB_exception(NdbMgmException,arg1->getMgmError());
+        NDB_exception(MgmApiException,arg1->getMgmError());
       }
   }
   int pollEvents(unsigned timeout_in_milliseconds);
diff -Nrup a/storage/ndb/swig/mgmapi/NdbMgm.i b/storage/ndb/swig/mgmapi/NdbMgm.i
--- a/storage/ndb/swig/mgmapi/NdbMgm.i	2008-03-11 08:27:24 -07:00
+++ b/storage/ndb/swig/mgmapi/NdbMgm.i	2008-03-15 11:06:40 -07:00
@@ -130,12 +130,12 @@ public:
     ndb_mgm_set_name($self, name);
   }
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == -1) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
   /** @} *********************************************************************/
@@ -286,12 +286,12 @@ public:
     return ( ndb_mgm_is_connected($self) == 0 ) ? false : true ;
   }
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == NULL) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -326,12 +326,12 @@ public:
    *                          wait_completed == 0
    */
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result->theReply == NULL) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -364,12 +364,12 @@ public:
    * @param   backup_id     Backup ID.
    * @return                Reply message. NULL on error.
    */
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == NULL) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -407,14 +407,14 @@ public:
   }
 
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result != NULL && result->return_code < 0) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
-        NDB_exception(NdbMgmException,result->message);
+        NDB_exception(MgmApiException,result->message);
       } else if (result == NULL) {
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -474,12 +474,12 @@ public:
   }
 
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == -1) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -651,12 +651,12 @@ public:
    * @{
    */
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == -1) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -715,12 +715,12 @@ public:
   //int ndb_mgm_listen_event(NdbMgmHandle handle, const int filter[])
 
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result == NULL) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
@@ -822,12 +822,12 @@ public:
 
   }
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result < 0) {
         //int errCode = ndb_mgm_get_latest_error(arg1);
         const char * errMsg = ndb_mgm_get_latest_error_msg(arg1);
-        NDB_exception(NdbMgmException,errMsg);
+        NDB_exception(MgmApiException,errMsg);
       }
   }
 
diff -Nrup a/storage/ndb/swig/mgmapi/NdbMgmFactory.i
b/storage/ndb/swig/mgmapi/NdbMgmFactory.i
--- a/storage/ndb/swig/mgmapi/NdbMgmFactory.i	2008-03-11 08:27:25 -07:00
+++ b/storage/ndb/swig/mgmapi/NdbMgmFactory.i	2008-03-15 11:06:40 -07:00
@@ -53,10 +53,10 @@ class NdbMgmFactory
   ~NdbMgmFactory();
 public:
 
-  %ndbexception("NdbMgmException") {
+  %ndbexception("MgmApiException") {
     $action
       if (result==NULL) {
-        NDB_exception(NdbMgmException,"Couldn't allocate NdbMgm");
+        NDB_exception(MgmApiException,"Couldn't allocate NdbMgm");
       }
   }
   static ndb_mgm_handle * createNdbMgm(const char * connectString = 0);
diff -Nrup a/storage/ndb/swig/mgmapi/events.i b/storage/ndb/swig/mgmapi/events.i
--- a/storage/ndb/swig/mgmapi/events.i	2008-03-11 08:27:25 -07:00
+++ /dev/null	Wed Dec 31 16:00:00 196900
@@ -1,49 +0,0 @@
-/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
- *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- *
- *  Copyright (C) 2008 MySQL, Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-
-%import "mgmapi/mgmglobals.i"
-%import "mgmapi/NdbLogEvent.i"
-%import "mgmapi/listeners.i"
-
-
-%{
-
-#include <stdio.h>
-#include <vector>
-
-#undef PACKAGE
-#undef PACKAGE_NAME
-#undef PACKAGE_STRING
-#undef PACKAGE_TARNAME
-#undef PACKAGE_VERSION
-#undef VERSION
-
-#include "config.h"
-#include "ndb_init.h"
-#include "storage/ndb/mgmapi/mgmapi.h"
-#include "mgmapi_debug.h"
-#include "listeners.hpp"
-#include "events.hpp"
-
-%}
-
-%ignore getEventType;
-%ignore le_handleEvent;
-%include "events.hpp"
diff -Nrup a/storage/ndb/swig/mgmapi/listeners.i b/storage/ndb/swig/mgmapi/listeners.i
--- a/storage/ndb/swig/mgmapi/listeners.i	2008-03-11 08:27:26 -07:00
+++ b/storage/ndb/swig/mgmapi/listeners.i	2008-03-15 11:06:40 -07:00
@@ -20,7 +20,6 @@
 
 %import "mgmapi/mgmglobals.i"
 %import "mgmapi/NdbLogEvent.i"
-%import "mgmapi/events.i"
 %import "mgmapi/NdbLogEventManager.i"
 
 %{
@@ -37,10 +36,9 @@
 
 #include "config.h"
 #include "ndb_init.h"
-#include "storage/ndb/mgmapi/mgmapi.h"
+#include "mgmapi/mgmapi.h"
 #include "mgmapi_debug.h"
 #include "listeners.hpp"
-#include "events.hpp"
 
     %}
 
diff -Nrup a/storage/ndb/swig/mgmapi/mgmglobals.i b/storage/ndb/swig/mgmapi/mgmglobals.i
--- a/storage/ndb/swig/mgmapi/mgmglobals.i	2008-03-11 08:27:26 -07:00
+++ b/storage/ndb/swig/mgmapi/mgmglobals.i	2008-03-15 11:06:40 -07:00
@@ -23,20 +23,9 @@
 %include "std_vector.i"
 
 %{
-#include <stdio.h>
-#include <vector>
-
-#undef PACKAGE
-#undef PACKAGE_NAME
-#undef PACKAGE_STRING
-#undef PACKAGE_TARNAME
-#undef PACKAGE_VERSION
-#undef VERSION
-
-#include "config.h"
 
 #include "ndb_init.h"
-#include "storage/ndb/mgmapi/mgmapi.h"
+#include "mgmapi/mgmapi.h"
 #include "mgmapi_debug.h"
 
 
@@ -53,7 +42,6 @@
   %}
 
 %include "ndb_constants.h"
- //%include "ndb_logevent.h"
 
 #define MGM_LOGLEVELS CFG_MAX_LOGLEVEL - CFG_MIN_LOGLEVEL + 1
 #define NDB_MGM_MAX_LOGLEVEL 15
@@ -76,171 +64,19 @@ enum ndb_mgm_node_type {
  *   Database node status
  */
 %rename ndb_mgm_node_status NodeStatus;
-enum ndb_mgm_node_status {
-  /** Node status not known*/
-  NDB_MGM_NODE_STATUS_UNKNOWN       = 0,
-  /** No contact with node*/
-  NDB_MGM_NODE_STATUS_NO_CONTACT    = 1,
-  /** Has not run starting protocol*/
-  NDB_MGM_NODE_STATUS_NOT_STARTED   = 2,
-  /** Is running starting protocol*/
-  NDB_MGM_NODE_STATUS_STARTING      = 3,
-  /** Running*/
-  NDB_MGM_NODE_STATUS_STARTED       = 4,
-  /** Is shutting down*/
-  NDB_MGM_NODE_STATUS_SHUTTING_DOWN = 5,
-  /** Is restarting*/
-  NDB_MGM_NODE_STATUS_RESTARTING    = 6,
-  /** Maintenance mode*/
-  NDB_MGM_NODE_STATUS_SINGLEUSER    = 7,
-  /** Resume mode*/
-  NDB_MGM_NODE_STATUS_RESUME        = 8,
-};
 
 /**
  *    Error codes
  */
 %rename ndb_mgm_error NdbMgmError;
-enum ndb_mgm_error {
-  /** Not an error */
-  NDB_MGM_NO_ERROR = 0,
-
-  /* Request for service errors */
-  /** Supplied connectstring is illegal */
-  NDB_MGM_ILLEGAL_CONNECT_STRING = 1001,
-  /** Supplied NdbMgmHandle is illegal */
-  NDB_MGM_ILLEGAL_SERVER_HANDLE = 1005,
-  /** Illegal reply from server */
-  NDB_MGM_ILLEGAL_SERVER_REPLY = 1006,
-  /** Illegal number of nodes */
-  NDB_MGM_ILLEGAL_NUMBER_OF_NODES = 1007,
-  /** Illegal node status */
-  NDB_MGM_ILLEGAL_NODE_STATUS = 1008,
-  /** Memory allocation error */
-  NDB_MGM_OUT_OF_MEMORY = 1009,
-  /** Management server not connected */
-  NDB_MGM_SERVER_NOT_CONNECTED = 1010,
-  /** Could not connect to socker */
-  NDB_MGM_COULD_NOT_CONNECT_TO_SOCKET = 1011,
-  /** Could not bind local address */
-  NDB_MGM_BIND_ADDRESS = 1012,
-
-  /* Alloc node id failures */
-  /** Generic error, retry may succeed */
-  NDB_MGM_ALLOCID_ERROR = 1101,
-  /** Non retriable error */
-  NDB_MGM_ALLOCID_CONFIG_MISMATCH = 1102,
-
-  /* Service errors - Start/Stop Node or System */
-  /** Start failed */
-  NDB_MGM_START_FAILED = 2001,
-  /** Stop failed */
-  NDB_MGM_STOP_FAILED = 2002,
-  /** Restart failed */
-  NDB_MGM_RESTART_FAILED = 2003,
-
-  /* Service errors - Backup */
-  /** Unable to start backup */
-  NDB_MGM_COULD_NOT_START_BACKUP = 3001,
-  /** Unable to abort backup */
-  NDB_MGM_COULD_NOT_ABORT_BACKUP = 3002,
-
-  /* Service errors - Single User Mode */
-  /** Unable to enter single user mode */
-  NDB_MGM_COULD_NOT_ENTER_SINGLE_USER_MODE = 4001,
-  /** Unable to exit single user mode */
-  NDB_MGM_COULD_NOT_EXIT_SINGLE_USER_MODE = 4002,
-
-  /* Usage errors */
-  /** Usage error */
-  NDB_MGM_USAGE_ERROR = 5001
-};
 
 %rename ndb_mgm_event_severity NdbLogEventSeverity;
-enum ndb_mgm_event_severity {
-  NDB_MGM_ILLEGAL_EVENT_SEVERITY = -1,
-  /*  Must be a nonnegative integer (used for array indexing) */
-  /** Cluster log on */
-  NDB_MGM_EVENT_SEVERITY_ON    = 0,
-  /** Used in NDB Cluster developement */
-  NDB_MGM_EVENT_SEVERITY_DEBUG = 1,
-  /** Informational messages*/
-  NDB_MGM_EVENT_SEVERITY_INFO = 2,
-  /** Conditions that are not error condition, but might require handling.
-   */
-  NDB_MGM_EVENT_SEVERITY_WARNING = 3,
-  /** Conditions that, while not fatal, should be corrected. */
-  NDB_MGM_EVENT_SEVERITY_ERROR = 4,
-  /** Critical conditions, like device errors or out of resources */
-  NDB_MGM_EVENT_SEVERITY_CRITICAL = 5,
-  /** A condition that should be corrected immediately,
-   *  such as a corrupted system
-   */
-  NDB_MGM_EVENT_SEVERITY_ALERT = 6,
-  /* must be next number, works as bound in loop */
-  /** All severities */
-  NDB_MGM_EVENT_SEVERITY_ALL = 7
-};
 
 /**
  *  Log event categories, used to set filter level on the log events using
  *  ndb_mgm_set_clusterlog_loglevel() and ndb_mgm_listen_event()
  */
 %rename ndb_mgm_event_category NdbLogEventCategory;
-enum ndb_mgm_event_category {
-  /**
-   * Invalid log event category
-   */
-  NDB_MGM_ILLEGAL_EVENT_CATEGORY = -1,
-  /**
-   * Log events during all kinds of startups
-   */
-  NDB_MGM_EVENT_CATEGORY_STARTUP = CFG_LOGLEVEL_STARTUP,
-  /**
-   * Log events during shutdown
-   */
-  NDB_MGM_EVENT_CATEGORY_SHUTDOWN = CFG_LOGLEVEL_SHUTDOWN,
-  /**
-   * Statistics log events
-   */
-  NDB_MGM_EVENT_CATEGORY_STATISTIC = CFG_LOGLEVEL_STATISTICS,
-  /**
-   * Log events related to checkpoints
-   */
-  NDB_MGM_EVENT_CATEGORY_CHECKPOINT = CFG_LOGLEVEL_CHECKPOINT,
-  /**
-   * Log events during node restart
-   */
-  NDB_MGM_EVENT_CATEGORY_NODE_RESTART = CFG_LOGLEVEL_NODERESTART,
-  /**
-   * Log events related to connections between cluster nodes
-   */
-  NDB_MGM_EVENT_CATEGORY_CONNECTION = CFG_LOGLEVEL_CONNECTION,
-  /**
-   * Backup related log events
-   */
-  NDB_MGM_EVENT_CATEGORY_BACKUP = CFG_LOGLEVEL_BACKUP,
-  /**
-   * Congestion related log events
-   */
-  NDB_MGM_EVENT_CATEGORY_CONGESTION = CFG_LOGLEVEL_CONGESTION,
-  /**
-   * Loglevel debug
-   */
-  NDB_MGM_EVENT_CATEGORY_DEBUG = CFG_LOGLEVEL_DEBUG,
-  /**
-   * Uncategorized log events (severity info)
-   */
-  NDB_MGM_EVENT_CATEGORY_INFO = CFG_LOGLEVEL_INFO,
-  /**
-   * Uncategorized log events (severity warning or higher)
-   */
-  NDB_MGM_EVENT_CATEGORY_ERROR = CFG_LOGLEVEL_ERROR,
-  NDB_MGM_MIN_EVENT_CATEGORY = CFG_MIN_LOGLEVEL,
-  NDB_MGM_MAX_EVENT_CATEGORY = CFG_MAX_LOGLEVEL
-
-
-};
 
 
 %rename ndb_mgm_severity NdbMgmSeverity;
@@ -258,170 +94,6 @@ public:
 };
 
 %rename Ndb_logevent_type NdbLogEventType;
-enum Ndb_logevent_type {
-
-  NDB_LE_ILLEGAL_TYPE = -1,
-
-  /** NDB_MGM_EVENT_CATEGORY_CONNECTION */
-  NDB_LE_Connected = 0,
-  /** NDB_MGM_EVENT_CATEGORY_CONNECTION */
-  NDB_LE_Disconnected = 1,
-  /** NDB_MGM_EVENT_CATEGORY_CONNECTION */
-  NDB_LE_CommunicationClosed = 2,
-  /** NDB_MGM_EVENT_CATEGORY_CONNECTION */
-  NDB_LE_CommunicationOpened = 3,
-  /** NDB_MGM_EVENT_CATEGORY_CONNECTION */
-  NDB_LE_ConnectedApiVersion = 51,
-
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_GlobalCheckpointStarted = 4,
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_GlobalCheckpointCompleted = 5,
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_LocalCheckpointStarted = 6,
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_LocalCheckpointCompleted = 7,
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_LCPStoppedInCalcKeepGci = 8,
-  /** NDB_MGM_EVENT_CATEGORY_CHECKPOINT */
-  NDB_LE_LCPFragmentCompleted = 9,
-
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStartStarted = 10,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStartCompleted = 11,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_STTORRYRecieved = 12,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_StartPhaseCompleted = 13,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_CM_REGCONF = 14,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_CM_REGREF = 15,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_FIND_NEIGHBOURS = 16,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStopStarted = 17,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStopCompleted = 53,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStopForced = 59,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_NDBStopAborted = 18,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_StartREDOLog = 19,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_StartLog = 20,
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_UNDORecordsExecuted = 21,
-
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NR_CopyDict = 22,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NR_CopyDistr = 23,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NR_CopyFragsStarted = 24,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NR_CopyFragDone = 25,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NR_CopyFragsCompleted = 26,
-
-  /* NODEFAIL */
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NodeFailCompleted = 27,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_NODE_FAILREP = 28,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_ArbitState = 29,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_ArbitResult = 30,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_GCP_TakeoverStarted = 31,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_GCP_TakeoverCompleted = 32,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_LCP_TakeoverStarted = 33,
-  /** NDB_MGM_EVENT_CATEGORY_NODE_RESTART */
-  NDB_LE_LCP_TakeoverCompleted = 34,
-
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_TransReportCounters = 35,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_OperationReportCounters = 36,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_TableCreated = 37,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_UndoLogBlocked = 38,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_JobStatistic = 39,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_SendBytesStatistic = 40,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_ReceiveBytesStatistic = 41,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_MemoryUsage = 50,
-  /** NDB_MGM_EVENT_CATEGORY_STATISTIC */
-  NDB_LE_ThreadConfigLoop = 68,
-
-  /** NDB_MGM_EVENT_CATEGORY_ERROR */
-  NDB_LE_TransporterError = 42,
-  /** NDB_MGM_EVENT_CATEGORY_ERROR */
-  NDB_LE_TransporterWarning = 43,
-  /** NDB_MGM_EVENT_CATEGORY_ERROR */
-  NDB_LE_MissedHeartbeat = 44,
-  /** NDB_MGM_EVENT_CATEGORY_ERROR */
-  NDB_LE_DeadDueToHeartbeat = 45,
-  /** NDB_MGM_EVENT_CATEGORY_ERROR */
-  NDB_LE_WarningEvent = 46,
-
-  /** NDB_MGM_EVENT_CATEGORY_INFO */
-  NDB_LE_SentHeartbeat = 47,
-  /** NDB_MGM_EVENT_CATEGORY_INFO */
-  NDB_LE_CreateLogBytes = 48,
-  /** NDB_MGM_EVENT_CATEGORY_INFO */
-  NDB_LE_InfoEvent = 49,
-
-  /* 50 used */
-  /* 51 used */
-
-  /* SINGLE USER */
-  NDB_LE_SingleUser = 52,
-  /* 53 used */
-
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_BackupStarted = 54,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_BackupFailedToStart = 55,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_BackupStatus = 62,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_BackupCompleted = 56,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_BackupAborted = 57,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_RestoreMetaData = 63,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_RestoreData = 64,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_RestoreLog = 65,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_RestoreStarted = 66,
-  /** NDB_MGM_EVENT_CATEGORY_BACKUP */
-  NDB_LE_RestoreCompleted = 67,
-
-  /** NDB_MGM_EVENT_CATEGORY_INFO */
-  NDB_LE_EventBufferStatus = 58,
-
-  /* 59 used */
-
-  /** NDB_MGM_EVENT_CATEGORY_STARTUP */
-  NDB_LE_StartReport = 60
-
-  /* 61 (used in upcoming patch) */
-  /* 62-68 used */
-  /* 69 unused */
-
-};
 
 
 %{
Thread
• bk commit into 5.1 tree (mtaylor:1.2552)	Monty Taylor	15 Mar