Synnefo » snf-ganeti » ganeti-local

  def ExpandNames(self):

    if self.op.instances:

      # Not getting the node allocation lock as only a specific set of

      # instances (and their nodes) is going to be acquired

      self.needed_locks = {

      self.wanted_names = self.owned_locks(locking.LEVEL_INSTANCE)

    self.wanted_instances = \

  def _EnsureChildSizes(self, disk):

    """Ensure children of the disk have the needed disk size.

                                             for nuuid in inst.all_nodes)])

        new_ipolicy = objects.FillIPolicy(self.new_ipolicy, group.ipolicy)

        ipol = masterd.instance.CalculateGroupIPolicy(cluster, group)

        if new:

          violations.update(new)

    for inst in self.all_inst_info.values():

      if inst.primary_node in [node.uuid for node in dangling_nodes]:

      elif inst.primary_node not in self.all_node_info:

    pretty_dangling = [

        "%s (%s)" %

        (node.name,

        for node in dangling_nodes]

    self._ErrorIf(bool(dangling_nodes), constants.CV_ECLUSTERDANGLINGNODES,

    self._ErrorIf(bool(no_node_instances), constants.CV_ECLUSTERDANGLINGINST,

                  None,

                  "the following instances have a non-existing primary-node:"

    return not self.bad

    self.group_uuid = self.cfg.LookupNodeGroup(self.op.group_name)

    # Get instances in node group; this is unsafe and needs verification later

      self.cfg.GetNodeGroupInstances(self.group_uuid, primary_only=True)

    self.needed_locks = {

      locking.LEVEL_NODEGROUP: [self.group_uuid],

      locking.LEVEL_NODE: [],

      # Get members of node group; this is unsafe and needs verification later

      nodes = set(self.cfg.GetNodeGroup(self.group_uuid).members)

      # In Exec(), we warn about mirrored instances that have primary and

      # secondary living in separate node groups. To fully verify that

      # volumes for these instances are healthy, we will need to do an

      # extra call to their secondaries. We ensure here those nodes will

      # be locked.

        # Important: access only the instances whose lock is owned

      self.needed_locks[locking.LEVEL_NODE] = nodes

    self.group_info = self.cfg.GetNodeGroup(self.group_uuid)

    group_node_uuids = set(self.group_info.members)

      self.cfg.GetNodeGroupInstances(self.group_uuid, primary_only=True)

    unlocked_node_uuids = \

        group_node_uuids.difference(self.owned_locks(locking.LEVEL_NODE))

    if unlocked_node_uuids:

      raise errors.OpPrereqError(

        utils.CommaJoin(self.cfg.GetNodeNames(unlocked_node_uuids)),

        errors.ECODE_STATE)

    self.all_node_info = self.cfg.GetAllNodesInfo()

    self.all_inst_info = self.cfg.GetAllInstancesInfo()

    self.my_node_info = dict((node_uuid, self.all_node_info[node_uuid])

                             for node_uuid in group_node_uuids)

    # We detect here the nodes that will need the extra RPC calls for verifying

    # split LV volumes; they should be locked.

          msg = "cannot reach the master IP"

        self._ErrorIf(True, constants.CV_ENODENET, ninfo.name, msg)

    """Verify an instance.

    This function checks to see if the required block devices are

    state.

    """

    groupinfo = self.cfg.GetAllNodeGroupsInfo()

    node_vol_should = {}

    cluster = self.cfg.GetClusterInfo()

    ipolicy = ganeti.masterd.instance.CalculateGroupIPolicy(cluster,

                                                            self.group_info)

                  utils.CommaJoin(err), code=self.ETYPE_WARNING)

      if n_img.offline or n_img.rpc_fail or n_img.lvm_fail:

        # ignore missing volumes on offline or broken nodes

        continue

        test = volume not in n_img.volumes

                      "volume %s missing on node %s", volume,

                    "instance not running on its primary node %s",

    diskdata = [(nname, success, status, idx)

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

      # node here

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

                    not success and not bad_snode,

                    "couldn't retrieve status for disk/%s on %s: %s",

                    idx, self.cfg.GetNodeName(nname), bdev_status)

         (bdev_status.is_degraded or

          bdev_status.ldisk_status != constants.LDS_OKAY):

        msg = "disk/%s on %s" % (idx, self.cfg.GetNodeName(nname))

          msg += "; state is '%s'" % \

                 constants.LDS_NAMES[bdev_status.ldisk_status]

    self._ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,

                  code=self.ETYPE_WARNING)

    if any(es_flags.values()):

        # Disk template not compatible with exclusive_storage: no instance

        # node should have the flag set

        es_nodes = [n

                    for (n, es) in es_flags.items()

                    if es]

                    "instance has template %s, which is not supported on nodes"

                    " that have exclusive storage set: %s",

                    utils.CommaJoin(self.cfg.GetNodeNames(es_nodes)))

        self._ErrorIf(disk.spindles is None,

                      "number of spindles not configured for disk %s while"

                      " exclusive storage is enabled, try running"

                      " gnt-cluster repair-disk-sizes", idx)

      instance_groups = {}

      pretty_list = [

        "%s (group %s)" % (utils.CommaJoin(self.cfg.GetNodeNames(nodes)),

                           groupinfo[group].name)

        # Sort so that we always list the primary node first.

        for group, nodes in sorted(instance_groups.items(),

                                   reverse=True)]

      self._ErrorIf(len(instance_groups) > 1,

                    constants.CV_EINSTANCESPLITGROUPS,

                    " different groups: %s", utils.CommaJoin(pretty_list),

                    code=self.ETYPE_WARNING)

    inst_nodes_offline = []

      s_img = node_image[snode]

      self._ErrorIf(s_img.rpc_fail and not s_img.offline, constants.CV_ENODERPC,

      if s_img.offline:

        inst_nodes_offline.append(snode)

    # warn that the instance lives on offline nodes

                  utils.CommaJoin(self.cfg.GetNodeNames(inst_nodes_offline)))

    # ... or ghost/non-vm_capable nodes

                    "instance lives on non-vm_capable node %s",

  def _VerifyOrphanVolumes(self, node_vol_should, node_image, reserved):

    """Verify if there are any unknown volumes in the cluster.

                      self.cfg.GetNodeName(node_uuid),

                      "volume %s is unknown", volume)

    """Verify N+1 Memory Resilience.

    Check that if one single node dies we can still start all the

        # nodes, and that's enough warning

        continue

      #TODO(dynmem): also consider ballooning out other instances

        needed_mem = 0

          if bep[constants.BE_AUTO_BALANCE]:

            needed_mem += bep[constants.BE_MINMEM]

        test = n_img.mfree < needed_mem

    # compute the DRBD minors

    node_drbd = {}

      self._ErrorIf(test, constants.CV_ECLUSTERCFG, None,

        # ghost instance should not be running, but otherwise we

        # don't give double warnings (both ghost instance and

        # unallocated minor in use)

      if test:

      else:

    # and now check them

    used_minors = nresult.get(constants.NV_DRBDLIST, [])

      # we cannot check drbd status

      return

      test = minor not in used_minors and must_exist

      self._ErrorIf(test, constants.CV_ENODEDRBD, ninfo.name,

    for minor in used_minors:

      test = minor not in node_drbd

      self._ErrorIf(test, constants.CV_ENODEDRBD, ninfo.name,

    if test:

      nimg.hyp_fail = True

    else:

  def _UpdateNodeInfo(self, ninfo, nresult, nimg, vg_name):

    """Verifies and computes a node information map

    @type node_uuids: list of strings

    @param node_uuids: Node UUIDs

    @param node_image: Node objects

    @param instanceinfo: Instance objects

    @rtype: {instance: {node: [(succes, payload)]}}

    @return: a dictionary of per-instance dictionaries with nodes as

    diskless = constants.DT_DISKLESS

    for nuuid in node_uuids:

      if not disks:

        # No need to collect data

      # _AnnotateDiskParams makes already copies of the disks

      devonly = []

        self.cfg.SetDiskID(anno_disk, nuuid)

        devonly.append(anno_disk)

                              node.name, idx, i)

              data.append((False, "Invalid result from the remote node"))

    # Add empty entries for diskless instances.

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

                      len(nuuids) <= len(instanceinfo[inst].all_nodes) and

    default_nicpp = cluster.nicparams[constants.PP_DEFAULT]

    if default_nicpp[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

      bridges.add(default_nicpp[constants.NIC_LINK])

        full_nic = cluster.SimpleFillNIC(nic.nicparams)

        if full_nic[constants.NIC_MODE] == constants.NIC_MODE_BRIDGED:

          bridges.add(full_nic[constants.NIC_LINK])

    if oob_paths:

      node_verify_param[constants.NV_OOB_PATHS] = oob_paths

        i_offline += 1

        if nuuid not in node_image:

          gnode = self.NodeImage(uuid=nuuid)

          gnode.ghost = (nuuid not in self.all_node_info)

          node_image[nuuid] = gnode

        nimg = node_image[snode]

        if pnode not in nimg.sbp:

          nimg.sbp[pnode] = []

    es_flags = rpc.GetExclusiveStorageForNodes(self.cfg,

                                               self.my_node_info.keys())

          self._VerifyNodeOS(node_i, nimg, refos_img)

        self._VerifyNodeBridges(node_i, nresult, bridges)

        # can no longer be done from _VerifyInstance below, since some of the

        # wrong instances could be from other node groups.)

                        "instance should not run on node %s", node_i.name)

          self._ErrorIf(not test, constants.CV_ENODEORPHANINSTANCE, node_i.name,

    self._VerifyGroupDRBDVersion(all_nvinfo)

    self._VerifyGroupLVM(node_image, vg_name)

                              node_image[node_uuid], vg_name)

    feedback_fn("* Verifying instance status")

      if verbose:

      # If the instance is non-redundant we cannot survive losing its primary

      # node, so we are not N+1 compliant.

        i_non_redundant.append(instance)

        i_non_a_balanced.append(instance)

    feedback_fn("* Verifying orphan volumes")

    # We will get spurious "unknown volume" warnings if any node of this group

    # is secondary for an instance whose primary is in another group. To avoid

    # them, we find these instances and add their volumes to node_vol_should.

        if (secondary in self.my_node_info

          break

    self._VerifyOrphanVolumes(node_vol_should, node_image, reserved)