Update NEWS file for the 0.1.0 release

Don't consider offline nodes as N+1 failed

This is just a cosmetic (I hope) change; the nodes shouldn't be used
anyway, and we only correct the display message.

Drop RAPI v1 compatiblity

Since we only support Ganeti 2.0, we drop the 1.2 compatibility.

Add support for 'offline' nodes

This patch drops compatiblity with Ganeti 1.2 and adds support for
offline nodes in the cluster. When reading from RAPI, the drained nodes
are considered offline so that we don't allocate on them too.

Update the IAlloc module

We know have a working parseData function that returns the node and
instance data. This uncovered bad support for non-drbd instances ☹

Move the JSON utilities to Utils.hs

This patch moves the generic/reusable JSON functions to Utils.hs, so
that they're shared between RAPI/IAlloc.

Add a copy of Rapi.HS as IAlloc.hs

This will be used in two ways:
  - format the response to Ganeti (easy, implemented)
  - parse the input data and build the node/instance lists (hard :)

Remove the apidoc dir on clean

hbal: add a --quiet option

This option is the opposite of the --verbose option, and it allows
decreasing the verbosity level from the default of one to zero (which
currently doesn't show the warning messages for missing disk/memory).

hbal: Simplify the oneline formatting

This patch moves the oneline format into a separate function for easier
usage.

hbal: Early exit when we don't have any instances

For clusters with no instances, there is no point in computing either
the score or in running the algorithm. In this case, we exit prematurely
and when running in one-line mode we show dummy information.

hbal: Add a new min-score option

This new parameter causes the algorithm to finish (or even not start at
all) if we reach/have a score better than it.

hbal: Change hardcoded tests to monadic composition

In some case we manually do “if isNothing … then Nothing else …”, which
can be very easily replaced with a monadic construct in the Maybe monad.

Fix the makefile dist rule

It was missing a dependency on the Version.hs file, so right after “make
clean”, a “make dist” used to fail.

Update NEWS file for the 0.0.8 release

Increase allowed missing memory to 512MB

Since Xen seems to “steal” some amounts of memory (depending on total
node memory), we increase the maximum allowed missing memory to 512MB,
based on gathered data from multiple machines.

Update man pages with the env variables

This patch documents the environment variables in the man pages of hbal
and hn1.

Add reading the file names from env vars

This patch adds support for selecting the instance/node file names via
two environment variables (HTOOLS_NODES, HTOOLS_INSTANCES).

Unfortunately we still have lots of duplicated code, since the options
are not unified.

Implement error checks for extra arguments

Neither hbal nor hn1 take any arguments beside the options, so if any
are passed is most likely an unintended error. This patch aborts in such
cases.

Fix the makefile clean rule

Use the $HPROGS variable instead of hardcoding the program names.

Add a gitignore file

Implement writing the command list to a script

This patch adds support in hbal for writing the command list to a shell
script, with error checking and allowing for early exit.

hbal: Abort for invalid offline node names

Since it's easy to pass a wrong node name as offline, we should abort
instead of silently ignoring it.

Updated new in preparation for the 0.0.7 release

More documentation updates

This removes most of the content of the README file (obsoleted by new
algorithm and man pages), modifies the Makefile to include the built
documentation in the source archive (so that haddock/hscolour are not
needed) and updates the haddock-prologue with current information.

More man page updates

This moves some data from README to the man pages and has other general
improvements.

Add checks for missing disk space

This small patch adds disk space checks to the Cluster.checkData
function, and simplifies a little the warning messages.

Include DRBD overhead in sda/sdb size

For Ganeti 1.2 which doesn't have the ‘disk_usage’ instance query field,
we need to manually include the DRBD overhead (per disk). This patch
modifies the RAPI collection to do this, but loading from disk does not
as it's unknown if the query came from hscan or RAPI 1.2 or RAPI 2.0...

Documentation updates

This patch adds a man page for hscan and updates the README and other
man pages with the latest changes.

Update all needed node fields on f_mem change

This fixes the setFmem function which didn't compute other related
fields after free memory change. Ideally, this should be abstracted so
that add/remove Pri and similar functions could reuse it instead of
duplicating code.

Fix interaction between down instances and nodes

If an instance is down, it's memory is not reflected in the node used
memory, and thus the node free memory is higher than the actual value.
This patch deducts the memory for such instances from the node free
memory, allowing a correct calculation for such cases.

Add a new instance field denoting run status

This patch modifies Rapi, the Cluster.loadData and hscan serialization to load
and save the instance run status. At instance level, we add both a boolean
field denoting the true/false run status, and a string field which holds the
original value (since we don't have a 1-to-1 mapping) for use in hscan
serialization.

The run status is not yet used.

Show the x_mem/i_mem in node list

This patch adds checking of cluster data in the binaries and display of
node's x_mem/i_mem in the node list.

Add functions to check and fix cluster data

This patch adds a checkData function which goes over the node list and computes
the unaccounted memory, returning a list of warning messages (if any) and the
update nodes.

Add a new node filed x_mem

Nodes can have some memory unaccounted for, due to (e.g.) hypervisor
overhead, rounding errors in reporting, etc.

It is better if we model this memory explicitly instead of hiding it,
and actually since the n_mem addition it is actually required to do so.

The new attribute is not yet used.

Split common CLI functionality into a module

This patch moves the common CLI functionality (as much as currently
possible) into a separate module. This means we only have one parseOpts
and that Utils.hs doesn't keep this kind of functions anymore.

Remove unused and obsolete function

The Node.str function is very old and is not useful since the node
objects have much more fields today. This patch removes it, and if
needed a full node display can be done via ‘show’.

Add node memory field to Node objects

This patch adds a new n_mem field to the node objects, and implements
read/save/show support for it. The field is not currently used (except
in the node list) but will be used for checking data consistency and
instance up/down status.

Pass actual types to node/instance constructors

This patch changes the parameters passed to the node and instance
constructors from generic Strings (which are then parsed via “read”) to
the actual used types, by converting them earlier in Cluster.loadData.

Small change in hscan

This fixes a mistake between Int/Integer. Should be more careful :)

Add hscan to Makefile

Add the hscan tool

This patch adds an hscan tool that loads data from clusters via RAPI and
writes it to files that can be later used offline.

Some small changes in preparation for hscan

This patch does some small changes:
  - fixes a comment
  - export more node functions (unneeded now, but hscan will use them)
  - fixes Makefile rule for building the programs

Add a separate type for the [(Int, String)] list

This is added for better readability, since this is very often used in
declarations.

Handle correctly offline nodes in cluster scoring

This patch changes two things with regard to offline nodes:
  - first, it only calculates the various coefficients across online
nodes
  - second, it adds a new score denoting the percentage of instances
which live on such nodes

The first change allows correct score computation in presence of offline
nodes (whose properties we don't need to take into account), while the
second change actively evacuates offline nodes.

Show offline nodes in the node status list

This patch adds a new ‘-’ flag for the node status which denotes offline
nodes.

Restrict move list based on offline node status

This patch changes the Cluster.checkInstanceMove function to restrict
the target move list based on which nodes are online.

Add command line support for offlining nodes

This patch modifies hbal (only, hn1 not yet) for setting nodes offline.

Add a new 'offline' Node attribute

This patch adds a new node attribute - offline - which will serve to
skip nodes from the target candidate list.

More fixes to the Makefile

Small doc update in Node.hs

Some updates to the apidoc rules

Fix/enhance makefile rules after the rename

Add a .gitattributes file

This will enhance the ‘dist’ rule by skipping unneeded files.

Introduce a namespace for the modules

The modules are moved from the ‘top’ namespace to ‘Ganeti.HTools’, in
compliance with standard practices.

Update NEWS for version 0.0.6

Abstract the version format into a function

This patch moves the version string creation into a function in Utils
which shows some more information.

Add a man page for hn1 and update the hbal one

A new man page and typos fixed in hbal.1.

Add a manpage for hbal

Add a --version option

This patch adds a -V, --version command line option that shows the
program version and also updates the hn1 usage string (similar to hbal).

Move a function around in hbal.hs

This just reorders some functions for a more logical ordering.

Show the step counter in the solution list

This patch changes the solution list to include a step counter so that
it's more clear these are successive steps (in a definite order), and
not just an unordered list of changes.

Use gnt-instance migrate instead of failover

This patch changes the gnt-instance failover to migrate, and fixes a bug
in the formatting of commands.

hbal: added a verbose setting and changed output

This patch added a verbose output and changed the output so that by
default it is less verbose and more clear.

Add a new move FailoverAndReplace

This patch adds a new instance move, FailoverAndReplace, which promotes
the old secondary to primary and then uses a new secondary node.

This is the last move that we can do within the limitations of one node
changed per move.

Some more docstring updates

Enhance the command list for the solution

This patch moves the formatting of the command list to Cluster.hs and
enhances it with separator messages between the steps.

Add a new ReplaceAndFailover move

This patch adds a new replace secondary and failover move (equals to
“r:x f”), which can improve the solution (since we are testing more
options at each step).

Some whitespace changes

Aligned the comments in Instance.hs

Convert hbal from multiple rounds to a step-method

Currently hbal does multiple rounds, stopping when a rounds doesn't
bring improvements. With the recent changes to not remove instances from
the candidate list, this is obsolete as the first round will always run
to the end of the improvements.

This patch changes this so that the Cluster.checkMove function doesn't
recurse, but just computes the next best move (as its docstring says).
This means we can actually incrementally compute and print the solution,
and this is needed as otherwise an instance could move twice and the
second time it needs the current placement to compute the exact command
line and operation needed for the move.

Rework the solution printing in Cluster.hs

This abstracts the individual placement solution so that it can be used
independently.

Remove the restriction of one-move-per-round

The current code restricts each instance to one move per round. This is
bad, as an computation restarted in the middle of the solution will have
a different set of instances to work and will thus lead to a different
end-solution.

Once this is applied, further rounds are not possible since the first
round will have tried all instances at its end. As such, the removal of
the rounds feature will be next.

The code adds a hard-coded 100 moves limit, which for big clusters is
actually small.

Add a header to node lists and print more data

This prints the total memory/disk and also adds a header.

Rename the maxRes to r_mem

This is to keep in style with the other memory variables.

Display the reserved memory too in node lists

This is useful and not easy to compute otherwise.

First try to embed VCS id in binaries

This patch attempts to embed the VCS id in binaries, based on the way
other projects seem to do this.

Fix the Makefile clean rule

This removes obsolete entries from the clean rule and adds the hbal
binary.

Change the N1 score to percent of N1 failures

Since for a very many N+1 failures in a cluster, we could actually
degrade the N1 CV by making a node N+1 compliant, we need to make sure
this value only decreases when fixing non-compliant nodes.

The easiest way is to compute the N+1 score as a percentage of failed
nodes, with the caveat that the domain of values might not be fully
compatible with the other scores. It is still [0, 1] but does not vary
like the others.

Add two new variables in the cluster score

This patch adds two new variables to the cluster score:
  - variance of the failN1 attribute
  - variance of the reserved memory percentage

The variance of the failN1 helps make the cluster N+1 happy, whereas the
reserved memory percentage helps balance the unused memory for
redundancy on the nodes.

Add the node reserved memory percentage

This patch adds the node attribute “reserved memory percentage” that is
derived from the maximum reserved memory for a node and its total
memory.

This will be useful for enhancing the balancing algorithm.

Record the running cluster CV in placements

This patch adds a score variable to the placement type, so we can record
the changes in the cluster CV for later display.

This gives visibility in the decrease of the parameters and can show
which are the most important steps to perform (out of the full move
list).

Also print cluster coefficients in hn1

This patch adds printing the initial and final cluster coefficients in
hn1 too, to better understand the found solution.

Beautify the cluster status list

This patch removes the primary/secondary instance lists from the node
status and also removes the tabbed formatting with explicit width
formatting.

Beautify solution list

This patch makes the tabular solution list nicer, by changing from tabs
to explicit widths.

Limit string literals to 80-char columns

Learned how multi-line string literals work in Haskell :)

Add a news file and make the 0.0.5 release

Beautify: strip common suffix from names

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.

hbal: allow, but warn on, N+1 failed clusters

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

Change the node N+1 check model

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.

Show which nodes are not N+1 compliant in output

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.

Don't build documentation for the Main modules

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

Change the total disk/mem to Double

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

A no-code change s/disk/dsk/

This just makes indendation nicer in many expressions.

Compute the p_mem / p_dsk statically

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.

Documentation updates

Simplify the checkInstanceMove function

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.

A small optimization in node computation

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

Container: add a 'keys' function

Replace a foldl by foldl'

Split checkMove into two

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