Improve Haskell configure options and detection
authorIustin Pop <iustin@google.com>
Wed, 10 Oct 2012 05:12:43 +0000 (07:12 +0200)
committerIustin Pop <iustin@google.com>
Wed, 10 Oct 2012 11:43:04 +0000 (13:43 +0200)
This patch cleans up  the Haskell library detection and defaults.

First, it makes the base compiler/libraries required, per the email discussion.

It then adds two new small autoconf macros, on to check for a required
Haskell library and one to do custom action based on test results. We
use these macros to cleanup and simplify a bit the module detection:

- rapi, confd, and split query are auto detected and enabled if _all_
  required libraries are present
- unittests are enabled if _all_ required libraries are present

The patch also updates the documentation regarding required libraries.

After this patch, base Ganeti fully buildable on Debian Squeeze/Ubuntu
Lucid.

Signed-off-by: Iustin Pop <iustin@google.com>
Reviewed-by: Guido Trotter <ultrotter@google.com>

INSTALL
Makefile.am
autotools/ac_ghc_pkg.m4 [new file with mode: 0644]
configure.ac
doc/devnotes.rst

diff --git a/INSTALL b/INSTALL
index 4308c5d..03e9363 100644 (file)
--- a/INSTALL
+++ b/INSTALL
@@ -113,11 +113,9 @@ dependencies.
 Haskell requirements
 ~~~~~~~~~~~~~~~~~~~~
 
-If you want to enable the `htools` component, which is recommended on
-bigger deployments (this give you automatic instance placement, cluster
-balancing, etc.), then you need to have a Haskell compiler installed on
-your build machine (but this is not required on the machines which are
-just going to run Ganeti). More specifically:
+Starting with Ganeti 2.7, the Haskell GHC compiler and a few base
+libraries are required in order to build Ganeti (but not to run and
+deploy Ganeti on production machines). More specifically:
 
 - `GHC <http://www.haskell.org/ghc/>`_ version 6.12 or higher
 - or even better, `The Haskell Platform
@@ -128,75 +126,82 @@ just going to run Ganeti). More specifically:
   network library
 - `parallel <http://hackage.haskell.org/package/parallel>`_, a parallel
   programming library (note: tested with up to version 3.x)
-- `curl <http://hackage.haskell.org/package/curl>`_, bindings for the
-  curl library, only needed if you want these tools to connect to remote
-  clusters (as opposed to the local one)
 - `bytestring <http://hackage.haskell.org/package/bytestring>`_ and
   `utf8-string <http://hackage.haskell.org/package/utf8-string>`_
   libraries; these usually come with the GHC compiler
-- `regex-pcre <http://hackage.haskell.org/package/regex-pcre>`_,
-  bindings for the ``pcre`` library
+- `deepseq <http://hackage.haskell.org/package/deepseq>`_
 
 Some of these are also available as package in Debian/Ubuntu::
 
   $ apt-get install ghc6 libghc6-json-dev libghc6-network-dev \
-                    libghc6-parallel-dev libghc6-curl-dev
-
-Or in Fedora running::
+                    libghc6-parallel-dev libghc6-deepseq-dev
 
-  $ yum install ghc ghc-json-devel ghc-network-devel ghc-parallel-devel
+Or in newer versions of these distributions (using GHC 7.x)::
 
-The most recent Fedora doesn't provide ``ghc-curl``. So this needs to be
-installed using ``cabal`` or alternatively htools can be build without
-curl support.
+  $ apt-get install ghc libghc-json-dev libghc-network-dev \
+                    libghc-parallel-dev  libghc-deepseq-dev \
+                    libghc-utf8-string-dev
 
-Note that more recent versions have switched to GHC 7.x and the packages
-were renamed::
+In Fedora, they are available via packages as well::
 
-  $ apt-get install ghc libghc-json-dev libghc-network-dev \
-                    libghc-parallel-dev libghc-curl-dev \
-                    libghc-regex-pcre-dev libghc-utf8-string-dev
+  $ yum install ghc ghc-json-devel ghc-network-devel \
+                    ghc-parallel-devel ghc-deepseq-devel
 
 If using a distribution which does not provide them, first install
