release/src/router/mysql/storage/ndb/include/kernel/signaldata/RepImpl.hpp

   1 /* Copyright (c) 2003-2005 MySQL AB
   2
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; version 2 of the License.
   6
   7    This program is distributed in the hope that it will be useful,
   8    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10    GNU General Public License for more details.
  11
  12    You should have received a copy of the GNU General Public License
  13    along with this program; if not, write to the Free Software
  14    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA */
  15
  16 #ifndef REP_IMPL_HPP
  17 #define REP_IMPL_HPP
  18
  19 #include "SignalData.hpp"
  20 #include <NodeBitmask.hpp>
  21 #include <ndb_limits.h>
  22 #include <debugger/GrepError.hpp>
  23
  24 /**
  25  * RecordType
  26  * sz = no of elems in enum
  27  * @todo support for meta_log must be added
  28  */
  29 enum RecordType
  30 {
  31   DATA_SCAN = 0,
  32   DATA_LOG = 1,
  33   META_SCAN = 2,
  34   //  META_LOG = 3,  //removed META_LOG. not supported
  35   RecordTypeSize = 3 // =4 if meta log is supported
  36 };
  37
  38 /**
  39  * Wait GCP
  40  */
  41 class RepWaitGcpReq
  42 {
  43   /**
  44    * Sender(s)/Reciver(s)
  45    */
  46   friend class Rep;
  47   friend class GrepParticipant;
  48   friend bool printREP_WAITGCP_REQ(FILE *, const Uint32 *, Uint32, Uint16);
  49
  50 public:
  51   STATIC_CONST( SignalLength = 5 );
  52   Uint32 senderData;
  53   Uint32 subscriptionId;
  54   Uint32 subscriptionKey;
  55   Uint32 gcp;
  56   Uint32 senderNodeId;
  57 };
  58
  59 class RepWaitGcpConf
  60 {
  61   /**
  62    * Sender(s)/Reciver(s)
  63    */
  64   friend class Rep;
  65   friend class GrepParticipant;
  66
  67   friend bool printREP_WAITGCP_CONF(FILE *, const Uint32 *, Uint32, Uint16);
  68
  69 public:
  70   STATIC_CONST( SignalLength = 5 );
  71   Uint32 senderData;
  72   Uint32 senderRef;
  73   Uint32 subscriptionId;
  74   Uint32 subscriptionKey;
  75   Uint32 senderNodeId;
  76 };
  77
  78 class RepWaitGcpRef
  79 {
  80   /**
  81    * Sender(s)/Reciver(s)
  82    */
  83   friend class Rep;
  84   friend class GrepParticipant;
  85
  86   friend bool printREP_WAITGCP_REF(FILE *, const Uint32 *, Uint32, Uint16);
  87
  88 public:
  89   STATIC_CONST( SignalLength = 6 );
  90   Uint32 senderData;
  91   Uint32 senderRef;
  92   Uint32 subscriptionId;
  93   Uint32 subscriptionKey;
  94   Uint32 senderNodeId;
  95   GrepError::GE_Code err;
  96 };
  97
  98 class RepGetGciReq
  99 {
 100   /**
 101    * Sender(s)/Reciver(s)
 102    */
 103   friend class Rep;
 104   friend class Grep;
 105
 106   friend bool printREP_GET_GCI_REQ(FILE *, const Uint32 *, Uint32, Uint16);
 107
 108 public:
 109   STATIC_CONST( SignalLength = 3 );
 110   Uint32 senderData;
 111   Uint32 senderRef;
 112   Uint32 nodeGrp;
 113 };
 114
 115 class RepGetGciConf
 116 {
 117   /**
 118    * Sender(s)/Reciver(s)
 119    */
 120   friend class Rep;
 121
 122   friend bool printREP_GET_GCI_CONF(FILE *, const Uint32 *, Uint32, Uint16);
 123
 124 public:
 125   STATIC_CONST( SignalLength = 7 );
 126   Uint32 senderData;
 127   Uint32 senderRef;
 128   Uint32 nodeGrp;
 129   Uint32 firstPSGCI;
 130   Uint32 lastPSGCI;
 131   Uint32 firstSSGCI;
 132   Uint32 lastSSGCI;
 133 };
 134
 135 class RepGetGciRef
 136 {
 137   /**
 138    * Sender(s)/Reciver(s)
 139    */
 140   friend class Rep;
 141
 142   friend bool printREP_GET_GCI_REF(FILE *, const Uint32 *, Uint32, Uint16);
 143
 144 public:
 145   STATIC_CONST( SignalLength = 8);
 146   Uint32 senderData;
 147   Uint32 senderRef;
 148   Uint32 nodeGrp;
 149   Uint32 firstPSGCI;
 150   Uint32 lastPSGCI;
 151   Uint32 firstSSGCI;
 152   Uint32 lastSSGCI;
 153   GrepError::GE_Code err;
 154 };
 155
 156 class RepGetGciBufferReq {
 157   /**
 158    * Sender(s)/Reciver(s)
 159    */
 160   friend class Rep;
 161
 162   friend bool printREP_GET_GCIBUFFER_REQ(FILE *, const Uint32 *,
 163                                          Uint32, Uint16);
 164 public:
 165   STATIC_CONST( SignalLength = 5 );
 166   Uint32 senderRef;
 167   Uint32 senderData;
 168   Uint32 firstGCI;
 169   Uint32 lastGCI;
 170   Uint32 nodeGrp;
 171 };
 172
 173
 174 class RepGetGciBufferConf {
 175   /**
 176    * Sender(s)/Reciver(s)
 177    */
 178   friend class Rep;
 179
 180   friend bool printREP_GET_GCIBUFFER_CONF(FILE *, const Uint32 *,
 181                                           Uint32, Uint16);
 182
 183 public:
 184   STATIC_CONST( SignalLength = 8 );
 185   Uint32 senderData;
 186   Uint32 senderRef;
 187   Uint32 firstPSGCI;
 188   Uint32 lastPSGCI;
 189   Uint32 firstSSGCI;
 190   Uint32 lastSSGCI;
 191   Uint32 currentGCIBuffer;
 192   Uint32 nodeGrp;
 193 };
 194
 195 class RepGetGciBufferRef
 196 {
 197   /**
 198    * Sender(s)/Reciver(s)
 199    */
 200   friend class Rep;
 201
 202   friend bool printREP_GET_GCIBUFFER_REF(FILE *, const Uint32 *,
 203                                          Uint32, Uint16);
 204
 205 public:
 206   STATIC_CONST( SignalLength = 9 );
 207   Uint32 senderData;
 208   Uint32 senderRef;
 209   Uint32 firstPSGCI;
 210   Uint32 lastPSGCI;
 211   Uint32 firstSSGCI;
 212   Uint32 lastSSGCI;
 213   Uint32 currentGCIBuffer;
 214   Uint32 nodeGrp;
 215   GrepError::GE_Code err;
 216 };
 217
 218 class RepInsertGciBufferReq
 219 {
 220   /**
 221    * Sender(s)/Reciver(s)
 222    */
 223   friend class Rep;
 224
 225   friend bool printREP_INSERT_GCIBUFFER_REQ(FILE *, const Uint32 *,
 226                                             Uint32, Uint16);
 227
 228 public:
 229   STATIC_CONST( SignalLength = 5 );
 230   Uint32 senderData;
 231   Uint32 senderRef;
 232   Uint32 gci;
 233   Uint32 nodeGrp;
 234   Uint32 force;
 235 };
 236
 237 class RepInsertGciBufferRef
 238 {
 239   /**
 240    * Sender(s)/Reciver(s)
 241    */
 242   friend class Rep;
 243
 244   friend bool printREP_INSERT_GCIBUFFER_REF(FILE *, const Uint32 *,
 245                                             Uint32, Uint16);
 246 public:
 247   STATIC_CONST( SignalLength = 7 );
 248   Uint32 senderData;
 249   Uint32 senderRef;
 250   Uint32 gci;
 251   Uint32 nodeGrp;
 252   Uint32 tableId;
 253   Uint32 force;
 254   GrepError::GE_Code err;
 255 };
 256
 257 class RepInsertGciBufferConf
 258 {
 259   /**
 260    * Sender(s)/Reciver(s)
 261    */
 262   friend class Rep;
 263
 264   friend bool printREP_INSERT_GCIBUFFER_CONF(FILE *, const Uint32 *,
 265                                              Uint32, Uint16);
 266 public:
 267   STATIC_CONST( SignalLength = 5 );
 268   Uint32 senderData;
 269   Uint32 senderRef;
 270   Uint32 gci;
 271   Uint32 nodeGrp;
 272   Uint32 force;
 273 };
 274
 275
 276 class RepClearPSGciBufferReq
 277 {
 278   /**
 279    * Sender(s)/Reciver(s)
 280    */
 281   friend class Rep;
 282
 283   friend bool printREP_CLEAR_PS_GCIBUFFER_REQ(FILE *, const Uint32 *,
 284                                               Uint32, Uint16);
 285 public:
 286   STATIC_CONST( SignalLength = 5 );
 287   Uint32 senderData;
 288   Uint32 senderRef;
 289   Uint32 firstGCI;
 290   Uint32 lastGCI;
 291   Uint32 nodeGrp;
 292 };
 293
 294 class RepClearPSGciBufferRef
 295 {
 296   /**
 297    * Sender(s)/Reciver(s)
 298    */
 299   friend class Rep;
 300
 301   friend bool printREP_CLEAR_PS_GCIBUFFER_REF(FILE *, const Uint32 *,
 302                                               Uint32, Uint16);
 303
 304 public:
 305   STATIC_CONST( SignalLength = 7 );
 306   Uint32 senderData;
 307   Uint32 senderRef;
 308   Uint32 firstGCI;
 309   Uint32 lastGCI;
 310   Uint32 currentGCI;
 311   Uint32 nodeGrp;
 312   GrepError::GE_Code err;
 313 };
 314
 315 class RepClearPSGciBufferConf
 316 {
 317   /**
 318    * Sender(s)/Reciver(s)
 319    */
 320   friend class Rep;
 321
 322   friend bool printREP_CLEAR_PS_GCIBUFFER_CONF(FILE *, const Uint32 *,
 323                                                Uint32, Uint16);
 324 public:
 325   STATIC_CONST( SignalLength = 5 );
 326   Uint32 senderData;
 327   Uint32 senderRef;
 328   Uint32 firstGCI;
 329   Uint32 lastGCI;
 330   Uint32 nodeGrp;
 331 };
 332
 333 class RepClearSSGciBufferReq
 334 {
 335   /**
 336    * Sender(s)/Reciver(s)
 337    */
 338   friend class Rep;
 339
 340   friend bool printREP_CLEAR_SS_GCIBUFFER_REQ(FILE *, const Uint32 *,
 341                                               Uint32, Uint16);
 342 public:
 343   STATIC_CONST( SignalLength = 5 );
 344   Uint32 senderData;
 345   Uint32 senderRef;
 346   Uint32 firstGCI;
 347   Uint32 lastGCI;
 348   Uint32 nodeGrp;
 349 };
 350
 351 class RepClearSSGciBufferRef
 352 {
 353   /**
 354    * Sender(s)/Reciver(s)
 355    */
 356   friend class Rep;
 357
 358   friend bool printREP_CLEAR_SS_GCIBUFFER_REF(FILE *, const Uint32 *,
 359                                               Uint32, Uint16);
 360
 361 public:
 362   STATIC_CONST( SignalLength = 7 );
 363   Uint32 senderData;
 364   Uint32 senderRef;
 365   Uint32 firstGCI;
 366   Uint32 lastGCI;
 367   Uint32 currentGCI;
 368   Uint32 nodeGrp;
 369   GrepError::GE_Code err;
 370 };
 371
 372 class RepClearSSGciBufferConf
 373 {
 374   /**
 375    * Sender(s)/Reciver(s)
 376    */
 377   friend class Rep;
 378
 379   friend bool printREP_CLEAR_SS_GCIBUFFER_CONF(FILE *, const Uint32 *,
 380                                                Uint32, Uint16);
 381 public:
 382   STATIC_CONST( SignalLength = 5 );
 383   Uint32 senderData;
 384   Uint32 senderRef;
 385   Uint32 firstGCI;
 386   Uint32 lastGCI;
 387   Uint32 nodeGrp;
 388 };
 389
 390
 391 class RepDataPage
 392 {
 393   /**
 394    * Sender(s)/Reciver(s)
 395    */
 396   friend class Rep;
 397
 398   friend bool printREP_DATA_PAGE(FILE *, const Uint32 *, Uint32, Uint16);
 399
 400 public:
 401   STATIC_CONST( SignalLength = 4 );
 402   Uint32 senderData;
 403   Uint32 senderRef;
 404   Uint32 nodeGrp;
 405   Uint32 gci;
 406 };
 407
 408
 409 class RepGciBufferAccRep
 410 {
 411   /**
 412    * Sender(s)/Reciver(s)
 413    */
 414   friend class Rep;
 415
 416   friend bool printREP_GCIBUFFER_ACC_REP(FILE *, const Uint32 *,
 417                                          Uint32, Uint16);
 418 public:
 419   STATIC_CONST( SignalLength = 5 );
 420   Uint32 senderData;
 421   Uint32 senderRef;
 422   Uint32 nodeGrp;
 423   Uint32 gci;
 424   Uint32 totalSentBytes;
 425 };
 426
 427 class RepDropTableReq
 428 {
 429   /**
 430    * Sender(s)/Reciver(s)
 431    */
 432   friend class Rep;
 433
 434   friend bool printREP_DROP_TABLE_REQ(FILE *, const Uint32 *,
 435                                       Uint32, Uint16);
 436
 437 public:
 438   STATIC_CONST( SignalLength = 4 );
 439   Uint32 tableId;
 440   //  char   tableName[MAX_TAB_NAME_SIZE];
 441 };
 442
 443 class RepDropTableRef
 444 {
 445   /**
 446    * Sender(s)/Reciver(s)
 447    */
 448   friend class Rep;
 449
 450   friend bool printREP_DROP_TABLE_REF(FILE *, const Uint32 *,
 451                                       Uint32, Uint16);
 452
 453 public:
 454   STATIC_CONST( SignalLength = 4 );
 455   Uint32 tableId;
 456   // char   tableName[MAX_TAB_NAME_SIZE];
 457 };
 458
 459 class RepDropTableConf
 460 {
 461   /**
 462    * Sender(s)/Reciver(s)
 463    */
 464   friend class Rep;
 465
 466   friend bool printREP_DROP_TABLE_CONF(FILE *, const Uint32 *, Uint32, Uint16);
 467
 468 public:
 469   STATIC_CONST( SignalLength = 4 );
 470   Uint32 tableId;
 471   //char   tableName[MAX_TAB_NAME_SIZE];
 472 };
 473
 474 class RepDisconnectRep
 475 {
 476   /**
 477    * Sender(s)/Reciver(s)
 478    */
 479   friend class Rep;
 480   friend class Grep;
 481
 482   friend bool printREP_DISCONNECT_REP(FILE *, const Uint32 *, Uint32, Uint16);
 483
 484 public:
 485   enum NodeType {
 486     DB = 0,
 487     REP = 1
 488   };
 489   STATIC_CONST( SignalLength = 7 );
 490   Uint32 senderData;
 491   Uint32 senderRef;
 492   Uint32 nodeId;
 493   Uint32 nodeType;
 494   Uint32 subId;
 495   Uint32 subKey;
 496   Uint32 err;
 497 };
 498
 499 #endif