Synnefo » snf-ganeti » ganeti-local

  self.op and self._feedback_fn to be available.)

  """

  ETYPE_FIELD = "code"

  ETYPE_ERROR = "ERROR"

        utils.ForceDictType(hv_params, constants.HVS_PARAMETER_TYPES)

        hv_class.CheckParameterSyntax(hv_params)

      except errors.GenericError, err:

  def ExpandNames(self):

    # Information can be safely retrieved as the BGL is acquired in exclusive

    feedback_fn("* Verifying cluster config")

    for msg in self.cfg.VerifyConfig():

    feedback_fn("* Verifying cluster certificate files")

    for cert_filename in constants.ALL_CERT_FILES:

      (errcode, msg) = _VerifyCertificate(cert_filename)

    feedback_fn("* Verifying hypervisor parameters")

                                                ["no instances"])))

        for node in dangling_nodes]

                  "the following nodes (and their instances) belong to a non"

                  " existing group: %s", utils.CommaJoin(pretty_dangling))

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

                  " %s", utils.CommaJoin(no_node_instances))

    # 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

    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)

    # 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 pv names

    pvlist = nresult.get(constants.NV_PVLIST, None)

    test = pvlist is None

    if not test:

      # check that ':' is not present in PV names, since it's a

      # special character for lvcreate (denotes the range of PEs to

      # use on the PV)

      for _, pvname, owner_vg in pvlist:

        test = ":" in pvname

  def _VerifyNodeBridges(self, ninfo, nresult, bridges):

    """Check the node bridges.

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

    test = not isinstance(missing, list)

             "did not return valid bridge information")

    if not test:

  def _VerifyNodeNetwork(self, ninfo, nresult):

    """Check the node network connectivity results.

    _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, instanceconfig, node_image,

                      diskstatus):

        continue

      for volume in node_vol_should[node]:

        test = volume not in n_img.volumes

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

    if instanceconfig.admin_up:

      pri_img = node_image[node_current]

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

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

               node_current)

      snode = node_image[nname]

      bad_snode = snode.ghost or snode.offline

      _ErrorIf(instanceconfig.admin_up and not success and not bad_snode,

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

               idx, nname, bdev_status)

      _ErrorIf((instanceconfig.admin_up and success and

                bdev_status.ldisk_status == constants.LDS_FAULTY),

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

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

        test = ((node not in node_vol_should or

                volume not in node_vol_should[node]) and

                not reserved.Matches(volume))

                      "volume %s is unknown", volume)

  def _VerifyNPlusOneMemory(self, node_image, instance_cfg):

          if bep[constants.BE_AUTO_BALANCE]:

            needed_mem += bep[constants.BE_MEMORY]

        test = n_img.mfree < needed_mem

                      "not enough memory to accomodate instance failovers"

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

                      prinode, needed_mem, n_img.mfree)

        node_files = nresult.payload.get(constants.NV_FILELIST, None)

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

              "Node did not return file checksum data")

      if test:

        ignore_nodes.add(node.name)

      if filename in files_all_opt:

        # All or no nodes

        errorif(missing_file and missing_file != expected_nodes,

                "File %s is optional, but it must exist on all or no"

                " nodes (not found on %s)",

                filename, utils.CommaJoin(utils.NiceSort(missing_file)))

      else:

                "File %s is missing from node(s) %s", filename,

                utils.CommaJoin(utils.NiceSort(missing_file)))

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

        unexpected = with_file - expected_nodes

        errorif(unexpected,

                "File %s should not exist on node(s) %s",

                filename, utils.CommaJoin(utils.NiceSort(unexpected)))

      else:

        variants = []

              "File %s found with %s different checksums (%s)",

              filename, len(checksums), "; ".join(variants))

    if drbd_helper:

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

      test = (helper_result == 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 = {}

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

      test = instance not in instanceinfo

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

        # ghost instance should not be running, but otherwise we

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

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

            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

    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)",

               os_name, base.name)

      if test:

                         ("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]",

                 kind, os_name, base.name,

                 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",

             base.name, utils.CommaJoin(missing))

    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.

    if vg_name is None:

      pass

    elif isinstance(lvdata, basestring):

               utils.SafeEncode(lvdata))

    elif not isinstance(lvdata, dict):

    else:

      nimg.volumes = lvdata

      nimg.lvm_fail = False

    """

    idata = nresult.get(constants.NV_INSTANCELIST, None)

    test = not isinstance(idata, list)

    if test:

      nimg.hyp_fail = True

    else:

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

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

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

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

      else:

        msg = nres.fail_msg

                 "while getting disk information: %s", msg)

        if msg:

          # No data from this node

        feedback_fn("* Verifying node %s (%s)" % (node, ntype))

      msg = all_nvinfo[node].fail_msg

      if msg:

        nimg.rpc_fail = True

        continue

        for inst in non_primary_inst:

          test = inst in self.all_inst_info

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

                   "node is running unknown instance %s", inst)

    for node, result in extra_lv_nvinfo.items():

      pnode = inst_config.primary_node

      pnode_img = node_image[pnode]

      _ErrorIf(pnode_img.rpc_fail and not pnode_img.offline,

               " primary node failed", instance)

      _ErrorIf(inst_config.admin_up and pnode_img.offline,

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

               inst_config.primary_node)

      if not inst_config.secondary_nodes:

        i_non_redundant.append(instance)

               instance, "instance has multiple secondary nodes: %s",

               utils.CommaJoin(inst_config.secondary_nodes),

               code=self.ETYPE_WARNING)

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

                                     reverse=True)]

                      instance, "instance has primary and secondary nodes in"

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

                      code=self.ETYPE_WARNING)

      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

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

               utils.CommaJoin(inst_nodes_offline))

      # ... or ghost/non-vm_capable nodes

      for node in inst_config.all_nodes:

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

    feedback_fn("* Verifying orphan volumes")

        res = hooks_results[node_name]

        msg = res.fail_msg

        test = msg and not res.offline

                      "Communication failure in hooks execution: %s", msg)

        if res.offline or msg:

          # No need to investigate payload if node is offline or gave

          continue

        for script, hkr, output in res.payload:

          test = hkr == constants.HKR_FAIL

                        "Script %s failed, output:", script)

          if test:

            output = self._HOOKS_INDENT_RE.sub("      ", output)

VERIFY_NPLUSONE_MEM = "nplusone_mem"

VERIFY_OPTIONAL_CHECKS = frozenset([VERIFY_NPLUSONE_MEM])

# Node verify constants

NV_DRBDHELPER = "drbd-helper"

NV_DRBDLIST = "drbd-list"

class TestClusterVerifyFiles(unittest.TestCase):

  @staticmethod

  def _FakeErrorIf(errors, cond, ecode, item, msg, *args, **kwargs):

             ht.TNonEmptyString(item)) or

             item is None))

    if args: