Revert "Version bump to etcd v3.2.11, grpc v1.7.5"

vendor/github.com/coreos/etcd/lease/leasehttp/BUILD

@@ -13,6 +13,7 @@ go_library(
         "//vendor/github.com/coreos/etcd/lease:go_default_library",
         "//vendor/github.com/coreos/etcd/lease/leasepb:go_default_library",
         "//vendor/github.com/coreos/etcd/pkg/httputil:go_default_library",
+        "//vendor/golang.org/x/net/context:go_default_library",
     ],
 )
 

vendor/github.com/coreos/etcd/lease/leasehttp/http.go

@@ -16,7 +16,6 @@ package leasehttp
 
 import (
 	"bytes"
-	"context"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -27,6 +26,7 @@ import (
 	"github.com/coreos/etcd/lease"
 	"github.com/coreos/etcd/lease/leasepb"
 	"github.com/coreos/etcd/pkg/httputil"
+	"golang.org/x/net/context"
 )
 
 var (
@@ -202,27 +202,45 @@ func TimeToLiveHTTP(ctx context.Context, id lease.LeaseID, keys bool, url string
 	}
 	req.Header.Set("Content-Type", "application/protobuf")
 
-	req = req.WithContext(ctx)
+	cancel := httputil.RequestCanceler(req)
 
 	cc := &http.Client{Transport: rt}
 	var b []byte
 	// buffer errc channel so that errc don't block inside the go routinue
-	resp, err := cc.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	b, err = readResponse(resp)
-	if err != nil {
-		return nil, err
-	}
-	if resp.StatusCode == http.StatusRequestTimeout {
-		return nil, ErrLeaseHTTPTimeout
-	}
-	if resp.StatusCode == http.StatusNotFound {
-		return nil, lease.ErrLeaseNotFound
-	}
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("lease: unknown error(%s)", string(b))
+	errc := make(chan error, 2)
+	go func() {
+		resp, err := cc.Do(req)
+		if err != nil {
+			errc <- err
+			return
+		}
+		b, err = readResponse(resp)
+		if err != nil {
+			errc <- err
+			return
+		}
+		if resp.StatusCode == http.StatusRequestTimeout {
+			errc <- ErrLeaseHTTPTimeout
+			return
+		}
+		if resp.StatusCode == http.StatusNotFound {
+			errc <- lease.ErrLeaseNotFound
+			return
+		}
+		if resp.StatusCode != http.StatusOK {
+			errc <- fmt.Errorf("lease: unknown error(%s)", string(b))
+			return
+		}
+		errc <- nil
+	}()
+	select {
+	case derr := <-errc:
+		if derr != nil {
+			return nil, derr
+		}
+	case <-ctx.Done():
+		cancel()
+		return nil, ctx.Err()
 	}
 
 	lresp := &leasepb.LeaseInternalResponse{}

vendor/github.com/coreos/etcd/lease/leasepb/lease.pb.go

@@ -590,7 +590,7 @@ func init() { proto.RegisterFile("lease.proto", fileDescriptorLease) }
 
 var fileDescriptorLease = []byte{
 	// 233 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x49, 0x4d, 0x2c,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0xce, 0x49, 0x4d, 0x2c,
 	0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x07, 0x73, 0x0a, 0x92, 0xa4, 0x44, 0xd2,
 	0xf3, 0xd3, 0xf3, 0xc1, 0x62, 0xfa, 0x20, 0x16, 0x44, 0x5a, 0x4a, 0x2d, 0xb5, 0x24, 0x39, 0x45,
 	0x1f, 0x44, 0x14, 0xa7, 0x16, 0x95, 0xa5, 0x16, 0x21, 0x31, 0x0b, 0x92, 0xf4, 0x8b, 0x0a, 0x92,

vendor/github.com/coreos/etcd/lease/lessor.go

@@ -31,39 +31,40 @@ import (
 const (
 	// NoLease is a special LeaseID representing the absence of a lease.
 	NoLease = LeaseID(0)
-
-	forever = monotime.Time(math.MaxInt64)
 )
 
 var (
 	leaseBucketName = []byte("lease")
 
-	// maximum number of leases to revoke per second; configurable for tests
-	leaseRevokeRate = 1000
+	forever = monotime.Time(math.MaxInt64)
 
 	ErrNotPrimary    = errors.New("not a primary lessor")
 	ErrLeaseNotFound = errors.New("lease not found")
 	ErrLeaseExists   = errors.New("lease already exists")
 )
 
-// TxnDelete is a TxnWrite that only permits deletes. Defined here
-// to avoid circular dependency with mvcc.
-type TxnDelete interface {
-	DeleteRange(key, end []byte) (n, rev int64)
-	End()
-}
-
-// RangeDeleter is a TxnDelete constructor.
-type RangeDeleter func() TxnDelete
-
 type LeaseID int64
 
+// RangeDeleter defines an interface with Txn and DeleteRange method.
+// We define this interface only for lessor to limit the number
+// of methods of mvcc.KV to what lessor actually needs.
+//
+// Having a minimum interface makes testing easy.
+type RangeDeleter interface {
+	// TxnBegin see comments on mvcc.KV
+	TxnBegin() int64
+	// TxnEnd see comments on mvcc.KV
+	TxnEnd(txnID int64) error
+	// TxnDeleteRange see comments on mvcc.KV
+	TxnDeleteRange(txnID int64, key, end []byte) (n, rev int64, err error)
+}
+
 // Lessor owns leases. It can grant, revoke, renew and modify leases for lessee.
 type Lessor interface {
-	// SetRangeDeleter lets the lessor create TxnDeletes to the store.
-	// Lessor deletes the items in the revoked or expired lease by creating
-	// new TxnDeletes.
-	SetRangeDeleter(rd RangeDeleter)
+	// SetRangeDeleter sets the RangeDeleter to the Lessor.
+	// Lessor deletes the items in the revoked or expired lease from the
+	// the set RangeDeleter.
+	SetRangeDeleter(dr RangeDeleter)
 
 	// Grant grants a lease that expires at least after TTL seconds.
 	Grant(id LeaseID, ttl int64) (*Lease, error)
@@ -247,14 +248,17 @@ func (le *lessor) Revoke(id LeaseID) error {
 		return nil
 	}
 
-	txn := le.rd()
+	tid := le.rd.TxnBegin()
 
 	// sort keys so deletes are in same order among all members,
 	// otherwise the backened hashes will be different
 	keys := l.Keys()
 	sort.StringSlice(keys).Sort()
 	for _, key := range keys {
-		txn.DeleteRange([]byte(key), nil)
+		_, _, err := le.rd.TxnDeleteRange(tid, []byte(key), nil)
+		if err != nil {
+			panic(err)
+		}
 	}
 
 	le.mu.Lock()
@@ -265,7 +269,11 @@ func (le *lessor) Revoke(id LeaseID) error {
 	// deleting the keys if etcdserver fails in between.
 	le.b.BatchTx().UnsafeDelete(leaseBucketName, int64ToBytes(int64(l.ID)))
 
-	txn.End()
+	err := le.rd.TxnEnd(tid)
+	if err != nil {
+		panic(err)
+	}
+
 	return nil
 }
 
@@ -327,53 +335,8 @@ func (le *lessor) Promote(extend time.Duration) {
 	for _, l := range le.leaseMap {
 		l.refresh(extend)
 	}
-
-	if len(le.leaseMap) < leaseRevokeRate {
-		// no possibility of lease pile-up
-		return
-	}
-
-	// adjust expiries in case of overlap
-	leases := make([]*Lease, 0, len(le.leaseMap))
-	for _, l := range le.leaseMap {
-		leases = append(leases, l)
-	}
-	sort.Sort(leasesByExpiry(leases))
-
-	baseWindow := leases[0].Remaining()
-	nextWindow := baseWindow + time.Second
-	expires := 0
-	// have fewer expires than the total revoke rate so piled up leases
-	// don't consume the entire revoke limit
-	targetExpiresPerSecond := (3 * leaseRevokeRate) / 4
-	for _, l := range leases {
-		remaining := l.Remaining()
-		if remaining > nextWindow {
-			baseWindow = remaining
-			nextWindow = baseWindow + time.Second
-			expires = 1
-			continue
-		}
-		expires++
-		if expires <= targetExpiresPerSecond {
-			continue
-		}
-		rateDelay := float64(time.Second) * (float64(expires) / float64(targetExpiresPerSecond))
-		// If leases are extended by n seconds, leases n seconds ahead of the
-		// base window should be extended by only one second.
-		rateDelay -= float64(remaining - baseWindow)
-		delay := time.Duration(rateDelay)
-		nextWindow = baseWindow + delay
-		l.refresh(delay + extend)
-	}
 }
 
-type leasesByExpiry []*Lease
-
-func (le leasesByExpiry) Len() int           { return len(le) }
-func (le leasesByExpiry) Less(i, j int) bool { return le[i].Remaining() < le[j].Remaining() }
-func (le leasesByExpiry) Swap(i, j int)      { le[i], le[j] = le[j], le[i] }
-
 func (le *lessor) Demote() {
 	le.mu.Lock()
 	defer le.mu.Unlock()
@@ -470,10 +433,6 @@ func (le *lessor) runLoop() {
 		le.mu.Unlock()
 
 		if len(ls) != 0 {
-			// rate limit
-			if len(ls) > leaseRevokeRate/2 {
-				ls = ls[:leaseRevokeRate/2]
-			}
 			select {
 			case <-le.stopC:
 				return