Early termination on session expiration to avoid unnecessary lock waiting

[justlorain]

What would you like to be added?

As mentioned in the concurrency/Mutex TODO,

etcd/client/v3/concurrency/mutex.go

Line 88 in 05d5753

// TODO: early termination if the session key is deleted before other session keys with smaller revisions.

the current implementation causes unnecessary waiting when a session expires. The following example illustrates this issue.

Suppose three clients (A, B, and C) sequentially call the Lock method

etcd/client/v3/concurrency/mutex.go

Line 75 in 05d5753

func (m *Mutex) Lock(ctx context.Context) error {

to acquire a lock. At this point, A holds the lock, B is waiting for A (waiting for A’s key to be deleted), and C is waiting for B. Both client B and client C are blocked in the waitDeletes method.

etcd/client/v3/concurrency/key.go

Line 49 in 05d5753

func waitDeletes(ctx context.Context, client *v3.Client, pfx string, maxCreateRev int64) error {

Now, if client C’s session cancels lease refresh using the Orphan method,

etcd/client/v3/concurrency/session.go

Line 102 in 05d5753

func (s *Session) Orphan() {

the key held by client C in the waiting queue will be automatically deleted when the lease expires. However, client C will still remain blocked in the waitDeletes method until B’s key is deleted. Only then will client C be able to detect, through the check

etcd/client/v3/concurrency/mutex.go

Lines 96 to 105 in 05d5753

	// make sure the session is not expired, and the owner key still exists.
	gresp, werr := client.Get(ctx, m.myKey)
	if werr != nil {
	m.Unlock(client.Ctx())
	return werr
	}
	if len(gresp.Kvs) == 0 { // is the session key lost?
	return ErrSessionExpired
	}

in the Lock method, that its key has already been deleted, thus returning the ErrSessionExpired error.

To resolve this issue, we can Watch for the deletion events of both the key with a smaller revision and the key held by the current client. This way, we can return immediately when the session expires instead of waiting until all keys with smaller revisions have been deleted.

Why is this needed?

Resolve the situation described in the TODO and reduce unnecessary lock waiting.