code.grnet.gr Git - ganeti-local/blob - lib/cmdlib/misc.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Miscellaneous logical units that don't fit into any category."""
  23
  24 import logging
  25 import time
  26
  27 from ganeti import compat
  28 from ganeti import constants
  29 from ganeti import errors
  30 from ganeti import locking
  31 from ganeti import qlang
  32 from ganeti import query
  33 from ganeti import utils
  34 from ganeti.cmdlib.base import NoHooksLU, QueryBase
  35 from ganeti.cmdlib.common import GetWantedNodes, SupportsOob
  36
  37
  38 class LUOobCommand(NoHooksLU):
  39   """Logical unit for OOB handling.
  40
  41   """
  42   REQ_BGL = False
  43   _SKIP_MASTER = (constants.OOB_POWER_OFF, constants.OOB_POWER_CYCLE)
  44
  45   def ExpandNames(self):
  46     """Gather locks we need.
  47
  48     """
  49     if 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
  53     else:
  54       lock_node_uuids = locking.ALL_SET
  55
  56     self.needed_locks = {
  57       locking.LEVEL_NODE: lock_node_uuids,
  58       }
  59
  60     self.share_locks[locking.LEVEL_NODE_ALLOC] = 1
  61
  62     if not self.op.node_names:
  63       # Acquire node allocation lock only if all nodes are affected
  64       self.needed_locks[locking.LEVEL_NODE_ALLOC] = locking.ALL_SET
  65
  66   def CheckPrereq(self):
  67     """Check prerequisites.
  68
  69     This checks:
  70      - the node exists in the configuration
  71      - OOB is supported
  72
  73     Any errors are signaled by raising errors.OpPrereqError.
  74
  75     """
  76     self.nodes = []
  77     self.master_node_uuid = self.cfg.GetMasterNode()
  78     master_node_obj = self.cfg.GetNodeInfo(self.master_node_uuid)
  79
  80     assert self.op.power_delay >= 0.0
  81
  82     if self.op.node_uuids:
  83       if (self.op.command in self._SKIP_MASTER and
  84           master_node_obj.uuid in self.op.node_uuids):
  85         master_oob_handler = SupportsOob(self.cfg, master_node_obj)
  86
  87         if master_oob_handler:
  88           additional_text = ("run '%s %s %s' if you want to operate on the"
  89                              " master regardless") % (master_oob_handler,
  90                                                       self.op.command,
  91                                                       master_node_obj.name)
  92         else:
  93           additional_text = "it does not support out-of-band operations"
  94
  95         raise errors.OpPrereqError(("Operating on the master node %s is not"
  96                                     " allowed for %s; %s") %
  97                                    (master_node_obj.name, self.op.command,
  98                                     additional_text), errors.ECODE_INVAL)
  99     else:
 100       self.op.node_uuids = self.cfg.GetNodeList()
 101       if self.op.command in self._SKIP_MASTER:
 102         self.op.node_uuids.remove(master_node_obj.uuid)
 103
 104     if self.op.command in self._SKIP_MASTER:
 105       assert master_node_obj.uuid not in self.op.node_uuids
 106
 107     for node_uuid in self.op.node_uuids:
 108       node = self.cfg.GetNodeInfo(node_uuid)
 109       if node is None:
 110         raise errors.OpPrereqError("Node %s not found" % node_uuid,
 111                                    errors.ECODE_NOENT)
 112
 113       self.nodes.append(node)
 114
 115       if (not self.op.ignore_status and
 116           (self.op.command == constants.OOB_POWER_OFF and not node.offline)):
 117         raise errors.OpPrereqError(("Cannot power off node %s because it is"
 118                                     " not marked offline") % node.name,
 119                                    errors.ECODE_STATE)
 120
 121   def Exec(self, feedback_fn):
 122     """Execute OOB and return result if we expect any.
 123
 124     """
 125     ret = []
 126
 127     for idx, node in enumerate(utils.NiceSort(self.nodes,
 128                                               key=lambda node: node.name)):
 129       node_entry = [(constants.RS_NORMAL, node.name)]
 130       ret.append(node_entry)
 131
 132       oob_program = SupportsOob(self.cfg, node)
 133
 134       if not oob_program:
 135         node_entry.append((constants.RS_UNAVAIL, None))
 136         continue
 137
 138       logging.info("Executing out-of-band command '%s' using '%s' on %s",
 139                    self.op.command, oob_program, node.name)
 140       result = self.rpc.call_run_oob(self.master_node_uuid, oob_program,
 141                                      self.op.command, node.name,
 142                                      self.op.timeout)
 143
 144       if result.fail_msg:
 145         self.LogWarning("Out-of-band RPC failed on node '%s': %s",
 146                         node.name, result.fail_msg)
 147         node_entry.append((constants.RS_NODATA, None))
 148       else:
 149         try:
 150           self._CheckPayload(result)
 151         except errors.OpExecError, err:
 152           self.LogWarning("Payload returned by node '%s' is not valid: %s",
 153                           node.name, err)
 154           node_entry.append((constants.RS_NODATA, None))
 155         else:
 156           if self.op.command == constants.OOB_HEALTH:
 157             # For health we should log important events
 158             for item, status in result.payload:
 159               if status in [constants.OOB_STATUS_WARNING,
 160                             constants.OOB_STATUS_CRITICAL]:
 161                 self.LogWarning("Item '%s' on node '%s' has status '%s'",
 162                                 item, node.name, status)
 163
 164           if self.op.command == constants.OOB_POWER_ON:
 165             node.powered = True
 166           elif self.op.command == constants.OOB_POWER_OFF:
 167             node.powered = False
 168           elif self.op.command == constants.OOB_POWER_STATUS:
 169             powered = result.payload[constants.OOB_POWER_STATUS_POWERED]
 170             if powered != node.powered:
 171               logging.warning(("Recorded power state (%s) of node '%s' does not"
 172                                " match actual power state (%s)"), node.powered,
 173                               node.name, powered)
 174
 175           # For configuration changing commands we should update the node
 176           if self.op.command in (constants.OOB_POWER_ON,
 177                                  constants.OOB_POWER_OFF):
 178             self.cfg.Update(node, feedback_fn)
 179
 180           node_entry.append((constants.RS_NORMAL, result.payload))
 181
 182           if (self.op.command == constants.OOB_POWER_ON and
 183               idx < len(self.nodes) - 1):
 184             time.sleep(self.op.power_delay)
 185
 186     return ret
 187
 188   def _CheckPayload(self, result):
 189     """Checks if the payload is valid.
 190
 191     @param result: RPC result
 192     @raises errors.OpExecError: If payload is not valid
 193
 194     """
 195     errs = []
 196     if self.op.command == constants.OOB_HEALTH:
 197       if not isinstance(result.payload, list):
 198         errs.append("command 'health' is expected to return a list but got %s" %
 199                     type(result.payload))
 200       else:
 201         for item, status in result.payload:
 202           if status not in constants.OOB_STATUSES:
 203             errs.append("health item '%s' has invalid status '%s'" %
 204                         (item, status))
 205
 206     if self.op.command == constants.OOB_POWER_STATUS:
 207       if not isinstance(result.payload, dict):
 208         errs.append("power-status is expected to return a dict but got %s" %
 209                     type(result.payload))
 210
 211     if self.op.command in [
 212       constants.OOB_POWER_ON,
 213       constants.OOB_POWER_OFF,
 214       constants.OOB_POWER_CYCLE,
 215       ]:
 216       if result.payload is not None:
 217         errs.append("%s is expected to not return payload but got '%s'" %
 218                     (self.op.command, result.payload))
 219
 220     if errs:
 221       raise errors.OpExecError("Check of out-of-band payload failed due to %s" %
 222                                utils.CommaJoin(errs))
 223
 224
 225 class ExtStorageQuery(QueryBase):
 226   FIELDS = query.EXTSTORAGE_FIELDS
 227
 228   def ExpandNames(self, lu):
 229     # Lock all nodes in shared mode
 230     # Temporary removal of locks, should be reverted later
 231     # TODO: reintroduce locks when they are lighter-weight
 232     lu.needed_locks = {}
 233     #self.share_locks[locking.LEVEL_NODE] = 1
 234     #self.needed_locks[locking.LEVEL_NODE] = locking.ALL_SET
 235
 236     # The following variables interact with _QueryBase._GetNames
 237     if self.names:
 238       self.wanted = [lu.cfg.GetNodeInfoByName(name).uuid for name in self.names]
 239     else:
 240       self.wanted = locking.ALL_SET
 241
 242     self.do_locking = self.use_locking
 243
 244   def DeclareLocks(self, lu, level):
 245     pass
 246
 247   @staticmethod
 248   def _DiagnoseByProvider(rlist):
 249     """Remaps a per-node return list into an a per-provider per-node dictionary
 250
 251     @param rlist: a map with node uuids as keys and ExtStorage objects as values
 252
 253     @rtype: dict
 254     @return: a dictionary with extstorage providers as keys and as
 255         value another map, with node uuids as keys and tuples of
 256         (path, status, diagnose, parameters) as values, eg::
 257
 258           {"provider1": {"node_uuid1": [(/usr/lib/..., True, "", [])]
 259                          "node_uuid2": [(/srv/..., False, "missing file")]
 260                          "node_uuid3": [(/srv/..., True, "", [])]
 261           }
 262
 263     """
 264     all_es = {}
 265     # we build here the list of nodes that didn't fail the RPC (at RPC
 266     # level), so that nodes with a non-responding node daemon don't
 267     # make all OSes invalid
 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():
 271       if nr.fail_msg or not nr.payload:
 272         continue
 273       for (name, path, status, diagnose, params) in nr.payload:
 274         if name not in all_es:
 275           # build a list of nodes for this os containing empty lists
 276           # for each node in node_list
 277           all_es[name] = {}
 278           for nuuid in good_nodes:
 279             all_es[name][nuuid] = []
 280         # convert params from [name, help] to (name, help)
 281         params = [tuple(v) for v in params]
 282         all_es[name][node_uuid].append((path, status, diagnose, params))
 283     return all_es
 284
 285   def _GetQueryData(self, lu):
 286     """Computes the list of nodes and their attributes.
 287
 288     """
 289     # Locking is not used
 290     assert not (compat.any(lu.glm.is_owned(level)
 291                            for level in locking.LEVELS
 292                            if level != locking.LEVEL_CLUSTER) or
 293                 self.do_locking or self.use_locking)
 294
 295     valid_nodes = [node.uuid
 296                    for node in lu.cfg.GetAllNodesInfo().values()
 297                    if not node.offline and node.vm_capable]
 298     pol = self._DiagnoseByProvider(lu.rpc.call_extstorage_diagnose(valid_nodes))
 299
 300     data = {}
 301
 302     nodegroup_list = lu.cfg.GetNodeGroupList()
 303
 304     for (es_name, es_data) in pol.items():
 305       # For every provider compute the nodegroup validity.
 306       # To do this we need to check the validity of each node in es_data
 307       # and then construct the corresponding nodegroup dict:
 308       #      { nodegroup1: status
 309       #        nodegroup2: status
 310       #      }
 311       ndgrp_data = {}
 312       for nodegroup in nodegroup_list:
 313         ndgrp = lu.cfg.GetNodeGroup(nodegroup)
 314
 315         nodegroup_nodes = ndgrp.members
 316         nodegroup_name = ndgrp.name
 317         node_statuses = []
 318
 319         for node in nodegroup_nodes:
 320           if node in valid_nodes:
 321             if es_data[node] != []:
 322               node_status = es_data[node][0][1]
 323               node_statuses.append(node_status)
 324             else:
 325               node_statuses.append(False)
 326
 327         if False in node_statuses:
 328           ndgrp_data[nodegroup_name] = False
 329         else:
 330           ndgrp_data[nodegroup_name] = True
 331
 332       # Compute the provider's parameters
 333       parameters = set()
 334       for idx, esl in enumerate(es_data.values()):
 335         valid = bool(esl and esl[0][1])
 336         if not valid:
 337           break
 338
 339         node_params = esl[0][3]
 340         if idx == 0:
 341           # First entry
 342           parameters.update(node_params)
 343         else:
 344           # Filter out inconsistent values
 345           parameters.intersection_update(node_params)
 346
 347       params = list(parameters)
 348
 349       # Now fill all the info for this provider
 350       info = query.ExtStorageInfo(name=es_name, node_status=es_data,
 351                                   nodegroup_status=ndgrp_data,
 352                                   parameters=params)
 353
 354       data[es_name] = info
 355
 356     # Prepare data in requested order
 357     return [data[name] for name in self._GetNames(lu, pol.keys(), None)
 358             if name in data]
 359
 360
 361 class LUExtStorageDiagnose(NoHooksLU):
 362   """Logical unit for ExtStorage diagnose/query.
 363
 364   """
 365   REQ_BGL = False
 366
 367   def CheckArguments(self):
 368     self.eq = ExtStorageQuery(qlang.MakeSimpleFilter("name", self.op.names),
 369                                self.op.output_fields, False)
 370
 371   def ExpandNames(self):
 372     self.eq.ExpandNames(self)
 373
 374   def Exec(self, feedback_fn):
 375     return self.eq.OldStyleQuery(self)
 376
 377
 378 class LURestrictedCommand(NoHooksLU):
 379   """Logical unit for executing restricted commands.
 380
 381   """
 382   REQ_BGL = False
 383
 384   def ExpandNames(self):
 385     if self.op.nodes:
 386       (self.op.node_uuids, self.op.nodes) = GetWantedNodes(self, self.op.nodes)
 387
 388     self.needed_locks = {
 389       locking.LEVEL_NODE: self.op.node_uuids,
 390       }
 391     self.share_locks = {
 392       locking.LEVEL_NODE: not self.op.use_locking,
 393       }
 394
 395   def CheckPrereq(self):
 396     """Check prerequisites.
 397
 398     """
 399
 400   def Exec(self, feedback_fn):
 401     """Execute restricted command and return output.
 402
 403     """
 404     owned_nodes = frozenset(self.owned_locks(locking.LEVEL_NODE))
 405
 406     # Check if correct locks are held
 407     assert set(self.op.node_uuids).issubset(owned_nodes)
 408
 409     rpcres = self.rpc.call_restricted_command(self.op.node_uuids,
 410                                               self.op.command)
 411
 412     result = []
 413
 414     for node_uuid in self.op.node_uuids:
 415       nres = rpcres[node_uuid]
 416       if nres.fail_msg:
 417         msg = ("Command '%s' on node '%s' failed: %s" %
 418                (self.op.command, self.cfg.GetNodeName(node_uuid),
 419                 nres.fail_msg))
 420         result.append((False, msg))
 421       else:
 422         result.append((True, nres.payload))
 423
 424     return result