Safe Haskell	Safe-Infered

Ganeti.HTools.Cluster

Contents

Types
Utility functions
Balancing functions
Allocation functions
Formatting functions
Node group functions

Description

Implementation of cluster-wide logic.

This module holds all pure cluster-logic; I/O related functionality goes into the Main module for the individual binaries.

Synopsis

Types

data AllocDetails Source

Allocation details for an instance, specifying required number of nodes, and an optional group (name) to allocate to

Constructors

AllocDetails Int (Maybe String)

Instances

Show AllocDetails

data GenericAllocSolution a Source

Allocation/relocation solution.

Constructors

AllocSolution
Fields asFailures :: [FailMode] Failure counts asAllocs :: Int Good allocation count asSolution :: Maybe (GenericAllocElement a) The actual allocation result asLog :: [String] Informational messages

type AllocSolution = GenericAllocSolution Score Source

type AllocResult = (FailStats, List, List, [Instance], [CStats])Source

Allocation results, as used in iterateAlloc and tieredAlloc.

type GenericAllocSolutionList a = [(Instance, GenericAllocSolution a)]Source

Type alias for easier handling.

type AllocSolutionList = GenericAllocSolutionList Score Source

type AllocNodes = Either [Ndx] [(Ndx, [Ndx])]Source

A type denoting the valid allocation mode/pairs.

For a one-node allocation, this will be a Left [Ndx], whereas for a two-node allocation, this will be a Right [(Ndx, [Ndx])]. In the latter case, the list is basically an association list, grouped by primary node and holding the potential secondary nodes in the sub-list.

emptyAllocSolution :: GenericAllocSolution aSource

The empty solution we start with when computing allocations.

data Table Source

The complete state for the balancing solution.

Constructors

Table List List Score [Placement]

Instances

Show Table

data CStats Source

Cluster statistics data type.

Constructors

CStats

Fields

csFmem :: Integer: Cluster free mem
csFdsk :: Integer: Cluster free disk
csFspn :: Integer: Cluster free spindles
csAmem :: Integer: Cluster allocatable mem
csAdsk :: Integer: Cluster allocatable disk
csAcpu :: Integer: Cluster allocatable cpus
csMmem :: Integer: Max node allocatable mem
csMdsk :: Integer: Max node allocatable disk
csMcpu :: Integer: Max node allocatable cpu
csImem :: Integer: Instance used mem
csIdsk :: Integer: Instance used disk
csIspn :: Integer: Instance used spindles
csIcpu :: Integer: Instance used cpu
csTmem :: Double: Cluster total mem
csTdsk :: Double: Cluster total disk
csTspn :: Double: Cluster total spindles
csTcpu :: Double: Cluster total cpus
csVcpu :: Integer: Cluster total virtual cpus
csNcpu :: Double: Equivalent to csIcpu but in terms of physical CPUs, i.e. normalised used phys CPUs
csXmem :: Integer: Unnacounted for mem
csNmem :: Integer: Node own memory
csScore :: Score: The cluster score
csNinst :: Int: The total number of instances

Instances

Show CStats

type AllocMethod Source

Arguments

= List	Node list
-> List	Instance list
-> Maybe Int	Optional allocation limit
-> Instance	Instance spec for allocation
-> AllocNodes	Which nodes we should allocate on
-> [Instance]	Allocated instances
-> [CStats]	Running cluster stats
-> Result AllocResult	Allocation result

A simple type for allocation functions.

Utility functions

verifyN1 :: [Node] -> [Node]Source

computeBadItems :: List -> List -> ([Node], [Instance])Source

Computes the pair of bad nodes and instances.

The bad node list is computed via a simple verifyN1 check, and the bad instance list is the list of primary and secondary instances of those nodes.

emptyCStats :: CStats Source

updateCStats :: CStats -> Node -> CStats Source

totalResources :: List -> CStats Source

Compute the total free disk and memory in the cluster.

computeAllocationDelta :: CStats -> CStats -> AllocStats Source

Compute the delta between two cluster state.

This is used when doing allocations, to understand better the available cluster resources. The return value is a triple of the current used values, the delta that was still allocated, and what was left unallocated.

