diff options
Diffstat (limited to 'ldap/servers/plugins/replication/cl5_test.c')
| -rw-r--r-- | ldap/servers/plugins/replication/cl5_test.c | 830 |
1 files changed, 830 insertions, 0 deletions
diff --git a/ldap/servers/plugins/replication/cl5_test.c b/ldap/servers/plugins/replication/cl5_test.c new file mode 100644 index 00000000..b64a60f5 --- /dev/null +++ b/ldap/servers/plugins/replication/cl5_test.c @@ -0,0 +1,830 @@ +/** BEGIN COPYRIGHT BLOCK + * Copyright 2001 Sun Microsystems, Inc. + * Portions copyright 1999, 2001-2003 Netscape Communications Corporation. + * All rights reserved. + * END COPYRIGHT BLOCK **/ +/* cl5_test.c - changelog test cases */ +#include "cl5_test.h" +#include "slapi-plugin.h" +#include "cl5.h" + +#define REPLICA_ROOT "dc=example,dc=com" /* replica root */ +#define OP_COUNT 4 /* number of ops generated at a time */ +#define MOD_COUNT 5 +#define VALUE_COUNT 5 +#define ENTRY_COUNT 50 +#define CL_DN "cn=changelog5,cn=config" +#define INSTANCE_ATTR "nsslapd-instancedir" +#define REPLICA_OC "nsds5Replica" +#define REPLICA_RDN "cn=replica" + +static void testBasic (); +static void testBackupRestore (); +static void testIteration (); +static void testTrimming (); +static void testPerformance (); +static void testPerformanceMT (); +static void testLDIF (); +static void testAll (); +static int configureChangelog (); +static int configureReplica (); +static int populateChangelogOp (); +static int populateChangelog (int entryCount, CSN ***csnList); +static int processEntries (int entryCount, CSN **csnList); +static void clearCSNList (CSN ***csnList, int count); +static void threadMain (void *data); +static char* getBaseDir (const char *dir); +static LDAPMod **buildMods (); + +void testChangelog (TestType type) +{ + switch (type) + { + case TEST_BASIC: testBasic (); + break; + case TEST_BACKUP_RESTORE: testBackupRestore (); + break; + case TEST_ITERATION: testIteration (); + break; + case TEST_TRIMMING: testTrimming (); + break; + case TEST_PERFORMANCE: testPerformance (); + break; + case TEST_PERFORMANCE_MT: testPerformanceMT (); + break; + case TEST_LDIF: testLDIF (); + break; + case TEST_ALL: testAll (); + break; + default: printf ("Taste case %d is not supported\n", type); + } +} + +/* tests Open/Close, normal recovery, read/write/remove + of an entry */ +static void testBasic () +{ + int rc = 0; + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting basic test ...\n"); + + /* ONREPL - we can't run the tests from the startup code because + operations can't be issued until all plugins are started. So, + instead, we do it when changelog is created + rc = configureChangelog (); */ + if (rc == 0) + { + rc = configureReplica (); + if (rc == 0) + { + rc = populateChangelogOp (); + } + } + + if (rc == 0) + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Basic test completed successfully\n"); + else + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Basic test failed\n"); +} + +static void testBackupRestore () +{ + char *dir; + int rc = -1; + char *baseDir; + char bkDir [MAXPATHLEN + 1]; + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting backup and recovery test ...\n"); + + dir = cl5GetDir (); + + if (dir) + { + baseDir = getBaseDir (dir); + sprintf (bkDir, "%s/clbackup", baseDir); + slapi_ch_free ((void**)&baseDir); + rc = cl5Backup (bkDir, NULL); + + if (rc == CL5_SUCCESS) + { + cl5Close (); + rc = cl5Restore (dir, bkDir, NULL); + if (rc == CL5_SUCCESS) + rc = cl5Open (dir, NULL); + + /* PR_RmDir (bkDir);*/ + } + } + + if (rc == CL5_SUCCESS) + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Backup and Restore test completed successfully\n"); + else + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Backup and Restore test failed\n"); +} + +static void testIteration () +{ + Object *r_obj; + Slapi_DN *r_root; + Replica *r; + char *replGen; + RUV *ruv; + CL5ReplayIterator *it = NULL; + slapi_operation_parameters op; + int rc; + int i; + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting iteration test ...\n"); + + /* get replica object */ + r_root = slapi_sdn_new_dn_byval(REPLICA_ROOT); + r_obj = replica_get_replica_from_dn (r_root); + slapi_sdn_free (&r_root); + if (r_obj == NULL) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "replica is not configured for (%s)\n", + REPLICA_ROOT); + return; + } + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting first iteration pass ...\n"); + + /* configure empty consumer ruv */ + r = (Replica*)object_get_data (r_obj); + PR_ASSERT (r); + replGen = replica_get_generation (r); + ruv_init_new (replGen, 0, NULL, &ruv); + + /* create replay iterator */ + rc = cl5CreateReplayIterator (r_obj, ruv, &it); + if (it) + { + i = 0; + while ((rc = cl5GetNextOperationToReplay (it, &op)) == CL5_SUCCESS) + { + ruv_set_csns (ruv, op.csn, NULL); + operation_parameters_done (&op); + i ++; + } + } + + if (it) + cl5DestroyReplayIterator (&it); + + if (rc == CL5_NOTFOUND) + { + if (i == 0) /* success */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "First iteration pass completed " + "successfully: no changes to replay\n"); + else /* incorrect number of entries traversed */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "First iteration pass failed: " + "traversed %d entries; expected none\n", i); + } + else /* general error */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "First iteration pass failed\n"); + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting second iteration pass ...\n"); + + /* add some entries */ + populateChangelogOp (); + + /* create replay iterator */ + rc = cl5CreateReplayIterator (r_obj, ruv, &it); + if (it) + { + i = 0; + while ((rc = cl5GetNextOperationToReplay (it, &op)) == CL5_SUCCESS) + { + ruv_set_csns (ruv, op.csn, NULL); + operation_parameters_done (&op); + i ++; + } + } + + if (it) + cl5DestroyReplayIterator (&it); + + if (rc == CL5_NOTFOUND) + { + if (i == OP_COUNT) /* success */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Second iteration pass completed " + "successfully: %d entries traversed\n", i); + else /* incorrect number of entries traversed */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Second iteration pass failed: " + "traversed %d entries; expected %d\n", i, OP_COUNT); + } + else /* general error */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Second iteration pass failed\n"); + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting third iteration pass ...\n"); + /* add more entries */ + populateChangelogOp (); + + /* create replay iterator */ + rc = cl5CreateReplayIterator (r_obj, ruv, &it); + if (it) + { + i = 0; + while ((rc = cl5GetNextOperationToReplay (it, &op)) == CL5_SUCCESS) + { + ruv_set_csns (ruv, op.csn, NULL); + operation_parameters_done (&op); + i ++; + } + } + + if (it) + cl5DestroyReplayIterator (&it); + + if (rc == CL5_NOTFOUND) + { + if (i == OP_COUNT) /* success */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Third iteration pass completed " + "successfully: %d entries traversed\n", i); + else /* incorrect number of entries traversed */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Third iteration pass failed: " + "traversed %d entries; expected %d\n", i, OP_COUNT); + } + else /* general error */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Second iteration pass failed\n"); + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Iteration test is complete\n"); + + ruv_destroy (&ruv); + object_release (r_obj); + slapi_ch_free ((void**)&replGen); +} + +static void testTrimming () +{ + PRIntervalTime interval; + int count; + int rc; + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting trimming test ...\n"); + + rc = populateChangelog (200, NULL); + + if (rc == 0) + { + interval = PR_SecondsToInterval(2); + DS_Sleep (interval); + + rc = populateChangelog (300, NULL); + + if (rc == 0) + rc = cl5ConfigTrimming (300, "1d"); + + interval = PR_SecondsToInterval(300); /* 5 min is default trimming interval */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Trimming test: sleeping for 5 minutes until trimming kicks in\n"); + DS_Sleep (interval); + + count = cl5GetOperationCount (NULL); + } + + if (rc == 0 && count == 300) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Trimming test completed successfully: changelog contains 300 entries\n"); + } + else if (rc == 0) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Trimming test failed: changelog contains %d entries; expected - 300\n", + count); + } + else /* general failure */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Trimming test failed\n"); +} + +static void testPerformance () +{ + PRTime starttime, endtime, totaltime; + int entryCount = 5000; + CSN **csnList = NULL; + int rc; + + starttime = PR_Now(); + + rc = populateChangelog (entryCount, &csnList); + + endtime = PR_Now(); + + totaltime = (endtime - starttime) / 1000; /* ms */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Write performance:\n" + "entry count - %d, total time - %ldms\n" + "latency = %d msec\nthroughput = %d entry/sec\n", + entryCount, totaltime, + totaltime / entryCount, entryCount * 1000 / totaltime); + + + starttime = endtime; + + rc = processEntries (entryCount, csnList); + + endtime = PR_Now(); + + totaltime = (endtime - starttime) / 1000; /* ms */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Read performance:\n" + "entry count - %d, total time - %ld\n" + "latency = %d msec\nthroughput = %d entry/sec\n", + entryCount, totaltime, + totaltime / entryCount, entryCount * 1000 / totaltime); + + clearCSNList (&csnList, entryCount); +} + +static int threadsLeft; +static void testPerformanceMT () +{ + PRTime starttime, endtime, totaltime; + int entryCount = 200; + int threadCount = 10; + int entryTotal; + int i; + PRIntervalTime interval; + + interval = PR_MillisecondsToInterval(100); + threadsLeft = threadCount * 2; + entryTotal = threadCount * entryCount; + starttime = PR_Now(); + + for (i = 0; i < threadCount; i++) + { + PR_CreateThread(PR_USER_THREAD, threadMain, (void*)&entryCount, + PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, + PR_UNJOINABLE_THREAD, 0); + } + + while (threadsLeft > 5) + DS_Sleep (interval); + + endtime = PR_Now(); + + totaltime = (endtime - starttime) / 1000; /* ms */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Write performance:\n" + "entry count - %d, total time - %ld\n" + "latency = %d msec per entry\nthroughput = %d entry/sec\n", + entryCount, totaltime, + totaltime / entryTotal, entryTotal * 1000 / totaltime); + + + starttime = endtime; + + while (threadsLeft != 0) + DS_Sleep (interval); + + endtime = PR_Now(); + + totaltime = (endtime - starttime) / 1000; /* ms */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Read performance:\n" + "entry count - %d, total time - %ld\n" + "latency = %d msec per entry\nthroughput = %d entry/sec\n", + entryCount, totaltime, + totaltime / entryTotal, entryTotal * 1000 / totaltime); +} + +static void testLDIF () +{ + char *clDir = cl5GetDir (); + int rc; + char *baseDir; + char ldifFile [MAXPATHLEN + 1]; + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "Starting LDIF test ...\n"); + + baseDir = getBaseDir (clDir); + sprintf (ldifFile, "%s/cl5.ldif", baseDir); + slapi_ch_free ((void**)&baseDir); + rc = populateChangelog (ENTRY_COUNT, NULL); + + if (rc == CL5_SUCCESS) + { + rc = cl5ExportLDIF (ldifFile, NULL); + if (rc == CL5_SUCCESS) + { + cl5Close(); + rc = cl5ImportLDIF (clDir, ldifFile, NULL); + if (rc == CL5_SUCCESS) + cl5Open(clDir, NULL); + } + } + + PR_Delete (ldifFile); + + if (rc == CL5_SUCCESS) + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "LDIF test completed successfully\n"); + else + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "LDIF test failed\n"); +} + +static void testAll () +{ + testBasic (); + + testIteration (); + + testBackupRestore (); + + testLDIF (); + + /* testTrimming ();*/ + +#if 0 + /* xxxPINAKI */ + /* these tests are not working correctly...the call to db->put() */ + /* just hangs forever */ + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Starting single threaded performance measurement ...\n"); + testPerformance (); + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Starting multi threaded performance measurement ...\n"); + testPerformanceMT (); +#endif + +} + +static int populateChangelog (int entryCount, CSN ***csnList) +{ + CSN *csn; + int i; + slapi_operation_parameters op; + int rc; + char *uniqueid; + + if (csnList) + { + (*csnList) = (CSN**)slapi_ch_calloc (entryCount, sizeof (CSN*)); + } + + /* generate entries */ + for (i = 0; i < entryCount; i++) + { + /* ONREPL need to get replica object + rc = csnGetNewCSNForRepl (&csn); + if (rc != CL5_SUCCESS) */ + return -1; + + if (csnList) + (*csnList) [i] = csn_dup (csn); + memset (&op, 0, sizeof (op)); + op.csn = csn; + slapi_uniqueIDGenerateString(&uniqueid); + op.target_address.uniqueid = uniqueid; + op.target_address.dn = slapi_ch_strdup ("cn=entry,dc=example,dc=com"); + if (i % 5 == 0) + { + op.operation_type = SLAPI_OPERATION_MODRDN; + op.p.p_modrdn.modrdn_deloldrdn = 1; + op.p.p_modrdn.modrdn_newrdn = slapi_ch_strdup("cn=entry2,dc=example,dc=com"); + op.p.p_modrdn.modrdn_newsuperior_address.dn = NULL; + op.p.p_modrdn.modrdn_newsuperior_address.uniqueid = NULL; + op.p.p_modrdn.modrdn_mods = buildMods (); + } + else if (i % 4 == 0) + { + op.operation_type = SLAPI_OPERATION_DELETE; + } + else if (i % 3 == 0) + { + + op.operation_type = SLAPI_OPERATION_ADD; + op.p.p_add.target_entry = slapi_entry_alloc (); + slapi_entry_set_dn (op.p.p_add.target_entry, slapi_ch_strdup(op.target_address.dn)); + slapi_entry_set_uniqueid (op.p.p_add.target_entry, slapi_ch_strdup(op.target_address.uniqueid)); + slapi_entry_attr_set_charptr(op.p.p_add.target_entry, "objectclass", "top"); + slapi_entry_attr_set_charptr(op.p.p_add.target_entry, "cn", "entry"); + } + else + { + op.operation_type = SLAPI_OPERATION_MODIFY; + op.p.p_modify.modify_mods = buildMods (); + } + + /* ONREPL rc = cl5WriteOperation (&op, 1);*/ + operation_parameters_done (&op); + + if (rc != CL5_SUCCESS) + return -1; + } + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Successfully populated changelog with %d entries\n", entryCount); + return 0; +} + +static int processEntries (int entryCount, CSN **csnList) +{ + int i; + int rc = 0; + slapi_operation_parameters op; + + for (i = 0; i < entryCount; i++) + { + memset (&op, 0, sizeof (op)); + + op.csn = csn_dup (csnList [i]); + + /* rc = cl5GetOperation (&op);*/ + if (rc != CL5_SUCCESS) + return -1; + + operation_parameters_done (&op); + } + + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, + "Successfully read %d entries from the changelog\n", entryCount); + return 0; +} + +void clearCSNList (CSN ***csnList, int count) +{ + int i; + + for (i = 0; i < count; i++) + { + csn_free (&((*csnList)[i])); + } + + slapi_ch_free ((void**)csnList); +} + +static void threadMain (void *data) +{ + int entryCount = *(int*)data; + CSN **csnList; + + populateChangelog (entryCount, &csnList); + PR_AtomicDecrement (&threadsLeft); + + processEntries (entryCount, csnList); + PR_AtomicDecrement (&threadsLeft); + + clearCSNList (&csnList, entryCount); +} + +static char* getBaseDir (const char *dir) +{ + char *baseDir = slapi_ch_strdup (dir); + char *ch; + + ch = &(baseDir [strlen (dir) - 2]); + + while (ch >= baseDir && *ch != '\\' && *ch != '/') + ch --; + + if (ch >= baseDir) + { + *ch = '\0'; + } + + return baseDir; +} + +static LDAPMod **buildMods () +{ + Slapi_Mods smods; + Slapi_Mod smod; + LDAPMod **mods; + struct berval bv; + int j, k; + + slapi_mods_init (&smods, MOD_COUNT); + + for (j = 0; j < MOD_COUNT; j++) + { + slapi_mod_init (&smod, VALUE_COUNT); + slapi_mod_set_operation (&smod, LDAP_MOD_ADD | LDAP_MOD_BVALUES); + slapi_mod_set_type (&smod, "attr"); + + for (k = 0; k < VALUE_COUNT; k++) + { + bv.bv_val = "bvalue"; + bv.bv_len = strlen (bv.bv_val) + 1; + slapi_mod_add_value (&smod, &bv); + } + + slapi_mods_add_smod (&smods, &smod); + /* ONREPL slapi_mod_done (&smod); */ + } + + mods = slapi_mods_get_ldapmods_passout (&smods); + slapi_mods_done (&smods); + return mods; +} + +/* Format: + dn: cn=changelog5,cn=config + objectclass: top + objectclass: extensibleObject + cn: changelog5 + nsslapd-changelogDir: d:/netscape/server4/slapd-elf/cl5 */ +static int configureChangelog () +{ + Slapi_PBlock *pb = slapi_pblock_new (); + Slapi_Entry *e = slapi_entry_alloc (); + int rc; + char *attrs[] = {INSTANCE_ATTR, NULL}; + Slapi_Entry **entries; + char cl_dir [256]; + char *str = NULL; + + /* set changelog dn */ + slapi_entry_set_dn (e, slapi_ch_strdup (CL_DN)); + + /* set object classes */ + slapi_entry_add_string(e, "objectclass", "top"); + slapi_entry_add_string(e, "objectclass", "extensibleObject"); + + /* get directory instance dir */ + slapi_search_internal_set_pb (pb, "cn=config", LDAP_SCOPE_BASE, "objectclass=*", + attrs, 0, NULL, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + slapi_search_internal_pb (pb); + + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to get server instance " + "directory; LDAP error - %d\n", rc); + rc = -1; + goto done; + } + + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_SEARCH_ENTRIES, &entries); + str = slapi_entry_attr_get_charptr(entries[0], INSTANCE_ATTR); + sprintf (cl_dir, "%s/%s", str, "cl5db"); + slapi_ch_free((void **)&str); + slapi_entry_add_string (e, CONFIG_CHANGELOG_DIR_ATTRIBUTE, cl_dir); + + slapi_free_search_results_internal(pb); + slapi_pblock_destroy (pb); + + pb = slapi_pblock_new (); + + slapi_add_entry_internal_set_pb (pb, e, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + + slapi_add_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to add changelog " + "configuration entry; LDAP error - %d\n", rc); + rc = -1; + } + else + rc = 0; + +done: + slapi_pblock_destroy (pb); + + return rc; +} + +/* Format: + dn: cn=replica,cn="o=NetscapeRoot",cn= mapping tree,cn=config + objectclass: top + objectclass: nsds5Replica + objectclass: extensibleObject + nsds5ReplicaRoot: o=NetscapeRoot + nsds5ReplicaId: 2 + nsds5flags: 1 + cn: replica + */ +static int configureReplica () +{ + Slapi_PBlock *pb = slapi_pblock_new (); + Slapi_Entry *e = slapi_entry_alloc (); + int rc; + char dn [128]; + + /* set changelog dn */ + sprintf (dn, "%s,cn=\"%s\",%s", REPLICA_RDN, REPLICA_ROOT, + slapi_get_mapping_tree_config_root ()); + slapi_entry_set_dn (e, slapi_ch_strdup (dn)); + + /* set object classes */ + slapi_entry_add_string(e, "objectclass", "top"); + slapi_entry_add_string(e, "objectclass", REPLICA_OC); + slapi_entry_add_string(e, "objectclass", "extensibleObject"); + + /* set other attributes */ + slapi_entry_add_string (e, attr_replicaRoot, REPLICA_ROOT); + slapi_entry_add_string (e, attr_replicaId, "1"); + slapi_entry_add_string (e, attr_flags, "1"); + + slapi_add_entry_internal_set_pb (pb, e, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + + slapi_add_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to add replica for (%s) " + "configuration entry; LDAP error - %d\n", REPLICA_ROOT, rc); + rc = -1; + } + else + rc = 0; + + slapi_pblock_destroy (pb); + + return rc; +} + +/* generates one of each ldap operations */ +static int populateChangelogOp () +{ + Slapi_PBlock *pb = slapi_pblock_new (); + Slapi_Entry *e = slapi_entry_alloc (); + int rc; + char dn [128], newrdn [64]; + LDAPMod *mods[2]; + Slapi_Mod smod; + struct berval bv; + time_t cur_time; + + /* add entry */ + cur_time = time(NULL); + sprintf (dn, "cn=%s,%s", ctime(&cur_time), REPLICA_ROOT); + slapi_entry_set_dn (e, slapi_ch_strdup (dn)); + slapi_entry_add_string(e, "objectclass", "top"); + slapi_entry_add_string(e, "objectclass", "extensibleObject"); + slapi_entry_add_string (e, "mail", "jsmith@netscape.com"); + + slapi_add_entry_internal_set_pb (pb, e, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + slapi_add_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + slapi_pblock_destroy (pb); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to add entry (%s); " + "LDAP error - %d\n", dn, rc); + return -1; + } + + /* modify entry */ + pb = slapi_pblock_new (); + slapi_mod_init (&smod, 1); + slapi_mod_set_type (&smod, "mail"); + slapi_mod_set_operation (&smod, LDAP_MOD_REPLACE | LDAP_MOD_BVALUES); + bv.bv_val = "jsmith@aol.com"; + bv.bv_len = strlen (bv.bv_val); + slapi_mod_add_value(&smod, &bv); + mods[0] = (LDAPMod*)slapi_mod_get_ldapmod_byref(&smod); + mods[1] = NULL; + slapi_modify_internal_set_pb (pb, dn, mods, NULL, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + slapi_modify_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + slapi_mod_done (&smod); + slapi_pblock_destroy (pb); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to modify entry (%s); " + "LDAP error - %d\n", dn, rc); + return -1; + } + + /* rename entry */ + pb = slapi_pblock_new (); + cur_time = time (NULL); + sprintf (newrdn, "cn=renamed%s", ctime(&cur_time)); + slapi_rename_internal_set_pb (pb, dn, newrdn, NULL, 1, NULL, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + slapi_modrdn_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + slapi_pblock_destroy (pb); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to rename entry (%s); " + "LDAP error - %d\n", dn, rc); + return -1; + } + + /* delete the entry */ + pb = slapi_pblock_new (); + sprintf (dn, "%s,%s", newrdn, REPLICA_ROOT); + slapi_delete_internal_set_pb (pb, dn, NULL, NULL, + repl_get_plugin_identity (PLUGIN_MULTIMASTER_REPLICATION), 0); + slapi_delete_internal_pb (pb); + slapi_pblock_get(pb, SLAPI_PLUGIN_INTOP_RESULT, &rc); + slapi_pblock_destroy (pb); + if (rc != LDAP_SUCCESS) + { + slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name_cl, "failed to delete entry (%s); " + "LDAP error - %d\n", dn, rc); + return -1; + } + + return 0; +} |