Synnefo » snf-ganeti

  def perspective_blockdev_getmirrorstatus_multi(params):

    """Return the mirror status for a list of disks.

    """

    (node_disks, ) = params

    node_name = netutils.Hostname.GetSysName()

    disks = [objects.Disk.FromDict(dsk_s)

             for dsk_s in node_disks.get(node_name, [])]

    return [status.ToDict()

            for status in backend.BlockdevGetmirrorstatus(disks)]

  @staticmethod

  EINSTANCEFAULTYDISK = (TINSTANCE, "EINSTANCEFAULTYDISK")

  def _VerifyInstance(self, instance, instanceconfig, node_image,

                      diskstatus):

    diskdata = [(nname, disk, idx)

                for (nname, disks) in diskstatus.items()

                for idx, disk in enumerate(disks)]

    for nname, bdev_status, idx in diskdata:

      _ErrorIf(not bdev_status,

               self.EINSTANCEFAULTYDISK, instance,

               "couldn't retrieve status for disk/%s on %s", idx, nname)

      _ErrorIf(bdev_status and bdev_status.ldisk_status == constants.LDS_FAULTY,

               self.EINSTANCEFAULTYDISK, instance,

               "disk/%s on %s is faulty", idx, nname)

  def _CollectDiskInfo(self, nodelist, node_image, instanceinfo):

    """Gets per-disk status information for all instances.

    @type nodelist: list of strings

    @param nodelist: Node names

    @type node_image: dict of (name, L{objects.Node})

    @param node_image: Node objects

    @type instanceinfo: dict of (name, L{objects.Instance})

    @param instanceinfo: Instance objects

    """

    _ErrorIf = self._ErrorIf # pylint: disable-msg=C0103

    node_disks = {}

    node_disks_devonly = {}

    for nname in nodelist:

      disks = [(inst, disk)

               for instlist in [node_image[nname].pinst,

                                node_image[nname].sinst]

               for inst in instlist

               for disk in instanceinfo[inst].disks]

      if not disks:

        # No need to collect data

        continue

      node_disks[nname] = disks

      # Creating copies as SetDiskID below will modify the objects and that can

      # lead to incorrect data returned from nodes

      devonly = [dev.Copy() for (_, dev) in disks]

      for dev in devonly:

        self.cfg.SetDiskID(dev, nname)

      node_disks_devonly[nname] = devonly

    assert len(node_disks) == len(node_disks_devonly)

    # Collect data from all nodes with disks

    result = self.rpc.call_blockdev_getmirrorstatus_multi(node_disks.keys(),

                                                          node_disks_devonly)

    assert len(result) == len(node_disks)

    instdisk = {}

    for (nname, nres) in result.items():

      if nres.offline:

        # Ignore offline node

        continue

      disks = node_disks[nname]

      msg = nres.fail_msg

      _ErrorIf(msg, self.ENODERPC, nname,

               "while getting disk information: %s", nres.fail_msg)

      if msg:

        # No data from this node

        data = len(disks) * [None]

      else:

        data = nres.payload

      for ((inst, _), status) in zip(disks, data):

        instdisk.setdefault(inst, {}).setdefault(nname, []).append(status)

    assert compat.all(len(statuses) == len(instanceinfo[inst].disks) and

                      len(nnames) <= len(instanceinfo[inst].all_nodes)

                      for inst, nnames in instdisk.items()

                      for nname, statuses in nnames.items())

    return instdisk

    feedback_fn("* Gathering disk information (%s nodes)" % len(nodelist))

    instdisk = self._CollectDiskInfo(nodelist, node_image, instanceinfo)

      self._VerifyInstance(instance, inst_config, node_image,

                           instdisk[instance])

  def call_blockdev_getmirrorstatus_multi(self, node_list, node_disks):

    """Request status of (mirroring) devices from multiple nodes.

    This is a multi-node call.

    """

    result = self._MultiNodeCall(node_list, "blockdev_getmirrorstatus_multi",

                                 [dict((name, [dsk.ToDict() for dsk in disks])

                                       for name, disks in node_disks.items())])

    for nres in result.values():

      if not nres.fail_msg:

        nres.payload = [objects.BlockDevStatus.FromDict(i)

                        for i in nres.payload]

    return result

  @_RpcTimeout(_TMO_NORMAL)