This splits the current “clean” rule into proper clean (cleaning of
build artifacts) and maintainer-clean (cleaning of distributed files).
This should make it better for Debian packaging.

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

Also replace tabs in an older entry with spaces.

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.

This patch fixes the relocate-to-primary-node problem, and doesn't mark
the excluded nodes as offline anymore (we don't use them anyway, so
let's not use a different/fake cluster state).

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”.

Both allocate and relocate compute new node lists, whose score must be
ranked and the best option chosen. This means we can convert the code to
a generic function.

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.

This is not yet used.

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).

This patch generalizes a little the CLI handling by not passing in a
special function for help and such, but instead requiring that the
options object supports some common functionality.

Since both nodes and instances support some common functionality (names
and indices), we add a class so that we can access these attributes in a
generic way.

In order to simplify the data structures, we add back the name on the
node and instance objects. We still keep the index for, well, indexing,
but we will use the name directly from the object, in order to get rid
of the ktn/kti arguments which are passed around everywhere.

This new big patch does a couple of more cleanups in the loading of data
chapter:
  - introduce a Types module that holds most types (except the base
    Node/Instance/etc.) so that multiple other modules can use these
    (instead of only Cluster and its users)
  - bring IAlloc.hs in line with the recent changes of providing data
    types and not strings
  - removal of obsolete Utils.hs json-related functions

This big patch changes the loader model from “string data as common
format” to actual object structures as common format.

The text loading function move from Cluster.hs to a new Text.hs module,
some common functions are moved to a new Loader.hs module, and the
return values from both Rapi.hs and Text.hs are uniformized.

This makes hail compile and get a request parsed via IAlloc, but nothing
more.

This patch adds experimental support to hbal for non-redundant instances
(i.e.  instances with only one node). They are currently handled as
non-moveable, and as such the algorithm simply ignores them.

Supports needs to be added when reading from RAPI via hscan, and
probably in other corner cases.

This patch switches from plain read to a wrapper over readsPrec that
returns better error messages than the buildin 'Prelude: no parse'.

This allows easy checking for valid format of the input data (row-wise).

This patch converts loadTabular and loadData to a monadic form, thus
allowing meaningful error messages from the node/instance load routines.

D'oh, one can extract from a wrapped variable, not only from functions.

This patch changes Cluster.loadData to return a Result, instead of
directly the values; this will allow us to return meaningful error
values (e.g. when an instances lives on unknown node) rather than simply
abort. Currently the result is always an Ok, the actual signalling of
errors will come later.

Its callers are changed to accommodate for the new return type and to
display errors as needed.