Synnefo » snf-ganeti

printBool True False = "0"

printBool False b = show b

printGroupsMappings :: Group.List -> IO ()

printGroupsMappings gl = do

    let extract_vals = \g -> (printf "GROUP_UUID_%d" $ Group.idx g :: String,

        printpairs = map extract_vals (Container.elems gl)

    printKeysHTC printpairs

-- | Extract name or idx from group.

extractGroupData :: Bool -> Group.Group -> String

extractGroupData False grp = Group.name grp

-- | Prepare values for group.

prepareGroupValues :: [Int] -> Double -> [String]

prepareGroupValues stats score =

-- | Prepare values for cluster.

prepareClusterValues :: Bool -> [Int] -> [Bool] -> [String]

prepareClusterValues machineread stats bstats =

-- | Print all the statistics on a group level.

printGroupStats :: Int -> Bool -> Phase -> Group.Group -> [Int] -> Double

instances residing on offline nodes.

-}

perGroupChecks verbose machineread phase gl (gidx, (nl, il)) = do

  let grp = Container.find gidx gl

      offnl = filter Node.offline (Container.elems nl)

  return groupstats

-- | Use Hbal's iterateDepth to simulate group rebalance.

executeSimulation opts ini_tbl min_cv gidx nl il = do

  let imlen = maximum . map (length . Instance.alias) $ Container.elems il

      nmlen = maximum . map (length . Node.alias) $ Container.elems nl

-- | Simulate group rebalance if group's score is not good

maybeSimulateGroupRebalance :: Options -> (Gdx, (Node.List, Instance.List))

maybeSimulateGroupRebalance opts (gidx, (nl, il)) = do

  let ini_cv = Cluster.compCV nl

      ini_tbl = Cluster.Table nl il ini_cv []

      min_cv = optMinScore opts

    then return (gidx, (nl, il))

    else executeSimulation opts ini_tbl min_cv gidx nl il

maybeSimulateRebalance :: Bool             -- ^ Whether to simulate rebalance

                       -> Options          -- ^ Command line options

                       -> [(Gdx, (Node.List, Instance.List))] -- ^ Group data

maybeSimulateRebalance True opts cluster =

    mapM (maybeSimulateGroupRebalance opts) cluster

maybeSimulateRebalance False _ cluster = return cluster

  when machineread $ printGroupsMappings gl

  let clusterstats = map sum (transpose groupsstats) :: [Int]

      needrebalance = clusterNeedsRebalance clusterstats

      canrebalance = length splitinstances == 0

  when nosimulation $ do

    unless (verbose == 0 || machineread) $

  when (length splitinstances > 0) $ do

    unless (verbose == 0 || machineread) $

  unless needrebalance $ do

    unless (verbose == 0 || machineread) $

  let exitOK = nosimulation || not needrebalance

  rebalancedcluster <- maybeSimulateRebalance simulate opts splitcluster