Synnefo » snf-ganeti » ganeti-local

    ) where

import Data.List

import Text.Printf (printf)

import Data.Function

import Control.Monad

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

-- | Allocation\/relocation solution.

-- | An instance move definition

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

-- | Applies an instance move to a given node list and instance.

applyMove :: Node.List -> Instance.Instance

-- Failover (f)

applyMove nl inst Failover =

    let old_pdx = Instance.pnode inst

-- | Tries to allocate an instance on one given node.

allocateOnSingle :: Node.List -> Instance.Instance -> Node.Node

allocateOnSingle nl inst p =

    let new_pdx = Node.idx p

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

-- | Tries to allocate an instance on a given pair of nodes.

allocateOnPair :: Node.List -> Instance.Instance -> Node.Node -> Node.Node

allocateOnPair nl inst tgt_p tgt_s =

    let new_pdx = Node.idx tgt_p

        new_sdx = Node.idx tgt_s

        Table ini_nl ini_il _ ini_plc = ini_tbl

        (tmp_nl, new_inst, pri_idx, sec_idx) = applyMove ini_nl target move

    in

-- | Given the status of the current secondary as a valid new node

-- and the current candidate target node,

          p_rem = new_prem}

-- | Adds a primary instance.

addPri t inst =

    let iname = Instance.idx inst

        new_mem = f_mem t - Instance.mem inst

      if (failHealth new_mem new_dsk) || (new_failn1 && not (failN1 t)) ||

         (failLimits t new_dp new_pcpu)

      then

      else

        let new_plist = iname:(plist t)

            new_mp = (fromIntegral new_mem) / (t_mem t)

        in

-- | Adds a secondary instance.

addSec t inst pdx =

    let iname = Instance.idx inst

        old_peers = peers t

    in if (failHealth old_mem new_dsk) || (new_failn1 && not (failN1 t)) ||

          (failLimits t new_dp noLimit)

       then

       else

           let new_slist = iname:(slist t)

           in

-- * Stats functions

    , NameAssoc

    , Result(..)

    , Element(..)

    ) where

-- | The instance index type.

    return = Ok

    fail = Bad

-- | A generic class for items that have updateable names and indices.

class Element a where

    -- | Returns the name of the element

import Data.List

import Data.Function

import Monad

import System

import System.IO

import Ganeti.HTools.IAlloc

import Ganeti.HTools.Types

import Ganeti.HTools.Loader (RqType(..), Request(..))

-- | Command line options structure.

data Options = Options

    ]

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

filterFails sols =

    if null sols then fail "No nodes onto which to allocate at all"

processResults :: (Monad m) => [(Node.List, [Node.Node])]

               -> m (String, [Node.Node])

    in return (info, w)

-- | Process a request and return new node lists

processRequest request =

  let Request rqtype nl il _ = request

  in case rqtype of

import Data.List

import Data.Function

import Monad

import System

import System.IO

import qualified Ganeti.HTools.CLI as CLI

import Ganeti.HTools.Utils

-- | Command line options structure.

data Options = Options

    ]

filterFails :: Cluster.AllocSolution

filterFails sols =

processResults sols =

    let sols' = map (\e@(nl', _, _) -> (Cluster.compCV  nl', e)) sols

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

iterateDepth :: Node.List

             -> Instance.List

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

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

          sols = (Cluster.tryAlloc nl il newi2 nreq)::

          orig = (nl, ixes)

printStats :: String -> Cluster.CStats -> IO ()

printStats kind cs = do