eventscript: introduce enum for different event script calls.

Rather than doing strcmp everywhere, pass an explicit enum around.  This
also subtly documents what options are available.  The "options" arg
is now used for extra arguments only.

Unfortunately, gcc complains on empty format strings, so we make
ctdb_event_script() take no varargs, and add ctdb_event_script_args().  We
leave ctdb_event_script_callback() taking varargs, which means callers
have to do "%s", "".

For the moment, we have CTDB_EVENT_UNKNOWN for handling forced scripts
from the ctdb tool.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

eventscript: put timeout inside ctdb_event_script_callback_v

Everyone uses the same timeout value, so just remove it from the API.
If we ever need variable timeouts, that might as well be central too.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

eventscript: cleanup ctdb_event_script_v

ctdb_event_script_v doesn't take varargs.  ctdb_run_event_script is
a better name, and fix comment.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

eventscript: fix bug in timeouts on forced eventscripts.  Again.

In 15bc66ae801b0c69, Ronnie fixed a double-free race.  The problem was that
ctdb_run_eventscripts() hands a context to ctdb_event_script_callback() to
hang its data off, which gets freed in the callback.  This particularly
hurt in ctdb_event_script_timeout.

There's nothing wrong with this, but obviously we should make the callback
call last of all.  At the time, ctdb_event_script_timeout() carefully
extracted everything from the struct ctdb_event_script_state before
calling ->callback.

This was cleaned up in 64da4402c6ad485f (Ronnie again), and now state
was referred to after the callback again.  But the same change introduced
a direct use-after-free bug which caused an occasional oops.

So in our last episode (eda052101728cf92) Volker fixed this, and Michael
committed it.

But we still have the double free bug which 15bc66ae801b0c69 was supposed
to fix!  Let's try to fix this in a more permanent way, but always doing
the callback from the destructor.  This means we need to hold the status,
and don't send the KILL signal if ->child is set to 0.

Finally, add a comment about freeing ourselves in run_eventscripts_callback
and the structure definition.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

eventscript: clean up forked handler event code

Write the whole int through the pipe, rather than quietly cutting it
off.  Also, use -2 as the result if the read fails; -1 comes from many
paths if the child fails before running the script.

Add a comment about why we don't need to check the write.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

rework and simplify the eventscript handling

This version has no trailing whitespace, and fixed

Now vaguely tested initscript updates.

Signed-off-by: Martin Schwenke <martin@meltin.net>

More untested eventscript factorisation.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Eventscripts: Untested factorisations and introduction of status event.

This is the first stage of an experimental change to eventscripts.
Ronnie and I did a few hours of factorisation of 40.vsftpd and applied
many of the changes to 41.httpd.  Other eventscripts were also
modified.

At this stage this is completely untested.

Signed-off-by: Martin Schwenke <martin@meltin.net>

test of a change to make ctdbd use "status" event instead of the "monitor" event.

This allows running the actual monitoring asynchronously from ctdbd
and only using "status" to pick up the actual results.

Merge commit 'martins/master'

Test suite: Fix the NFS and CIFS tickle tests.

The NFS test sleeps for MonitorInterval to give CTDB time to record an
NFS tickle.  However, this isn't always long enough.  This changes the
test to wait until a monitor event has actually occurred.

The CIFS test assumes that Samba is able to register a tickle with
CTDB before it notices that netstat has registered the tickle and can
use onnode to ask CTDB about it.  That is an incorrect assumption -
sometimes we can get to the point of asking CTDB about the tickle
before Samba and CTDB have processed it.  This adds a timeout loop
that makes the CIFS test wait until the tickle has been registered or
fail after 10 seconds.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Merge commit 'origin/master'

Fix bashism in events.d/11.natgw

Signed-off-by: Michael Adam <obnox@samba.org>

version 1.0.104

sugegstion from metze,
use killtcp and kill both directions of the nfs connections.
we used to kill only one direction since the other direction was unkillble
but recent kernels allow us to kill both

suggestion from Christian,

dont allow UNHEALTHY nodes to become natgw master, unless all nodes
are unhealthy

Fix a segfault in the eventscript timeout handler.

The state was freed too early.

Signed-off-by: Michael Adam <obnox@samba.org>

ctdb.sysconfig: add a comment section about CTDB_RUN_TIMEOUT_MONITOR

Michael