-the Haskell platform. You can also install ``cabal`` manualy::
+the Haskell platform. You can also install ``cabal`` manually::
 
   $ apt-get install cabal-install
 
 Then install the additional libraries via
 ``cabal``::
 
-  $ cabal install json network parallel curl regex-pcre utf8-string
+  $ cabal install json network parallel utf8-string
 
 The compilation of the htools components is automatically enabled when
 the compiler and the requisite libraries are found. You can use the
 ``--enable-htools`` configure flag to force the selection (at which
 point ``./configure`` will fail if it doesn't find the prerequisites).
 
-In Ganeti version 2.6, one of the daemons (``ganeti-confd``) is shipped
-in two versions: the Python default version (which has no extra
-dependencies), and an experimental Haskell version. This latter version
-can be enabled via the ``./configure`` flag ``--enable-confd=haskell``
-and a few has extra dependencies:
 
+Haskell optional features
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Optionally, more functionality can be enabled if your build machine has
+a few more Haskell libraries enabled: RAPI access to remote cluster from
+htools (``--enable-htools-rapi``) and enabling the ``ganeti-confd``
+daemon (``--enable-confd``). The list of extra dependencies for these
+is:
+
+- `curl <http://hackage.haskell.org/package/curl>`_, tested with
+  versions 1.3.4 and above
 - `hslogger <http://software.complete.org/hslogger>`_, version 1.1 and
   above (note that Debian Squeeze only has version 1.0.9)
 - `Crypto <http://hackage.haskell.org/package/Crypto>`_, tested with
   version 4.2.4
 - `text <http://hackage.haskell.org/package/text>`_
 - `hinotify <http://hackage.haskell.org/package/hinotify>`_
+- `regex-pcre <http://hackage.haskell.org/package/regex-pcre>`_,
+  bindings for the ``pcre`` library
 
-These libraries are available in Debian Wheezy (but not in Squeeze), so
-you can use either apt::
+These libraries are available in Debian Wheezy (but not in Squeeze, with
+the exception of curl), so you can use either apt::
 
   $ apt-get install libghc-hslogger-dev libghc-crypto-dev libghc-text-dev \
-                    libghc-hinotify-dev
+                    libghc-hinotify-dev libghc-regex-pcre-dev libghc-curl-dev
 
 or ``cabal``::
 
-  $ cabal install hslogger Crypto text hinotify
+  $ cabal install hslogger Crypto text hinotify regex-pcre curl
 
 to install them.
 
+The most recent Fedora doesn't provide ``curl``, ``crypto``,
+``inotify``. So these need to be installed using ``cabal``, if
+desired. The other packages can be installed via ``yum``::
+
+  $ yum install ghc-hslogger-devel ghc-text-devel \
+                ghc-regex-pcre-devel
+
 .. _cabal-note:
 .. note::
   If one of the cabal packages fails to install due to unfulfilled
index 15874a7..3333c6f 100644 (file)
@@ -601,18 +601,15 @@ install-exec-hook:
 endif
 
 $(HS_ALL_PROGS): %: %.hs $(HS_LIBTEST_SRCS) $(HS_BUILT_SRCS) Makefile
-       @if [ -z "$(HTOOLS)" ]; then \
-         echo "Error: htools compilation disabled at configure time" 1>&2 ;\
-         exit 1; \
-       fi
-       @if [ "$(notdir $@)" = "test" ] && [ -z "$(GHC_PKG_QUICKCHECK)" ]; then \
-         echo "Error: cannot run unittests without the QuickCheck library (see devnotes.rst)" 1>&2; \
+       @if [ "$(notdir $@)" = "test" ] && [ "$(HTOOLS_NODEV)" ]; then \
+         echo "Error: cannot run unittests without the development" \
+              " libraries (see devnotes.rst)" 1>&2; \
          exit 1; \
        fi
        @rm -f $(notdir $@).tix
        $(GHC) --make \
          $(HFLAGS) \
-         $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) \
+         $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) $(HTOOLS_REGEX_PCRE) \
          -osuf $(notdir $@).o -hisuf $(notdir $@).hi \
          $(HEXTRA) $(HEXTRA_INT) $@
        @touch "$@"
@@ -1234,11 +1231,7 @@ lib/_autoconf.py: Makefile | stamp-directories
          echo "NODED_GROUP = '$(NODED_GROUP)'"; \
          echo "DISK_SEPARATOR = '$(DISK_SEPARATOR)'"; \
          echo "QEMUIMG_PATH = '$(QEMUIMG_PATH)'"; \
-         if [ "$(HTOOLS)" ]; then \
-           echo "HTOOLS = True"; \
-         else \
-           echo "HTOOLS = False"; \
-         fi; \
+         echo "HTOOLS = True"; \
          echo "ENABLE_CONFD = $(ENABLE_CONFD)"; \
          echo "XEN_CMD = '$(XEN_CMD)'"; \
          echo "ENABLE_SPLIT_QUERY = $(ENABLE_SPLIT_QUERY)"; \
@@ -1593,6 +1586,9 @@ hs-apidoc: $(HS_BUILT_SRCS)
        if [ "$(HTOOLS_PARALLEL3)" ]; \
        then OPTGHC="$$OPTGHC --optghc=$(HTOOLS_PARALLEL3)"; \
        fi; \
+       if [ "$(HTOOLS_REGEX_PCRE)" ]; \
+       then OPTGHC="$$OPTGHC --optghc=$(HTOOLS_REGEX_PCRE)"; \
+       fi; \
        RELSRCS="$(HS_LIB_SRCS:htools/%=%) $(patsubst htools/%,%,$(filter htools/%,$(HS_BUILT_SRCS)))"; \
        for file in $$RELSRCS; do \
                hfile=`echo $$file|sed 's/\\.hs$$//'`.html; \
@@ -1610,7 +1606,7 @@ TAGS: $(GENERATED_FILES)
        rm -f TAGS
        $(GHC) -e ":etags" -v0 \
          $(filter-out -O -Werror,$(HFLAGS)) \
-         $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) \
+         $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) $(HTOOLS_REGEX_PCRE) \
          $(HS_LIBTEST_SRCS)
        find . -path './lib/*.py' -o -path './scripts/gnt-*' -o \
          -path './daemons/ganeti-*' -o -path './tools/*' -o \
diff --git a/autotools/ac_ghc_pkg.m4 b/autotools/ac_ghc_pkg.m4
new file mode 100644 (file)
index 0000000..702666e
--- /dev/null
@@ -0,0 +1,77 @@
+#####
+
+# Copyright (C) 2012 Google Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301, USA.
+
+#####
+#
+# SYNOPSIS
+#
+#   AC_GHC_PKG_CHECK(modname, action_found, action_not_found, extended)
+#
+# DESCRIPTION
+#
+#   Checks for a Haskell (GHC) module. If found, execute the second
+#   argument, if not found, the third one.
+#
+#   If the fourth argument is non-empty, then the check will be some
+#   via 'ghc-pkg list' (which supports patterns), otherwise it will
+#   use just 'ghc-pkg latest'.
+#
+#
+#####
+
+AC_DEFUN([AC_GHC_PKG_CHECK],[
+    if test -z $GHC_PKG; then
+        AC_MSG_ERROR([GHC_PKG not defined])
+    fi
+    AC_MSG_CHECKING([haskell library $1])
+    if test -n "$4"; then
+      GHC_PKG_RESULT=$($GHC_PKG --simple-output list '$1'|tail -n1)
+    else
+      GHC_PKG_RESULT=$($GHC_PKG latest '$1' 2>/dev/null)
+    fi
+    if test -n "$GHC_PKG_RESULT"; then
+      AC_MSG_RESULT($GHC_PKG_RESULT)
+      $2
+    else
+      AC_MSG_RESULT([no])
+      $3
+    fi
+])
+
+#####
+#
+# SYNOPSIS
+#
+#   AC_GHC_PKG_REQUIRE(modname, extended)
+#
+# DESCRIPTION
+#
+#   Checks for a Haskell (GHC) module, and abort if not found. If the
+#   second argument is non-empty, then the check will be some via
+#   'ghc-pkg list' (which supports patterns), otherwise it will use
+#   just 'ghc-pkg latest'.
+#
+#
+#####
+
+AC_DEFUN([AC_GHC_PKG_REQUIRE],[
+    AC_GHC_PKG_CHECK($1, [],
+                     [AC_MSG_FAILURE([Required Haskell module $1 not found])],
+                     $2)
+])
index b603562..70695ee 100644 (file)
@@ -310,45 +310,6 @@ then
 fi
 AC_SUBST(SYSLOG_USAGE, $SYSLOG)
 
-# --enable-htools
-HTOOLS=
-AC_ARG_ENABLE([htools],
-        [AS_HELP_STRING([--enable-htools],
-        [enable use of htools (needs GHC and libraries, default: check)])],
-        [],
-        [enable_htools=check])
-
-# --enable-htools-rapi
-HTOOLS_RAPI=
-AC_ARG_ENABLE([htools-rapi],
-        [AS_HELP_STRING([--enable-htools-rapi],
-        [enable use of RAPI in htools (needs curl, default: no)])],
-        [],
-        [enable_htools_rapi=check])
-
-# --enable-confd
-ENABLE_CONFD=
-AC_ARG_ENABLE([confd],
-  [AS_HELP_STRING([--enable-confd],
-  [enable the ganeti-confd daemon (default: yes)])],
-  [[case "$enableval" in
-      no)
-        enable_confd=False
-        ;;
-      yes|haskell)
-        enable_confd=True
-        ;;
-      *)
-        echo "Invalid value for enable-confd '$enableval'"
-        exit 1
-        ;;
-    esac
-  ]],
-  [enable_confd=True])
-AC_SUBST(ENABLE_CONFD, $enable_confd)
-
-AM_CONDITIONAL([ENABLE_CONFD], [test x$enable_confd = xTrue])
-
 # --with-disk-separator=...
 AC_ARG_WITH([disk-separator],
   [AS_HELP_STRING([--with-disk-separator=STRING],
@@ -430,97 +391,113 @@ then
   AC_MSG_WARN([qemu-img not found, using ovfconverter will not be possible])
 fi
 
-if test "$enable_htools" != "no"; then
+# --enable-htools-rapi
+HTOOLS_RAPI=
+AC_ARG_ENABLE([htools-rapi],
+        [AS_HELP_STRING([--enable-htools-rapi],
+        [enable use of curl in the Haskell code (default: check)])],
+        [],
+        [enable_htools_rapi=check])
+
+# --enable-confd
+ENABLE_CONFD=
+AC_ARG_ENABLE([confd],
+  [AS_HELP_STRING([--enable-confd],
+  [enable the ganeti-confd daemon (default: check)])],
+  [],
+  [enable_confd=check])
 
 # Check for ghc
 AC_ARG_VAR(GHC, [ghc path])
 AC_PATH_PROG(GHC, [ghc], [])
 if test -z "$GHC"; then
-  if test "$enable_htools" != "check"; then
-    AC_MSG_FAILURE([ghc not found, htools compilation will not possible])
-  fi
+  AC_MSG_FAILURE([ghc not found, compilation will not possible])
 fi
 
 # Check for ghc-pkg
-HTOOLS_MODULES=
 AC_ARG_VAR(GHC_PKG, [ghc-pkg path])
 AC_PATH_PROG(GHC_PKG, [ghc-pkg], [])
 if test -z "$GHC_PKG"; then
-  if test "$enable_htools" != "check"; then
-    AC_MSG_FAILURE([ghc-pkg not found, htools compilation will not be possible])
-  fi
-else
-  # check for modules
-  AC_MSG_NOTICE([checking for required haskell modules])
-  HTOOLS_NOCURL=-DNO_CURL
-  if test "$enable_htools_rapi" != "no"; then
-    AC_MSG_CHECKING([curl])
-    GHC_PKG_CURL=$($GHC_PKG latest curl)
-    if test -z "$GHC_PKG_CURL"; then
-      if test "$enable_htools_rapi" = "check"; then
-        AC_MSG_WARN(m4_normalize([The curl library not found, htools will be
-                                  compiled without RAPI support]))
-      else
-        AC_MSG_FAILURE(m4_normalize([The curl library was not found, but it has
-                                     been requested]))
-      fi
+  AC_MSG_FAILURE([ghc-pkg not found, compilation will not be possible])
+fi
+
+# check for modules, first custom/special checks
+AC_MSG_NOTICE([checking for required haskell modules])
+HTOOLS_NOCURL=-DNO_CURL
+if test "$enable_htools_rapi" != "no"; then
+  AC_GHC_PKG_CHECK([curl], [HTOOLS_NOCURL=], [])
+  if test -n "$HTOOLS_NOCURL"; then
+    if test "$enable_htools_rapi" = "check"; then
+      AC_MSG_WARN(m4_normalize([The curl library was not found, Haskell
+                                code will be compiled without RAPI support]))
     else
-      HTOOLS_NOCURL=
+      AC_MSG_FAILURE(m4_normalize([The curl library was not found, but it has
+                                   been requested]))
     fi
-    AC_MSG_RESULT($GHC_PKG_CURL)
-  fi
-  AC_SUBST(GHC_PKG_CURL)
-  AC_SUBST(HTOOLS_NOCURL)
-  AC_MSG_CHECKING([parallel])
-  GHC_PKG_PARALLEL=$($GHC_PKG --simple-output list 'parallel-3.*')
-  if test -n "$GHC_PKG_PARALLEL"
-  then
-    HTOOLS_PARALLEL3=-DPARALLEL3
   else
-    GHC_PKG_PARALLEL=$($GHC_PKG --simple-output list 'parallel-2.*')
-  fi
-  if test -z "$GHC_PKG_PARALLEL"
-  then
-    GHC_PKG_PARALLEL=$($GHC_PKG --simple-output list 'parallel-1.*')
-  fi
-  AC_SUBST(GHC_PKG_PARALLEL)
-  AC_SUBST(HTOOLS_PARALLEL3)
-  AC_MSG_RESULT($GHC_PKG_PARALLEL)
-  AC_MSG_CHECKING([json])
-  GHC_PKG_JSON=$($GHC_PKG latest json)
-  AC_MSG_RESULT($GHC_PKG_JSON)
-  AC_MSG_CHECKING([network])
-  GHC_PKG_NETWORK=$($GHC_PKG latest network)
-  AC_MSG_RESULT($GHC_PKG_NETWORK)
-  AC_MSG_CHECKING([QuickCheck 2.x])
-  GHC_PKG_QUICKCHECK=$($GHC_PKG --simple-output list 'QuickCheck-2.*')
-  AC_MSG_RESULT($GHC_PKG_QUICKCHECK)
-  if test -z "$GHC_PKG_PARALLEL" || test -z "$GHC_PKG_JSON" || \
-     test -z "$GHC_PKG_NETWORK"; then
-    if test "$enable_htools" != "check"; then
-      AC_MSG_FAILURE(m4_normalize([Required Haskell modules not found, htools
-                                   compilation disabled]))
-    fi
-  else
-    # we leave the other modules to be auto-selected
-    HTOOLS_MODULES="-package $GHC_PKG_PARALLEL"
-  fi
-  if test -z "$GHC_PKG_QUICKCHECK"; then
-     AC_MSG_WARN(m4_normalize([The QuickCheck 2.x module was not found,
-                               you won't be able to run Haskell unittests]))
+    AC_MSG_NOTICE([Enabling curl/RAPI/RPC usage in Haskell code])
   fi
 fi
-AC_SUBST(HTOOLS_MODULES)
-AC_SUBST(GHC_PKG_QUICKCHECK)
-
-if test "$enable_htools" != "no"; then
-  if test -z "$GHC" || test -z "$HTOOLS_MODULES"; then
-    AC_MSG_WARN(m4_normalize([Haskell compiler/required libraries not found,
-                              htools compilation disabled]))
+AC_SUBST(HTOOLS_NOCURL)
+
+HTOOLS_PARALLEL3=
+AC_GHC_PKG_CHECK([parallel-3.*], [HTOOLS_PARALLEL3=-DPARALLEL3],
+                 [AC_GHC_PKG_REQUIRE(parallel)], t)
+AC_SUBST(HTOOLS_PARALLEL3)
+
+# and now standard modules
+AC_GHC_PKG_REQUIRE(json)
+AC_GHC_PKG_REQUIRE(network)
+AC_GHC_PKG_REQUIRE(mtl)
+AC_GHC_PKG_REQUIRE(bytestring)
+AC_GHC_PKG_REQUIRE(utf8-string)
+
+# extra modules for confd functionality
+HTOOLS_REGEX_PCRE=-DNO_REGEX_PCRE
+has_confd=False
+if test "$enable_confd" != "no"; then
+  CONFD_PKG=
+  AC_GHC_PKG_CHECK([regex-pcre], [HTOOLS_REGEX_PCRE=],
+                   [CONFD_PKG="$CONFD_PKG regex-pcre"])
+  AC_GHC_PKG_CHECK([hslogger], [], [CONFD_PKG="$CONFD_PKG hslogger"])
+  AC_GHC_PKG_CHECK([Crypto], [], [CONFD_PKG="$CONFD_PKG Crypto"])
+  AC_GHC_PKG_CHECK([text], [], [CONFD_PKG="$CONFD_PKG text"])
+  AC_GHC_PKG_CHECK([hinotify], [], [CONFD_PKG="$CONFD_PKG hinotify"])
+  if test -z "$CONFD_PKG"; then
+    has_confd=True
   else
-    HTOOLS=yes
+    if test "$enable_confd" = "check"; then
+      AC_MSG_WARN(m4_normalize([The required extra libraries for confd were
+                                not found ($CONFD_PKG), confd disabled]))
+    else
+      AC_MSG_FAILURE(m4_normalize([The confd functionality was requested, but
+                                   required libraries were not found:
+                                   $CONFD_PKG]))
+    fi
   fi
 fi
+AC_SUBST(HTOOLS_REGEX_PCRE)
+if test "$has_confd" = "True"; then
+  AC_MSG_NOTICE([Enabling confd usage])
+fi
+AC_SUBST(ENABLE_CONFD, $has_confd)
+AM_CONDITIONAL([ENABLE_CONFD], [test x$has_confd = xTrue])
+
+# development modules
+HTOOLS_NODEV=
+AC_GHC_PKG_CHECK([QuickCheck-2.*], [], [HTOOLS_NODEV=1], t)
+AC_GHC_PKG_CHECK([test-framework-0.6*], [], [HTOOLS_NODEV=1], t)
+AC_GHC_PKG_CHECK([test-framework-hunit], [], [HTOOLS_NODEV=1])
+AC_GHC_PKG_CHECK([test-framework-quickcheck2], [], [HTOOLS_NODEV=1])
+if test -n "$HTOOLS_NODEV"; then
+   AC_MSG_WARN(m4_normalize([Required development modules were not found,
+                             you won't be able to run Haskell unittests]))
+else
+   AC_MSG_NOTICE([Haskell development modules found, unittests enabled])
+fi
+AC_SUBST(HTOOLS_NODEV)
+
+HTOOLS=yes
 AC_SUBST(HTOOLS)
 
 # --enable-split-query
@@ -541,7 +518,7 @@ AC_ARG_ENABLE([split-query],
         ;;
     esac
   ]],
-  [[case "x${enable_confd}x${HTOOLS_NOCURL}x" in
+  [[case "x${has_confd}x${HTOOLS_NOCURL}x" in
      xTruexx)
        enable_split_query=True
        ;;
@@ -551,7 +528,7 @@ AC_ARG_ENABLE([split-query],
    esac]])
 AC_SUBST(ENABLE_SPLIT_QUERY, $enable_split_query)
 
-if test x$enable_split_query = xTrue -a x$enable_confd != xTrue; then
+if test x$enable_split_query = xTrue -a x$has_confd != xTrue; then
   AC_MSG_ERROR([Split queries require the confd daemon])
 fi
 
@@ -592,8 +569,6 @@ if test -z "$HLINT"; then
   AC_MSG_WARN([hlint not found, checking code will not be possible])
 fi
 
-fi # end if enable_htools, define automake conditions
-
 if test "$HTOOLS" != "yes" && test "$ENABLE_CONFD" = "True"; then
    AC_MSG_ERROR(m4_normalize([cannot enable ganeti-confd if
                               htools support is not enabled]))
index 718ca75..014f2cd 100644 (file)
@@ -86,7 +86,9 @@ required ones from the quick install document) via::
 
 Or alternatively via ``cabal``::
 
-  $ cabal install quickcheck hscolour hlint shelltestrunner
+  $ cabal install QuickCheck HUnit \
+          test-framework test-framework-quickcheck2 test-framework-hunit \
+          hscolour hlint shelltestrunner
 
 
 Configuring for development