Synnefo » snf-ganeti

    return bad

  def _VerifyInstance(self, instance, instanceconfig, node_vol_is,

    """Verify an instance.

    This function checks to see if the required block devices are

    instanceconfig.MapLVsByNode(node_vol_should)

    for node in node_vol_should:

      for volume in node_vol_should[node]:

        if node not in node_vol_is or volume not in node_vol_is[node]:

          feedback_fn("  - ERROR: volume %s missing on node %s" %

          bad = True

    if not instanceconfig.status == 'down':

        feedback_fn("  - ERROR: instance %s not running on node %s" %

                        (instance, node_current))

        bad = True

    instancelist = utils.NiceSort(self.cfg.GetInstanceList())

    i_non_redundant = [] # Non redundant instances

    i_non_a_balanced = [] # Non auto-balanced instances

    node_volume = {}

    node_instance = {}

    node_info = {}

      node = node_i.name

      nresult = all_nvinfo[node].data

      if node == master_node:

        ntype = "master"

      elif node_i.master_candidate:

      feedback_fn("* Verifying instance %s" % instance)

      inst_config = self.cfg.GetInstanceInfo(instance)

      result =  self._VerifyInstance(instance, inst_config, node_volume,

      bad = bad or result

      inst_config.MapLVsByNode(node_vol_should)

      pnode = inst_config.primary_node

      if pnode in node_info:

        node_info[pnode]['pinst'].append(instance)

        feedback_fn("  - ERROR: instance %s, connection to primary node"

                    " %s failed" % (instance, pnode))

        bad = True

          if pnode not in node_info[snode]['sinst-by-pnode']:

            node_info[snode]['sinst-by-pnode'][pnode] = []

          node_info[snode]['sinst-by-pnode'][pnode].append(instance)

          feedback_fn("  - ERROR: instance %s, connection to secondary node"

                      " %s failed" % (instance, snode))

      feedback_fn("  - NOTICE: %d non-auto-balanced instance(s) found."

                  % len(i_non_a_balanced))

    return not bad

  def HooksCallBack(self, phase, hooks_results, feedback_fn, lu_result):

          show_node_header = True

          res = hooks_results[node_name]

          if res.failed or res.data is False or not isinstance(res.data, list):

            feedback_fn("    Communication failure in hooks execution")

            lu_result = 1

            continue

      # node_volume

      lvs = node_lvs[node]

      if lvs.failed:

        continue

      lvs = lvs.data

      if isinstance(lvs, basestring):

      for node_name in results:

        res = results[node_name]

        if res.failed or res.data is False or not isinstance(res.data, list):

          continue

        for script, hkr, output in res.data:

          if hkr == constants.HKR_FAIL: