Channel.hpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #ifndef CHANNEL_HPP
  14. #define CHANNEL_HPP
  15. #include "Interval.hpp"
  16. #include <rep/rep_version.hpp>
  17. #include <Vector.hpp>
  18. #include <ndb_limits.h>
  19. #include <GrepError.hpp>
  20. /**
  21.  * Max number of requested epochs from PS
  22.  */
  23. #define GREP_SYSTEM_TABLE_MAX_RANGE 20
  24. #define MAX_NO_OF_NODE_GROUPS 32
  25. /**
  26.  * This table struct is used in m_selectedTables
  27.  */
  28. struct table{
  29.   table(const char * n) {strncpy(tableName, n, MAX_TAB_NAME_SIZE);}
  30.   char tableName[MAX_TAB_NAME_SIZE];
  31. };
  32. /**
  33.  * @class Channel
  34.  * @brief Represents location of various epochs belonging to a subscription
  35.  */
  36. class Channel {
  37. public:
  38.   enum StateSub
  39.   {
  40.     NO_SUBSCRIPTION_EXISTS,
  41.     CREATING_SUBSCRIPTION_ID,
  42.     SUBSCRIPTION_ID_CREATED,
  43.     STARTING_SUBSCRIPTION,
  44.     SUBSCRIPTION_STARTED
  45.   };
  46.   enum StateRep
  47.   {
  48.     CONSISTENT,        ///< Consistent database.  Grep not running.
  49.     METALOG_STARTING,  ///< Starting. Starting METALOG subscription
  50.     METALOG_STARTED,         
  51.     METASCAN_STARTING, ///< Starting. Starting METASCAN subscription
  52.     METASCAN_COMPLETED,
  53.     DATALOG_STARTING,  ///< Starting. Starting DATALOG subscription
  54.     DATALOG_STARTED,
  55.     DATASCAN_STARTING, ///< Starting. Starting DATASCAN subscription
  56.     DATASCAN_COMPLETED,
  57.     LOG,               ///< Started. Cons/Inconsistent. Grep running.
  58.                        ///< All scan records have been applied.
  59.     STOPPING           ///< Channel is stopping
  60.   };
  61.   /**
  62.    *   Storage "positions" of Epochs
  63.    */
  64.   enum Position {
  65.     PS = 0,            ///< Stored on Primary System REP
  66.     SSReq = 1,         ///< Requested for transfer to Standby System
  67.     SS = 2,            ///< Stored on Standby System REP
  68.     AppReq = 3,        ///< Requested to be applied to Standby System
  69.     App = 4,           ///< Has been applied to Standby System
  70.     DelReq = 5,        ///< Has been requested to be deleted on PS REP & SS REP
  71.     NO_OF_POSITIONS = 6
  72.   }; //DONT FORGET TO ADD STUFF in position2Name if u add somehting here,
  73.   /***************************************************************************
  74.    * CONSTRUCTOR / DESTRUCTOR
  75.    ***************************************************************************/
  76.   Channel();
  77.   ~Channel();
  78.   /**
  79.    *   Get and set no of nodegroups that actually exists on PS
  80.    */
  81.   void  setNoOfNodeGroups(Uint32 n) { m_noOfNodeGroups = n; };
  82.   Uint32 getNoOfNodeGroups()         { return m_noOfNodeGroups; };
  83.   void getEpochState(Position p, 
  84.      Uint32 nodeGrp, 
  85.      Uint32 * first, 
  86.      Uint32 * last);
  87.   Uint32 getEpochState(Position p, Uint32 nodegroup);
  88.   bool m_requestorEnabled;  
  89.   bool m_transferEnabled;   
  90.   bool m_applyEnabled;    
  91.   bool m_deleteEnabled;     
  92.   bool m_autoStartEnabled;     
  93.   
  94.   /***************************************************************************
  95.    * GETTERS and SETTERS
  96.    ***************************************************************************/
  97.   bool requestTransfer(Uint32 nodeGrp, Interval * i);
  98.   bool requestApply(Uint32 nodeGrp, Uint32 * epoch);
  99.   bool requestDelete(Uint32 nodeGrp, Interval * i);
  100.   void add(Position pos, Uint32 nodeGrp, const Interval i);
  101.   void clear(Position pos, Uint32 nodeGrp, const Interval i);
  102.   void   setSubId(Uint32 subId)   { m_subId=subId; };
  103.   Uint32 getSubId()               { return m_subId; };
  104.   Uint32 getSubKey()              { return m_subKey; };
  105.   void   setSubKey(Uint32 subKey) { m_subKey=subKey; };
  106.   bool isSynchable(Uint32 nodeGrp);
  107.   GrepError::Code  addTable(const char * tableName);
  108.   GrepError::Code  removeTable(const char * tableName);
  109.   void             printTables();
  110.   bool             isSelective() {return m_selectedTables.size()>0;};
  111.   Vector<struct table *> *  getSelectedTables();
  112.   void reset();
  113.   StateRep  getState()                { return m_stateRep; }
  114.   void      setState(StateRep sr)     { m_stateRep = sr; }
  115.   StateSub  getStateSub()             { return m_stateSub; }
  116.   void      setStateSub(StateSub ss)  { m_stateSub = ss; }
  117.   Interval  getMetaScanEpochs()           { return m_metaScanEpochs; }
  118.   void      setMetaScanEpochs(Interval i) { m_metaScanEpochs = i; }
  119.   Interval  getDataScanEpochs()           { return m_dataScanEpochs; }
  120.   void      setDataScanEpochs(Interval i) { m_dataScanEpochs = i; }
  121.   GrepError::Code  setStopEpochId(Uint32 n);
  122.   Uint32           getStopEpochId()         { return m_stopEpochId; };
  123.   bool isStoppable();
  124.   bool shouldStop();
  125.   bool subscriptionExists() { return (m_subId != 0 && m_subKey != 0); }
  126.   /***************************************************************************
  127.    * GETTERS
  128.    ***************************************************************************/
  129.   Uint32 getFirst(Position pos, Uint32 nodeGrp) { 
  130.     return state[nodeGrp][pos].first(); 
  131.   }
  132.   Uint32 getLast(Position pos, Uint32 nodeGrp) { 
  133.     return state[nodeGrp][pos].last(); 
  134.   }
  135.   void           getFullyAppliedEpochs(Interval * i);
  136.   /***************************************************************************
  137.    * PRINT METHODS
  138.    ***************************************************************************/
  139.   void print();
  140.   void print(Position pos);
  141.   void print(Position pos, Uint32 nodeGrp);
  142.   void print(Uint32 nodeGrp);
  143.   /***************************************************************************
  144.    * PUBLIC ATTRIBUTES
  145.    ***************************************************************************/
  146. private:  
  147.   /***************************************************************************
  148.    * PRIVATE ATTRIBUTES
  149.    ***************************************************************************/
  150.   StateRep      m_stateRep;        // Replication state
  151.   StateSub      m_stateSub;        // Subscription state
  152.   Uint32        m_subId;
  153.   Uint32        m_subKey;
  154.   Uint32        m_noOfNodeGroups;  // Number of node grps in this channel
  155.   Uint32        m_stopEpochId;     // Epoch id to stop subscription
  156.   Interval      state[MAX_NO_OF_NODE_GROUPS][NO_OF_POSITIONS];
  157.   Interval      m_metaScanEpochs;  
  158.   Interval      m_dataScanEpochs;  
  159.   
  160.   Vector<struct table *> m_selectedTables;
  161.   void invariant();                // Abort if channel metadata is inconsistent
  162.   char * position2Name(Position p);
  163. public:
  164.   bool copy(Position from, Position to, Uint32 range, 
  165.     Uint32 * f, Uint32 * l, Uint32 nodeGrp);
  166. };
  167. #endif