From c79630de8012a893ed3d1c46b41bc7871a07a3e2 Mon Sep 17 00:00:00 2001

From: Mark Reynolds <mreynolds@redhat.com>

Date: Wed, 26 May 2021 13:32:13 -0400

Subject: [PATCH 11/12] Issue 4778 - RFE - Allow setting TOD for db compaction

 and add task

Description:  Since database compaction can be costly it should be allowed

              to set a time to execute it during offpeak hours.  Once the

              compaction interval has been met, it will wait for the configured

              time of day to do the compaction.  The default is just before

              midnight: 23:59

              A task was also created that can run compaction on demand,

              and can also just target the replication changelog.  This could

              be used in conjunction with a cronjob for more complex

              execution patterns.

ASAN tested and approved.

relates: https://github.com/389ds/389-ds-base/issues/4778

Reviewed by: spichugi(Thanks!)

---

 .../tests/suites/config/compact_test.py       |  81 ++++++

 ldap/schema/01core389.ldif                    |   3 +-

 ldap/servers/plugins/replication/cl5.h        |   1 +

 ldap/servers/plugins/replication/cl5_api.c    |  70 ++++-

 ldap/servers/plugins/replication/cl5_api.h    |   2 +-

 .../servers/plugins/replication/cl5_clcache.c |   3 -

 ldap/servers/plugins/replication/cl5_config.c | 102 ++++++-

 ldap/servers/plugins/replication/cl5_init.c   |   2 +-

 .../servers/plugins/replication/repl_shared.h |   2 +

 ldap/servers/plugins/retrocl/retrocl.c        |   1 -

 .../slapd/back-ldbm/db-bdb/bdb_config.c       |  79 ++++++

 .../slapd/back-ldbm/db-bdb/bdb_layer.c        | 258 ++++++++++++------

 .../slapd/back-ldbm/db-bdb/bdb_layer.h        |   4 +-

 ldap/servers/slapd/back-ldbm/init.c           |   2 +

 ldap/servers/slapd/back-ldbm/ldbm_config.h    |   1 +

 .../servers/slapd/back-ldbm/proto-back-ldbm.h |   1 +

 ldap/servers/slapd/filtercmp.c                |   5 +-

 ldap/servers/slapd/pblock.c                   |  17 +-

 ldap/servers/slapd/slap.h                     |   2 +

 ldap/servers/slapd/slapi-private.h            |   1 +

 ldap/servers/slapd/task.c                     | 102 ++++++-

 src/cockpit/389-console/src/database.jsx      |   1 +

 .../src/lib/database/databaseConfig.jsx       |  16 +-

 src/lib389/lib389/_constants.py               |   1 +

 src/lib389/lib389/backend.py                  |   1 +

 src/lib389/lib389/cli_conf/backend.py         |  24 +-

 src/lib389/lib389/cli_conf/replication.py     |   3 +

 src/lib389/lib389/tasks.py                    |  14 +-

 28 files changed, 689 insertions(+), 110 deletions(-)

 create mode 100644 dirsrvtests/tests/suites/config/compact_test.py

diff --git a/dirsrvtests/tests/suites/config/compact_test.py b/dirsrvtests/tests/suites/config/compact_test.py

new file mode 100644

index 000000000..1f1c097e4

--- /dev/null

+++ b/dirsrvtests/tests/suites/config/compact_test.py

@@ -0,0 +1,81 @@

+import logging

+import pytest

+import os

+import time

+from lib389.tasks import DBCompactTask

+from lib389.backend import DatabaseConfig

+from lib389.replica import Changelog5

+from lib389.topologies import topology_m1 as topo

+

+log = logging.getLogger(__name__)

+

+

+def test_compact_db_task(topo):

+    """Specify a test case purpose or name here

+

+    :id: 1b3222ef-a336-4259-be21-6a52f76e1859

+    :setup: Standalone Instance

+    :steps:

+        1. Create task

+        2. Check task was successful

+        3. Check errors log to show task was run

+        3. Create task just for replication

+    :expectedresults:

+        1. Success

+        2. Success

+        3. Success

+        4. Success

+    """

+    inst = topo.ms["supplier1"]

+

+    task = DBCompactTask(inst)

+    task.create()

+    task.wait()

+    assert task.get_exit_code() == 0

+

+    # Check errors log to make sure task actually compacted db

+    assert inst.searchErrorsLog("Compacting databases")

+    inst.deleteErrorLogs(restart=False)

+

+

+def test_compaction_interval_and_time(topo):

+    """Specify a test case purpose or name here

+

+    :id: f361bee9-d7e7-4569-9255-d7b60dd9d92e

+    :setup: Supplier Instance

+    :steps:

+        1. Configure compact interval and time for database and changelog

+        2. Check compaction occurs as expected

+    :expectedresults:

+        1. Success

+        2. Success

+    """

+

+    inst = topo.ms["supplier1"]

+

+    # Configure DB compaction

