Revision 1c3231aa lib/cmdlib/misc.py
| b/lib/cmdlib/misc.py | ||
|---|---|---|
| 47 | 47 |
|
| 48 | 48 |
""" |
| 49 | 49 |
if self.op.node_names: |
| 50 |
self.op.node_names = GetWantedNodes(self, self.op.node_names) |
|
| 51 |
lock_names = self.op.node_names |
|
| 50 |
(self.op.node_uuids, self.op.node_names) = \ |
|
| 51 |
GetWantedNodes(self, self.op.node_names) |
|
| 52 |
lock_node_uuids = self.op.node_uuids |
|
| 52 | 53 |
else: |
| 53 |
lock_names = locking.ALL_SET
|
|
| 54 |
lock_node_uuids = locking.ALL_SET
|
|
| 54 | 55 |
|
| 55 | 56 |
self.needed_locks = {
|
| 56 |
locking.LEVEL_NODE: lock_names,
|
|
| 57 |
locking.LEVEL_NODE: lock_node_uuids,
|
|
| 57 | 58 |
} |
| 58 | 59 |
|
| 59 | 60 |
self.share_locks[locking.LEVEL_NODE_ALLOC] = 1 |
| ... | ... | |
| 73 | 74 |
|
| 74 | 75 |
""" |
| 75 | 76 |
self.nodes = [] |
| 76 |
self.master_node = self.cfg.GetMasterNode() |
|
| 77 |
self.master_node_uuid = self.cfg.GetMasterNode() |
|
| 78 |
master_node_obj = self.cfg.GetNodeInfo(self.master_node_uuid) |
|
| 77 | 79 |
|
| 78 | 80 |
assert self.op.power_delay >= 0.0 |
| 79 | 81 |
|
| 80 |
if self.op.node_names:
|
|
| 82 |
if self.op.node_uuids:
|
|
| 81 | 83 |
if (self.op.command in self._SKIP_MASTER and |
| 82 |
self.master_node in self.op.node_names): |
|
| 83 |
master_node_obj = self.cfg.GetNodeInfo(self.master_node) |
|
| 84 |
master_node_obj.uuid in self.op.node_uuids): |
|
| 84 | 85 |
master_oob_handler = SupportsOob(self.cfg, master_node_obj) |
| 85 | 86 |
|
| 86 | 87 |
if master_oob_handler: |
| 87 | 88 |
additional_text = ("run '%s %s %s' if you want to operate on the"
|
| 88 | 89 |
" master regardless") % (master_oob_handler, |
| 89 | 90 |
self.op.command, |
| 90 |
self.master_node)
|
|
| 91 |
master_node_obj.name)
|
|
| 91 | 92 |
else: |
| 92 | 93 |
additional_text = "it does not support out-of-band operations" |
| 93 | 94 |
|
| 94 | 95 |
raise errors.OpPrereqError(("Operating on the master node %s is not"
|
| 95 | 96 |
" allowed for %s; %s") % |
| 96 |
(self.master_node, self.op.command,
|
|
| 97 |
(master_node_obj.name, self.op.command,
|
|
| 97 | 98 |
additional_text), errors.ECODE_INVAL) |
| 98 | 99 |
else: |
| 99 |
self.op.node_names = self.cfg.GetNodeList()
|
|
| 100 |
self.op.node_uuids = self.cfg.GetNodeList()
|
|
| 100 | 101 |
if self.op.command in self._SKIP_MASTER: |
| 101 |
self.op.node_names.remove(self.master_node)
|
|
| 102 |
self.op.node_uuids.remove(master_node_obj.uuid)
|
|
| 102 | 103 |
|
| 103 | 104 |
if self.op.command in self._SKIP_MASTER: |
| 104 |
assert self.master_node not in self.op.node_names
|
|
| 105 |
assert master_node_obj.uuid not in self.op.node_uuids
|
|
| 105 | 106 |
|
| 106 |
for (node_name, node) in self.cfg.GetMultiNodeInfo(self.op.node_names): |
|
| 107 |
for node_uuid in self.op.node_uuids: |
|
| 108 |
node = self.cfg.GetNodeInfo(node_uuid) |
|
| 107 | 109 |
if node is None: |
| 108 |
raise errors.OpPrereqError("Node %s not found" % node_name,
|
|
| 110 |
raise errors.OpPrereqError("Node %s not found" % node_uuid,
|
|
| 109 | 111 |
errors.ECODE_NOENT) |
| 110 |
else: |
|
| 111 |
self.nodes.append(node)
|
|
| 112 |
|
|
| 113 |
self.nodes.append(node) |
|
| 112 | 114 |
|
| 113 | 115 |
if (not self.op.ignore_status and |
| 114 | 116 |
(self.op.command == constants.OOB_POWER_OFF and not node.offline)): |
| 115 | 117 |
raise errors.OpPrereqError(("Cannot power off node %s because it is"
|
| 116 |
" not marked offline") % node_name,
|
|
| 118 |
" not marked offline") % node.name,
|
|
| 117 | 119 |
errors.ECODE_STATE) |
| 118 | 120 |
|
| 119 | 121 |
def Exec(self, feedback_fn): |
| 120 | 122 |
"""Execute OOB and return result if we expect any. |
| 121 | 123 |
|
| 122 | 124 |
""" |
| 123 |
master_node = self.master_node |
|
| 124 | 125 |
ret = [] |
| 125 | 126 |
|
| 126 | 127 |
for idx, node in enumerate(utils.NiceSort(self.nodes, |
| ... | ... | |
| 136 | 137 |
|
| 137 | 138 |
logging.info("Executing out-of-band command '%s' using '%s' on %s",
|
| 138 | 139 |
self.op.command, oob_program, node.name) |
| 139 |
result = self.rpc.call_run_oob(master_node, oob_program,
|
|
| 140 |
result = self.rpc.call_run_oob(self.master_node_uuid, oob_program,
|
|
| 140 | 141 |
self.op.command, node.name, |
| 141 | 142 |
self.op.timeout) |
| 142 | 143 |
|
| ... | ... | |
| 234 | 235 |
|
| 235 | 236 |
# The following variables interact with _QueryBase._GetNames |
| 236 | 237 |
if self.names: |
| 237 |
self.wanted = self.names
|
|
| 238 |
self.wanted = [lu.cfg.GetNodeInfoByName(name).uuid for name in self.names]
|
|
| 238 | 239 |
else: |
| 239 | 240 |
self.wanted = locking.ALL_SET |
| 240 | 241 |
|
| ... | ... | |
| 247 | 248 |
def _DiagnoseByProvider(rlist): |
| 248 | 249 |
"""Remaps a per-node return list into an a per-provider per-node dictionary |
| 249 | 250 |
|
| 250 |
@param rlist: a map with node names as keys and ExtStorage objects as values
|
|
| 251 |
@param rlist: a map with node uuids as keys and ExtStorage objects as values
|
|
| 251 | 252 |
|
| 252 | 253 |
@rtype: dict |
| 253 | 254 |
@return: a dictionary with extstorage providers as keys and as |
| 254 |
value another map, with nodes as keys and tuples of |
|
| 255 |
value another map, with node uuids as keys and tuples of
|
|
| 255 | 256 |
(path, status, diagnose, parameters) as values, eg:: |
| 256 | 257 |
|
| 257 |
{"provider1": {"node1": [(/usr/lib/..., True, "", [])]
|
|
| 258 |
"node2": [(/srv/..., False, "missing file")] |
|
| 259 |
"node3": [(/srv/..., True, "", [])] |
|
| 258 |
{"provider1": {"node_uuid1": [(/usr/lib/..., True, "", [])]
|
|
| 259 |
"node_uuid2": [(/srv/..., False, "missing file")]
|
|
| 260 |
"node_uuid3": [(/srv/..., True, "", [])]
|
|
| 260 | 261 |
} |
| 261 | 262 |
|
| 262 | 263 |
""" |
| ... | ... | |
| 264 | 265 |
# we build here the list of nodes that didn't fail the RPC (at RPC |
| 265 | 266 |
# level), so that nodes with a non-responding node daemon don't |
| 266 | 267 |
# make all OSes invalid |
| 267 |
good_nodes = [node_name for node_name in rlist
|
|
| 268 |
if not rlist[node_name].fail_msg]
|
|
| 269 |
for node_name, nr in rlist.items():
|
|
| 268 |
good_nodes = [node_uuid for node_uuid in rlist
|
|
| 269 |
if not rlist[node_uuid].fail_msg]
|
|
| 270 |
for node_uuid, nr in rlist.items():
|
|
| 270 | 271 |
if nr.fail_msg or not nr.payload: |
| 271 | 272 |
continue |
| 272 | 273 |
for (name, path, status, diagnose, params) in nr.payload: |
| ... | ... | |
| 274 | 275 |
# build a list of nodes for this os containing empty lists |
| 275 | 276 |
# for each node in node_list |
| 276 | 277 |
all_es[name] = {}
|
| 277 |
for nname in good_nodes:
|
|
| 278 |
all_es[name][nname] = []
|
|
| 278 |
for nuuid in good_nodes:
|
|
| 279 |
all_es[name][nuuid] = []
|
|
| 279 | 280 |
# convert params from [name, help] to (name, help) |
| 280 | 281 |
params = [tuple(v) for v in params] |
| 281 |
all_es[name][node_name].append((path, status, diagnose, params))
|
|
| 282 |
all_es[name][node_uuid].append((path, status, diagnose, params))
|
|
| 282 | 283 |
return all_es |
| 283 | 284 |
|
| 284 | 285 |
def _GetQueryData(self, lu): |
| ... | ... | |
| 291 | 292 |
if level != locking.LEVEL_CLUSTER) or |
| 292 | 293 |
self.do_locking or self.use_locking) |
| 293 | 294 |
|
| 294 |
valid_nodes = [node.name
|
|
| 295 |
valid_nodes = [node.uuid
|
|
| 295 | 296 |
for node in lu.cfg.GetAllNodesInfo().values() |
| 296 | 297 |
if not node.offline and node.vm_capable] |
| 297 | 298 |
pol = self._DiagnoseByProvider(lu.rpc.call_extstorage_diagnose(valid_nodes)) |
| ... | ... | |
| 382 | 383 |
|
| 383 | 384 |
def ExpandNames(self): |
| 384 | 385 |
if self.op.nodes: |
| 385 |
self.op.nodes = GetWantedNodes(self, self.op.nodes)
|
|
| 386 |
(self.op.node_uuids, self.op.nodes) = GetWantedNodes(self, self.op.nodes)
|
|
| 386 | 387 |
|
| 387 | 388 |
self.needed_locks = {
|
| 388 |
locking.LEVEL_NODE: self.op.nodes, |
|
| 389 |
locking.LEVEL_NODE: self.op.node_uuids,
|
|
| 389 | 390 |
} |
| 390 | 391 |
self.share_locks = {
|
| 391 | 392 |
locking.LEVEL_NODE: not self.op.use_locking, |
| ... | ... | |
| 403 | 404 |
owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE)) |
| 404 | 405 |
|
| 405 | 406 |
# Check if correct locks are held |
| 406 |
assert set(self.op.nodes).issubset(owned_nodes) |
|
| 407 |
assert set(self.op.node_uuids).issubset(owned_nodes)
|
|
| 407 | 408 |
|
| 408 |
rpcres = self.rpc.call_restricted_command(self.op.nodes, self.op.command) |
|
| 409 |
rpcres = self.rpc.call_restricted_command(self.op.node_uuids, |
|
| 410 |
self.op.command) |
|
| 409 | 411 |
|
| 410 | 412 |
result = [] |
| 411 | 413 |
|
| 412 |
for node_name in self.op.nodes:
|
|
| 413 |
nres = rpcres[node_name]
|
|
| 414 |
for node_uuid in self.op.node_uuids:
|
|
| 415 |
nres = rpcres[node_uuid]
|
|
| 414 | 416 |
if nres.fail_msg: |
| 415 | 417 |
msg = ("Command '%s' on node '%s' failed: %s" %
|
| 416 |
(self.op.command, node_name, nres.fail_msg)) |
|
| 418 |
(self.op.command, self.cfg.GetNodeName(node_uuid), |
|
| 419 |
nres.fail_msg)) |
|
| 417 | 420 |
result.append((False, msg)) |
| 418 | 421 |
else: |
| 419 | 422 |
result.append((True, nres.payload)) |
Also available in: Unified diff