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

Allocation results, as used in iterateAlloc and tieredAlloc.

Type alias for easier handling.

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.

The complete state for the balancing solution.

Cluster statistics data type.

A simple type for allocation functions.

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

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.

Zero-initializer for the CStats type.

Update stats with data from a new node.

Compute the total free disk and memory in the cluster.

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.

Compute online nodes from a List.

Compute best table. Note that the ordering of the arguments is important.

Tries to perform an instance move and returns the best table between the original one and the new one.

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.

Compute the best move for a given instance.

Compute the best next move.

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

Run a balance move.

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

Try to allocate an instance on the cluster.

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.

Sort multigroup results based on policy and score.

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

Removes node groups which can't accommodate the instance

Finds an allocation solution for an instance on a group

Finds the best group for an instance on a multi-group cluster.

Only solutions in preferred and last_resort groups will be accepted as valid, and additionally if the allowed groups parameter is not null then allocation will only be run for those group indices.

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

Try to allocate an instance to a group.

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

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:

1. 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
2. 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.

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.

Guess a number of machines worth trying to put on the cluster in one step. The goal is to guess a number close to the actual capacity of the cluster but preferrably not bigger, unless it is quite small (as we don't want to do big steps smaller than 20).

A speed-up version of iterateAllocSmallStep.

This function returns precisely the same result as iterateAllocSmallStep. However the computation is speed up by the following heuristic: allocate a group of instances iteratively without considering global N+1 redundancy; if the result of this is globally N+1 redundant, then everything was OK inbetween and we can continue from there. Only if that fails, do a step-by-step iterative allocation. In order to further speed up the computation while keeping it robust, we first try (if the first argument is True) a number of steps guessed from the node capacity, then, if that failed, a fixed step size and only as last restort step-by-step iterative allocation.

A speed-up version of iterateAllocSmallStep.

Predicate whether shrinking a single resource can lead to a valid allocation.

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.

Given the original and final nodes, computes the relocation description.

Converts a placement to string format.

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.

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

Inner function for splitJobs, that either appends the next job to the current jobset, or starts a new jobset.

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

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

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

Print the node list.

Print the instance list.

Computes the group of an instance.

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