Synnefo » snf-ganeti

  opcodelist.append(opcodes.OpOobCommand(node_names=[node],

                                         command=oob_command))

    (_, data_tuple) = result[0]

    if data_tuple[0] != constants.RS_NORMAL:

      if data_tuple[0] == constants.RS_UNAVAIL:

        result = "OOB is not supported"

        result = "RPC failed, look out for warning in the output"

      ToStderr(result)

      return constants.EXIT_FAILURE

    else:

      if oob_command == constants.OOB_POWER_STATUS:

        text = "The machine is %spowered"

        if data_tuple[1][constants.OOB_POWER_STATUS_POWERED]:

          result = text % ""

        else:

          result = text % "not "

        ToStdout(result)

    self.nodes = []

    for node_name in self.op.node_names:

      node = self.cfg.GetNodeInfo(node_name)

      if node is None:

        raise errors.OpPrereqError("Node %s not found" % node_name,

                                   errors.ECODE_NOENT)

      else:

        self.nodes.append(node)

      if (self.op.command == constants.OOB_POWER_OFF and not node.offline):

        raise errors.OpPrereqError(("Cannot power off node %s because it is"

                                    " not marked offline") % node_name,

                                   errors.ECODE_STATE)

    if self.op.node_names:

      self.op.node_names = [_ExpandNodeName(self.cfg, name)

                            for name in self.op.node_names]

    else:

      self.op.node_names = self.cfg.GetNodeList()

      locking.LEVEL_NODE: self.op.node_names,

    ret = []

    for node in self.nodes:

      node_entry = [(constants.RS_NORMAL, node.name)]

      ret.append(node_entry)

      oob_program = _SupportsOob(self.cfg, node)

      if not oob_program:

        node_entry.append((constants.RS_UNAVAIL, None))

        continue

      logging.info("Executing out-of-band command '%s' using '%s' on %s",

                   self.op.command, oob_program, node.name)

      result = self.rpc.call_run_oob(master_node, oob_program,

                                     self.op.command, node.name,

                                     self.op.timeout)

      result.Raise("An error occurred on execution of OOB helper")

      if result.fail_msg:

        self.LogWarning("On node '%s' out-of-band RPC failed with: %s",

                        node.name, result.fail_msg)

        node_entry.append((constants.RS_NODATA, None))

      else:

        try:

          self._CheckPayload(result)

        except errors.OpExecError, err:

          self.LogWarning("The payload returned by '%s' is not valid: %s",

                          node.name, err)

          node_entry.append((constants.RS_NODATA, None))

        else:

          if self.op.command == constants.OOB_HEALTH:

            # For health we should log important events

            for item, status in result.payload:

              if status in [constants.OOB_STATUS_WARNING,

                            constants.OOB_STATUS_CRITICAL]:

                self.LogWarning("On node '%s' item '%s' has status '%s'",

                                node.name, item, status)

          if self.op.command == constants.OOB_POWER_ON:

            node.powered = True

          elif self.op.command == constants.OOB_POWER_OFF:

            node.powered = False

          elif self.op.command == constants.OOB_POWER_STATUS:

            powered = result.payload[constants.OOB_POWER_STATUS_POWERED]

            if powered != node.powered:

              logging.warning(("Recorded power state (%s) of node '%s' does not"

                               " match actual power state (%s)"), node.powered,

                              node.name, powered)

          # For configuration changing commands we should update the node

          if self.op.command in (constants.OOB_POWER_ON,

                                 constants.OOB_POWER_OFF):

            self.cfg.Update(node, feedback_fn)

          node_entry.append((constants.RS_NORMAL, result.payload))

    return ret

    ("node_names", ht.EmptyList, ht.TListOf(ht.TNonEmptyString)),