- merge from ronnie
- add a flag to check that recovery completed correctly. If not, re-trigger it in monitoring

wait for ctdbd to finish cleanup before considering "service ctdb stop" to be done

nicer use of testparm

update the section about event scripts

disable nfsv4 in etc/sysconfig/nfs

when a ctdb_takeover_run has failed  we must make sure that
need_takeover_run is set to true  or else we might forget to rerun it
again during the next recovery

othervise,  need_takeover_run is only set to true IFF the node flags for
a remote node and the local nodes differ.
It is possible that a takeover run fails  and thus the reassignment of
ip addresses is incomplete  but before we get back to the test in
monitor_cluster()  that all the node flags of all nodes have converged
and they now match each others again.   and thus causing
monitor_cluster() to fail to realize that a takeover run is needed.

ensure smbd and winbindd do die in 50.samba

merge from tridge

prevent recursion in the calling of ctdb_takeover_run

more shell scripting fixes in 10.interface

force recovery if unable to tell a node to release an IP

fixed script errors in 10.interface

we don't need the is_loopback logic in ctdb any more

remove more cruft from the logs

new approach for killing TCP connections on IP release

remove clutter from ctdb log file

fixed return code

handle hung or slow ctdb daemons on shutdown

- set arp_ignore to prevent replying to arp requests for addresses on loopback
- put removed IPs on loopback with scope host
- check for nul strings in ethtool call
;

- don't allow the registration of clients with IPs we don't hold
- change some debug levels to make tracking of IP release problems easier

changed some debug levels

use the public addresses variable instead of hardcoding the path

move all ip addresses onto loopback when we startup ctdb

fixed location of arp_filter

get interface right

grab the interface name from tok and not from the uninitialized array

merged patch from tridge

fixed a pointer cast warning

added back --public-interface to startup script

- use struct sockaddr_in more consistently instead of string addresses
- allow for public_address lines with a defaulting interface

add back in --public-interface as a default

merge from ronnie

add crontab and sysctl output

update a comment

change the signature to ctdb_sys_have_ip() to also return:
 a bool that specifies whether the ip was held by a loopback adaptor or
not
 the name of the interface where the ip was held

when we release an ip address from an interface, move the ip address
over to the loopback interface

when we release an ip address  after we have move it onto loopback,
use 60.nfs to kill off the server side (the local part) of the tcp
connection   so that the tcp connections dont survive a
failover/failback

61.nfstickle,   since we kill hte tcp connections when we release an ip
address   we no longer need to restart the nfs service in 61.nfstickle

update ctdb_takeover to use the new signature for ctdb_sys_have_ip

when we add a tcp connection to kill in ctdb_killtcp_add_connection()
check if either the srouce or destination address match a known public
address

set /proc/sys/net/ipv4/conf/all/arp_filter to 1 by default when
10.interfaces startsup

this setting makes the system only respond to APR requests from the NIC
where the ip address is tied to and adds to the
"principle of least surprise" when using multihoming servers

ctdb ip    must loop over all connected nodes to pull hte public ip list
and merge into a big list   since with the deassociation between a node
and a public ipaddress    the /etc/ctdb/public_addresses files can
differ between nodes and no node know about all public addresses that a
cluster can use

remove the ctdb publicip  command
this command no longer makes sense when there is no on-to-one mapping
between a node and its default public ip

update web nfs with the new NFS_HOSTNAME variable we need to be able to
stat notify using the correct hostname

add a short delay after stopping nfslock   to make it less likely that
"weird" things happen

merge from tridge

60.nfs:
we must always restart the lockmanager when the cluster has been
reconfigured and ip addresses has changed. This is to make sure we get a
clusterwide grace period for nfs locking.
if we dont do this and only restart locking on the nodes that were
direclty affected, a different client can take out a conflicting lock
from a different node before affected clients has had a chance to
reclaim all the locks lost during reconfigure.
grace period on rhel5 kernel has bene increased to 90 seconds!

