Synnefo » snf-ganeti

	src/Ganeti/OpCodes.hs \

	src/Ganeti/OpParams.hs \

	src/Ganeti/Path.hs \

	src/Ganeti/Query/Common.hs \

	src/Ganeti/Query/Export.hs \

	src/Ganeti/Query/Filter.hs \

  shutil.rmtree(status_dir, ignore_errors=True)

  """Sets the physical ID on disks and returns the block devices.

  """

  # set the correct physical ID

  for cf in disks:

  bdevs = []

  return bdevs

  """Disconnects the network on a list of drbd devices.

  """

  # disconnect disks

  for rd in bdevs:

            err, exc=True)

  """Attaches the network on a list of drbd devices.

  """

  if multimaster:

    for idx, rd in enumerate(bdevs):

        _Fail("Can't change to primary mode: %s", err)

  """Wait until DRBDs have synchronized.

  """

      raise utils.RetryAgain()

    return stats

  min_resync = 100

  alldone = True

    mac_prefix=mac_prefix,

    volume_group_name=vg_name,

    tcpudp_port_pool=set(),

    master_ip=clustername.ip,

    master_netmask=master_netmask,

    master_netdev=master_netdev,

                                                _INITCONF_ECID)

  master_node_config.uuid = uuid_generator.Generate([], utils.NewUUID,

                                                    _INITCONF_ECID)

  nodes = {

    }

  default_nodegroup = objects.NodeGroup(

    uuid=uuid_generator.Generate([], utils.NewUUID, _INITCONF_ECID),

    name=constants.INITIAL_NODE_GROUP_NAME,

    diskparams={},

    )

  nodegroups = {

                  mode=0600)

  """Execute the last steps of cluster destroy

  This function shuts down all the daemons, completing the destroy

  modify_ssh_setup = cfg.GetClusterInfo().modify_ssh_setup

  runner = rpc.BootstrapRunner()

  master_params = cfg.GetMasterNetworkParameters()

  ems = cfg.GetUseExternalMipScript()

  msg = result.fail_msg

  if msg:

    logging.warning("Could not disable the master IP: %s", msg)

  msg = result.fail_msg

  if msg:

    logging.warning("Could not disable the master role: %s", msg)

  msg = result.fail_msg

  if msg:

    logging.warning("Could not shutdown the node daemon and cleanup"

  sstore = ssconf.SimpleStore()

  old_master, new_master = ssconf.GetMasterAndMyself(sstore)

  mc_list = sstore.GetMasterCandidates()

  if old_master == new_master:

                               errors.ECODE_STATE)

  if not no_voting:

    if vote_list:

      voted_master = vote_list[0][0]

    # configuration data

    cfg = config.ConfigWriter(accept_foreign=True)

    cluster_info = cfg.GetClusterInfo()

    # this will also regenerate the ssconf files, since we updated the

    # cluster info

    cfg.Update(cluster_info, logging.error)

  runner = rpc.BootstrapRunner()

  master_params = cfg.GetMasterNetworkParameters()

  ems = cfg.GetUseExternalMipScript()

                                                 master_params, ems)

  msg = result.fail_msg

  return old_master

  """Check the agreement on who is the master.

  This function will return a list of (node, number of votes), ordered

  since we use the same source for configuration information for both

  backend and boostrap, we'll always vote for ourselves.

      node will be removed if it is in the list

  @rtype: list

  @return: list of (node, votes)

  """

  myself = netutils.Hostname.GetSysName()

  try:

  except ValueError:

    pass

    # no nodes left (eventually after removing myself)

    return []

  if not isinstance(results, dict):

    # this should not happen (unless internal error in rpc)

    logging.critical("Can't complete rpc call, aborting master startup")

  votes = {}

    data = nres.payload

    msg = nres.fail_msg

    fail = False

    if msg:

      fail = True

    # for now we accept both length 3, 4 and 5 (data[3] is primary ip version

    # and data[4] is the master netmask)

    elif not isinstance(data, (tuple, list)) or len(data) < 3:

      fail = True

    if fail:

      if None not in votes:

    return 1

  op = opcodes.OpClusterDestroy()

  # if we reached this, the opcode didn't fail; we can proceed to

  # shutdown all the daemons

  return 0

  return constants.EXIT_SUCCESS

  """Formats the logical_id of a disk.

  """

  if dev_type == constants.LD_DRBD8:

    data = [

      ]

  elif dev_type == constants.LD_LV:

    data = ["%s/%s" % (vg_name, lv_name)]

  else:

  return data

    data.append(("access mode", dev["mode"]))

  if dev["logical_id"] is not None:

    try:

    except ValueError:

      l_id = [str(dev["logical_id"])]

    if len(l_id) == 1:

from ganeti.cmdlib.base import QueryBase, NoHooksLU, LogicalUnit

from ganeti.cmdlib.common import GetWantedNodes, ShareAll, CheckNodeOnline, \

from ganeti.cmdlib.instance_storage import StartInstanceDisks, \

  ShutdownInstanceDisks

from ganeti.cmdlib.instance_utils import GetClusterDomainSecret, \

    # The following variables interact with _QueryBase._GetNames

    if self.names:

    else:

      self.wanted = locking.ALL_SET

                           if level != locking.LEVEL_CLUSTER) or

                self.do_locking or self.use_locking)

    result = []

      if nres.fail_msg:

      else:

    return result

    if self.op.mode == constants.EXPORT_MODE_REMOTE:

      salt = utils.GenerateSecret(8)

      result = self.rpc.call_x509_cert_create(instance.primary_node,

                                              constants.RIE_CERT_VALIDITY)

      (name, cert_pem) = result.payload

    # Lock all nodes for local exports

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

      # FIXME: lock only instance primary and destination node

      #

      # Sad but true, for now we have do lock all nodes, as we don't know where

    nl = [self.cfg.GetMasterNode(), self.instance.primary_node]

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

    return (nl, nl)

                                 " down before", errors.ECODE_STATE)

    if self.op.mode == constants.EXPORT_MODE_LOCAL:

      assert self.dst_node is not None

      self._cds = None

      self.dest_disk_info = None

    """

    assert self.op.mode != constants.EXPORT_MODE_REMOTE

    # on one-node clusters nodelist will be empty after the removal

    # if we proceed the backup would be removed because OpBackupQuery

    # substitutes an empty list with the full cluster node list.

    iname = self.instance.name

      feedback_fn("Removing old exports for instance %s" % iname)

          continue

          if msg:

            self.LogWarning("Could not remove older export for instance %s"

  def Exec(self, feedback_fn):

    """Export an instance to an image in the cluster.

    assert self.op.mode in constants.EXPORT_MODES

    instance = self.instance

    if self.op.shutdown:

      # shutdown the instance, but not the disks

      feedback_fn("Shutting down instance %s" % instance.name)

                                               self.op.shutdown_timeout,

                                               self.op.reason)

      # TODO: Maybe ignore failures if ignore_remove_failures is set

      result.Raise("Could not shutdown instance %s on"

    # set the disks ID correctly since call_instance_start needs the

    # correct drbd minor to create the symlinks

    for disk in instance.disks:

    activate_disks = not instance.disks_active

            not self.op.remove_instance):

          assert not activate_disks

          feedback_fn("Starting instance %s" % instance.name)

                                                (instance, None, None), False,

                                                 self.op.reason)

          msg = result.fail_msg

    locked_nodes = self.owned_locks(locking.LEVEL_NODE)

    exportlist = self.rpc.call_export_list(locked_nodes)

    found = False

      if msg:

        continue

        found = True

        msg = result.fail_msg

        if msg:

          logging.error("Could not remove export for instance %s"

    if fqdn_warn and not found:

      feedback_fn("Export not found. If trying to remove an export belonging"

      }

      # Acquire just two nodes

      self.needed_locks = {

      }

      # Acquire no locks

      self.needed_locks = {} # No, you can't leave it to the default value None

  def BuildHooksNodes(self):

    """Build list of nodes to run LU's hooks.

    @note: If the C{HPATH} attribute of the LU class is C{None}, this function

      will not be called.

    # For now we'll replace self.needed_locks[locking.LEVEL_NODE], but in the

    # future we might want to have different behaviors depending on the value

    # of self.recalculate_locks[locking.LEVEL_NODE]

    locked_i = self.owned_locks(locking.LEVEL_INSTANCE)

    for _, instance in self.cfg.GetMultiInstanceInfo(locked_i):

      if not primary_only:

    if self.recalculate_locks[level] == constants.LOCKS_REPLACE:

    elif self.recalculate_locks[level] == constants.LOCKS_APPEND:

    else:

      raise errors.ProgrammerError("Unknown recalculation mode")

    """

    master_params = self.cfg.GetMasterNetworkParameters()

    ems = self.cfg.GetUseExternalMipScript()

                                                   master_params, ems)

    result.Raise("Could not activate the master IP")

    """

    master_params = self.cfg.GetMasterNetworkParameters()

    ems = self.cfg.GetUseExternalMipScript()

                                                     master_params, ems)

    result.Raise("Could not deactivate the master IP")

    master_params = self.cfg.GetMasterNetworkParameters()

    # Run post hooks on master node before it's removed

    ems = self.cfg.GetUseExternalMipScript()

                                                     master_params, ems)

    result.Warn("Error disabling the master IP address", self.LogWarning)

