Synnefo » snf-ganeti » ganeti-local

        m_name = maximum . map (length . Node.name) $ snl

        helper = Node.list m_name

        header = printf

                 " F" m_name "Name"

                 "t_mem" "n_mem" "i_mem" "x_mem" "f_mem" "r_mem"

                 "t_dsk" "f_dsk"

    in unlines $ (header:map helper snl)

-- | Shows statistics for a given node list.

    offline <- fromObj "offline" a

    drained <- fromObj "drained" a

    node <- (case offline of

               _ -> do

                 mtotal <- fromObj "total_memory" a

                 return $ Node.create n mtotal mnode mfree

    return (name, node)

-- | Top-level parser.

                    sdx = Instance.snode inst

                    pold = fromJust $ lookup pdx accu

                    pnew = Node.setPri pold idx

                    ac1 = deleteBy assocEqual (pdx, pold) accu

                in

                  if sdx /= Node.noSecondary then

                      let

-}

module Ganeti.HTools.Node

           plist, slist, offline)

    , List

    -- * Constructor

    , setFmem

    , setPri

    , setSec

    -- * Instance (re)location

    , removePri

    , removeSec

                 , x_mem :: Int    -- ^ Unaccounted memory (MiB)

                 , t_dsk :: Double -- ^ Total disk space (MiB)

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

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

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

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

                 , p_mem :: Double -- ^ Percent of free memory

                 , p_dsk :: Double -- ^ Percent of free disk

                 , p_rem :: Double -- ^ Percent of reserved memory

                 , 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 name_init mem_t_init mem_n_init mem_f_init

    Node

    {

      name  = name_init,

      f_mem = mem_f_init,

      t_dsk = dsk_t_init,

      f_dsk = dsk_f_init,

      plist = [],

      slist = [],

      failN1 = True,

      p_mem = (fromIntegral mem_f_init) / mem_t_init,

      p_dsk = (fromIntegral dsk_f_init) / dsk_t_init,

      p_rem = 0,

      offline = offline_init,

      x_mem = 0

    }

setSec :: Node -> T.Idx -> Node

setSec t idx = t { slist = idx:(slist t) }

-- * Update functions

-- | Sets the free memory.

        sl = slist t

        mp = p_mem t

        dp = p_dsk t

        off = offline t

        fn = failN1 t

        tmem = t_mem t

        fmem = f_mem t

        imem = (truncate tmem) - nmem - xmem - fmem

    in

                 (if off then '-' else if fn then '*' else ' ')

                 mname (name t) tmem nmem imem xmem fmem (r_mem t)

                 ((t_dsk t) / 1024) ((f_dsk t) `div` 1024)

                 (length pl) (length sl)

    name <- fromObj "name" a

    offline <- fromObj "offline" a

    node <- (case offline of

               _ -> do

                 drained <- fromObj "drained" a

                 return $ Node.create name mtotal mnode mfree

    return (name, node)

-- | Builds the cluster data from an URL.

-- | Load a node from a field list.

loadNode :: (Monad m) => [String] -> m (String, Node.Node)

  new_node <-

      else do

        vtm <- tryRead name tm

        vnm <- tryRead name nm

        vfm <- tryRead name fm

        vtd <- tryRead name td

        vfd <- tryRead name fd

  return (name, new_node)

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