Provided by: wackamole_2.1.1-3.1_i386 bug

NAME

     wackamole.conf - Wackamole daemon configuration file

SYNOPSIS

     wackamole.conf

DESCRIPTION

     wackamole reads its configuration information from wackamole.conf (or the
     file specified with -c on the command line).

     Spread  The spread daemon to which wackamole should connect.  Default
             value is “4803”.

     SpreadRetryInterval
             The time interval between a failed attempt to connect to Spread
             and the next attempt.  Default “5s”.

     Group   The Spread group overwhich all wackamole instances in the cluster
             will communicate.

     Control
             The file (unix domain socket) on which wackamole will listen for
             and to which wackatrl will send out-of-band administrative
             commands.

     AcquisitionsPerRound
             This is specified within a Balance stanza. This value informs
             wackamole of the maximum number of interfaces it will assume
             responsibility for in a single balancing roung.  Possible values
             are non-negative integers and the keywork “all”.

     Interval
             This is specified within a Balance stanza.  This value specifies
             how long each balancing round is to take.  The default is “4s”.

             Sample Balance stanza:

                   Balance {
                     AcquisitionsPerRound = all
                     interval = 4s
                   }

     Mature  Desribing the time interval required before an new node becomes
             mature and can assume responsibilities.  The default value is
             “5s”.

     Arp-Cache
             This time interval is the interval at which wackamole will
             recollect local arp cache information and share it with its
             peers.  The default is “60s”.

     Prefer <IP>
             Tells wackamole that this IP address is preferred and that an
             attempt should be made to assume responsibility for the VIF
             headed by this IP.  Use of this option is discouraged as
             wackamole can typically make decisions all by its lonesome.

     VirtualInterfaces
             This stanza describes the virtual interfaces (and the virtual IP
             addresses those interfaces contain) that wackamole will manage.
             A virtual interface can be a single IP address of the form:

                   int:IP/CIDR
                   int:IP/CIDRnNET

             Interfaces may consist of multiple grouped IPs (that cannot be
             separated) by specifiying them in braces:

                   { int:IP/CIDR int:IP/CIDRnNET int:IP/CIDR }

             int in the syntax represents the physical interface on which the
             IP address will be managed ( e.g. fxp0, eth1, en0, hme0 ).  IP is
             a standard form IPv4 address.  CIDR is the numeric CIDR-form
             netmask (the number of set bits in the netmask).  Note that many
             operating systems ( FreeBSD, Solaris, Mac OS X) recommend that
             aliases be added with a netmask of 0xffffffff and in these cases,
             /32 is the appropirate CIDR to use.  NET provides a hint to
             wackamole as to the netspace in which the IP sits.  As the
             netmask directly on the interface is often /32, it often does not
             illustrate that ARP spoofs can be sent to other IPs (as none lie
             in its directly attached netspace.  NET is a way of effectively
             telling wackamole the directly attached IP network that ARP
             responses could be sent to.  If NET is not specified, it is
             assumed to be a n24.

             With the exception of the interface name and perhaps the netmask,
             these stanzas must be across all machines in the cluster.
             Wackamole manages IP addresses by both index number and IP
             address, so it is fundamental that the lists look the same and be
             in the same order.

             Sample VirtualInterfaces stanza:

                   VirtualInterfaces {
                       eth0:10.2.3.11/24
                       eth0:10.2.3.12/24
                       eth0:10.2.3.13/24
                       eth0:10.2.3.13/24
                       eth0:10.2.3.13/24
                   }

             Sample multi-IP VirtualInterfaces stanza:

                   VirtualInterfaces {
                       { fxp0:192.168.10.2/32n23 fxp1:192.0.2.2/32n29 }
                       { fxp0:192.168.10.3/32n23 fxp1:192.0.2.3/32n29 }
                   }

EXTENSIBILITY

     Wackamole allows for user-defined actions to occur when HA events occur.
     There are four types of events:

     on up   This occurs when a virtual interface is brought online.

     on down
             This occurs when a virtual interface is brought offline.

     post up
             This occurs after a balancing round during which one or more
             virtual interfaces where brought online.

     post down
             This occurs after a balancing round during which one or more
             virtual interfaces where brought offline.

     Wackamole allows shared objects to loaded and executed during any of
     these events by specifying:

     RunDynamic module:func event

     module is a shared object (or dyld bundle) that can be loaded using the
     operating systems dynamic run-time loader (dlopen or dyld).  func is the
     name of the symbol to be referenced from that object and invoked.  event
     is one of the four events listed above.

     Wackamole also has an optional embedded perl interpreter which allows
     modules written in perl to be loaded and executed.  Perl specific options
     are:

     PerlUseLib
             Takes a directory as a parameter and is effectively the same as
             performing use lib within perl.

     PerlUse
             Takes a module as a parameter and performs a use on it making it
             available for use within wackamole.

     The RunDynamic directive envokes perl methods if two colons (::) are used
     to seperate the module from the func.  Sample execution of
     MyModule::DoMagic on a post up event:

           PerlUseLib /opt/wackamole/site
           PerlUse MyModule
           RunDynamic MyModule::DoMagic post up

AUTHORS

     Yair Amir <yairamir@cnds.jhu.edu> Ryan Caudy <wyvern@cnds.jhu.edu>
     Aashima Munjal <munjal@cnds.jhu.edu> Theo Schlossnagle
     <jesus@cnds.jhu.edu>

SEE ALSO

     wackamole(8) wackatrl(1)