+    config = DatabaseConfig(inst)

+    config.set([('nsslapd-db-compactdb-interval', '2'), ('nsslapd-db-compactdb-time', '00:01')])

+

+    # Configure changelog compaction

+    cl5 = Changelog5(inst)

+    cl5.replace_many(

+        ('nsslapd-changelogcompactdb-interval', '2'),

+        ('nsslapd-changelogcompactdb-time', '00:01'),

+        ('nsslapd-changelogtrim-interval',  '2')

+    )

+    inst.deleteErrorLogs()

+

+    # Check is compaction occurred

+    time.sleep(6)

+    assert inst.searchErrorsLog("Compacting databases")

+    assert inst.searchErrorsLog("compacting replication changelogs")

+    inst.deleteErrorLogs(restart=False)

+

+

+if __name__ == '__main__':

+    # Run isolated

+    # -s for DEBUG mode

+    CURRENT_FILE = os.path.realpath(__file__)

+    pytest.main(["-s", CURRENT_FILE])

+

diff --git a/ldap/schema/01core389.ldif b/ldap/schema/01core389.ldif

index 9e9a26c21..0c73e5114 100644

--- a/ldap/schema/01core389.ldif

+++ b/ldap/schema/01core389.ldif

@@ -285,6 +285,7 @@ attributeTypes: ( 2.16.840.1.113730.3.1.2310 NAME 'nsds5ReplicaFlowControlWindow

 attributeTypes: ( 2.16.840.1.113730.3.1.2311 NAME 'nsds5ReplicaFlowControlPause' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

 attributeTypes: ( 2.16.840.1.113730.3.1.2313 NAME 'nsslapd-changelogtrim-interval' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

 attributeTypes: ( 2.16.840.1.113730.3.1.2314 NAME 'nsslapd-changelogcompactdb-interval' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

+attributeTypes: ( 2.16.840.1.113730.3.1.2385 NAME 'nsslapd-changelogcompactdb-time' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

 attributeTypes: ( 2.16.840.1.113730.3.1.2315 NAME 'nsDS5ReplicaWaitForAsyncResults' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

 attributeTypes: ( 2.16.840.1.113730.3.1.2316 NAME 'nsslapd-auditfaillog-maxlogsize' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

 attributeTypes: ( 2.16.840.1.113730.3.1.2317 NAME 'nsslapd-auditfaillog-logrotationsync-enabled' DESC 'Netscape defined attribute type' SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 SINGLE-VALUE X-ORIGIN 'Netscape Directory Server' )

@@ -345,5 +346,5 @@ objectClasses: ( nsEncryptionConfig-oid NAME 'nsEncryptionConfig' DESC 'Netscape

 objectClasses: ( nsEncryptionModule-oid NAME 'nsEncryptionModule' DESC 'Netscape defined objectclass' SUP top MUST ( cn ) MAY ( nsSSLToken $ nsSSLPersonalityssl $ nsSSLActivation $ ServerKeyExtractFile $ ServerCertExtractFile ) X-ORIGIN 'Netscape' )

 objectClasses: ( 2.16.840.1.113730.3.2.327 NAME 'rootDNPluginConfig' DESC 'Netscape defined objectclass' SUP top MUST ( cn ) MAY ( rootdn-open-time $ rootdn-close-time $ rootdn-days-allowed $ rootdn-allow-host $ rootdn-deny-host $ rootdn-allow-ip $ rootdn-deny-ip ) X-ORIGIN 'Netscape' )

 objectClasses: ( 2.16.840.1.113730.3.2.328 NAME 'nsSchemaPolicy' DESC 'Netscape defined objectclass' SUP top  MAY ( cn $ schemaUpdateObjectclassAccept $ schemaUpdateObjectclassReject $ schemaUpdateAttributeAccept $ schemaUpdateAttributeReject) X-ORIGIN 'Netscape Directory Server' )

-objectClasses: ( 2.16.840.1.113730.3.2.332 NAME 'nsChangelogConfig' DESC 'Configuration of the changelog5 object' SUP top MUST ( cn $ nsslapd-changelogdir ) MAY ( nsslapd-changelogmaxage $ nsslapd-changelogtrim-interval $ nsslapd-changelogmaxentries $ nsslapd-changelogsuffix $ nsslapd-changelogcompactdb-interval $ nsslapd-encryptionalgorithm $ nsSymmetricKey ) X-ORIGIN '389 Directory Server' )

+objectClasses: ( 2.16.840.1.113730.3.2.332 NAME 'nsChangelogConfig' DESC 'Configuration of the changelog5 object' SUP top MUST ( cn $ nsslapd-changelogdir ) MAY ( nsslapd-changelogmaxage $ nsslapd-changelogtrim-interval $ nsslapd-changelogmaxentries $ nsslapd-changelogsuffix $ nsslapd-changelogcompactdb-interval $ nsslapd-changelogcompactdb-time $ nsslapd-encryptionalgorithm $ nsSymmetricKey ) X-ORIGIN '389 Directory Server' )

 objectClasses: ( 2.16.840.1.113730.3.2.337 NAME 'rewriterEntry' DESC '' SUP top MUST ( nsslapd-libPath ) MAY ( cn $ nsslapd-filterrewriter $ nsslapd-returnedAttrRewriter ) X-ORIGIN '389 Directory Server' )

diff --git a/ldap/servers/plugins/replication/cl5.h b/ldap/servers/plugins/replication/cl5.h

index 2af57e369..99ea1c6a2 100644

--- a/ldap/servers/plugins/replication/cl5.h

+++ b/ldap/servers/plugins/replication/cl5.h

@@ -29,6 +29,7 @@ typedef struct changelog5Config

     char *symmetricKey;

     long compactInterval;

     long trimInterval;

+    char *compactTime;

 } changelog5Config;

 /* initializes changelog*/

diff --git a/ldap/servers/plugins/replication/cl5_api.c b/ldap/servers/plugins/replication/cl5_api.c

index 403a6a666..75a2f46f5 100644

--- a/ldap/servers/plugins/replication/cl5_api.c

+++ b/ldap/servers/plugins/replication/cl5_api.c

@@ -158,6 +158,7 @@ typedef struct cl5trim

     time_t maxAge;       /* maximum entry age in seconds                            */

     int maxEntries;      /* maximum number of entries across all changelog files    */

     int compactInterval; /* interval to compact changelog db */

+    char *compactTime;   /* time to compact changelog db */

     int trimInterval;    /* trimming interval */

     PRLock *lock;        /* controls access to trimming configuration            */

 } CL5Trim;

@@ -184,6 +185,7 @@ typedef struct cl5desc

     PRLock *clLock;         /* Lock associated to clVar, used to notify threads on close */

     PRCondVar *clCvar;      /* Condition Variable used to notify threads on close */

     void *clcrypt_handle;   /* for cl encryption */

+    char *compact_time;     /* Time to execute changelog compaction */

 } CL5Desc;

 typedef void (*VFP)(void *);

@@ -1025,7 +1027,7 @@ cl5GetState()

                 CL5_BAD_STATE if changelog is not open

  */

 int

-cl5ConfigTrimming(int maxEntries, const char *maxAge, int compactInterval, int trimInterval)

+cl5ConfigTrimming(int maxEntries, const char *maxAge, int compactInterval, char *compactTime, int trimInterval)

 {

     if (s_cl5Desc.dbState == CL5_STATE_NONE) {

         slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name_cl,

@@ -1061,6 +1063,10 @@ cl5ConfigTrimming(int maxEntries, const char *maxAge, int compactInterval, int t

         s_cl5Desc.dbTrim.compactInterval = compactInterval;

     }

+    if (strcmp(compactTime, CL5_STR_IGNORE) != 0) {

+        s_cl5Desc.dbTrim.compactTime = slapi_ch_strdup(compactTime);

+    }

+

     if (trimInterval != CL5_NUM_IGNORE) {

         s_cl5Desc.dbTrim.trimInterval = trimInterval;

     }

@@ -3077,16 +3083,48 @@ _cl5TrimCleanup(void)

 {

     if (s_cl5Desc.dbTrim.lock)

         PR_DestroyLock(s_cl5Desc.dbTrim.lock);

+    slapi_ch_free_string(&s_cl5Desc.dbTrim.compactTime);

     memset(&s_cl5Desc.dbTrim, 0, sizeof(s_cl5Desc.dbTrim));

 }

+static time_t

+_cl5_get_tod_expiration(char *expire_time)

+{

+    time_t start_time, todays_elapsed_time, now = time(NULL);

+    struct tm *tm_struct = localtime(&now;;

+    char hour_str[3] = {0};

+    char min_str[3] = {0};

+    char *s = expire_time;

+    char *endp = NULL;

+    int32_t hour, min, expiring_time;

+

+    /* Get today's start time */

+    todays_elapsed_time = (tm_struct->tm_hour * 3600) + (tm_struct->tm_min * 60) + (tm_struct->tm_sec);

+    start_time = slapi_current_utc_time() - todays_elapsed_time;

+

+    /* Get the hour and minute and calculate the expiring time.  The time was

+     * already validated in bdb_config.c:  HH:MM */

+    hour_str[0] = *s++;

+    hour_str[1] = *s++;

+    s++;  /* skip colon */

+    min_str[0] = *s++;

+    min_str[1] = *s++;

+    hour = strtoll(hour_str, &endp, 10);

+    min = strtoll(min_str, &endp, 10);

+    expiring_time = (hour * 60 * 60) + (min * 60);

+

+    return start_time + expiring_time;

+}

+

 static int

 _cl5TrimMain(void *param __attribute__((unused)))

 {

     time_t timePrev = slapi_current_utc_time();

     time_t timeCompactPrev = slapi_current_utc_time();

     time_t timeNow;

+    PRBool compacting = PR_FALSE;

+    int32_t compactdb_time = 0;

     PR_AtomicIncrement(&s_cl5Desc.threadCount);

@@ -3097,11 +3135,26 @@ _cl5TrimMain(void *param __attribute__((unused)))

             timePrev = timeNow;

             _cl5DoTrimming();

         }

+

+        if (!compacting) {

+            /* Once we know we want to compact we need to stop refreshing the

+             * TOD expiration. Otherwise if the compact time is close to

+             * midnight we could roll over past midnight during the checkpoint

+             * sleep interval, and we'd never actually compact the databases.

+             * We also need to get this value before the sleep.

+            */

+            compactdb_time = _cl5_get_tod_expiration(s_cl5Desc.dbTrim.compactTime);

+        }

         if ((s_cl5Desc.dbTrim.compactInterval > 0) &&

-            (timeNow - timeCompactPrev >= s_cl5Desc.dbTrim.compactInterval)) {

-            /* time to trim */

-            timeCompactPrev = timeNow;

-            _cl5CompactDBs();

+            (timeNow - timeCompactPrev >= s_cl5Desc.dbTrim.compactInterval))

+        {

+            compacting = PR_TRUE;

+            if (slapi_current_utc_time() > compactdb_time) {

+				/* time to trim */

+				timeCompactPrev = timeNow;

+				_cl5CompactDBs();

+				compacting = PR_FALSE;

+            }

         }

         if (NULL == s_cl5Desc.clLock) {

             /* most likely, emergency */

@@ -3215,6 +3268,10 @@ _cl5CompactDBs(void)

                       rc, db_strerror(rc));

         goto bail;

     }

+

+

+    slapi_log_err(SLAPI_LOG_NOTICE, repl_plugin_name_cl,

+                  "_cl5CompactDBs - compacting replication changelogs...\n");

     for (fileObj = objset_first_obj(s_cl5Desc.dbFiles);

          fileObj;

          fileObj = objset_next_obj(s_cl5Desc.dbFiles, fileObj)) {

@@ -3235,6 +3292,9 @@ _cl5CompactDBs(void)

                       "_cl5CompactDBs - %s - %d pages freed\n",

                       dbFile->replName, c_data.compact_pages_free);

     }

+

+    slapi_log_err(SLAPI_LOG_NOTICE, repl_plugin_name_cl,

+                  "_cl5CompactDBs - compacting replication changelogs finished.\n");

 bail:

     if (fileObj) {

         object_release(fileObj);

diff --git a/ldap/servers/plugins/replication/cl5_api.h b/ldap/servers/plugins/replication/cl5_api.h

index 302af97a0..4b0949fb3 100644

--- a/ldap/servers/plugins/replication/cl5_api.h

+++ b/ldap/servers/plugins/replication/cl5_api.h

@@ -236,7 +236,7 @@ int cl5GetState(void);

    Return:        CL5_SUCCESS if successful;

                 CL5_BAD_STATE if changelog has not been open

  */

-int cl5ConfigTrimming(int maxEntries, const char *maxAge, int compactInterval, int trimInterval);

+int cl5ConfigTrimming(int maxEntries, const char *maxAge, int compactInterval, char *compactTime, int trimInterval);

 void cl5DestroyIterator(void *iterator);

diff --git a/ldap/servers/plugins/replication/cl5_clcache.c b/ldap/servers/plugins/replication/cl5_clcache.c

index 90dec4d54..e5a39c9c1 100644

--- a/ldap/servers/plugins/replication/cl5_clcache.c

+++ b/ldap/servers/plugins/replication/cl5_clcache.c

@@ -452,9 +452,6 @@ static int

 clcache_cursor_set(DBC *cursor, CLC_Buffer *buf)

 {

     int rc;

-    uint32_t ulen;

-    uint32_t dlen;

-    uint32_t size;

     rc = cursor->c_get(cursor, &buf->buf_key, &buf->buf_data, DB_SET);

     if (rc == DB_BUFFER_SMALL) {

diff --git a/ldap/servers/plugins/replication/cl5_config.c b/ldap/servers/plugins/replication/cl5_config.c

index e0530bed2..b32686788 100644

--- a/ldap/servers/plugins/replication/cl5_config.c

+++ b/ldap/servers/plugins/replication/cl5_config.c

@@ -131,6 +131,7 @@ changelog5_config_done(changelog5Config *config)

         /* slapi_ch_free_string accepts NULL pointer */

         slapi_ch_free_string(&config->maxAge);

         slapi_ch_free_string(&config->dir);

+        slapi_ch_free_string(&config->compactTime);

         slapi_ch_free_string(&config->symmetricKey);

         slapi_ch_free_string(&config->dbconfig.encryptionAlgorithm);

         slapi_ch_free_string(&config->dbconfig.symmetricKey);

@@ -211,7 +212,7 @@ changelog5_config_add(Slapi_PBlock *pb __attribute__((unused)),

     }

     /* set trimming parameters */

-    rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.trimInterval);

+    rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.compactTime, config.trimInterval);

     if (rc != CL5_SUCCESS) {

         *returncode = 1;

         if (returntext) {

@@ -302,6 +303,7 @@ changelog5_config_modify(Slapi_PBlock *pb,

     config.compactInterval = CL5_NUM_IGNORE;

     slapi_ch_free_string(&config.maxAge);

     config.maxAge = slapi_ch_strdup(CL5_STR_IGNORE);

+    config.compactTime = slapi_ch_strdup(CHANGELOGDB_COMPACT_TIME);

     config.trimInterval = CL5_NUM_IGNORE;

     slapi_pblock_get(pb, SLAPI_MODIFY_MODS, &mods;;

@@ -375,6 +377,55 @@ changelog5_config_modify(Slapi_PBlock *pb,

                         *returncode = LDAP_UNWILLING_TO_PERFORM;

                         goto done;

                     }

+                } else if (strcasecmp(config_attr, CONFIG_CHANGELOG_COMPACTTIME_ATTRIBUTE) == 0) {

+                	if (config_attr_value && config_attr_value[0] != '\0') {

+                	    char *val = slapi_ch_strdup(config_attr_value);

+                        char *endp = NULL;

+                        char *hour_str = NULL;

+                        char *min_str = NULL;

+                        int32_t hour, min;

+                        errno = 0;

+

+                        slapi_ch_free_string(&config.compactTime);

+

+                      	if (strstr(val, ":")) {

+                            /* Get the hour and minute */

+                            hour_str = ldap_utf8strtok_r(val, ":", &min_str);

+                  	        /* Validate hour */

+                   	        hour = strtoll(hour_str, &endp, 10);

+                 	        if (*endp != '\0' || errno == ERANGE || hour < 0 || hour > 23 || strlen(hour_str) != 2) {

+          	       	            slapi_create_errormsg(returntext, SLAPI_DSE_RETURNTEXT_SIZE,

+                   	                    "Invalid hour set (%s), must be a two digit number between 00 and 23",

+                   	                    hour_str);

+                   	            slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+                                       "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+                	       	                    "Using default of 23:59\n", hour_str);

+                                *returncode = LDAP_UNWILLING_TO_PERFORM;

+                   	            goto done;

+           	       	        }

+       	        	        /* Validate minute */

+           	       	        min = strtoll(min_str, &endp, 10);

+           	      	        if (*endp != '\0' || errno == ERANGE || min < 0 || min > 59 || strlen(min_str) != 2) {

+                   	            slapi_create_errormsg(returntext, SLAPI_DSE_RETURNTEXT_SIZE,

+                  	                    "Invalid minute set (%s), must be a two digit number between 00 and 59",

+                   	                    hour_str);

+                   	            slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+                   	                    "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+                   	                    "Using default of 23:59\n", min_str);

+                                *returncode = LDAP_UNWILLING_TO_PERFORM;

+                   	            goto done;

+                   	        }

+                   	    } else {

+                   	        /* Wrong format */

+                   	        slapi_create_errormsg(returntext, SLAPI_DSE_RETURNTEXT_SIZE,

+                   	                "Invalid setting (%s), must have a time format of HH:MM", val);

+                   	        slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+                   	                "Invalid setting (%s), must have a time format of HH:MM\n", val);

+                            *returncode = LDAP_UNWILLING_TO_PERFORM;

+                   	        goto done;

+                   	    }

+                        config.compactTime = slapi_ch_strdup(config_attr_value);

+                    }

                 } else if (strcasecmp(config_attr, CONFIG_CHANGELOG_TRIM_ATTRIBUTE) == 0) {

                     if (slapi_is_duration_valid(config_attr_value)) {

                         config.trimInterval = (long)slapi_parse_duration(config_attr_value);

@@ -419,6 +470,11 @@ changelog5_config_modify(Slapi_PBlock *pb,

         if (originalConfig->maxAge)

             config.maxAge = slapi_ch_strdup(originalConfig->maxAge);

     }

+    if (strcmp(config.compactTime, CL5_STR_IGNORE) == 0) {

+        slapi_ch_free_string(&config.compactTime);

+        if (originalConfig->compactTime)

+            config.compactTime = slapi_ch_strdup(originalConfig->compactTime);

+    }

     /* attempt to change chagelog dir */

     if (config.dir) {

@@ -519,7 +575,7 @@ changelog5_config_modify(Slapi_PBlock *pb,

     if (config.maxEntries != CL5_NUM_IGNORE ||

         config.trimInterval != CL5_NUM_IGNORE ||

         strcmp(config.maxAge, CL5_STR_IGNORE) != 0) {

-        rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.trimInterval);

+        rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.compactTime, config.trimInterval);

         if (rc != CL5_SUCCESS) {

             *returncode = 1;

             if (returntext) {

@@ -689,6 +745,7 @@ changelog5_extract_config(Slapi_Entry *entry, changelog5Config *config)

 {

     const char *arg;

     char *max_age = NULL;

+    char *val = NULL;

     memset(config, 0, sizeof(*config));

     config->dir = slapi_entry_attr_get_charptr(entry, CONFIG_CHANGELOG_DIR_ATTRIBUTE);

@@ -711,6 +768,47 @@ changelog5_extract_config(Slapi_Entry *entry, changelog5Config *config)

         config->compactInterval = CHANGELOGDB_COMPACT_INTERVAL;

     }

+    arg = slapi_entry_attr_get_ref(entry, CONFIG_CHANGELOG_COMPACTTIME_ATTRIBUTE);

+    if (arg) {

+        char *endp = NULL;

+        char *hour_str = NULL;

+        char *min_str = NULL;

+        int32_t hour, min;

+        errno = 0;

+

+        val = slapi_ch_strdup((char *)arg);

+    	if (strstr(val, ":")) {

+            /* Get the hour and minute */

+            hour_str = ldap_utf8strtok_r(val, ":", &min_str);

+    	        /* Validate hour */

+   	        hour = strtoll(hour_str, &endp, 10);

+   	        if (*endp != '\0' || errno == ERANGE || hour < 0 || hour > 23 || strlen(hour_str) != 2) {

+   	            slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+   	                    "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+   	                    "Using default of 23:59\n", hour_str);

+   	            goto set_default;

+   	        }

+    	        /* Validate minute */

+   	        min = strtoll(min_str, &endp, 10);

+  	        if (*endp != '\0' || errno == ERANGE || min < 0 || min > 59 || strlen(min_str) != 2) {

+   	            slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+   	                    "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+   	                    "Using default of 23:59\n", min_str);

+   	            goto set_default;

+   	        }

+   	    } else {

+   	        /* Wrong format */

+   	        slapi_log_err(SLAPI_LOG_ERR, "changelog5_extract_config",

+   	                "Invalid setting (%s), must have a time format of HH:MM\n", val);

+   	        goto set_default;

+   	    }

+        config->compactTime = slapi_ch_strdup(arg);

+    } else {

+    	set_default:

+        config->compactTime = slapi_ch_strdup(CHANGELOGDB_COMPACT_TIME);

+    }

+    slapi_ch_free_string(&val;;

+

     arg = slapi_entry_attr_get_ref(entry, CONFIG_CHANGELOG_TRIM_ATTRIBUTE);

     if (arg) {

         if (slapi_is_duration_valid(arg)) {

diff --git a/ldap/servers/plugins/replication/cl5_init.c b/ldap/servers/plugins/replication/cl5_init.c

index 112c4ece4..251859714 100644

--- a/ldap/servers/plugins/replication/cl5_init.c

+++ b/ldap/servers/plugins/replication/cl5_init.c

@@ -57,7 +57,7 @@ changelog5_init()

     }

     /* set trimming parameters */

-    rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.trimInterval);

+    rc = cl5ConfigTrimming(config.maxEntries, config.maxAge, config.compactInterval, config.compactTime, config.trimInterval);

     if (rc != CL5_SUCCESS) {

         slapi_log_err(SLAPI_LOG_ERR, repl_plugin_name_cl,

                       "changelog5_init: failed to configure changelog trimming\n");

diff --git a/ldap/servers/plugins/replication/repl_shared.h b/ldap/servers/plugins/replication/repl_shared.h

index b1ed86934..6708e12f7 100644

--- a/ldap/servers/plugins/replication/repl_shared.h

+++ b/ldap/servers/plugins/replication/repl_shared.h

@@ -26,11 +26,13 @@

 #define CHANGELOGDB_TRIM_INTERVAL 300        /* 5 minutes */

 #define CHANGELOGDB_COMPACT_INTERVAL 2592000 /* 30 days */

+#define CHANGELOGDB_COMPACT_TIME "23:55" /* 30 days */

 #define CONFIG_CHANGELOG_DIR_ATTRIBUTE "nsslapd-changelogdir"

 #define CONFIG_CHANGELOG_MAXENTRIES_ATTRIBUTE "nsslapd-changelogmaxentries"

 #define CONFIG_CHANGELOG_MAXAGE_ATTRIBUTE "nsslapd-changelogmaxage"

 #define CONFIG_CHANGELOG_COMPACTDB_ATTRIBUTE "nsslapd-changelogcompactdb-interval"

+#define CONFIG_CHANGELOG_COMPACTTIME_ATTRIBUTE "nsslapd-changelogcompactdb-time"

 #define CONFIG_CHANGELOG_TRIM_ATTRIBUTE "nsslapd-changelogtrim-interval"

 /* Changelog Internal Configuration Parameters -> Changelog Cache related */

 #define CONFIG_CHANGELOG_ENCRYPTION_ALGORITHM "nsslapd-encryptionalgorithm"

diff --git a/ldap/servers/plugins/retrocl/retrocl.c b/ldap/servers/plugins/retrocl/retrocl.c

index 2a620301c..f73c81528 100644

--- a/ldap/servers/plugins/retrocl/retrocl.c

+++ b/ldap/servers/plugins/retrocl/retrocl.c

@@ -400,7 +400,6 @@ retrocl_start(Slapi_PBlock *pb)

         for (size_t i = 0; i < num_vals; i++) {

             char *value = values[i];

-            size_t length = strlen(value);

             char *pos = strchr(value, ':');

             if (pos == NULL) {

diff --git a/ldap/servers/slapd/back-ldbm/db-bdb/bdb_config.c b/ldap/servers/slapd/back-ldbm/db-bdb/bdb_config.c

index 167644943..4261c6ce2 100644

--- a/ldap/servers/slapd/back-ldbm/db-bdb/bdb_config.c

+++ b/ldap/servers/slapd/back-ldbm/db-bdb/bdb_config.c

@@ -678,6 +678,84 @@ bdb_config_db_compactdb_interval_set(void *arg,

     return retval;

 }

+static void *

+bdb_config_db_compactdb_time_get(void *arg)

+{

+    struct ldbminfo *li = (struct ldbminfo *)arg;

+    return (void *)slapi_ch_strdup(BDB_CONFIG(li)->bdb_compactdb_time);

+}

+

+static int

+bdb_config_db_compactdb_time_set(void *arg,

+                                 void *value,

+                                 char *errorbuf __attribute__((unused)),

+                                 int phase __attribute__((unused)),

+                                 int apply)

+{

+    struct ldbminfo *li = (struct ldbminfo *)arg;

+    char *val = slapi_ch_strdup((char *)value);

+    char *endp = NULL;

+    char *hour_str = NULL;

+    char *min_str = NULL;

+    char *default_time = "23:59";

+    int32_t hour, min;

+    int retval = LDAP_SUCCESS;

+    errno = 0;

+

+    if (strstr(val, ":")) {

+        /* Get the hour and minute */

+        hour_str = ldap_utf8strtok_r(val, ":", &min_str);

+

+        /* Validate hour */

+        hour = strtoll(hour_str, &endp, 10);

+        if (*endp != '\0' || errno == ERANGE || hour < 0 || hour > 23 || strlen(hour_str) != 2) {

+            slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,

+                    "Invalid hour set (%s), must be a two digit number between 00 and 23",

+                    hour_str);

+            slapi_log_err(SLAPI_LOG_ERR, "bdb_config_db_compactdb_interval_set",

+                    "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+                    "Using default of 23:59\n", hour_str);

+            retval = LDAP_OPERATIONS_ERROR;

+            goto done;

+        }

+

+        /* Validate minute */

+        min = strtoll(min_str, &endp, 10);

+        if (*endp != '\0' || errno == ERANGE || min < 0 || min > 59 || strlen(min_str) != 2) {

+            slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,

+                    "Invalid minute set (%s), must be a two digit number between 00 and 59",

+                    hour_str);

+            slapi_log_err(SLAPI_LOG_ERR, "bdb_config_db_compactdb_interval_set",

+                    "Invalid minute set (%s), must be a two digit number between 00 and 59.  "

+                    "Using default of 23:59\n", min_str);

+            retval = LDAP_OPERATIONS_ERROR;

+            goto done;

+        }

+    } else {

+        /* Wrong format */

+        slapi_create_errormsg(errorbuf, SLAPI_DSE_RETURNTEXT_SIZE,

+                "Invalid setting (%s), must have a time format of HH:MM", val);

+        slapi_log_err(SLAPI_LOG_ERR, "bdb_config_db_compactdb_interval_set",

+                "Invalid setting (%s), must have a time format of HH:MM\n", val);

+        retval = LDAP_OPERATIONS_ERROR;

+        goto done;

+    }

+

+done:

+    if (apply) {

+        slapi_ch_free((void **)&(BDB_CONFIG(li)->bdb_compactdb_time));

+        if (retval) {

+            /* Something went wrong, use the default */

+            BDB_CONFIG(li)->bdb_compactdb_time = slapi_ch_strdup(default_time);

+        } else {

+            BDB_CONFIG(li)->bdb_compactdb_time = slapi_ch_strdup((char *)value);

+        }

+    }

+    slapi_ch_free_string(&val;;

+

+    return retval;

+}

+

 static void *

 bdb_config_db_page_size_get(void *arg)

 {

@@ -1473,6 +1551,7 @@ static config_info bdb_config_param[] = {

     {CONFIG_DB_TRANSACTION_WAIT, CONFIG_TYPE_ONOFF, "off", &bdb_config_db_transaction_wait_get, &bdb_config_db_transaction_wait_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

     {CONFIG_DB_CHECKPOINT_INTERVAL, CONFIG_TYPE_INT, "60", &bdb_config_db_checkpoint_interval_get, &bdb_config_db_checkpoint_interval_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

     {CONFIG_DB_COMPACTDB_INTERVAL, CONFIG_TYPE_INT, "2592000" /*30days*/, &bdb_config_db_compactdb_interval_get, &bdb_config_db_compactdb_interval_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

+    {CONFIG_DB_COMPACTDB_TIME, CONFIG_TYPE_STRING, "23:59", &bdb_config_db_compactdb_time_get, &bdb_config_db_compactdb_time_set, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

     {CONFIG_DB_TRANSACTION_BATCH, CONFIG_TYPE_INT, "0", &bdb_get_batch_transactions, &bdb_set_batch_transactions, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

     {CONFIG_DB_TRANSACTION_BATCH_MIN_SLEEP, CONFIG_TYPE_INT, "50", &bdb_get_batch_txn_min_sleep, &bdb_set_batch_txn_min_sleep, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

     {CONFIG_DB_TRANSACTION_BATCH_MAX_SLEEP, CONFIG_TYPE_INT, "50", &bdb_get_batch_txn_max_sleep, &bdb_set_batch_txn_max_sleep, CONFIG_FLAG_ALWAYS_SHOW | CONFIG_FLAG_ALLOW_RUNNING_CHANGE},

diff --git a/ldap/servers/slapd/back-ldbm/db-bdb/bdb_layer.c b/ldap/servers/slapd/back-ldbm/db-bdb/bdb_layer.c

index 2f25f67a2..ec1976d38 100644

--- a/ldap/servers/slapd/back-ldbm/db-bdb/bdb_layer.c

+++ b/ldap/servers/slapd/back-ldbm/db-bdb/bdb_layer.c

@@ -2126,6 +2126,7 @@ bdb_post_close(struct ldbminfo *li, int dbmode)

          */

         slapi_ch_free_string(&conf->bdb_dbhome_directory);

         slapi_ch_free_string(&conf->bdb_home_directory);

+        slapi_ch_free_string(&conf->bdb_compactdb_time);

     }

     return return_value;

@@ -3644,6 +3645,39 @@ log_flush_threadmain(void *param)

     return 0;

 }

+/*

+ * This refreshes the TOD expiration.  So live changes to the configuration

+ * will take effect immediately.

+ */

+static time_t

+bdb_get_tod_expiration(char *expire_time)

+{

+    time_t start_time, todays_elapsed_time, now = time(NULL);

+    struct tm *tm_struct = localtime(&now;;

+    char hour_str[3] = {0};

+    char min_str[3] = {0};

+    char *s = expire_time;

+    char *endp = NULL;

+    int32_t hour, min, expiring_time;

+

+    /* Get today's start time */

+    todays_elapsed_time = (tm_struct->tm_hour * 3600) + (tm_struct->tm_min * 60) + (tm_struct->tm_sec);

+    start_time = slapi_current_utc_time() - todays_elapsed_time;

+

+    /* Get the hour and minute and calculate the expiring time.  The time was

+     * already validated in bdb_config.c:  HH:MM */

+    hour_str[0] = *s++;

+    hour_str[1] = *s++;

+    s++;  /* skip colon */

+    min_str[0] = *s++;

+    min_str[1] = *s++;

+    hour = strtoll(hour_str, &endp, 10);

+    min = strtoll(min_str, &endp, 10);

+    expiring_time = (hour * 60 * 60) + (min * 60);

+

+    return start_time + expiring_time;

+}

+

 /*

  * create a thread for checkpoint_threadmain

  */

@@ -3685,7 +3719,9 @@ checkpoint_threadmain(void *param)

     time_t checkpoint_interval_update = 0;

     time_t compactdb_interval = 0;

     time_t checkpoint_interval = 0;

-    back_txn txn;

+    int32_t compactdb_time = 0;

+    PRBool compacting = PR_FALSE;

+

     PR_ASSERT(NULL != param);

     li = (struct ldbminfo *)param;

@@ -3724,22 +3760,35 @@ checkpoint_threadmain(void *param)

     slapi_timespec_expire_at(checkpoint_interval, &checkpoint_expire);

     while (!BDB_CONFIG(li)->bdb_stop_threads) {

-        /* sleep for a while */

-        /* why aren't we sleeping exactly the right amount of time ? */

-        /* answer---because the interval might be changed after the server

-         * starts up */

+        PR_Lock(li->li_config_mutex);

+        checkpoint_interval_update = (time_t)BDB_CONFIG(li)->bdb_checkpoint_interval;

+        compactdb_interval_update = (time_t)BDB_CONFIG(li)->bdb_compactdb_interval;

+        if (!compacting) {

+            /* Once we know we want to compact we need to stop refreshing the

+             * TOD expiration. Otherwise if the compact time is close to