1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
/* Copyright (C) 2003 MySQL AB
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; version 2 of the License.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifndef ClusterMgr_H
#define ClusterMgr_H
#include "API.hpp"
#include <ndb_limits.h>
#include <NdbThread.h>
#include <NdbMutex.h>
#include <NdbCondition.h>
#include <signaldata/ArbitSignalData.hpp>
#include <signaldata/NodeStateSignalData.hpp>
#include <NodeInfo.hpp>
#include <NodeState.hpp>
extern "C" void* runClusterMgr_C(void * me);
/**
* @class ClusterMgr
*/
class ClusterMgr {
friend void* runClusterMgr_C(void * me);
friend void execute(void *, struct SignalHeader * const,
Uint8, Uint32 * const, LinearSectionPtr ptr[3]);
public:
ClusterMgr(class TransporterFacade &);
~ClusterMgr();
void init(struct ndb_mgm_configuration_iterator & config);
void reportConnected(NodeId nodeId);
void reportDisconnected(NodeId nodeId);
bool checkUpgradeCompatability(Uint32 nodeVersion);
void doStop();
void startThread();
void forceHB();
private:
void threadMain();
int theStop;
class TransporterFacade & theFacade;
public:
struct Node {
Node();
bool defined;
bool connected; // Transporter connected
bool compatible; // Version is compatible
bool nfCompleteRep; // NF Complete Rep has arrived
bool m_alive; // Node is alive
bool m_api_reg_conf;// API_REGCONF has arrived
NodeInfo m_info;
NodeState m_state;
/**
* Heartbeat stuff
*/
Uint32 hbFrequency; // Heartbeat frequence
Uint32 hbCounter; // # milliseconds passed since last hb sent
};
const Node & getNodeInfo(NodeId) const;
Uint32 getNoOfConnectedNodes() const;
void hb_received(NodeId);
Uint32 m_connect_count;
private:
Uint32 noOfAliveNodes;
Uint32 noOfConnectedNodes;
Node theNodes[MAX_NODES];
NdbThread* theClusterMgrThread;
NodeBitmask waitForHBFromNodes; // used in forcing HBs
NdbCondition* waitForHBCond;
bool waitingForHB;
/**
* Used for controlling start/stop of the thread
*/
NdbMutex* clusterMgrThreadMutex;
void showState(NodeId nodeId);
void reportNodeFailed(NodeId nodeId, bool disconnect = false);
/**
* Signals received
*/
void execAPI_REGREQ (const Uint32 * theData);
void execAPI_REGCONF (const Uint32 * theData);
void execAPI_REGREF (const Uint32 * theData);
void execNODE_FAILREP (const Uint32 * theData);
void execNF_COMPLETEREP(const Uint32 * theData);
inline void set_node_alive(Node& node, bool alive){
if(node.m_alive && !alive)
{
assert(noOfAliveNodes);
noOfAliveNodes--;
}
else if(!node.m_alive && alive)
{
noOfAliveNodes++;
}
node.m_alive = alive;
}
};
inline
const ClusterMgr::Node &
ClusterMgr::getNodeInfo(NodeId nodeId) const {
return theNodes[nodeId];
}
inline
Uint32
ClusterMgr::getNoOfConnectedNodes() const {
return noOfConnectedNodes;
}
inline
void
ClusterMgr::hb_received(NodeId nodeId) {
theNodes[nodeId].m_info.m_heartbeat_cnt= 0;
}
/*****************************************************************************/
/**
* @class ArbitMgr
* Arbitration manager. Runs in separate thread.
* Started only by a request from the kernel.
*/
extern "C" void* runArbitMgr_C(void* me);
class ArbitMgr
{
public:
ArbitMgr(class TransporterFacade &);
~ArbitMgr();
inline void setRank(unsigned n) { theRank = n; }
inline void setDelay(unsigned n) { theDelay = n; }
void doStart(const Uint32* theData);
void doChoose(const Uint32* theData);
void doStop(const Uint32* theData);
friend void* runArbitMgr_C(void* me);
private:
class TransporterFacade & theFacade;
unsigned theRank;
unsigned theDelay;
void threadMain();
NdbThread* theThread;
NdbMutex* theThreadMutex; // not really needed
struct ArbitSignal {
GlobalSignalNumber gsn;
ArbitSignalData data;
NDB_TICKS timestamp;
ArbitSignal() {}
inline void init(GlobalSignalNumber aGsn, const Uint32* aData) {
gsn = aGsn;
if (aData != NULL)
memcpy(&data, aData, sizeof(data));
else
memset(&data, 0, sizeof(data));
}
inline void setTimestamp() {
timestamp = NdbTick_CurrentMillisecond();
}
inline NDB_TICKS getTimediff() {
NDB_TICKS now = NdbTick_CurrentMillisecond();
return now < timestamp ? 0 : now - timestamp;
}
};
NdbMutex* theInputMutex;
NdbCondition* theInputCond;
int theInputTimeout;
bool theInputFull; // the predicate
ArbitSignal theInputBuffer; // shared buffer
void sendSignalToThread(ArbitSignal& aSignal);
enum State { // thread states
StateInit,
StateStarted, // thread started
StateChoose1, // received one valid REQ
StateChoose2, // received two valid REQs
StateFinished // finished one way or other
};
State theState;
enum Stop { // stop code in ArbitSignal.data.code
StopExit = 1, // at API exit
StopRequest = 2, // request from kernel
StopRestart = 3 // stop before restart
};
void threadStart(ArbitSignal& aSignal); // handle thread events
void threadChoose(ArbitSignal& aSignal);
void threadTimeout();
void threadStop(ArbitSignal& aSignal);
ArbitSignal theStartReq;
ArbitSignal theChooseReq1;
ArbitSignal theChooseReq2;
ArbitSignal theStopOrd;
void sendStartConf(ArbitSignal& aSignal, Uint32);
void sendChooseRef(ArbitSignal& aSignal, Uint32);
void sendChooseConf(ArbitSignal& aSignal, Uint32);
void sendStopRep(ArbitSignal& aSignal, Uint32);
void sendSignalToQmgr(ArbitSignal& aSignal);
};
#endif
|
