Deferred attach: create the timed event as a child context of the da context we want to delete.
Othwervise the da context can be timed out and talloc_free()d
but the event for this already freed object will still trigger,
causing a talloc error and shutdown.

CQ S1022515

IP reallocation. If a public address is already hosted on the node when we startup, log a warning message but do not cause the recovery to fail.

CQ S1022356

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

Vacuuming: initialize a variable to avoid a harmless valgrind hit

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

Dont allow clients to connect to databases untile we are well past and through
the initial recovery phase

CQ S1022412

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

vacuum: fix a comment typo

vacuum: use insert_record_into_delete_queue in ctdb_local_schedule_for_deletion.

This is to take advantage of the hash collision handling and logging
also in ctdb_local_schedule_for_deletion.

vacuum: refactor insert_record_into_delete_queue out of ctdb_control_schedule_for_deletion

vacuum: raise a debug level from INFO to DEBUG

when overwriting an existing entry in the delete_queue.

ctdb_ltdb_store_server: honour the AUTOMATIC record flag

Do not delete empty records that carry this flag but store
them and schedule them for deletetion. Do not store the flag
in the ltdb though, since this is internal only and should not
be visible to the client.

ltdb: add the CTDB_REC_FLAG_AUTOMATIC to the initial header in ctdb_ltdb_fetch()

Signals that this record was not created by a client level store.

ctdb_private.h: add record flag CTDB_REC_FLAG_AUTOMATIC

This is a flag that shall signa that a record has been automatically generated by ctdb
and not by an explicit client store operation. This will be used in the ctdb_ltdb_fetch
operation which stores an empty record with default initial header before trying to
migrate the record from the dmaster when the record does not exist in the local tdb.

ctdb_ltdb_store_server: add ability to send SCHEDULE_FOR_DELETION control to ctdb_ltdb_store.

ctdb_ltdb_store_server: Improve debug message in ctdb_ltdb_store when store or delete fails.

ctdb_ltdb_store_server: always store the data when ctdb_ltdb_store() is called from the client

This also fixes a segfault since ctdb_lmaster uses the vnn_map.

ctdb_ltdb_store_server: implement fastpath vacuuming deletion based on VACUUM_MIGRATED flag.

When the record has been obtained by the lmaster as part of the vacuuming-fetch
handler and it is empty and never been migrated with data, then such records
are deleted instead of being stored. These records have automatically been
deleted when leaving the former dmaster, so that they vanish for good when
hitting the lmaster in this way. This will reduces the load on traditional
vacuuming.

Pair-Programmed-With: Stefan Metzmacher <metze@samba.org>

ctdb_ltdb_store_server: delete an empty record that is safe to delete instead of storing locally.

When storing a record that is being migrated off to another node
and has never been migrated with data, then we can safely delete it
from the local tdb instead of storing the record with empty data.

Note: This record is not deleted if we are its lmaster or dmaster.

Pair-Programmed-With: Stefan Metzmacher <metze@samba.org>

server: Use the ctdb_ltdb_store_server() in the ctdb daemon for non-persistent dbs

This is realized by adding a ctdb_ltdb_store_fn function pointer to the db
context and filling it in the attach procedure for non-persistent dbs.

server: create a server variant ctdb_ltdb_store_server() of ctdb_ltdb_store().

This is supposed to contain logic for deleting records that are safe
to delete and scheduling records for deletion. It will be called in
server context for non-persistent databases instead of the standard
ctdb_ltdb_store() function.

daemon: fill ctdb->ctdbd_pid early

test: send SCHEDULE_FOR_DELETION control from randrec test.

client: add accessor function ctdb_header_from_record_handle().

vacuum: add ctdb_local_schedule_for_deletion()

server: implement a new control SCHEDULE_FOR_DELETION to fill the delete_queue.

control: add a new control opcode CTDB_CONTROL_SCHEDULE_FOR_DELETION

control: add macro CHECK_CONTROL_MIN_DATA_SIZE.

This is for the control dispatcher to check whether the input data has
a required minimum size.

vacuum: lower level of hash collision debug message to INFO

vacuum: add statistics output to the fast and full traverse runs.

vacuum: refactor insert_delete_record_data_into_tree() out of add_record_to_delete_tree()

for reuse in filling the delete_queue.

vacuum: change all Vacuum*Interval tunables to default to 10

So, by default we have a fastpath vacuuming every 10 seconds and
full blown db-traverse vacuuming once every 10 minutes.

vacuum: disable full db-traverse vacuuming runs when VacuumFastPathCount == 0

vacuum: Only run full vacuumig (db traverse) every VacuumFastPathCount times.

vacuum: reset the fast path count in the event handle if it exceeds the limit.

vacuum: bump the number of fast-path runs in the vacuum child destructor

vacuum: add a fast_path_count to the vacuum_handle.

