Allow setting/disabling Obtain deadline in Options about redislock

[segevfiner]

Here is the workaround I had to write:

// obtainLockIndefinitly tries to obtain a new lock using a key with the given TTL, indefinitly as
// long as the retry strategy says to retry.
// May return ErrNotObtained if not successful.
//
// XXX This is a workaround around Obtain having an unsettable deadline, setting it hardcoded to
// the ttl.
func obtainLockIndefinitly(client *redislock.Client, key string, ttl time.Duration, opt *redislock.Options) (*redislock.Lock, error) {
	var opt2 redislock.Options
	if opt != nil {
		opt2 = *opt
	}

	ctx := context.Background()
	if opt != nil && opt.Context != nil {
		ctx = opt.Context
	}

	retry := redislock.NoRetry()
	if opt != nil && opt.RetryStrategy != nil {
		retry = opt.RetryStrategy
		opt2.RetryStrategy = nil
	}

	var timer *time.Timer
	for {
		lock, err := client.Obtain(key, ttl, &opt2)
		if err != nil && err != redislock.ErrNotObtained {
			return nil, err
		} else if err == nil {
			return lock, nil
		}

		backoff := retry.NextBackoff()
		if backoff < 1 {
			break
		}

		if timer == nil {
			timer = time.NewTimer(backoff)
			defer timer.Stop()
		} else {
			timer.Reset(backoff)
		}

		select {
		case <-ctx.Done():
			return nil, ctx.Err()
		case <-timer.C:
		}
	}

	return nil, redislock.ErrNotObtained
}

[dim]

@segevfiner in reality you need to have some sort of overall deadline, because any lock is by nature temporary and not permanent. That being said, nothing prevents you from setting a HUGE ttl, e.g. 365*24*time.Hour. Wouldn't that solve the problem?

[segevfiner]

No. Because I still want to have a short TTL for the lock itself in Redis, I only want to try locking it indefinitely, but once it is locked, it should have a short TTL and the code will take care of refreshing it.

[dim]

How about #22?