[prev in list] [next in list] [prev in thread] [next in thread]
List: fedora-directory-commits
Subject: [389-commits] Branch '389-ds-base-1.2.10' - 2 commits - ldap/servers VERSION.sh
From: Mark Reynolds <mreynolds () fedoraproject ! org>
Date: 2012-10-18 15:53:38
Message-ID: 20121018155338.7CC47A1C8E () fedorahosted ! org
[Download RAW message or body]
VERSION.sh | 2
ldap/servers/plugins/replication/repl5.h | 3
ldap/servers/plugins/replication/repl5_replica.c | 2
ldap/servers/plugins/replication/repl5_replica_config.c | 135 ++++++++++++++--
ldap/servers/plugins/replication/repl_extop.c | 33 ++-
5 files changed, 149 insertions(+), 26 deletions(-)
New commits:
commit 569c2d3d5b7612113073abc6a1ec24f660b4b95f
Author: Mark Reynolds <mreynolds@redhat.com>
Date: Thu Oct 18 10:39:16 2012 -0400
bump version to 1.2.10.16
diff --git a/VERSION.sh b/VERSION.sh
index 0e62a09..f12b8e2 100644
--- a/VERSION.sh
+++ b/VERSION.sh
@@ -10,7 +10,7 @@ vendor="389 Project"
# PACKAGE_VERSION is constructed from these
VERSION_MAJOR=1
VERSION_MINOR=2
-VERSION_MAINT=10.15
+VERSION_MAINT=10.16
# if this is a PRERELEASE, set VERSION_PREREL
# otherwise, comment it out
# be sure to include the dot prefix in the prerel
commit 7a0e4c959bbd768475ed3711f51edf23462ab8f6
Author: Mark Reynolds <mreynolds@redhat.com>
Date: Thu Oct 18 10:30:54 2012 -0400
Ticket 403 - CLEANALLRUV - minor fixes and add support for replica-force-cleaning
Description: Improved maxcsn checking of remote replicas. Added check for \
running
duplicate clean/abort tasks, added check to prevent multiple \
threads from being created, and added a new option:
replica-force-cleaning: yes
- This skips the maxcsn checks
diff --git a/ldap/servers/plugins/replication/repl5.h \
b/ldap/servers/plugins/replication/repl5.h index 1637057..31231ac 100644
--- a/ldap/servers/plugins/replication/repl5.h
+++ b/ldap/servers/plugins/replication/repl5.h
@@ -616,8 +616,10 @@ CSN *replica_get_cleanruv_maxcsn(Replica *r, ReplicaId rid);
void ruv_get_cleaned_rids(RUV *ruv, ReplicaId *rids);
void add_aborted_rid(ReplicaId rid, Replica *r, char *repl_root);
int is_task_aborted(ReplicaId rid);
+int is_pre_cleaned_rid(ReplicaId rid);
void delete_aborted_rid(Replica *replica, ReplicaId rid, char *repl_root);
void set_cleaned_rid(ReplicaId rid);
+void set_aborted_rid(ReplicaId rid);
void cleanruv_log(Slapi_Task *task, char *task_type, char *fmt, ...);
#define CLEANRIDSIZ 4 /* maximum number for concurrent CLEANALLRUV tasks */
@@ -633,6 +635,7 @@ typedef struct _cleanruv_data
char *repl_root;
Slapi_DN *sdn;
char *certify;
+ char *force;
} cleanruv_data;
/* replutil.c */
diff --git a/ldap/servers/plugins/replication/repl5_replica.c \
b/ldap/servers/plugins/replication/repl5_replica.c index c956647..ec0b113 100644
--- a/ldap/servers/plugins/replication/repl5_replica.c
+++ b/ldap/servers/plugins/replication/repl5_replica.c
@@ -1863,6 +1863,7 @@ replica_check_for_tasks(Replica *r, Slapi_Entry *e)
csn_init_by_string(maxcsn, csnpart);
csn_as_string(maxcsn, PR_FALSE, csnstr);
add_cleaned_rid(rid, r, csnstr);
+ set_cleaned_rid(rid);
slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "CleanAllRUV Task: \
cleanAllRUV task found, " "resuming the cleaning of rid(%d)...\n", rid);
@@ -1951,6 +1952,7 @@ done:
stop_ruv_cleaning();
maxcsn = replica_get_cleanruv_maxcsn(r, rid);
delete_cleaned_rid(r, rid, maxcsn);
+ set_aborted_rid(rid);
csn_free(&maxcsn);
slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "Abort CleanAllRUV \
Task: abort task found, "
diff --git a/ldap/servers/plugins/replication/repl5_replica_config.c \
b/ldap/servers/plugins/replication/repl5_replica_config.c index 752b09b..fe34f4b \
100644
--- a/ldap/servers/plugins/replication/repl5_replica_config.c
+++ b/ldap/servers/plugins/replication/repl5_replica_config.c
@@ -64,6 +64,7 @@
int slapi_log_urp = SLAPI_LOG_REPL;
static ReplicaId cleaned_rids[CLEANRIDSIZ + 1] = {0};
+static ReplicaId pre_cleaned_rids[CLEANRIDSIZ + 1] = {0};
static ReplicaId aborted_rids[CLEANRIDSIZ + 1] = {0};
static Slapi_RWLock *rid_lock = NULL;
static Slapi_RWLock *abort_rid_lock = NULL;
@@ -84,7 +85,7 @@ static int replica_execute_task (Object *r, const char *task_name, \
char *returnt static int replica_execute_cl2ldif_task (Object *r, char *returntext);
static int replica_execute_ldif2cl_task (Object *r, char *returntext);
static int replica_execute_cleanruv_task (Object *r, ReplicaId rid, char \
*returntext);
-static int replica_execute_cleanall_ruv_task (Object *r, ReplicaId rid, Slapi_Task \
*task, char *returntext); +static int replica_execute_cleanall_ruv_task (Object *r, \
ReplicaId rid, Slapi_Task *task, const char *force_cleaning, char *returntext); \
static void replica_cleanallruv_thread(void *arg); static void \
replica_send_cleanruv_task(Repl_Agmt *agmt, ReplicaId rid, Slapi_Task *task); static \
int check_agmts_are_alive(Replica *replica, ReplicaId rid, Slapi_Task *task); @@ \
-96,6 +97,7 @@ static int replica_cleanallruv_replica_alive(Repl_Agmt *agmt); static \
int replica_cleanallruv_check_ruv(Repl_Agmt *ra, char *rid_text, Slapi_Task *task); \
static int get_cleanruv_task_count(); static int get_abort_cleanruv_task_count();
+static void preset_cleaned_rid(ReplicaId rid);
static int replica_cleanup_task (Object *r, const char *task_name, char *returntext, \
int apply_mods); static int replica_task_done(Replica *replica);
static multimaster_mtnode_extension * _replica_config_get_mtnode_ext (const \
Slapi_Entry *e); @@ -893,7 +895,7 @@ static int replica_execute_task (Object *r, \
const char *task_name, char *returnt if (apply_mods)
{
Slapi_Task *empty_task = NULL;
- return replica_execute_cleanall_ruv_task(r, (ReplicaId)temprid, empty_task, \
returntext); + return replica_execute_cleanall_ruv_task(r, (ReplicaId)temprid, \
empty_task, "no", returntext); }
else
return LDAP_SUCCESS;
@@ -1231,11 +1233,13 @@ replica_cleanall_ruv_task(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter, Object *r;
const char *base_dn;
const char *rid_str;
+ const char *force_cleaning;
ReplicaId rid;
int rc = SLAPI_DSE_CALLBACK_OK;
/* allocate new task now */
task = slapi_new_task(slapi_entry_get_ndn(e));
+ task_dn = slapi_entry_get_sdn(e);
if(task == NULL){
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: Failed \
to create new task\n"); rc = SLAPI_DSE_CALLBACK_ERROR;
@@ -1255,8 +1259,21 @@ replica_cleanall_ruv_task(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter, rc = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
+ if ((force_cleaning = fetch_attr(e, "replica-force-cleaning", 0)) != NULL){
+ if(strcasecmp(force_cleaning,"yes") != 0 && strcasecmp(force_cleaning,"no") \
!= 0){ + PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Invalid value \
for replica-force-cleaning " + "(%s). Value must be \"yes\" or \"no\" \
for task - (%s)", + force_cleaning, slapi_sdn_get_dn(task_dn));
+ cleanruv_log(task, CLEANALLRUV_ID, "%s", returntext);
+ *returncode = LDAP_OPERATIONS_ERROR;
+ rc = SLAPI_DSE_CALLBACK_ERROR;
+ goto out;
+ }
+ } else {
+ force_cleaning = "no";
+ }
+
- task_dn = slapi_entry_get_sdn(e);
/*
* Check the rid
*/
@@ -1269,6 +1286,14 @@ replica_cleanall_ruv_task(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter, rc = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
+ if(is_cleaned_rid(rid)){
+ /* we are already cleaning this rid */
+ PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Replica id (%d) is already \
being cleaned", rid); + cleanruv_log(task, CLEANALLRUV_ID, "%s", returntext);
+ *returncode = LDAP_UNWILLING_TO_PERFORM;
+ rc = SLAPI_DSE_CALLBACK_ERROR;
+ goto out;
+ }
/*
* Get the replica object
*/
@@ -1282,7 +1307,7 @@ replica_cleanall_ruv_task(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter, }
/* clean the RUV's */
- rc = replica_execute_cleanall_ruv_task (r, rid, task, returntext);
+ rc = replica_execute_cleanall_ruv_task (r, rid, task, force_cleaning, \
returntext);
out:
if(rc){
@@ -1305,7 +1330,7 @@ out:
*
*/
static int
-replica_execute_cleanall_ruv_task (Object *r, ReplicaId rid, Slapi_Task *task, char \
*returntext) +replica_execute_cleanall_ruv_task (Object *r, ReplicaId rid, Slapi_Task \
*task, const char* force_cleaning, char *returntext) {
PRThread *thread = NULL;
Slapi_Task *pre_task = NULL; /* this is supposed to be null for logging */
@@ -1374,7 +1399,7 @@ replica_execute_cleanall_ruv_task (Object *r, ReplicaId rid, \
Slapi_Task *task, c /*
* Create payload
*/
- ridstr = slapi_ch_smprintf("%d:%s:%s", rid, \
slapi_sdn_get_dn(replica_get_root(replica)), csnstr); + ridstr = \
slapi_ch_smprintf("%d:%s:%s:%s", rid, slapi_sdn_get_dn(replica_get_root(replica)), \
csnstr, force_cleaning); payload = create_ruv_payload(ridstr);
slapi_ch_free_string(&ridstr);
@@ -1400,12 +1425,14 @@ replica_execute_cleanall_ruv_task (Object *r, ReplicaId rid, \
Slapi_Task *task, c data->maxcsn = maxcsn;
data->payload = payload;
data->sdn = NULL;
+ data->force = slapi_ch_strdup(force_cleaning);
thread = PR_CreateThread(PR_USER_THREAD, replica_cleanallruv_thread,
(void *)data, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
if (thread == NULL) {
rc = -1;
+ slapi_ch_free_string(&data->force);
goto fail;
} else {
goto done;
@@ -1501,6 +1528,7 @@ replica_cleanallruv_thread(void *arg)
}
rid_text = slapi_ch_smprintf("{replica %d ldap", data->rid);
csn_as_string(data->maxcsn, PR_FALSE, csnstr);
+ preset_cleaned_rid(data->rid); /* this prevents duplicate thread creation */
/*
* Add the cleanallruv task to the repl config - so we can handle restarts
@@ -1514,7 +1542,7 @@ replica_cleanallruv_thread(void *arg)
ruv_obj = replica_get_ruv(data->replica);
ruv = object_get_data (ruv_obj);
while(data->maxcsn && !is_task_aborted(data->rid) && !is_cleaned_rid(data->rid) \
&& !slapi_is_shutting_down()){
- if(csn_get_replicaid(data->maxcsn) == 0 || \
ruv_covers_csn_cleanallruv(ruv,data->maxcsn)){ + \
if(csn_get_replicaid(data->maxcsn) == 0 || \
ruv_covers_csn_cleanallruv(ruv,data->maxcsn) || strcasecmp(data->force,"yes") == 0){ \
/* We are caught up, now we can clean the ruv's */ break;
}
@@ -1525,6 +1553,8 @@ replica_cleanallruv_thread(void *arg)
object_release(ruv_obj);
/*
* Next, make sure all the replicas are up and running before sending off the \
clean ruv tasks + *
+ * Even if we are forcing the cleaning, the replicas still need to be up
*/
cleanruv_log(data->task, CLEANALLRUV_ID,"Waiting for all the replicas to be \
online..."); if(check_agmts_are_alive(data->replica, data->rid, data->task)){
@@ -1536,7 +1566,7 @@ replica_cleanallruv_thread(void *arg)
* Make sure all the replicas have seen the max csn
*/
cleanruv_log(data->task, CLEANALLRUV_ID,"Waiting for all the replicas to receive \
all the deleted replica updates...");
- if(check_agmts_are_caught_up(data->replica, data->rid, csnstr, data->task)){
+ if(strcasecmp(data->force,"no") == 0 && check_agmts_are_caught_up(data->replica, \
data->rid, csnstr, data->task)){ /* error, aborted or shutdown */
aborted = 1;
goto done;
@@ -1567,6 +1597,7 @@ replica_cleanallruv_thread(void *arg)
agmt_not_notified = 0;
} else {
agmt_not_notified = 1;
+ cleanruv_log(data->task, CLEANALLRUV_ID, "Failed to send task to \
replica (%s)",agmt_get_long_name(agmt)); break;
}
agmt_obj = agmtlist_get_next_agreement_for_replica (data->replica, \
agmt_obj); @@ -1620,6 +1651,7 @@ replica_cleanallruv_thread(void *arg)
if(replica_cleanallruv_check_ruv(agmt, rid_text, data->task) == 0){
found_dirty_rid = 0;
} else {
+ cleanruv_log(data->task, CLEANALLRUV_ID,"Replica is not cleaned yet \
(%s)",agmt_get_long_name(agmt)); found_dirty_rid = 1;
break;
}
@@ -1679,6 +1711,7 @@ done:
object_release(data->repl_obj);
}
slapi_sdn_free(&data->sdn);
+ slapi_ch_free_string(&data->force);
slapi_ch_free_string(&rid_text);
csn_free(&data->maxcsn);
slapi_ch_free((void **)&data);
@@ -1715,6 +1748,7 @@ check_agmts_are_caught_up(Replica *replica, ReplicaId rid, char \
*maxcsn, Slapi_T not_all_caughtup = 0;
} else {
not_all_caughtup = 1;
+ cleanruv_log(task, CLEANALLRUV_ID, "Replica not caught up \
(%s)",agmt_get_long_name(agmt)); break;
}
agmt_obj = agmtlist_get_next_agreement_for_replica (replica, agmt_obj);
@@ -1771,6 +1805,7 @@ check_agmts_are_alive(Replica *replica, ReplicaId rid, \
Slapi_Task *task) not_all_alive = 0;
} else {
not_all_alive = 1;
+ cleanruv_log(task, CLEANALLRUV_ID, "Replica not online \
(%s)",agmt_get_long_name(agmt)); break;
}
agmt_obj = agmtlist_get_next_agreement_for_replica (replica, agmt_obj);
@@ -1914,6 +1949,23 @@ is_cleaned_rid(ReplicaId rid)
}
int
+is_pre_cleaned_rid(ReplicaId rid)
+{
+ int i;
+
+ slapi_rwlock_rdlock(rid_lock);
+ for(i = 0; i < CLEANRIDSIZ && pre_cleaned_rids[i] != 0; i++){
+ if(rid == pre_cleaned_rids[i]){
+ slapi_rwlock_unlock(rid_lock);
+ return 1;
+ }
+ }
+ slapi_rwlock_unlock(rid_lock);
+
+ return 0;
+}
+
+int
is_task_aborted(ReplicaId rid)
{
int i;
@@ -1947,11 +1999,44 @@ set_cleaned_rid(ReplicaId rid)
if(cleaned_rids[i] == 0){
cleaned_rids[i] = rid;
cleaned_rids[i + 1] = 0;
+ break;
}
}
slapi_rwlock_unlock(rid_lock);
}
+static void
+preset_cleaned_rid(ReplicaId rid)
+{
+ int i;
+
+ slapi_rwlock_wrlock(rid_lock);
+ for(i = 0; i < CLEANRIDSIZ; i++){
+ if(pre_cleaned_rids[i] == 0){
+ pre_cleaned_rids[i] = rid;
+ pre_cleaned_rids[i + 1] = 0;
+ break;
+ }
+ }
+ slapi_rwlock_unlock(rid_lock);
+}
+
+void
+set_aborted_rid(ReplicaId rid)
+{
+ int i;
+
+ slapi_rwlock_wrlock(abort_rid_lock);
+ for(i = 0; i < CLEANRIDSIZ; i++){
+ if(aborted_rids[i] == 0){
+ aborted_rids[i] = rid;
+ aborted_rids[i + 1] = 0;
+ break;
+ }
+ }
+ slapi_rwlock_unlock(abort_rid_lock);;
+}
+
/*
* Add the rid and maxcsn to the repl config (so we can resume after a server \
restart)
*/
@@ -2134,11 +2219,18 @@ delete_cleaned_rid(Replica *r, ReplicaId rid, CSN *maxcsn)
* Remove this rid, and optimize the array
*/
slapi_rwlock_wrlock(rid_lock);
+ /* do the cleaned rids */
for(i = 0; i < CLEANRIDSIZ && cleaned_rids[i] != rid; i++); /* found rid, stop \
*/ for(; i < CLEANRIDSIZ; i++){
/* rewrite entire array */
cleaned_rids[i] = cleaned_rids[i + 1];
}
+ /* do the preset cleaned rids */
+ for(i = 0; i < CLEANRIDSIZ && pre_cleaned_rids[i] != rid; i++); /* found rid, \
stop */ + for(; i < CLEANRIDSIZ; i++){
+ /* rewrite entire array */
+ pre_cleaned_rids[i] = pre_cleaned_rids[i + 1];
+ }
slapi_rwlock_unlock(rid_lock);
/*
* Prepare the mods for the config entry
@@ -2244,6 +2336,14 @@ replica_cleanall_ruv_abort(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter rc = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
+ if(is_aborted_rid(rid)){
+ /* we are already cleaning this rid */
+ PR_snprintf(returntext, SLAPI_DSE_RETURNTEXT_SIZE, "Replica id (%d) is already \
being aborted", rid); + cleanruv_log(task, ABORT_CLEANALLRUV_ID, "%s", \
returntext); + *returncode = LDAP_UNWILLING_TO_PERFORM;
+ rc = SLAPI_DSE_CALLBACK_ERROR;
+ goto out;
+ }
/*
* Get the replica object
*/
@@ -2256,7 +2356,7 @@ replica_cleanall_ruv_abort(Slapi_PBlock *pb, Slapi_Entry *e, \
Slapi_Entry *eAfter goto out;
}
/*
- * Check verify value
+ * Check certify value
*/
if(certify_all){
if(strcasecmp(certify_all,"yes") && strcasecmp(certify_all,"no")){
@@ -2591,10 +2691,17 @@ replica_cleanallruv_check_maxcsn(Repl_Agmt *agmt, char \
*rid_text, char *maxcsn,
for(part_count = 1; ruv_part && part_count < 5; \
part_count++){
ruv_part = ldap_utf8strtok_r(iter, " ", &iter);
}
- if(part_count == 5 && ruv_part){
- /* we have the maxcsn */
- if(strcmp(ruv_part, maxcsn)){
+ if(part_count == 5 && ruv_part){/* we have the maxcsn */
+ CSN *max, *repl_max;
+
+ max = csn_new();
+ repl_max = csn_new();
+ csn_init_by_string(max, maxcsn);
+ csn_init_by_string(repl_max, ruv_part);
+ if(csn_compare (repl_max, max) < 0){
/* we are not caught up yet, free, and return */
+ cleanruv_log(task, CLEANALLRUV_ID,"Replica \
maxcsn (%s) not caught up deleted replica's maxcsn(%s)", + \
ruv_part, maxcsn); ldap_value_free_len(vals);
ldap_memfree( attr );
ldap_msgfree( result );
@@ -2602,9 +2709,13 @@ replica_cleanallruv_check_maxcsn(Repl_Agmt *agmt, char \
*rid_text, char *maxcsn, ber_free( ber, 0 );
}
conn_delete_internal_ext(conn);
+ csn_free(&max);
+ csn_free(&repl_max);
return -1;
} else {
/* ok this replica has all the updates from the \
deleted replica */ + csn_free(&max);
+ csn_free(&repl_max);
rc = 0;
}
} else {
diff --git a/ldap/servers/plugins/replication/repl_extop.c \
b/ldap/servers/plugins/replication/repl_extop.c index b2381b8..8026ff4 100644
--- a/ldap/servers/plugins/replication/repl_extop.c
+++ b/ldap/servers/plugins/replication/repl_extop.c
@@ -1519,6 +1519,7 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
char *payload = NULL;
char *csnstr = NULL;
char *iter;
+ char *force = NULL;
int release_it = 0;
int rid = 0;
int rc = LDAP_OPERATIONS_ERROR;
@@ -1535,18 +1536,22 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
* Decode the payload
*/
if(decode_cleanruv_payload(extop_payload, &payload)){
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: failed to \
decode payload. Aborting ext op\n"); + slapi_log_error(SLAPI_LOG_FATAL, \
repl_plugin_name, "cleanAllRUV Task: failed to decode payload. Aborting ext op\n"); \
goto free_and_return; }
rid = atoi(ldap_utf8strtok_r(payload, ":", &iter));
repl_root = ldap_utf8strtok_r(iter, ":", &iter);
csnstr = ldap_utf8strtok_r(iter, ":", &iter);
+ force = ldap_utf8strtok_r(iter, ":", &iter);
+ if(force == NULL){
+ force = "no";
+ }
maxcsn = csn_new();
csn_init_by_string(maxcsn, csnstr);
/*
* If we already cleaned this server, just return success
*/
- if(is_cleaned_rid(rid)){
+ if(is_cleaned_rid(rid) || is_pre_cleaned_rid(rid)){
csn_free(&maxcsn);
rc = LDAP_SUCCESS;
goto free_and_return;
@@ -1556,7 +1561,7 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
* Get the node, so we can get the replica and its agreements
*/
if((mtnode_ext = replica_config_get_mtnode_by_dn(repl_root)) == NULL){
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: failed to \
get replication node " + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: failed to get replication node " "from (%s), aborting \
operation\n", repl_root); goto free_and_return;
}
@@ -1565,14 +1570,14 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
object_acquire (mtnode_ext->replica);
release_it = 1;
} else {
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: replica is \
missing from (%s), " + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: replica is missing from (%s), " "aborting \
operation\n",repl_root); goto free_and_return;
}
r = (Replica*)object_get_data (mtnode_ext->replica);
if(r == NULL){
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: replica is \
NULL, aborting task\n"); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: replica is NULL, aborting task\n"); goto free_and_return;
}
@@ -1582,10 +1587,10 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
*
* This will also release mtnode_ext->replica
*/
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: launching \
cleanAllRUV thread...\n"); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: launching cleanAllRUV thread...\n"); data = \
(cleanruv_data*)slapi_ch_calloc(1, sizeof(cleanruv_data)); if (data == NULL) {
- slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: failed to \
allocate " + slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV Task: \
failed to allocate " "cleanruv_Data\n");
goto free_and_return;
}
@@ -1595,15 +1600,17 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
data->task = NULL;
data->maxcsn = maxcsn;
data->payload = slapi_ch_bvdup(extop_payload);
+ data->force = slapi_ch_strdup(force);
thread = PR_CreateThread(PR_USER_THREAD, replica_cleanallruv_thread_ext,
(void *)data, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
if (thread == NULL) {
- slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: unable to \
create cleanAllRUV " + slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: unable to create cleanAllRUV " "monitoring thread. Aborting \
task.\n"); ber_bvfree(data->payload);
data->payload = NULL;
+ slapi_ch_free_string(&data->force);
slapi_ch_free((void **)&data);
} else {
release_it = 0; /* thread will release data->repl_obj == mtnode_ext->replica */
@@ -1625,18 +1632,18 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
/* we've already been cleaned */
break;
}
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: checking if \
we're caught up...\n"); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: checking if we're caught up...\n"); \
if(ruv_covers_csn_cleanallruv(ruv,maxcsn) || csn_get_replicaid(maxcsn) == 0){ /* We \
are caught up */ break;
} else {
char csnstr[CSN_STRSIZE];
csn_as_string(maxcsn, PR_FALSE, csnstr);
- slapi_log_error( SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: not ruv \
caught up maxcsn(%s)\n", csnstr); + slapi_log_error( SLAPI_LOG_FATAL, \
repl_plugin_name, "cleanAllRUV Task: ruv not caught up to maxcsn(%s)\n", csnstr); }
DS_Sleep(PR_SecondsToInterval(5));
}
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: we're caught \
up...\n"); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV Task: \
we're caught up...\n"); /*
* Set cleaned rid in memory only - does not survive a server restart
*/
@@ -1652,8 +1659,8 @@ multimaster_extop_cleanruv(Slapi_PBlock *pb)
* This read-only replica has no easy way to tell when it's safe to release the \
rid.
* So we won't release it, not until a server restart.
*/
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: You must \
restart the server if you want to reuse rid(%d).\n", rid);
- slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV_task: Successfully \
cleaned rid(%d).\n", rid); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, \
"cleanAllRUV Task: You must restart the server if you want to reuse rid(%d).\n", \
rid); + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "cleanAllRUV Task: \
Successfully cleaned rid(%d).\n", rid); rc = LDAP_SUCCESS;
}
--
389 commits mailing list
389-commits@lists.fedoraproject.org
https://admin.fedoraproject.org/mailman/listinfo/389-commits
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic