Synnefo » snf-ganeti

{-

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

  let vm_capable' = fromMaybe True vm_capable

  gidx <- lookupGroup ktg n guuid

  node <- if offline || drained || not vm_capable'

            else do

              mtotal <- extract "total_memory"

              mnode  <- extract "reserved_memory"

              dtotal <- extract "total_disk"

              dfree  <- extract "free_disk"

              ctotal <- extract "total_cpus"

              return $ Node.create n mtotal mnode mfree

  return (n, node)

-- | Parses a group as found in the cluster group list.

{-

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

queryNodesMsg =

  L.Query L.QRNode ["name", "mtotal", "mnode", "mfree", "dtotal", "dfree",

                    "ctotal", "offline", "drained", "vm_capable",

-- | The input data for instance query.

queryInstancesMsg :: L.LuxiOp

-- | Construct a node from a JSON object.

parseNode :: NameAssoc -> [(JSValue, JSValue)] -> Result (String, Node.Node)

parseNode ktg [ name, mtotal, mnode, mfree, dtotal, dfree

    = do

  xname <- annotateResult "Parsing new node" (fromJValWithStatus name)

  let convert a = genericConvert "Node" xname a

  xoffline <- convert "offline" offline

  xdrained <- convert "drained" drained

  xvm_capable <- convert "vm_capable" vm_capable

  xgdx   <- convert "group.uuid" g_uuid >>= lookupGroup ktg xname

  node <- if xoffline || xdrained || not xvm_capable

            else do

              xmtotal  <- convert "mtotal" mtotal

              xmnode   <- convert "mnode" mnode

              xdfree   <- convert "dfree" dfree

              xctotal  <- convert "ctotal" ctotal

              return $ Node.create xname xmtotal xmnode xmfree

  return (xname, node)

parseNode _ v = fail ("Invalid node query result: " ++ show v)

  , fDsk     :: Int       -- ^ Free disk space (MiB)

  , tCpu     :: Double    -- ^ Total CPU count

  , uCpu     :: Int       -- ^ Used VCPU count

  , pList    :: [T.Idx]   -- ^ List of primary instance indices

  , sList    :: [T.Idx]   -- ^ List of secondary instance indices

  , idx      :: T.Ndx     -- ^ Internal index for book-keeping

                          -- threshold

  , hiCpu    :: Int       -- ^ Autocomputed from mCpu high cpu

                          -- threshold

  , offline  :: Bool      -- ^ Whether the node should not be used for

                          -- allocations and skipped from score

                          -- computations

-- The index and the peers maps are empty, and will be need to be

-- update later via the 'setIdx' and 'buildPeers' functions.

create :: String -> Double -> Int -> Int -> Double

create name_init mem_t_init mem_n_init mem_f_init

  Node { name = name_init

       , alias = name_init

       , tMem = mem_t_init

       , tDsk = dsk_t_init

       , fDsk = dsk_f_init

       , tCpu = cpu_t_init

       , uCpu = 0

       , pList = []

       , sList = []

       , mDsk = T.defReservedDiskRatio

       , loDsk = mDskToloDsk T.defReservedDiskRatio dsk_t_init

       , hiCpu = mCpuTohiCpu (T.iPolicyVcpuRatio T.defIPolicy) cpu_t_init

       , utilPool = T.baseUtil

       , utilLoad = T.zeroUtil

       , pTags = Map.empty

mCpuTohiCpu :: Double -> Double -> Int

mCpuTohiCpu mval = floor . (mval *)

-- | Changes the index.

--

-- This is used only during the building of the data structures.

setPolicy :: T.IPolicy -> Node -> Node

setPolicy pol node =

  node { iPolicy = pol

-- | Computes the maximum reserved memory for peers from a peer map.

computeMaxRes :: P.PeerMap -> P.Elem

  cpu_t <- choose (base_cpu, top_cpu)

  offl  <- arbitrary

  let n = Node.create name (fromIntegral mem_t) mem_n mem_f

      n' = Node.setPolicy nullIPolicy n

  return $ Node.buildPeers n' Container.empty

{-

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

  drained <- extract "drained"

  vm_cap  <- annotateResult desc $ maybeFromObj a "vm_capable"

  let vm_cap' = fromMaybe True vm_cap

  guuid   <- annotateResult desc $ maybeFromObj a "group.uuid"

  guuid' <-  lookupGroup ktg name (fromMaybe defaultGroupID guuid)

  node <- if offline || drained || not vm_cap'

            else do

              mtotal  <- extract "mtotal"

              mnode   <- extract "mnode"

              dfree   <- extract "dfree"

              ctotal  <- extract "ctotal"

              return $ Node.create name mtotal mnode mfree

  return (name, node)

-- | Construct a group from a JSON object.

{-

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

                     Node.create (printf "node-%02d-%03d" grpIndex idx)

                           (fromIntegral mem) 0 mem

                           (fromIntegral disk) disk

                  ) [1..ncount]

      grp = Group.create (printf "group-%02d" grpIndex)

            (printf "fake-uuid-%02d" grpIndex) apol defIPolicy

  gdx <- lookupGroup ktg name gu

  new_node <-

      if any (== "?") [tm,nm,fm,td,fd,tc] || fo == "Y" then

      else do

        vtm <- tryRead name tm

        vnm <- tryRead name nm

        vtd <- tryRead name td

        vfd <- tryRead name fd

        vtc <- tryRead name tc

  return (name, new_node)

loadNode _ s = fail $ "Invalid/incomplete node data: '" ++ show s ++ "'"