开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
Suma.hpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：16k
源码类别：

MySQL数据库

开发平台：

Visual C++

Suma.hpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  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; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #ifndef SUMA_H
  18. #define SUMA_H
  20. #include <ndb_limits.h>
  21. #include <SimulatedBlock.hpp>
  23. #include <NodeBitmask.hpp>
  25. #include <SLList.hpp>
  26. #include <DLList.hpp>
  27. #include <KeyTable.hpp>
  28. #include <DataBuffer.hpp>
  29. #include <SignalCounter.hpp>
  30. #include <AttributeHeader.hpp>
  31. #include <AttributeList.hpp>
  33. #include <signaldata/UtilSequence.hpp>
  34. #include <signaldata/SumaImpl.hpp>
  36. class SumaParticipant : public SimulatedBlock {
  37. protected:
  38.   SumaParticipant(const Configuration & conf);
  39.   virtual ~SumaParticipant();
  40.   BLOCK_DEFINES(SumaParticipant);
  41.   
  42. protected:
  43.   /**
  44.    * Private interface
  45.    */
  46.   void execSUB_CREATE_REQ(Signal* signal);
  47.   void execSUB_REMOVE_REQ(Signal* signal);
  48.   
  49.   void execSUB_START_REQ(Signal* signal);
  50.   void execSUB_STOP_REQ(Signal* signal);
  51.   
  52.   void execSUB_SYNC_REQ(Signal* signal);
  53.   void execSUB_ABORT_SYNC_REQ(Signal* signal);
  55.   void execSUB_STOP_CONF(Signal* signal);
  56.   void execSUB_STOP_REF(Signal* signal);
  58.  /**
  59.    * Dict interface
  60.    */
  61.   void execLIST_TABLES_REF(Signal* signal);
  62.   void execLIST_TABLES_CONF(Signal* signal);
  63.   void execGET_TABINFOREF(Signal* signal);
  64.   void execGET_TABINFO_CONF(Signal* signal);
  65. #if 0
  66.   void execGET_TABLEID_CONF(Signal* signal);
  67.   void execGET_TABLEID_REF(Signal* signal);
  68. #endif
  69.   /**
  70.    * Scan interface
  71.    */
  72.   void execSCAN_HBREP(Signal* signal);
  73.   void execSCAN_FRAGREF(Signal* signal);
  74.   void execSCAN_FRAGCONF(Signal* signal);
  75.   void execTRANSID_AI(Signal* signal);
  76.   void execSUB_SYNC_CONTINUE_REF(Signal* signal);
  77.   void execSUB_SYNC_CONTINUE_CONF(Signal* signal);
  78.   
  79.   /**
  80.    * Trigger logging
  81.    */
  82.   void execTRIG_ATTRINFO(Signal* signal);
  83.   void execFIRE_TRIG_ORD(Signal* signal);
  84.   void execSUB_GCP_COMPLETE_REP(Signal* signal);
  85.   void runSUB_GCP_COMPLETE_ACC(Signal* signal);
  86.   
  87.   /**
  88.    * DIH signals
  89.    */
  90.   void execDI_FCOUNTREF(Signal* signal);
  91.   void execDI_FCOUNTCONF(Signal* signal);
  92.   void execDIGETPRIMREF(Signal* signal);
  93.   void execDIGETPRIMCONF(Signal* signal);
  95.   /**
  96.    * Trigger administration
  97.    */
  98.   void execCREATE_TRIG_REF(Signal* signal);
  99.   void execCREATE_TRIG_CONF(Signal* signal);
  100.   void execDROP_TRIG_REF(Signal* signal);
  101.   void execDROP_TRIG_CONF(Signal* signal);
  102.   
  103.   /**
  104.    * continueb
  105.    */
  106.   void execCONTINUEB(Signal* signal);
  108. public:
  109.   typedef DataBuffer<15> TableList;
  110.   
  111.   union FragmentDescriptor { 
  112.     struct  {
  113.       Uint16 m_fragmentNo;
  114.       Uint16 m_nodeId;
  115.     } m_fragDesc;
  116.     Uint32 m_dummy;
  117.   };
  118.   
  119.   /**
  120.    * Used when sending SCAN_FRAG
  121.    */
  122.   union AttributeDescriptor {
  123.     struct {
  124.       Uint16 attrId;
  125.       Uint16 unused;
  126.     } m_attrDesc;
  127.     Uint32 m_dummy;
  128.   };
  130.   struct Table {
  131.     Table() { m_tableId = ~0; }
  132.     void release(SumaParticipant&);
  134.     union { Uint32 m_tableId; Uint32 key; };
  135.     Uint32 m_schemaVersion;
  136.     Uint32 m_hasTriggerDefined[3]; // Insert/Update/Delete
  137.     Uint32 m_triggerIds[3]; // Insert/Update/Delete
  138.     
  139.     /**
  140.      * Default order in which to ask for attributes during scan
  141.      *   1) Fixed, not nullable
  142.      *   2) Rest
  143.      */
  144.     DataBuffer<15>::Head m_attributes; // Attribute id's
  145.     
  146.     /**
  147.      * Fragments
  148.      */
  149.     DataBuffer<15>::Head m_fragments;  // Fragment descriptors
  150.     
  151.     /**
  152.      * Hash table stuff
  153.      */
  154.     Uint32 nextHash;
  155.     union { Uint32 prevHash; Uint32 nextPool; };
  156.     Uint32 hashValue() const {
  157.       return m_tableId;
  158.     }
  159.     bool equal(const Table& rec) const {
  160.       return m_tableId == rec.m_tableId;
  161.     }
  162.   };
  163.   typedef Ptr<Table> TablePtr;
  165.   /**
  166.    * Subscriptions
  167.    */
  168.   struct SyncRecord {
  169.     SyncRecord(SumaParticipant& s, DataBuffer<15>::DataBufferPool & p)
  170.       : m_locked(false), m_tableList(p), suma(s)
  171. #ifdef ERROR_INSERT
  172. , cerrorInsert(s.cerrorInsert)
  173. #endif
  174.     {}
  175.     
  176.     void release();
  178.     Uint32 m_subscriptionPtrI;
  179.     bool   m_locked;
  180.     bool   m_doSendSyncData;
  181.     bool   m_error;
  182.     TableList m_tableList;    // Tables to sync (snapshoted at beginning)
  183.     TableList::DataBufferIterator m_tableList_it;
  185.     /**
  186.      * Sync meta
  187.      */
  188.     void startMeta(Signal*);
  189.     void nextMeta(Signal*);
  190.     void completeMeta(Signal*);
  191.     
  192.     /**
  193.      * Create triggers
  194.      */
  195.     Uint32 m_latestTriggerId;
  196.     void startTrigger(Signal* signal);
  197.     void nextTrigger(Signal* signal);
  198.     void completeTrigger(Signal* signal);
  199.     void createAttributeMask(AttributeMask&, Table*);
  200.     
  201.     /**
  202.      * Drop triggers
  203.      */
  204.     void startDropTrigger(Signal* signal);
  205.     void nextDropTrigger(Signal* signal);
  206.     void completeDropTrigger(Signal* signal);
  208.     /**
  209.      * Sync data
  210.      */
  211.     Uint32 m_currentTable;          // Index in m_tableList
  212.     Uint32 m_currentFragment;       // Index in tabPtr.p->m_fragments
  213.     DataBuffer<15>::Head m_attributeList; // Attribute if other than default
  214.     DataBuffer<15>::Head m_tabList; // tables if other than default
  215.     
  216.     Uint32 m_currentTableId;        // Current table
  217.     Uint32 m_currentNoOfAttributes; // No of attributes for current table
  218.     void startScan(Signal*);
  219.     void nextScan(Signal*);
  220.     bool getNextFragment(TablePtr * tab, FragmentDescriptor * fd);
  221.     void completeScan(Signal*);
  223.     SumaParticipant & suma;
  224. #ifdef ERROR_INSERT
  225.     UintR &cerrorInsert;
  226. #endif
  227.     BlockNumber number() const { return suma.number(); }
  228.     void progError(int line, int cause, const char * extra) { 
  229.       suma.progError(line, cause, extra); 
  230.     }
  231.     
  232.     void runLIST_TABLES_CONF(Signal* signal);
  233.     void runGET_TABINFO_CONF(Signal* signal);    
  234.     void runGET_TABINFOREF(Signal* signal);
  235.     
  236.     void runDI_FCOUNTCONF(Signal* signal);
  237.     void runDIGETPRIMCONF(Signal* signal);
  239.     void runCREATE_TRIG_CONF(Signal* signal);
  240.     void runDROP_TRIG_CONF(Signal* signal);
  241.     void runDROP_TRIG_REF(Signal* signal);
  242.     void runDropTrig(Signal* signal, Uint32 triggerId, Uint32 tableId);
  244.     union { Uint32 nextPool; Uint32 nextList; Uint32 ptrI; };
  245.   };
  246.   friend struct SyncRecord;
  247.   
  248.   struct Subscription {
  249.     Uint32 m_subscriberRef;
  250.     Uint32 m_subscriberData;
  251.     Uint32 m_senderRef;
  252.     Uint32 m_senderData;
  253.     Uint32 m_subscriptionId;
  254.     Uint32 m_subscriptionKey;
  255.     Uint32 m_subscriptionType;
  256.     Uint32 m_coordinatorRef;
  257.     Uint32 m_syncPtrI;  // Active sync operation
  258.     Uint32 m_nSubscribers;
  259.     bool m_markRemove;
  261.     Uint32 nextHash;
  262.     union { Uint32 prevHash; Uint32 nextPool; };
  264.     Uint32 hashValue() const {
  265.       return m_subscriptionId + m_subscriptionKey;
  266.     }
  268.     bool equal(const Subscription & s) const {
  269.       return 
  270. m_subscriptionId == s.m_subscriptionId && 
  271. m_subscriptionKey == s.m_subscriptionKey;
  272.     }
  273.     /**
  274.      * The following holds the table names of tables included 
  275.      * in the subscription.
  276.      */
  277.     // TODO we've got to fix this, this is to inefficient. Tomas
  278.     char m_tables[MAX_TABLES];
  279. #if 0
  280.     char m_tableNames[MAX_TABLES][MAX_TAB_NAME_SIZE];
  281. #endif
  282.     /**
  283.      * "Iterator" used to iterate through m_tableNames
  284.      */
  285.     Uint32 m_maxTables;
  286.     Uint32 m_currentTable;
  287.   };
  288.   typedef Ptr<Subscription> SubscriptionPtr;
  289.   
  290.   struct Subscriber {
  291.     Uint32 m_senderRef;
  292.     Uint32 m_senderData;
  293.     Uint32 m_subscriberRef;
  294.     Uint32 m_subscriberData;
  295.     Uint32 m_subPtrI; //reference to subscription
  296.     Uint32 m_firstGCI; // first GCI to send
  297.     Uint32 m_lastGCI; // last acnowledged GCI
  298.     Uint32 nextList;
  299.     union { Uint32 nextPool; Uint32 prevList; };
  300.   };
  301.   typedef Ptr<Subscriber> SubscriberPtr;
  303.   struct Bucket {
  304.     bool active;
  305.     bool handover;
  306.     bool handover_started;
  307.     Uint32 handoverGCI;
  308.   };
  309. #define NO_OF_BUCKETS 24
  310.   struct Bucket c_buckets[NO_OF_BUCKETS];
  311.   bool c_handoverToDo;
  312.   Uint32 c_lastCompleteGCI;
  314.   /**
  315.    * 
  316.    */
  317.   DLList<Subscriber> c_metaSubscribers;
  318.   DLList<Subscriber> c_dataSubscribers;
  319.   DLList<Subscriber> c_prepDataSubscribers;
  320.   DLList<Subscriber> c_removeDataSubscribers;
  322.   /**
  323.    * Lists
  324.    */
  325.   KeyTable<Table> c_tables;
  326.   DLHashTable<Subscription> c_subscriptions;
  327.   
  328.   /**
  329.    * Pools
  330.    */
  331.   ArrayPool<Subscriber> c_subscriberPool;
  332.   ArrayPool<Table> c_tablePool_;
  333.   ArrayPool<Subscription> c_subscriptionPool;
  334.   ArrayPool<SyncRecord> c_syncPool;
  335.   DataBuffer<15>::DataBufferPool c_dataBufferPool;
  337.   /**
  338.    * for restarting Suma not to start sending data too early
  339.    */
  340.   bool c_restartLock;
  342.   /**
  343.    * for flagging that a GCI containg inconsistent data
  344.    * typically due to node failiure
  345.    */
  347.   Uint32 c_lastInconsistentGCI;
  348.   Uint32 c_nodeFailGCI;
  350.   NodeBitmask c_failedApiNodes;
  351.   
  352.   /**
  353.    * Functions
  354.    */
  355.   bool removeSubscribersOnNode(Signal *signal, Uint32 nodeId);
  357.   bool parseTable(Signal* signal, class GetTabInfoConf* conf, Uint32 tableId,
  358.   SyncRecord* syncPtr_p);
  359.   bool checkTableTriggers(SegmentedSectionPtr ptr);
  361.   void addTableId(Uint32 TableId,
  362.   SubscriptionPtr subPtr, SyncRecord *psyncRec);
  364.   void sendSubIdRef(Signal* signal, Uint32 errorCode);
  365.   void sendSubCreateConf(Signal* signal, Uint32 sender, SubscriptionPtr subPtr);  
  366.   void sendSubCreateRef(Signal* signal, const SubCreateReq& req, Uint32 errorCode);  
  367.   void sendSubStartRef(SubscriptionPtr subPtr, Signal* signal,
  368.        Uint32 errorCode, bool temporary = false);
  369.   void sendSubStartRef(Signal* signal,
  370.        Uint32 errorCode, bool temporary = false);
  371.   void sendSubStopRef(Signal* signal,
  372.       Uint32 errorCode, bool temporary = false);
  373.   void sendSubSyncRef(Signal* signal, Uint32 errorCode);  
  374.   void sendSubRemoveRef(Signal* signal, const SubRemoveReq& ref,
  375. Uint32 errorCode, bool temporary = false);
  376.   void sendSubStartComplete(Signal*, SubscriberPtr, Uint32, 
  377.     SubscriptionData::Part);
  378.   void sendSubStopComplete(Signal*, SubscriberPtr);
  379.   void sendSubStopReq(Signal* signal);
  381.   void completeSubRemoveReq(Signal* signal, SubscriptionPtr subPtr);
  383.   Uint32 getFirstGCI(Signal* signal);
  384.   Uint32 decideWhoToSend(Uint32 nBucket, Uint32 gci);
  386.   virtual Uint32 getStoreBucket(Uint32 v) = 0;
  387.   virtual Uint32 getResponsibleSumaNodeId(Uint32 D) = 0;
  388.   virtual Uint32 RtoI(Uint32 sumaRef, bool dieOnNotFound = true) = 0;
  390.   struct FailoverBuffer {
  391.     //    FailoverBuffer(DataBuffer<15>::DataBufferPool & p);
  392.     FailoverBuffer();
  394.     bool subTableData(Uint32 gci, Uint32 *src, int sz);
  395.     bool subGcpCompleteRep(Uint32 gci);
  396.     bool nodeFailRep();
  398.     //    typedef DataBuffer<15> GCIDataBuffer;
  399.     //    GCIDataBuffer                      m_GCIDataBuffer;
  400.     //    GCIDataBuffer::DataBufferIterator  m_GCIDataBuffer_it;
  402.     Uint32 *c_gcis;
  403.     int c_sz;
  405.     //    Uint32 *c_buf;
  406.     //    int c_buf_sz;
  408.     int c_first;
  409.     int c_next;
  410.     bool c_full;
  411.   } c_failoverBuffer;
  413.   /**
  414.    * Table admin
  415.    */
  416.   void convertNameToId( SubscriptionPtr subPtr, Signal * signal);
  419. };
  421. class Suma : public SumaParticipant {
  422.   BLOCK_DEFINES(Suma);
  423. public:
  424.   Suma(const Configuration & conf);
  425.   virtual ~Suma();
  426. private:
  427.   /**
  428.    * Public interface
  429.    */
  430.   void execCREATE_SUBSCRIPTION_REQ(Signal* signal);
  431.   void execDROP_SUBSCRIPTION_REQ(Signal* signal);
  432.   
  433.   void execSTART_SUBSCRIPTION_REQ(Signal* signal);
  434.   void execSTOP_SUBSCRIPTION_REQ(Signal* signal);
  435.   
  436.   void execSYNC_SUBSCRIPTION_REQ(Signal* signal);
  437.   void execABORT_SYNC_REQ(Signal* signal);
  439.   /**
  440.    * Framework signals
  441.    */
  443.   void getNodeGroupMembers(Signal* signal);
  445.   void execSTTOR(Signal* signal);
  446.   void sendSTTORRY(Signal*);
  447.   void execNDB_STTOR(Signal* signal);
  448.   void execDUMP_STATE_ORD(Signal* signal);
  449.   void execREAD_NODESCONF(Signal* signal);
  450.   void execNODE_FAILREP(Signal* signal);
  451.   void execINCL_NODEREQ(Signal* signal);
  452.   void execCONTINUEB(Signal* signal);
  453.   void execSIGNAL_DROPPED_REP(Signal* signal);
  454.   void execAPI_FAILREQ(Signal* signal) ;
  456.   void execSUB_GCP_COMPLETE_ACC(Signal* signal);
  458.   /**
  459.    * Controller interface
  460.    */
  461.   void execSUB_CREATE_REF(Signal* signal);
  462.   void execSUB_CREATE_CONF(Signal* signal);
  464.   void execSUB_DROP_REF(Signal* signal);
  465.   void execSUB_DROP_CONF(Signal* signal);
  467.   void execSUB_START_REF(Signal* signal);
  468.   void execSUB_START_CONF(Signal* signal);
  470.   void execSUB_STOP_REF(Signal* signal);
  471.   void execSUB_STOP_CONF(Signal* signal);
  473.   void execSUB_SYNC_REF(Signal* signal);
  474.   void execSUB_SYNC_CONF(Signal* signal);
  475.   
  476.   void execSUB_ABORT_SYNC_REF(Signal* signal);
  477.   void execSUB_ABORT_SYNC_CONF(Signal* signal);
  479.   void execSUMA_START_ME(Signal* signal);
  480.   void execSUMA_HANDOVER_REQ(Signal* signal);
  481.   void execSUMA_HANDOVER_CONF(Signal* signal);
  483.   /**
  484.    * Subscription generation interface
  485.    */
  486.   void createSequence(Signal* signal);
  487.   void createSequenceReply(Signal* signal,
  488.    UtilSequenceConf* conf,
  489.    UtilSequenceRef* ref);
  490.   void execUTIL_SEQUENCE_CONF(Signal* signal);  
  491.   void execUTIL_SEQUENCE_REF(Signal* signal);
  492.   void execCREATE_SUBID_REQ(Signal* signal);
  493.   
  494.   Uint32 getStoreBucket(Uint32 v);
  495.   Uint32 getResponsibleSumaNodeId(Uint32 D);
  497.   /**
  498.    * for Suma that is restarting another
  499.    */
  501.   struct Restart {
  502.     Restart(Suma& s);
  504.     Suma & suma;
  506.     bool c_okToStart[MAX_REPLICAS];
  507.     bool c_waitingToStart[MAX_REPLICAS];
  509.     DLHashTable<SumaParticipant::Subscription>::Iterator c_subPtr; // TODO  [MAX_REPLICAS] 
  510.     SubscriberPtr c_subbPtr; // TODO [MAX_REPLICAS] 
  512.     void progError(int line, int cause, const char * extra) { 
  513.       suma.progError(line, cause, extra); 
  514.     }
  516.     void resetNode(Uint32 sumaRef);
  517.     void runSUMA_START_ME(Signal*, Uint32 sumaRef);
  518.     void startNode(Signal*, Uint32 sumaRef);
  520.     void createSubscription(Signal* signal, Uint32 sumaRef);
  521.     void nextSubscription(Signal* signal, Uint32 sumaRef);
  522.     void completeSubscription(Signal* signal, Uint32 sumaRef);
  524.     void startSync(Signal* signal, Uint32 sumaRef);
  525.     void nextSync(Signal* signal, Uint32 sumaRef);
  526.     void completeSync(Signal* signal, Uint32 sumaRef);
  528.     void sendSubStartReq(SubscriptionPtr subPtr, SubscriberPtr subbPtr,
  529.  Signal* signal, Uint32 sumaRef);
  530.     void startSubscriber(Signal* signal, Uint32 sumaRef);
  531.     void nextSubscriber(Signal* signal, Uint32 sumaRef);
  532.     void completeSubscriber(Signal* signal, Uint32 sumaRef);
  534.     void completeRestartingNode(Signal* signal, Uint32 sumaRef);
  535.   } Restart;
  537. private:
  538.   friend class Restart;
  539.   struct SubCoordinator {
  540.     Uint32 m_subscriberRef;
  541.     Uint32 m_subscriberData;
  542.     
  543.     Uint32 m_subscriptionId;
  544.     Uint32 m_subscriptionKey;
  545.     
  546.     NdbNodeBitmask m_participants;
  547.     
  548.     Uint32 m_outstandingGsn;
  549.     SignalCounter m_outstandingRequests;
  550.     
  551.     Uint32 nextList;
  552.     union { Uint32 prevList; Uint32 nextPool; };
  553.   };
  554.   Ptr<SubCoordinator> SubCoordinatorPtr;
  555.   
  556.   struct Node {
  557.     Uint32 nodeId;
  558.     Uint32 alive;
  559.     Uint32 nextList;
  560.     union { Uint32 prevList; Uint32 nextPool; };
  561.   };
  562.   typedef Ptr<Node> NodePtr;
  564.   /**
  565.    * Variables
  566.    */
  567.   NodeId c_masterNodeId;
  568.   SLList<Node> c_nodes;
  569.   NdbNodeBitmask c_aliveNodes;
  570.   NdbNodeBitmask c_preparingNodes;
  572.   Uint32 RtoI(Uint32 sumaRef, bool dieOnNotFound = true);
  574.   /**
  575.    * for all Suma's to keep track of other Suma's in Node group
  576.    */
  577.   Uint32 c_nodeGroup;
  578.   Uint32 c_noNodesInGroup;
  579.   Uint32 c_idInNodeGroup;
  580.   NodeId c_nodesInGroup[MAX_REPLICAS];
  582.   /**
  583.    * don't seem to be used
  584.    */
  585.   ArrayPool<Node> c_nodePool;
  586.   ArrayPool<SubCoordinator> c_subCoordinatorPool;
  587.   DLList<SubCoordinator> c_runningSubscriptions;
  588. };
  590. inline Uint32
  591. Suma::RtoI(Uint32 sumaRef, bool dieOnNotFound) {
  592.   for (Uint32 i = 0; i < c_noNodesInGroup; i++) {
  593.     if (sumaRef == calcSumaBlockRef(c_nodesInGroup[i]))
  594.       return i;
  595.   }
  596.   ndbrequire(!dieOnNotFound);
  597.   return RNIL;
  598. }
  600. #endif