this.maxRetryCount = maxRetryCount;
    }

    public long getRetryInterval() {
        return retryInterval;
    }

    public void setRetryInterval(final long retryInterval) {
        this.retryInterval = retryInterval;
    }

    public RequestListener getRequestListener() {
        return listener;
    }

	mutex         sync.Mutex
	retryInterval time.Duration
}

type dynamicTimeoutOpts struct {
	timeout       time.Duration
	minimum       time.Duration
	retryInterval time.Duration
}

func newDynamicTimeoutWithOpts(opts dynamicTimeoutOpts) *dynamicTimeout {
	dt := newDynamicTimeout(opts.timeout, opts.minimum)
	dt.retryInterval = opts.retryInterval
	return dt
}

			return cfg, fmt.Errorf("invalid %s max_retry", maxRetryCfgVal)
		}
		retryIntervalCfgVal := getCfgVal(EnvLoggerWebhookRetryInterval, k, kv.Get(RetryInterval))
		retryInterval, err := time.ParseDuration(retryIntervalCfgVal)
		if err != nil {
			return cfg, err
		}
		if retryInterval > time.Minute {
			return cfg, fmt.Errorf("maximum allowed value for retry interval is '1m': %s", retryIntervalCfgVal)
		}
		cfg.HTTP[k] = http.Config{

package store

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	xioutil "github.com/minio/minio/internal/ioutil"
)

const (
	retryInterval = 3 * time.Second
)

type logger = func(ctx context.Context, err error, id string, errKind ...interface{})

// ErrNotConnected - indicates that the target connection is not active.

	start := UTCNow()

	newCtx, cancel := context.WithCancel(ctx)
	if !di.rwMutex.GetLock(newCtx, cancel, di.opsID, lockSource, dsync.Options{
		Timeout:       timeout.Timeout(),
		RetryInterval: timeout.RetryInterval(),
	}) {
		timeout.LogFailure()
		defer cancel()
		if err := newCtx.Err(); err == context.Canceled {
			return LockContext{ctx: ctx, cancel: func() {}}, err
		}

    }

    public void setSizeForDelete(final int sizeForDelete) {
        this.sizeForDelete = sizeForDelete;
    }

    public void setRetryInterval(final long retryInterval) {
        this.retryInterval = retryInterval;
    }

    public void setMaxRetryCount(final int maxRetryCount) {
        this.maxRetryCount = maxRetryCount;
    }

    public void setConnTimeout(final long connTimeout) {

package cmd

import (
	"context"
	"time"
)

var sharedLockTimeout = newDynamicTimeoutWithOpts(dynamicTimeoutOpts{
	timeout:       30 * time.Second,
	minimum:       10 * time.Second,
	retryInterval: time.Minute,
})

type sharedLock struct {
	lockContext chan LockContext
}

func (ld sharedLock) backgroundRoutine(ctx context.Context, objAPI ObjectLayer, lockName string) {
	for {

		config.HelpKV{
			Key:         MaxRetry,
			Description: `maximum retry count before we start dropping logged event(s)`,
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         RetryInterval,
			Description: `sleep between each retries, allowed maximum value is '1m' e.g. '10s'`,
			Optional:    true,
			Type:        "duration",
		},
		config.HelpKV{
			Key:         httpTimeout,

		class="org.codelibs.fess.crawler.client.FaultTolerantClient" instance="prototype">
		<property name="crawlerClient">internalHttpClient</property>
		<property name="maxRetryCount">5</property>
		<property name="retryInterval">500</property>
	</component>

	<component name="fsClient"
		class="org.codelibs.fess.crawler.client.fs.FileSystemClient" instance="prototype">
		<property name="charset">"UTF-8"</property>
	</component>

				dm.startContinuousLockRefresh(lockLossCallback, id, source, quorum)

				return locked
			}

			switch {
			case opts.RetryInterval < 0:
				return false
			case opts.RetryInterval > 0:
				time.Sleep(opts.RetryInterval)
			default:
				attempt++
				time.Sleep(lockRetryBackOff(dm.rng, attempt))
			}
		}
	}
}