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

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. #include "NodeGroupInfo.hpp"
  14. NodeGroupInfo::NodeGroupInfo() 
  15. {
  16. }
  17. NodeGroupInfo::~NodeGroupInfo() 
  18. {
  19.   for(Uint32 i=0; i<m_nodeGroupList.size(); i++) {
  20.     delete m_nodeGroupList[i];
  21.   }
  22.   m_nodeGroupList.clear();
  23. }
  24. void
  25. NodeGroupInfo::setPrimaryNode(Uint32 nodeGrp, Uint32 nodeId) {
  26.   Uint32 pos;
  27.   /**
  28.    * Validation check to find out that the nodegroup really exists.
  29.    * The list is not sorted, so the index of the nodegroup is returned
  30.    * in pos.
  31.    */
  32.   if(existsNodeGroup(nodeGrp, &pos)) {
  33.     m_nodeGroupList[pos]->setPrimaryNode(nodeId);
  34.   } else {
  35.     /**
  36.      * could not find node group
  37.      */
  38.     RLOG(("Node group not found"));
  39.     REPABORT("Node group not found");
  40.   }
  41. }
  42. Uint32
  43. NodeGroupInfo::getPrimaryNode(Uint32 nodeGrp) {
  44.   Uint32 pos;
  45.   /**
  46.    * Validation check to find out that the nodegroup really exists.
  47.    * The list is not sorted, so the index of the nodegroup is returned
  48.    * in pos.
  49.    */
  50.   if(existsNodeGroup(nodeGrp, &pos)) {
  51.     return m_nodeGroupList[pos]->getPrimaryNode();
  52.   } else {
  53.     /**
  54.      * could not find node group
  55.      */
  56.     RLOG(("Node group not found"));
  57.     REPABORT("Node group not found");
  58.   }
  59. }
  60. void
  61. NodeGroupInfo::addNodeToNodeGrp(Uint32 nodeId, bool connected, Uint32 nodeGrp)
  62. {
  63.   Uint32 pos;
  64.   if(existsNodeGroup(nodeGrp, &pos)) {
  65.     /**
  66.      *  NG exists -> just add the node
  67.      */
  68.     m_nodeGroupList[pos]->addNode(nodeId, connected);
  69.   } else {
  70.     /**
  71.      *  NG do not exist -> create a new nodeGrp and add the node
  72.      */
  73.     m_nodeGroupList.push_back(new NodeGroup(nodeGrp));
  74.     
  75.     /**
  76.      * paranoia
  77.      */
  78.     if(existsNodeGroup(nodeGrp, &pos)) {
  79.       m_nodeGroupList[pos]->addNode(nodeId, connected);
  80.     } else {
  81.       REPABORT("");
  82.     }
  83.   }
  84. }
  85. Uint32
  86. NodeGroupInfo::findNodeGroup(Uint32 nodeId) 
  87. {
  88.   /**
  89.    *  Check for existance in each nodegroup
  90.    */
  91.   for(Uint32 i=0; i<m_nodeGroupList.size(); i++) {
  92.     if(m_nodeGroupList[i]->exists(nodeId)) return i;
  93.   }
  94.   REPABORT1("No node group known for node", nodeId);
  95. }
  96. Uint32 
  97. NodeGroupInfo::getFirstConnectedNode(Uint32 nodeGrp) 
  98. {
  99.   Uint32 pos;
  100.   /**
  101.    * Validation check to find out that the nodegroup really exists.
  102.    * The list is not sorted, so the index of the nodegroup is returned
  103.    * in pos.
  104.    */
  105.   if(existsNodeGroup(nodeGrp, &pos)) {
  106.     return m_nodeGroupList[pos]->getFirstConnectedNode();
  107.   } else {
  108.     /**
  109.      * could not find node group
  110.      */
  111.     REPABORT("");
  112.   }
  113. }
  114. bool
  115. NodeGroupInfo::connectedNodeGrp(Uint32 nodeGrp) 
  116. {
  117.   return m_nodeGroupList[nodeGrp]->connectedNodeGrp();
  118. }
  119. bool
  120. NodeGroupInfo::isConnected(Uint32 nodeId) 
  121. {
  122.   Uint32 nodeGrp = findNodeGroup(nodeId);
  123.   return m_nodeGroupList[nodeGrp]->isConnected(nodeId);
  124.  
  125. }
  126. bool
  127. NodeGroupInfo::fullyConnected() 
  128. {
  129.   for(Uint32 i=0; i<m_nodeGroupList.size(); i++) {
  130.     if(!(m_nodeGroupList[i]->fullyConnected()))
  131.       return false;
  132.   }
  133.   return true;
  134. }
  135. void
  136. NodeGroupInfo::setConnectStatus(Uint32 nodeId, bool connected) 
  137. {
  138.   Uint32 nodeGrp = findNodeGroup(nodeId);
  139.   m_nodeGroupList[nodeGrp]->setNodeConnectStatus(nodeId,connected);
  140. }
  141. bool
  142. NodeGroupInfo::existsNodeGroup(Uint32 nodeGrp, Uint32 * pos)
  143. {
  144.   for(Uint32 i=0; i<m_nodeGroupList.size(); i++) {
  145.     if(m_nodeGroupList[i]->getNodeGrp()==nodeGrp) {
  146.       *pos=i;
  147.       return true;
  148.     }
  149.   }
  150.   return false;
  151. }
  152. /*****************************************************************************
  153.  * Iterator
  154.  *****************************************************************************/
  155. NodeGroupInfo::iterator::iterator(Uint32 nodeGrp, NodeGroupInfo * ngi) 
  156. {
  157.   m_iterator = 0;
  158.   for(Uint32 i=0; i < ngi->m_nodeGroupList.size(); i++) {
  159.     if(ngi->m_nodeGroupList[i]->getNodeGrp()==nodeGrp) {
  160.       m_nodeList = ngi->m_nodeGroupList[i]->getNodeConnectList();
  161.       return;
  162.     }
  163.   }
  164.   m_nodeList=0;
  165. }
  166. bool
  167. NodeGroupInfo::iterator::exists() 
  168. {
  169.   if(m_nodeList==0) return 0;
  170.   return (m_iterator < m_nodeList->size());
  171. }
  172. NodeConnectInfo *
  173. NodeGroupInfo::iterator::first() 
  174. {
  175.   m_iterator=0;
  176.   if(m_nodeList==0) return 0;
  177.   if(m_nodeList->size() == 0) return 0;
  178.   return (*m_nodeList)[m_iterator];
  179. }
  180. NodeConnectInfo *
  181. NodeGroupInfo::iterator::next() 
  182. {
  183.   m_iterator++;
  184.   if(m_nodeList==0) return 0;
  185.   if(m_nodeList->size() == 0) return 0;
  186.   if(m_iterator<m_nodeList->size())
  187.     return (*m_nodeList)[m_iterator];
  188.   else
  189.     return 0;
  190. }