Synnefo » snf-ganeti

  let bad_nodes = verifyN1 $ getOnline nl

      bad_instances = map (\idx -> Container.find idx il) .

                      sort . nub $

  in

    (bad_nodes, bad_instances)

                 cs_xmem = x_xmem, cs_nmem = x_nmem, cs_ninst = x_ninst

               }

            = 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

          , cs_imem = x_imem + inc_imem

          , cs_idsk = x_idsk + inc_idsk

          , cs_icpu = x_icpu + inc_icpu

          }

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

    let

        all_nodes = Container.elems nl

        (offline, nodes) = partition Node.offline all_nodes

        mem_cv = varianceCoeff mem_l

        dsk_cv = varianceCoeff dsk_l

        n1_l = length $ filter Node.failN1 nodes

        n1_score = fromIntegral n1_l /

                   fromIntegral (length nodes)::Double

        res_cv = varianceCoeff res_l

        off_score = if offline_inst == 0

                    then 0::Double

                    else fromIntegral offline_inst /

                         fromIntegral (offline_inst + online_inst)::Double

        cpu_cv = varianceCoeff cpu_l

    in [mem_cv, dsk_cv, n1_score, res_cv, off_score, cpu_cv]

          -> IMove -> OpResult (Node.List, Instance.Instance, Ndx, Ndx)

-- Failover (f)

applyMove nl inst Failover =

        old_p = Container.find old_pdx nl

        old_s = Container.find old_sdx nl

        int_p = Node.removePri old_p inst

-- Replace the primary (f:, r:np, f)

applyMove nl inst (ReplacePrimary new_pdx) =

        old_p = Container.find old_pdx nl

        old_s = Container.find old_sdx nl

        tgt_n = Container.find new_pdx nl

-- Replace the secondary (r:ns)

applyMove nl inst (ReplaceSecondary new_sdx) =

        old_s = Container.find old_sdx nl

        tgt_n = Container.find new_sdx nl

        int_s = Node.removeSec old_s inst

-- Replace the secondary and failover (r:np, f)

applyMove nl inst (ReplaceAndFailover new_pdx) =

        old_p = Container.find old_pdx nl

        old_s = Container.find old_sdx nl

        tgt_n = Container.find new_pdx nl

-- Failver and replace the secondary (f, r:ns)

applyMove nl inst (FailoverAndReplace new_sdx) =

        old_p = Container.find old_pdx nl

        old_s = Container.find old_sdx nl

        tgt_n = Container.find new_sdx nl

                  -> Table             -- ^ Best new table for this instance

checkInstanceMove nodes_idx disk_moves ini_tbl target =

    let

        nodes = filter (\idx -> idx /= opdx && idx /= osdx) nodes_idx

        use_secondary = elem osdx nodes_idx

        aft_failover = if use_secondary -- if allowed to failover

        best_tbl =

            foldl'

            (\ step_tbl em ->

                    else compareTables step_tbl $

                         checkInstanceMove nodes_idx disk_moves ini_tbl em)

            ini_tbl victims

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 = foldl' (\cstate x ->

        inam = Instance.name inst

        npri = Container.nameOf nl p

        nsec = Container.nameOf nl s

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

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

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

involvedNodes il plc =

    let (i, np, ns, _, _) = plc

        inst = Container.find i il

    in nub [np, ns, op, os]

-- | Inner function for splitJobs, that either appends the next job to

                         , vcpus :: Int     -- ^ Number of VCPUs

                         , running :: Bool  -- ^ Whether the instance

                                            -- is running

                         , idx :: T.Idx     -- ^ Internal index for

                                            -- book-keeping

                         } deriving (Show)

                      "running" -> True

                      "ERROR_up" -> True

                      _ -> False,

          idx = -1

        }

setPri :: Instance  -- ^ the original instance

        -> T.Ndx    -- ^ the new primary node

        -> Instance -- ^ the modified instance

-- | Changes the secondary node of the instance.

setSec :: Instance  -- ^ the original instance

        -> T.Ndx    -- ^ the new secondary node

        -> Instance -- ^ the modified instance