Add a 99.timeout event script to trigger monitor timeouts.

This just sleeps for twice the value of EventScriptTimeout
in the monitor action. It is not run by default, but
can be activated by setting CTDB_RUN_TIMEOUT_MONITOR
in /etc/sysconfig/ctdb .

Michael

dont use the pointer after it has been talloc_free()d.

From Rusty

It's much nicer for post-mortem debugging to have a body to examine.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

add an extra test for the bond devices and check that there is an active slave.
this to handle the case where all links do have a physical layer, but where all slaves have been disabled using ifdown

dont verify winbindd is running properly at startup

new version 1.0.103

move the check to skip vacuuming on persistent database to the ctdb_vacuuming_init() function

packaging: use githash in rpm release by default.

setting USE_GITHASH=no in the environment makes
makerpms.sh omit the git hash

Michael

server: disable vacuuming for persistent tdbs.

The vacuum process treats persistent databases the same as
non-persistent and thus ignores the extra state for transactions.
This way, it breaks the api-level transactions.

Michael

client: randomize the transaction_start retry loop:

instead of sleeping 1 second, sleep between 1 and 100 milliseconds

Michael

Revert "dont exit on a commit failure"

This reverts commit 4e9a3a5dc232bac12ab387ea0cf4f1b279bed5c1.

Transaction commit should not be allowed to fail.
This is a real error.

Michael

client: fix a race in the local race condition fix in transaction_start

The gap that remained is between checking whether a transaction commit
is in progress and taking the lock. Now we first take the lock and then
check whether a transaction commit is in progress. If so, we release the
lock, wait for one second and retry.

Michael

client: add a debug message when a transaction_commit needs to be retried

Michael

packaging(RPM): don't touch the run levels in ctdb install/udpate.

We should really leave it up to the administrator to decide
whether ctdb should be started automatically at boot-time.

Michael

start the syslog child a little later, after we have forked and detached from the local shell

create a child process to write to syslog.

use a udp socket on the ctdbd port to send messages to teh syslog child process for loggign.

we need this when syslog becomes "slow",   like very slow, and on boxes where syslog is limited to 100 lines per second and starts to block after that

server: fix debug message in trans2_commit (refusing persistent store during transaction)

log the right db_id
also log the client_id

Michael

client: log db_id as 8-digit hex in ctdb_transaction_fetch_start()

Michael

server: uniformly log db and client ids as 8-digit hex numbers in trans2_commit

Michael

server: line-wrap a debug statement in trans2_commit

Michael

server: output client_id in some debug messages in trans2_commit

Michael

server: fix a debug message in trans2_commit - log the correct db_id

Michael

server: extend a debug message in ctdb_control_trans2_error()

Michael

server: add positive debug statements to trans2_commit and trans2_finished

When the operation completed / started successfully.

Michael

client: improve "control timed out" debug message

* add __location__
* wrap overly long line
* print unsigned ints as unsigned (reqid, opcode, destnode)

Michael

server: trans2_active: don't report a transaction active on the node that performs the transaction

Otherwise a node can lock itself out, e.g. when a commit control times out...

Michael

new version 1.0.102

ensure tdb names end with .tdb. and any number of digits

vacuuming needed additional check before getting rid of the record; there is a gap between selecting the records and deleting them, therefore we have to check if the records still can be deleted when we actually are about to delete them

Revert "From Wolfgang M."

This reverts commit 5b70fa8cfd5916d3c212823ad5cc1b251ae175ed.

make the error logged when winbindd fails to access the dc during startup more scary and easier to spot in the logs

update the uptime command to indicate that time since last is either from alst recovery or from last failover

Revert "update the "uptime" command to indicate the "time since last" is the time since the last recovery OR failover."

This reverts commit 3b0d44497800a16400d05a30bdaf6e6c285d4b36.

update the manpage for "update" to indicate the "time since last" indicates
the time since the last recovery OR failover

update the "uptime" command to indicate the "time since last" is the time since the last recovery OR failover.

ctdb_client: reformat a comment slightly to enhance clearness.

Michael

client: fix race condition with concurrent transactions on the same node.

