[SCM] CTDB repository - branch master updated - 1.0.99-37-gfa34e8a
Ronnie Sahlberg
sahlberg at samba.org
Tue Oct 27 23:11:26 MDT 2009
The branch, master has been updated
via fa34e8a5d588026029dca949151697817fe7f127 (commit)
via 64da4402c6ad485f1d0a604878a7b0c01a0ea5f0 (commit)
via 6a1f7a7b1b3a0b8f89998db8fdad83bbb4e9b5a5 (commit)
from 4037b6e73a819a8e2463dfe0959b42875e05e106 (commit)
http://gitweb.samba.org/?p=sahlberg/ctdb.git;a=shortlog;h=master
- Log -----------------------------------------------------------------
commit fa34e8a5d588026029dca949151697817fe7f127
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Wed Oct 28 16:18:28 2009 +1100
new version 1.0.100
commit 64da4402c6ad485f1d0a604878a7b0c01a0ea5f0
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Wed Oct 28 16:11:54 2009 +1100
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
commit 6a1f7a7b1b3a0b8f89998db8fdad83bbb4e9b5a5
Author: Ronnie Sahlberg <ronniesahlberg at gmail.com>
Date: Wed Oct 28 09:07:43 2009 +1100
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
-----------------------------------------------------------------------
Summary of changes:
include/ctdb_private.h | 4 +-
packaging/RPM/ctdb.spec | 15 ++++-
server/ctdb_monitor.c | 28 ++++----
server/ctdb_recover.c | 6 +-
server/ctdb_takeover.c | 6 +-
server/ctdb_tunables.c | 2 +-
server/eventscript.c | 185 +++++++++++++++++++++++++++++------------------
7 files changed, 152 insertions(+), 94 deletions(-)
Changeset truncated at 500 lines:
diff --git a/include/ctdb_private.h b/include/ctdb_private.h
index e73913a..7ee3db5 100644
--- a/include/ctdb_private.h
+++ b/include/ctdb_private.h
@@ -450,8 +450,8 @@ struct ctdb_context {
TALLOC_CTX *eventscripts_ctx; /* a context to hold data for the RUN_EVENTSCRIPTS control */
uint32_t *recd_ping_count;
TALLOC_CTX *release_ips_ctx; /* a context used to automatically drop all IPs if we fail to recover the node */
- TALLOC_CTX *script_monitoring_ctx; /* a context where we store results while running the monitor event */
- TALLOC_CTX *last_monitoring_ctx;
+ TALLOC_CTX *script_monitor_ctx; /* a context where we store results while running the monitor event */
+ TALLOC_CTX *last_monitor_ctx;
TALLOC_CTX *banning_ctx;
};
diff --git a/packaging/RPM/ctdb.spec b/packaging/RPM/ctdb.spec
index d243888..f5808e6 100644
--- a/packaging/RPM/ctdb.spec
+++ b/packaging/RPM/ctdb.spec
@@ -4,7 +4,7 @@ Summary: Clustered TDB
Vendor: Samba Team
Packager: Samba Team <samba at samba.org>
Name: ctdb
-Version: 1.0.99
+Version: 1.0.100
Release: 1
Epoch: 0
License: GNU GPL version 3
@@ -127,6 +127,19 @@ exit 0
%{_libdir}/pkgconfig/ctdb.pc
%changelog
+* Wed Oct 28 2009 : Version 1.0.100
+ - Change eventscript handling to allow EventScriptTimeout for each individual script instead of for all scripts as a whole.
+ - Enhanced logging from the eventscripts, log the name and the duration for each script as it finishes.
+ - Add a check to use wbinfo -t for the startup event of samba
+ - TEMP: allow clients to attach to databases even when teh node is in recovery mode
+ - dont run the monitor event as frequently after an event has failed
+ - DEBUG: in the eventloops, check the local time and warn if the time changes backward or rapidly forward
+ - From Metze, fix a bug where recovery master becoming unhealthy did not trigger an ip failover.
+ - Disable the multipath script by default
+ - Automatically re-activate the reclock checking if the reclock file is specified at runtime. Update manpage to reflect this.
+ - Add a mechanism where samba can register a SRVID and if samba unexpectedly disconnects, a message will be broadcasted to all other samba daemons.
+ - Log the pstree on hung scripts to a file in /tmp isntead of /var/log/messages
+ - change ban count before unhealthy/banned to 10
* Thu Oct 22 2009 : Version 1.0.99
- Fix a SEGV in the new db priority code.
- From Wolfgang : eliminate a ctdb_fatal() if there is a dmaster violation detected.
diff --git a/server/ctdb_monitor.c b/server/ctdb_monitor.c
index f2d6d18..efba8f9 100644
--- a/server/ctdb_monitor.c
+++ b/server/ctdb_monitor.c
@@ -194,7 +194,7 @@ static void ctdb_startup_callback(struct ctdb_context *ctdb, int status, void *p
} else if (status == 0) {
DEBUG(DEBUG_NOTICE,("startup event OK - enabling monitoring\n"));
ctdb->done_startup = true;
- ctdb->monitor->next_interval = 1;
+ ctdb->monitor->next_interval = 5;
ctdb_run_notification_script(ctdb, "startup");
}
@@ -211,7 +211,7 @@ 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);
- int ret;
+ int ret = 0;
if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL ||
(ctdb->monitor->monitoring_mode == CTDB_MONITORING_DISABLED && ctdb->done_startup)) {
@@ -223,7 +223,7 @@ static void ctdb_check_health(struct event_context *ev, struct timed_event *te,
if (!ctdb->done_startup) {
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
ctdb->monitor->monitor_context, ctdb_startup_callback,
ctdb, "startup");
} else {
@@ -241,26 +241,26 @@ static void ctdb_check_health(struct event_context *ev, struct timed_event *te,
break;
}
}
- if (skip_monitoring) {
+ 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,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
- ctdb->monitor->monitor_context, ctdb_health_callback,
- ctdb, "monitor");
+ timeval_set(ctdb->tunable.script_timeout, 0),
+ ctdb->monitor->monitor_context, ctdb_health_callback,
+ ctdb, "monitor");
}
}
if (ret != 0) {
DEBUG(DEBUG_ERR,("Unable to launch monitor event script\n"));
- ctdb->monitor->next_interval = 1;
+ ctdb->monitor->next_interval = 5;
event_add_timed(ctdb->ev, ctdb->monitor->monitor_context,
- timeval_current_ofs(1, 0),
- ctdb_check_health, ctdb);
- }
+ timeval_current_ofs(5, 0),
+ ctdb_check_health, ctdb);
+ }
}
/*
@@ -279,7 +279,7 @@ void ctdb_disable_monitoring(struct ctdb_context *ctdb)
void ctdb_enable_monitoring(struct ctdb_context *ctdb)
{
ctdb->monitor->monitoring_mode = CTDB_MONITORING_ACTIVE;
- ctdb->monitor->next_interval = 2;
+ ctdb->monitor->next_interval = 5;
DEBUG(DEBUG_INFO,("Monitoring has been enabled\n"));
}
@@ -292,7 +292,7 @@ void ctdb_stop_monitoring(struct ctdb_context *ctdb)
ctdb->monitor->monitor_context = NULL;
ctdb->monitor->monitoring_mode = CTDB_MONITORING_DISABLED;
- ctdb->monitor->next_interval = 1;
+ ctdb->monitor->next_interval = 5;
DEBUG(DEBUG_NOTICE,("Monitoring has been stopped\n"));
}
@@ -310,7 +310,7 @@ void ctdb_start_monitoring(struct ctdb_context *ctdb)
ctdb->monitor = talloc(ctdb, struct ctdb_monitor_state);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor);
- ctdb->monitor->next_interval = 1;
+ ctdb->monitor->next_interval = 5;
ctdb->monitor->monitor_context = talloc_new(ctdb->monitor);
CTDB_NO_MEMORY_FATAL(ctdb, ctdb->monitor->monitor_context);
diff --git a/server/ctdb_recover.c b/server/ctdb_recover.c
index 862168e..ccac8e6 100644
--- a/server/ctdb_recover.c
+++ b/server/ctdb_recover.c
@@ -963,7 +963,7 @@ int32_t ctdb_control_end_recovery(struct ctdb_context *ctdb,
ctdb_disable_monitoring(ctdb);
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
state,
ctdb_end_recovery_callback,
state, "recovered");
@@ -1017,7 +1017,7 @@ int32_t ctdb_control_start_recovery(struct ctdb_context *ctdb,
ctdb_disable_monitoring(ctdb);
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
state,
ctdb_start_recovery_callback,
state, "startrecovery");
@@ -1231,7 +1231,7 @@ int32_t ctdb_control_stop_node(struct ctdb_context *ctdb, struct ctdb_req_contro
ctdb_disable_monitoring(ctdb);
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
state,
ctdb_stop_node_callback,
state, "stopped");
diff --git a/server/ctdb_takeover.c b/server/ctdb_takeover.c
index 559f7fb..a140578 100644
--- a/server/ctdb_takeover.c
+++ b/server/ctdb_takeover.c
@@ -235,7 +235,7 @@ int32_t ctdb_control_takeover_ip(struct ctdb_context *ctdb,
vnn->iface));
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
state, takeover_ip_callback, state,
"takeip %s %s %u",
vnn->iface,
@@ -391,7 +391,7 @@ int32_t ctdb_control_release_ip(struct ctdb_context *ctdb,
state->vnn = vnn;
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
state, release_ip_callback, state,
"releaseip %s %s %u",
vnn->iface,
@@ -2094,7 +2094,7 @@ int32_t ctdb_control_del_public_address(struct ctdb_context *ctdb, TDB_DATA inda
DLIST_REMOVE(ctdb->vnn, vnn);
ret = ctdb_event_script_callback(ctdb,
- timeval_current_ofs(ctdb->tunable.script_timeout, 0),
+ timeval_set(ctdb->tunable.script_timeout, 0),
mem_ctx, delete_ip_callback, mem_ctx,
"releaseip %s %s %u",
vnn->iface,
diff --git a/server/ctdb_tunables.c b/server/ctdb_tunables.c
index 8ad4cde..0bf87b9 100644
--- a/server/ctdb_tunables.c
+++ b/server/ctdb_tunables.c
@@ -37,7 +37,7 @@ static const struct {
{ "TakeoverTimeout", 5, offsetof(struct ctdb_tunable, takeover_timeout) },
{ "MonitorInterval", 15, offsetof(struct ctdb_tunable, monitor_interval) },
{ "TickleUpdateInterval",20, offsetof(struct ctdb_tunable, tickle_update_interval) },
- { "EventScriptTimeout", 20, offsetof(struct ctdb_tunable, script_timeout) },
+ { "EventScriptTimeout", 30, offsetof(struct ctdb_tunable, script_timeout) },
{ "EventScriptBanCount", 10, offsetof(struct ctdb_tunable, script_ban_count) },
{ "EventScriptUnhealthyOnTimeout", 0, offsetof(struct ctdb_tunable, script_unhealthy_on_timeout) },
{ "RecoveryGracePeriod", 120, offsetof(struct ctdb_tunable, recovery_grace_period) },
diff --git a/server/eventscript.c b/server/eventscript.c
index b4f5e2a..0fea281 100644
--- a/server/eventscript.c
+++ b/server/eventscript.c
@@ -32,6 +32,8 @@ static struct {
const char *script_running;
} child_state;
+static void ctdb_event_script_timeout(struct event_context *ev, struct timed_event *te, struct timeval t, void *p);
+
/*
ctdbd sends us a SIGTERM when we should time out the current script
*/
@@ -63,6 +65,8 @@ struct ctdb_event_script_state {
int fd[2];
void *private_data;
const char *options;
+ struct timed_event *te;
+ struct timeval timeout;
};
@@ -77,11 +81,12 @@ struct ctdb_monitor_script_status {
char *output;
};
-struct ctdb_monitoring_status {
+struct ctdb_monitor_status {
struct timeval start;
struct timeval finished;
int32_t status;
struct ctdb_monitor_script_status *scripts;
+ struct ctdb_event_script_state *state;
};
@@ -90,9 +95,7 @@ struct ctdb_monitoring_status {
*/
int ctdb_log_event_script_output(struct ctdb_context *ctdb, char *str, uint16_t len)
{
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
struct ctdb_monitor_script_status *script;
if (monitoring_status == NULL) {
@@ -118,21 +121,15 @@ int ctdb_log_event_script_output(struct ctdb_context *ctdb, char *str, uint16_t
*/
int32_t ctdb_control_event_script_init(struct ctdb_context *ctdb)
{
- struct ctdb_monitoring_status *monitoring_status;
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
DEBUG(DEBUG_INFO, ("event script init called\n"));
- if (ctdb->script_monitoring_ctx != NULL) {
- talloc_free(ctdb->script_monitoring_ctx);
- ctdb->script_monitoring_ctx = NULL;
- }
- monitoring_status = talloc_zero(ctdb, struct ctdb_monitoring_status);
if (monitoring_status == NULL) {
- DEBUG(DEBUG_ERR, (__location__ " ERROR: Failed to talloc script_monitoring context\n"));
- return -1;
+ DEBUG(DEBUG_ERR,(__location__ " Init called when context is NULL\n"));
+ return 0;
}
- ctdb->script_monitoring_ctx = monitoring_status;
monitoring_status->start = timeval_current();
return 0;
@@ -145,9 +142,8 @@ int32_t ctdb_control_event_script_init(struct ctdb_context *ctdb)
int32_t ctdb_control_event_script_start(struct ctdb_context *ctdb, TDB_DATA indata)
{
const char *name = (const char *)indata.dptr;
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
+ struct ctdb_event_script_state *state;
struct ctdb_monitor_script_status *script;
DEBUG(DEBUG_INFO, ("event script start called : %s\n", name));
@@ -169,6 +165,19 @@ int32_t ctdb_control_event_script_start(struct ctdb_context *ctdb, TDB_DATA inda
script->start = timeval_current();
monitoring_status->scripts = script;
+ state = monitoring_status->state;
+ if (state != NULL) {
+ /* reset the timeout for the next eventscript */
+ if (!timeval_is_zero(&state->timeout)) {
+ if (state->te != NULL) {
+ talloc_free(state->te);
+ state->te = NULL;
+ }
+ state->te = event_add_timed(ctdb->ev, state, timeval_current_ofs(state->timeout.tv_sec, state->timeout.tv_usec), ctdb_event_script_timeout, state);
+ }
+
+ }
+
return 0;
}
@@ -178,13 +187,9 @@ int32_t ctdb_control_event_script_start(struct ctdb_context *ctdb, TDB_DATA inda
int32_t ctdb_control_event_script_stop(struct ctdb_context *ctdb, TDB_DATA indata)
{
int32_t res = *((int32_t *)indata.dptr);
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
struct ctdb_monitor_script_status *script;
- DEBUG(DEBUG_INFO, ("event script stop called : %d\n", (int)res));
-
if (monitoring_status == NULL) {
DEBUG(DEBUG_ERR,(__location__ " script_status is NULL when script finished.\n"));
return -1;
@@ -199,6 +204,8 @@ int32_t ctdb_control_event_script_stop(struct ctdb_context *ctdb, TDB_DATA indat
script->finished = timeval_current();
script->status = res;
+ DEBUG(DEBUG_INFO, ("event script stop called for script:%s duration:%.1f status:%d\n", script->name, timeval_elapsed(&script->start), (int)res));
+
return 0;
}
@@ -207,9 +214,7 @@ int32_t ctdb_control_event_script_stop(struct ctdb_context *ctdb, TDB_DATA indat
int32_t ctdb_control_event_script_disabled(struct ctdb_context *ctdb, TDB_DATA indata)
{
const char *name = (const char *)indata.dptr;
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
struct ctdb_monitor_script_status *script;
DEBUG(DEBUG_INFO, ("event script disabed called for script %s\n", name));
@@ -237,9 +242,7 @@ int32_t ctdb_control_event_script_disabled(struct ctdb_context *ctdb, TDB_DATA i
*/
int32_t ctdb_control_event_script_finished(struct ctdb_context *ctdb)
{
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
DEBUG(DEBUG_INFO, ("event script finished called\n"));
@@ -250,11 +253,13 @@ int32_t ctdb_control_event_script_finished(struct ctdb_context *ctdb)
monitoring_status->finished = timeval_current();
monitoring_status->status = MONITOR_SCRIPT_OK;
- if (ctdb->last_monitoring_ctx) {
- talloc_free(ctdb->last_monitoring_ctx);
+
+ if (ctdb->last_monitor_ctx) {
+ talloc_free(ctdb->last_monitor_ctx);
+ ctdb->last_monitor_ctx = NULL;
}
- ctdb->last_monitoring_ctx = ctdb->script_monitoring_ctx;
- ctdb->script_monitoring_ctx = NULL;
+ ctdb->last_monitor_ctx = talloc_steal(ctdb, ctdb->script_monitor_ctx);
+ ctdb->script_monitor_ctx = NULL;
return 0;
}
@@ -298,9 +303,7 @@ static struct ctdb_monitoring_wire *marshall_monitoring_scripts(TALLOC_CTX *mem_
int32_t ctdb_control_get_event_script_status(struct ctdb_context *ctdb, TDB_DATA *outdata)
{
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->last_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->last_monitor_ctx;
struct ctdb_monitoring_wire *monitoring_scripts;
if (monitoring_status == NULL) {
@@ -627,8 +630,6 @@ static void ctdb_event_script_handler(struct event_context *ev, struct fd_event
{
struct ctdb_event_script_state *state =
talloc_get_type(p, struct ctdb_event_script_state);
- void (*callback)(struct ctdb_context *, int, void *) = state->callback;
- void *private_data = state->private_data;
struct ctdb_context *ctdb = state->ctdb;
signed char rt = -1;
@@ -636,10 +637,13 @@ static void ctdb_event_script_handler(struct event_context *ev, struct fd_event
DEBUG(DEBUG_INFO,(__location__ " Eventscript %s finished with state %d\n", state->options, rt));
+ if (state->callback) {
+ state->callback(ctdb, rt, state->private_data);
+ state->callback = NULL;
+ }
+
talloc_set_destructor(state, NULL);
talloc_free(state);
- callback(ctdb, rt, private_data);
-
ctdb->event_script_timeouts = 0;
}
@@ -663,19 +667,20 @@ static void ctdb_event_script_timeout(struct event_context *ev, struct timed_eve
struct timeval t, void *p)
{
struct ctdb_event_script_state *state = talloc_get_type(p, struct ctdb_event_script_state);
- void (*callback)(struct ctdb_context *, int, void *) = state->callback;
void *private_data = state->private_data;
struct ctdb_context *ctdb = state->ctdb;
char *options;
- struct ctdb_monitoring_status *monitoring_status =
- talloc_get_type(ctdb->script_monitoring_ctx,
- struct ctdb_monitoring_status);
+ struct ctdb_monitor_status *monitoring_status = (struct ctdb_monitor_status *)ctdb->script_monitor_ctx;
+
+ state->te = NULL;
DEBUG(DEBUG_ERR,("Event script timed out : %s count : %u pid : %d\n", state->options, ctdb->event_script_timeouts, state->child));
if (kill(state->child, 0) != 0) {
DEBUG(DEBUG_ERR,("Event script child process already dead, errno %s(%d)\n", strerror(errno), errno));
- callback(ctdb, 0, private_data);
-
+ if (state->callback) {
+ state->callback(ctdb, 0, private_data);
+ state->callback = NULL;
+ }
talloc_set_destructor(state, NULL);
talloc_free(state);
return;
@@ -696,24 +701,39 @@ static void ctdb_event_script_timeout(struct event_context *ev, struct timed_eve
if (ctdb->event_script_timeouts > ctdb->tunable.script_ban_count) {
if (ctdb->tunable.script_unhealthy_on_timeout != 0) {
DEBUG(DEBUG_ERR, ("Maximum timeout count %u reached for eventscript. Making node unhealthy\n", ctdb->tunable.script_ban_count));
- callback(ctdb, -ETIME, private_data);
+ if (state->callback) {
+ state->callback(ctdb, -ETIME, private_data);
+ state->callback = NULL;
+ }
} else {
ctdb->event_script_timeouts = 0;
DEBUG(DEBUG_ERR, ("Maximum timeout count %u reached for eventscript. Banning self for %d seconds\n", ctdb->tunable.script_ban_count, ctdb->tunable.recovery_ban_period));
ctdb_ban_self(ctdb, ctdb->tunable.recovery_ban_period);
- callback(ctdb, -1, private_data);
+ if (state->callback) {
+ state->callback(ctdb, -1, private_data);
+ state->callback = NULL;
+ }
}
} else {
- callback(ctdb, 0, private_data);
+ if (state->callback) {
+ state->callback(ctdb, 0, private_data);
+ state->callback = NULL;
+ }
}
} else if (!strcmp(options, "startup")) {
DEBUG(DEBUG_ERR, (__location__ " eventscript for startup event timedout.\n"));
- callback(ctdb, -1, private_data);
+ if (state->callback) {
+ state->callback(ctdb, -1, private_data);
+ state->callback = NULL;
+ }
} else {
/* if it is not a monitor event we ban ourself immediately */
DEBUG(DEBUG_ERR, (__location__ " eventscript for NON-monitor/NON-startup event timedout. Immediately banning ourself for %d seconds\n", ctdb->tunable.recovery_ban_period));
ctdb_ban_self(ctdb, ctdb->tunable.recovery_ban_period);
- callback(ctdb, -1, private_data);
+ if (state->callback) {
+ state->callback(ctdb, -1, private_data);
+ state->callback = NULL;
+ }
}
if (monitoring_status != NULL) {
@@ -724,11 +744,12 @@ static void ctdb_event_script_timeout(struct event_context *ev, struct timed_eve
script->timedout = 1;
}
monitoring_status->status = MONITOR_SCRIPT_TIMEOUT;
- if (ctdb->last_monitoring_ctx) {
- talloc_free(ctdb->last_monitoring_ctx);
- ctdb->last_monitoring_ctx = ctdb->script_monitoring_ctx;
- ctdb->script_monitoring_ctx = NULL;
--
CTDB repository
More information about the samba-cvs
mailing list