getOnline :: List -> [Node]Source

Balancing functions

compareTables :: Table -> Table -> Table Source

allocateOnSingle :: AlgorithmOptions -> List -> Instance -> Ndx -> OpResult AllocElement Source

allocateOnPair :: AlgorithmOptions -> [Statistics] -> List -> Instance -> Ndx -> Ndx -> OpResult AllocElement Source

checkSingleStep :: Bool -> Table -> Instance -> Table -> IMove -> Table Source

possibleMoves :: MirrorType -> Bool -> Bool -> Bool -> (Bool, Bool) -> Ndx -> [IMove]Source

checkInstanceMove :: AlgorithmOptions -> [Ndx] -> Table -> Instance -> Table Source

checkMove :: AlgorithmOptions -> [Ndx] -> Table -> [Instance] -> Table Source

doNextBalance Source

Arguments

:: Table	The starting table
-> Int	Remaining length
-> Score	Score at which to stop
-> Bool	The resulting table and commands

Check if we are allowed to go deeper in the balancing.

tryBalance Source

Arguments

:: AlgorithmOptions	Algorithmic options for balancing
-> Table	The starting table
-> Maybe Table	The resulting table and commands

Run a balance move.

Allocation functions

collapseFailures :: [FailMode] -> FailStats Source

Build failure stats out of a list of failures.

bestAllocElement :: Ord a => Maybe (GenericAllocElement a) -> Maybe (GenericAllocElement a) -> Maybe (GenericAllocElement a)Source

concatAllocs :: Ord a => GenericAllocSolution a -> OpResult (GenericAllocElement a) -> GenericAllocSolution aSource

Update current Allocation solution and failure stats with new elements.

sumAllocs :: Ord a => GenericAllocSolution a -> GenericAllocSolution a -> GenericAllocSolution aSource

Sums two AllocSolution structures.

genericDescribeSolution :: (a -> String) -> GenericAllocSolution a -> StringSource

genericAnnotateSolution :: (a -> String) -> GenericAllocSolution a -> GenericAllocSolution aSource

Annotates a solution with the appropriate string.

annotateSolution :: AllocSolution -> AllocSolution Source

genAllocNodes Source

Arguments

:: List	Group list
-> List	The node map
-> Int	The number of nodes required
-> Bool	Whether to drop or not unallocable nodes
-> Result AllocNodes	The (monadic) result

Generate the valid node allocation singles or pairs for a new instance.

tryAlloc Source

Arguments

:: Monad m
=> AlgorithmOptions
-> List	The node list
-> List	The instance list
-> Instance	The instance to allocate
-> AllocNodes	The allocation targets
-> m AllocSolution	Possible solution list

Try to allocate an instance on the cluster.

solutionDescription :: (Group, Result (GenericAllocSolution a)) -> [String]Source

Given a group/result, describe it as a nice (list of) messages.

filterMGResults :: [(Group, Result (GenericAllocSolution a))] -> [(Group, GenericAllocSolution a)]Source

From a list of possibly bad and possibly empty solutions, filter only the groups with a valid result. Note that the result will be reversed compared to the original list.

sortMGResults :: Ord a => [(Group, GenericAllocSolution a)] -> [(Group, GenericAllocSolution a)]Source

Sort multigroup results based on policy and score.

hasRequiredNetworks :: Group -> Instance -> BoolSource

Determines if a group is connected to the networks required by the | instance.

filterValidGroups :: [(Group, (List, List))] -> Instance -> ([(Group, (List, List))], [String])Source

findAllocation :: AlgorithmOptions -> List -> List -> List -> Gdx -> Instance -> Int -> Result (AllocSolution, [String])Source

findBestAllocGroup :: AlgorithmOptions -> List -> List -> List -> Maybe [Gdx] -> Instance -> Int -> Result (Group, AllocSolution, [String])Source

tryMGAlloc Source

Arguments

:: AlgorithmOptions
-> List	The group list
-> List	The node list
-> List	The instance list
-> Instance	The instance to allocate
-> Int	Required number of nodes
-> Result AllocSolution	Possible solution list

Try to allocate an instance on a multi-group cluster.

tryGroupAlloc Source

Arguments

