summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ldap/servers/plugins/memberof/memberof.c162
-rw-r--r--ldap/servers/slapd/back-ldbm/archive.c4
-rw-r--r--ldap/servers/slapd/back-ldbm/back-ldbm.h6
-rw-r--r--ldap/servers/slapd/back-ldbm/dblayer.c6
-rw-r--r--ldap/servers/slapd/back-ldbm/import.c52
-rw-r--r--ldap/servers/slapd/back-ldbm/ldif2ldbm.c20
-rw-r--r--ldap/servers/slapd/main.c14
-rw-r--r--ldap/servers/slapd/slap.h25
-rw-r--r--ldap/servers/slapd/slapi-plugin.h37
-rw-r--r--ldap/servers/slapd/slapi-private.h40
-rw-r--r--ldap/servers/slapd/task.c749
-rw-r--r--ldap/servers/slapd/test-plugins/sampletask.c115
12 files changed, 640 insertions, 590 deletions
diff --git a/ldap/servers/plugins/memberof/memberof.c b/ldap/servers/plugins/memberof/memberof.c
index a1341a7e..96d9a906 100644
--- a/ldap/servers/plugins/memberof/memberof.c
+++ b/ldap/servers/plugins/memberof/memberof.c
@@ -49,10 +49,10 @@
*
* To start the memberof task add an entry like:
*
- * dn: cn=memberof task 2, cn=memberof task, cn=tasks, cn=config
+ * dn: cn=mytask, cn=memberof task, cn=tasks, cn=config
* objectClass: top
* objectClass: extensibleObject
- * cn: sample task
+ * cn: mytask
* basedn: dc=example, dc=com
* filter: (uid=test4)
*
@@ -75,7 +75,6 @@
#define MEMBEROF_GROUP_ATTR "member"
#define MEMBEROF_ATTR "memberof"
#define MEMBEROF_GROUP_ATTR_IS_DN 1
-#define MEMBEROF_GROUP_ATTR_TYPE "uid"
#define MEMBEROF_GROUP_FILTER "(" MEMBEROF_GROUP_ATTR "=*)"
#define MEMBEROF_PLUGIN_SUBSYSTEM "memberof-plugin" /* used for logging */
@@ -92,50 +91,6 @@ typedef struct _memberofstringll
void *next;
} memberofstringll;
-
-
-/****** secrets *********/
-
-/*from FDS slap.h
- * until we get a proper api for access
- */
-#define TASK_RUNNING_AS_TASK 0x0
-
-/*from FDS slapi-private.h
- * until we get a proper api for access
- */
-
-
-#define SLAPI_DSE_CALLBACK_OK (1)
-#define SLAPI_DSE_CALLBACK_ERROR (-1)
-#define SLAPI_DSE_CALLBACK_DO_NOT_APPLY (0)
-
-/******************************************************************************
- * Online tasks interface (to support import, export, etc)
- * After some cleanup, we could consider making these public.
- */
-struct _slapi_task {
- struct _slapi_task *next;
- char *task_dn;
- int task_exitcode; /* for the end user */
- int task_state; /* (see above) */
- int task_progress; /* number between 0 and task_work */
- int task_work; /* "units" of work to be done */
- int task_flags; /* (see above) */
-
- /* it is the task's responsibility to allocate this memory & free it: */
- char *task_status; /* transient status info */
- char *task_log; /* appended warnings, etc */
-
- void *task_private; /* for use by backends */
- TaskCallbackFn cancel; /* task has been cancelled by user */
- TaskCallbackFn destructor; /* task entry is being destroyed */
- int task_refcount;
-};
-
-/****** secrets ********/
-
-
/*** function prototypes ***/
/* exported functions */
@@ -169,7 +124,7 @@ static int memberof_add_attr_list(Slapi_PBlock *pb, char *groupdn, Slapi_Attr *a
static int memberof_del_attr_list(Slapi_PBlock *pb, char *groupdn, Slapi_Attr *attr);
static int memberof_moddn_attr_list(Slapi_PBlock *pb, char *pre_dn, char *post_dn,
Slapi_Attr *attr);
-static int memberofd_replace_list(Slapi_PBlock *pb, char *group_dn);
+static int memberof_replace_list(Slapi_PBlock *pb, char *group_dn);
static void memberof_set_plugin_id(void * plugin_id);
static void *memberof_get_plugin_id();
static int memberof_compare(const void *a, const void *b);
@@ -195,9 +150,10 @@ static int memberof_add_membership(Slapi_PBlock *pb, char *op_this, char *op_to)
static int memberof_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
Slapi_Entry *eAfter, int *returncode, char *returntext,
void *arg);
+static void memberof_task_destructor(Slapi_Task *task);
static const char *fetch_attr(Slapi_Entry *e, const char *attrname,
const char *default_val);
-static void memberof_memberof_fixup_task_thread(void *arg);
+static void memberof_fixup_task_thread(void *arg);
static int memberof_fix_memberof(char *dn, char *filter_str);
static int memberof_fix_memberof_callback(Slapi_Entry *e, void *callback_data);
@@ -511,6 +467,8 @@ int memberof_postop_modrdn(Slapi_PBlock *pb)
memberof_lock();
+ /* get a list of member attributes present in the group
+ * entry that is being renamed. */
if(0 == slapi_entry_attr_find(post_e, MEMBEROF_GROUP_ATTR, &attr))
{
memberof_moddn_attr_list(pb, pre_dn, post_dn, attr);
@@ -656,7 +614,7 @@ int memberof_postop_modify(Slapi_PBlock *pb)
{
/* If there are no values in the smod, we should
* just do a replace instead. The user is just
- * trying to delete all members from this this
+ * trying to delete all members from this group
* entry, which the replace code deals with. */
if (slapi_mod_get_num_values(smod) == 0)
{
@@ -673,7 +631,7 @@ int memberof_postop_modify(Slapi_PBlock *pb)
case LDAP_MOD_REPLACE:
{
/* replace current values */
- memberofd_replace_list(pb, dn);
+ memberof_replace_list(pb, dn);
break;
}
@@ -877,6 +835,14 @@ int memberof_modop_one_replace_r(Slapi_PBlock *pb, int mod_op, char *group_dn,
{
op_str = "ADD";
}
+ else if(LDAP_MOD_REPLACE == mod_op)
+ {
+ op_str = "REPLACE";
+ }
+ else
+ {
+ op_str = "UNKNOWN";
+ }
slapi_log_error( SLAPI_LOG_PLUGIN, MEMBEROF_PLUGIN_SUBSYSTEM,
"memberof_modop_one_r: %s %s in %s\n"
@@ -1347,7 +1313,7 @@ int memberof_is_group_member(Slapi_Value *groupdn, Slapi_Value *memberdn)
return rc;
}
-/* memberof_memberof_search_callback()
+/* memberof_test_membership()
* for each attribute in the memberof attribute
* determine if the entry is still a member
*
@@ -1517,7 +1483,7 @@ bail:
* Perform replace the group DN list in the memberof attribute of the list of targets
*
*/
-int memberofd_replace_list(Slapi_PBlock *pb, char *group_dn)
+int memberof_replace_list(Slapi_PBlock *pb, char *group_dn)
{
struct slapi_entry *pre_e = NULL;
struct slapi_entry *post_e = NULL;
@@ -1876,29 +1842,22 @@ void memberof_unlock()
slapi_unlock_mutex(memberof_operation_lock);
}
-/*
- *
- */
-
typedef struct _task_data
{
char *dn;
char *filter_str;
- Slapi_Task *task;
} task_data;
-void memberof_memberof_fixup_task_thread(void *arg)
+void memberof_fixup_task_thread(void *arg)
{
- task_data *td = (task_data *)arg;
- Slapi_Task *task = td->task;
+ Slapi_Task *task = (Slapi_Task *)arg;
+ task_data *td = NULL;
int rc = 0;
- task->task_work = 1;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
-
- slapi_task_status_changed(task);
+ /* Fetch our task data from the task */
+ td = (task_data *)slapi_task_get_data(task);
+ slapi_task_begin(task, 1);
slapi_task_log_notice(task, "Memberof task starts (arg: %s) ...\n",
td->filter_str);
@@ -1907,20 +1866,10 @@ void memberof_memberof_fixup_task_thread(void *arg)
slapi_task_log_notice(task, "Memberof task finished.");
slapi_task_log_status(task, "Memberof task finished.");
+ slapi_task_inc_progress(task);
- task->task_progress = 1;
- task->task_exitcode = rc;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
-
- slapi_ch_free_string(&td->dn);
- slapi_ch_free_string(&td->filter_str);
-
- {
- /* make the compiler happy */
- void *ptd = td;
- slapi_ch_free(&ptd);
- }
+ /* this will queue the destruction of the task */
+ slapi_task_finish(task, rc);
}
/* extract a single value from the entry (as a string) -- if it's not in the
@@ -1966,13 +1915,7 @@ int memberof_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
goto out;
}
- /* allocate new task now */
- task = slapi_new_task(slapi_entry_get_ndn(e));
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = 1;
- task->task_progress = 0;
-
- /* create a pblock to pass the necessary info to the task thread */
+ /* setup our task data */
mytaskdata = (task_data*)slapi_ch_malloc(sizeof(task_data));
if (mytaskdata == NULL)
{
@@ -1982,11 +1925,19 @@ int memberof_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
mytaskdata->dn = slapi_ch_strdup(dn);
mytaskdata->filter_str = slapi_ch_strdup(filter);
- mytaskdata->task = task;
+
+ /* allocate new task now */
+ task = slapi_new_task(slapi_entry_get_ndn(e));
+
+ /* register our destructor for cleaning up our private data */
+ slapi_task_set_destructor_fn(task, memberof_task_destructor);
+
+ /* Stash a pointer to our data in the task */
+ slapi_task_set_data(task, mytaskdata);
/* start the sample task as a separate thread */
- thread = PR_CreateThread(PR_USER_THREAD, memberof_memberof_fixup_task_thread,
- (void *)mytaskdata, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
+ thread = PR_CreateThread(PR_USER_THREAD, memberof_fixup_task_thread,
+ (void *)task, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
if (thread == NULL)
{
@@ -1994,28 +1945,29 @@ int memberof_task_add(Slapi_PBlock *pb, Slapi_Entry *e,
"unable to create task thread!\n");
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
-
- slapi_ch_free_string(&mytaskdata->dn);
- slapi_ch_free_string(&mytaskdata->filter_str);
-
- {
- void *ptask = mytaskdata;
- slapi_ch_free(&ptask);
- goto out;
- }
+ slapi_task_finish(task, *returncode);
+ } else {
+ rv = SLAPI_DSE_CALLBACK_OK;
}
- /* thread successful -- don't free the pb, let the thread do that. */
- return SLAPI_DSE_CALLBACK_OK;
-
out:
- if (task)
- {
- slapi_destroy_task(task);
- }
return rv;
}
+void
+memberof_task_destructor(Slapi_Task *task)
+{
+ if (task) {
+ task_data *mydata = (task_data *)slapi_task_get_data(task);
+ if (mydata) {
+ slapi_ch_free_string(&mydata->dn);
+ slapi_ch_free_string(&mydata->filter_str);
+ /* Need to cast to avoid a compiler warning */
+ slapi_ch_free((void **)&mydata);
+ }
+ }
+}
+
int memberof_fix_memberof(char *dn, char *filter_str)
{
int rc = 0;
diff --git a/ldap/servers/slapd/back-ldbm/archive.c b/ldap/servers/slapd/back-ldbm/archive.c
index be2c4c63..a0568b7a 100644
--- a/ldap/servers/slapd/back-ldbm/archive.c
+++ b/ldap/servers/slapd/back-ldbm/archive.c
@@ -61,7 +61,7 @@ int ldbm_back_archive2ldbm( Slapi_PBlock *pb )
slapi_pblock_get( pb, SLAPI_BACKEND_INSTANCE_NAME, &backendname);
slapi_pblock_get( pb, SLAPI_BACKEND_TASK, &task );
slapi_pblock_get( pb, SLAPI_TASK_FLAGS, &task_flags );
- li->li_flags = run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ li->li_flags = run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
if ( !rawdirectory || !*rawdirectory ) {
LDAPDebug( LDAP_DEBUG_ANY, "archive2db: no archive name\n",
@@ -273,7 +273,7 @@ int ldbm_back_ldbm2archive( Slapi_PBlock *pb )
slapi_pblock_get( pb, SLAPI_PLUGIN_PRIVATE, &li );
slapi_pblock_get( pb, SLAPI_SEQ_VAL, &rawdirectory );
slapi_pblock_get( pb, SLAPI_TASK_FLAGS, &task_flags );
- li->li_flags = run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ li->li_flags = run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
slapi_pblock_get( pb, SLAPI_BACKEND_TASK, &task );
diff --git a/ldap/servers/slapd/back-ldbm/back-ldbm.h b/ldap/servers/slapd/back-ldbm/back-ldbm.h
index 87e04683..2af305fe 100644
--- a/ldap/servers/slapd/back-ldbm/back-ldbm.h
+++ b/ldap/servers/slapd/back-ldbm/back-ldbm.h
@@ -513,10 +513,10 @@ struct ldbminfo {
int li_legacy_errcode; /* 615428 -- in case legacy err code is expected */
};
-/* li_flags could store these bits defined in ../slap.h
+/* li_flags could store these bits defined in ../slapi-plugin.h
* task flag (pb_task_flags) *
- * #define TASK_RUNNING_AS_TASK 0x0
- * #define TASK_RUNNING_FROM_COMMANDLINE 0x1
+ * SLAPI_TASK_RUNNING_AS_TASK
+ * SLAPI_TASK_RUNNING_FROM_COMMANDLINE
*/
/* allow conf w/o CONFIG_FLAG_ALLOW_RUNNING_CHANGE to be updated */
#define LI_FORCE_MOD_CONFIG 0x10
diff --git a/ldap/servers/slapd/back-ldbm/dblayer.c b/ldap/servers/slapd/back-ldbm/dblayer.c
index 8f0bc07b..abd71b85 100644
--- a/ldap/servers/slapd/back-ldbm/dblayer.c
+++ b/ldap/servers/slapd/back-ldbm/dblayer.c
@@ -1954,7 +1954,7 @@ int dblayer_instance_start(backend *be, int mode)
oflags |= DB_PRIVATE;
}
PR_Lock(li->li_config_mutex);
- if ((li->li_flags & TASK_RUNNING_FROM_COMMANDLINE) &&
+ if ((li->li_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE) &&
(li->li_import_cache_autosize)) /* Autosizing importCache
* Need to re-eval every time
* to guarantee the memory is
@@ -5678,7 +5678,7 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task, char *
* dse_conf_verify may need to have db started, as well. */
/* If no logfiles were stored, then fatal recovery isn't required */
- if (li->li_flags & TASK_RUNNING_FROM_COMMANDLINE)
+ if (li->li_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE)
{
/* command line mode; no need to run db threads */
dbmode |= DBLAYER_NO_DBTHREADS_MODE;
@@ -5707,7 +5707,7 @@ int dblayer_restore(struct ldbminfo *li, char *src_dir, Slapi_Task *task, char *
"Warning: Unable to verify the index configuration\n", 0, 0, 0);
}
- if (li->li_flags & TASK_RUNNING_FROM_COMMANDLINE) {
+ if (li->li_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE) {
/* command line: close the database down again */
tmp_rval = dblayer_close(li, dbmode);
if (0 != tmp_rval) {
diff --git a/ldap/servers/slapd/back-ldbm/import.c b/ldap/servers/slapd/back-ldbm/import.c
index 7666dcfe..533a61c3 100644
--- a/ldap/servers/slapd/back-ldbm/import.c
+++ b/ldap/servers/slapd/back-ldbm/import.c
@@ -197,29 +197,19 @@ void import_log_notice(ImportJob *job, char *format, ...)
buffer, 0);
}
-static int import_task_destroy(Slapi_Task *task)
+static void import_task_destroy(Slapi_Task *task)
{
- ImportJob *job = (ImportJob *)task->task_private;
-
- if (task->task_log) {
- slapi_ch_free((void **)&task->task_log);
- }
-
- if (task->task_status) {
- slapi_ch_free((void **)&task->task_status);
- }
-
+ ImportJob *job = (ImportJob *)slapi_task_get_data(task);
if (job && job->task_status) {
slapi_ch_free((void **)&job->task_status);
job->task_status = NULL;
}
FREE(job);
- task->task_private = NULL;
- return 0;
+ slapi_task_set_data(task, NULL);
}
-static int import_task_abort(Slapi_Task *task)
+static void import_task_abort(Slapi_Task *task)
{
ImportJob *job;
@@ -227,9 +217,8 @@ static int import_task_abort(Slapi_Task *task)
* DSE lock for modify...
*/
- if (task->task_state == SLAPI_TASK_FINISHED) {
+ if (slapi_task_get_state(task) == SLAPI_TASK_FINISHED) {
/* too late */
- return 0;
}
/*
@@ -238,14 +227,12 @@ static int import_task_abort(Slapi_Task *task)
* because it will free the job.
*/
- job = (ImportJob *)task->task_private;
+ job = (ImportJob *)slapi_task_get_data(task);
import_abort_all(job, 0);
- while (task->task_state != SLAPI_TASK_FINISHED)
+ while (slapi_task_get_state(task) != SLAPI_TASK_FINISHED)
DS_Sleep(PR_MillisecondsToInterval(100));
-
- return 0;
}
@@ -1042,13 +1029,8 @@ static int import_all_done(ImportJob *job, int ret)
slapi_ch_free_string(&inst_dirp);
}
- if (job->task != NULL && 0 == job->task->task_refcount) {
- /* exit code */
- job->task->task_exitcode = ret;
- job->task->task_state = SLAPI_TASK_FINISHED;
- job->task->task_progress = job->task->task_work;
- job->task->task_private = NULL;
- slapi_task_status_changed(job->task);
+ if ((job->task != NULL) && (0 == slapi_task_get_refcount(job->task))) {
+ slapi_task_finish(job->task, ret);
}
if (job->flags & FLAG_ONLINE) {
@@ -1093,7 +1075,7 @@ int import_main_offline(void *arg)
ImportWorkerInfo *producer = NULL;
if (job->task)
- job->task->task_refcount++;
+ slapi_task_inc_refcount(job->task);
PR_ASSERT(inst != NULL);
time(&beginning);
@@ -1364,13 +1346,11 @@ error:
if (0 != ret) {
import_log_notice(job, "Import failed.");
if (job->task != NULL) {
- job->task->task_state = SLAPI_TASK_FINISHED;
- job->task->task_exitcode = ret;
- slapi_task_status_changed(job->task);
+ slapi_task_finish(job->task, ret);
}
} else {
if (job->task)
- job->task->task_refcount--;
+ slapi_task_dec_refcount(job->task);
import_all_done(job, ret);
}
@@ -1471,15 +1451,17 @@ int ldbm_back_ldif2ldbm_deluxe(Slapi_PBlock *pb)
/* add 1 to account for post-import cleanup (which can take a
* significant amount of time)
*/
+ /* NGK - This should eventually be cleaned up to use the public
+ * task API. */
if (0 == total_files) /* reindexing */
job->task->task_work = 2;
else
job->task->task_work = total_files + 1;
job->task->task_progress = 0;
job->task->task_state = SLAPI_TASK_RUNNING;
- job->task->task_private = job;
- job->task->destructor = import_task_destroy;
- job->task->cancel = import_task_abort;
+ slapi_task_set_data(job->task, job);
+ slapi_task_set_destructor_fn(job->task, import_task_destroy);
+ slapi_task_set_cancel_fn(job->task, import_task_abort);
job->flags |= FLAG_ONLINE;
/* create thread for import_main, so we can return */
diff --git a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
index 827e471c..e4f82b2f 100644
--- a/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
+++ b/ldap/servers/slapd/back-ldbm/ldif2ldbm.c
@@ -568,7 +568,7 @@ int ldbm_back_ldif2ldbm( Slapi_PBlock *pb )
/* hopefully this will go away once import is not run standalone... */
slapi_pblock_get(pb, SLAPI_TASK_FLAGS, &task_flags);
- if (task_flags & TASK_RUNNING_FROM_COMMANDLINE) {
+ if (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE) {
/* initialize UniqueID generator - must be done once backends are started
and event queue is initialized but before plugins are started */
Slapi_DN *sdn = slapi_sdn_new_dn_byval ("cn=uniqueid generator,cn=config");
@@ -581,7 +581,7 @@ int ldbm_back_ldif2ldbm( Slapi_PBlock *pb )
return -1;
}
- li->li_flags |= TASK_RUNNING_FROM_COMMANDLINE;
+ li->li_flags |= SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
ldbm_config_load_dse_info(li);
autosize_import_cache(li);
}
@@ -604,7 +604,7 @@ int ldbm_back_ldif2ldbm( Slapi_PBlock *pb )
/***** prepare & init libdb and dblayer *****/
- if (! (task_flags & TASK_RUNNING_FROM_COMMANDLINE)) {
+ if (! (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE)) {
/* shutdown this instance of the db */
LDAPDebug(LDAP_DEBUG_ANY, "Bringing %s offline...\n",
instance_name, 0, 0);
@@ -778,11 +778,11 @@ ldbm_back_ldbm2ldif( Slapi_PBlock *pb )
slapi_pblock_get( pb, SLAPI_TASK_FLAGS, &task_flags );
slapi_pblock_get( pb, SLAPI_DB2LDIF_DECRYPT, &decrypt );
slapi_pblock_get( pb, SLAPI_DB2LDIF_SERVER_RUNNING, &server_running );
- run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
dump_replica = pb->pb_ldif_dump_replica;
if (run_from_cmdline) {
- li->li_flags |= TASK_RUNNING_FROM_COMMANDLINE;
+ li->li_flags |= SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
if (!dump_replica) {
we_start_the_backends = 1;
}
@@ -1298,12 +1298,12 @@ ldbm_back_ldbm2index(Slapi_PBlock *pb)
slapi_pblock_get(pb, SLAPI_BACKEND_INSTANCE_NAME, &instance_name);
slapi_pblock_get(pb, SLAPI_PLUGIN_PRIVATE, &li);
slapi_pblock_get(pb, SLAPI_TASK_FLAGS, &task_flags);
- run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
slapi_pblock_get(pb, SLAPI_BACKEND_TASK, &task);
if (run_from_cmdline) {
/* No ldbm backend exists until we process the config info. */
- li->li_flags |= TASK_RUNNING_FROM_COMMANDLINE;
+ li->li_flags |= SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
ldbm_config_load_dse_info(li);
txn.back_txn_txn = NULL; /* no transaction */
}
@@ -1764,6 +1764,8 @@ ldbm_back_ldbm2index(Slapi_PBlock *pb)
percent = (ep->ep_id*100 / (lastid ? lastid : 1));
}
if (task) {
+ /* NGK - This should eventually be cleaned up to use the
+ * public task API */
task->task_progress = (idl ? idindex : ep->ep_id);
task->task_work = (idl ? idl->b_nids : lastid);
slapi_task_status_changed(task);
@@ -1970,7 +1972,7 @@ int ldbm_back_upgradedb(Slapi_PBlock *pb)
slapi_pblock_get(pb, SLAPI_BACKEND_TASK, &task);
slapi_pblock_get(pb, SLAPI_DB2LDIF_SERVER_RUNNING, &server_running);
- run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
slapi_pblock_get(pb, SLAPI_PLUGIN_PRIVATE, &li);
if (run_from_cmdline)
{
@@ -2435,7 +2437,7 @@ void upgradedb_core(Slapi_PBlock *pb, ldbm_instance *inst)
int run_from_cmdline = 0;
slapi_pblock_get(pb, SLAPI_TASK_FLAGS, &task_flags);
- run_from_cmdline = (task_flags & TASK_RUNNING_FROM_COMMANDLINE);
+ run_from_cmdline = (task_flags & SLAPI_TASK_RUNNING_FROM_COMMANDLINE);
be = inst->inst_be;
slapi_log_error(SLAPI_LOG_FATAL, "upgrade DB",
diff --git a/ldap/servers/slapd/main.c b/ldap/servers/slapd/main.c
index 0b5f3e7d..1c1943a6 100644
--- a/ldap/servers/slapd/main.c
+++ b/ldap/servers/slapd/main.c
@@ -2118,7 +2118,7 @@ slapd_exemode_ldif2db()
pb.pb_ldif_files = ldif_file;
pb.pb_ldif_include = db2ldif_include;
pb.pb_ldif_exclude = db2ldif_exclude;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
#ifndef _WIN32
main_setuid(slapdFrontendConfig->localuser);
#endif
@@ -2245,7 +2245,7 @@ slapd_exemode_db2ldif(int argc, char** argv)
pb.pb_ldif_dump_uniqueid = db2ldif_dump_uniqueid;
pb.pb_ldif_encrypt = importexport_encrypt;
pb.pb_instance_name = *instp;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
if (is_slapd_running())
pb.pb_server_running = 1;
else
@@ -2431,7 +2431,7 @@ static int slapd_exemode_db2index()
pb.pb_plugin = plugin;
pb.pb_db2index_attrs = db2index_attrs;
pb.pb_instance_name = cmd_line_instance_name;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
#ifndef _WIN32
main_setuid(slapdFrontendConfig->localuser);
#endif
@@ -2489,7 +2489,7 @@ slapd_exemode_db2archive()
pb.pb_plugin = backend_plugin;
pb.pb_instance_name = cmd_line_instance_name;
pb.pb_seq_val = archive_name;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
#ifndef _WIN32
main_setuid(slapdFrontendConfig->localuser);
#endif
@@ -2539,7 +2539,7 @@ slapd_exemode_archive2db()
pb.pb_plugin = backend_plugin;
pb.pb_instance_name = cmd_line_instance_name;
pb.pb_seq_val = archive_name;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
#ifndef _WIN32
main_setuid(slapdFrontendConfig->localuser);
#endif
@@ -2601,7 +2601,7 @@ slapd_exemode_upgradedb()
pb.pb_plugin = backend_plugin;
pb.pb_seq_val = archive_name;
pb.pb_seq_type = upgradedb_force;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
/* borrowing import code, so need to set up the import variables */
pb.pb_ldif_generate_uniqueid = ldif2db_generate_uniqueid;
pb.pb_ldif_namespaceid = ldif2db_namespaceid;
@@ -2656,7 +2656,7 @@ slapd_exemode_dbverify()
pb.pb_seq_type = dbverify_verbose;
pb.pb_plugin = backend_plugin;
pb.pb_instance_name = (char *)cmd_line_instance_names;
- pb.pb_task_flags = TASK_RUNNING_FROM_COMMANDLINE;
+ pb.pb_task_flags = SLAPI_TASK_RUNNING_FROM_COMMANDLINE;
if ( backend_plugin->plg_dbverify != NULL ) {
return_value = (*backend_plugin->plg_dbverify)( &pb );
diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h
index f1777eb8..0b3305e3 100644
--- a/ldap/servers/slapd/slap.h
+++ b/ldap/servers/slapd/slap.h
@@ -1283,6 +1283,27 @@ typedef struct conn {
#define SLAPD_POLL_FLAGS (PR_POLL_READ)
#endif
+/******************************************************************************
+ * * Online tasks interface (to support import, export, etc)
+ * * After some cleanup, we could consider making these public.
+ * */
+struct slapi_task {
+ struct slapi_task *next;
+ char *task_dn;
+ int task_exitcode; /* for the end user */
+ int task_state; /* current state of task */
+ int task_progress; /* number between 0 and task_work */
+ int task_work; /* "units" of work to be done */
+ int task_flags; /* (see above) */
+ char *task_status; /* transient status info */
+ char *task_log; /* appended warnings, etc */
+ void *task_private; /* allow opaque data to be stashed in the task */
+ TaskCallbackFn cancel; /* task has been cancelled by user */
+ TaskCallbackFn destructor; /* task entry is being destroyed */
+ int task_refcount;
+} slapi_task;
+/* End of interface to support online tasks **********************************/
+
typedef struct slapi_pblock {
/* common */
Slapi_Backend *pb_backend;
@@ -2016,10 +2037,6 @@ extern char *attr_dataversion;
#include "intrinsics.h"
-/* task flag (pb_task_flags)*/
-#define TASK_RUNNING_AS_TASK 0x0
-#define TASK_RUNNING_FROM_COMMANDLINE 0x1
-
/* printkey: import & export */
#define EXPORT_PRINTKEY 0x1
#define EXPORT_NOWRAP 0x2
diff --git a/ldap/servers/slapd/slapi-plugin.h b/ldap/servers/slapd/slapi-plugin.h
index f963621e..b7f5f927 100644
--- a/ldap/servers/slapd/slapi-plugin.h
+++ b/ldap/servers/slapd/slapi-plugin.h
@@ -149,9 +149,10 @@ typedef struct slapi_rdn Slapi_RDN;
typedef struct slapi_mod Slapi_Mod;
typedef struct slapi_mods Slapi_Mods;
typedef struct slapi_componentid Slapi_ComponentId;
+
/* Online tasks interface (to support import, export, etc) */
-typedef struct _slapi_task Slapi_Task;
-typedef int (*TaskCallbackFn)(Slapi_Task *task);
+typedef struct slapi_task Slapi_Task;
+typedef void (*TaskCallbackFn)(Slapi_Task *task);
/*
* The default thread stacksize for nspr21 is 64k (except on IRIX! It's 32k!).
@@ -1206,6 +1207,22 @@ void slapi_register_role_check(roles_check_fn_type check_fn);
typedef int (*dseCallbackFn)(Slapi_PBlock *, Slapi_Entry *, Slapi_Entry *,
int *, char*, void *);
+/*
+ * Note: DSE callback functions MUST return one of these three values:
+ *
+ * SLAPI_DSE_CALLBACK_OK -- no errors occurred; apply changes.
+ * SLAPI_DSE_CALLBACK_ERROR -- an error occurred; don't apply changes.
+ * SLAPI_DSE_CALLBACK_DO_NOT_APPLY -- no error, but do not apply changes.
+ *
+ * SLAPI_DSE_CALLBACK_DO_NOT_APPLY should only be returned by modify
+ * callbacks (i.e., those registered with operation==SLAPI_OPERATION_MODIFY).
+ * A return value of SLAPI_DSE_CALLBACK_DO_NOT_APPLY is treated the same as
+ * SLAPI_DSE_CALLBACK_ERROR for all other operations.
+ */
+#define SLAPI_DSE_CALLBACK_OK (1)
+#define SLAPI_DSE_CALLBACK_ERROR (-1)
+#define SLAPI_DSE_CALLBACK_DO_NOT_APPLY (0)
+
/******************************************************************************
* Online tasks interface (to support import, export, etc)
* After some cleanup, we could consider making these public.
@@ -1217,10 +1234,26 @@ typedef int (*dseCallbackFn)(Slapi_PBlock *, Slapi_Entry *, Slapi_Entry *,
#define SLAPI_TASK_FINISHED 2
#define SLAPI_TASK_CANCELLED 3
+/* task flag (pb_task_flags)*/
+#define SLAPI_TASK_RUNNING_AS_TASK 0x0
+#define SLAPI_TASK_RUNNING_FROM_COMMANDLINE 0x1
+
/* task flags (set by the task-control code) */
#define SLAPI_TASK_DESTROYING 0x01 /* queued event for destruction */
int slapi_task_register_handler(const char *name, dseCallbackFn func);
+void slapi_task_begin(Slapi_Task *task, int total_work);
+void slapi_task_inc_progress(Slapi_Task *task);
+void slapi_task_finish(Slapi_Task *task, int rc);
+void slapi_task_cancel(Slapi_Task *task, int rc);
+int slapi_task_get_state(Slapi_Task *task);
+void slapi_task_set_data(Slapi_Task *task, void *data);
+void * slapi_task_get_data(Slapi_Task *task);
+void slapi_task_inc_refcount(Slapi_Task *task);
+void slapi_task_dec_refcount(Slapi_Task *task);
+int slapi_task_get_refcount(Slapi_Task *task);
+void slapi_task_set_destructor_fn(Slapi_Task *task, TaskCallbackFn func);
+void slapi_task_set_cancel_fn(Slapi_Task *task, TaskCallbackFn func);
void slapi_task_status_changed(Slapi_Task *task);
void slapi_task_log_status(Slapi_Task *task, char *format, ...)
#ifdef __GNUC__
diff --git a/ldap/servers/slapd/slapi-private.h b/ldap/servers/slapd/slapi-private.h
index 834ce46d..1225e8d5 100644
--- a/ldap/servers/slapd/slapi-private.h
+++ b/ldap/servers/slapd/slapi-private.h
@@ -1060,22 +1060,6 @@ int slapi_uniqueIDGenerateFromNameString(char **uId,
*/
/*
- * Note: DSE callback functions MUST return one of these three values:
- *
- * SLAPI_DSE_CALLBACK_OK -- no errors occurred; apply changes.
- * SLAPI_DSE_CALLBACK_ERROR -- an error occurred; don't apply changes.
- * SLAPI_DSE_CALLBACK_DO_NOT_APPLY -- no error, but do not apply changes.
- *
- * SLAPI_DSE_CALLBACK_DO_NOT_APPLY should only be returned by modify
- * callbacks (i.e., those registered with operation==SLAPI_OPERATION_MODIFY).
- * A return value of SLAPI_DSE_CALLBACK_DO_NOT_APPLY is treated the same as
- * SLAPI_DSE_CALLBACK_ERROR for all other operations.
- */
-#define SLAPI_DSE_CALLBACK_OK (1)
-#define SLAPI_DSE_CALLBACK_ERROR (-1)
-#define SLAPI_DSE_CALLBACK_DO_NOT_APPLY (0)
-
-/*
* Flags for slapi_config_register_callback() and
* slapi_config_remove_callback()
*/
@@ -1198,30 +1182,6 @@ int slapd_re_init( void );
/***** End of items added for the replication plugin. ***********************/
-/******************************************************************************
- * Online tasks interface (to support import, export, etc)
- * After some cleanup, we could consider making these public.
- */
-struct _slapi_task {
- struct _slapi_task *next;
- char *task_dn;
- int task_exitcode; /* for the end user */
- int task_state; /* (see above) */
- int task_progress; /* number between 0 and task_work */
- int task_work; /* "units" of work to be done */
- int task_flags; /* (see above) */
-
- /* it is the task's responsibility to allocate this memory & free it: */
- char *task_status; /* transient status info */
- char *task_log; /* appended warnings, etc */
-
- void *task_private; /* for use by backends */
- TaskCallbackFn cancel; /* task has been cancelled by user */
- TaskCallbackFn destructor; /* task entry is being destroyed */
- int task_refcount;
-};
-/* End of interface to support online tasks **********************************/
-
void DS_Sleep(PRIntervalTime ticks);
/* macro to specify the behavior of upgradedb */
diff --git a/ldap/servers/slapd/task.c b/ldap/servers/slapd/task.c
index 13606c1c..67c93c16 100644
--- a/ldap/servers/slapd/task.c
+++ b/ldap/servers/slapd/task.c
@@ -47,6 +47,9 @@
#include "slap.h"
+/***********************************
+ * Static Global Variables
+ ***********************************/
/* don't panic, this is only used when creating new tasks or removing old
* ones...
*/
@@ -54,7 +57,9 @@ static Slapi_Task *global_task_list = NULL;
static PRLock *global_task_lock = NULL;
static int shutting_down = 0;
-
+/***********************************
+ * Private Defines
+ ***********************************/
#define TASK_BASE_DN "cn=tasks, cn=config"
#define TASK_IMPORT_DN "cn=import, cn=tasks, cn=config"
#define TASK_EXPORT_DN "cn=export, cn=tasks, cn=config"
@@ -71,13 +76,398 @@ static int shutting_down = 0;
#define DEFAULT_TTL "120" /* seconds */
+#define LOG_BUFFER 256
+/* if the cumul. log gets larger than this, it's truncated: */
+#define MAX_SCROLLBACK_BUFFER 8192
+#define NEXTMOD(_type, _val) do { \
+ modlist[cur].mod_op = LDAP_MOD_REPLACE; \
+ modlist[cur].mod_type = (_type); \
+ modlist[cur].mod_values = (char **)slapi_ch_malloc(2*sizeof(char *)); \
+ modlist[cur].mod_values[0] = (_val); \
+ modlist[cur].mod_values[1] = NULL; \
+ mod[cur] = &modlist[cur]; \
+ cur++; \
+} while (0)
+
+
+/***********************************
+ * Static Function Prototypes
+ ***********************************/
+static Slapi_Task *new_task(const char *dn);
+static void destroy_task(time_t when, void *arg);
static int task_modify(Slapi_PBlock *pb, Slapi_Entry *e,
Slapi_Entry *eAfter, int *returncode, char *returntext, void *arg);
static int task_deny(Slapi_PBlock *pb, Slapi_Entry *e,
Slapi_Entry *eAfter, int *returncode, char *returntext, void *arg);
-static int task_generic_destructor(Slapi_Task *task);
+static void task_generic_destructor(Slapi_Task *task);
+static const char *fetch_attr(Slapi_Entry *e, const char *attrname,
+ const char *default_val);
+static Slapi_Entry *get_internal_entry(Slapi_PBlock *pb, char *dn);
+static void modify_internal_entry(char *dn, LDAPMod **mods);
+
+/***********************************
+ * Public Functions
+ ***********************************/
+/*
+ * slapi_new_task: create a new task, fill in DN, and setup modify callback
+ * argument:
+ * dn: task dn
+ * result:
+ * Success: Slapi_Task object
+ * Failure: NULL
+ */
+Slapi_Task *
+slapi_new_task(const char *dn)
+{
+ return new_task(dn);
+}
+
+/* slapi_destroy_task: destroy a task
+ * argument:
+ * task: task to destroy
+ * result:
+ * none
+ */
+void
+slapi_destroy_task(void *arg)
+{
+ if (arg) {
+ destroy_task(1, arg);
+ }
+}
+
+/*
+ * Sets the initial task state and updated status
+ */
+void slapi_task_begin(Slapi_Task *task, int total_work)
+{
+ if (task) {
+ task->task_work = total_work;
+ task->task_progress = 0;
+ task->task_state = SLAPI_TASK_RUNNING;
+ slapi_task_status_changed(task);
+ }
+}
+
+/*
+ * Increments task progress and updates status
+ */
+void slapi_task_inc_progress(Slapi_Task *task)
+{
+ if (task) {
+ task->task_progress++;
+ slapi_task_status_changed(task);
+ }
+}
+
+/*
+ * Sets completed task state and updates status
+ */
+void slapi_task_finish(Slapi_Task *task, int rc)
+{
+ if (task) {
+ task->task_exitcode = rc;
+ task->task_state = SLAPI_TASK_FINISHED;
+ slapi_task_status_changed(task);
+ }
+}
+
+/*
+ * Cancels a task
+ */
+void slapi_task_cancel(Slapi_Task *task, int rc)
+{
+ if (task) {
+ task->task_exitcode = rc;
+ task->task_state = SLAPI_TASK_CANCELLED;
+ slapi_task_status_changed(task);
+ }
+}
+
+/*
+ * Get the current state of a task
+ */
+int slapi_task_get_state(Slapi_Task *task)
+{
+ if (task) {
+ return task->task_state;
+ }
+}
+
+/* this changes the 'nsTaskStatus' value, which is transient (anything logged
+ * here wipes out any previous status)
+ */
+void slapi_task_log_status(Slapi_Task *task, char *format, ...)
+{
+ va_list ap;
+
+ if (! task->task_status)
+ task->task_status = (char *)slapi_ch_malloc(10 * LOG_BUFFER);
+ if (! task->task_status)
+ return; /* out of memory? */
+
+ va_start(ap, format);
+ PR_vsnprintf(task->task_status, (10 * LOG_BUFFER), format, ap);
+ va_end(ap);
+ slapi_task_status_changed(task);
+}
+
+/* this adds a line to the 'nsTaskLog' value, which is cumulative (anything
+ * logged here is added to the end)
+ */
+void slapi_task_log_notice(Slapi_Task *task, char *format, ...)
+{
+ va_list ap;
+ char buffer[LOG_BUFFER];
+ size_t len;
+
+ va_start(ap, format);
+ PR_vsnprintf(buffer, LOG_BUFFER, format, ap);
+ va_end(ap);
+
+ len = 2 + strlen(buffer) + (task->task_log ? strlen(task->task_log) : 0);
+ if ((len > MAX_SCROLLBACK_BUFFER) && task->task_log) {
+ size_t i;
+ char *newbuf;
+
+ /* start from middle of buffer, and find next linefeed */
+ i = strlen(task->task_log)/2;
+ while (task->task_log[i] && (task->task_log[i] != '\n'))
+ i++;
+ if (task->task_log[i])
+ i++;
+ len = strlen(task->task_log) - i + 2 + strlen(buffer);
+ newbuf = (char *)slapi_ch_malloc(len);
+ if (! newbuf)
+ return; /* out of memory? */
+ strcpy(newbuf, task->task_log + i);
+ slapi_ch_free((void **)&task->task_log);
+ task->task_log = newbuf;
+ } else {
+ if (! task->task_log) {
+ task->task_log = (char *)slapi_ch_malloc(len);
+ task->task_log[0] = 0;
+ } else {
+ task->task_log = (char *)slapi_ch_realloc(task->task_log, len);
+ }
+ if (! task->task_log)
+ return; /* out of memory? */
+ }
+
+ if (task->task_log[0])
+ strcat(task->task_log, "\n");
+ strcat(task->task_log, buffer);
+
+ slapi_task_status_changed(task);
+}
+
+/* update attributes in the entry under "cn=tasks" to match the current
+ * status of the task. */
+void slapi_task_status_changed(Slapi_Task *task)
+{
+ LDAPMod modlist[20];
+ LDAPMod *mod[20];
+ int cur = 0, i;
+ char s1[20], s2[20], s3[20];
+
+ if (shutting_down) {
+ /* don't care about task status updates anymore */
+ return;
+ }
+
+ NEXTMOD(TASK_LOG_NAME, task->task_log);
+ NEXTMOD(TASK_STATUS_NAME, task->task_status);
+ sprintf(s1, "%d", task->task_exitcode);
+ sprintf(s2, "%d", task->task_progress);
+ sprintf(s3, "%d", task->task_work);
+ NEXTMOD(TASK_PROGRESS_NAME, s2);
+ NEXTMOD(TASK_WORK_NAME, s3);
+ /* only add the exit code when the job is done */
+ if ((task->task_state == SLAPI_TASK_FINISHED) ||
+ (task->task_state == SLAPI_TASK_CANCELLED)) {
+ NEXTMOD(TASK_EXITCODE_NAME, s1);
+ /* make sure the console can tell the task has ended */
+ if (task->task_progress != task->task_work) {
+ task->task_progress = task->task_work;
+ }
+ }
+
+ mod[cur] = NULL;
+ modify_internal_entry(task->task_dn, mod);
+
+ for (i = 0; i < cur; i++)
+ slapi_ch_free((void **)&modlist[i].mod_values);
+
+ if (((task->task_state == SLAPI_TASK_FINISHED) ||
+ (task->task_state == SLAPI_TASK_CANCELLED)) &&
+ !(task->task_flags & SLAPI_TASK_DESTROYING)) {
+ Slapi_PBlock *pb = slapi_pblock_new();
+ Slapi_Entry *e;
+ int ttl;
+ time_t expire;
+
+ e = get_internal_entry(pb, task->task_dn);
+ if (e == NULL)
+ return;
+ ttl = atoi(fetch_attr(e, "ttl", DEFAULT_TTL));
+ if (ttl > 3600)
+ ttl = 3600; /* be reasonable. */
+ expire = time(NULL) + ttl;
+ task->task_flags |= SLAPI_TASK_DESTROYING;
+ /* queue an event to destroy the state info */
+ slapi_eq_once(destroy_task, (void *)task, expire);
+
+ slapi_free_search_results_internal(pb);
+ slapi_pblock_destroy(pb);
+ }
+}
+
+/*
+ * Stash some opaque task specific data in the task for later use.
+ */
+void slapi_task_set_data(Slapi_Task *task, void *data)
+{
+ if (task) {
+ task->task_private = data;
+ }
+}
+
+/*
+ * Retrieve some opaque task specific data from the task.
+ */
+void * slapi_task_get_data(Slapi_Task *task)
+{
+ if (task) {
+ return task->task_private;
+ }
+}
+
+/*
+ * Increment the task reference count
+ */
+void slapi_task_inc_refcount(Slapi_Task *task)
+{
+ if (task) {
+ task->task_refcount++;
+ }
+}
+
+/*
+ * Decrement the task reference count
+ */
+void slapi_task_dec_refcount(Slapi_Task *task)
+{
+ if (task) {
+ task->task_refcount--;
+ }
+}
+
+/*
+ * Returns the task reference count
+ */
+int slapi_task_get_refcount(Slapi_Task *task)
+{
+ if (task) {
+ return task->task_refcount;
+ }
+}
+
+/* name is, for example, "import" */
+int slapi_task_register_handler(const char *name, dseCallbackFn func)
+{
+ char *dn = NULL;
+ Slapi_PBlock *pb = NULL;
+ Slapi_Operation *op;
+ LDAPMod *mods[3];
+ LDAPMod mod[3];
+ const char *objectclass[3];
+ const char *cnvals[2];
+ int ret = -1;
+ int x;
+
+ dn = slapi_ch_smprintf("cn=%s, %s", name, TASK_BASE_DN);
+ if (dn == NULL) {
+ goto out;
+ }
+
+ pb = slapi_pblock_new();
+ if (pb == NULL) {
+ goto out;
+ }
+
+ /* this is painful :( */
+ mods[0] = &mod[0];
+ mod[0].mod_op = LDAP_MOD_ADD;
+ mod[0].mod_type = "objectClass";
+ mod[0].mod_values = (char **)objectclass;
+ objectclass[0] = "top";
+ objectclass[1] = "extensibleObject";
+ objectclass[2] = NULL;
+ mods[1] = &mod[1];
+ mod[1].mod_op = LDAP_MOD_ADD;
+ mod[1].mod_type = "cn";
+ mod[1].mod_values = (char **)cnvals;
+ cnvals[0] = name;
+ cnvals[1] = NULL;
+ mods[2] = NULL;
+ slapi_add_internal_set_pb(pb, dn, mods, NULL,
+ plugin_get_default_component_id(), 0);
+ x = 1;
+ slapi_pblock_set(pb, SLAPI_DSE_DONT_WRITE_WHEN_ADDING, &x);
+ /* Make sure these adds don't appear in the audit and change logs */
+ slapi_pblock_get(pb, SLAPI_OPERATION, &op);
+ operation_set_flag(op, OP_FLAG_ACTION_NOLOG);
+
+ slapi_add_internal_pb(pb);
+ slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &x);
+ if ((x != LDAP_SUCCESS) && (x != LDAP_ALREADY_EXISTS)) {
+ LDAPDebug(LDAP_DEBUG_ANY,
+ "Can't create task node '%s' (error %d)\n",
+ name, x, 0);
+ ret = x;
+ goto out;
+ }
+
+ /* register add callback */
+ slapi_config_register_callback(SLAPI_OPERATION_ADD, DSE_FLAG_PREOP,
+ dn, LDAP_SCOPE_SUBTREE, "(objectclass=*)", func, NULL);
+ /* deny modify/delete of the root task entry */
+ slapi_config_register_callback(SLAPI_OPERATION_MODIFY, DSE_FLAG_PREOP,
+ dn, LDAP_SCOPE_BASE, "(objectclass=*)", task_deny, NULL);
+ slapi_config_register_callback(SLAPI_OPERATION_DELETE, DSE_FLAG_PREOP,
+ dn, LDAP_SCOPE_BASE, "(objectclass=*)", task_deny, NULL);
+
+ ret = 0;
+
+out:
+ if (dn) {
+ slapi_ch_free((void **)&dn);
+ }
+ if (pb) {
+ slapi_pblock_destroy(pb);
+ }
+ return ret;
+}
+
+void slapi_task_set_destructor_fn(Slapi_Task *task, TaskCallbackFn func)
+{
+ if (task) {
+ task->destructor = func;
+ }
+}
+
+void slapi_task_set_cancel_fn(Slapi_Task *task, TaskCallbackFn func)
+{
+ if (task) {
+ task->cancel = func;
+ }
+}
+
+/***********************************
+ * Static Helper Functions
+ ***********************************/
/* create a new task, fill in DN, and setup modify callback */
static Slapi_Task *
new_task(const char *dn)
@@ -92,7 +482,11 @@ new_task(const char *dn)
PR_Unlock(global_task_lock);
task->task_dn = slapi_ch_strdup(dn);
- task->destructor = task_generic_destructor;
+ task->task_state = SLAPI_TASK_SETUP;
+ task->task_flags = SLAPI_TASK_RUNNING_AS_TASK;
+ task->destructor = NULL;
+ task->cancel = NULL;
+ task->task_private = NULL;
slapi_config_register_callback(SLAPI_OPERATION_MODIFY, DSE_FLAG_PREOP, dn,
LDAP_SCOPE_BASE, "(objectclass=*)", task_modify, (void *)task);
slapi_config_register_callback(SLAPI_OPERATION_DELETE, DSE_FLAG_PREOP, dn,
@@ -100,8 +494,8 @@ new_task(const char *dn)
/* don't add entries under this one */
#if 0
/* don't know why, but this doesn't work. it makes the current add
- * operation fail. :(
- */
+ * * operation fail. :(
+ * */
slapi_config_register_callback(SLAPI_OPERATION_ADD, DSE_FLAG_PREOP, dn,
LDAP_SCOPE_SUBTREE, "(objectclass=*)", task_deny, NULL);
#endif
@@ -117,8 +511,13 @@ destroy_task(time_t when, void *arg)
Slapi_Task *t1;
Slapi_PBlock *pb = slapi_pblock_new();
- if (task->destructor != NULL)
+ /* Call the custom destructor callback if one was provided,
+ * then perform the internal task destruction. */
+ if (task->destructor != NULL) {
(*task->destructor)(task);
+ }
+
+ task_generic_destructor(task);
/* if when == 0, we're already locked (called during shutdown) */
if (when != 0) {
@@ -152,35 +551,6 @@ destroy_task(time_t when, void *arg)
slapi_ch_free((void **)&task);
}
-/*
- * slapi_new_task: create a new task, fill in DN, and setup modify callback
- * argument:
- * dn: task dn
- * result:
- * Success: Slapi_Task object
- * Failure: NULL
- */
-Slapi_Task *
-slapi_new_task(const char *dn)
-{
- return new_task(dn);
-}
-
-/* slapi_destroy_task: destroy a task
- * argument:
- * task: task to destroy
- * result:
- * none
- */
-void
-slapi_destroy_task(void *arg)
-{
- destroy_task(1, arg);
-}
-
-/********** some useful helper functions **********/
-
-
/* extract a single value from the entry (as a string) -- if it's not in the
* entry, the default will be returned (which can be NULL).
* you do not need to free anything returned by this.
@@ -268,81 +638,7 @@ static void modify_internal_entry(char *dn, LDAPMod **mods)
} while (ret != LDAP_SUCCESS);
}
-
-/********** helper functions for dealing with task logging **********/
-
-#define LOG_BUFFER 256
-/* if the cumul. log gets larger than this, it's truncated: */
-#define MAX_SCROLLBACK_BUFFER 8192
-
-/* this changes the 'nsTaskStatus' value, which is transient (anything logged
- * here wipes out any previous status)
- */
-void slapi_task_log_status(Slapi_Task *task, char *format, ...)
-{
- va_list ap;
-
- if (! task->task_status)
- task->task_status = (char *)slapi_ch_malloc(10 * LOG_BUFFER);
- if (! task->task_status)
- return; /* out of memory? */
-
- va_start(ap, format);
- PR_vsnprintf(task->task_status, (10 * LOG_BUFFER), format, ap);
- va_end(ap);
- slapi_task_status_changed(task);
-}
-
-/* this adds a line to the 'nsTaskLog' value, which is cumulative (anything
- * logged here is added to the end)
- */
-void slapi_task_log_notice(Slapi_Task *task, char *format, ...)
-{
- va_list ap;
- char buffer[LOG_BUFFER];
- size_t len;
-
- va_start(ap, format);
- PR_vsnprintf(buffer, LOG_BUFFER, format, ap);
- va_end(ap);
-
- len = 2 + strlen(buffer) + (task->task_log ? strlen(task->task_log) : 0);
- if ((len > MAX_SCROLLBACK_BUFFER) && task->task_log) {
- size_t i;
- char *newbuf;
-
- /* start from middle of buffer, and find next linefeed */
- i = strlen(task->task_log)/2;
- while (task->task_log[i] && (task->task_log[i] != '\n'))
- i++;
- if (task->task_log[i])
- i++;
- len = strlen(task->task_log) - i + 2 + strlen(buffer);
- newbuf = (char *)slapi_ch_malloc(len);
- if (! newbuf)
- return; /* out of memory? */
- strcpy(newbuf, task->task_log + i);
- slapi_ch_free((void **)&task->task_log);
- task->task_log = newbuf;
- } else {
- if (! task->task_log) {
- task->task_log = (char *)slapi_ch_malloc(len);
- task->task_log[0] = 0;
- } else {
- task->task_log = (char *)slapi_ch_realloc(task->task_log, len);
- }
- if (! task->task_log)
- return; /* out of memory? */
- }
-
- if (task->task_log[0])
- strcat(task->task_log, "\n");
- strcat(task->task_log, buffer);
-
- slapi_task_status_changed(task);
-}
-
-static int task_generic_destructor(Slapi_Task *task)
+static void task_generic_destructor(Slapi_Task *task)
{
if (task->task_log) {
slapi_ch_free((void **)&task->task_log);
@@ -351,7 +647,6 @@ static int task_generic_destructor(Slapi_Task *task)
slapi_ch_free((void **)&task->task_status);
}
task->task_log = task->task_status = NULL;
- return 0;
}
@@ -553,13 +848,12 @@ static int task_import_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
rv = LDAP_OPERATIONS_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
memset(&mypb, 0, sizeof(mypb));
mypb.pb_backend = be;
@@ -575,7 +869,7 @@ static int task_import_add(Slapi_PBlock *pb, Slapi_Entry *e,
mypb.pb_ldif_include = include;
mypb.pb_ldif_exclude = exclude;
mypb.pb_task = task;
- mypb.pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb.pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
if (NULL != encrypt_on_import && 0 == strcasecmp(encrypt_on_import, "true") ) {
mypb.pb_ldif_encrypt = 1;
}
@@ -618,10 +912,7 @@ static void task_export_thread(void *arg)
g_incr_active_threadcnt();
for (count = 0, inp = instance_names; *inp; inp++, count++)
;
- task->task_work = count;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
- slapi_task_status_changed(task);
+ slapi_task_begin(task, count);
for (inp = instance_names; *inp; inp++) {
int release_me = 0;
@@ -693,8 +984,7 @@ static void task_export_thread(void *arg)
if (rv != 0)
break;
- task->task_progress++;
- slapi_task_status_changed(task);
+ slapi_task_inc_progress(task);
}
/* free the memory now */
@@ -712,9 +1002,7 @@ static void task_export_thread(void *arg)
LDAPDebug(LDAP_DEBUG_ANY, "Export failed.\n", 0, 0, 0);
}
- task->task_exitcode = rv;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
+ slapi_task_finish(task, rv);
g_decr_active_threadcnt();
}
@@ -888,16 +1176,13 @@ static int task_export_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = instance_cnt;
- task->task_progress = 0;
mypb = slapi_pblock_new();
if (mypb == NULL) {
@@ -914,7 +1199,7 @@ static int task_export_add(Slapi_PBlock *pb, Slapi_Entry *e,
/* horrible hack */
mypb->pb_instance_name = (char *)instance_names;
mypb->pb_task = task;
- mypb->pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb->pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
if (NULL != decrypt_on_export && 0 == strcasecmp(decrypt_on_export, "true") ) {
mypb->pb_ldif_encrypt = 1;
}
@@ -957,10 +1242,7 @@ static void task_backup_thread(void *arg)
int rv;
g_incr_active_threadcnt();
- task->task_work = 1;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
- slapi_task_status_changed(task);
+ slapi_task_begin(task, 1);
slapi_task_log_notice(task, "Beginning backup of '%s'",
pb->pb_plugin->plg_name);
@@ -978,11 +1260,7 @@ static void task_backup_thread(void *arg)
LDAPDebug(LDAP_DEBUG_ANY, "Backup finished.\n", 0, 0, 0);
}
- task->task_progress = 1;
- task->task_exitcode = rv;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
-
+ slapi_task_finish(task, rv);
slapi_ch_free((void **)&pb->pb_seq_val);
slapi_pblock_destroy(pb);
g_decr_active_threadcnt();
@@ -1048,16 +1326,13 @@ static int task_backup_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = 1;
- task->task_progress = 0;
mypb = slapi_pblock_new();
if (mypb == NULL) {
@@ -1068,7 +1343,7 @@ static int task_backup_add(Slapi_PBlock *pb, Slapi_Entry *e,
mypb->pb_seq_val = slapi_ch_strdup(archive_dir);
mypb->pb_plugin = be->be_database;
mypb->pb_task = task;
- mypb->pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb->pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
/* start the backup as a separate thread */
thread = PR_CreateThread(PR_USER_THREAD, task_backup_thread,
@@ -1102,10 +1377,7 @@ static void task_restore_thread(void *arg)
int rv;
g_incr_active_threadcnt();
- task->task_work = 1;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
- slapi_task_status_changed(task);
+ slapi_task_begin(task, 1);
slapi_task_log_notice(task, "Beginning restore to '%s'",
pb->pb_plugin->plg_name);
@@ -1123,11 +1395,7 @@ static void task_restore_thread(void *arg)
LDAPDebug(LDAP_DEBUG_ANY, "Restore finished.\n", 0, 0, 0);
}
- task->task_progress = 1;
- task->task_exitcode = rv;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
-
+ slapi_task_finish(task, rv);
slapi_ch_free((void **)&pb->pb_seq_val);
slapi_pblock_destroy(pb);
g_decr_active_threadcnt();
@@ -1199,16 +1467,13 @@ static int task_restore_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = 1;
- task->task_progress = 0;
mypb = slapi_pblock_new();
if (mypb == NULL) {
@@ -1221,7 +1486,7 @@ static int task_restore_add(Slapi_PBlock *pb, Slapi_Entry *e,
if (NULL != instance_name)
mypb->pb_instance_name = slapi_ch_strdup(instance_name);
mypb->pb_task = task;
- mypb->pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb->pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
/* start the restore as a separate thread */
thread = PR_CreateThread(PR_USER_THREAD, task_restore_thread,
@@ -1255,10 +1520,7 @@ static void task_index_thread(void *arg)
int rv;
g_incr_active_threadcnt();
- task->task_work = 1;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
- slapi_task_status_changed(task);
+ slapi_task_begin(task, 1);
rv = (*pb->pb_plugin->plg_db2index)(pb);
if (rv != 0) {
@@ -1267,11 +1529,7 @@ static void task_index_thread(void *arg)
LDAPDebug(LDAP_DEBUG_ANY, "Index failed (error %d)\n", rv, 0, 0);
}
- task->task_progress = task->task_work;
- task->task_exitcode = rv;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
-
+ slapi_task_finish(task, rv);
charray_free(pb->pb_db2index_attrs);
slapi_ch_free((void **)&pb->pb_instance_name);
slapi_pblock_destroy(pb);
@@ -1353,16 +1611,13 @@ static int task_index_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = 1;
- task->task_progress = 0;
mypb = slapi_pblock_new();
if (mypb == NULL) {
@@ -1375,7 +1630,7 @@ static int task_index_add(Slapi_PBlock *pb, Slapi_Entry *e,
mypb->pb_instance_name = slapi_ch_strdup(instance_name);
mypb->pb_db2index_attrs = indexlist;
mypb->pb_task = task;
- mypb->pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb->pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
/* start the db2index as a separate thread */
thread = PR_CreateThread(PR_USER_THREAD, task_index_thread,
@@ -1460,14 +1715,14 @@ task_upgradedb_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter,
}
/* allocate new task now */
- task = new_task(slapi_entry_get_ndn(e));
+ task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
+ /* NGK - This could use some cleanup to use the SLAPI task API, such as slapi_task_begin() */
task->task_work = 1;
task->task_progress = 0;
@@ -1478,7 +1733,7 @@ task_upgradedb_add(Slapi_PBlock *pb, Slapi_Entry *e, Slapi_Entry *eAfter,
mypb.pb_seq_type = SLAPI_UPGRADEDB_FORCE; /* force; reindex all regardless the dbversion */
mypb.pb_seq_val = slapi_ch_strdup(archive_dir);
mypb.pb_task = task;
- mypb.pb_task_flags = TASK_RUNNING_AS_TASK;
+ mypb.pb_task_flags = SLAPI_TASK_RUNNING_AS_TASK;
rv = (mypb.pb_plugin->plg_upgradedb)(&mypb);
if (rv == 0) {
@@ -1502,76 +1757,6 @@ out:
return SLAPI_DSE_CALLBACK_OK;
}
-/* update attributes in the entry under "cn=tasks" to match the current
- * status of the task.
- */
-#define NEXTMOD(_type, _val) do { \
- modlist[cur].mod_op = LDAP_MOD_REPLACE; \
- modlist[cur].mod_type = (_type); \
- modlist[cur].mod_values = (char **)slapi_ch_malloc(2*sizeof(char *)); \
- modlist[cur].mod_values[0] = (_val); \
- modlist[cur].mod_values[1] = NULL; \
- mod[cur] = &modlist[cur]; \
- cur++; \
-} while (0)
-void slapi_task_status_changed(Slapi_Task *task)
-{
- LDAPMod modlist[20];
- LDAPMod *mod[20];
- int cur = 0, i;
- char s1[20], s2[20], s3[20];
-
- if (shutting_down) {
- /* don't care about task status updates anymore */
- return;
- }
-
- NEXTMOD(TASK_LOG_NAME, task->task_log);
- NEXTMOD(TASK_STATUS_NAME, task->task_status);
- sprintf(s1, "%d", task->task_exitcode);
- sprintf(s2, "%d", task->task_progress);
- sprintf(s3, "%d", task->task_work);
- NEXTMOD(TASK_PROGRESS_NAME, s2);
- NEXTMOD(TASK_WORK_NAME, s3);
- /* only add the exit code when the job is done */
- if ((task->task_state == SLAPI_TASK_FINISHED) ||
- (task->task_state == SLAPI_TASK_CANCELLED)) {
- NEXTMOD(TASK_EXITCODE_NAME, s1);
- /* make sure the console can tell the task has ended */
- if (task->task_progress != task->task_work) {
- task->task_progress = task->task_work;
- }
- }
-
- mod[cur] = NULL;
- modify_internal_entry(task->task_dn, mod);
-
- for (i = 0; i < cur; i++)
- slapi_ch_free((void **)&modlist[i].mod_values);
-
- if ((task->task_state == SLAPI_TASK_FINISHED) &&
- !(task->task_flags & SLAPI_TASK_DESTROYING)) {
- Slapi_PBlock *pb = slapi_pblock_new();
- Slapi_Entry *e;
- int ttl;
- time_t expire;
-
- e = get_internal_entry(pb, task->task_dn);
- if (e == NULL)
- return;
- ttl = atoi(fetch_attr(e, "ttl", DEFAULT_TTL));
- if (ttl > 3600)
- ttl = 3600; /* be reasonable. */
- expire = time(NULL) + ttl;
- task->task_flags |= SLAPI_TASK_DESTROYING;
- /* queue an event to destroy the state info */
- slapi_eq_once(destroy_task, (void *)task, expire);
-
- slapi_free_search_results_internal(pb);
- slapi_pblock_destroy(pb);
- }
-}
-
/* cleanup old tasks that may still be in the DSE from a previous session
* (this can happen if the server crashes [no matter how unlikely we like
* to think that is].)
@@ -1636,84 +1821,6 @@ void task_cleanup(void)
slapi_pblock_destroy(pb);
}
-/* name is, for exmaple, "import" */
-int slapi_task_register_handler(const char *name, dseCallbackFn func)
-{
- char *dn = NULL;
- Slapi_PBlock *pb = NULL;
- Slapi_Operation *op;
- LDAPMod *mods[3];
- LDAPMod mod[3];
- const char *objectclass[3];
- const char *cnvals[2];
- int ret = -1;
- int x;
-
- dn = slapi_ch_smprintf("cn=%s, %s", name, TASK_BASE_DN);
- if (dn == NULL) {
- goto out;
- }
-
- pb = slapi_pblock_new();
- if (pb == NULL) {
- goto out;
- }
-
- /* this is painful :( */
- mods[0] = &mod[0];
- mod[0].mod_op = LDAP_MOD_ADD;
- mod[0].mod_type = "objectClass";
- mod[0].mod_values = (char **)objectclass;
- objectclass[0] = "top";
- objectclass[1] = "extensibleObject";
- objectclass[2] = NULL;
- mods[1] = &mod[1];
- mod[1].mod_op = LDAP_MOD_ADD;
- mod[1].mod_type = "cn";
- mod[1].mod_values = (char **)cnvals;
- cnvals[0] = name;
- cnvals[1] = NULL;
- mods[2] = NULL;
- slapi_add_internal_set_pb(pb, dn, mods, NULL,
- plugin_get_default_component_id(), 0);
- x = 1;
- slapi_pblock_set(pb, SLAPI_DSE_DONT_WRITE_WHEN_ADDING, &x);
- /* Make sure these adds don't appear in the audit and change logs */
- slapi_pblock_get(pb, SLAPI_OPERATION, &op);
- operation_set_flag(op, OP_FLAG_ACTION_NOLOG);
-
- slapi_add_internal_pb(pb);
- slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &x);
- if ((x != LDAP_SUCCESS) && (x != LDAP_ALREADY_EXISTS)) {
- LDAPDebug(LDAP_DEBUG_ANY,
- "Can't create task node '%s' (error %d)\n",
- name, x, 0);
- ret = x;
- goto out;
- }
-
- /* register add callback */
- slapi_config_register_callback(SLAPI_OPERATION_ADD, DSE_FLAG_PREOP,
- dn, LDAP_SCOPE_SUBTREE, "(objectclass=*)", func, NULL);
- /* deny modify/delete of the root task entry */
- slapi_config_register_callback(SLAPI_OPERATION_MODIFY, DSE_FLAG_PREOP,
- dn, LDAP_SCOPE_BASE, "(objectclass=*)", task_deny, NULL);
- slapi_config_register_callback(SLAPI_OPERATION_DELETE, DSE_FLAG_PREOP,
- dn, LDAP_SCOPE_BASE, "(objectclass=*)", task_deny, NULL);
-
- ret = 0;
-
-out:
- if (dn) {
- slapi_ch_free((void **)&dn);
- }
- if (pb) {
- slapi_pblock_destroy(pb);
- }
- return ret;
-}
-
-
void task_init(void)
{
global_task_lock = PR_NewLock();
diff --git a/ldap/servers/slapd/test-plugins/sampletask.c b/ldap/servers/slapd/test-plugins/sampletask.c
index 94f1ade8..357ed5ca 100644
--- a/ldap/servers/slapd/test-plugins/sampletask.c
+++ b/ldap/servers/slapd/test-plugins/sampletask.c
@@ -47,7 +47,7 @@
* objectClass: nsSlapdPlugin
* objectClass: extensibleObject
* cn: sampletask
- * nsslapd-pluginPath: <prefix>/usr/lib/<PACKAGE_NAME>/plugins/libsampletask-plugin.so
+ * nsslapd-pluginPath: libsampletask-plugin
* nsslapd-pluginInitfunc: sampletask_init
* nsslapd-pluginType: object
* nsslapd-pluginEnabled: on
@@ -58,26 +58,26 @@
*
* 4. create a config task entry in dse.ldif
* Task entry:
- * dn: cn=sample task, cn=tasks, cn=config
+ * dn: cn=sampletask, cn=tasks, cn=config
* objectClass: top
* objectClass: extensibleObject
- * cn: sample task
+ * cn: sampletask
*
* 5. to invoke the sample task, run the command line:
* $ ./ldapmodify -h <host> -p <port> -D "cn=Directory Manager" -w <pw> -a
- * dn: cn=sample task 0, cn=sample task, cn=tasks, cn=config
+ * dn: cn=sampletask 0, cn=sample task, cn=tasks, cn=config
* objectClass: top
* objectClass: extensibleObject
* cn: sample task 0
- * arg0: sample task arg0
+ * myarg: sample task myarg
*
* Result is in the errors log
- * [...] - Sample task starts (arg: sample task arg0) ...
+ * [...] - Sample task starts (arg: sample task myarg) ...
* [...] - Sample task finished.
*/
-#include "slap.h"
-#include "slapi-private.h"
+#include "slapi-plugin.h"
+#include "nspr.h"
static int task_sampletask_add(Slapi_PBlock *pb, Slapi_Entry *e,
Slapi_Entry *eAfter, int *returncode, char *returntext,
@@ -118,33 +118,32 @@ task_sampletask_start(Slapi_PBlock *pb)
static void
task_sampletask_thread(void *arg)
{
- Slapi_PBlock *pb = (Slapi_PBlock *)arg;
- Slapi_Task *task = pb->pb_task;
- int rv;
-
- task->task_work = 1;
- task->task_progress = 0;
- task->task_state = SLAPI_TASK_RUNNING;
- slapi_task_status_changed(task);
-
- slapi_task_log_notice(task, "Sample task starts (arg: %s) ...\n",
- pb->pb_seq_val);
- LDAPDebug(LDAP_DEBUG_ANY, "Sample task starts (arg: %s) ...\n",
- pb->pb_seq_val, 0, 0);
- /* do real work */
- rv = 0;
+ Slapi_Task *task = (Slapi_Task *)arg;
+ char *myarg = NULL;
+ int i, rv = 0;
+ int total_work = 3;
+
+ /* fetch our argument from the task */
+ myarg = (char *)slapi_task_get_data(task);
+
+ /* update task state to show it's running */
+ slapi_task_begin(task, total_work);
+ slapi_task_log_notice(task, "Sample task starts (arg: %s) ...\n", myarg);
+ slapi_log_error(SLAPI_LOG_FATAL, "sampletask", "Sample task starts (arg: %s) ...\n", myarg);
+
+ /* real work would be done here */
+ for (i = 0; i < total_work; i++) {
+ PR_Sleep(10000);
+ slapi_task_inc_progress(task);
+ }
+ /* update task state to say we're finished */
slapi_task_log_notice(task, "Sample task finished.");
slapi_task_log_status(task, "Sample task finished.");
- LDAPDebug(LDAP_DEBUG_ANY, "Sample task finished.\n", 0, 0, 0);
-
- task->task_progress = 1;
- task->task_exitcode = rv;
- task->task_state = SLAPI_TASK_FINISHED;
- slapi_task_status_changed(task);
+ slapi_log_error(SLAPI_LOG_FATAL, "sampletask", "Sample task finished.\n");
- slapi_ch_free((void **)&pb->pb_seq_val);
- slapi_pblock_destroy(pb);
+ /* this will queue the destruction of the task */
+ slapi_task_finish(task, rv);
}
/* extract a single value from the entry (as a string) -- if it's not in the
@@ -163,6 +162,17 @@ static const char *fetch_attr(Slapi_Entry *e, const char *attrname,
return slapi_value_get_string(val);
}
+static void
+task_sampletask_destructor(Slapi_Task *task)
+{
+ if (task) {
+ char *myarg = (char *)slapi_task_get_data(task);
+ if (myarg) {
+ slapi_ch_free_string(&myarg);
+ }
+ }
+}
+
/*
* Invoked when the task instance is added by the client (step 5 of the comment)
* Get the necessary attributes from the task entry, and spawns a thread to do
@@ -178,7 +188,7 @@ task_sampletask_add(Slapi_PBlock *pb, Slapi_Entry *e,
int rv = SLAPI_DSE_CALLBACK_OK;
Slapi_PBlock *mypb = NULL;
Slapi_Task *task = NULL;
- const char *arg0;
+ const char *myarg;
*returncode = LDAP_SUCCESS;
if ((cn = fetch_attr(e, "cn", NULL)) == NULL) {
@@ -188,7 +198,7 @@ task_sampletask_add(Slapi_PBlock *pb, Slapi_Entry *e,
}
/* get arg(s) */
- if ((arg0 = fetch_attr(e, "arg0", NULL)) == NULL) {
+ if ((myarg = fetch_attr(e, "myarg", NULL)) == NULL) {
*returncode = LDAP_OBJECT_CLASS_VIOLATION;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
@@ -197,46 +207,33 @@ task_sampletask_add(Slapi_PBlock *pb, Slapi_Entry *e,
/* allocate new task now */
task = slapi_new_task(slapi_entry_get_ndn(e));
if (task == NULL) {
- LDAPDebug(LDAP_DEBUG_ANY, "unable to allocate new task!\n", 0, 0, 0);
+ slapi_log_error(SLAPI_LOG_FATAL, "sampletask", "unable to allocate new task!\n");
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
goto out;
}
- task->task_state = SLAPI_TASK_SETUP;
- task->task_work = 1;
- task->task_progress = 0;
- /* create a pblock to pass the necessary info to the task thread */
- mypb = slapi_pblock_new();
- if (mypb == NULL) {
- *returncode = LDAP_OPERATIONS_ERROR;
- rv = SLAPI_DSE_CALLBACK_ERROR;
- goto out;
- }
- mypb->pb_seq_val = slapi_ch_strdup(arg0);
- mypb->pb_task = task;
- mypb->pb_task_flags = TASK_RUNNING_AS_TASK;
+ /* set a destructor that will clean up myarg for us when the task is complete */
+ slapi_task_set_destructor_fn(task, task_sampletask_destructor);
+
+ /* Stash our argument in the task for use by the task thread */
+ slapi_task_set_data(task, slapi_ch_strdup(myarg));
/* start the sample task as a separate thread */
thread = PR_CreateThread(PR_USER_THREAD, task_sampletask_thread,
- (void *)mypb, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
+ (void *)task, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE);
if (thread == NULL) {
- LDAPDebug(LDAP_DEBUG_ANY,
- "unable to create sample task thread!\n", 0, 0, 0);
+ slapi_log_error(SLAPI_LOG_FATAL, "sampletask",
+ "unable to create sample task thread!\n");
*returncode = LDAP_OPERATIONS_ERROR;
rv = SLAPI_DSE_CALLBACK_ERROR;
- slapi_ch_free((void **)&mypb->pb_seq_val);
- slapi_pblock_destroy(mypb);
- goto out;
+ slapi_task_finish(task, *returncode);
+ } else {
+ /* thread successful */
+ rv = SLAPI_DSE_CALLBACK_OK;
}
- /* thread successful -- don't free the pb, let the thread do that. */
- return SLAPI_DSE_CALLBACK_OK;
-
out:
- if (task) {
- slapi_destroy_task(task);
- }
return rv;
}
generated by cgit (git 2.34.1) at 2024-09-28 11:20:35 +0000