Synnefo » snf-ganeti

    """

    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

        unexpected = with_file - expected_nodes

      # See if there are multiple versions of the file

      test = len(checksums) > 1

      if test:

        variants = ["variant %s on %s" %

                      enumerate(sorted(checksums.items()))]

      else:

        variants = []

  def _VerifyNodeDrbd(self, ninfo, nresult, instanceinfo, drbd_helper,

                      drbd_map):

        L{ganeti.config.ConfigWriter.ComputeDRBDMap}

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    if drbd_helper:

      helper_result = nresult.get(constants.NV_DRBDHELPER, None)

      test = (helper_result is None)

               "no drbd usermode helper returned")

      if helper_result:

        status, payload = helper_result

        test = not status

                 "drbd usermode helper check unsuccessful: %s", payload)

        test = status and (payload != drbd_helper)

                 "wrong drbd usermode helper: %s", payload)

    # compute the DRBD minors

    node_drbd = {}

      test = instance not in instanceinfo

      _ErrorIf(test, constants.CV_ECLUSTERCFG, None,

               "ghost instance '%s' in temporary DRBD map", instance)

    # and now check them

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

    test = not isinstance(used_minors, (tuple, list))

             "cannot parse drbd status file: %s", str(used_minors))

    if test:

      # we cannot check drbd status

    for minor, (iname, must_exist) in node_drbd.items():

      test = minor not in used_minors and must_exist

               "drbd minor %d of instance %s is not active", minor, iname)

    for minor in used_minors:

      test = minor not in node_drbd

               "unallocated drbd minor %d is in use", minor)

  def _UpdateNodeOS(self, ninfo, nresult, nimg):

    @param nimg: the node image object

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    remote_os = nresult.get(constants.NV_OSLIST, None)

            not compat.all(isinstance(v, list) and len(v) == 7

                           for v in remote_os))

             "node hasn't returned valid OS data")

    nimg.os_fail = test

    @param base: the 'template' node we match against (e.g. from the master)

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    assert not nimg.os_fail, "Entered _VerifyNodeOS with failed OS rpc?"

    for os_name, os_data in nimg.oslist.items():

      assert os_data, "Empty OS status for OS %s?!" % os_name

      f_path, f_status, f_diag, f_var, f_param, f_api = os_data[0]

               "Invalid OS %s (located at %s): %s", os_name, f_path, f_diag)

               "OS '%s' has multiple entries (first one shadows the rest): %s",

               os_name, utils.CommaJoin([v[0] for v in os_data]))

      # comparisons with the 'base' image

      test = os_name not in base.oslist

               "Extra OS %s not present on reference node (%s)",

      if test:

        continue

      assert base.oslist[os_name], "Base node has empty OS status?"

                         ("variants list", f_var, b_var),

                         ("parameters", beautify_params(f_param),

                          beautify_params(b_param))]:

                 "OS %s for %s differs from reference node %s: [%s] vs. [%s]",

                 utils.CommaJoin(sorted(a)), utils.CommaJoin(sorted(b)))

    # check any missing OSes

    missing = set(base.oslist.keys()).difference(nimg.oslist.keys())

             "OSes present on reference node %s but missing on this node: %s",

  def _VerifyFileStoragePaths(self, ninfo, nresult, is_master):

    """Verifies paths in L{pathutils.FILE_STORAGE_PATHS_FILE}.

    @param is_master: Whether node is the master node

    """

    if (is_master and

        (constants.ENABLE_FILE_STORAGE or

        fspaths = nresult[constants.NV_FILE_STORAGE_PATHS]

      except KeyError:

        # This should never happen

                      "Node did not return forbidden file storage paths")

      else:

                      "Found forbidden file storage paths: %s",

                      utils.CommaJoin(fspaths))

    else:

      self._ErrorIf(constants.NV_FILE_STORAGE_PATHS in nresult,

                    "Node should not have returned forbidden file storage"

                    " paths")

    @param nresult: the remote results for the node

    """

    # We just have to verify the paths on master and/or master candidates

    # as the oob helper is invoked on the master

    if ((ninfo.master_candidate or ninfo.master_capable) and

        constants.NV_OOB_PATHS in nresult):

      for path_result in nresult[constants.NV_OOB_PATHS]:

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

    """Verifies and updates the node volume data.

    @param vg_name: the configured VG name

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    nimg.lvm_fail = True

    if vg_name is None:

      pass

    elif isinstance(lvdata, basestring):

    elif not isinstance(lvdata, dict):

               "rpc call to node failed (lvlist)")

    else:

      nimg.volumes = lvdata

    @param vg_name: the configured VG name

    """

    _ErrorIf = self._ErrorIf # pylint: disable=C0103

    # try to read free memory (from the hypervisor)

    hv_info = nresult.get(constants.NV_HVINFO, None)

    test = not isinstance(hv_info, dict) or "memory_free" not in hv_info

             "rpc call to node failed (hvinfo)")

    if not test:

      try:

        nimg.mfree = int(hv_info["memory_free"])

      except (ValueError, TypeError):

                 "node returned invalid nodeinfo, check hypervisor")

    # FIXME: devise a free space model for file based instances as well

    if vg_name is not None:

      test = (constants.NV_VGLIST not in nresult or

              vg_name not in nresult[constants.NV_VGLIST])

               "node didn't return data for the volume group '%s'"

               " - it is either missing or broken", vg_name)

      if not test:

        try:

          nimg.dfree = int(nresult[constants.NV_VGLIST][vg_name])

        except (ValueError, TypeError):

                   "node returned invalid LVM info, check LVM status")

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

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

    @param node_image: Node objects

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

        list of tuples (success, payload)

    """

    node_disks = {}

    node_disks_devonly = {}

    diskless_instances = set()

    diskless = constants.DT_DISKLESS

      diskless_instances.update(inst for inst in node_instances

                                if instanceinfo[inst].disk_template == diskless)

      disks = [(inst, disk)

        # No need to collect data

        continue

      # _AnnotateDiskParams makes already copies of the disks

      devonly = []

      for (inst, dev) in disks:

        (anno_disk,) = AnnotateDiskParams(instanceinfo[inst], [dev], self.cfg)

        devonly.append(anno_disk)

    assert len(node_disks) == len(node_disks_devonly)

    instdisk = {}

      if nres.offline:

        # No data from this node

        data = len(disks) * [(False, "node offline")]

      else:

        msg = nres.fail_msg

        if msg:

          # No data from this node

          data = len(disks) * [(False, msg)]

              data.append(i)

            else:

              logging.warning("Invalid result from node %s, entry %d: %s",

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

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

    # Add empty entries for diskless instances.

    for inst in diskless_instances:

      instdisk[inst] = {}

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

                      compat.all(isinstance(s, (tuple, list)) and

                                 len(s) == 2 for s in statuses)

    if __debug__:

      instdisk_keys = set(instdisk)

      instanceinfo_keys = set(instanceinfo)

    """Build hooks nodes.

    """

  def Exec(self, feedback_fn):

    """Verify integrity of the node group, performing various test on nodes.

    # This method has too many local variables. pylint: disable=R0914

    feedback_fn("* Verifying group '%s'" % self.group_info.name)

      # empty node group

      feedback_fn("* Empty node group, skipping verification")

      return True

    drbd_helper = self.cfg.GetDRBDHelper()

    cluster = self.cfg.GetClusterInfo()

    hypervisors = cluster.enabled_hypervisors

    i_non_redundant = [] # Non redundant instances

    i_non_a_balanced = [] # Non auto-balanced instances

    filemap = ComputeAncillaryFiles(cluster, False)

    # do local checksums

    master_ip = self.cfg.GetMasterIP()

    user_scripts = []

    if self.cfg.GetUseExternalMipScript():

      constants.NV_HVINFO: self.cfg.GetHypervisorType(),

      constants.NV_NODESETUP: None,

      constants.NV_TIME: None,

      constants.NV_OSLIST: None,

      constants.NV_VMNODES: self.cfg.GetNonVmCapableNodeList(),

      constants.NV_USERSCRIPTS: user_scripts,

    if constants.ENABLE_FILE_STORAGE or constants.ENABLE_SHARED_FILE_STORAGE:

      # Load file storage paths only from master node

    # bridge checks

    # FIXME: this needs to be changed per node-group, not cluster-wide

      node_verify_param[constants.NV_BRIDGES] = list(bridges)

    # Build our expected cluster state

                                                 vm_capable=node.vm_capable))

                      for node in node_data_list)

      if inst_config.admin_state == constants.ADMINST_OFFLINE:

        i_offline += 1

      inst_config.MapLVsByNode(node_vol_should)

          nimg.sbp[pnode] = []

        nimg.sbp[pnode].append(instance)

    # The value of exclusive_storage should be the same across the group, so if

    # it's True for at least a node, we act as if it were set for all the nodes

    self._exclusive_storage = compat.any(es_flags.values())

    # time before and after executing the request, we can at least have a time

    # window.

    nvinfo_starttime = time.time()

                                           node_verify_param,

                                           self.cfg.GetClusterName(),

                                           self.cfg.GetClusterInfo().hvparams)

    all_drbd_map = self.cfg.ComputeDRBDMap()

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

                                     self.my_inst_info)

    feedback_fn("* Verifying configuration file consistency")

    # If not all nodes are being checked, we need to make sure the master node

    # and a non-checked vm_capable node are in the list.

      vf_nvinfo = all_nvinfo.copy()

      vf_node_info = list(self.my_node_info.values())

      # Add the first vm_capable node we find which is not included,

      # excluding the master node (which we already have)

        if (nodeinfo.vm_capable and not nodeinfo.offline and

          break

      key = constants.NV_FILELIST

      vf_nvinfo.update(self.rpc.call_node_verify(

         self.cfg.GetClusterName(), self.cfg.GetClusterInfo().hvparams))

    else:

      vf_nvinfo = all_nvinfo

      vf_node_info = self.my_node_info.values()

    feedback_fn("* Verifying node status")

    refos_img = None

    for node_i in node_data_list:

      if node_i.offline:

        if verbose:

        n_offline += 1

        continue

        ntype = "master"

      elif node_i.master_candidate:

        ntype = "master candidate"

      else:

        ntype = "regular"

      if verbose:

      if msg:

        nimg.rpc_fail = True

        continue

      nimg.call_ok = self._VerifyNode(node_i, nresult)

      self._VerifyNodeTime(node_i, nresult, nvinfo_starttime, nvinfo_endtime)

      self._VerifyNodeUserScripts(node_i, nresult)

      self._VerifyOob(node_i, nresult)

      self._VerifyFileStoragePaths(node_i, nresult,

      if nimg.vm_capable: