Synnefo » snf-ganeti » ganeti-local

      es_flags = rpc.GetExclusiveStorageForNodeNames(lu.cfg, toquery_nodes)

      # FIXME: This currently maps everything to lvm, this should be more

      # flexible

                                        [lu.cfg.GetHypervisorType()], es_flags)

      live_data = dict((name, rpc.MakeLegacyNodeInfo(nresult.payload))

                       for (name, nresult) in node_data.items()

      node_whitelist = None

    es_flags = rpc.GetExclusiveStorageForNodeNames(cfg, node_list)

    node_data = self.rpc.call_node_info(node_list, vg_req,

                                        [hypervisor_name], es_flags)

    node_iinfo = \

        if has_lvm:

          total_disk = get_attr("vg_size")

          free_disk = get_attr("vg_free")

        else:

          # we didn't even ask the node for VG status, so use zeros

          total_disk = free_disk = 0

        # compute memory used by instances

        pnr_dyn = {

          "free_memory": mem_free,

          "total_disk": total_disk,

          "free_disk": free_disk,

          "total_cpus": get_attr("cpu_total"),

          "i_pri_memory": i_p_mem,

          "i_pri_up_memory": i_p_up_mem,

  "dtotal": ("DTotal", QFT_UNIT, "vg_size",

             "Total disk space in volume group used for instance disk"

             " allocation"),

  "mfree": ("MFree", QFT_UNIT, "memory_free",

            "Memory available for instance allocations"),

  "mnode": ("MNode", QFT_UNIT, "memory_dom0",

            ] + _COMMON_FIELDS

N_FIELDS = ["name", "offline", "master_candidate", "drained",

            "mtotal", "mnode", "mfree",

            "pinst_cnt", "sinst_cnt",

            "ctotal", "cnodes", "csockets",

  return [(d.ToDict(), uid) for d, uid in value]

def MakeLegacyNodeInfo(data, require_vg_info=True):

  """Formats the data returned by L{rpc.RpcRunner.call_node_info}.

  ret = utils.JoinDisjointDicts(hv_info, {"bootid": bootid})

  if require_vg_info or vgs_info:

    ret = utils.JoinDisjointDicts(vg0_info, ret)

  return ret

                   "beparams", "hvparams",

                   "oper_state", "oper_ram", "oper_vcpus", "status", "tags")

               "mtotal", "mnode", "mfree",

               "pinst_cnt", "sinst_cnt", "tags")

{-

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

  , fromJVal

  , jsonHead

  , getMaybeJsonHead

  , asJSObject

  , asObjectList

  , tryFromObj

getMaybeJsonHead [] _ = J.JSNull

getMaybeJsonHead (x:_) f = maybe J.JSNull J.showJSON (f x)

-- | Converts a JSON value into a JSON object.

asJSObject :: (Monad m) => J.JSValue -> m (J.JSObject J.JSValue)

asJSObject (J.JSObject a) = return a

     "Available disk space in volume group")

  , ("dtotal", "DTotal", QFTUnit, "vg_size",

     "Total disk space in volume group used for instance disk allocation")

  , ("mfree", "MFree", QFTUnit, "memory_free",

     "Memory available for instance allocations")

  , ("mnode", "MNode", QFTUnit, "memory_dom0",

  getMaybeJsonHead (rpcResNodeInfoVgInfo res) vgInfoVgFree

nodeLiveFieldExtract "dtotal" res =

  getMaybeJsonHead (rpcResNodeInfoVgInfo res) vgInfoVgSize

nodeLiveFieldExtract "mfree" res =

  jsonHead (rpcResNodeInfoHvInfo res) hvInfoMemoryFree

nodeLiveFieldExtract "mnode" res =

collectLiveData True cfg nodes = do

  let vgs = maybeToList . clusterVolumeGroupName $ configCluster cfg

      -- FIXME: This currently sets every storage unit to LVM

      hvs = [getDefaultHypervisor cfg]

      step n (bn, gn, em) =

        let ndp' = getNodeNdParams cfg n

      "mtotal": 4096,

      "dfree": 5 * 1024 * 1024,

      "dtotal": 100 * 1024 * 1024,

      }

    assert (sorted(query._NODE_LIVE_FIELDS.keys()) ==

class TestLegacyNodeInfo(unittest.TestCase):

  KEY_BOOT = "bootid"

  KEY_HV = "cpu_count"

  VAL_BOOT = 0

  VAL_HV = 2

  DICT_HV = {KEY_HV: VAL_HV}

  STD_DICT = {

    KEY_BOOT: VAL_BOOT,

    }

  def testStandard(self):