Add a tunable VacuumFastPathCount.

This will control how many fast-path vacuuming runs wil have to
be done, before a full vacuuming will be triggered, i.e. one with
a db-traversal.

vacuum: traverse the delete_queue befor traversing the database.

vacuum: add delete_queue_traverse() for traversal of the delete_queue.

vacuum: reduce indentation in add_record_to_delete_tree()

This simplyfies the logical structure a bit by using early return.

vacuum: refactor new add_record_to_delete_tree() out of vacuum_traverse().

This will be reused by the traversal of the delete_queue list.

vacuum: skip adding records to list of records to send to lmaster on lmaster

This list is skipped afterwards when the lists are processed.

vacuum: refactor new add_record_to_vacuum_fetch_list() out of vacuum_traverse().

This is the function that fills the list of records to send to each lmaster
with the VACUUM_FETCH message.

This function will be reused in the traverse function for the delete_queue.

server: rename ctdb_repack_db() to ctdb_vacuum_and_repack_db()

When wiping a database, clear the delete_queue.

vaccum: clear the fast-path vacuuming delete_queue after creating the vacuuming child.

Maybe we should keep a copy for the case that the vacuuming fails?

When attaching to a non-persistent DB, initialize the delete_queue.

Add a delete_queue to the ctdb database context struct.

This list will be filled by the client using a new
delete control. The list will then be used to implement
a fast-path vacuuming that will traverse this list instead
of traversing the database.

call: becoming dmaster in VACUUM_MIGRATION, set the VACUUM_MIGRATED record flag

This temporary flag is used for the local record storage function to
decide whether to delete an empty record which has never been migrated
with data as part of the fast-path vacuuming process or, or to store
the record.

call: hand the submitted record_flags to local record storage function.

call: transfer the record flags in the ctdb call packets.

This way, the MIGRATED_WITH_DATA information can be transported
along with the records. This is important for vacuuming to function
properly.

The record flags are appended to the data section of the ctdb_req_dmaster
and ctdb_reply_dmaster structs.

Pair-Programmed-With: Stefan Metzmacher <metze@samba.org>

server: in the VACUUM_FETCH handler, add the VACUUM_MIGRAION to the call flags

This way, the records coming in via this handler, can be treated appropriately.
Namely, they can be deleted instead of being stored when the meet the fast-path
vacuuming criteria (empty, never migrated with data...)

add a new record flag CTDB_REC_FLAG_VACUUM_MIGRATED.

This is to be used internally. The purpose is to flag a record
as been migrated by a VACUUM_MIGRATION, which is triggered by
a VACUUM_FETCH message as part of the vacuuming. The local store
routine will base its decision whether to delete or to store
the record (among other things) upon the value of this flag.

This flag should never be stored in the local database copies.

call: Move definition of call flags down to the definition of the flags field.

call: add new call flag CTDB_CALL_FLAG_VACUUM_MIGRATION

This is to be used when the CTDB_SRVID_VACUUM_FETCH message
triggers the migration of deleted records to the lmaster.
The lmaster can then delete records that have not been
migrated with data instead of storing them.

recoverd: in a recovery, set the MIGRATED_WITH_DATA flag on all records

Those records that are kept after recovery, are non-empty, and
stored identically on all nodes. So this is as if they had been
migrated with data.

Pair-Programmed-With: Stefan Metzmacher <metze@samba.org>

server: when we migrate off a record with data, set the MIGRATED_WITH_DATA flag

vacuum: check lmaster against num_nodes instead of vnn_map->size

When lmaster is bigger than the biggest recorded node number,
then exit the traverse with error.

vacuum: reduce indentation of the loop sending VACUUM_FETCH controls

This slightly improves the code structure in that loop.

vacuum: correctly send TRY_DELETE_RECORDS ctrl to all active nodes

Originally, the control was sent to all records in the vnn_map, but
there was something still missing here:
When a node can not become lmaster (via CTDB_CAPABILITY_LMASTER=no)
then it will not be part of the vnn_map. So such a node would
be active but never receive the TRY_DELETE_RECORDS control from a
vacuuming run.

This is fixed in this change by correctly building the list of
active nodes first in the same way that the recovery process does it.

vacuum: in ctdb_vacuum_db, fix the length of the array of vacuum fetch lists

This patch fixes segfaults in the vacuum child when at least one
node has been stopped or removed from the cluster:

The size of the vnn_map is only the number of active nodes
(that can be lmaster). But the node numbers that are referenced
by the vnn_map spread over all configured nodes.

Since the array of vacuum fetch lists is referenced by the
key's lmaster's node number later on, the array needs to
be of size num_nodes instad of vnn_map->size.

Fix typos in a comment in vacuum_traverse.

tests: fix segfault in store test when connection to ctdbd failed.

