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
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
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
|
# Copyright (C) 2018 Red Hat, Inc. <http://www.redhat.com>
#
# 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; either version 2 of the License, or
# any later version.
#
# 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.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
"""
Description: Library for gluster peer operations.
"""
import json
import httplib
from glustolibs.gluster.rest import RestClient
from glusto.core import Glusto as g
def peer_probe(mnode, server):
"""Probe the specified server.
Args:
mnode (str): Node on which command has to be executed.
server (str): Server to be peer probed.
Returns:
tuple: Tuple containing three elements (ret, out, err).
The first element 'ret' is of type 'int' and is the return value
of command execution.
The second element 'out' is of type 'str' and is the stdout value
of the command execution.
The third element 'err' is of type 'str' and is the error message
and error code of the the command execution.
"""
data = {"addresses": [server]}
return RestClient(mnode).handle_request('POST', "/v1/peers", httplib.CREATED, data)
def pool_list(mnode):
"""Runs 'gluster pool list' command on the specified node.
Args:
mnode (str): Node on which command has to be executed.
Returns:
tuple: Tuple containing three elements (ret, out, err).
The first element 'ret' is of type 'int' and is the return value
of command execution.
The second element 'out' is of type 'str' and is the stdout value
of the command execution.
The third element 'err' is of type 'str' and is the stderr value
of the command execution.
"""
return RestClient(mnode).handle_request('GET', "/v1/peers", httplib.OK, None)
def peer_detach(mnode, server):
""" Detach the specified server.
Args:
mnode (str): Node on which command has to be executed.
server (str): Server to be peer detached.
Returns:
tuple: Tuple containing three elements (ret, out, err).
The first element 'ret' is of type 'int' and is the return value
of command execution.
The second element 'out' is of type 'str' and is the stdout value
of the command execution.
The third element 'err' is of type 'str' and is the stderr value
of the command execution.
"""
server_id = get_peer_id(mnode, server)
ret, out, err = RestClient(mnode).handle_request('DELETE', "/v1/peers/%s"
% server_id, httplib.NO_CONTENT, None)
if ret != httplib.NO_CONTENT:
returncode = 1
g.log.error("Failed to peer detach the node '%s'.", server)
else:
returncode = 0
return (returncode, out, err)
def peer_status(mnode, peer=None):
""" Fetches the peer status
Args:
mnode (str): Node on which command has to be executed.
Returns:
tuple: Tuple containing three elements (ret, out, err).
The first element 'ret' is of type 'int' and is the return value
of command execution.
The second element 'out' is of type 'str' and is the stdout value
of the command execution.
The third element 'err' is of type 'str' and is the stderr value
of the command execution.
"""
path = "/v1/peers"
if peer:
peerid = get_peer_id(mnode, peer)
path = "%s/%s" % (path, peerid)
return RestClient(mnode).handle_request('GET', path, httplib.OK, None)
def peer_edit(mnode, peerid, zone):
""" Edits the peer zone
_
Args:
mnode (str): Node on which command has to be executed.
peerid (str): The peerid of the peer.
Zone (str): The zone details that has to be edited.
Returns:
tuple: Tuple containing three elements (ret, out, err).
The first element 'ret' is of type 'int' and is the return value
of command execution.
The second element 'out' is of type 'str' and is the stdout value
of the command execution.
The third element 'err' is of type 'str' and is the stderr value
of the command execution.
"""
data = {"metadata": {"zone": zone}}
return RestClient(mnode).handle_request("POST", "/v1/peers/%s" % peerid,
httplib.CREATED, data)
def get_peer_id(mnode, server):
"""
Returns the peer_id of the given server
Args:
server (str) : A server to fetch peer-ids
Returns:
server_id (str) : Peer-id of the given server/peer
"""
from glustolibs.gluster.lib_utils import get_ip_from_hostname
_ip = node = ids = []
_ip = get_ip_from_hostname([server])
server = ''.join(_ip)
_, out, _ = pool_list(mnode)
output = json.loads(out)
for elem in output:
item = elem['client-addresses'][1].split(":")
node.append(item[0])
item = elem['id']
ids.append(item)
if server in node:
return ids[-1]
def is_peer_connected(mnode, servers):
"""Checks whether specified peer is in cluster and 'Connected' state.
Args:
mnode (str): Node from which peer probe has to be executed.
servers (str): A server| list of servers to be validated.
Returns
bool : True on success (peer in cluster and connected), False on
failure.
"""
from glustolibs.gluster.lib_utils import to_list
servers = to_list(servers)
for server in servers:
_, out, _ = peer_status(mnode, server)
out = json.loads(out)
if not out['online']:
g.log.error("The peer %s is not connected", server)
return False
return True
def nodes_from_pool_list(mnode):
"""Return list of nodes from the 'gluster pool list'.
Args:
mnode (str): Node on which command has to be executed.
Returns:
NoneType: None if command execution fails.
list: List of nodes in pool on Success, Empty list on failure.
"""
_, pool_list_data, _ = pool_list(mnode)
server_list = json.loads(pool_list_data)
if server_list is None:
g.log.error("Unable to get Nodes from the pool list command.")
return None
nodes = []
for server in server_list:
nodes.append(server['name'])
return nodes
def peer_probe_servers(mnode, servers, validate=True):
"""Probe specified servers and validate whether probed servers
are in cluster and connected state if validate is set to True.
Args:
mnode (str): Node on which command has to be executed.
servers (str|list): A server|List of servers to be peer probed.
Kwargs:
validate (bool): True to validate if probed peer is in cluster and
connected state. False otherwise. Defaults to True.
Returns:
bool: True on success and False on failure.
"""
from glustolibs.gluster.lib_utils import to_list
servers = to_list(servers)
if mnode in servers:
servers.remove(mnode)
# Get list of nodes from 'gluster pool list'
nodes_in_pool_list = nodes_from_pool_list(mnode)
if not nodes_in_pool_list:
g.log.error("Unable to get nodes from gluster pool list. "
"Failing peer probe.")
return False
for server in servers:
if server not in nodes_in_pool_list:
ret, _, _ = peer_probe(mnode, server)
if ret != 0:
g.log.error("Failed to peer probe the node '%s'.", server)
return False
g.log.info("Successfully peer probed the node '%s'.", server)
# Validating whether peer is in connected state after peer probe
if validate:
_rc = False
i = 0
while i < 200:
if is_peer_connected(mnode, servers):
_rc = True
break
if not _rc:
g.log.error("Peers are in not connected state")
g.log.info("All peers are in connected state")
return _rc
def peer_detach_servers(mnode, servers, validate=True):
"""Detach peers and validate status of peer if validate is set to True.
Args:
mnode (str): Node on which command has to be executed.
servers (str|list): A server|List of servers to be detached.
Kwargs:
validate (bool): True if status of the peer needs to be validated,
False otherwise. Defaults to True.
Returns:
bool: True on success and False on failure.
"""
from glustolibs.gluster.lib_utils import to_list
servers = to_list(servers)
if mnode in servers:
servers.remove(mnode)
for server in servers:
ret, _, _ = peer_detach(mnode, server)
if ret:
g.log.error("Failed to peer detach the node '%s'.", server)
return False
# Validating whether peer detach is successful
if validate:
i = 0
while i < 200:
count = 0
nodes_in_pool = nodes_from_pool_list(mnode)
_rc = True
for server in servers:
if server in nodes_in_pool:
g.log.error("Peer '%s' still in pool", server)
_rc = False
count += 1
if not count:
break
if not _rc:
g.log.error("Validation after peer detach failed.")
g.log.info("Validation after peer detach is successful")
return _rc
|
