IAllocator currently uses a wrong key name for reading the total disk
space (‘disk_usage’ which was copied from RAPI, but the actual
iallocator key is ‘disk_space_total’).

This patch fixes that and also makes iallocator always use this key,
instead of computing the size by itself—with Ganeti 2.0 this is
key is always available.

During a replace-primary instance move, on the real cluster the instance
is temporarily started on the secondary, and as such we must check that
the secondary node can hold it for this duration. Currently the code
does not, and depending on cluster scoring it will put instances on such
'bad' secondaries (usually without enough memory).

This patch fixes this by adding/removing the instance as a primary on
the secondary node; and then using the result node as the new secondary.
(Since we're in a monad, we could have just tried the allocation and
dropped the result, but this is more clear).

Currently tryAlloc/tryReloc do not return the new instance, as this is
not needed for IAllocator alloc/reloc requests. However, for computing
the space, the new instance is useful, so we modify these functions to
return this information too.

The patch also improves hspace to have (with default parameters) a
parseable output.

And an alignment issue.

This patch makes sure that all references to the name of the software is
ganeti-htools, not simply htools.

This doc-patch adds copyright and license information to (hopefully) all
needed files.

This patch moves the test declaration into QC.hs, so that test.hs has to
be modified only when we add a new test category.

These are generic enough to be used from multiple places, they belong
better in Cluster.hs than in the hail source.

These two will be more generic than now, and belong somewhere else -
Loader.hs is a generic module for data loading, thus we move them there.

Also replace a type with its synonim.

This patch does only doc build changes, doc changes and function move
around (for more logical documentation). It should have no impact at all
on the code.

This is more of an exercise in QuickCheck than strong testing.

This completes the removal started earlier byt removeing the need to
pass the number of nodes to Node.buildPeers, which is now unused.

This patch adds a QuickCheck-based test infrastructure and initial tests
based on it. The PeerMap module has a 100% coverage ☺️

Side-note: one has to read the source of QuickCheck to see how to use it
(especially the Batch submodule), the docs are not enough…

This patch removes some unused functions and does some cleanup of the
remaining ones.

We remove some unused arguments (added way back for compatibility with
Arrays, which we didn't use in the end). This makes the code clearer
(and doesn't need the Ndx type to be an instance of Num).

Currently we (wrongly) use lookupNode to lookup instances, just because
the name assoc list has the same type. This patch adds a separate
function for it.

This is a first step towards full datatype renaming. That requires more
changes, so at first we only want to document clearly what is a node
index, what is an instance index, and what is a plain Int.

This patch makes the Types module a base module, and Node/Instance ones
import it, from the previous (opposite) situation. This will allow in
the future to use newtypes for the index and name types.

The IAllocator source was copied from Rapi before the offline node fixes
were made. This changes such that offline nodes are accepted correctly.

Currently iallocator is broken when reading single-node instances (and
with an ugly error message). This patch fixes this case, by marking them
with secondary node “noSecondary” like the rest of the code.

Slash is a reserved char. Slash is a reserved char. Slash is a…

This patch implements filtering out of the offline/drained nodes and
fixes a bug in IAllocator.hs parsing (similar to an older bug in Rapi.hs
from where the code was copied).

This patch implements non-mirrored instance allocation, by allocating as
secondary node “noSecondary”.

This patch implements allocate for two node requests. One node requests
can be done as soon as we have a valid allocateOn function for single
nodes.

This patch completes the implementation of hail relocate. It maps all
valid destination nodes through a ReplaceSecondary IMove, filters out
the failed relocations, computes the resulting scores and picks the
lowest one.

This patch implements a very stupid (and broken) version of hail
‘allocate’.

This patch removes the ktn/kti lists from most parts of the first half
of the loading sequence. Some remain as the [(String, Int)] is the
nicest way to lookup names and get indices back.

This removes the return of ktn/kti from Loader.mergeData and associated
functions.

This patch removes all uses of ktn/kti from the past-loader stages.

These will be used to remove even more uses of ktn/kti in non-critical
paths.

Since we have Node/Instance.name, we can now simplify a few constructs.

This strips the suffix from the objects themselves, not only from the
ktn/kti vars.

This patch makes the format of IAlloc.loadData be similar the same as
Loader.mergeData.

This patch moves the common loading sequence to CLI, such that hbal/hn1
and possible future scripts that take the input from same sources can
use it.

This moves the remaining loading function to Loader (together with its
associated support functions).