statd-callout:
we must restart lockmanager to ensure a clusterwide grace period for
nfs. this makes locking "more correct" for nfs clients and prevents
other clients/nodes from taking out a conflicting lock while a different
client/node tries to reclaim lost locks.
This makes it "almost consistent" for NFS clients   but there is still
the possibility that a cifs client can take out a conflicting lock
before an nfs client has had a chance to reclaim an existing lock.
This can not be solved with anything less than making the kernel nfs
lock manager "samba aware" and making samba aware of the internal state
of the kernel lock manager so that they can cooperate.

we can not just stop/start the lockmanager back to back in rhel5 since
if they are stopped/started too close to eachother then when the new
lockmanager upon starting up sends out statd notifications two things
can happen:
1, new lockmanager sends out notification BEFORE it has registered with
portmapper leading to
  lockmanager starts
  lockmanager sends notification to the client
  client tries to recover the lock and tries to portmap the lockmanager
  port on the server.
  server is not (yet) registered with portmapper and server responds
  "no such program" to hte clients request to discover where lockmanager
   is.
  client then just completely gives up reclaiming the lock and doesnt
  even reattempt the portmapper call after some timeout.
  ==> lock reclaim failed.
2, if they are started back to back, and a client tries to reclaim the
   lock  the lockmanager sometimes sends two responses back to back
   to the client.   one with status NLM_GRANTED (==you got the lock
reclaimed) and one with status NLM_DENIED (==you could not get the lock
reclaimed)
   This confuses the client and leads to the server thinking that the
client does have the lock   and the client thinking it has not got the
lock    and orphaned locks result.

We also send out additional notification messages of different formats
to allow more legacy clients to interoperate with locking.

we dont need the rpc.statd on shared directory   neither do we need
PUBLIC_IP anymore

improve the handling of hosts to notify with statd

specify the additional ports for nfs

the event scripts for nfs are called 60.nfs and 61.nfstickle

document NFS_TICKLE_SHARED_DIRECTORY on our web page

we dont use 'sendip' any more   so dont check for it and exit from the
61.nfstickles script if it is missing from the host

we should always get data back from getnodemap

dont dereference vnn before we have assigned it a pointer value

added a diagnostics tool for ctdb

allow different nodes in the cluster to use different public_addresses
files
so that we can partition the cluster into different subsets of nodes
which each serve a different subset of the public addresses

get rid of the ctdb_vnn_list structure and just use a single list of
ctdb_vnn

we cant have takeover_ctx hanging off ctdb  since it is freed/recreated
everytime we release an ip.
this context is used to hold all resources needed when sending out
gratious arps and tcp tickles during ip takeover.

we hang it off the vnn structure that manages that particular ip address
instead   so that we can have multiple ones going in parallell

this bug (or the same bug in different shape) has probably been in ctdb
for very very long   but is likely to be hard to trigger

fix typo in debug output

dont just always return 0 from the killtcp control.
return 0 or -1 so that the ctdb tool knows whether the control succeeded
or not

change vnn to pnn in the traverse structure

change debug output from vnn to pnn

change debug output from vnn to pnn

change ctdb_daemon_send_message to take pnn as parameter isntead of vnn

change ctdb_send_message  to take pnn as parameter instead of vnn

change ctdb_ctrl_getvnn to ctdb_ctrl_getpnn

change ctdb_node_flags_change.vnn to ctdb_node_flags_changed.pnn

change ctdb_ban_info.vnn to ctdb_ban_info.pnn

change server_id.vnn to server_id.pnn

change ctdb_get_vnn to ctdb_get_pnn

change vnn to pnn in the ctdb tool

change ctdb_validate_vnn to ctdb_validate_pnn

change ctdb->vnn to ctdb->pnn

change how we do public addresses and takeover so that we can have
multiple public addresses spread across multiple interfaces on each
node.

this is a massive patch since we have previously made the assumtion that
we only have one public address per node.

get rid of the public_interface argument.  the public addresses file
now explicitely lists which interface the address belongs to

merge from tridge

up the release number

merge from ronnie

when we start 60.nfs   we must make sure that the shared storage
nfs-state directory actually exists (by creating it)
or else the lock manager will not start

merge from ronnie