tests: fix segfault in fetch_one test when connection to ctdbd fails

tests: fix segfault in fetch test when connection to ctdb failed.

tests: fix segfault in randrec test when connection to daemon fails.

gitignore: add tags file

gitignore: add vi swap files

server: add a comment explaining the call redirect logic in ctdb_call_send_redirect().

Restart recovery dameon if it looks like it hung.
Dont shutdown ctdbd completely, that only makes the problem worse.

If/when the recovery daemon terminates unexpectedly, try to restart it again from the main daemon instead of just shutting down the main deamon too.

While it does not address the reason for recovery daemon shutting down, it reduces the impact of such issues and makes the system more robust.

version 1.2.200

ATTACH_DB: simplify the code slightly and change the semantics to only
refuse a db attach during recovery IF we can associate the request from a
genuine real client instead of deciding this on whether client_id is zero or

This will suppress/avoid messages like these :
DB Attach to database %s refused. Can not match clientid...

Dont return error if trying to set db priority on a db that does not yet exist.
Just treat as a nop.

When the database is created later it will get its priority set properly.

new version 1.3.2

recover: finish pending trans3 commits when a recovery is finished.

When the end_recovery control is received, pending trans3 commits are
finished. During the recovery, all the actions like persistent_callback
and persistent_store_timeout had been disabled to let the recovery do
its job. After the recover is completed, send the reply to the waiting
clients.

persistent: add ctdb_persistent_finish_trans3_commits().

This function walks all databases and checks for running trans3 commits.
It sends replies to all of them (with error code) and ends them.
To be called when a recovery finishes.

daemon: correctly end a running trans3_commit if the client disconnects.

persistent: add a client context to the persistent_stat and track the db_id

The db_id is tracked in the client context as an indication that a
transaction commit is in progress. This is cleared in the persistent_state
talloc destructor.

This is in order to properly treat running trans3_commits if the client
disconnects.

persistent: reject trans3_control when a commit is already active.

This should actually never happen.

persistent: allocate the persistent state in the ctdb_db struct in trans3_commit

Make sure that ctdb_db->persistent_state is correctly NULL-ed when
the state is freed. This way, we can use ctdb_db->persistent_state
as an indication for whether a transaction commit is currently
running.

persistent: add a ctdb_db context to the ctdb_persistent_state struct.

persistent: add a ctdb_persistent_state member to the ctdb_db context.

To be used for tracking running transaction commits through recoveries.

persistent_callback: print "no error message given" instead of "(null)"

persistent: reduce indentation for the finishing moves in ctdb_persistent_callback

persistent: if a node failed to update_record, trigger a recovery

and stop processing of the update_record replies in order to let
the recovery finish the trans3_commit control.

persistent_store_timout: do not really time out the trans3_commit control in recovery

If a recovery was started, then all further processing of the update_record
controls sent by the trans3_commit control and timing them out is disabled.
The recovery should trigger sending the reply for the update record control
when finished.

persistent_callback: ignore the update-recordreturn code of remote node in recovery

If a recovery was started, then all further processing of the update_record
controls sent by the trans3_commit control is disabled. The recovery should
trigger sending the reply for the update record control when finished.

Deferred attach : at early startup, defer any db attach calls until we are out of recovery.

new version 1.3.1

50.samba   run the smbcontrol in the background. no need to block waiting for it.

Merge branch '1.3' of 10.1.1.27:/shared/ctdb/ctdb-git into 1.3

ctdb_req_dmaster from non-master

If we find a situatior where we get a stray packet with the wrong
dmaster, dont suicide with ctdb_fatal() since this is too disruptive.
Just drop the stray packet and force a recovery to make sure all is good again.

CQ S1022004

Merge branch '1.3' of 10.1.1.27:/shared/ctdb/ctdb-git into 1.3

Merge branch '1.3' of 10.1.1.27:/shared/ctdb/ctdb-git into 1.3

50.samba : Tell winbind about every time we add/remove and ip from the node

CQ S1021636

New branch 1.3

Revert "Dont allow client processes to attach to databases while we are still in recovery mode."

This reverts commit faf3b1542fd27b3ad32ac7b362ef39d8cb0b05ff.

git pull ... 1.2-splitbrain
does not do what I think it does.
Revert patch and pull it into the right branch instead.

Dont allow client processes to attach to databases while we are still in recovery mode.

The exception is the local recovery daemon which needs to be able to attach (==create) any missing databases during recovery. This process requires the use of the attach control.

New version 1.2.20

We default to non-deterministic ip now where ips are "sticky" and dont change
too much.
This means we can simplify the way we add ips significantly and stop
trying to move them.

We also check if the node already hosts the ip, in which case we used to return an error. Instead just print an error string but return 0, ok.
This makes it easier to script, and works around broken scripts.

CQ1021034

New version 1.2.19