-- | Changes both nodes of the instance.

setBoth :: Instance  -- ^ the original instance

         -> T.Ndx    -- ^ new primary node index

         -> T.Ndx    -- ^ new secondary node index

         -> Instance -- ^ the modified instance

         -> [(Ndx, Node.Node)]

fixNodes accu (idx, inst) =

    let

        pold = fromJust $ lookup pdx accu

        pnew = Node.setPri pold idx

        pnew' = Node.addCpus pnew (Instance.vcpus inst)

    Container.mapAccum

        (\ msgs node ->

             let nname = Node.name node

                 dilst = filter (not . Instance.running) nilst

                 adj_mem = sum . map Instance.mem $ dilst

                             - nodeImem node il

                             + adj_mem

                             - nodeIdsk node il

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

                 umsg1 = [printf "node %s is missing %d MB ram \

                                 \and %d GB disk"

                                 nname delta_mem (delta_dsk `div` 1024) |

nodeImem node il =

    let rfind = flip Container.find il

    in sum . map (Instance.mem . rfind)

-- | Compute the amount of disk used by instances on a node (either primary

-- or secondary).

nodeIdsk node il =

    let rfind = flip Container.find il

    in sum . map (Instance.dsk . rfind)

module Ganeti.HTools.Node

    ( Node(failN1, name, idx,

    , List

    -- * Constructor

    , create

-- | The node type.

data Node = Node { name  :: String -- ^ The node name

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

                 , peers :: PeerMap.PeerMap -- ^ Pnode to instance mapping

                 , failN1:: Bool   -- ^ Whether the node has failed n1

                                   -- failover by primaries of this node

                                   -- threshold

                                   -- threshold

                 , offline :: Bool -- ^ Whether the node should not be used

                                   -- for allocations and skipped from

    Node

    {

      name  = name_init,

      failN1 = True,

      idx = -1,

      peers = PeerMap.empty,

      offline = offline_init,

    }

-- | Changes the index.

-- | Sets the unnaccounted memory.

setXmem :: Node -> Int -> Node

-- | Sets the max disk usage ratio

setMdsk :: Node -> Double -> Node

                             then noLimitInt

-- | Sets the max cpu usage ratio

setMcpu :: Node -> Double -> Node

-- | Computes the maximum reserved memory for peers from a peer map.

computeMaxRes :: PeerMap.PeerMap -> PeerMap.Elem

buildPeers t il =

    let mdata = map

                (\i_idx -> let inst = Container.find i_idx il

        pmap = PeerMap.accumArray (+) mdata

        new_rmem = computeMaxRes pmap

-- | Assigns an instance to a node as primary without other updates.

setPri :: Node -> T.Idx -> Node

-- | Assigns an instance to a node as secondary without other updates.

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

-- | Add primary cpus to a node

addCpus :: Node -> Int -> Node

addCpus t count =

-- * Update functions

-- | Sets the free memory.

setFmem :: Node -> Int -> Node

setFmem t new_mem =

    in

-- | Removes a primary instance.

removePri :: Node -> Instance.Instance -> Node

removePri t inst =

    let iname = Instance.idx inst

-- | Removes a secondary instance.

removeSec :: Node -> Instance.Instance -> Node

removeSec t inst =

    let iname = Instance.idx inst

        old_peers = peers t

        old_peem = PeerMap.find pnode old_peers

        new_peem =  old_peem - Instance.mem inst

        new_peers = PeerMap.add pnode new_peem old_peers

        new_rmem = if old_peem < old_rmem then

                       old_rmem

                   else

                       computeMaxRes new_peers

-- | Adds a primary instance.

addPri :: Node -> Instance.Instance -> T.OpResult Node

addPri t inst =

    let iname = Instance.idx inst

    in if new_mem <= 0 then T.OpFail T.FailMem

       else if new_failn1 && not (failN1 t) then T.OpFail T.FailMem

       else if l_cpu >= 0 && l_cpu < new_pcpu then T.OpFail T.FailCPU

       else

           in T.OpGood r

-- | Adds a secondary instance.

addSec t inst pdx =

    let iname = Instance.idx inst

        old_peers = peers t

        new_peem = PeerMap.find pdx old_peers + Instance.mem inst

        new_peers = PeerMap.add pdx new_peem old_peers

        new_failn1 = old_mem <= new_rmem

       else if new_failn1 && not (failN1 t) then T.OpFail T.FailMem

                        peers = new_peers, failN1 = new_failn1,

           in T.OpGood r

-- * Stats functions

-- | Computes the amount of available disk on a given node

availDisk :: Node -> Int

availDisk t =

    in

      if _l == noLimitInt

      then _f

-- | String converter for the node list functionality.

list :: Int -> Node -> String

list mname t =

        off = offline t

        fn = failN1 t

        imem = truncate tmem - nmem - xmem - fmem

    in

      if off

             printf " %c %-*s %5.0f %5d %5d %5d %5d %5d %5.0f %5d\

                    \ %4.0f %4d %3d %3d %6.4f %6.4f %5.2f"

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

                 pl sl mp dp cp

    where _types = (inst::Instance.Instance, name::String)

prop_Instance_setPri inst pdx =

    where _types = (inst::Instance.Instance, pdx::Types.Ndx)

prop_Instance_setSec inst sdx =

    where _types = (inst::Instance.Instance, sdx::Types.Ndx)

prop_Instance_setBoth inst pdx sdx =

    where _types = (inst::Instance.Instance, pdx::Types.Ndx, sdx::Types.Ndx)

          si = Instance.setBoth inst pdx sdx

prop_Instance_runStatus_True inst =

    let run_st = Instance.running inst

    in

      run_tx == "running" || run_tx == "ERROR_up" ==> run_st == True

prop_Instance_runStatus_False inst =

    let run_st = Instance.running inst

    in

      run_tx /= "running" && run_tx /= "ERROR_up" ==> run_st == False

            (Instance.name i == name &&

             Instance.vcpus i == vcpus &&

             Instance.mem i == mem &&

test_Text =

    [ run prop_Text_Load_Instance

-- Node tests

-- | Check that an instance add with too high memory or disk will be rejected

                             not (Node.failN1 node)

                             ==>

                             isFailure (Node.addPri node inst)

-- | Check that an instance add with too high memory or disk will be rejected

prop_Node_addSec node inst pdx =

    not (Node.failN1 node)

    ==> isFailure (Node.addSec node inst pdx)

        where _types = (node::Node.Node, inst::Instance.Instance, pdx::Int)

-- | Check that the cluster score is close to zero for a homogeneous cluster

prop_Score_Zero node count =

    ((not $ Node.offline node) && (not $ Node.failN1 node) && (count > 0) &&

    let fn = Node.buildPeers node Container.empty

        nlst = (zip [1..] $ replicate count fn)::[(Types.Ndx, Node.Node)]

        nl = Container.fromAssocList nlst

serializeNode :: String -> Node.Node -> String

serializeNode csf node =

    printf "%s|%.0f|%d|%d|%.0f|%d|%.0f|%c" (Node.name node ++ csf)

               (if Node.offline node then 'Y' else 'N')

-- | Generate node file data from node objects

serializeInstance csf nl inst =

    let

        iname = Instance.name inst ++ csf

        snode = (if sidx == Node.noSecondary

                    then ""

                    else Container.nameOf nl sidx ++ csf)

    in

      printf "%s|%d|%d|%d|%s|%s|%s"

             iname (Instance.mem inst) (Instance.dsk inst)

             pnode snode

-- | Generate instance file data from instance objects

        ccv = Cluster.compCV nl

        nodes = Container.elems nl

        insts = Container.elems il

    in

      printf "%5d %5d %5d %5d %6.0f %6d %6.0f %6d %.8f"

                 (length nodes) (length insts)

         hPutStr stderr . unlines $

         map (\i -> printf "Inst: %*s %-*s %-*s"

                    ix_namelen (Instance.name i)

                           in if sdx == Node.noSecondary then ""

                              else Container.nameOf fin_nl sdx)

             ) fin_ixes