merge from tridge

add an extra debug statement when we send a SIGTERM to a process

make the ctdb shutdown command use the async _send() function to send
the shutdown command
and return success to the caller if the _send() was successful

fixed segv when no public interface is set

add async versions of the freeze node control and freeze all nodes in
parallell

change the monitoring of recmode in the recovery daemon to use a fully
async eventdriven api for controls

add a control to pull the server id list off a node

add an initial implementation of a service_id structure and three
controls to  register/unregister/check a server id.

a server id consists of TYPE:VNN:ID    where type is specific to the
application.  VNN is the node where the serverid was registered and ID
might be a node unique identifier such as a pid or similar.

Clients can register a server id for themself at the local ctdb daemon.
When a client dissappears   or when the domain socket connection for the
client drops  then any and all server ids registered across that domain
socket will also be automatically removed from the store.

clients can register as many server_ids as they want at the same time
but each TYPE:VNN:ID must be globally unique.

Clients have the option of explicitely unregister a server id by using
the UNREGISTER control.

Registration and unregistration can only be done by clients to the local
daemon. clients can not register their server id to a remote node.

clients can check if a server id does exist on any ctdb node in the
network by using the check control

cleanup invoke_control_callback.   we dont need to pass some of these
parameters to _recv() since they are already set

change the api for managing callbacks to controls   so that isntead of
passing it as a parameter we set the callback function explicitely from
the caller if the ..._send() function returned a valid state pointer.

comment why we do a talloc_steal

get rid of the explicit global timeout used in the previous example and
try this time by relying on the timeouts for the individual controls

try out a slightly different api for controls where you provide a
callback function which is called upon completion (or timeout) of the
control.

modify scanning of recmaster in the monitoring_cluster code to try the
api out

break checking that the recoverymode on all nodes are ok  out into its
own function

hang the ctdb_req_control structure off the ctdb_client_control_state
struct  so that if we timeout a control we can print debug info such as
what opcode failed and to which node

we dont need the *status parameter to ctdb_client_control_state

create async versions of the getrecmaster control

pass a memory context to getrecmaster

in ctdb_call_recv() we must check that state is non-NULL since
ctdb_call() may pass a null pointer to _recv() and this would cause a
segfault.
fortunately there appears there are no critical users for this codepath
right now so the risk was more theoretical IF clients start using this
call it coult segfault.

change ctdb_control() to become fully async so we later can make
recovery daemon do the expensive controls to nodes in parallell instead
of in sequence

create an enum to describe the state of a control in flight  instead of
using the enum that is for calls

merge from tridge

merge from ronnie

merge from volker

merge from volker

when we receive a packet from the network, check explicitely that the
node is not banned it the call is for a database record. i.e a REQ/REPLY
CALL/DMASTER

if we get such a call while banned, ignore the packet and write an entry
in the logfile

create a define to represent the 'invalid' generation id we used in two
places.

create a new helper function to generate new generation id values that
know about the invalid id and avoids generating it.

update the ctdb status tool to know about the invalid generation id and
print the string INVALID instead

if the node is inactive  i.e. banned or disconnected  then that node is
not participating in the cluster

if a client tries to attach to a database while the node is inactive,
return an error back to the client and fail the attach

when a node becomes banned    its databases are no longer part of ctdb
and it should thus no longer serve any database access calls until it
has been reintroduced into the cluster.

when becoming banned,   reset the local generation id to 1   to prevent
any further database access calls from other nodes from being processed.

if lockwait takes an excessive time to complete. log the time it took to
complete and also the name of the database

change the structure used for node flag change messages so that we can
see both the old flags as well as the new flags (so we can tell which
flags changed)

send the CTDB_SRVID_RECONFIGURE messages to connected nodes only, not to
every node, connected or not, in the cluster.

in the handler inside the recovery daemon which is invoked for node flag
change messages, only do a takeover_run() and redistribute the ip addresses IF it was the
disabled or the unhealthy flags that changed. Also send out the cluster
reconfigured message in this case.
If any of the other flags changed we dont need to do the takeover_run(0
here since that will be done during recovery.