In ctdb_transaction_commit(), when the trans2_commit control fails, there
is a race condition in the 1 second sleep between the local transaction_cancel
and the call to ctdb_replay_transaction(): The database is not locked, and
neither is the transaction_lock record. So another client can start and possibly
complete a new transaction in this gap, but only on the same node: The locking
of the transaction_lock record on a different node which involves migration of
the record to the other node has been disabled by introduction of the
transaction_active flag on the db which closes precisely this gap from the start
of the commit until the call to TRANS2_FINISH or TRANS2_ERROR.
But this mechanism does not cover the case where a process on the same node
tries to start a transaction: There is no obstacle to locking the transaction_lock
record because the record does not need to be migrated.

This commit closes this race condition in ctdb_transaction_fetch_start()
by using the new ctdb_ctrl_transaction_active() call to ask the local
ctdb daemon whether it has a transaction running on the database.
If so, the check is repeated until the running transaction is done.

This does introduce an additional call to the local ctdbd when starting
transactions, but it does close the (hopefully) last race condition.

Michael

client: add ctdb_ctrl_transaction_active() which calls out to CTDB_TRANS2_ACTIVE

Michael

server: add a new ctdb control CTDB_TRANS2_ACTIVE

This aske the daemon wheter a transaction is currently active on a
given DB on that node. More precisely this asks for the transaction_active
flag in the ctdb_db_context that is set in the CTDB_TRANS2_COMMIT
control and cleared in the CTDB_TRANS2_ERROR or CTDB_TRANS2_FINISHED controls.

This will be useful for fixing race conditions in the transaction code.

Michael

version 1.0.101

create a separate context for non-monitor eventscripts so they dont collide

return 0 in the event script callback if it was aborted by a different script

new version   1.0.100

change the eventscript handling to allow EventScriptTimeout for each individual script isntead of for the entire set of scripts

restructure the talloc hierarchy to allow this

Test suite: Regression fix - wait_until should not run command in sub-shell.

Commit 25e82a8a667a54c6921ef076c63fdd738dd75d19 changed wait_until()
to protect the command it runs from "set -e" by running it in a
subshell.  This breaks uses where the command is expected to set
global variables.  For example, wait_until_get_src_socket lost the
value of $out from its call to get_src_socket().

The fix is to not be lazy and use a sub-shell!

Signed-off-by: Martin Schwenke <martin@meltin.net>

Enhance the logging fromeventscripts.
When a single script is finished, also log the name of the script, the duration it took and the return status.

In the loop where we signal back to the main daemon that the script finished, do this once every 100ms instead of once every 1 second

add a check that winbind can actually talk to teh dc during the startup event
and refuse to start up if it can not

temporarily try allowing clients to attach to databases even if the node is banned/stopped or inactive in any other way.

dont run the monitor event so frequently after a event has failed.

use _exit() instead of exit() when terminating an eventscript.

for debugging

add a global variable holding the pid of the main daemon.
change the tracking of time() in the event loop to only check/warn when called from the main daemon

ctdb_diagnostics: don't use hardcoded path to iptables

All event scripts use only the relative path, so we should
here.

Also PATH includes /sbin and /usr/sbin...

metze

ctdb_client: fix DEBUG statement in ctdb_ctrl_modflags()

metze

server: if takeover runs when the recovery master becomes unhealthy

The problem was this:

When the monitor event fails, the node->flags get updated,
and an update (containing the old and new flags) is sent to
the recovery master.

If the recovery master sends the update to itself (the same process),
it was compairing the node->flags variable with the received new flags.
This check always found both flag values to be equal
and never sets the rec->need_takeover_run variable to true.

There were two problem, first the push_flags_handler() function
didn't pass the received old flags.

And the ctdb_control_modflags() function ignored the received old flags.

metze

server: print out the full 64-bit srvid on 32-bit hosts

metze

tcp: don't log an error when we succefully bind to the desired address

metze

patch the event loop so we read the current time every iteration.

log an error if the clock jumps backwards
also log an error if the clock jumps >5 seconds forward (we assume here we will get at least one event every 5 seconds)

Suggestion from Volker,

make ctdb_queue_length() cheaper by using a counter variable instead of counting the number of packets each time.

disabel the multipath eventscript by default

update the manpage for ctdb setreclock

automatically re-activate the reclock file check if we set the reclock file to something

lower the log level of a debug message

Add a mechanism where we can register notifications to be sent out to a SRVID when the client disconnects.

The way to use this is from a client to :
1, first create a message handle and bind it to a SRVID
   A special prefix for the srvid space has been set aside for samba :
   Only samba is allowed to use srvid's with the top 32 bits set like this.
   The lower 32 bits are for samba to use internally.

2, register a "notification" using the new control :
                    CTDB_CONTROL_REGISTER_NOTIFY         = 114,
   This control takes as indata a structure like this :
struct ctdb_client_notify_register {
        uint64_t srvid;
        uint32_t len;
        uint8_t notify_data[1];
};

srvid is the srvid used in the space set aside above.
len and notify_data is an arbitrary blob.
When notifications are later sent out to all clients, this is the payload of that notification message.

If a client has registered with control 114 and then disconnects from ctdbd, ctdbd will broadcast a message to that srvid to all nodes/listeners in the cluster.

A client can resister itself with as many different srvid's it want, but this is handled through a linked list from the client structure so it mainly designed for "few notifications per client".

3, a client that no longer wants to have a notification set up can deregister using control
                    CTDB_CONTROL_DEREGISTER_NOTIFY       = 115,
which takes this as arguments :
struct ctdb_client_notify_deregister {
        uint64_t srvid;
};

When a client deregisters, there will no longer be sent a message to all other clients when this client disconnects from ctdbd.

when scripts timeout, log pstree to a file in /tmp and just log the filename in the messages file

set the eventscripts to timeout after 20 seconds
change the ban count to 10 failures before we ban by default

Merge commit 'martins/master'

new version 1.0.99

Merge commit 'origin/master'

Document onnode -n and -f options.

Signed-off-by: Martin Schwenke <martin@meltin.net>

if a lock wait child died/finished, we could have released the lockwait handle and set it to NULL before we call the destructors for releaseing the waiters.

The waiters reference the locakwait handle in order to remove itself from the li
nked list which caused a SEGV.

We dont actually need to remove ourselves from this list here since
if the parent freeze_handle holding the list is freed, then all waiters are rele
ased as well, and the only place we actually need to relink the waiter is in ctd
b_freeze_lock_handler, where we want to respond back to the clients and release
the waiters  but we still want to keep the freeze_handle hanging around.

From Volker L
Fix some warnings  and an incorrect check for a talloc failure

From Wolfgang M.

With the new vacuuming code, dont treat an invalid dmaster as fatal. Let it update to the new value insetad.

Merge commit 'origin/master'

Test suite: Remove the disable/enable monitor tests - they are useless.

Signed-off-by: Martin Schwenke <martin@meltin.net>

Test suite: Fix the timeouts on the skip share check tests.

The timeout for waiting for state changes isn't very predictable.  It
is "about" MonitorInterval seconds...  but can be longer given the
duration of eventscript runs and other things.  So, we change the
timeout to MonitorInterval + EventScriptTimeout, hoping it never takes
that long.

Move the eventscript installation/removal from the old fake-tests into
a function in the functions file.  Implement supporting functions to
create/remove/check-for various files that it handles.  Also add a
function that uses all of this that waits for the next monitor event
(but only if all other monitor events pass).

The final check in the skip share check tests uses the above and waits
for a monitor event, and then checks that the node is still healthy.

Also enhance the wait_until function to handle a command starting with
'!' (as a separate word) to make it easy to wait for a file not to
exist.

Signed-off-by: Martin Schwenke <martin@meltin.net>

During tests it is common to add/delete test eventscripts at runtime.
This can race with teh eventascript handling that does a :

list all scripts,   sort them,  then execute them

so trap status code 127 which means the script could not be executed (or /bin/sh does not exist) and treat it as not to cause the node to become unhealthy

lower the debug levels for the "create FD messages" so we dont fill up the logs.

When clients have blocked, perhaps because the node is banned or stopped and the client is blocked trying to tdb_fetch() a record, make sure we dont queue up too many REQ_MESSAGES.

    Add a new tunable to control the maximum queue size we allow to a blocked client before we start discarding REQ_MESSAGES instead of queueing them for delivery.

    This avoids having queued up very very large number of MESSAGES that samba semds
     between eachother to nodes that are blocked/banned/stopped for extended periods
    .

dont restart ctdb when installing the rpm

In ctdb_ltdb_store(), add a missing transaction_cancel when local store failed.

Spotted by Volker.

Michael

mprove the log message when we skip the ip allocation check from the recovery daemon.

we also skip this check if we are already in the process of performing an ip reallocation and not only when we are performing a full recovery.

treat interfaces with the name ethX* as bond devices