Synnefo » snf-ganeti » ganeti-local

module Ganeti.HTools.Cluster

    (

     -- * Types

    , Placement

    , Solution(..)

    , Table(..)

                      _ -> -1

-- | A removal set.

-- | An instance move definition

data IMove = Failover                -- ^ Failover the instance (f)

             deriving (Show)

-- | The complete state for the balancing solution

             deriving (Show)

-- General functions

verifyN1 nl = filter Node.failN1 nl

{-| Add an instance and return the new node and instance maps. -}

addInstance nl idata pri sec =

  let pdx = Node.idx pri

      sdx = Node.idx sec

      return new_nl

-- | Remove an instance and return the new node and instance maps.

removeInstance nl idata =

  let pnode = Instance.pnode idata

      snode = Instance.snode idata

  new_nl

-- | Remove an instance and return the new node map.

removeInstances = foldl' removeInstance

-- | Compute the total free disk and memory in the cluster.

their new nodes.

 -}

applySolution nl il sol =

    let odxes = map (\ (a, b, c, _) -> (Container.find a il,

                                        Node.idx (Container.find b nl),

those nodes.

-}

                   ([Node.Node], [Instance.Instance])

computeBadItems nl il =

  let bad_nodes = verifyN1 $ filter (not . Node.offline) $ Container.elems nl

placement can make this shortcut.

-}

checkRemoval nl victims =

  let nx = removeInstances nl victims

      failN1 = verifyN1Check (Container.elems nx)

-- | Computes the removals list for a given depth

                 -> [Instance.Instance]

                 -> Int

                 -> [Maybe Removal]

    solution by recursing until all target instances are placed.

-}

               -> [Instance.Instance] -- ^ List of instances still to place

               -> [Placement]         -- ^ Partial solution until now

               -> Int                 -- ^ The delta of the partial solution

    ) prev_sol nodes

-- | Apply a move

-- Failover (f)

applyMove nl inst Failover =

    let old_pdx = Instance.pnode inst

                 Container.addTwo old_sdx new_p old_pdx int_p nl

    in (new_nl, Instance.setBoth inst old_sdx new_sdx, old_sdx, new_sdx)

allocateOnSingle nl inst p =

    let new_pdx = Node.idx p

        new_nl = Node.addPri p inst >>= \new_p ->

                 return $ Container.add new_pdx new_p nl

    in (new_nl, Instance.setBoth inst new_pdx Node.noSecondary)

allocateOnPair nl inst tgt_p tgt_s =

    let new_pdx = Node.idx tgt_p

        new_sdx = Node.idx tgt_s

solutionFromRemovals. In case we have no solution, we return Nothing.

-}

                -> [Instance.Instance] -- ^ The list of /bad/ instances

                -> Int             -- ^ The /depth/ of removals

                -> Int             -- ^ Maximum number of removals to process

                      printf "replace-disks -n %s %s" d i])

{-| Converts a placement to string format -}

                  -> Int

                  -> Int

                  -> Placement

        (i, p, s, c) = plc

        inst = Container.find i il

        inam = Instance.name inst

        (moves, cmds) =  computeMoves inam opri osec npri nsec

        ostr = (printf "%s:%s" opri osec)::String

        nstr = (printf "%s:%s" npri nsec)::String

        zip [1..] cmd_strs

{-| Converts a solution to string format -}

              -> [Placement]

              -> ([String], [[String]])

printSolution nl il sol =

    let

    in

      unzip $ map (uncurry $ printSolutionLine nl il nmlen imlen) $

            zip sol [1..]

-- | Print the node list.

printNodes nl =

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

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

    in unlines $ (header:map helper snl)

-- | Compute the mem and disk covariance.

compDetailedCV nl =

    let

        all_nodes = Container.elems nl

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

-- | Compute the 'total' variance.

compCV nl =

    let (mem_cv, dsk_cv, n1_score, res_cv, off_score) = compDetailedCV nl

    in mem_cv + dsk_cv + n1_score + res_cv + off_score

printStats nl =

    let (mem_cv, dsk_cv, n1_score, res_cv, off_score) = compDetailedCV nl

    in printf "f_mem=%.8f, r_mem=%.8f, f_dsk=%.8f, n1=%.3f, uf=%.3f"