Synnefo » snf-ganeti » ganeti-local

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:

- `deepseq <http://hackage.haskell.org/package/deepseq>`_

                    libghc6-parallel-dev libghc6-deepseq-dev

Or in newer versions of these distributions (using GHC 7.x)::

  $ apt-get install ghc libghc-json-dev libghc-network-dev \

                    libghc-parallel-dev  libghc-deepseq-dev \

                    libghc-utf8-string-dev

In Fedora, they are available via packages as well::

  $ yum install ghc ghc-json-devel ghc-network-devel \

                    ghc-parallel-devel ghc-deepseq-devel

the Haskell platform. You can also install ``cabal`` manually::

  $ cabal install json network parallel utf8-string

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

- `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, with

the exception of curl), so you can use either apt::

                    libghc-hinotify-dev libghc-regex-pcre-dev libghc-curl-dev

  $ cabal install hslogger Crypto text hinotify regex-pcre curl

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

	@if [ "$(notdir $@)" = "test" ] && [ "$(HTOOLS_NODEV)" ]; then \

	  echo "Error: cannot run unittests without the development" \

	       " libraries (see devnotes.rst)" 1>&2; \

	  $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) $(HTOOLS_REGEX_PCRE) \

	  echo "HTOOLS = True"; \

	if [ "$(HTOOLS_REGEX_PCRE)" ]; \

	then OPTGHC="$$OPTGHC --optghc=$(HTOOLS_REGEX_PCRE)"; \

	fi; \

	  $(HTOOLS_NOCURL) $(HTOOLS_PARALLEL3) $(HTOOLS_REGEX_PCRE) \

#####

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

])

# --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])

  AC_MSG_FAILURE([ghc not found, compilation will not possible])

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

      AC_MSG_FAILURE(m4_normalize([The curl library was not found, but it has

                                   been requested]))

    AC_MSG_NOTICE([Enabling curl/RAPI/RPC usage in Haskell code])

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

    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

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

  [[case "x${has_confd}x${HTOOLS_NOCURL}x" in

if test x$enable_split_query = xTrue -a x$has_confd != xTrue; then

  $ cabal install QuickCheck HUnit \

          test-framework test-framework-quickcheck2 test-framework-hunit \

          hscolour hlint shelltestrunner