[SCM] CTDB repository - branch 2.5 updated - ctdb-2.5.1-20-gfe68ada
Amitay Isaacs
amitay at samba.org
Sun Jan 19 21:27:30 MST 2014
The branch, 2.5 has been updated
via fe68ada3ea823771864fb5f9751eb041227740e2 (commit)
via 8066b9b9d2faa9e74a89939c1af1884bb052d6cd (commit)
via 490d4ae1ce74ca25d538cc7102ac463af4a8a3dc (commit)
via f450c23be123a630e0525ecb16bb94e82f0d2cfc (commit)
via 112bb7a5a756c3b9aa5d853998520eca00e3c8e5 (commit)
via 11f72ed1d26228b2db2ae72bfc7232625a8797ed (commit)
from 4121d33fcd53aa1fc241137724f30119aa750d34 (commit)
http://gitweb.samba.org/?p=ctdb.git;a=shortlog;h=2.5
- Log -----------------------------------------------------------------
commit fe68ada3ea823771864fb5f9751eb041227740e2
Author: Martin Schwenke <martin at meltin.net>
Date: Wed Dec 18 17:08:55 2013 +1100
eventscripts: Move all eventscript state under $CTDB_VARDIR/state
Services can be flagged for reconfigure when they release IPs at
shutdown. The flag is never removed and the service is prematurely
reconfigured during the first "ipreallocated" event, before any IPs
are hosted and before the "startup" event has actually started the
services.
$CTDB_VARDIR/state directly contained the service state subdirectories
and is already removed in the "init" event. Just push the service
state subdirectories down a level and put everything else in a
subdirectory.
This way all the eventscript state gets cleaned up every time CTDB
starts up.
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
Autobuild-User(master): Amitay Isaacs <amitay at samba.org>
Autobuild-Date(master): Fri Jan 17 09:58:26 CET 2014 on sn-devel-104
(Imported from commit b7bfe46636d07c71f83daff884ec339c9b4aee72)
commit 8066b9b9d2faa9e74a89939c1af1884bb052d6cd
Author: Martin Schwenke <martin at meltin.net>
Date: Wed Dec 18 15:37:11 2013 +1100
daemon: Untangle serialisation of 1st recovery -> startup -> monitor
At the moment ctdb_check_healthy() is overloaded to wait until the
first recovery is complete, handle the "startup" event and also
actually handle monitoring. This is untidy and hard to follow.
Instead, have the daemon explicitly wait for 1st recovery after the
"setup" event. When first recovery is complete, schedule a function
to handle the "startup" event. When the "startup" event succeeds then
explicitly enable monitoring.
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
(Imported from commit e6304d1e1adc86fc9c1199feb7b4802614fbc70f)
commit 490d4ae1ce74ca25d538cc7102ac463af4a8a3dc
Author: Martin Schwenke <martin at meltin.net>
Date: Mon Jan 13 16:34:50 2014 +1100
eventscripts: Print a count if killing TCP connections times out
Also update related test
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
(Imported from commit 50e00b3e5224d53df0f3cc882e71737f928e01cd)
commit f450c23be123a630e0525ecb16bb94e82f0d2cfc
Author: Martin Schwenke <martin at meltin.net>
Date: Wed Dec 18 13:51:22 2013 +1100
eventscripts: Reconfigure lock should be released quickly
Currently the lock is held until the corresponding eventscript
completes, since the process still exists. If the regular part of an
eventscript hangs then the lock might unnecessarily be held for a long
time. The pathological case is when a monitor event gets stuck in
D-wait state and the script times out but can't be killed so the lock
is still held. This can cause an unwanted monitor replay.
Change this so that the lock is released immediately after the
reconfiguration is complete.
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
(Imported from commit 8eb20c23476d390bb8a12ba01c9f06e7ac4a1453)
commit 112bb7a5a756c3b9aa5d853998520eca00e3c8e5
Author: Martin Schwenke <martin at meltin.net>
Date: Wed Dec 18 19:15:39 2013 +1100
recoverd: Do not refuse disabling takeover runs on inactive nodes
Failure might be expected when disabling takeover runs on banned
nodes, since they might be suffering from performance problems or
similar. More broadly, administrators who reconfigure a cluster that
isn't in a happy state aren't necessarily doing something sensible.
However, allowing takeover runs to be disabled on inactive nodes stops
reconfiguration of stopped nodes. This is probaby an unreasonable
limitation, so drop it.
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
(Imported from commit e77d5f99e396d71c1d354b3f8dc5ddf9ba5c5ee9)
commit 11f72ed1d26228b2db2ae72bfc7232625a8797ed
Author: Martin Schwenke <martin at meltin.net>
Date: Tue Nov 26 12:35:44 2013 +1100
recoverd: Ignore failed ipreallocated controls to inactive nodes
Currently timeouts for controls to inactive nodes can cause banning
credits to be applied. This should not happen.
Signed-off-by: Martin Schwenke <martin at meltin.net>
Reviewed-by: Amitay Isaacs <amitay at gmail.com>
(Imported from commit a955d0bedce888597633c0c88082f29e1d26e503)
-----------------------------------------------------------------------
Summary of changes:
config/functions | 24 +++-
include/ctdb_private.h | 2 +-
server/ctdb_daemon.c | 7 +-
server/ctdb_monitor.c | 136 ++++++++++++----------
server/ctdb_recoverd.c | 7 -
server/ctdb_takeover.c | 34 +++---
tests/eventscripts/10.interface.releaseip.011.sh | 2 +-
tests/eventscripts/60.nfs.multi.003.sh | 2 +-
tests/eventscripts/60.nfs.multi.004.sh | 2 +-
tests/eventscripts/60.nfs.multi.005.sh | 2 +-
10 files changed, 114 insertions(+), 104 deletions(-)
Changeset truncated at 500 lines:
diff --git a/config/functions b/config/functions
index 4430d86..1aad3ae 100755
--- a/config/functions
+++ b/config/functions
@@ -601,7 +601,7 @@ kill_tcp_connections ()
_count=$(($_count + 1))
if [ $_count -gt 3 ] ; then
- echo "Timed out killing tcp connections for IP $_ip"
+ echo "Timed out killing tcp connections for IP $_ip ($_remaining remaining)"
return
fi
@@ -986,12 +986,12 @@ ctdb_check_counter () {
########################################################
-ctdb_status_dir="$CTDB_VARDIR/status"
-ctdb_fail_dir="$CTDB_VARDIR/failcount"
+ctdb_status_dir="$CTDB_VARDIR/state/service_status"
+ctdb_fail_dir="$CTDB_VARDIR/state/failcount"
ctdb_setup_service_state_dir ()
{
- service_state_dir="$CTDB_VARDIR/state/${1:-${service_name}}"
+ service_state_dir="$CTDB_VARDIR/state/service_state/${1:-${service_name}}"
mkdir -p "$service_state_dir" || {
echo "Error creating state dir \"$service_state_dir\""
exit 1
@@ -1001,7 +1001,7 @@ ctdb_setup_service_state_dir ()
########################################################
# Managed status history, for auto-start/stop
-ctdb_managed_dir="$CTDB_VARDIR/managed_history"
+ctdb_managed_dir="$CTDB_VARDIR/state/managed_history"
_ctdb_managed_common ()
{
@@ -1106,7 +1106,7 @@ service_reconfigure ()
:
}
-ctdb_reconfigure_try_lock ()
+ctdb_reconfigure_take_lock ()
{
_ctdb_service_reconfigure_common
_lock="${_d}/reconfigure_lock"
@@ -1133,6 +1133,14 @@ ctdb_reconfigure_try_lock ()
) <"$_lock"
}
+ctdb_reconfigure_release_lock ()
+{
+ _ctdb_service_reconfigure_common
+ _lock="${_d}/reconfigure_lock"
+
+ rm -f "$_lock"
+}
+
ctdb_replay_monitor_status ()
{
echo "Replaying previous status for this script due to reconfigure..."
@@ -1182,7 +1190,7 @@ ctdb_service_check_reconfigure ()
*) return 0 ;;
esac
- if ctdb_reconfigure_try_lock ; then
+ if ctdb_reconfigure_take_lock ; then
# No events covered by this function are running, so proceed
# with gay abandon.
case "$event_name" in
@@ -1196,6 +1204,8 @@ ctdb_service_check_reconfigure ()
fi
;;
esac
+
+ ctdb_reconfigure_release_lock
else
# Somebody else is running an event we don't want to collide
# with. We proceed with caution.
diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index 5c18d87..eba4045 100644
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -1067,7 +1067,7 @@ uint32_t ctdb_get_num_active_nodes(struct ctdb_context *ctdb);
void ctdb_disable_monitoring(struct ctdb_context *ctdb);
void ctdb_enable_monitoring(struct ctdb_context *ctdb);
void ctdb_stop_monitoring(struct ctdb_context *ctdb);
-void ctdb_start_monitoring(struct ctdb_context *ctdb);
+void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb);
void ctdb_start_tcp_tickle_update(struct ctdb_context *ctdb);
void ctdb_send_keepalive(struct ctdb_context *ctdb, uint32_t destnode);
void ctdb_start_keepalive(struct ctdb_context *ctdb);
diff --git a/server/ctdb_daemon.c b/server/ctdb_daemon.c
index aa0cedb..a83a855 100644
--- a/server/ctdb_daemon.c
+++ b/server/ctdb_daemon.c
@@ -84,9 +84,6 @@ static void ctdb_start_periodic_events(struct ctdb_context *ctdb)
/* start monitoring for connected/disconnected nodes */
ctdb_start_keepalive(ctdb);
- /* start monitoring for node health */
- ctdb_start_monitoring(ctdb);
-
/* start periodic update of tcp tickle lists */
ctdb_start_tcp_tickle_update(ctdb);
@@ -1048,8 +1045,6 @@ static void ctdb_setup_event_callback(struct ctdb_context *ctdb, int status,
}
ctdb_run_notification_script(ctdb, "setup");
- ctdb_set_runstate(ctdb, CTDB_RUNSTATE_FIRST_RECOVERY);
-
/* tell all other nodes we've just started up */
ctdb_daemon_send_control(ctdb, CTDB_BROADCAST_ALL,
0, CTDB_CONTROL_STARTUP, 0,
@@ -1063,6 +1058,8 @@ static void ctdb_setup_event_callback(struct ctdb_context *ctdb, int status,
}
ctdb_start_periodic_events(ctdb);
+
+ ctdb_wait_for_first_recovery(ctdb);
}
static struct timeval tevent_before_wait_ts;
diff --git a/server/ctdb_monitor.c b/server/ctdb_monitor.c
index 2b52fd0..9b8df6d 100644
--- a/server/ctdb_monitor.c
+++ b/server/ctdb_monitor.c
@@ -196,6 +196,8 @@ after_change_status:
}
+static void ctdb_run_startup(struct event_context *ev, struct timed_event *te,
+ struct timeval t, void *private_data);
/*
called when the startup event script finishes
*/
@@ -203,18 +205,58 @@ static void ctdb_startup_callback(struct ctdb_context *ctdb, int status, void *p
{
if (status != 0) {
DEBUG(DEBUG_ERR,("startup event failed\n"));
- } else if (status == 0) {
- DEBUG(DEBUG_NOTICE,("startup event OK - enabling monitoring\n"));
- ctdb_set_runstate(ctdb, CTDB_RUNSTATE_RUNNING);
- ctdb->monitor->next_interval = 2;
- ctdb_run_notification_script(ctdb, "startup");
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ timeval_current_ofs(5, 0),
+ ctdb_run_startup, ctdb);
+ return;
}
- event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ DEBUG(DEBUG_NOTICE,("startup event OK - enabling monitoring\n"));
+ ctdb_set_runstate(ctdb, CTDB_RUNSTATE_RUNNING);
+ ctdb->monitor->next_interval = 2;
+ ctdb_run_notification_script(ctdb, "startup");
+
+ ctdb->monitor->monitoring_mode = CTDB_MONITORING_ACTIVE;
+
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
timeval_current_ofs(ctdb->monitor->next_interval, 0),
ctdb_check_health, ctdb);
}
+static void ctdb_run_startup(struct event_context *ev, struct timed_event *te,
+ struct timeval t, void *private_data)
+{
+ struct ctdb_context *ctdb = talloc_get_type(private_data,
+ struct ctdb_context);
+ int ret;
+
+ /* This is necessary to avoid the "startup" event colliding
+ * with the "ipreallocated" event from the takeover run
+ * following the first recovery. We might as well serialise
+ * these things if we can.
+ */
+ if (ctdb->runstate < CTDB_RUNSTATE_STARTUP) {
+ DEBUG(DEBUG_NOTICE,
+ ("Not yet in startup runstate. Wait one more second\n"));
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ timeval_current_ofs(1, 0),
+ ctdb_run_startup, ctdb);
+ return;
+ }
+
+ DEBUG(DEBUG_NOTICE,("Running the \"startup\" event.\n"));
+ ret = ctdb_event_script_callback(ctdb,
+ ctdb->monitor->monitor_context,
+ ctdb_startup_callback,
+ ctdb, CTDB_EVENT_STARTUP, "%s", "");
+
+ if (ret != 0) {
+ DEBUG(DEBUG_ERR,("Unable to launch startup event script\n"));
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ timeval_current_ofs(5, 0),
+ ctdb_run_startup, ctdb);
+ }
+}
/*
wait until we have finished initial recoveries before we start the
@@ -302,8 +344,7 @@ static void ctdb_wait_until_recovered(struct event_context *ev, struct timed_eve
ctdb->db_persistent_check_errors = 0;
event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current(),
- ctdb_check_health, ctdb);
+ timeval_current(), ctdb_run_startup, ctdb);
}
@@ -314,65 +355,41 @@ static void ctdb_check_health(struct event_context *ev, struct timed_event *te,
struct timeval t, void *private_data)
{
struct ctdb_context *ctdb = talloc_get_type(private_data, struct ctdb_context);
+ bool skip_monitoring = false;
int ret = 0;
- if (ctdb->runstate < CTDB_RUNSTATE_STARTUP) {
- DEBUG(DEBUG_NOTICE,("Not yet in startup runstate. Wait one more second\n"));
- event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(1, 0),
- ctdb_check_health, ctdb);
- return;
- }
-
if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL ||
- (ctdb->monitor->monitoring_mode == CTDB_MONITORING_DISABLED &&
- ctdb->runstate == CTDB_RUNSTATE_RUNNING)) {
- event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(ctdb->monitor->next_interval, 0),
- ctdb_check_health, ctdb);
- return;
- }
-
- if (ctdb->runstate == CTDB_RUNSTATE_STARTUP) {
- DEBUG(DEBUG_NOTICE,("Recoveries finished. Running the \"startup\" event.\n"));
- ret = ctdb_event_script_callback(ctdb,
- ctdb->monitor->monitor_context, ctdb_startup_callback,
- ctdb,
- CTDB_EVENT_STARTUP, "%s", "");
+ ctdb->monitor->monitoring_mode == CTDB_MONITORING_DISABLED) {
+ skip_monitoring = true;
} else {
int i;
- int skip_monitoring = 0;
-
- if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL) {
- skip_monitoring = 1;
- DEBUG(DEBUG_ERR,("Skip monitoring during recovery\n"));
- }
for (i=1; i<=NUM_DB_PRIORITIES; i++) {
if (ctdb->freeze_handles[i] != NULL) {
- DEBUG(DEBUG_ERR,("Skip monitoring since databases are frozen\n"));
- skip_monitoring = 1;
+ DEBUG(DEBUG_ERR,
+ ("Skip monitoring since databases are frozen\n"));
+ skip_monitoring = true;
break;
}
}
- if (skip_monitoring != 0) {
- event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(ctdb->monitor->next_interval, 0),
- ctdb_check_health, ctdb);
- return;
- } else {
- ret = ctdb_event_script_callback(ctdb,
- ctdb->monitor->monitor_context, ctdb_health_callback,
- ctdb,
- CTDB_EVENT_MONITOR, "%s", "");
- }
}
+ if (skip_monitoring) {
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ timeval_current_ofs(ctdb->monitor->next_interval, 0),
+ ctdb_check_health, ctdb);
+ return;
+ }
+
+ ret = ctdb_event_script_callback(ctdb,
+ ctdb->monitor->monitor_context,
+ ctdb_health_callback,
+ ctdb, CTDB_EVENT_MONITOR, "%s", "");
if (ret != 0) {
DEBUG(DEBUG_ERR,("Unable to launch monitor event script\n"));
ctdb->monitor->next_interval = 5;
- event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(5, 0),
- ctdb_check_health, ctdb);
+ event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
+ timeval_current_ofs(5, 0),
+ ctdb_check_health, ctdb);
}
}
@@ -412,26 +429,19 @@ void ctdb_stop_monitoring(struct ctdb_context *ctdb)
/*
start watching for nodes that might be dead
*/
-void ctdb_start_monitoring(struct ctdb_context *ctdb)
+void ctdb_wait_for_first_recovery(struct ctdb_context *ctdb)
{
- if (ctdb->monitor != NULL) {
- return;
- }
+ ctdb_set_runstate(ctdb, CTDB_RUNSTATE_FIRST_RECOVERY);
ctdb->monitor = talloc(ctdb, struct ctdb_monitor_state);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor);
- ctdb->monitor->next_interval = 5;
-
ctdb->monitor->monitor_context = talloc_new(ctdb->monitor);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor->monitor_context);
event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(1, 0),
- ctdb_wait_until_recovered, ctdb);
-
- ctdb->monitor->monitoring_mode = CTDB_MONITORING_ACTIVE;
- DEBUG(DEBUG_NOTICE,("Monitoring has been started\n"));
+ timeval_current_ofs(1, 0),
+ ctdb_wait_until_recovered, ctdb);
}
diff --git a/server/ctdb_recoverd.c b/server/ctdb_recoverd.c
index c5cd36c..179eb7d 100644
--- a/server/ctdb_recoverd.c
+++ b/server/ctdb_recoverd.c
@@ -2498,13 +2498,6 @@ static void disable_takeover_runs_handler(struct ctdb_context *ctdb,
goto done;
}
- if (rec->node_flags & NODE_FLAGS_INACTIVE) {
- DEBUG(DEBUG_ERR,
- ("Refusing to disable takeover runs on inactive node\n"));
- ret = -EHOSTDOWN;
- goto done;
- }
-
if (rec->takeover_run_in_progress) {
DEBUG(DEBUG_ERR,
("Unable to disable takeover runs - in progress\n"));
diff --git a/server/ctdb_takeover.c b/server/ctdb_takeover.c
index 0d859f9..b918e5a 100644
--- a/server/ctdb_takeover.c
+++ b/server/ctdb_takeover.c
@@ -2552,6 +2552,23 @@ static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
struct iprealloc_callback_data *cd =
(struct iprealloc_callback_data *)callback;
+ numnodes = talloc_array_length(cd->retry_nodes);
+ if (pnn > numnodes) {
+ DEBUG(DEBUG_ERR,
+ ("ipreallocated failure from node %d, "
+ "but only %d nodes in nodemap\n",
+ pnn, numnodes));
+ return;
+ }
+
+ /* Can't run the "ipreallocated" event on a INACTIVE node */
+ if (cd->nodemap->nodes[pnn].flags & NODE_FLAGS_INACTIVE) {
+ DEBUG(DEBUG_WARNING,
+ ("ipreallocated failed on inactive node %d, ignoring\n",
+ pnn));
+ return;
+ }
+
switch (res) {
case -ETIME:
/* If the control timed out then that's a real error,
@@ -2568,23 +2585,6 @@ static void iprealloc_fail_callback(struct ctdb_context *ctdb, uint32_t pnn,
* because the error codes are all folded down to -1.
* Consider retrying using EVENTSCRIPT control...
*/
-
- numnodes = talloc_array_length(cd->retry_nodes);
- if (pnn > numnodes) {
- DEBUG(DEBUG_ERR,
- ("ipreallocated failure from node %d, but only %d nodes in nodemap\n",
- pnn, numnodes));
- return;
- }
-
- /* Can't run the "ipreallocated" event on a INACTIVE node */
- if (cd->nodemap->nodes[pnn].flags & NODE_FLAGS_INACTIVE) {
- DEBUG(DEBUG_ERR,
- ("ipreallocated failure from node %d, but node is inactive - not flagging a retry\n",
- pnn));
- return;
- }
-
DEBUG(DEBUG_WARNING,
("ipreallocated failure from node %d, flagging retry\n",
pnn));
diff --git a/tests/eventscripts/10.interface.releaseip.011.sh b/tests/eventscripts/10.interface.releaseip.011.sh
index 17b7421..e1514ee 100755
--- a/tests/eventscripts/10.interface.releaseip.011.sh
+++ b/tests/eventscripts/10.interface.releaseip.011.sh
@@ -34,7 +34,7 @@ $out
Waiting for 1 connections to be killed for IP ${ip}
Waiting for 1 connections to be killed for IP ${ip}
Waiting for 1 connections to be killed for IP ${ip}
-Timed out killing tcp connections for IP $ip
+Timed out killing tcp connections for IP $ip (1 remaining)
EOF
simple_test $dev $ip $bits
diff --git a/tests/eventscripts/60.nfs.multi.003.sh b/tests/eventscripts/60.nfs.multi.003.sh
index 653dece..aed1f34 100755
--- a/tests/eventscripts/60.nfs.multi.003.sh
+++ b/tests/eventscripts/60.nfs.multi.003.sh
@@ -16,7 +16,7 @@ simple_test_event "takeip" $public_address
ctdb_fake_scriptstatus 1 "ERROR" "$err"
-eventscript_call ctdb_reconfigure_try_lock
+eventscript_call ctdb_reconfigure_take_lock
required_result 1 <<EOF
Replaying previous status for this script due to reconfigure...
diff --git a/tests/eventscripts/60.nfs.multi.004.sh b/tests/eventscripts/60.nfs.multi.004.sh
index 43323cf..e07f8d5 100755
--- a/tests/eventscripts/60.nfs.multi.004.sh
+++ b/tests/eventscripts/60.nfs.multi.004.sh
@@ -16,7 +16,7 @@ simple_test_event "takeip" $public_address
ctdb_fake_scriptstatus -62 "TIMEDOUT" "$err"
-eventscript_call ctdb_reconfigure_try_lock
+eventscript_call ctdb_reconfigure_take_lock
required_result 1 <<EOF
Replaying previous status for this script due to reconfigure...
diff --git a/tests/eventscripts/60.nfs.multi.005.sh b/tests/eventscripts/60.nfs.multi.005.sh
index 9816bec..da334fd 100755
--- a/tests/eventscripts/60.nfs.multi.005.sh
+++ b/tests/eventscripts/60.nfs.multi.005.sh
@@ -16,7 +16,7 @@ simple_test_event "takeip" $public_address
ctdb_fake_scriptstatus -8 "DISABLED" "$err"
-eventscript_call ctdb_reconfigure_try_lock
+eventscript_call ctdb_reconfigure_take_lock
ok <<EOF
Replaying previous status for this script due to reconfigure...
--
CTDB repository
More information about the samba-cvs
mailing list