Synnefo » snf-ganeti

         reasonable values in the respose)

    """

    # 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)

    if test:

      return False

    test = local_version != remote_version[0]

    if test:

      return False

    # 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

    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:

    test = nresult.get(constants.NV_NODESETUP,

                       ["Missing NODESETUP results"])

    return True

    @param nvinfo_endtime: the end time of the RPC call

    """

    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

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

    """Check the node LVM results and update info for cross-node checks.

    if vg_name is None:

      return

    # 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

    if not bridges:

      return

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

    test = not isinstance(missing, list)

    if not test:

  def _VerifyNodeUserScripts(self, ninfo, nresult):

    """Check the results of user scripts presence and executability on the node

    @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

    """

    test = constants.NV_NODELIST not in nresult

    if not test:

      if nresult[constants.NV_NODELIST]:

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

    test = constants.NV_NODENETTEST not in nresult

    if not test:

      if nresult[constants.NV_NODENETTEST]:

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

        for anode in nlist:

    test = constants.NV_MASTERIP not in nresult

    if not test:

      if not nresult[constants.NV_MASTERIP]:

        if ninfo.uuid == self.master_node:

          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):

    state.

    """

    pnode = inst_config.primary_node

    pnode_img = node_image[pnode]

    groupinfo = self.cfg.GetAllNodeGroupsInfo()

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

                                                            self.group_info)

    err = ComputeIPolicyInstanceViolation(ipolicy, inst_config, self.cfg)

    for node in node_vol_should:

      n_img = node_image[node]

        continue

      for volume in node_vol_should[node]:

        test = volume not in n_img.volumes

    if inst_config.admin_state == constants.ADMINST_UP:

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

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

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

      # node here

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

    es_flags = rpc.GetExclusiveStorageForNodes(self.cfg,

                                               inst_config.all_nodes)

                    inst_config.disk_template,

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

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

    if inst_config.disk_template in constants.DTS_INT_MIRROR:

      instance_nodes = utils.NiceSort(inst_config.all_nodes)

    inst_nodes_offline = []

    for snode in inst_config.secondary_nodes:

      s_img = node_image[snode]

      if s_img.offline:

        inst_nodes_offline.append(snode)

    # warn that the instance lives on offline nodes

    # ... or ghost/non-vm_capable nodes

    for node in inst_config.all_nodes:

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

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

        L{ganeti.config.ConfigWriter.ComputeDRBDMap}

    """

    if drbd_helper:

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

      test = (helper_result is None)

      if helper_result:

        status, payload = helper_result

        test = not status

        test = status and (payload != drbd_helper)

    # compute the DRBD minors

    node_drbd = {}

    for minor, instance in drbd_map[ninfo.uuid].items():

      test = instance not in instanceinfo

        # ghost instance should not be running, but otherwise we

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

        # unallocated minor in use)

    # and now check them

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

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

    if test:

      # we cannot check drbd status

      return

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

      test = minor not in used_minors and must_exist

    for minor in used_minors:

      test = minor not in node_drbd

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

    """Builds the node OS structures.

    @param nimg: the node image object

    """

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

    test = (not isinstance(remote_os, list) or

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

                           for v in remote_os))

    nimg.os_fail = test

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

    """

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

    beautify_params = lambda l: ["%s: %s" % (k, v) for (k, v) in l]

    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]

      # comparisons with the 'base' image

      test = os_name not in base.oslist

      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))]:

    # check any missing OSes

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

  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

         constants.ENABLE_SHARED_FILE_STORAGE)):

        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]:

        self._ErrorIf(path_result, constants.CV_ENODEOOBPATH,

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

    """Verifies and updates the node volume data.

    @param vg_name: the configured VG name

    """

    nimg.lvm_fail = True

    lvdata = nresult.get(constants.NV_LVLIST, "Missing LV data")

    if vg_name is None:

      pass

    elif isinstance(lvdata, basestring):

    elif not isinstance(lvdata, dict):

    else:

      nimg.volumes = lvdata

      nimg.lvm_fail = False

    @param vg_name: the configured VG name

    """

    # 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

    if not test:

      try:

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

      except (ValueError, TypeError):

    # 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])

      if not test:

        try:

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

        except (ValueError, TypeError):

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

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

      return True

    self.bad = False

    verbose = self.op.verbose

    self._feedback_fn = feedback_fn

        feedback_fn("* Verifying node %s (%s)" % (node_i.name, ntype))

      msg = all_nvinfo[node_i.uuid].fail_msg

      if msg:

        nimg.rpc_fail = True

        continue

        for inst in non_primary_inst:

          test = inst in self.all_inst_info

    self._VerifyGroupDRBDVersion(all_nvinfo)

    self._VerifyGroupLVM(node_image, vg_name)