class LUClusterPostInit(LogicalUnit):

    if query.CQ_CONFIG in self.requested_data:

      cluster = lu.cfg.GetClusterInfo()

    else:

      cluster = NotImplemented

    if query.CQ_QUEUE_DRAINED in self.requested_data:

      drain_flag = os.path.exists(pathutils.JOB_QUEUE_DRAIN_FILE)

      drain_flag = NotImplemented

    if query.CQ_WATCHER_PAUSE in self.requested_data:

      result.Raise("Can't retrieve watcher pause from master node '%s'" %

      watcher_pause = result.payload

    else:

      watcher_pause = NotImplemented

class LUClusterQuery(NoHooksLU):

      "export_version": constants.EXPORT_VERSION,

      "architecture": runtime.GetArchInfo(),

      "name": cluster.cluster_name,

      "default_hypervisor": cluster.primary_hypervisor,

      "enabled_hypervisors": cluster.enabled_hypervisors,

      "hvparams": dict([(hypervisor_name, cluster.hvparams[hypervisor_name])

    # shutdown the master IP

    master_params = self.cfg.GetMasterNetworkParameters()

    ems = self.cfg.GetUseExternalMipScript()

                                                     master_params, ems)

    result.Raise("Could not disable the master role")

      ssh.WriteKnownHostsFile(self.cfg, pathutils.SSH_KNOWN_HOSTS_FILE)

      node_list = self.cfg.GetOnlineNodeList()

      try:

      except ValueError:

        pass

      UploadHelper(self, node_list, pathutils.SSH_KNOWN_HOSTS_FILE)

    finally:

      master_params.ip = new_ip

                                                     master_params, ems)

      result.Warn("Could not re-enable the master role on the master,"

                  " please restart manually", self.LogWarning)

      "Not owning correct locks"

    assert not self.owned_locks(locking.LEVEL_NODE)

    changed = []

      newl = [v[2].Copy() for v in dskl]

      for dsk in newl:

      if result.fail_msg:

        self.LogWarning("Failure in blockdev_getdimensions call to node"

        continue

      if len(result.payload) != len(dskl):

        logging.warning("Invalid result from node %s: len(dksl)=%d,"

        self.LogWarning("Invalid result from node %s, ignoring node results",

        continue

      for ((instance, idx, disk), dimensions) in zip(dskl, result.payload):

        if dimensions is None:

          disk.size = size

          self.cfg.Update(instance, feedback_fn)

          changed.append((instance.name, idx, "size", size))

          if spindles is None:

            self.LogWarning("Disk %d of instance %s did not return valid"

                            " spindles information, ignoring", idx,

    mn = self.cfg.GetMasterNode()

    return ([mn], [mn])

                   new_enabled_disk_templates):

    """Check the consistency of the vg name on all nodes and in case it gets

       unset whether there are instances still using it.

           (self.cfg.GetVGName() is not None and

            utils.LvmGetsEnabled(enabled_disk_templates,

                                 new_enabled_disk_templates)):

    """Check the status of the volume group on each node.

    """

      if msg:

        # ignoring down node

        self.LogWarning("Error while gathering data on node %s"

        continue

                                            self.op.vg_name,

                                            constants.MIN_VG_SIZE)

      if vgstatus:

        raise errors.OpPrereqError("Error on node '%s': %s" %

  def _GetEnabledDiskTemplates(self, cluster):

    """Determines the enabled disk templates and the subset of disk templates

                                   " drbd-based instances exist",

                                   errors.ECODE_INVAL)

    self.cluster = cluster = self.cfg.GetClusterInfo()

    (enabled_disk_templates, new_enabled_disk_templates) = \

      self._GetEnabledDiskTemplates(cluster)

                      new_enabled_disk_templates)

    if self.op.drbd_helper:

      # checks given drbd helper on all nodes

        if ninfo.offline:

          continue

        if msg:

          raise errors.OpPrereqError("Error checking drbd helper on node"

                                     errors.ECODE_ENVIRON)

        if node_helper != self.op.drbd_helper:

          raise errors.OpPrereqError("Error on node '%s': drbd helper is %s" %

    # validate params changes

    if self.op.beparams:

      violations = set()

      for group in self.cfg.GetAllNodeGroupsInfo().values():

        instances = frozenset([inst for inst in all_instances

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

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

        new = ComputeNewInstanceViolations(ipol,

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)

          hv_class.CheckParameterSyntax(hv_params)

    self._CheckDiskTemplateConsistency()

          new_osp = objects.FillDict(cluster_defaults, hv_params)

          hv_class = hypervisor.GetHypervisorClass(hv_name)

          hv_class.CheckParameterSyntax(new_osp)

    if self.op.default_iallocator:

      alloc_script = utils.FindFile(self.op.default_iallocator,

      ems = self.cfg.GetUseExternalMipScript()

      feedback_fn("Shutting down master ip on the current netdev (%s)" %

                  self.cluster.master_netdev)

                                                       master_params, ems)

      result.Raise("Could not disable the master ip")

      feedback_fn("Changing master_netdev from %s to %s" %

    if self.op.master_netmask:

      master_params = self.cfg.GetMasterNetworkParameters()

      feedback_fn("Changing master IP netmask to %s" % self.op.master_netmask)

      result.Warn("Could not change the master IP netmask", feedback_fn)

      self.cluster.master_netmask = self.op.master_netmask

      feedback_fn("Starting the master ip on the new master netdev (%s)" %

                  self.op.master_netdev)

      ems = self.cfg.GetUseExternalMipScript()

                                                     master_params, ems)

      result.Warn("Could not re-enable the master ip on the master,"

                  " please restart manually", self.LogWarning)

    # occur, it would never be caught by VerifyGroup, which only acts on

    # nodes/instances reachable from existing node groups.

                         if node.group not in self.all_group_info)

    dangling_instances = {}

    no_node_instances = []

    for inst in self.all_inst_info.values():

        dangling_instances.setdefault(inst.primary_node, []).append(inst.name)

      elif inst.primary_node not in self.all_node_info:

        no_node_instances.append(inst.name)

    pretty_dangling = [

        "%s (%s)" %

        (node.name,

                                                ["no instances"])))

        for node in dangling_nodes]

  class NodeImage(object):

    """A class representing the logical and physical status of a node.

    @ivar volumes: a structure as returned from

        L{ganeti.backend.GetVolumeList} (runtime)

    @ivar instances: a list of running instances (runtime)

    @ivar pv_max: size in MiB of the biggest PVs

    """

      self.volumes = {}

      self.instances = []

      self.pinst = []

    assert self.group_uuid in self.owned_locks(locking.LEVEL_NODEGROUP)

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

    group_instances = \

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

    unlocked_instances = \

        group_instances.difference(self.owned_locks(locking.LEVEL_INSTANCE))

    if unlocked_instances:

      raise errors.OpPrereqError("Missing lock for instances: %s" %

    self.all_node_info = self.cfg.GetAllNodesInfo()

    self.all_inst_info = self.cfg.GetAllInstancesInfo()

    self.my_inst_info = dict((name, self.all_inst_info[name])

                             for name in self.my_inst_names)

    for inst in self.my_inst_info.values():

      if inst.disk_template in constants.DTS_INT_MIRROR:

    unlocked_lv_nodes = \

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

         reasonable values in the respose)

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    # main result, nresult should be a non-empty dict

    test = not nresult or not isinstance(nresult, dict)

                  "unable to verify node: no data returned")

    if test:

      return False

    test = not (remote_version and

                isinstance(remote_version, (list, tuple)) and

                len(remote_version) == 2)

             "connection to node returned invalid data")

    if test:

      return False

    test = local_version != remote_version[0]

             "incompatible protocol versions: master %s,"

             " node %s", local_version, remote_version[0])

    if test:

    # full package version

    self._ErrorIf(constants.RELEASE_VERSION != remote_version[1],

                  "software version mismatch: master %s, node %s",

                  constants.RELEASE_VERSION, remote_version[1],

                  code=self.ETYPE_WARNING)

    if ninfo.vm_capable and isinstance(hyp_result, dict):

      for hv_name, hv_result in hyp_result.iteritems():

        test = hv_result is not None

                 "hypervisor %s verify failure: '%s'", hv_name, hv_result)

    hvp_result = nresult.get(constants.NV_HVPARAMS, None)

    if ninfo.vm_capable and isinstance(hvp_result, list):

      for item, hv_name, hv_result in hvp_result:

                 "hypervisor %s parameter verify failure (source %s): %s",

                 hv_name, item, hv_result)

    test = nresult.get(constants.NV_NODESETUP,

                       ["Missing NODESETUP results"])

             "; ".join(test))

    return True

    @param nvinfo_endtime: the end time of the RPC call

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    ntime = nresult.get(constants.NV_TIME, None)

    try:

      ntime_merged = utils.MergeTime(ntime)

    except (ValueError, TypeError):

      return

    if ntime_merged < (nvinfo_starttime - constants.NODE_MAX_CLOCK_SKEW):

    else:

      ntime_diff = None

             "Node time diverges by at least %s from master node time",

             ntime_diff)

    if vg_name is None:

      return

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    # checks vg existence and size > 20G

    vglist = nresult.get(constants.NV_VGLIST, None)

    test = not vglist

    if not test:

      vgstatus = utils.CheckVolumeGroupSize(vglist, vg_name,

                                            constants.MIN_VG_SIZE)

    # Check PVs

    (errmsgs, pvminmax) = CheckNodePVs(nresult, self._exclusive_storage)

    for em in errmsgs:

    if pvminmax is not None:

      (nimg.pv_min, nimg.pv_max) = pvminmax

    """

    node_versions = {}

      nresult = ndata.payload

      version = nresult.get(constants.NV_DRBDVERSION, "Missing DRBD version")

    if len(set(node_versions.values())) > 1:

        msg = "DRBD version mismatch: %s" % version

                    code=self.ETYPE_WARNING)

  def _VerifyGroupLVM(self, node_image, vg_name):

    if not bridges:

      return

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    missing = nresult.get(constants.NV_BRIDGES, None)

    test = not isinstance(missing, list)

             "did not return valid bridge information")

    if not test:

               "missing bridges: %s" % utils.CommaJoin(sorted(missing)))

  def _VerifyNodeUserScripts(self, ninfo, nresult):

    @param nresult: the remote results for the node

    """

    test = not constants.NV_USERSCRIPTS in nresult

                  "did not return user scripts information")

    broken_scripts = nresult.get(constants.NV_USERSCRIPTS, None)

    if not test:

                    "user scripts not present or not executable: %s" %

                    utils.CommaJoin(sorted(broken_scripts)))

    @param nresult: the remote results for the node

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    test = constants.NV_NODELIST not in nresult

             "node hasn't returned node ssh connectivity data")

    if not test:

      if nresult[constants.NV_NODELIST]:

        for a_node, a_msg in nresult[constants.NV_NODELIST].items():

                   "ssh communication with node '%s': %s", a_node, a_msg)

    test = constants.NV_NODENETTEST not in nresult

             "node hasn't returned node tcp connectivity data")

    if not test:

      if nresult[constants.NV_NODENETTEST]:

        nlist = utils.NiceSort(nresult[constants.NV_NODENETTEST].keys())

        for anode in nlist:

                   "tcp communication with node '%s': %s",

                   anode, nresult[constants.NV_NODENETTEST][anode])

    test = constants.NV_MASTERIP not in nresult

             "node hasn't returned node master IP reachability data")

    if not test:

      if not nresult[constants.NV_MASTERIP]:

          msg = "the master node cannot reach the master IP (not configured?)"

        else:

          msg = "cannot reach the master IP"

  def _VerifyInstance(self, instance, inst_config, node_image,

                      diskstatus):

      for volume in node_vol_should[node]:

        test = volume not in n_img.volumes

        _ErrorIf(test, constants.CV_EINSTANCEMISSINGDISK, instance,

    if inst_config.admin_state == constants.ADMINST_UP:

      test = instance not in pnode_img.instances and not pnode_img.offline

      _ErrorIf(test, constants.CV_EINSTANCEDOWN, instance,

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

      _ErrorIf(pnode_img.offline, constants.CV_EINSTANCEBADNODE, instance,

               "instance is marked as running and lives on offline node %s",

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

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

               not success and not bad_snode,

               constants.CV_EINSTANCEFAULTYDISK, instance,

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

      _ErrorIf((inst_config.disks_active and

                success and bdev_status.ldisk_status == constants.LDS_FAULTY),

               constants.CV_EINSTANCEFAULTYDISK, instance,

    _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,

             constants.CV_ENODERPC, pnode, "instance %s, connection to"

             utils.CommaJoin(inst_config.secondary_nodes),

             code=self.ETYPE_WARNING)

    if any(es_flags.values()):

      if inst_config.disk_template not in constants.DTS_EXCL_STORAGE:

        # Disk template not compatible with exclusive_storage: no instance

        self._Error(constants.CV_EINSTANCEUNSUITABLENODE, instance,

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

                    " that have exclusive storage set: %s",

      for (idx, disk) in enumerate(inst_config.disks):

        _ErrorIf(disk.spindles is None,

                 constants.CV_EINSTANCEMISSINGCFGPARAMETER, instance,

                                   []).append(node)

      pretty_list = [

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

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

                                   key=lambda (_, nodes): pnode in nodes,

    # warn that the instance lives on offline nodes

    _ErrorIf(inst_nodes_offline, constants.CV_EINSTANCEBADNODE, instance,

             "instance has offline secondary node(s) %s",

    # ... or ghost/non-vm_capable nodes

    for node in inst_config.all_nodes:

      _ErrorIf(node_image[node].ghost, constants.CV_EINSTANCEBADNODE,

      _ErrorIf(not node_image[node].vm_capable, constants.CV_EINSTANCEBADNODE,

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

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

    @param reserved: a FieldSet of reserved volume names

    """

      if (n_img.offline or n_img.rpc_fail or n_img.lvm_fail or

        # skip non-healthy nodes

        continue

      for volume in n_img.volumes:

                not reserved.Matches(volume))

                      "volume %s is unknown", volume)

  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):

    """

    cluster_info = self.cfg.GetClusterInfo()

      # This code checks that every node which is now listed as

      # secondary has enough memory to host all instances it is

      # supposed to should a single other node in the cluster fail.

      # WARNING: we currently take into account down instances as well

      # as up ones, considering that even if they're down someone

      # might want to start them even in the event of a node failure.

        # we're skipping nodes marked offline and nodes in other groups from

        # the N+1 warning, since most likely we don't have good memory

        # infromation from them; we already list instances living on such

          if bep[constants.BE_AUTO_BALANCE]:

            needed_mem += bep[constants.BE_MINMEM]

        test = n_img.mfree < needed_mem

                      "not enough memory to accomodate instance failovers"

                      " should node %s fail (%dMiB needed, %dMiB available)",

                   (files_all, files_opt, files_mc, files_vm)):

    """Verifies file checksums collected from all nodes.

    @param all_nvinfo: RPC results

    """

    files2nodefn = [

      (files_all, None),

      (files_mc, lambda node: (node.master_candidate or

      (files_vm, lambda node: node.vm_capable),

      ]

    nodefiles = {}

    for (files, fn) in files2nodefn:

      if fn is None:

      else:

      nodefiles.update((filename,

                       for filename in files)

    assert set(nodefiles) == (files_all | files_mc | files_vm)

    fileinfo = dict((filename, {}) for filename in nodefiles)

    ignore_nodes = set()

      if node.offline:

        continue

      if nresult.fail_msg or not nresult.payload:

        node_files = None

        del fingerprints

      test = not (node_files and isinstance(node_files, dict))

      if test:

        continue

      # Build per-checksum mapping from filename to nodes having it

      for (filename, checksum) in node_files.items():

        assert filename in nodefiles

    for (filename, checksums) in fileinfo.items():

      assert compat.all(len(i) > 10 for i in checksums), "Invalid checksum"

      # Nodes having the file

      expected_nodes = nodefiles[filename] - ignore_nodes

      if filename in files_opt:

        # All or no nodes

      else:

        # Warn if a node has a file it shouldn't