:: AlgorithmOptions
-> List	The group list
-> List	The node list
-> List	The instance list
-> String	The allocation group (name)
-> Instance	The instance to allocate
-> Int	Required number of nodes
-> Result AllocSolution	Solution

Try to allocate an instance to a group.

updateIl Source

Arguments

:: List	The original instance list
-> Maybe (GenericAllocElement a)	The result of the allocation attempt
-> List	The updated instance list

Calculate the new instance list after allocation solution.

extractNl Source

Arguments

:: List	The original node list
-> Maybe (GenericAllocElement a)	The result of the allocation attempt
-> List	The new node list

Extract the the new node list from the allocation solution.

allocList Source

Arguments

:: AlgorithmOptions
-> List	The group list
-> List	The node list
-> List	The instance list
-> [(Instance, AllocDetails)]	The instance to allocate
-> AllocSolutionList	Possible solution list
-> Result (List, List, AllocSolutionList)	The final solution list

Try to allocate a list of instances on a multi-group cluster.

tryChangeGroup Source

Arguments

:: AlgorithmOptions
-> List	The cluster groups
-> List	The node list (cluster-wide)
-> List	Instance list (cluster-wide)
-> [Gdx]	Target groups; if empty, any groups not being evacuated
-> [Idx]	List of instance (indices) to be evacuated
-> Result (List, List, EvacSolution)

Change-group IAllocator mode main function.

This is very similar to tryNodeEvac, the only difference is that we don't choose as target group the current instance group, but instead:

at the start of the function, we compute which are the target groups; either no groups were passed in, in which case we choose all groups out of which we don't evacuate instance, or there were some groups passed, in which case we use those
for each instance, we use findBestAllocGroup to choose the best group to hold the instance, and then we do what tryNodeEvac does, except for this group instead of the current instance group.

Note that the correct behaviour of this function relies on the function nodeEvacInstance to be able to do correctly both intra-group and inter-group moves when passed the ChangeAll mode.

iterateAlloc :: AlgorithmOptions -> AllocMethod Source

Standard-sized allocation method.

This places instances of the same size on the cluster until we're out of space. The result will be a list of identically-sized instances.

sufficesShrinking :: (Instance -> AllocSolution) -> Instance -> FailMode -> Maybe Instance Source

tieredAlloc :: AlgorithmOptions -> AllocMethod Source

Tiered allocation method.

This places instances on the cluster, and decreases the spec until we can allocate again. The result will be a list of decreasing instance specs.

Formatting functions

computeMoves :: Instance -> String -> IMove -> String -> String -> (String, [String])Source

printSolutionLine Source

Arguments

:: List	The node list
-> List	The instance list
-> Int	Maximum node name length
-> Int	Maximum instance name length
-> Placement	The current placement
-> Int	The index of the placement in the solution
-> (String, [String])

Converts a placement to string format.

involvedNodes Source

Arguments

:: List	Instance list, used for retrieving the instance from its index; note that this must be the original instance list, so that we can retrieve the old nodes
-> Placement	The placement we're investigating, containing the new nodes and instance index
-> [Ndx]	Resulting list of node indices

Return the instance and involved nodes in an instance move.

Note that the output list length can vary, and is not required nor guaranteed to be of any specific length.

getMoves :: (Table, Table) -> [MoveJob]Source

From two adjacent cluster tables get the list of moves that transitions from to the other

mergeJobs :: ([JobSet], [Ndx]) -> MoveJob -> ([JobSet], [Ndx])Source

splitJobs :: [MoveJob] -> [JobSet]Source

Break a list of moves into independent groups. Note that this will reverse the order of jobs.

formatJob :: Int -> Int -> (Int, MoveJob) -> [String]Source

formatCmds :: [JobSet] -> StringSource

Given a list of commands, prefix them with gnt-instance and also beautify the display a little.

printNodes :: List -> [String] -> StringSource

Print the node list.

printInsts :: List -> List -> StringSource

Print the instance list.

Node group functions

instanceGroup :: List -> Instance -> Result Gdx Source

Computes the group of an instance.

findSplitInstances :: List -> List -> [Instance]Source

Compute the list of badly allocated instances (split across node groups).