Add offline_timeout_max option to control offline interval backoff

src/confdb/confdb.h

@@ -243,6 +243,7 @@
 #define CONFDB_DOMAIN_PWD_EXPIRATION_WARNING "pwd_expiration_warning"
 #define CONFDB_DOMAIN_REFRESH_EXPIRED_INTERVAL "refresh_expired_interval"
 #define CONFDB_DOMAIN_OFFLINE_TIMEOUT "offline_timeout"
+#define CONFDB_DOMAIN_OFFLINE_TIMEOUT_MAX "offline_timeout_max"
 #define CONFDB_DOMAIN_SUBDOMAIN_INHERIT "subdomain_inherit"
 #define CONFDB_DOMAIN_CACHED_AUTH_TIMEOUT "cached_auth_timeout"
 #define CONFDB_DOMAIN_TYPE "domain_type"

src/config/SSSDConfigTest.py

@@ -593,6 +593,7 @@ def testListOptions(self):
             'max_id',
             'timeout',
             'offline_timeout',
+            'offline_timeout_max',
             'command',
             'enumerate',
             'cache_credentials',
@@ -969,6 +970,7 @@ def testRemoveProvider(self):
             'max_id',
             'timeout',
             'offline_timeout',
+            'offline_timeout_max',
             'command',
             'enumerate',
             'cache_credentials',

src/config/cfg_rules.ini

@@ -369,6 +369,7 @@ option = timeout
 option = enumerate
 option = subdomain_enumerate
 option = offline_timeout
+option = offline_timeout_max
 option = cache_credentials
 option = cache_credentials_minimal_first_factor_length
 option = use_fully_qualified_names

src/config/etc/sssd.api.conf

@@ -166,6 +166,7 @@ timeout = int, None, false
 enumerate = bool, None, false
 subdomain_enumerate = str, None, false
 offline_timeout = int, None, false
+offline_timeout_max = int, None, false
 cache_credentials = bool, None, false
 cache_credentials_minimal_first_factor_length = int, None, false
 use_fully_qualified_names = bool, None, false

src/man/sssd.conf.5.xml

@@ -783,15 +783,37 @@
                         </para>
                         <para>
                             Note that the maximum length of each interval
-                            is currently limited to one hour. If the
-                            calculated length of new_interval is greater
-                            than an hour, it will be forced to one hour.
+                            is defined by offline_timeout_max, which defaults
+                            to one hour. If the calculated length of new_interval
+                            is greater than offline_timeout_max, it will be forced
+                            to the offline_timeout_max value.
                         </para>
                         <para>
                             Default: 60
                         </para>
                     </listitem>
                 </varlistentry>
+                <varlistentry>
+                    <term>offline_timeout_max (integer)</term>
+                    <listitem>
+                        <para>
+                            Controls by how much the time between attempts to go
+                            online can be incremented following unsuccessful
+                            attempts to go online.
+                        </para>
+                        <para>
+                            A value of 0 disables the incrementing behaviour.
+                        </para>
+                        <para>
+                            Although a value between 0 and offline_timeout may be
+                            specified, it has the effect of overriding the
+                            offline_timeout value so is of little use.
+                        </para>
+                        <para>
+                            Default: 3600
+                        </para>
+                    </listitem>
+                </varlistentry>
                 <varlistentry>
                     <term>responder_idle_timeout</term>
                     <listitem>

src/providers/be_ptask.c

@@ -214,12 +214,12 @@ static void be_ptask_schedule(struct be_ptask *task,
             return;
         }
 
-        delay = task->period;
-
-        if (backoff_allowed(task) && task->period * 2 <= task->max_backoff) {
+        if (backoff_allowed(task)) {
             /* double the period for the next execution */
-            task->period *= 2;
+            task->period = MIN(task->period * 2, task->max_backoff);
         }
+
+        delay = task->period;
         break;
     }
 

src/providers/data_provider_be.c

@@ -51,6 +51,9 @@
 #define ONLINE_CB_RETRY 3
 #define ONLINE_CB_RETRY_MAX_DELAY 4
 
+#define OFFLINE_TIMEOUT_DEFAULT 60
+#define OFFLINE_TIMEOUT_MAX_DEFAULT 3600
+
 /* sssd.service */
 static errno_t
 data_provider_res_init(TALLOC_CTX *mem_ctx,
@@ -98,21 +101,42 @@ static int get_offline_timeout(struct be_ctx *ctx)
     int offline_timeout;
 
     ret = confdb_get_int(ctx->cdb, ctx->conf_path,
-                         CONFDB_DOMAIN_OFFLINE_TIMEOUT, 60,
+                         CONFDB_DOMAIN_OFFLINE_TIMEOUT,
+                         OFFLINE_TIMEOUT_DEFAULT,
                          &offline_timeout);
     if (ret != EOK) {
         DEBUG(SSSDBG_CRIT_FAILURE,
               "Failed to get offline_timeout from confdb. "
-              "Will use 60 seconds.\n");
-        offline_timeout = 60;
+              "Will use %d seconds.\n", OFFLINE_TIMEOUT_DEFAULT);
+        offline_timeout = OFFLINE_TIMEOUT_DEFAULT;
     }
 
     return offline_timeout;
 }
 
+static int get_offline_timeout_max(struct be_ctx *ctx)
+{
+    int offline_timeout_max;
+    errno_t ret;
+
+    ret = confdb_get_int(ctx->cdb, ctx->conf_path,
+                         CONFDB_DOMAIN_OFFLINE_TIMEOUT_MAX,
+                         OFFLINE_TIMEOUT_MAX_DEFAULT,
+                         &offline_timeout_max);
+    if (ret != EOK) {
+        DEBUG(SSSDBG_CONF_SETTINGS,
+              "Failed to get offline_timeout_max from confdb. "
+              "Will use %d seconds.\n", OFFLINE_TIMEOUT_MAX_DEFAULT);
+        offline_timeout_max = OFFLINE_TIMEOUT_MAX_DEFAULT;
+    }
+
+    return offline_timeout_max;
+}
+
 void be_mark_offline(struct be_ctx *ctx)
 {
     int offline_timeout;
+    int offline_timeout_max;
     errno_t ret;
 
     DEBUG(SSSDBG_TRACE_INTERNAL, "Going offline!\n");
@@ -126,11 +150,12 @@ void be_mark_offline(struct be_ctx *ctx)
         DEBUG(SSSDBG_TRACE_INTERNAL, "Initialize check_if_online_ptask.\n");
 
         offline_timeout = get_offline_timeout(ctx);
+        offline_timeout_max = get_offline_timeout_max(ctx);
 
         ret = be_ptask_create_sync(ctx, ctx,
                                    offline_timeout, offline_timeout,
                                    offline_timeout, 30, offline_timeout,
-                                   3600 /* max_backoff */,
+                                   offline_timeout_max,
                                    try_to_go_online,
                                    ctx, "Check if online (periodic)",
                                    BE_PTASK_OFFLINE_EXECUTE,