code.grnet.gr Git - ganeti-local/blob - configure.ac

   1 # Configure script for Ganeti
   2 m4_define([gnt_version_major], [2])
   3 m4_define([gnt_version_minor], [10])
   4 m4_define([gnt_version_revision], [0])
   5 m4_define([gnt_version_suffix], [~rc1])
   6 m4_define([gnt_version_full],
   7           m4_format([%d.%d.%d%s],
   8                     gnt_version_major, gnt_version_minor,
   9                     gnt_version_revision, gnt_version_suffix))
  10
  11 AC_PREREQ(2.59)
  12 AC_INIT(ganeti, gnt_version_full, ganeti@googlegroups.com)
  13 AC_CONFIG_AUX_DIR(autotools)
  14 AC_CONFIG_SRCDIR(configure)
  15 AM_INIT_AUTOMAKE([1.9 foreign tar-ustar -Wall -Wno-portability])
  16
  17 AC_SUBST([VERSION_MAJOR], gnt_version_major)
  18 AC_SUBST([VERSION_MINOR], gnt_version_minor)
  19 AC_SUBST([VERSION_REVISION], gnt_version_revision)
  20 AC_SUBST([VERSION_SUFFIX], gnt_version_suffix)
  21 AC_SUBST([VERSION_FULL], gnt_version_full)
  22
  23 AC_SUBST([BINDIR], $bindir)
  24 AC_SUBST([SBINDIR], $sbindir)
  25 AC_SUBST([MANDIR], $mandir)
  26
  27 # --enable-versionfull
  28 AC_ARG_ENABLE([versionfull],
  29   [AS_HELP_STRING([--enable-versionfull],
  30                   m4_normalize([use the full version string rather
  31                   than major.minor for version directories]))],
  32   [[if test "$enableval" != no; then
  33       USE_VERSION_FULL=yes
  34     else
  35       USER_VERSION_FULL=no
  36     fi
  37   ]],
  38   [USE_VERSION_FULL=no
  39   ])
  40 AC_SUBST(USE_VERSION_FULL, $USE_VERSION_FULL)
  41 AM_CONDITIONAL([USE_VERSION_FULL], [test "$USE_VERSION_FULL" = yes])
  42
  43 # --enable-symlinks
  44 AC_ARG_ENABLE([symlinks],
  45   [AS_HELP_STRING([--enable-symlinks],
  46                   m4_normalize([also install version-dependent symlinks under
  47                   $sysconfdir (default: enabled)]))],
  48   [[if test "$enableval" != no; then
  49       INSTALL_SYMLINKS=yes
  50     else
  51       INSTALL_SYMLINKS=no
  52     fi
  53   ]],
  54   [INSTALL_SYMLINKS=yes
  55   ])
  56 AC_SUBST(INSTALL_SYMLINKS, $INSTALL_SYMLINKS)
  57 AM_CONDITIONAL([INSTALL_SYMLINKS], [test "$INSTALL_SYMLINKS" = yes])
  58
  59 # --with-ssh-initscript=...
  60 AC_ARG_WITH([ssh-initscript],
  61   [AS_HELP_STRING([--with-ssh-initscript=SCRIPT],
  62     [SSH init script to use (default is /etc/init.d/ssh)]
  63   )],
  64   [ssh_initd_script="$withval"],
  65   [ssh_initd_script="/etc/init.d/ssh"])
  66 AC_SUBST(SSH_INITD_SCRIPT, $ssh_initd_script)
  67
  68 # --with-export-dir=...
  69 AC_ARG_WITH([export-dir],
  70   [AS_HELP_STRING([--with-export-dir=DIR],
  71     [directory to use by default for instance image]
  72     [ exports (default is /srv/ganeti/export)]
  73   )],
  74   [export_dir="$withval"],
  75   [export_dir="/srv/ganeti/export"])
  76 AC_SUBST(EXPORT_DIR, $export_dir)
  77
  78 # --with-ssh-config-dir=...
  79 AC_ARG_WITH([ssh-config-dir],
  80   [AS_HELP_STRING([--with-ssh-config-dir=DIR],
  81     [ directory with ssh host keys ]
  82     [ (default is /etc/ssh)]
  83   )],
  84   [ssh_config_dir="$withval"],
  85   [ssh_config_dir="/etc/ssh"])
  86 AC_SUBST(SSH_CONFIG_DIR, $ssh_config_dir)
  87
  88 # --with-xen-config-dir=...
  89 AC_ARG_WITH([xen-config-dir],
  90   [AS_HELP_STRING([--with-xen-config-dir=DIR],
  91                   m4_normalize([Xen configuration directory
  92                                 (default: /etc/xen)]))],
  93   [xen_config_dir="$withval"],
  94   [xen_config_dir=/etc/xen])
  95 AC_SUBST(XEN_CONFIG_DIR, $xen_config_dir)
  96
  97 # --with-os-search-path=...
  98 AC_ARG_WITH([os-search-path],
  99   [AS_HELP_STRING([--with-os-search-path=LIST],
 100     [comma separated list of directories to]
 101     [ search for OS images (default is /srv/ganeti/os)]
 102   )],
 103   [os_search_path="$withval"],
 104   [os_search_path="/srv/ganeti/os"])
 105 AC_SUBST(OS_SEARCH_PATH, $os_search_path)
 106
 107 # --with-extstorage-search-path=...
 108 AC_ARG_WITH([extstorage-search-path],
 109   [AS_HELP_STRING([--with-extstorage-search-path=LIST],
 110     [comma separated list of directories to]
 111     [ search for External Storage Providers]
 112     [ (default is /srv/ganeti/extstorage)]
 113   )],
 114   [es_search_path="$withval"],
 115   [es_search_path="/srv/ganeti/extstorage"])
 116 AC_SUBST(ES_SEARCH_PATH, $es_search_path)
 117
 118 # --with-iallocator-search-path=...
 119 AC_ARG_WITH([iallocator-search-path],
 120   [AS_HELP_STRING([--with-iallocator-search-path=LIST],
 121     [comma separated list of directories to]
 122     [ search for instance allocators (default is $libdir/ganeti/iallocators)]
 123   )],
 124   [iallocator_search_path="$withval"],
 125   [iallocator_search_path="$libdir/$PACKAGE_NAME/iallocators"])
 126 AC_SUBST(IALLOCATOR_SEARCH_PATH, $iallocator_search_path)
 127
 128 # --with-xen-bootloader=...
 129 AC_ARG_WITH([xen-bootloader],
 130   [AS_HELP_STRING([--with-xen-bootloader=PATH],
 131     [bootloader for Xen hypervisor (default is empty)]
 132   )],
 133   [xen_bootloader="$withval"],
 134   [xen_bootloader=])
 135 AC_SUBST(XEN_BOOTLOADER, $xen_bootloader)
 136
 137 # --with-xen-kernel=...
 138 AC_ARG_WITH([xen-kernel],
 139   [AS_HELP_STRING([--with-xen-kernel=PATH],
 140     [DomU kernel image for Xen hypervisor (default is /boot/vmlinuz-3-xenU)]
 141   )],
 142   [xen_kernel="$withval"],
 143   [xen_kernel="/boot/vmlinuz-3-xenU"])
 144 AC_SUBST(XEN_KERNEL, $xen_kernel)
 145
 146 # --with-xen-initrd=...
 147 AC_ARG_WITH([xen-initrd],
 148   [AS_HELP_STRING([--with-xen-initrd=PATH],
 149     [DomU initrd image for Xen hypervisor (default is /boot/initrd-3-xenU)]
 150   )],
 151   [xen_initrd="$withval"],
 152   [xen_initrd="/boot/initrd-3-xenU"])
 153 AC_SUBST(XEN_INITRD, $xen_initrd)
 154
 155 # --with-kvm-kernel=...
 156 AC_ARG_WITH([kvm-kernel],
 157   [AS_HELP_STRING([--with-kvm-kernel=PATH],
 158     [Guest kernel image for KVM hypervisor (default is /boot/vmlinuz-3-kvmU)]
 159   )],
 160   [kvm_kernel="$withval"],
 161   [kvm_kernel="/boot/vmlinuz-3-kvmU"])
 162 AC_SUBST(KVM_KERNEL, $kvm_kernel)
 163
 164 # --with-kvm-path=...
 165 AC_ARG_WITH([kvm-path],
 166   [AS_HELP_STRING([--with-kvm-path=PATH],
 167     [absolute path to the kvm binary]
 168     [ (default is /usr/bin/kvm)]
 169   )],
 170   [kvm_path="$withval"],
 171   [kvm_path="/usr/bin/kvm"])
 172 AC_SUBST(KVM_PATH, $kvm_path)
 173
 174 # --with-lvm-stripecount=...
 175 AC_ARG_WITH([lvm-stripecount],
 176   [AS_HELP_STRING([--with-lvm-stripecount=NUM],
 177     [the default number of stripes to use for LVM volumes]
 178     [ (default is 1)]
 179   )],
 180   [lvm_stripecount="$withval"],
 181   [lvm_stripecount=1])
 182 AC_SUBST(LVM_STRIPECOUNT, $lvm_stripecount)
 183
 184 # --with-ssh-login-user=...
 185 AC_ARG_WITH([ssh-login-user],
 186   [AS_HELP_STRING([--with-ssh-login-user=USERNAME],
 187     [user to use for SSH logins within the cluster (default is root)]
 188   )],
 189   [ssh_login_user="$withval"],
 190   [ssh_login_user=root])
 191 AC_SUBST(SSH_LOGIN_USER, $ssh_login_user)
 192
 193 # --with-ssh-console-user=...
 194 AC_ARG_WITH([ssh-console-user],
 195   [AS_HELP_STRING([--with-ssh-console-user=USERNAME],
 196     [user to use for SSH logins to access instance consoles (default is root)]
 197   )],
 198   [ssh_console_user="$withval"],
 199   [ssh_console_user=root])
 200 AC_SUBST(SSH_CONSOLE_USER, $ssh_console_user)
 201
 202 # --with-default-user=...
 203 AC_ARG_WITH([default-user],
 204   [AS_HELP_STRING([--with-default-user=USERNAME],
 205     [default user for daemons]
 206     [ (default is to run all daemons as root)]
 207   )],
 208   [user_default="$withval"],
 209   [user_default=root])
 210
 211 # --with-default-group=...
 212 AC_ARG_WITH([default-group],
 213   [AS_HELP_STRING([--with-default-group=GROUPNAME],
 214     [default group for daemons]
 215     [ (default is to run all daemons under group root)]
 216   )],
 217   [group_default="$withval"],
 218   [group_default=root])
 219
 220 # --with-user-prefix=...
 221 AC_ARG_WITH([user-prefix],
 222   [AS_HELP_STRING([--with-user-prefix=PREFIX],
 223     [prefix for daemon users]
 224     [ (default is to run all daemons as root; use --with-default-user]
 225     [ to change the default)]
 226   )],
 227   [user_masterd="${withval}masterd";
 228    user_rapi="${withval}rapi";
 229    user_confd="${withval}confd";
 230    user_luxid="${withval}luxid";
 231    user_noded="$user_default";
 232    user_mond="$user_default"],
 233   [user_masterd="$user_default";
 234    user_rapi="$user_default";
 235    user_confd="$user_default";
 236    user_luxid="$user_default";
 237    user_noded="$user_default";
 238    user_mond="$user_default"])
 239 AC_SUBST(MASTERD_USER, $user_masterd)
 240 AC_SUBST(RAPI_USER, $user_rapi)
 241 AC_SUBST(CONFD_USER, $user_confd)
 242 AC_SUBST(LUXID_USER, $user_luxid)
 243 AC_SUBST(NODED_USER, $user_noded)
 244 AC_SUBST(MOND_USER, $user_mond)
 245
 246 # --with-group-prefix=...
 247 AC_ARG_WITH([group-prefix],
 248   [AS_HELP_STRING([--with-group-prefix=PREFIX],
 249     [prefix for daemon POSIX groups]
 250     [ (default is to run all daemons under group root; use]
 251     [ --with-default-group to change the default)]
 252   )],
 253   [group_rapi="${withval}rapi";
 254    group_admin="${withval}admin";
 255    group_confd="${withval}confd";
 256    group_luxid="${withval}luxid";
 257    group_masterd="${withval}masterd";
 258    group_noded="$group_default";
 259    group_daemons="${withval}daemons";
 260    group_mond="$group_default"],
 261   [group_rapi="$group_default";
 262    group_admin="$group_default";
 263    group_confd="$group_default";
 264    group_luxid="$group_default";
 265    group_masterd="$group_default";
 266    group_noded="$group_default";
 267    group_daemons="$group_default";
 268    group_mond="$group_default"])
 269 AC_SUBST(RAPI_GROUP, $group_rapi)
 270 AC_SUBST(ADMIN_GROUP, $group_admin)
 271 AC_SUBST(CONFD_GROUP, $group_confd)
 272 AC_SUBST(LUXID_GROUP, $group_luxid)
 273 AC_SUBST(MASTERD_GROUP, $group_masterd)
 274 AC_SUBST(NODED_GROUP, $group_noded)
 275 AC_SUBST(DAEMONS_GROUP, $group_daemons)
 276 AC_SUBST(MOND_GROUP, $group_mond)
 277
 278 # Print the config to the user
 279 AC_MSG_NOTICE([Running ganeti-masterd as $group_masterd:$group_masterd])
 280 AC_MSG_NOTICE([Running ganeti-rapi as $user_rapi:$group_rapi])
 281 AC_MSG_NOTICE([Running ganeti-confd as $user_confd:$group_confd])
 282 AC_MSG_NOTICE([Running ganeti-luxid as $user_luxid:$group_luxid])
 283 AC_MSG_NOTICE([Group for daemons is $group_daemons])
 284 AC_MSG_NOTICE([Group for clients is $group_admin])
 285
 286 # --enable-drbd-barriers
 287 AC_ARG_ENABLE([drbd-barriers],
 288   [AS_HELP_STRING([--enable-drbd-barriers],
 289                   m4_normalize([enable the DRBD barriers functionality by
 290                                 default (>= 8.0.12) (default: enabled)]))],
 291   [[if test "$enableval" != no; then
 292       DRBD_BARRIERS=n
 293       DRBD_NO_META_FLUSH=False
 294     else
 295       DRBD_BARRIERS=bf
 296       DRBD_NO_META_FLUSH=True
 297     fi
 298   ]],
 299   [DRBD_BARRIERS=n
 300    DRBD_NO_META_FLUSH=False
 301   ])
 302 AC_SUBST(DRBD_BARRIERS, $DRBD_BARRIERS)
 303 AC_SUBST(DRBD_NO_META_FLUSH, $DRBD_NO_META_FLUSH)
 304
 305 # --enable-syslog[=no/yes/only]
 306 AC_ARG_ENABLE([syslog],
 307   [AS_HELP_STRING([--enable-syslog],
 308     [enable use of syslog (default: disabled), one of no/yes/only])],
 309   [[case "$enableval" in
 310       no)
 311         SYSLOG=no
 312         ;;
 313       yes)
 314         SYSLOG=yes
 315         ;;
 316       only)
 317         SYSLOG=only
 318         ;;
 319       *)
 320         SYSLOG=
 321         ;;
 322     esac
 323   ]],
 324   [SYSLOG=no])
 325
 326 if test -z "$SYSLOG"
 327 then
 328   AC_MSG_ERROR([invalid value for syslog, choose one of no/yes/only])
 329 fi
 330 AC_SUBST(SYSLOG_USAGE, $SYSLOG)
 331
 332 # --enable-restricted-commands[=no/yes]
 333 AC_ARG_ENABLE([restricted-commands],
 334   [AS_HELP_STRING([--enable-restricted-commands],
 335                   m4_normalize([enable restricted commands in the node daemon
 336                                 (default: disabled)]))],
 337   [[if test "$enableval" = no; then
 338       enable_restricted_commands=False
 339     else
 340       enable_restricted_commands=True
 341     fi
 342   ]],
 343   [enable_restricted_commands=False])
 344 AC_SUBST(ENABLE_RESTRICTED_COMMANDS, $enable_restricted_commands)
 345
 346 # --with-disk-separator=...
 347 AC_ARG_WITH([disk-separator],
 348   [AS_HELP_STRING([--with-disk-separator=STRING],
 349     [Disk index separator, useful if the default of ':' is handled]
 350     [ specially by the hypervisor]
 351   )],
 352   [disk_separator="$withval"],
 353   [disk_separator=":"])
 354 AC_SUBST(DISK_SEPARATOR, $disk_separator)
 355
 356 # Check common programs
 357 AC_PROG_INSTALL
 358 AC_PROG_LN_S
 359
 360 # check if ln is the GNU version of ln (and hence supports -T)
 361 if ln --version 2> /dev/null | head -1 | grep -q GNU
 362 then
 363   AC_SUBST(HAS_GNU_LN, True)
 364 else
 365   AC_SUBST(HAS_GNU_LN, False)
 366 fi
 367
 368 # Check for the ip command
 369 AC_ARG_VAR(IP_PATH, [ip path])
 370 AC_PATH_PROG(IP_PATH, [ip], [])
 371 if test -z "$IP_PATH"
 372 then
 373   AC_MSG_ERROR([ip command not found])
 374 fi
 375
 376 # Check for pandoc
 377 AC_ARG_VAR(PANDOC, [pandoc path])
 378 AC_PATH_PROG(PANDOC, [pandoc], [])
 379 if test -z "$PANDOC"
 380 then
 381   AC_MSG_WARN([pandoc not found, man pages rebuild will not be possible])
 382 fi
 383
 384 # Check for python-sphinx
 385 AC_ARG_VAR(SPHINX, [sphinx-build path])
 386 AC_PATH_PROG(SPHINX, [sphinx-build], [])
 387 if test -z "$SPHINX"
 388 then
 389   AC_MSG_WARN(m4_normalize([sphinx-build not found, documentation rebuild will
 390                             not be possible]))
 391 else
 392   # Sphinx exits with code 1 when it prints its usage
 393   sphinxver=`{ $SPHINX --version 2>&1 || :; } | head -n 3`
 394
 395   if ! echo "$sphinxver" | grep -q -w -e '^Sphinx' -e '^Usage:'; then
 396     AC_MSG_ERROR([Unable to determine Sphinx version])
 397
 398   # Note: Character classes ([...]) need to be double quoted due to autoconf
 399   # using m4
 400   elif ! echo "$sphinxver" | grep -q -E '^Sphinx[[[:space:]]]+v[[1-9]]\>'; then
 401     AC_MSG_ERROR([Sphinx 1.0 or higher is required])
 402   fi
 403 fi
 404 AM_CONDITIONAL([HAS_SPHINX], [test -n "$SPHINX"])
 405
 406 AC_ARG_ENABLE([manpages-in-doc],
 407   [AS_HELP_STRING([--enable-manpages-in-doc],
 408                   m4_normalize([include man pages in HTML documentation
 409                                 (requires sphinx; default disabled)]))],
 410   [case "$enableval" in
 411       yes) manpages_in_doc=yes ;;
 412       no) manpages_in_doc= ;;
 413       *)
 414         AC_MSG_ERROR([Bad value $enableval for --enable-manpages-in-doc])
 415         ;;
 416     esac
 417   ],
 418   [manpages_in_doc=])
 419 AM_CONDITIONAL([MANPAGES_IN_DOC], [test -n "$manpages_in_doc"])
 420 AC_SUBST(MANPAGES_IN_DOC, $manpages_in_doc)
 421
 422 if test -z "$SPHINX" -a -n "$manpages_in_doc"; then
 423   AC_MSG_ERROR([Including man pages in HTML documentation requires sphinx])
 424 fi
 425
 426 # Check for graphviz (dot)
 427 AC_ARG_VAR(DOT, [dot path])
 428 AC_PATH_PROG(DOT, [dot], [])
 429 if test -z "$DOT"
 430 then
 431   AC_MSG_WARN(m4_normalize([dot (from the graphviz suite) not found,
 432                             documentation rebuild not possible]))
 433 fi
 434
 435 # Check for pylint
 436 AC_ARG_VAR(PYLINT, [pylint path])
 437 AC_PATH_PROG(PYLINT, [pylint], [])
 438 if test -z "$PYLINT"
 439 then
 440   AC_MSG_WARN([pylint not found, checking code will not be possible])
 441 fi
 442
 443 # Check for pep8
 444 AC_ARG_VAR(PEP8, [pep8 path])
 445 AC_PATH_PROG(PEP8, [pep8], [])
 446 if test -z "$PEP8"
 447 then
 448   AC_MSG_WARN([pep8 not found, checking code will not be complete])
 449 fi
 450 AM_CONDITIONAL([HAS_PEP8], [test -n "$PEP8"])
 451
 452 # Check for python-coverage
 453 AC_ARG_VAR(PYCOVERAGE, [python-coverage path])
 454 AC_PATH_PROGS(PYCOVERAGE, [python-coverage coverage], [])
 455 if test -z "$PYCOVERAGE"
 456 then
 457   AC_MSG_WARN(m4_normalize([python-coverage or coverage not found, evaluating
 458                             Python test coverage will not be possible]))
 459 fi
 460
 461 # Check for socat
 462 AC_ARG_VAR(SOCAT, [socat path])
 463 AC_PATH_PROG(SOCAT, [socat], [])
 464 if test -z "$SOCAT"
 465 then
 466   AC_MSG_ERROR([socat not found])
 467 fi
 468
 469 # Check for qemu-img
 470 AC_ARG_VAR(QEMUIMG_PATH, [qemu-img path])
 471 AC_PATH_PROG(QEMUIMG_PATH, [qemu-img], [])
 472 if test -z "$QEMUIMG_PATH"
 473 then
 474   AC_MSG_WARN([qemu-img not found, using ovfconverter will not be possible])
 475 fi
 476
 477 # --enable-confd
 478 ENABLE_CONFD=
 479 AC_ARG_ENABLE([confd],
 480   [AS_HELP_STRING([--enable-confd],
 481   [enable the ganeti-confd daemon (default: check)])],
 482   [],
 483   [enable_confd=check])
 484
 485 ENABLE_MOND=
 486 AC_ARG_ENABLE([monitoring],
 487   [AS_HELP_STRING([--enable-monitoring],
 488   [enable the ganeti monitoring daemon (default: check)])],
 489   [],
 490   [enable_monitoring=check])
 491
 492 # Check for ghc
 493 AC_ARG_VAR(GHC, [ghc path])
 494 AC_PATH_PROG(GHC, [ghc], [])
 495 if test -z "$GHC"; then
 496   AC_MSG_FAILURE([ghc not found, compilation will not possible])
 497 fi
 498
 499 AC_MSG_CHECKING([checking for extra GHC flags])
 500 GHC_BYVERSION_FLAGS=
 501 # check for GHC supported flags that vary accross versions
 502 for flag in -fwarn-incomplete-uni-patterns; do
 503   if $GHC -e '0' $flag >/dev/null 2>/dev/null; then
 504    GHC_BYVERSION_FLAGS="$GHC_BYVERSION_FLAGS $flag"
 505   fi
 506 done
 507 AC_MSG_RESULT($GHC_BYVERSION_FLAGS)
 508 AC_SUBST(GHC_BYVERSION_FLAGS)
 509
 510 # Check for ghc-pkg
 511 AC_ARG_VAR(GHC_PKG, [ghc-pkg path])
 512 AC_PATH_PROG(GHC_PKG, [ghc-pkg], [])
 513 if test -z "$GHC_PKG"; then
 514   AC_MSG_FAILURE([ghc-pkg not found, compilation will not be possible])
 515 fi
 516
 517 # check for modules, first custom/special checks
 518 AC_MSG_NOTICE([checking for required haskell modules])
 519 HS_PARALLEL3=
 520 AC_GHC_PKG_CHECK([parallel-3.*], [HS_PARALLEL3=-DPARALLEL3],
 521                  [AC_GHC_PKG_REQUIRE(parallel)], t)
 522 AC_SUBST(HS_PARALLEL3)
 523
 524 # and now standard modules
 525 AC_GHC_PKG_REQUIRE(curl)
 526 AC_GHC_PKG_REQUIRE(json)
 527 AC_GHC_PKG_REQUIRE(network)
 528 AC_GHC_PKG_REQUIRE(mtl)
 529 AC_GHC_PKG_REQUIRE(bytestring)
 530 AC_GHC_PKG_REQUIRE(utf8-string)
 531 AC_GHC_PKG_REQUIRE(hslogger)
 532
 533 # extra modules for confd functionality
 534 HS_REGEX_PCRE=-DNO_REGEX_PCRE
 535 has_confd=False
 536 if test "$enable_confd" != no; then
 537   CONFD_PKG=
 538   AC_GHC_PKG_CHECK([regex-pcre], [HS_REGEX_PCRE=],
 539                    [CONFD_PKG="$CONFD_PKG regex-pcre"])
 540   AC_GHC_PKG_CHECK([Crypto], [], [CONFD_PKG="$CONFD_PKG Crypto"])
 541   AC_GHC_PKG_CHECK([text], [], [CONFD_PKG="$CONFD_PKG text"])
 542   AC_GHC_PKG_CHECK([hinotify], [], [CONFD_PKG="$CONFD_PKG hinotify"])
 543   AC_GHC_PKG_CHECK([vector], [], [CONFD_PKG="$CONFD_PKG vector"])
 544   if test -z "$CONFD_PKG"; then
 545     has_confd=True
 546   elif test "$enable_confd" = check; then
 547     AC_MSG_WARN(m4_normalize([The required extra libraries for confd were
 548                               not found ($CONFD_PKG), confd disabled]))
 549   else
 550     AC_MSG_FAILURE(m4_normalize([The confd functionality was requested, but
 551                                  required libraries were not found:
 552                                  $CONFD_PKG]))
 553   fi
 554 fi
 555 AC_SUBST(HS_REGEX_PCRE)
 556 if test "$has_confd" = True; then
 557   AC_MSG_NOTICE([Enabling confd usage])
 558 fi
 559 AC_SUBST(ENABLE_CONFD, $has_confd)
 560 AM_CONDITIONAL([ENABLE_CONFD], [test x$has_confd = xTrue])
 561
 562 #extra modules for monitoring daemon functionality
 563 has_monitoring=False
 564 if test "$enable_monitoring" != no; then
 565   MONITORING_PKG=
 566   AC_GHC_PKG_CHECK([attoparsec], [],
 567                    [MONITORING_PKG="$MONITORING_PKG attoparsec"])
 568   AC_GHC_PKG_CHECK([snap-server], [],
 569                    [MONITORING_PKG="$MONITORING_PKG snap-server"])
 570   AC_GHC_PKG_CHECK([process], [],
 571                    [MONITORING_PKG="$MONITORING_PKG process"])
 572   MONITORING_DEP=
 573   if test "$has_confd" = False; then
 574     MONITORING_DEP="$MONITORING_DEP confd"
 575   fi
 576   has_monitoring_pkg=False
 577   if test -z "$MONITORING_PKG"; then
 578     has_monitoring_pkg=True
 579   elif test "$enable_monitoring" = check; then
 580     AC_MSG_WARN(m4_normalize([The required extra libraries for the monitoring
 581                               daemon were not found ($MONITORING_PKG),
 582                               monitoring disabled]))
 583   else
 584     AC_MSG_FAILURE(m4_normalize([The monitoring functionality was requested, but
 585                                  required libraries were not found:
 586                                  $MONITORING_PKG]))
 587   fi
 588   has_monitoring_dep=False
 589   if test -z "$MONITORING_DEP"; then
 590     has_monitoring_dep=True
 591   elif test "$enable_monitoring" = check; then
 592     AC_MSG_WARN(m4_normalize([The optional Ganeti components required for the
 593                               monitoring agent were not enabled
 594                               ($MONITORING_DEP), monitoring disabled]))
 595   else
 596     AC_MSG_FAILURE(m4_normalize([The monitoring functionality was requested, but
 597                                  required optional Ganeti components were not
 598                                  found: $MONITORING_DEP]))
 599   fi
 600
 601 fi
 602 if test "$has_monitoring_pkg" = True -a "$has_monitoring_dep" = True; then
 603   has_monitoring=True
 604   AC_MSG_NOTICE([Enabling the monitoring agent usage])
 605 fi
 606 AC_SUBST(ENABLE_MOND, $has_monitoring)
 607 AM_CONDITIONAL([ENABLE_MOND], [test "$has_monitoring" = True])
 608
 609 # development modules
 610 HS_NODEV=
 611 AC_GHC_PKG_CHECK([QuickCheck-2.*], [], [HS_NODEV=1], t)
 612 AC_GHC_PKG_CHECK([test-framework-0.6*], [], [HS_NODEV=1], t)
 613 AC_GHC_PKG_CHECK([test-framework-hunit], [], [HS_NODEV=1])
 614 AC_GHC_PKG_CHECK([test-framework-quickcheck2], [], [HS_NODEV=1])
 615 AC_GHC_PKG_CHECK([temporary], [], [HS_NODEV=1])
 616 # FIXME: unify checks for non-test libraries (attoparsec, hinotify, ...)
 617 #        that are needed to execute the tests, avoiding the duplication
 618 #        of the checks.
 619 AC_GHC_PKG_CHECK([attoparsec], [], [HS_NODEV=1])
 620 AC_GHC_PKG_CHECK([vector], [], [HS_NODEV=1])
 621 AC_GHC_PKG_CHECK([process], [], [HS_NODEV=1])
 622 AC_GHC_PKG_CHECK([snap-server], [], [HS_NODEV=1])
 623 AC_GHC_PKG_CHECK([regex-pcre], [], [HS_NODEV=1])
 624 AC_GHC_PKG_CHECK([Crypto], [], [HS_NODEV=1])
 625 AC_GHC_PKG_CHECK([text], [], [HS_NODEV=1])
 626 AC_GHC_PKG_CHECK([hinotify], [], [HS_NODEV=1])
 627 if test -n "$HS_NODEV"; then
 628    AC_MSG_WARN(m4_normalize([Required development modules were not found,
 629                              you won't be able to run Haskell unittests]))
 630 else
 631    AC_MSG_NOTICE([Haskell development modules found, unittests enabled])
 632 fi
 633 AC_SUBST(HS_NODEV)
 634
 635 HTOOLS=yes
 636 AC_SUBST(HTOOLS)
 637
 638 # --enable-split-query
 639 ENABLE_SPLIT_QUERY=
 640 AC_ARG_ENABLE([split-query],
 641   [AS_HELP_STRING([--enable-split-query],
 642   [enable use of custom query daemon via confd])],
 643   [[case "$enableval" in
 644       no)
 645         enable_split_query=False
 646         ;;
 647       yes)
 648         enable_split_query=True
 649         ;;
 650       *)
 651         echo "Invalid value for enable-confd '$enableval'"
 652         exit 1
 653         ;;
 654     esac
 655   ]],
 656   [[case "x${has_confd}x" in
 657      xTruex)
 658        enable_split_query=True
 659        ;;
 660      *)
 661        enable_split_query=False
 662        ;;
 663    esac]])
 664 AC_SUBST(ENABLE_SPLIT_QUERY, $enable_split_query)
 665
 666 if test x$enable_split_query = xTrue -a x$has_confd != xTrue; then
 667   AC_MSG_ERROR([Split queries require the confd daemon])
 668 fi
 669
 670 if test x$enable_split_query = xTrue; then
 671   AC_MSG_NOTICE([Split query functionality enabled])
 672 fi
 673
 674 # Check for HsColour
 675 HS_APIDOC=no
 676 AC_ARG_VAR(HSCOLOUR, [HsColour path])
 677 AC_PATH_PROG(HSCOLOUR, [HsColour], [])
 678 if test -z "$HSCOLOUR"; then
 679   AC_MSG_WARN(m4_normalize([HsColour not found, htools API documentation will
 680                             not be generated]))
 681 fi
 682
 683 # Check for haddock
 684 AC_ARG_VAR(HADDOCK, [haddock path])
 685 AC_PATH_PROG(HADDOCK, [haddock], [])
 686 if test -z "$HADDOCK"; then
 687   AC_MSG_WARN(m4_normalize([haddock not found, htools API documentation will
 688                             not be generated]))
 689 fi
 690 if test -n "$HADDOCK" && test -n "$HSCOLOUR"; then
 691   HS_APIDOC=yes
 692 fi
 693 AC_SUBST(HS_APIDOC)
 694
 695 # Check for hlint
 696 AC_ARG_VAR(HLINT, [hlint path])
 697 AC_PATH_PROG(HLINT, [hlint], [])
 698 if test -z "$HLINT"; then
 699   AC_MSG_WARN([hlint not found, checking code will not be possible])
 700 fi
 701
 702 if test "$HTOOLS" != yes && test "$ENABLE_CONFD" = True; then
 703   AC_MSG_ERROR(m4_normalize([cannot enable ganeti-confd if
 704                              htools support is not enabled]))
 705 fi
 706
 707 AM_CONDITIONAL([WANT_HTOOLS], [test "$HTOOLS" = yes])
 708 AM_CONDITIONAL([WANT_HSTESTS], [test "x$HS_NODEV" = x])
 709 AM_CONDITIONAL([WANT_HSAPIDOC], [test "$HS_APIDOC" = yes])
 710 AM_CONDITIONAL([HAS_HLINT], [test "$HLINT"])
 711
 712 # Check for fakeroot
 713 AC_ARG_VAR(FAKEROOT_PATH, [fakeroot path])
 714 AC_PATH_PROG(FAKEROOT_PATH, [fakeroot], [])
 715 if test -z "$FAKEROOT_PATH"; then
 716   AC_MSG_WARN(m4_normalize([fakeroot not found, tests that must run as root
 717                             will not be executed]))
 718 fi
 719 AM_CONDITIONAL([HAS_FAKEROOT], [test "x$FAKEROOT_PATH" != x])
 720
 721 SOCAT_USE_ESCAPE=
 722 AC_ARG_ENABLE([socat-escape],
 723   [AS_HELP_STRING([--enable-socat-escape],
 724     [use escape functionality available in socat >= 1.7 (default: detect
 725      automatically)])],
 726   [[if test "$enableval" = yes; then
 727       SOCAT_USE_ESCAPE=True
 728     else
 729       SOCAT_USE_ESCAPE=False
 730     fi
 731   ]])
 732
 733 if test -z "$SOCAT_USE_ESCAPE"
 734 then
 735   if $SOCAT -hh | grep -w -q escape; then
 736     SOCAT_USE_ESCAPE=True
 737   else
 738     SOCAT_USE_ESCAPE=False
 739   fi
 740 fi
 741
 742 AC_SUBST(SOCAT_USE_ESCAPE)
 743
 744 SOCAT_USE_COMPRESS=
 745 AC_ARG_ENABLE([socat-compress],
 746   [AS_HELP_STRING([--enable-socat-compress],
 747     [use OpenSSL compression option available in patched socat builds
 748      (see INSTALL for details; default: detect automatically)])],
 749   [[if test "$enableval" = yes; then
 750       SOCAT_USE_COMPRESS=True
 751     else
 752       SOCAT_USE_COMPRESS=False
 753     fi
 754   ]])
 755
 756 if test -z "$SOCAT_USE_COMPRESS"
 757 then
 758   if $SOCAT -hhh | grep -w -q openssl-compress; then
 759     SOCAT_USE_COMPRESS=True
 760   else
 761     SOCAT_USE_COMPRESS=False
 762   fi
 763 fi
 764
 765 AC_SUBST(SOCAT_USE_COMPRESS)
 766
 767 if man --help | grep -q -e --warnings
 768 then
 769   MAN_HAS_WARNINGS=1
 770 else
 771   MAN_HAS_WARNINGS=
 772   AC_MSG_WARN(m4_normalize([man does not support --warnings, man page checks
 773                             will not be possible]))
 774 fi
 775
 776 AC_SUBST(MAN_HAS_WARNINGS)
 777
 778 # Check for Python
 779 AM_PATH_PYTHON(2.6)
 780
 781 AC_PYTHON_MODULE(OpenSSL, t)
 782 AC_PYTHON_MODULE(simplejson, t)
 783 AC_PYTHON_MODULE(pyparsing, t)
 784 AC_PYTHON_MODULE(pyinotify, t)
 785 AC_PYTHON_MODULE(pycurl, t)
 786 AC_PYTHON_MODULE(bitarray, t)
 787 AC_PYTHON_MODULE(ipaddr, t)
 788 AC_PYTHON_MODULE(mock)
 789 AC_PYTHON_MODULE(affinity)
 790 AC_PYTHON_MODULE(paramiko)
 791
 792 # Development-only Python modules
 793 PY_NODEV=
 794 AC_PYTHON_MODULE(yaml)
 795 if test $HAVE_PYMOD_YAML == "no"; then
 796   PY_NODEV="$PY_NODEV yaml"
 797 fi
 798
 799 if test -n "$PY_NODEV"; then
 800   AC_MSG_WARN(m4_normalize([Required development modules ($PY_NODEV) were not
 801                             found, you won't be able to run Python unittests]))
 802 else
 803   AC_MSG_NOTICE([Python development modules found, unittests enabled])
 804 fi
 805 AC_SUBST(PY_NODEV)
 806 AM_CONDITIONAL([PY_UNIT], [test -n $PY_NODEV])
 807
 808 AC_CONFIG_FILES([ Makefile ])
 809
 810 AC_OUTPUT