Synnefo » snf-ganeti » ganeti-local

    -- | Whether to be less verbose.

    silent     :: a -> Bool

-- | Command line parser, using the 'options' structure.

parseOpts :: (CLIOptions b) =>

             [String]            -- ^ The command line arguments

          do

            let resu@(po, _) = (foldl (flip id) defaultOptions o, n)

            when (showHelp po) $ do

              exitWith ExitSuccess

            when (showVersion po) $ do

              printf "%s %s\ncompiled with %s %s\nrunning on %s %s\n"

              exitWith ExitSuccess

            return resu

      (_, _, errs) ->

-- | Parse the environment and return the node\/instance names.

--

    (

     -- * Types

      Placement

    , Solution(..)

    , Table(..)

    , Removal

-- | The description of an instance placement.

type Placement = (Idx, Ndx, Ndx, Score)

-- | A cluster solution described as the solution delta and the list

-- of placements.

data Solution = Solution Int [Placement]

        mem_cv = varianceCoeff mem_l

        dsk_cv = varianceCoeff dsk_l

        n1_l = length $ filter Node.failN1 nodes

        res_l = map Node.p_rem nodes

        res_cv = varianceCoeff res_l

        offline_inst = sum . map (\n -> (length . Node.plist $ n) +

                                        (length . Node.slist $ n)) $ offline

        online_inst = sum . map (\n -> (length . Node.plist $ n) +

                                       (length . Node.slist $ n)) $ nodes

        cpu_l = map Node.p_cpu nodes

        cpu_cv = varianceCoeff cpu_l

    in (mem_cv, dsk_cv, n1_score, res_cv, off_score, cpu_cv)

         -> Instance.List     -- ^ The instance list

         -> Instance.Instance -- ^ The instance to allocate

         -> Int               -- ^ Required number of nodes

tryAlloc nl _ inst 2 =

    let all_nodes = getOnline nl

        all_pairs = liftM2 (,) all_nodes all_nodes

-- | Try to allocate an instance on the cluster.

tryReloc :: (Monad m) =>

tryReloc nl il xid 1 ex_idx =

    let all_nodes = getOnline nl

        inst = Container.find xid il

    let snl = sortBy (compare `on` Node.idx) (Container.elems nl)

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

        helper = Node.list m_name

    in unlines $ (header:map helper snl)

-- | Shows statistics for a given node list.

    , Request(..)

    ) where

import Data.List

import Data.Maybe (fromJust)

import Text.Printf (printf)

    unzip . map (\ (idx, (k, v)) -> ((k, idx), (idx, setIdx v idx)))

          . zip [0..]

-- | For each instance, add its index to its primary and secondary nodes.

fixNodes :: [(Ndx, Node.Node)]

         -> [(Idx, Instance.Instance)]

fixNodes nl il =

    foldl' (\accu (idx, inst) ->

                let

                    pdx = Instance.pnode inst

                    sdx = Instance.snode inst

                    pold = fromJust $ lookup pdx accu

                             - (nodeIdsk node il)

                 newn = Node.setFmem (Node.setXmem node delta_mem)

                        (Node.f_mem node - adj_mem)

             in (msgs ++ umsg1, newn)

        ) [] nl

import qualified Ganeti.HTools.Node as Node

import qualified Ganeti.HTools.Instance as Instance

-- | Safe 'read' function returning data encapsulated in a Result.

tryRead :: (Monad m, Read a) => String -> String -> m a

-- | Load a node from a field list.

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

meanValue :: Floating a => [a] -> a

meanValue lst = (sum lst) / (fromIntegral $ length lst)

-- | Standard deviation.

stdDev :: Floating a => [a] -> a

stdDev lst =

    let mv = meanValue lst

        av = sum $ map square $ map (\e -> e - mv) lst

        bv = sqrt (av / (fromIntegral $ length lst))

    in bv

        sols'' = sortBy (compare `on` fst) sols'

        (best, w) = head sols''

        (worst, l) = last sols''

    in return (info, w)

-- | Main function.

main :: IO ()

main = do

                 exitWith $ ExitFailure 1

               Ok rq -> return rq

  let (ok, info, rn) = case sols of

               Ok (info, sn) -> (True, "Request successful: " ++ info,

                                     map ((++ csf) . Node.name) sn)

                         nmlen imlen [] oneline min_cv

  let (Cluster.Table fin_nl _ fin_cv fin_plc) = fin_tbl

      ord_plc = reverse fin_plc

  unless oneline $ putStr sol_msg

      "show help"

    ]

-- | Generate node file data from node objects

-- | Generate instance file data from instance objects

-- | Return a one-line summary of cluster state

printCluster :: Node.List -> Instance.List

        ccv = Cluster.compCV nl

        nodes = Container.elems nl

        insts = Container.elems il

        f_ram = sum . map Node.f_mem $ nodes

        f_dsk = sum . map Node.f_dsk $ nodes

    in

                 (length nodes) (length insts)

                 (length bad_nodes) (length bad_instances)

                 ccv

                   putStrLn $ printCluster fix_nl il

                   when (optShowNodes opts) $ do

                           putStr $ Cluster.printNodes fix_nl

                       oname = odir </> (fixSlash name)

                   writeFile (oname <.> "nodes") ndata

                   writeFile (oname <.> "instances") idata)

      "show help"

    ]

filterFails sols =

    else let sols' = filter (isJust . fst3) sols

         in if null sols' then

            else

                return $ map (\(x, y, z) -> (fromJust x, y, z)) sols'

             -> (Node.List, [Instance.Instance])

iterateDepth nl il newinst nreq ixes =

      let depth = length ixes

          newidx = (length $ Container.elems il) + depth

          newi2 = Instance.setIdx (Instance.setName newinst newname) newidx

          orig = (nl, ixes)

      in

        if isNothing sols then orig