Synnefo » snf-ganeti » ganeti-local

type Score = Double

-- | The description of an instance placement.

{- | A cluster solution described as the solution delta and the list

of placements.

-- | An instance move definition

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

             deriving (Show)

-- | The complete state for the balancing solution

-- Second phase functions

-- | Single-node relocation cost

nodeDelta i p s =

    if i == p || i == s then

        0

-- | Apply a move

applyMove :: Node.List -> Instance.Instance

-- Failover (f)

applyMove nl inst Failover =

    let old_pdx = Instance.pnode inst

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

-- and the current candidate target node,

-- generate the possible moves for a instance.

possibleMoves True tdx =

    [ReplaceSecondary tdx,

     ReplaceAndFailover tdx,

     ReplaceAndFailover tdx]

-- | Compute the best move for a given instance.

                  -> Table             -- Original table

                  -> Instance.Instance -- Instance to move

                  -> Table             -- Best new table for this instance

      foldl' (checkSingleStep ini_tbl target) aft_failover all_moves

-- | Compute the best next move.

          -> Table               -- ^ The current solution

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

          -> Table               -- ^ The new solution

data RqType

    = Allocate Instance.Instance Int

    deriving (Show)

data Request = Request RqType Node.List Instance.List String

                         , running :: Bool  -- ^ whether the instance

                                            -- is running

                         , run_st :: String -- ^ original (text) run status

                                            -- book-keeping

                         } deriving (Show)

    setIdx  = setIdx

-- | A simple name for the int, instance association list

-- | A simple name for an instance map

type List = Container.Container Instance

create name_init mem_init dsk_init run_init pn sn =

    Instance {

          name = name_init,

-- | Changes the primary node of the instance.

setPri :: Instance  -- ^ the original instance

        -> Instance -- ^ the modified instance

setPri t p = t { pnode = p }

-- | Changes the secondary node of the instance.

setSec :: Instance  -- ^ the original instance

        -> Instance -- ^ the modified instance

setSec t s = t { snode = s }

-- | Changes both nodes of the instance.

setBoth :: Instance  -- ^ the original instance

         -> Instance -- ^ the modified instance

setBoth t p s = t { pnode = p, snode = s }

-- | Changes the index.

-- This is used only during the building of the data structures.

setIdx :: Instance  -- ^ the original instance

        -> Instance -- ^ the modified instance

setIdx t i = t { idx = i }

import Ganeti.HTools.Types

-- | Lookups a node into an assoc list

lookupNode ktn inst node =

    case lookup node ktn of

      Nothing -> fail $ "Unknown node '" ++ node ++ "' for instance " ++ inst

          . zip [0..]

-- | For each instance, add its index to its primary and secondary nodes

fixNodes nl il =

    foldl' (\accu (idx, inst) ->

                let

                 , x_mem :: Int    -- ^ unaccounted memory (MiB)

                 , t_dsk :: Double -- ^ total disk space (MiB)

                 , f_dsk :: Int    -- ^ free disk space (MiB)

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

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

                 , r_mem :: Int    -- ^ maximum memory needed for

    setIdx = setIdx

-- | A simple name for the int, node association list

-- | A simple name for a node map

type List = Container.Container Node

-- | Constant node index for a non-moveable instance

noSecondary = -1

{- | Create a new node.

-- | Changes the index.

-- This is used only during the building of the data structures.

setIdx t i = t {idx = i}

-- | Changes the name

computeMaxRes new_peers = PeerMap.maxElem new_peers

-- | Builds the peer map for a given node.

buildPeers t il num_nodes =

    let mdata = map

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

                failN1 = new_failn1, p_mem = new_mp, p_dsk = new_dp}

-- | Adds a secondary instance.

addSec t inst pdx =

    let iname = Instance.idx inst

        old_peers = peers t

                p_rem = new_prem}

-- | Add a primary instance to a node without other updates

setPri t idx = t { plist = idx:(plist t) }

-- | Add a secondary instance to a node without other updates

setSec t idx = t { slist = idx:(slist t) }

-- | String converter for the node list functionality.

import Data.Function

import Data.Ord

type Elem = Int

type PeerMap = [(Key, Elem)]

  nlist <- mapM parseNode arr

  return nlist

              -> JSObject JSValue

              -> Result (String, Instance.Instance)

parseInstance ktn a = do

-- | Load an instance from a field list

loadInst :: (Monad m) =>

loadInst ktn (name:mem:dsk:status:pnode:snode:[]) = do

  pidx <- lookupNode ktn name pnode

  sidx <- (if null snode then return Node.noSecondary

module Ganeti.HTools.Types

    where

-- | The type used to hold idx-to-name mappings

type NameList = [(Int, String)]

tryReloc :: (Monad m) =>

            Node.List

         -> Instance.List

         -> Int

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

tryReloc nl il xid 1 ex_idx =

    let all_nodes = getOnline nl

        inst = Container.find xid il

        ex_idx' = (Instance.pnode inst):ex_idx

        valid_idxes = map Node.idx valid_nodes

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

                                    Cluster.applyMove nl inst