Synnefo » snf-ganeti » ganeti-local

-- | Verifies the N+1 status and return the affected nodes.

verifyN1 :: [Node.Node] -> [Node.Node]

{-| Computes the pair of bad nodes and instances.

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

computeBadItems nl il =

  let bad_nodes = verifyN1 $ getOnline nl

  in

    (bad_nodes, bad_instances)

                 cs_amem = x_amem, cs_acpu = x_acpu, cs_adsk = x_adsk,

                 cs_mmem = x_mmem, cs_mdsk = x_mdsk, cs_mcpu = x_mcpu }

            = cs

        inc_amem' = if inc_amem > 0 then inc_amem else 0

        inc_adsk = Node.availDisk node

              , cs_amem = x_amem + inc_amem'

              , cs_adsk = x_adsk + inc_adsk

              , cs_acpu = x_acpu

        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)

          let tmp_s' = Node.removePri tmp_s inst

          new_p <- Node.addPri tgt_n inst

          new_s <- Node.addSec tmp_s' inst new_pdx

                 Container.addTwo old_pdx int_p old_sdx new_s nl

    in (new_nl, Instance.setPri inst new_pdx, new_pdx, old_sdx)

        new_nl = do -- Maybe monad

          new_p <- Node.addPri tgt_n inst

          new_s <- Node.addSec int_p inst new_pdx

                 Container.addTwo old_pdx new_s old_sdx int_s nl

    in (new_nl, Instance.setBoth inst new_pdx old_pdx, new_pdx, old_pdx)

        new_nl = do -- Maybe monad

          new_p <- Node.addPri int_s inst

          new_s <- Node.addSec tgt_n inst old_sdx

                 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)

    in return sols

tryAlloc _ _ _ reqn = fail $ "Unsupported number of alllocation \

                                               "), only two supported"

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

tryReloc nl il xid 1 ex_idx =

    let all_nodes = getOnline nl

        inst = Container.find xid il

        valid_nodes = filter (not . flip elem ex_idx' . Node.idx) all_nodes

        valid_idxes = map Node.idx valid_nodes

        sols1 = map (\x -> let (mnl, i, _, _) =

    in return sols1

tryReloc _ _ _ reqn _  = fail $ "Unsupported number of relocation \

                                                  "), only one supported"

-- * Formatting functions

        opri = Container.nameOf nl $ Instance.pnode inst

        osec = Container.nameOf nl $ Instance.snode inst

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

    in

      (printf "  %3d. %-*s %-*s => %-*s %.8f a=%s"

       pos imlen inam pmlen ostr

-- | Given a list of commands, prefix them with @gnt-instance@ and

-- also beautify the display a little.

formatCmds :: [[String]] -> String

-- | Converts a solution to string format.

printSolution :: Node.List

        nmlen = Container.maxNameLen nl

        imlen = Container.maxNameLen il

    in

-- | Print the node list.

printNodes :: Node.List -> String

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

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

        helper = Node.list m_name

-- | Shows statistics for a given node list.

printStats :: Node.List -> String