Class: Flare::Tools::Cluster
- Inherits:
-
Object
- Object
- Flare::Tools::Cluster
show all
- Includes:
- Util::Constant
- Defined in:
- lib/flare/tools/cluster.rb
Overview
Description
Cluster is a class that discribes a cluster information.
Defined Under Namespace
Classes: NodeStat
Constant Summary
collapse
- State =
'state'
- Role =
'role'
- StateActive =
'active'
- StateDown =
'down'
- StateReady =
'ready'
- StatePrepare =
'prepare'
- RoleProxy =
'proxy'
- RoleMaster =
'master'
- RoleSlave =
'slave'
- StatPartition =
'partition'
- States =
{ "active" => '0', "prepare" => '1', "down" => '2', "ready" => '3' }
- Roles =
{ "master" => '0', "slave" => '1', "proxy" => '2' }
Util::Constant::DefalutBwlimit, Util::Constant::DefaultIndexServerName, Util::Constant::DefaultIndexServerPort, Util::Constant::DefaultNodePort, Util::Constant::DefaultTimeout, Util::Constant::STATUS_NG, Util::Constant::STATUS_OK
Class Method Summary
collapse
Instance Method Summary
collapse
Constructor Details
#initialize(index_server_hostname, index_server_port, nodes_stat) ⇒ Cluster
Returns a new instance of Cluster.
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
# File 'lib/flare/tools/cluster.rb', line 95
def initialize(index_server_hostname, index_server_port, nodes_stat)
@index_server_hostname = index_server_hostname
@index_server_port = index_server_port
@nodes_stat = nodes_stat
max_partition = -1
nodes_stat.each do |nodekey,node_stat|
p = node_stat[StatPartition].to_i
max_partition = p if p > max_partition
end
@partition = if max_partition >= 0
(0..max_partition).map {Hash.new}
else
[]
end
@partition_size = max_partition+1
nodes_stat.each do |nodekey,node_stat|
p = node_stat[StatPartition].to_i
@partition[p][nodekey] = node_stat if p >= 0
end
@nodes = {}
nodes_stat.each do |k,v|
@nodes[k] = NodeStat.new(v)
end
end
|
Class Method Details
.build(flare_xml) ⇒ Object
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
|
# File 'lib/flare/tools/cluster.rb', line 302
def self.build flare_xml
doc = REXML::Document.new flare_xml
nodemap = doc.elements['/boost_serialization/node_map']
thread_type = doc.elements['/boost_serialization/thread_type']
count = nodemap.elements['count'].get_text.to_s.to_i
item_version = nodemap.elements['item_version'].get_text.to_s.to_i
nodestat = []
nodemap.elements.each('item') do |item|
nodekey = item.elements['first'].get_text.to_s
elem = item.elements['second'].elements
node = {
'server_name' => elem['node_server_name'].get_text.to_s,
'server_port' => elem['node_server_port'].get_text.to_s,
'role' => elem['node_role'].get_text.to_s,
'state' => elem['node_state'].get_text.to_s,
'partition' => elem['node_partition'].get_text.to_s,
'balance' => elem['node_balance'].get_text.to_s,
'thread_type' => elem['node_thread_type'].get_text.to_s
}
nodestat << [nodekey, node]
end
Cluster.new(DefaultIndexServerName, DefaultIndexServerPort, nodestat)
end
|
Instance Method Details
#has_nodekey?(nodekey) ⇒ Boolean
235
236
237
|
# File 'lib/flare/tools/cluster.rb', line 235
def has_nodekey?(nodekey)
@nodes.has_key? nodekey
end
|
#master_and_slave_nodekeys ⇒ Object
210
211
212
|
# File 'lib/flare/tools/cluster.rb', line 210
def master_and_slave_nodekeys
nodekeys_ {|v| v[Role] == RoleMaster || v[Role] == RoleSlave }
end
|
#master_in_partition(p) ⇒ Object
172
173
174
175
176
177
178
|
# File 'lib/flare/tools/cluster.rb', line 172
def master_in_partition(p)
return nil if partition(p).nil?
partition(p).inject(nil) {|r,i|
nodekey, node = i
if node[Role] == RoleMaster then nodekey else r end
}
end
|
#master_nodekeys ⇒ Object
206
207
208
|
# File 'lib/flare/tools/cluster.rb', line 206
def master_nodekeys
nodekeys_ {|v| v[Role] == RoleMaster }
end
|
#node_stat(nodekey) ⇒ Object
214
215
216
|
# File 'lib/flare/tools/cluster.rb', line 214
def node_stat(nodekey)
@nodes[nodekey]
end
|
#nodekeys ⇒ Object
202
203
204
|
# File 'lib/flare/tools/cluster.rb', line 202
def nodekeys
nodekeys_
end
|
#nodekeys_(&block) ⇒ Object
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
# File 'lib/flare/tools/cluster.rb', line 185
def nodekeys_(&block)
unordered = if block.nil?
@nodes.keys
else
ret = []
@nodes.each do |k,v|
ret << k if block.call(v)
end
ret
end
unordered.sort_by do |i|
p = @nodes[i].partition
p = @partition_size if p < 0
[p, @nodes[i].role, i]
end
end
|
#partition(p) ⇒ Object
168
169
170
|
# File 'lib/flare/tools/cluster.rb', line 168
def partition(p)
@partition[p.to_i]
end
|
#partition_of_nodename(node) ⇒ Object
proxy -> -1 not found -> nil
228
229
230
231
232
233
|
# File 'lib/flare/tools/cluster.rb', line 228
def partition_of_nodename node
@nodes.each do |k,v|
return v[StatPartition].to_i if k == node
end
return nil
end
|
#partition_size ⇒ Object
222
223
224
|
# File 'lib/flare/tools/cluster.rb', line 222
def partition_size
@partition_size
end
|
#reconstructable?(nodekey) ⇒ Boolean
check if the partition of a nodekey has at least one active slave
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
# File 'lib/flare/tools/cluster.rb', line 121
def reconstructable?(nodekey)
node = node_stat(nodekey)
ret = if node[State] == StateActive
case node[Role]
when RoleProxy
false
when RoleSlave
true
when RoleMaster
slaves_in_partition(node[StatPartition]).inject(false) do |r, slave_nodekey|
r || node_stat(slave_nodekey)[State] == StateActive
end
else
error "unknown role: #{node[Role]}"
false
end
else
false
end
ret
end
|
#safely_reconstructable?(nodekey) ⇒ Boolean
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
# File 'lib/flare/tools/cluster.rb', line 144
def safely_reconstructable?(nodekey)
node = node_stat(nodekey)
return false if node[State] != StateActive
case node[Role]
when RoleProxy
false
when RoleSlave
slaves_in_partition(node[StatPartition]).inject(false) do |r, slave_nodekey|
if slave_nodekey != nodekey
node_stat(slave_nodekey)[State] == StateActive
else
r
end
end
when RoleMaster
count = slaves_in_partition(node[StatPartition]).inject(0) do |r, slave_nodekey|
if node_stat(slave_nodekey)[State] == StateActive then r+1 else r end
end
(count >= 2)
else
raise "internal error."
end
end
|
#serattr_(x) ⇒ Object
239
240
241
242
|
# File 'lib/flare/tools/cluster.rb', line 239
def serattr_ x
return "" if x.nil?
" class_id=\"#{x['class_id']}\" tracking_level=\"#{x['tracking_level']}\" version=\"#{x['version']}\""
end
|
#serialize(node_map_version = nil) ⇒ Object
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
|
# File 'lib/flare/tools/cluster.rb', line 244
def serialize(node_map_version = nil)
thread_type = 0
node_map_id = {"class_id"=>"0", "tracking_level"=>"0", "version"=>"0"}
item_id = {"class_id"=>"1", "tracking_level"=>"0", "version"=>"0"}
second_id = {"class_id"=>"2", "tracking_level"=>"0", "version"=>"0"}
output =<<"EOS"
<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<!DOCTYPE boost_serialization>
<boost_serialization signature="serialization::archive" version="4">
EOS
if node_map_version
output +=<<"EOS"
<version>#{node_map_version}</version>
EOS
end
output +=<<"EOS"
<node_map#{serattr_(node_map_id)}>
\t<count>#{@nodes.size}</count>
\t<item_version>0</item_version>
EOS
@nodes.each do |k,v|
node_server_name, node_server_port = k.split(':')
node_role = Roles[v['role']]
node_state = States[v['state']]
node_partition = v['partition']
node_balance = v['balance']
node_thread_type = v['thread_type'].to_i
output +=<<"EOS"
\t<item#{serattr_(item_id)}>
\t\t<first>#{k}</first>
\t\t<second#{serattr_(second_id)}>
\t\t\t<node_server_name>#{node_server_name}</node_server_name>
\t\t\t<node_server_port>#{node_server_port}</node_server_port>
\t\t\t<node_role>#{node_role}</node_role>
\t\t\t<node_state>#{node_state}</node_state>
\t\t\t<node_partition>#{node_partition}</node_partition>
\t\t\t<node_balance>#{node_balance}</node_balance>
\t\t\t<node_thread_type>#{node_thread_type}</node_thread_type>
\t\t</second>
\t</item>
EOS
item_id = nil
second_id = nil
thread_type = node_thread_type+1 if node_thread_type >= thread_type
end
output +=<<"EOS"
</node_map>
<thread_type>#{thread_type}</thread_type>
</boost_serialization>
EOS
output
end
|
#size ⇒ Object
218
219
220
|
# File 'lib/flare/tools/cluster.rb', line 218
def size
@nodes.size
end
|
#slaves_in_partition(p) ⇒ Object
180
181
182
183
|
# File 'lib/flare/tools/cluster.rb', line 180
def slaves_in_partition(p)
return nil if partition(p).nil?
partition(p).inject([]) {|r,i| if i[1][Role] == RoleSlave then r << i[0] else r end}
end
|