This patch automatically removes the longest common (domain, i.e.
starting with a dot) suffix from the node and instance names. This gives
a much clearer display, and this format is compatible with the way
Ganeti accepts shortened names.

Based on the node changes, we remove the N+1 check and only show a
warning instead.

Currently, we fail a new instance placement if the new node status is
not N+1 compliant. This means that an allocation on an already N+1
failed node still fails, even though (conceptually) we're not worse than
before.

This patch changes this model to fail the allocation *only* if the node
was N+1 compliant before. This allows balancing to work on non-N+1 happy
clusters, with the caveat that they probably won't be N+1 happy at the
end.

Since we skip N+1 check in some cases, we add a new “failHealth” check
that verifies the node still has strict positive free memory and disk
space.

This patch adds a '*' character to nodes which are not N+1 compliant to
the output, to help with understanding pre- and post-changes cluster
status.

This fixes the doc issue which exists since the addition of hbal. Now
make doc makes sense again.

Since we only use the totals for computations, and we always convert
them via fromIntegral, let's just store them directly as Doubles.

This just makes indendation nicer in many expressions.

This patch changes the computation of p_mem / p_dsk from on-demand
(whenever the cluster stats are computed) to after-modify (after a node
is modified, we update its stats). This brings a god speed-up as only
one node or two are usually changed between cluster-wide stats are
computed.

This patch flattens the two folds into one, by simply building the whole
list of moves instead  of the double recursion (nodes and the each
node's moves). This has no functional change, but it's much cleaner.

Currently we always compute the available node list for moves (for an
instances) based on the nodes of the initial table. This works find,
however is a repeated calculation.

We optimize this by passing a node list (of indexes, not full objects),
which helps in two ways:
  - faster to filter later
  - allows restriction of target nodes by enforcing only this subset as
    target for moves

This cleans up and splits the individual instance move into a separate function.

This patch changes the balancing algorithm to not iterate linearly over
the instances (in a random, but fixed order), instead selecting at each
step the best next move. This should allow a better score (most of the
time), and usually also a shorter solution.

This patch moves a function to Utils and changes hn1 to be able to take
data from RAPI.

This patch changes the tryRapi function so that if the http request
succeeded, we don't try https too.

... hopefully this is more clear.

The patch adds compatibility with RAPI v1, and this required some new
JSON functions as valFromObj doesn't behave nicely.

Some other unrelated changes were done too.

We need to lookup the moving accumulator, of course.

This patch changes the RAPI endpoint return the same data format as the
input files. This will allow using it instead of the files.

This patch changes the format of the input node and instance lists. It
removes the list of primary and secondary instances from the nodes, and
adds the primary and secondary nodes to the instance list.

This is done so that we can have the same input data from commands as
from the RAPI.

This is the initial import of release 0.0.3.