Merge pull request #5579 from gyuho/request_union

RequestOp, ResponseOp

Documentation/dev-guide/api_reference_v3.md

@@ -12,13 +12,13 @@
 | UserGet | AuthUserGetRequest | AuthUserGetResponse | UserGet gets detailed user information or lists all users. |
 | UserDelete | AuthUserDeleteRequest | AuthUserDeleteResponse | UserDelete deletes a specified user. |
 | UserChangePassword | AuthUserChangePasswordRequest | AuthUserChangePasswordResponse | UserChangePassword changes the password of a specified user. |
-| UserGrant | AuthUserGrantRequest | AuthUserGrantResponse | UserGrant grants a role to a specified user. |
-| UserRevoke | AuthUserRevokeRequest | AuthUserRevokeResponse | UserRevoke revokes a role of specified user. |
+| UserGrantRole | AuthUserGrantRoleRequest | AuthUserGrantRoleResponse | UserGrant grants a role to a specified user. |
+| UserRevokeRole | AuthUserRevokeRoleRequest | AuthUserRevokeRoleResponse | UserRevokeRole revokes a role of specified user. |
 | RoleAdd | AuthRoleAddRequest | AuthRoleAddResponse | RoleAdd adds a new role. |
 | RoleGet | AuthRoleGetRequest | AuthRoleGetResponse | RoleGet gets detailed role information or lists all roles. |
 | RoleDelete | AuthRoleDeleteRequest | AuthRoleDeleteResponse | RoleDelete deletes a specified role. |
-| RoleGrant | AuthRoleGrantRequest | AuthRoleGrantResponse | RoleGrant grants a permission of a specified key or range to a specified role. |
-| RoleRevoke | AuthRoleRevokeRequest | AuthRoleRevokeResponse | RoleRevoke revokes a key or range permission of a specified role. |
+| RoleGrantPermission | AuthRoleGrantPermissionRequest | AuthRoleGrantPermissionResponse | RoleGrantPermission grants a permission of a specified key or range to a specified role. |
+| RoleRevokePermission | AuthRoleRevokePermissionRequest | AuthRoleRevokePermissionResponse | RoleRevokePermission revokes a key or range permission of a specified role. |
 
 
 
@@ -149,7 +149,9 @@ Empty field.
 
 ##### message `AuthRoleDeleteRequest` (etcdserver/etcdserverpb/rpc.proto)
 
-Empty field.
+| Field | Description | Type |
+| ----- | ----------- | ---- |
+| role |  | string |
 
 
 
@@ -163,7 +165,9 @@ Empty field.
 
 ##### message `AuthRoleGetRequest` (etcdserver/etcdserverpb/rpc.proto)
 
-Empty field.
+| Field | Description | Type |
+| ----- | ----------- | ---- |
+| role |  | string |
 
 
 
@@ -172,10 +176,11 @@ Empty field.
 | Field | Description | Type |
 | ----- | ----------- | ---- |
 | header |  | ResponseHeader |
+| perm |  | (slice of) authpb.Permission |
 
 
 
-##### message `AuthRoleGrantRequest` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthRoleGrantPermissionRequest` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -184,7 +189,7 @@ Empty field.
 
 
 
-##### message `AuthRoleGrantResponse` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthRoleGrantPermissionResponse` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -192,13 +197,16 @@ Empty field.
 
 
 
-##### message `AuthRoleRevokeRequest` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthRoleRevokePermissionRequest` (etcdserver/etcdserverpb/rpc.proto)
 
-Empty field.
+| Field | Description | Type |
+| ----- | ----------- | ---- |
+| role |  | string |
+| key |  | string |
 
 
 
-##### message `AuthRoleRevokeResponse` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthRoleRevokePermissionResponse` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -258,7 +266,9 @@ Empty field.
 
 ##### message `AuthUserGetRequest` (etcdserver/etcdserverpb/rpc.proto)
 
-Empty field.
+| Field | Description | Type |
+| ----- | ----------- | ---- |
+| name |  | string |
 
 
 
@@ -267,10 +277,11 @@ Empty field.
 | Field | Description | Type |
 | ----- | ----------- | ---- |
 | header |  | ResponseHeader |
+| roles |  | (slice of) string |
 
 
 
-##### message `AuthUserGrantRequest` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthUserGrantRoleRequest` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -279,7 +290,7 @@ Empty field.
 
 
 
-##### message `AuthUserGrantResponse` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthUserGrantRoleResponse` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -287,13 +298,16 @@ Empty field.
 
 
 
-##### message `AuthUserRevokeRequest` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthUserRevokeRoleRequest` (etcdserver/etcdserverpb/rpc.proto)
 
-Empty field.
+| Field | Description | Type |
+| ----- | ----------- | ---- |
+| name |  | string |
+| role |  | string |
 
 
 
-##### message `AuthUserRevokeResponse` (etcdserver/etcdserverpb/rpc.proto)
+##### message `AuthUserRevokeRoleResponse` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -572,7 +586,7 @@ Empty field.
 
 
 
-##### message `RequestUnion` (etcdserver/etcdserverpb/rpc.proto)
+##### message `RequestOp` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -594,7 +608,7 @@ Empty field.
 
 
 
-##### message `ResponseUnion` (etcdserver/etcdserverpb/rpc.proto)
+##### message `ResponseOp` (etcdserver/etcdserverpb/rpc.proto)
 
 | Field | Description | Type |
 | ----- | ----------- | ---- |
@@ -647,8 +661,8 @@ From google paxosdb paper: Our implementation hinges around a powerful primitive
 | Field | Description | Type |
 | ----- | ----------- | ---- |
 | compare | compare is a list of predicates representing a conjunction of terms. If the comparisons succeed, then the success requests will be processed in order, and the response will contain their respective responses in order. If the comparisons fail, then the failure requests will be processed in order, and the response will contain their respective responses in order. | (slice of) Compare |
-| success | success is a list of requests which will be applied when compare evaluates to true. | (slice of) RequestUnion |
-| failure | failure is a list of requests which will be applied when compare evaluates to false. | (slice of) RequestUnion |
+| success | success is a list of requests which will be applied when compare evaluates to true. | (slice of) RequestOp |
+| failure | failure is a list of requests which will be applied when compare evaluates to false. | (slice of) RequestOp |
 
 
 
@@ -658,7 +672,7 @@ From google paxosdb paper: Our implementation hinges around a powerful primitive
 | ----- | ----------- | ---- |
 | header |  | ResponseHeader |
 | succeeded | succeeded is set to true if the compare evaluated to true or false otherwise. | bool |
-| responses | responses is a list of responses corresponding to the results from applying success if succeeded is true or failure if succeeded is false. | (slice of) ResponseUnion |
+| responses | responses is a list of responses corresponding to the results from applying success if succeeded is true or failure if succeeded is false. | (slice of) ResponseOp |
 
 
 

auth/authpb/auth.pb.go

@@ -756,7 +756,7 @@ var (
 )
 
 var fileDescriptorAuth = []byte{
-	// 254 bytes of a gzipped FileDescriptorProto
+	// 265 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4a, 0x2c, 0x2d, 0xc9,
 	0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0xb1, 0x0b, 0x92, 0xa4, 0x44, 0xd2, 0xf3,
 	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x87, 0x8b, 0x25, 0xb4, 0x38, 0xb5,
@@ -764,13 +764,14 @@ var fileDescriptorAuth = []byte{
 	0xcc, 0x16, 0x92, 0xe2, 0xe2, 0x28, 0x48, 0x2c, 0x2e, 0x2e, 0xcf, 0x2f, 0x4a, 0x91, 0x60, 0x02,
 	0x8b, 0xc3, 0xf9, 0x42, 0x22, 0x5c, 0xac, 0x45, 0xf9, 0x39, 0xa9, 0xc5, 0x12, 0xcc, 0x0a, 0xcc,
 	0x1a, 0x9c, 0x41, 0x10, 0x8e, 0x52, 0x3d, 0x17, 0x57, 0x40, 0x6a, 0x51, 0x6e, 0x66, 0x71, 0x71,
-	0x66, 0x7e, 0x9e, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x48, 0x10, 0x53, 0xc8, 0x18,
-	0x68, 0x22, 0x50, 0x3e, 0xa4, 0xb2, 0x20, 0x15, 0x6c, 0x22, 0x9f, 0x91, 0xb8, 0x1e, 0xc4, 0x79,
-	0x7a, 0x08, 0x7d, 0x7a, 0x20, 0xe9, 0x20, 0xb8, 0x42, 0x25, 0x2d, 0x2e, 0x16, 0x10, 0x2d, 0xc4,
-	0xc1, 0xc5, 0x12, 0xe4, 0xea, 0xe8, 0x22, 0xc0, 0x20, 0xc4, 0xc9, 0xc5, 0x1a, 0x1e, 0xe4, 0x19,
-	0xe2, 0x2a, 0xc0, 0x28, 0xc4, 0xcb, 0xc5, 0x09, 0x12, 0x84, 0x70, 0x99, 0x94, 0x42, 0x80, 0x6a,
-	0x80, 0x2e, 0xc1, 0xea, 0x1d, 0x0b, 0x2e, 0x5e, 0xa0, 0x1b, 0x10, 0xf6, 0x00, 0x5d, 0xc0, 0xac,
-	0xc1, 0x6d, 0x24, 0x84, 0xe9, 0x82, 0x20, 0x54, 0x85, 0x4e, 0x22, 0x27, 0x1e, 0xca, 0x31, 0x5c,
-	0x00, 0xe2, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x00, 0xf1, 0x03, 0x20, 0x4e, 0x62, 0x03, 0x87, 0xa0,
-	0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x92, 0x06, 0xa1, 0xed, 0x6d, 0x01, 0x00, 0x00,
+	0x66, 0x7e, 0x9e, 0x90, 0x00, 0x17, 0x73, 0x76, 0x6a, 0x25, 0xd4, 0x48, 0x10, 0x53, 0xc8, 0x98,
+	0x8b, 0xa3, 0x20, 0xb5, 0x28, 0x37, 0xa4, 0xb2, 0x20, 0x15, 0x6c, 0x22, 0x9f, 0x91, 0xb8, 0x1e,
+	0xc4, 0x79, 0x7a, 0x08, 0x7d, 0x7a, 0x20, 0xe9, 0x20, 0xb8, 0x42, 0x25, 0x2d, 0x2e, 0x16, 0x10,
+	0x2d, 0xc4, 0xc1, 0xc5, 0x12, 0xe4, 0xea, 0xe8, 0x22, 0xc0, 0x20, 0xc4, 0xc9, 0xc5, 0x1a, 0x1e,
+	0xe4, 0x19, 0xe2, 0x2a, 0xc0, 0x28, 0xc4, 0xcb, 0xc5, 0x09, 0x12, 0x84, 0x70, 0x99, 0x94, 0x42,
+	0xb8, 0x58, 0x82, 0xf2, 0x73, 0x52, 0xb1, 0x7a, 0xc7, 0x82, 0x8b, 0x37, 0x3b, 0xb5, 0x12, 0x61,
+	0x8f, 0x04, 0x93, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x10, 0xa6, 0x0b, 0x82, 0x50, 0x15, 0x3a, 0x89,
+	0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe1, 0xa1, 0x1c, 0xc3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9,
+	0x31, 0x3e, 0x78, 0x24, 0xc7, 0x98, 0xc4, 0x06, 0x0e, 0x41, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x92, 0x06, 0xa1, 0xed, 0x6d, 0x01, 0x00, 0x00,
 }

clientv3/op.go

@@ -53,7 +53,7 @@ type Op struct {
 	leaseID LeaseID
 }
 
-func (op Op) toRequestUnion() *pb.RequestUnion {
+func (op Op) toRequestOp() *pb.RequestOp {
 	switch op.t {
 	case tRange:
 		r := &pb.RangeRequest{Key: op.key, RangeEnd: op.end, Limit: op.limit, Revision: op.rev, Serializable: op.serializable}
@@ -61,13 +61,13 @@ func (op Op) toRequestUnion() *pb.RequestUnion {
 			r.SortOrder = pb.RangeRequest_SortOrder(op.sort.Order)
 			r.SortTarget = pb.RangeRequest_SortTarget(op.sort.Target)
 		}
-		return &pb.RequestUnion{Request: &pb.RequestUnion_RequestRange{RequestRange: r}}
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestRange{RequestRange: r}}
 	case tPut:
 		r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID)}
-		return &pb.RequestUnion{Request: &pb.RequestUnion_RequestPut{RequestPut: r}}
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: r}}
 	case tDeleteRange:
 		r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end}
-		return &pb.RequestUnion{Request: &pb.RequestUnion_RequestDeleteRange{RequestDeleteRange: r}}
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{RequestDeleteRange: r}}
 	default:
 		panic("Unknown Op")
 	}

clientv3/txn.go

@@ -66,8 +66,8 @@ type txn struct {
 
 	cmps []*pb.Compare
 
-	sus []*pb.RequestUnion
-	fas []*pb.RequestUnion
+	sus []*pb.RequestOp
+	fas []*pb.RequestOp
 }
 
 func (txn *txn) If(cs ...Cmp) Txn {
@@ -110,7 +110,7 @@ func (txn *txn) Then(ops ...Op) Txn {
 
 	for _, op := range ops {
 		txn.isWrite = txn.isWrite || op.isWrite()
-		txn.sus = append(txn.sus, op.toRequestUnion())
+		txn.sus = append(txn.sus, op.toRequestOp())
 	}
 
 	return txn
@@ -128,7 +128,7 @@ func (txn *txn) Else(ops ...Op) Txn {
 
 	for _, op := range ops {
 		txn.isWrite = txn.isWrite || op.isWrite()
-		txn.fas = append(txn.fas, op.toRequestUnion())
+		txn.fas = append(txn.fas, op.toRequestOp())
 	}
 
 	return txn

etcdctl/ctlv3/command/printer.go

@@ -128,11 +128,11 @@ func (s *simplePrinter) Txn(resp v3.TxnResponse) {
 	for _, r := range resp.Responses {
 		fmt.Println("")
 		switch v := r.Response.(type) {
-		case *pb.ResponseUnion_ResponseDeleteRange:
+		case *pb.ResponseOp_ResponseDeleteRange:
 			s.Del((v3.DeleteResponse)(*v.ResponseDeleteRange))
-		case *pb.ResponseUnion_ResponsePut:
+		case *pb.ResponseOp_ResponsePut:
 			s.Put((v3.PutResponse)(*v.ResponsePut))
-		case *pb.ResponseUnion_ResponseRange:
+		case *pb.ResponseOp_ResponseRange:
 			s.Get(((v3.GetResponse)(*v.ResponseRange)))
 		default:
 			fmt.Printf("unexpected response %+v\n", r)

etcdserver/api/v3rpc/key.go

@@ -156,7 +156,7 @@ func checkTxnRequest(r *pb.TxnRequest) error {
 	}
 
 	for _, u := range r.Success {
-		if err := checkRequestUnion(u); err != nil {
+		if err := checkRequestOp(u); err != nil {
 			return err
 		}
 	}
@@ -165,7 +165,7 @@ func checkTxnRequest(r *pb.TxnRequest) error {
 	}
 
 	for _, u := range r.Failure {
-		if err := checkRequestUnion(u); err != nil {
+		if err := checkRequestOp(u); err != nil {
 			return err
 		}
 	}
@@ -173,11 +173,11 @@ func checkTxnRequest(r *pb.TxnRequest) error {
 }
 
 // checkRequestDupKeys gives rpctypes.ErrGRPCDuplicateKey if the same key is modified twice
-func checkRequestDupKeys(reqs []*pb.RequestUnion) error {
+func checkRequestDupKeys(reqs []*pb.RequestOp) error {
 	// check put overlap
 	keys := make(map[string]struct{})
 	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestUnion_RequestPut)
+		tv, ok := requ.Request.(*pb.RequestOp_RequestPut)
 		if !ok {
 			continue
 		}
@@ -205,7 +205,7 @@ func checkRequestDupKeys(reqs []*pb.RequestUnion) error {
 
 	// check put overlap with deletes
 	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestUnion_RequestDeleteRange)
+		tv, ok := requ.Request.(*pb.RequestOp_RequestDeleteRange)
 		if !ok {
 			continue
 		}
@@ -230,23 +230,23 @@ func checkRequestDupKeys(reqs []*pb.RequestUnion) error {
 	return nil
 }
 
-func checkRequestUnion(u *pb.RequestUnion) error {
+func checkRequestOp(u *pb.RequestOp) error {
 	// TODO: ensure only one of the field is set.
 	switch uv := u.Request.(type) {
-	case *pb.RequestUnion_RequestRange:
+	case *pb.RequestOp_RequestRange:
 		if uv.RequestRange != nil {
 			return checkRangeRequest(uv.RequestRange)
 		}
-	case *pb.RequestUnion_RequestPut:
+	case *pb.RequestOp_RequestPut:
 		if uv.RequestPut != nil {
 			return checkPutRequest(uv.RequestPut)
 		}
-	case *pb.RequestUnion_RequestDeleteRange:
+	case *pb.RequestOp_RequestDeleteRange:
 		if uv.RequestDeleteRange != nil {
 			return checkDeleteRequest(uv.RequestDeleteRange)
 		}
 	default:
-		// empty union
+		// empty op
 		return nil
 	}
 	return nil

etcdserver/apply.go

@@ -269,7 +269,7 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 		}
 	}
 
-	var reqs []*pb.RequestUnion
+	var reqs []*pb.RequestOp
 	if ok {
 		reqs = rt.Success
 	} else {
@@ -295,7 +295,7 @@ func (a *applierV3backend) Txn(rt *pb.TxnRequest) (*pb.TxnResponse, error) {
 		}
 	}()
 
-	resps := make([]*pb.ResponseUnion, len(reqs))
+	resps := make([]*pb.ResponseOp, len(reqs))
 	changedKV := false
 	for i := range reqs {
 		if reqs[i].GetRequestRange() == nil {
@@ -384,31 +384,31 @@ func (a *applierV3backend) applyCompare(c *pb.Compare) (int64, bool) {
 	return rev, true
 }
 
-func (a *applierV3backend) applyUnion(txnID int64, union *pb.RequestUnion) *pb.ResponseUnion {
+func (a *applierV3backend) applyUnion(txnID int64, union *pb.RequestOp) *pb.ResponseOp {
 	switch tv := union.Request.(type) {
-	case *pb.RequestUnion_RequestRange:
+	case *pb.RequestOp_RequestRange:
 		if tv.RequestRange != nil {
 			resp, err := a.Range(txnID, tv.RequestRange)
 			if err != nil {
 				panic("unexpected error during txn")
 			}
-			return &pb.ResponseUnion{Response: &pb.ResponseUnion_ResponseRange{ResponseRange: resp}}
+			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponseRange{ResponseRange: resp}}
 		}
-	case *pb.RequestUnion_RequestPut:
+	case *pb.RequestOp_RequestPut:
 		if tv.RequestPut != nil {
 			resp, err := a.Put(txnID, tv.RequestPut)
 			if err != nil {
 				panic("unexpected error during txn")
 			}
-			return &pb.ResponseUnion{Response: &pb.ResponseUnion_ResponsePut{ResponsePut: resp}}
+			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponsePut{ResponsePut: resp}}
 		}
-	case *pb.RequestUnion_RequestDeleteRange:
+	case *pb.RequestOp_RequestDeleteRange:
 		if tv.RequestDeleteRange != nil {
 			resp, err := a.DeleteRange(txnID, tv.RequestDeleteRange)
 			if err != nil {
 				panic("unexpected error during txn")
 			}
-			return &pb.ResponseUnion{Response: &pb.ResponseUnion_ResponseDeleteRange{ResponseDeleteRange: resp}}
+			return &pb.ResponseOp{Response: &pb.ResponseOp_ResponseDeleteRange{ResponseDeleteRange: resp}}
 		}
 	default:
 		// empty union
@@ -653,9 +653,9 @@ func (s *kvSortByValue) Less(i, j int) bool {
 	return bytes.Compare(s.kvs[i].Value, s.kvs[j].Value) < 0
 }
 
-func (a *applierV3backend) checkRequestLeases(reqs []*pb.RequestUnion) error {
+func (a *applierV3backend) checkRequestLeases(reqs []*pb.RequestOp) error {
 	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestUnion_RequestPut)
+		tv, ok := requ.Request.(*pb.RequestOp_RequestPut)
 		if !ok {
 			continue
 		}
@@ -670,9 +670,9 @@ func (a *applierV3backend) checkRequestLeases(reqs []*pb.RequestUnion) error {
 	return nil
 }
 
-func (a *applierV3backend) checkRequestRange(reqs []*pb.RequestUnion) error {
+func (a *applierV3backend) checkRequestRange(reqs []*pb.RequestOp) error {
 	for _, requ := range reqs {
-		tv, ok := requ.Request.(*pb.RequestUnion_RequestRange)
+		tv, ok := requ.Request.(*pb.RequestOp_RequestRange)
 		if !ok {
 			continue
 		}

etcdserver/etcdserverpb/etcdserver.pb.go

@@ -23,8 +23,8 @@
 		PutResponse
 		DeleteRangeRequest
 		DeleteRangeResponse
-		RequestUnion
-		ResponseUnion
+		RequestOp
+		ResponseOp
 		Compare
 		TxnRequest
 		TxnResponse
@@ -1006,30 +1006,30 @@ var (
 )
 
 var fileDescriptorEtcdserver = []byte{
-	// 388 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x92, 0xd1, 0xee, 0xd2, 0x30,
-	0x14, 0xc6, 0xff, 0xdb, 0xca, 0x60, 0x15, 0x15, 0x1b, 0x62, 0x4e, 0x88, 0x41, 0x43, 0xbc, 0xf0,
-	0x4a, 0xdf, 0x01, 0xe1, 0x82, 0x44, 0x0d, 0x82, 0xd1, 0xeb, 0xba, 0x1d, 0xa1, 0x09, 0x5b, 0x47,
-	0xdb, 0x4d, 0xde, 0xc0, 0x57, 0xe3, 0xd2, 0x27, 0x30, 0xea, 0x93, 0xd8, 0x16, 0x86, 0xd5, 0x8b,
-	0x26, 0xcb, 0xef, 0xfb, 0xce, 0xe9, 0xd7, 0x73, 0x46, 0x47, 0x68, 0xf2, 0x42, 0xa3, 0x6a, 0x51,
-	0xbd, 0xac, 0x95, 0x34, 0x92, 0x0d, 0xff, 0x92, 0xfa, 0xf3, 0x64, 0xbc, 0x93, 0x3b, 0xe9, 0x85,
-	0x57, 0xee, 0xeb, 0xe2, 0x99, 0x7d, 0x23, 0xb4, 0xbf, 0xc1, 0x63, 0x83, 0xda, 0xb0, 0x31, 0x8d,
-	0x57, 0x0b, 0x88, 0x9e, 0x45, 0x2f, 0xc8, 0x9c, 0x9c, 0x7f, 0x3c, 0xbd, 0xdb, 0xc4, 0x62, 0xc1,
-	0x9e, 0xd0, 0xf4, 0x2d, 0x9a, 0xbd, 0x2c, 0x20, 0xb6, 0x4a, 0x76, 0x55, 0xd2, 0xd2, 0x33, 0x06,
-	0x94, 0xac, 0xb9, 0xd9, 0x43, 0x12, 0x68, 0xa4, 0xb6, 0x84, 0x3d, 0xa6, 0xc9, 0x47, 0x7e, 0x00,
-	0x12, 0x08, 0x49, 0xcb, 0x0f, 0x8e, 0x2f, 0x84, 0x82, 0x9e, 0xe5, 0x83, 0x8e, 0x17, 0x42, 0xb1,
-	0x19, 0xcd, 0xd6, 0x0a, 0x5b, 0x5b, 0xd3, 0x20, 0xa4, 0x41, 0x55, 0x56, 0x77, 0xb8, 0xf3, 0xac,
-	0xaa, 0x02, 0x4f, 0xd0, 0x0f, 0x82, 0x7a, 0x8f, 0xc7, 0x9d, 0x67, 0x79, 0x12, 0xda, 0xc0, 0xe0,
-	0x76, 0x4b, 0x74, 0xf1, 0x78, 0xcc, 0x9e, 0x53, 0xba, 0x3c, 0xd5, 0x42, 0x71, 0x23, 0x64, 0x05,
-	0x99, 0x35, 0x25, 0xd7, 0x46, 0x14, 0x6f, 0xdc, 0xbd, 0xed, 0x13, 0x17, 0x06, 0x68, 0x10, 0x95,
-	0x7c, 0xb5, 0x84, 0x4d, 0x68, 0x6f, 0x2b, 0xaa, 0x1c, 0xe1, 0x5e, 0x90, 0xa1, 0xa7, 0x1d, 0x72,
-	0xf7, 0x6f, 0x30, 0x6f, 0x94, 0x16, 0x2d, 0xc2, 0x30, 0x28, 0xcd, 0x54, 0x87, 0xdd, 0x4c, 0xb7,
-	0x52, 0x19, 0x2c, 0xe0, 0x7e, 0x60, 0x48, 0xb5, 0x67, 0x4e, 0x7d, 0xdf, 0x48, 0xd5, 0x94, 0xf0,
-	0x20, 0x54, 0x8f, 0x9e, 0xb9, 0x54, 0x1f, 0x44, 0x89, 0xf0, 0x30, 0x48, 0x4d, 0x8c, 0x25, 0xbe,
-	0xab, 0x51, 0xc8, 0x4b, 0x18, 0xfd, 0xd3, 0xd5, 0x33, 0x36, 0x75, 0x8b, 0xfe, 0xa2, 0x50, 0xef,
-	0xe1, 0x51, 0x30, 0x95, 0xbe, 0xba, 0xc0, 0xd9, 0x1b, 0x3a, 0xb0, 0x7b, 0xe6, 0x05, 0x37, 0xdc,
-	0x75, 0x7a, 0x27, 0x0b, 0xfc, 0xef, 0x6f, 0x48, 0x2b, 0xcf, 0xdc, 0x0b, 0x5f, 0x1f, 0x1a, 0x6d,
-	0x50, 0x59, 0x43, 0x1c, 0x6e, 0x21, 0xef, 0xf0, 0x7c, 0x74, 0xfe, 0x35, 0xbd, 0x3b, 0xff, 0x9e,
-	0x46, 0xdf, 0xed, 0xf9, 0x69, 0xcf, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x8e, 0x1a, 0x0d,
-	0xa0, 0x02, 0x00, 0x00,
+	// 398 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x5c, 0x92, 0xd1, 0x6e, 0xd3, 0x30,
+	0x14, 0x86, 0xe7, 0xd6, 0x4d, 0x1b, 0x33, 0xa0, 0x58, 0x13, 0x3a, 0x9a, 0x50, 0xa8, 0x2a, 0x2e,
+	0x7a, 0x05, 0xef, 0x30, 0xba, 0x8b, 0x4a, 0x0c, 0x8d, 0x0e, 0x8d, 0x6b, 0xd3, 0x1c, 0x56, 0x4b,
+	0x49, 0x9c, 0xd9, 0x27, 0xa1, 0x6f, 0xc0, 0xab, 0xf5, 0x92, 0x27, 0x40, 0xd0, 0x27, 0x41, 0x76,
+	0x96, 0x62, 0x76, 0x67, 0x7d, 0xff, 0xef, 0xdf, 0xbf, 0xed, 0x23, 0xa6, 0x48, 0x9b, 0xdc, 0xa1,
+	0x6d, 0xd1, 0xbe, 0xad, 0xad, 0x21, 0x23, 0x4f, 0xff, 0x91, 0xfa, 0xeb, 0xf9, 0xd9, 0x9d, 0xb9,
+	0x33, 0x41, 0x78, 0xe7, 0x57, 0x9d, 0x67, 0xfe, 0x83, 0x8b, 0xf1, 0x1a, 0xef, 0x1b, 0x74, 0x24,
+	0xcf, 0xc4, 0x60, 0xb5, 0x04, 0x36, 0x63, 0x0b, 0x7e, 0xc1, 0xf7, 0xbf, 0x5e, 0x9f, 0xac, 0x07,
+	0x7a, 0x29, 0x5f, 0x89, 0xe4, 0x0a, 0x69, 0x6b, 0x72, 0x18, 0xcc, 0xd8, 0x22, 0x7d, 0x50, 0x92,
+	0x32, 0x30, 0x09, 0x82, 0x5f, 0x2b, 0xda, 0xc2, 0x30, 0xd2, 0x78, 0xad, 0x68, 0x2b, 0x5f, 0x8a,
+	0xe1, 0xad, 0x2a, 0x80, 0x47, 0xc2, 0xb0, 0x55, 0x85, 0xe7, 0x4b, 0x6d, 0x61, 0x34, 0x63, 0x8b,
+	0x49, 0xcf, 0x73, 0x6d, 0xe5, 0x5c, 0xa4, 0xd7, 0x16, 0xdb, 0x5b, 0x55, 0x34, 0x08, 0x49, 0xb4,
+	0x2b, 0xad, 0x7b, 0xdc, 0x7b, 0x56, 0x55, 0x8e, 0x3b, 0x18, 0x47, 0x45, 0x83, 0x27, 0xe0, 0xde,
+	0x73, 0xb9, 0xd3, 0x8e, 0x60, 0x72, 0x3c, 0x85, 0x75, 0x9e, 0x80, 0xe5, 0x1b, 0x21, 0x2e, 0x77,
+	0xb5, 0xb6, 0x8a, 0xb4, 0xa9, 0x20, 0x9d, 0xb1, 0xc5, 0xf0, 0x21, 0x48, 0xe0, 0x91, 0xfb, 0xbb,
+	0x7d, 0x51, 0x9a, 0x40, 0x44, 0x55, 0xf9, 0x77, 0xa5, 0x49, 0x9e, 0x8b, 0xd1, 0x8d, 0xae, 0x36,
+	0x08, 0x4f, 0xa2, 0x0e, 0x23, 0xe7, 0x91, 0x3f, 0x7f, 0x8d, 0x9b, 0xc6, 0x3a, 0xdd, 0x22, 0x9c,
+	0x46, 0x5b, 0x53, 0xdb, 0x63, 0xff, 0xa6, 0x37, 0xc6, 0x12, 0xe6, 0xf0, 0x34, 0x32, 0x24, 0x2e,
+	0x30, 0xaf, 0x7e, 0x6a, 0x8c, 0x6d, 0x4a, 0x78, 0x16, 0xab, 0xf7, 0x81, 0xf9, 0x56, 0x9f, 0x75,
+	0x89, 0xf0, 0x3c, 0x6a, 0xcd, 0x49, 0x97, 0x5d, 0x2a, 0x59, 0x54, 0x25, 0x4c, 0xff, 0x4b, 0x0d,
+	0x4c, 0x66, 0xfe, 0xa3, 0xbf, 0x59, 0x74, 0x5b, 0x78, 0x11, 0xbd, 0xca, 0xd8, 0x76, 0x70, 0xfe,
+	0x41, 0x4c, 0xae, 0x90, 0x54, 0xae, 0x48, 0xf9, 0xa4, 0x8f, 0x26, 0xc7, 0x47, 0xd3, 0x90, 0x54,
+	0x81, 0xf9, 0x1b, 0xbe, 0x2f, 0x1a, 0x47, 0x68, 0x57, 0xcb, 0x30, 0x14, 0xc7, 0x5f, 0xd8, 0xf4,
+	0xf8, 0x62, 0xba, 0xff, 0x93, 0x9d, 0xec, 0x0f, 0x19, 0xfb, 0x79, 0xc8, 0xd8, 0xef, 0x43, 0xc6,
+	0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0xfb, 0x8e, 0x1a, 0x0d, 0xa0, 0x02, 0x00, 0x00,
 }

etcdserver/etcdserverpb/raft_internal.pb.go

@@ -1697,51 +1697,51 @@ var (
 )
 
 var fileDescriptorRaftInternal = []byte{
-	// 722 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x95, 0xcb, 0x6e, 0xd3, 0x4c,
-	0x14, 0xc7, 0xbf, 0xa6, 0xd7, 0x4c, 0x9a, 0x7e, 0x65, 0xda, 0xc2, 0x90, 0x4a, 0xa5, 0x14, 0x71,
-	0x11, 0x97, 0x82, 0xda, 0x25, 0x0b, 0x08, 0x4d, 0x29, 0x95, 0x10, 0xaa, 0x2c, 0x90, 0x90, 0x58,
-	0x58, 0xd3, 0xf8, 0x90, 0x06, 0x1c, 0xdb, 0x8c, 0x27, 0xa1, 0xbc, 0x15, 0xb7, 0x87, 0xe8, 0x82,
-	0x4b, 0xe1, 0x09, 0x80, 0x15, 0x7b, 0x78, 0x00, 0x3c, 0x17, 0x8f, 0xed, 0x64, 0xdc, 0x85, 0x25,
-	0xfb, 0x9c, 0xff, 0xf9, 0x9d, 0x33, 0xf3, 0x9f, 0x49, 0xd0, 0x02, 0xa3, 0xcf, 0xb9, 0xdb, 0x0d,
-	0x38, 0xb0, 0x80, 0xfa, 0xeb, 0x11, 0x0b, 0x79, 0x88, 0x67, 0x81, 0xb7, 0xbd, 0x18, 0xd8, 0x00,
-	0x58, 0xb4, 0xdf, 0x58, 0xec, 0x84, 0x9d, 0x50, 0x26, 0x6e, 0x8a, 0x37, 0xa5, 0x69, 0xcc, 0x67,
-	0x1a, 0x1d, 0xa9, 0xb2, 0xa8, 0xad, 0x5e, 0xd7, 0x6e, 0xa3, 0xba, 0x03, 0xaf, 0xfa, 0x10, 0xf3,
-	0x07, 0x40, 0x3d, 0x60, 0x78, 0x0e, 0x55, 0x76, 0x5b, 0x64, 0x6c, 0x75, 0xec, 0xca, 0x84, 0x53,
-	0xe9, 0xb6, 0x70, 0x03, 0xcd, 0xf4, 0x63, 0xd1, 0xb2, 0x07, 0xa4, 0x92, 0x44, 0xab, 0x8e, 0xf9,
-	0x5e, 0xfb, 0x5e, 0x47, 0x0b, 0xbb, 0x7a, 0x20, 0x27, 0x99, 0x4e, 0x93, 0x46, 0x18, 0x17, 0x51,
-	0x65, 0xb0, 0x21, 0xab, 0x6b, 0x1b, 0x4b, 0xeb, 0xf9, 0x91, 0xd7, 0x75, 0x89, 0x93, 0x08, 0xf0,
-	0x2d, 0x34, 0xc9, 0x68, 0xd0, 0x01, 0x32, 0x2e, 0x95, 0x8d, 0x21, 0xa5, 0x48, 0xa5, 0x72, 0x25,
-	0xc4, 0x57, 0xd1, 0x78, 0xd4, 0xe7, 0x64, 0x42, 0xea, 0x49, 0x51, 0xbf, 0xd7, 0x4f, 0xe7, 0x71,
-	0x84, 0x08, 0x6f, 0xa1, 0x59, 0x0f, 0x7c, 0xe0, 0xe0, 0xaa, 0x26, 0x93, 0xb2, 0x68, 0xb5, 0x58,
-	0xd4, 0x92, 0x8a, 0x42, 0xab, 0x9a, 0x97, 0xc5, 0x44, 0x43, 0x7e, 0x18, 0x90, 0x29, 0x5b, 0xc3,
-	0xc7, 0x87, 0x81, 0x69, 0x98, 0x88, 0xf0, 0x1d, 0x84, 0xda, 0x61, 0x2f, 0xa2, 0x6d, 0xde, 0x0d,
-	0x03, 0x32, 0x2d, 0x4b, 0xce, 0x15, 0x4b, 0xb6, 0x4c, 0x3e, 0xad, 0xcc, 0x95, 0xe0, 0xbb, 0xa8,
-	0xe6, 0x03, 0x8d, 0xc1, 0xed, 0x24, 0x13, 0x73, 0x32, 0x63, 0x23, 0x3c, 0x14, 0x82, 0x1d, 0x91,
-	0x37, 0x04, 0xdf, 0x84, 0xc4, 0x9a, 0x15, 0x81, 0xc1, 0x20, 0x7c, 0x09, 0xa4, 0x6a, 0x5b, 0xb3,
-	0x44, 0x38, 0x52, 0x60, 0xd6, 0xec, 0x67, 0x31, 0x61, 0x0b, 0xf5, 0x29, 0xeb, 0x11, 0x64, 0xb3,
-	0xa5, 0x29, 0x52, 0xc6, 0x16, 0x29, 0xc4, 0x9b, 0x68, 0xea, 0x40, 0x9e, 0x26, 0xe2, 0xc9, 0x92,
-	0x65, 0xab, 0xe7, 0xea, 0xc0, 0x39, 0x5a, 0x8a, 0x9b, 0xa8, 0x46, 0xfb, 0xfc, 0xc0, 0x85, 0x80,
-	0xee, 0xfb, 0x40, 0x7e, 0x5b, 0x37, 0xac, 0x99, 0x28, 0xb6, 0xa5, 0xc0, 0x2c, 0x97, 0x9a, 0x10,
-	0x6e, 0xa1, 0x59, 0x89, 0xf0, 0xba, 0xb1, 0x64, 0xfc, 0x99, 0xb6, 0xad, 0x57, 0x30, 0x5a, 0x4a,
-	0x61, 0xd6, 0x4b, 0xb3, 0x18, 0xbe, 0xaf, 0x28, 0x10, 0xf0, 0x6e, 0x9b, 0x72, 0x20, 0x7f, 0x15,
-	0xe5, 0xfc, 0x28, 0x25, 0x95, 0xa4, 0x98, 0x42, 0x1d, 0xde, 0x46, 0x75, 0x39, 0x8d, 0xb8, 0x2e,
-	0x2e, 0xf5, 0x3c, 0xf2, 0x69, 0xa6, 0x6c, 0x9c, 0x27, 0xc9, 0x57, 0xd3, 0xf3, 0x0a, 0xe3, 0xe8,
-	0x18, 0x7e, 0x84, 0xe6, 0x33, 0x8c, 0x3a, 0x8b, 0xe4, 0xb3, 0x22, 0x5d, 0xb0, 0x93, 0xf4, 0x21,
-	0xd6, 0xb0, 0x39, 0x5a, 0x08, 0x17, 0xc7, 0xea, 0x00, 0x27, 0x5f, 0x4e, 0x1c, 0x6b, 0x07, 0xf8,
-	0xc8, 0x58, 0x49, 0x0c, 0x77, 0xd0, 0xd9, 0x0c, 0xd3, 0x3e, 0x10, 0xb7, 0xc3, 0x8d, 0x68, 0x1c,
-	0xbf, 0x0e, 0x99, 0x47, 0xbe, 0x2a, 0xe4, 0x35, 0x3b, 0x72, 0x4b, 0xaa, 0xf7, 0xb4, 0x38, 0xa5,
-	0x9f, 0xa6, 0xd6, 0x34, 0x7e, 0x8a, 0x16, 0x73, 0xf3, 0x8a, 0x63, 0xed, 0xb2, 0x30, 0x31, 0xf7,
-	0x58, 0xf5, 0xb8, 0x54, 0x32, 0xb6, 0xbc, 0x12, 0x61, 0x66, 0xf1, 0x29, 0x3a, 0x9c, 0xc1, 0xcf,
-	0xd0, 0x52, 0x46, 0x56, 0x37, 0x44, 0xa1, 0xbf, 0x29, 0xf4, 0x65, 0x3b, 0x5a, 0x5f, 0x95, 0x1c,
-	0x1b, 0xd3, 0x91, 0x94, 0xd9, 0x66, 0x01, 0x94, 0xee, 0xbf, 0xad, 0x96, 0x6d, 0xb3, 0xd0, 0x0f,
-	0xbb, 0xaf, 0x63, 0xc6, 0x7d, 0x89, 0xd1, 0xee, 0xbf, 0xab, 0x96, 0xb9, 0x2f, 0xaa, 0x2c, 0xee,
-	0x67, 0xe1, 0xe2, 0x58, 0xc2, 0xfd, 0xf7, 0x27, 0x8e, 0x35, 0xec, 0xbe, 0x8e, 0xe1, 0x17, 0xa8,
-	0x91, 0xc3, 0x48, 0x53, 0x22, 0x60, 0xbd, 0x6e, 0x1c, 0x8b, 0xdf, 0xba, 0x0f, 0x8a, 0x79, 0xbd,
-	0x84, 0x29, 0xe4, 0x7b, 0x46, 0x9d, 0xf2, 0xcf, 0x50, 0x7b, 0x1e, 0xf7, 0xd0, 0x72, 0xd6, 0x4b,
-	0xdb, 0x94, 0x6b, 0xf6, 0x51, 0x35, 0xbb, 0x61, 0x6f, 0xa6, 0x1c, 0x19, 0xed, 0x46, 0x68, 0x89,
-	0x60, 0xed, 0x7f, 0x54, 0xdf, 0xee, 0x45, 0xfc, 0x8d, 0x03, 0x71, 0x14, 0x06, 0x31, 0xdc, 0x9b,
-	0x3f, 0xfa, 0xb9, 0xf2, 0xdf, 0xd1, 0xaf, 0x95, 0xb1, 0xe3, 0xe4, 0xf9, 0x91, 0x3c, 0xfb, 0x53,
-	0xf2, 0xbf, 0x73, 0xf3, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0x8d, 0xf6, 0xc5, 0x93, 0x07,
-	0x00, 0x00,
+	// 725 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x7c, 0x95, 0x5b, 0x4f, 0x13, 0x41,
+	0x14, 0xc7, 0x6d, 0xb9, 0x76, 0x4a, 0x11, 0x07, 0xd0, 0xb1, 0x24, 0x15, 0x31, 0x2a, 0xf1, 0x82,
+	0x06, 0x1e, 0x7d, 0xd0, 0x4a, 0x11, 0x49, 0x8c, 0x21, 0x1b, 0x4d, 0x4c, 0x7c, 0xd8, 0x0c, 0xdd,
+	0x43, 0x5b, 0xdd, 0xee, 0xae, 0xb3, 0xd3, 0x8a, 0xdf, 0xca, 0xdb, 0x87, 0xe0, 0xc1, 0x0b, 0xfa,
+	0x09, 0xb4, 0x4f, 0xbe, 0xeb, 0x07, 0x30, 0x73, 0xd9, 0xd9, 0x6e, 0x3b, 0xcb, 0xdb, 0x72, 0xce,
+	0xff, 0xfc, 0xce, 0x39, 0xf3, 0x9f, 0xa1, 0x68, 0x91, 0xd1, 0x43, 0xee, 0x76, 0x02, 0x0e, 0x2c,
+	0xa0, 0xfe, 0x46, 0xc4, 0x42, 0x1e, 0xe2, 0x39, 0xe0, 0x4d, 0x2f, 0x06, 0xd6, 0x07, 0x16, 0x1d,
+	0x54, 0x97, 0x5a, 0x61, 0x2b, 0x94, 0x89, 0x3b, 0xe2, 0x4b, 0x69, 0xaa, 0x0b, 0xa9, 0x46, 0x47,
+	0x4a, 0x2c, 0x6a, 0xaa, 0xcf, 0xb5, 0x7b, 0xa8, 0xe2, 0xc0, 0x9b, 0x1e, 0xc4, 0xfc, 0x31, 0x50,
+	0x0f, 0x18, 0x9e, 0x47, 0xc5, 0xbd, 0x06, 0x29, 0xac, 0x16, 0xd6, 0x27, 0x9d, 0x62, 0xa7, 0x81,
+	0xab, 0x68, 0xb6, 0x17, 0x8b, 0x96, 0x5d, 0x20, 0xc5, 0xd5, 0xc2, 0x7a, 0xc9, 0x31, 0x7f, 0xaf,
+	0xfd, 0xac, 0xa0, 0xc5, 0x3d, 0x3d, 0x90, 0x43, 0x0f, 0xb9, 0x26, 0x8d, 0x31, 0xae, 0xa2, 0x62,
+	0x7f, 0x53, 0x56, 0x97, 0x37, 0x97, 0x37, 0x86, 0x47, 0xde, 0xd0, 0x25, 0x4e, 0xb1, 0xbf, 0x89,
+	0xef, 0xa2, 0x29, 0x46, 0x83, 0x16, 0x90, 0x09, 0xa9, 0xac, 0x8e, 0x28, 0x45, 0x2a, 0x91, 0x2b,
+	0x21, 0xbe, 0x81, 0x26, 0xa2, 0x1e, 0x27, 0x93, 0x52, 0x4f, 0xb2, 0xfa, 0xfd, 0x5e, 0x32, 0x8f,
+	0x23, 0x44, 0x78, 0x1b, 0xcd, 0x79, 0xe0, 0x03, 0x07, 0x57, 0x35, 0x99, 0x92, 0x45, 0xab, 0xd9,
+	0xa2, 0x86, 0x54, 0x64, 0x5a, 0x95, 0xbd, 0x34, 0x26, 0x1a, 0xf2, 0xa3, 0x80, 0x4c, 0xdb, 0x1a,
+	0x3e, 0x3b, 0x0a, 0x4c, 0x43, 0x7e, 0x14, 0xe0, 0xfb, 0x08, 0x35, 0xc3, 0x6e, 0x44, 0x9b, 0xbc,
+	0x13, 0x06, 0x64, 0x46, 0x96, 0x5c, 0xca, 0x96, 0x6c, 0x9b, 0x7c, 0x52, 0x39, 0x54, 0x82, 0x1f,
+	0xa0, 0xb2, 0x0f, 0x34, 0x06, 0xb7, 0xc5, 0x68, 0xc0, 0xc9, 0xac, 0x8d, 0xf0, 0x44, 0x08, 0x76,
+	0x45, 0xde, 0x10, 0x7c, 0x13, 0x12, 0x3b, 0x2b, 0x02, 0x83, 0x7e, 0xf8, 0x1a, 0x48, 0xc9, 0xb6,
+	0xb3, 0x44, 0x38, 0x52, 0x60, 0x76, 0xf6, 0xd3, 0x98, 0xb0, 0x85, 0xfa, 0x94, 0x75, 0x09, 0xb2,
+	0xd9, 0x52, 0x17, 0x29, 0x63, 0x8b, 0x14, 0xe2, 0x2d, 0x34, 0xdd, 0x96, 0xb7, 0x89, 0x78, 0xb2,
+	0x64, 0xc5, 0xea, 0xb9, 0xba, 0x70, 0x8e, 0x96, 0xe2, 0x3a, 0x2a, 0xd3, 0x1e, 0x6f, 0xbb, 0x10,
+	0xd0, 0x03, 0x1f, 0xc8, 0x1f, 0xeb, 0x81, 0xd5, 0x7b, 0xbc, 0xbd, 0x23, 0x05, 0x66, 0x5d, 0x6a,
+	0x42, 0xb8, 0x81, 0xe6, 0x24, 0xc2, 0xeb, 0xc4, 0x92, 0xf1, 0x77, 0xc6, 0xb6, 0xaf, 0x60, 0x34,
+	0x94, 0xc2, 0xec, 0x4b, 0xd3, 0x18, 0x7e, 0xa4, 0x28, 0x10, 0xf0, 0x4e, 0x93, 0x72, 0x20, 0xff,
+	0x14, 0xe5, 0xf2, 0x38, 0x25, 0x91, 0x24, 0x98, 0x4c, 0x1d, 0xde, 0x41, 0x15, 0x39, 0x8d, 0x78,
+	0x2e, 0x2e, 0xf5, 0x3c, 0xf2, 0x65, 0x36, 0x6f, 0x9c, 0xe7, 0x31, 0xb0, 0xba, 0xe7, 0x65, 0xc6,
+	0xd1, 0x31, 0xfc, 0x14, 0x2d, 0xa4, 0x18, 0x75, 0x17, 0xc9, 0x57, 0x45, 0xba, 0x62, 0x27, 0xe9,
+	0x4b, 0xac, 0x61, 0xf3, 0x34, 0x13, 0xce, 0x8e, 0xd5, 0x02, 0x4e, 0xbe, 0x9d, 0x3a, 0xd6, 0x2e,
+	0xf0, 0xb1, 0xb1, 0x76, 0x81, 0xe3, 0x16, 0xba, 0x98, 0x62, 0x9a, 0x6d, 0xf1, 0x3a, 0xdc, 0x88,
+	0xc6, 0xf1, 0xdb, 0x90, 0x79, 0xe4, 0xbb, 0x42, 0xde, 0xb4, 0x23, 0xb7, 0xa5, 0x7a, 0x5f, 0x8b,
+	0x13, 0xfa, 0x79, 0x6a, 0x4d, 0xe3, 0x17, 0x68, 0x69, 0x68, 0x5e, 0x71, 0xad, 0x5d, 0x16, 0xfa,
+	0x40, 0x4e, 0x54, 0x8f, 0x6b, 0x39, 0x63, 0xcb, 0x27, 0x11, 0xa6, 0x16, 0x9f, 0xa3, 0xa3, 0x19,
+	0xfc, 0x12, 0x2d, 0xa7, 0x64, 0xf5, 0x42, 0x14, 0xfa, 0x87, 0x42, 0x5f, 0xb7, 0xa3, 0xf5, 0x53,
+	0x19, 0x62, 0x63, 0x3a, 0x96, 0x32, 0xc7, 0x2c, 0x80, 0xd2, 0xfd, 0xf7, 0xa5, 0xbc, 0x63, 0x16,
+	0xfa, 0x51, 0xf7, 0x75, 0xcc, 0xb8, 0x2f, 0x31, 0xda, 0xfd, 0x0f, 0xa5, 0x3c, 0xf7, 0x45, 0x95,
+	0xc5, 0xfd, 0x34, 0x9c, 0x1d, 0x4b, 0xb8, 0xff, 0xf1, 0xd4, 0xb1, 0x46, 0xdd, 0xd7, 0x31, 0xfc,
+	0x0a, 0x55, 0x87, 0x30, 0xd2, 0x94, 0x08, 0x58, 0xb7, 0x13, 0xc7, 0xe2, 0x7f, 0xdd, 0x27, 0xc5,
+	0xbc, 0x95, 0xc3, 0x14, 0xf2, 0x7d, 0xa3, 0x4e, 0xf8, 0x17, 0xa8, 0x3d, 0x8f, 0xbb, 0x68, 0x25,
+	0xed, 0xa5, 0x6d, 0x1a, 0x6a, 0xf6, 0x59, 0x35, 0xbb, 0x6d, 0x6f, 0xa6, 0x1c, 0x19, 0xef, 0x46,
+	0x68, 0x8e, 0x60, 0xed, 0x2c, 0xaa, 0xec, 0x74, 0x23, 0xfe, 0xce, 0x81, 0x38, 0x0a, 0x83, 0x18,
+	0x1e, 0x2e, 0x1c, 0xff, 0xae, 0x9d, 0x39, 0x1e, 0xd4, 0x0a, 0x27, 0x83, 0x5a, 0xe1, 0xd7, 0xa0,
+	0x56, 0x38, 0x98, 0x96, 0xbf, 0x9d, 0x5b, 0xff, 0x03, 0x00, 0x00, 0xff, 0xff, 0xac, 0x8d, 0xf6,
+	0xc5, 0x93, 0x07, 0x00, 0x00,
 }

etcdserver/etcdserverpb/rpc.pb.go

@@ -319,106 +319,106 @@ func (m *DeleteRangeResponse) GetHeader() *ResponseHeader {
 	return nil
 }
 
-type RequestUnion struct {
+type RequestOp struct {
 	// request is a union of request types accepted by a transaction.
 	//
 	// Types that are valid to be assigned to Request:
-	//	*RequestUnion_RequestRange
-	//	*RequestUnion_RequestPut
-	//	*RequestUnion_RequestDeleteRange
-	Request isRequestUnion_Request `protobuf_oneof:"request"`
+	//	*RequestOp_RequestRange
+	//	*RequestOp_RequestPut
+	//	*RequestOp_RequestDeleteRange
+	Request isRequestOp_Request `protobuf_oneof:"request"`
 }
 
-func (m *RequestUnion) Reset()                    { *m = RequestUnion{} }
-func (m *RequestUnion) String() string            { return proto.CompactTextString(m) }
-func (*RequestUnion) ProtoMessage()               {}
-func (*RequestUnion) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{7} }
+func (m *RequestOp) Reset()                    { *m = RequestOp{} }
+func (m *RequestOp) String() string            { return proto.CompactTextString(m) }
+func (*RequestOp) ProtoMessage()               {}
+func (*RequestOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{7} }
 
-type isRequestUnion_Request interface {
-	isRequestUnion_Request()
+type isRequestOp_Request interface {
+	isRequestOp_Request()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
 
-type RequestUnion_RequestRange struct {
+type RequestOp_RequestRange struct {
 	RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,json=requestRange,oneof"`
 }
-type RequestUnion_RequestPut struct {
+type RequestOp_RequestPut struct {
 	RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,json=requestPut,oneof"`
 }
-type RequestUnion_RequestDeleteRange struct {
+type RequestOp_RequestDeleteRange struct {
 	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,oneof"`
 }
 
-func (*RequestUnion_RequestRange) isRequestUnion_Request()       {}
-func (*RequestUnion_RequestPut) isRequestUnion_Request()         {}
-func (*RequestUnion_RequestDeleteRange) isRequestUnion_Request() {}
+func (*RequestOp_RequestRange) isRequestOp_Request()       {}
+func (*RequestOp_RequestPut) isRequestOp_Request()         {}
+func (*RequestOp_RequestDeleteRange) isRequestOp_Request() {}
 
-func (m *RequestUnion) GetRequest() isRequestUnion_Request {
+func (m *RequestOp) GetRequest() isRequestOp_Request {
 	if m != nil {
 		return m.Request
 	}
 	return nil
 }
 
-func (m *RequestUnion) GetRequestRange() *RangeRequest {
-	if x, ok := m.GetRequest().(*RequestUnion_RequestRange); ok {
+func (m *RequestOp) GetRequestRange() *RangeRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestRange); ok {
 		return x.RequestRange
 	}
 	return nil
 }
 
-func (m *RequestUnion) GetRequestPut() *PutRequest {
-	if x, ok := m.GetRequest().(*RequestUnion_RequestPut); ok {
+func (m *RequestOp) GetRequestPut() *PutRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestPut); ok {
 		return x.RequestPut
 	}
 	return nil
 }
 
-func (m *RequestUnion) GetRequestDeleteRange() *DeleteRangeRequest {
-	if x, ok := m.GetRequest().(*RequestUnion_RequestDeleteRange); ok {
+func (m *RequestOp) GetRequestDeleteRange() *DeleteRangeRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestDeleteRange); ok {
 		return x.RequestDeleteRange
 	}
 	return nil
 }
 
 // XXX_OneofFuncs is for the internal use of the proto package.
-func (*RequestUnion) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _RequestUnion_OneofMarshaler, _RequestUnion_OneofUnmarshaler, _RequestUnion_OneofSizer, []interface{}{
-		(*RequestUnion_RequestRange)(nil),
-		(*RequestUnion_RequestPut)(nil),
-		(*RequestUnion_RequestDeleteRange)(nil),
+func (*RequestOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _RequestOp_OneofMarshaler, _RequestOp_OneofUnmarshaler, _RequestOp_OneofSizer, []interface{}{
+		(*RequestOp_RequestRange)(nil),
+		(*RequestOp_RequestPut)(nil),
+		(*RequestOp_RequestDeleteRange)(nil),
 	}
 }
 
-func _RequestUnion_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*RequestUnion)
+func _RequestOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*RequestOp)
 	// request
 	switch x := m.Request.(type) {
-	case *RequestUnion_RequestRange:
+	case *RequestOp_RequestRange:
 		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.RequestRange); err != nil {
 			return err
 		}
-	case *RequestUnion_RequestPut:
+	case *RequestOp_RequestPut:
 		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.RequestPut); err != nil {
 			return err
 		}
-	case *RequestUnion_RequestDeleteRange:
+	case *RequestOp_RequestDeleteRange:
 		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.RequestDeleteRange); err != nil {
 			return err
 		}
 	case nil:
 	default:
-		return fmt.Errorf("RequestUnion.Request has unexpected type %T", x)
+		return fmt.Errorf("RequestOp.Request has unexpected type %T", x)
 	}
 	return nil
 }
 
-func _RequestUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*RequestUnion)
+func _RequestOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*RequestOp)
 	switch tag {
 	case 1: // request.request_range
 		if wire != proto.WireBytes {
@@ -426,7 +426,7 @@ func _RequestUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.B
 		}
 		msg := new(RangeRequest)
 		err := b.DecodeMessage(msg)
-		m.Request = &RequestUnion_RequestRange{msg}
+		m.Request = &RequestOp_RequestRange{msg}
 		return true, err
 	case 2: // request.request_put
 		if wire != proto.WireBytes {
@@ -434,7 +434,7 @@ func _RequestUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.B
 		}
 		msg := new(PutRequest)
 		err := b.DecodeMessage(msg)
-		m.Request = &RequestUnion_RequestPut{msg}
+		m.Request = &RequestOp_RequestPut{msg}
 		return true, err
 	case 3: // request.request_delete_range
 		if wire != proto.WireBytes {
@@ -442,28 +442,28 @@ func _RequestUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.B
 		}
 		msg := new(DeleteRangeRequest)
 		err := b.DecodeMessage(msg)
-		m.Request = &RequestUnion_RequestDeleteRange{msg}
+		m.Request = &RequestOp_RequestDeleteRange{msg}
 		return true, err
 	default:
 		return false, nil
 	}
 }
 
-func _RequestUnion_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*RequestUnion)
+func _RequestOp_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*RequestOp)
 	// request
 	switch x := m.Request.(type) {
-	case *RequestUnion_RequestRange:
+	case *RequestOp_RequestRange:
 		s := proto.Size(x.RequestRange)
 		n += proto.SizeVarint(1<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
-	case *RequestUnion_RequestPut:
+	case *RequestOp_RequestPut:
 		s := proto.Size(x.RequestPut)
 		n += proto.SizeVarint(2<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
-	case *RequestUnion_RequestDeleteRange:
+	case *RequestOp_RequestDeleteRange:
 		s := proto.Size(x.RequestDeleteRange)
 		n += proto.SizeVarint(3<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
@@ -475,106 +475,106 @@ func _RequestUnion_OneofSizer(msg proto.Message) (n int) {
 	return n
 }
 
-type ResponseUnion struct {
+type ResponseOp struct {
 	// response is a union of response types returned by a transaction.
 	//
 	// Types that are valid to be assigned to Response:
-	//	*ResponseUnion_ResponseRange
-	//	*ResponseUnion_ResponsePut
-	//	*ResponseUnion_ResponseDeleteRange
-	Response isResponseUnion_Response `protobuf_oneof:"response"`
+	//	*ResponseOp_ResponseRange
+	//	*ResponseOp_ResponsePut
+	//	*ResponseOp_ResponseDeleteRange
+	Response isResponseOp_Response `protobuf_oneof:"response"`
 }
 
-func (m *ResponseUnion) Reset()                    { *m = ResponseUnion{} }
-func (m *ResponseUnion) String() string            { return proto.CompactTextString(m) }
-func (*ResponseUnion) ProtoMessage()               {}
-func (*ResponseUnion) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{8} }
+func (m *ResponseOp) Reset()                    { *m = ResponseOp{} }
+func (m *ResponseOp) String() string            { return proto.CompactTextString(m) }
+func (*ResponseOp) ProtoMessage()               {}
+func (*ResponseOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{8} }
 
-type isResponseUnion_Response interface {
-	isResponseUnion_Response()
+type isResponseOp_Response interface {
+	isResponseOp_Response()
 	MarshalTo([]byte) (int, error)
 	Size() int
 }
 
-type ResponseUnion_ResponseRange struct {
+type ResponseOp_ResponseRange struct {
 	ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,json=responseRange,oneof"`
 }
-type ResponseUnion_ResponsePut struct {
+type ResponseOp_ResponsePut struct {
 	ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,json=responsePut,oneof"`
 }
-type ResponseUnion_ResponseDeleteRange struct {
+type ResponseOp_ResponseDeleteRange struct {
 	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,oneof"`
 }
 
-func (*ResponseUnion_ResponseRange) isResponseUnion_Response()       {}
-func (*ResponseUnion_ResponsePut) isResponseUnion_Response()         {}
-func (*ResponseUnion_ResponseDeleteRange) isResponseUnion_Response() {}
+func (*ResponseOp_ResponseRange) isResponseOp_Response()       {}
+func (*ResponseOp_ResponsePut) isResponseOp_Response()         {}
+func (*ResponseOp_ResponseDeleteRange) isResponseOp_Response() {}
 
-func (m *ResponseUnion) GetResponse() isResponseUnion_Response {
+func (m *ResponseOp) GetResponse() isResponseOp_Response {
 	if m != nil {
 		return m.Response
 	}
 	return nil
 }
 
-func (m *ResponseUnion) GetResponseRange() *RangeResponse {
-	if x, ok := m.GetResponse().(*ResponseUnion_ResponseRange); ok {
+func (m *ResponseOp) GetResponseRange() *RangeResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseRange); ok {
 		return x.ResponseRange
 	}
 	return nil
 }
 
-func (m *ResponseUnion) GetResponsePut() *PutResponse {
-	if x, ok := m.GetResponse().(*ResponseUnion_ResponsePut); ok {
+func (m *ResponseOp) GetResponsePut() *PutResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponsePut); ok {
 		return x.ResponsePut
 	}
 	return nil
 }
 
-func (m *ResponseUnion) GetResponseDeleteRange() *DeleteRangeResponse {
-	if x, ok := m.GetResponse().(*ResponseUnion_ResponseDeleteRange); ok {
+func (m *ResponseOp) GetResponseDeleteRange() *DeleteRangeResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseDeleteRange); ok {
 		return x.ResponseDeleteRange
 	}
 	return nil
 }
 
 // XXX_OneofFuncs is for the internal use of the proto package.
-func (*ResponseUnion) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
-	return _ResponseUnion_OneofMarshaler, _ResponseUnion_OneofUnmarshaler, _ResponseUnion_OneofSizer, []interface{}{
-		(*ResponseUnion_ResponseRange)(nil),
-		(*ResponseUnion_ResponsePut)(nil),
-		(*ResponseUnion_ResponseDeleteRange)(nil),
+func (*ResponseOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _ResponseOp_OneofMarshaler, _ResponseOp_OneofUnmarshaler, _ResponseOp_OneofSizer, []interface{}{
+		(*ResponseOp_ResponseRange)(nil),
+		(*ResponseOp_ResponsePut)(nil),
+		(*ResponseOp_ResponseDeleteRange)(nil),
 	}
 }
 
-func _ResponseUnion_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
-	m := msg.(*ResponseUnion)
+func _ResponseOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*ResponseOp)
 	// response
 	switch x := m.Response.(type) {
-	case *ResponseUnion_ResponseRange:
+	case *ResponseOp_ResponseRange:
 		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.ResponseRange); err != nil {
 			return err
 		}
-	case *ResponseUnion_ResponsePut:
+	case *ResponseOp_ResponsePut:
 		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.ResponsePut); err != nil {
 			return err
 		}
-	case *ResponseUnion_ResponseDeleteRange:
+	case *ResponseOp_ResponseDeleteRange:
 		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.ResponseDeleteRange); err != nil {
 			return err
 		}
 	case nil:
 	default:
-		return fmt.Errorf("ResponseUnion.Response has unexpected type %T", x)
+		return fmt.Errorf("ResponseOp.Response has unexpected type %T", x)
 	}
 	return nil
 }
 
-func _ResponseUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
-	m := msg.(*ResponseUnion)
+func _ResponseOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*ResponseOp)
 	switch tag {
 	case 1: // response.response_range
 		if wire != proto.WireBytes {
@@ -582,7 +582,7 @@ func _ResponseUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.
 		}
 		msg := new(RangeResponse)
 		err := b.DecodeMessage(msg)
-		m.Response = &ResponseUnion_ResponseRange{msg}
+		m.Response = &ResponseOp_ResponseRange{msg}
 		return true, err
 	case 2: // response.response_put
 		if wire != proto.WireBytes {
@@ -590,7 +590,7 @@ func _ResponseUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.
 		}
 		msg := new(PutResponse)
 		err := b.DecodeMessage(msg)
-		m.Response = &ResponseUnion_ResponsePut{msg}
+		m.Response = &ResponseOp_ResponsePut{msg}
 		return true, err
 	case 3: // response.response_delete_range
 		if wire != proto.WireBytes {
@@ -598,28 +598,28 @@ func _ResponseUnion_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.
 		}
 		msg := new(DeleteRangeResponse)
 		err := b.DecodeMessage(msg)
-		m.Response = &ResponseUnion_ResponseDeleteRange{msg}
+		m.Response = &ResponseOp_ResponseDeleteRange{msg}
 		return true, err
 	default:
 		return false, nil
 	}
 }
 
-func _ResponseUnion_OneofSizer(msg proto.Message) (n int) {
-	m := msg.(*ResponseUnion)
+func _ResponseOp_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*ResponseOp)
 	// response
 	switch x := m.Response.(type) {
-	case *ResponseUnion_ResponseRange:
+	case *ResponseOp_ResponseRange:
 		s := proto.Size(x.ResponseRange)
 		n += proto.SizeVarint(1<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
-	case *ResponseUnion_ResponsePut:
+	case *ResponseOp_ResponsePut:
 		s := proto.Size(x.ResponsePut)
 		n += proto.SizeVarint(2<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
 		n += s
-	case *ResponseUnion_ResponseDeleteRange:
+	case *ResponseOp_ResponseDeleteRange:
 		s := proto.Size(x.ResponseDeleteRange)
 		n += proto.SizeVarint(3<<3 | proto.WireBytes)
 		n += proto.SizeVarint(uint64(s))
@@ -826,9 +826,9 @@ type TxnRequest struct {
 	// and the response will contain their respective responses in order.
 	Compare []*Compare `protobuf:"bytes,1,rep,name=compare" json:"compare,omitempty"`
 	// success is a list of requests which will be applied when compare evaluates to true.
-	Success []*RequestUnion `protobuf:"bytes,2,rep,name=success" json:"success,omitempty"`
+	Success []*RequestOp `protobuf:"bytes,2,rep,name=success" json:"success,omitempty"`
 	// failure is a list of requests which will be applied when compare evaluates to false.
-	Failure []*RequestUnion `protobuf:"bytes,3,rep,name=failure" json:"failure,omitempty"`
+	Failure []*RequestOp `protobuf:"bytes,3,rep,name=failure" json:"failure,omitempty"`
 }
 
 func (m *TxnRequest) Reset()                    { *m = TxnRequest{} }
@@ -843,14 +843,14 @@ func (m *TxnRequest) GetCompare() []*Compare {
 	return nil
 }
 
-func (m *TxnRequest) GetSuccess() []*RequestUnion {
+func (m *TxnRequest) GetSuccess() []*RequestOp {
 	if m != nil {
 		return m.Success
 	}
 	return nil
 }
 
-func (m *TxnRequest) GetFailure() []*RequestUnion {
+func (m *TxnRequest) GetFailure() []*RequestOp {
 	if m != nil {
 		return m.Failure
 	}
@@ -863,7 +863,7 @@ type TxnResponse struct {
 	Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
 	// responses is a list of responses corresponding to the results from applying
 	// success if succeeded is true or failure if succeeded is false.
-	Responses []*ResponseUnion `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"`
+	Responses []*ResponseOp `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"`
 }
 
 func (m *TxnResponse) Reset()                    { *m = TxnResponse{} }
@@ -878,7 +878,7 @@ func (m *TxnResponse) GetHeader() *ResponseHeader {
 	return nil
 }
 
-func (m *TxnResponse) GetResponses() []*ResponseUnion {
+func (m *TxnResponse) GetResponses() []*ResponseOp {
 	if m != nil {
 		return m.Responses
 	}
@@ -1912,8 +1912,8 @@ func init() {
 	proto.RegisterType((*PutResponse)(nil), "etcdserverpb.PutResponse")
 	proto.RegisterType((*DeleteRangeRequest)(nil), "etcdserverpb.DeleteRangeRequest")
 	proto.RegisterType((*DeleteRangeResponse)(nil), "etcdserverpb.DeleteRangeResponse")
-	proto.RegisterType((*RequestUnion)(nil), "etcdserverpb.RequestUnion")
-	proto.RegisterType((*ResponseUnion)(nil), "etcdserverpb.ResponseUnion")
+	proto.RegisterType((*RequestOp)(nil), "etcdserverpb.RequestOp")
+	proto.RegisterType((*ResponseOp)(nil), "etcdserverpb.ResponseOp")
 	proto.RegisterType((*Compare)(nil), "etcdserverpb.Compare")
 	proto.RegisterType((*TxnRequest)(nil), "etcdserverpb.TxnRequest")
 	proto.RegisterType((*TxnResponse)(nil), "etcdserverpb.TxnResponse")
@@ -3696,7 +3696,7 @@ func (m *DeleteRangeResponse) MarshalTo(data []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RequestUnion) Marshal() (data []byte, err error) {
+func (m *RequestOp) Marshal() (data []byte, err error) {
 	size := m.Size()
 	data = make([]byte, size)
 	n, err := m.MarshalTo(data)
@@ -3706,7 +3706,7 @@ func (m *RequestUnion) Marshal() (data []byte, err error) {
 	return data[:n], nil
 }
 
-func (m *RequestUnion) MarshalTo(data []byte) (int, error) {
+func (m *RequestOp) MarshalTo(data []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3721,7 +3721,7 @@ func (m *RequestUnion) MarshalTo(data []byte) (int, error) {
 	return i, nil
 }
 
-func (m *RequestUnion_RequestRange) MarshalTo(data []byte) (int, error) {
+func (m *RequestOp_RequestRange) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.RequestRange != nil {
 		data[i] = 0xa
@@ -3735,7 +3735,7 @@ func (m *RequestUnion_RequestRange) MarshalTo(data []byte) (int, error) {
 	}
 	return i, nil
 }
-func (m *RequestUnion_RequestPut) MarshalTo(data []byte) (int, error) {
+func (m *RequestOp_RequestPut) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.RequestPut != nil {
 		data[i] = 0x12
@@ -3749,7 +3749,7 @@ func (m *RequestUnion_RequestPut) MarshalTo(data []byte) (int, error) {
 	}
 	return i, nil
 }
-func (m *RequestUnion_RequestDeleteRange) MarshalTo(data []byte) (int, error) {
+func (m *RequestOp_RequestDeleteRange) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.RequestDeleteRange != nil {
 		data[i] = 0x1a
@@ -3763,7 +3763,7 @@ func (m *RequestUnion_RequestDeleteRange) MarshalTo(data []byte) (int, error) {
 	}
 	return i, nil
 }
-func (m *ResponseUnion) Marshal() (data []byte, err error) {
+func (m *ResponseOp) Marshal() (data []byte, err error) {
 	size := m.Size()
 	data = make([]byte, size)
 	n, err := m.MarshalTo(data)
@@ -3773,7 +3773,7 @@ func (m *ResponseUnion) Marshal() (data []byte, err error) {
 	return data[:n], nil
 }
 
-func (m *ResponseUnion) MarshalTo(data []byte) (int, error) {
+func (m *ResponseOp) MarshalTo(data []byte) (int, error) {
 	var i int
 	_ = i
 	var l int
@@ -3788,7 +3788,7 @@ func (m *ResponseUnion) MarshalTo(data []byte) (int, error) {
 	return i, nil
 }
 
-func (m *ResponseUnion_ResponseRange) MarshalTo(data []byte) (int, error) {
+func (m *ResponseOp_ResponseRange) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.ResponseRange != nil {
 		data[i] = 0xa
@@ -3802,7 +3802,7 @@ func (m *ResponseUnion_ResponseRange) MarshalTo(data []byte) (int, error) {
 	}
 	return i, nil
 }
-func (m *ResponseUnion_ResponsePut) MarshalTo(data []byte) (int, error) {
+func (m *ResponseOp_ResponsePut) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.ResponsePut != nil {
 		data[i] = 0x12
@@ -3816,7 +3816,7 @@ func (m *ResponseUnion_ResponsePut) MarshalTo(data []byte) (int, error) {
 	}
 	return i, nil
 }
-func (m *ResponseUnion_ResponseDeleteRange) MarshalTo(data []byte) (int, error) {
+func (m *ResponseOp_ResponseDeleteRange) MarshalTo(data []byte) (int, error) {
 	i := 0
 	if m.ResponseDeleteRange != nil {
 		data[i] = 0x1a
@@ -6016,7 +6016,7 @@ func (m *DeleteRangeResponse) Size() (n int) {
 	return n
 }
 
-func (m *RequestUnion) Size() (n int) {
+func (m *RequestOp) Size() (n int) {
 	var l int
 	_ = l
 	if m.Request != nil {
@@ -6025,7 +6025,7 @@ func (m *RequestUnion) Size() (n int) {
 	return n
 }
 
-func (m *RequestUnion_RequestRange) Size() (n int) {
+func (m *RequestOp_RequestRange) Size() (n int) {
 	var l int
 	_ = l
 	if m.RequestRange != nil {
@@ -6034,7 +6034,7 @@ func (m *RequestUnion_RequestRange) Size() (n int) {
 	}
 	return n
 }
-func (m *RequestUnion_RequestPut) Size() (n int) {
+func (m *RequestOp_RequestPut) Size() (n int) {
 	var l int
 	_ = l
 	if m.RequestPut != nil {
@@ -6043,7 +6043,7 @@ func (m *RequestUnion_RequestPut) Size() (n int) {
 	}
 	return n
 }
-func (m *RequestUnion_RequestDeleteRange) Size() (n int) {
+func (m *RequestOp_RequestDeleteRange) Size() (n int) {
 	var l int
 	_ = l
 	if m.RequestDeleteRange != nil {
@@ -6052,7 +6052,7 @@ func (m *RequestUnion_RequestDeleteRange) Size() (n int) {
 	}
 	return n
 }
-func (m *ResponseUnion) Size() (n int) {
+func (m *ResponseOp) Size() (n int) {
 	var l int
 	_ = l
 	if m.Response != nil {
@@ -6061,7 +6061,7 @@ func (m *ResponseUnion) Size() (n int) {
 	return n
 }
 
-func (m *ResponseUnion_ResponseRange) Size() (n int) {
+func (m *ResponseOp_ResponseRange) Size() (n int) {
 	var l int
 	_ = l
 	if m.ResponseRange != nil {
@@ -6070,7 +6070,7 @@ func (m *ResponseUnion_ResponseRange) Size() (n int) {
 	}
 	return n
 }
-func (m *ResponseUnion_ResponsePut) Size() (n int) {
+func (m *ResponseOp_ResponsePut) Size() (n int) {
 	var l int
 	_ = l
 	if m.ResponsePut != nil {
@@ -6079,7 +6079,7 @@ func (m *ResponseUnion_ResponsePut) Size() (n int) {
 	}
 	return n
 }
-func (m *ResponseUnion_ResponseDeleteRange) Size() (n int) {
+func (m *ResponseOp_ResponseDeleteRange) Size() (n int) {
 	var l int
 	_ = l
 	if m.ResponseDeleteRange != nil {
@@ -7834,7 +7834,7 @@ func (m *DeleteRangeResponse) Unmarshal(data []byte) error {
 	}
 	return nil
 }
-func (m *RequestUnion) Unmarshal(data []byte) error {
+func (m *RequestOp) Unmarshal(data []byte) error {
 	l := len(data)
 	iNdEx := 0
 	for iNdEx < l {
@@ -7857,10 +7857,10 @@ func (m *RequestUnion) Unmarshal(data []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: RequestUnion: wiretype end group for non-group")
+			return fmt.Errorf("proto: RequestOp: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: RequestUnion: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: RequestOp: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -7893,7 +7893,7 @@ func (m *RequestUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Request = &RequestUnion_RequestRange{v}
+			m.Request = &RequestOp_RequestRange{v}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -7925,7 +7925,7 @@ func (m *RequestUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Request = &RequestUnion_RequestPut{v}
+			m.Request = &RequestOp_RequestPut{v}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -7957,7 +7957,7 @@ func (m *RequestUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Request = &RequestUnion_RequestDeleteRange{v}
+			m.Request = &RequestOp_RequestDeleteRange{v}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -7980,7 +7980,7 @@ func (m *RequestUnion) Unmarshal(data []byte) error {
 	}
 	return nil
 }
-func (m *ResponseUnion) Unmarshal(data []byte) error {
+func (m *ResponseOp) Unmarshal(data []byte) error {
 	l := len(data)
 	iNdEx := 0
 	for iNdEx < l {
@@ -8003,10 +8003,10 @@ func (m *ResponseUnion) Unmarshal(data []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ResponseUnion: wiretype end group for non-group")
+			return fmt.Errorf("proto: ResponseOp: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ResponseUnion: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ResponseOp: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -8039,7 +8039,7 @@ func (m *ResponseUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Response = &ResponseUnion_ResponseRange{v}
+			m.Response = &ResponseOp_ResponseRange{v}
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {
@@ -8071,7 +8071,7 @@ func (m *ResponseUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Response = &ResponseUnion_ResponsePut{v}
+			m.Response = &ResponseOp_ResponsePut{v}
 			iNdEx = postIndex
 		case 3:
 			if wireType != 2 {
@@ -8103,7 +8103,7 @@ func (m *ResponseUnion) Unmarshal(data []byte) error {
 			if err := v.Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
-			m.Response = &ResponseUnion_ResponseDeleteRange{v}
+			m.Response = &ResponseOp_ResponseDeleteRange{v}
 			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
@@ -8421,7 +8421,7 @@ func (m *TxnRequest) Unmarshal(data []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Success = append(m.Success, &RequestUnion{})
+			m.Success = append(m.Success, &RequestOp{})
 			if err := m.Success[len(m.Success)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -8452,7 +8452,7 @@ func (m *TxnRequest) Unmarshal(data []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Failure = append(m.Failure, &RequestUnion{})
+			m.Failure = append(m.Failure, &RequestOp{})
 			if err := m.Failure[len(m.Failure)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -8586,7 +8586,7 @@ func (m *TxnResponse) Unmarshal(data []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.Responses = append(m.Responses, &ResponseUnion{})
+			m.Responses = append(m.Responses, &ResponseOp{})
 			if err := m.Responses[len(m.Responses)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -14365,171 +14365,172 @@ var (
 )
 
 var fileDescriptorRpc = []byte{
-	// 2650 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x5a, 0x4b, 0x6f, 0x1b, 0xc9,
-	0x11, 0x16, 0x1f, 0x22, 0xc5, 0x22, 0x45, 0xcb, 0x2d, 0xd9, 0x91, 0xc7, 0xeb, 0xc7, 0x8e, 0x9f,
-	0xc9, 0x7a, 0xe5, 0xac, 0xb2, 0x39, 0x04, 0x59, 0x6c, 0x40, 0x89, 0x5c, 0x5b, 0x91, 0x2c, 0xd9,
-	0x23, 0x4a, 0xde, 0x05, 0x02, 0x08, 0x43, 0xb2, 0x2d, 0x11, 0xe6, 0x6b, 0x67, 0x86, 0xb2, 0x65,
-	0x20, 0x97, 0x00, 0xf9, 0x05, 0x9b, 0x53, 0x90, 0x3f, 0x90, 0x73, 0x90, 0xff, 0x10, 0xe4, 0x92,
-	0xfc, 0x82, 0x20, 0xc8, 0x29, 0xc8, 0x25, 0xf7, 0xe4, 0x92, 0xea, 0xd7, 0x4c, 0xcf, 0xb0, 0x47,
-	0xf2, 0x66, 0x92, 0x83, 0xed, 0xe9, 0xea, 0xaa, 0xaf, 0xab, 0xab, 0xab, 0xab, 0xab, 0x8a, 0x86,
-	0x8a, 0x37, 0xe9, 0xae, 0x4d, 0xbc, 0x71, 0x30, 0x26, 0x35, 0x1a, 0x74, 0x7b, 0x3e, 0xf5, 0x4e,
-	0xa9, 0x37, 0xe9, 0x58, 0x2b, 0xc7, 0xe3, 0xe3, 0x31, 0x9f, 0x78, 0xcc, 0xbe, 0x04, 0x8f, 0x75,
-	0x8d, 0xf1, 0x3c, 0x1e, 0x9e, 0x76, 0xbb, 0xfc, 0xaf, 0x49, 0xe7, 0xf1, 0xeb, 0x53, 0x39, 0x75,
-	0x9d, 0x4f, 0xb9, 0xd3, 0xe0, 0x84, 0xff, 0x85, 0x53, 0xec, 0x1f, 0x31, 0x69, 0xff, 0x32, 0x07,
-	0x75, 0x87, 0xfa, 0x93, 0xf1, 0xc8, 0xa7, 0x4f, 0xa9, 0xdb, 0xa3, 0x1e, 0xb9, 0x01, 0xd0, 0x1d,
-	0x4c, 0xfd, 0x80, 0x7a, 0x47, 0xfd, 0xde, 0x6a, 0xee, 0x76, 0xee, 0x61, 0xd1, 0xa9, 0x48, 0xca,
-	0x56, 0x8f, 0x5c, 0x87, 0xca, 0x90, 0x0e, 0x3b, 0x62, 0x36, 0xcf, 0x67, 0x17, 0x04, 0x01, 0x27,
-	0x2d, 0x58, 0xf0, 0xe8, 0x69, 0xdf, 0xef, 0x8f, 0x47, 0xab, 0x05, 0x9c, 0x2b, 0x38, 0xe1, 0x98,
-	0x09, 0x7a, 0xee, 0xab, 0xe0, 0x08, 0x61, 0x86, 0xab, 0x45, 0x21, 0xc8, 0x08, 0x6d, 0x1c, 0xdb,
-	0xbf, 0x2a, 0x40, 0xcd, 0x71, 0x47, 0xc7, 0xd4, 0xa1, 0x5f, 0x4f, 0xa9, 0x1f, 0x90, 0x25, 0x28,
-	0xbc, 0xa6, 0x67, 0x7c, 0xf9, 0x9a, 0xc3, 0x3e, 0x85, 0x3c, 0x72, 0x1c, 0xd1, 0x91, 0x58, 0xb8,
-	0xc6, 0xe4, 0x91, 0xd0, 0x1a, 0xf5, 0xc8, 0x0a, 0xcc, 0x0f, 0xfa, 0xc3, 0x7e, 0x20, 0x57, 0x15,
-	0x83, 0x98, 0x3a, 0xc5, 0x84, 0x3a, 0x9b, 0x00, 0xfe, 0xd8, 0x0b, 0x8e, 0xc6, 0x1e, 0x6e, 0x7a,
-	0x75, 0x1e, 0x67, 0xeb, 0xeb, 0x77, 0xd7, 0x74, 0x53, 0xaf, 0xe9, 0x0a, 0xad, 0xed, 0x23, 0xf3,
-	0x1e, 0xe3, 0x75, 0x2a, 0xbe, 0xfa, 0x24, 0x5f, 0x40, 0x95, 0x83, 0x04, 0xae, 0x77, 0x4c, 0x83,
-	0xd5, 0x12, 0x47, 0xb9, 0x77, 0x01, 0x4a, 0x9b, 0x33, 0x3b, 0x7c, 0x79, 0xf1, 0x4d, 0x6c, 0xa8,
-	0x21, 0x7f, 0xdf, 0x1d, 0xf4, 0xdf, 0xb9, 0x9d, 0x01, 0x5d, 0x2d, 0x23, 0xd0, 0x82, 0x13, 0xa3,
-	0xd9, 0x6b, 0x50, 0x09, 0x75, 0x20, 0x0b, 0x50, 0xdc, 0xdd, 0xdb, 0x6d, 0x2d, 0xcd, 0x11, 0x80,
-	0x52, 0x63, 0x7f, 0xb3, 0xb5, 0xdb, 0x5c, 0xca, 0x91, 0x2a, 0x94, 0x9b, 0x2d, 0x31, 0xc8, 0xdb,
-	0x1b, 0x00, 0xd1, 0x6a, 0xa4, 0x0c, 0x85, 0xed, 0xd6, 0x57, 0xc8, 0x8f, 0x3c, 0x87, 0x2d, 0x67,
-	0x7f, 0x6b, 0x6f, 0x17, 0x05, 0x50, 0x78, 0xd3, 0x69, 0x35, 0xda, 0xad, 0xa5, 0x3c, 0xe3, 0x78,
-	0xb6, 0xd7, 0x5c, 0x2a, 0x90, 0x0a, 0xcc, 0x1f, 0x36, 0x76, 0x0e, 0x5a, 0x4b, 0x45, 0xfb, 0xe7,
-	0xb0, 0x28, 0xd5, 0x17, 0x2e, 0x42, 0x3e, 0x85, 0xd2, 0x09, 0x77, 0x13, 0x7e, 0x32, 0xd5, 0xf5,
-	0x0f, 0x12, 0x7b, 0x8d, 0xb9, 0x92, 0x23, 0x79, 0x71, 0x7b, 0x85, 0xd7, 0xa7, 0x3e, 0x1e, 0x5a,
-	0x01, 0x45, 0x96, 0xd6, 0x84, 0x87, 0xae, 0x6d, 0xd3, 0xb3, 0x43, 0x77, 0x30, 0xa5, 0x0e, 0x9b,
-	0x24, 0x04, 0x8a, 0xc3, 0xb1, 0x47, 0xf9, 0x01, 0x2e, 0x38, 0xfc, 0xdb, 0xfe, 0x29, 0xc0, 0xf3,
-	0x69, 0x90, 0xee, 0x12, 0x78, 0xea, 0xa7, 0x0c, 0x41, 0xba, 0x83, 0x18, 0x70, 0x5f, 0xa0, 0xae,
-	0x4f, 0x43, 0x5f, 0x60, 0x03, 0x7b, 0x13, 0xaa, 0x1c, 0x2b, 0xcb, 0x46, 0x10, 0x84, 0x34, 0xe9,
-	0x80, 0x06, 0x34, 0x83, 0xaf, 0xda, 0x14, 0x96, 0x63, 0x20, 0x99, 0x4c, 0xbb, 0x0a, 0xe5, 0x1e,
-	0x07, 0x13, 0xeb, 0x14, 0x1c, 0x35, 0xb4, 0xff, 0x99, 0xc3, 0x2b, 0x25, 0x34, 0x3c, 0x18, 0x31,
-	0x8f, 0x6f, 0xc0, 0xa2, 0x27, 0xc6, 0x47, 0x5c, 0x17, 0xb9, 0x8e, 0x95, 0xee, 0xae, 0x4f, 0xe7,
-	0x9c, 0x9a, 0x14, 0xe1, 0x64, 0xf2, 0x63, 0xa8, 0x2a, 0x88, 0xc9, 0x34, 0xe0, 0x2b, 0x56, 0xd7,
-	0x57, 0xe3, 0x00, 0xd1, 0x89, 0xa1, 0x38, 0x48, 0x76, 0x24, 0x92, 0x36, 0xac, 0x28, 0x61, 0xa1,
-	0xa3, 0x54, 0xa3, 0xc0, 0x51, 0x6e, 0xc7, 0x51, 0x66, 0xcd, 0x8c, 0x68, 0x44, 0xca, 0x6b, 0x93,
-	0x1b, 0x15, 0x28, 0x4b, 0xaa, 0xfd, 0xaf, 0x1c, 0xba, 0xab, 0x34, 0x93, 0xd8, 0x72, 0x13, 0xea,
-	0x9e, 0x24, 0xc4, 0xf6, 0x7c, 0xdd, 0xb8, 0x67, 0x69, 0xe0, 0x39, 0x67, 0x51, 0x09, 0x89, 0x5d,
-	0x7f, 0x0e, 0xb5, 0x10, 0x25, 0xda, 0xf6, 0x35, 0xc3, 0xb6, 0x43, 0x84, 0xaa, 0x12, 0x60, 0x1b,
-	0x7f, 0x09, 0x57, 0x42, 0x79, 0xc3, 0xce, 0x3f, 0x3c, 0x67, 0xe7, 0x21, 0xe0, 0xb2, 0x42, 0xd0,
-	0xf7, 0x0e, 0x2c, 0xbe, 0x09, 0xb2, 0xfd, 0xeb, 0x02, 0x94, 0x37, 0xc7, 0xc3, 0x89, 0xeb, 0xb1,
-	0x63, 0x2a, 0x21, 0x7d, 0x3a, 0x08, 0xf8, 0x76, 0xeb, 0xeb, 0x77, 0xe2, 0x2b, 0x48, 0x36, 0xf5,
-	0xaf, 0xc3, 0x59, 0x1d, 0x29, 0xc2, 0x84, 0x65, 0x38, 0xcb, 0xbf, 0x87, 0xb0, 0x0c, 0x66, 0x52,
-	0x44, 0x5d, 0x85, 0x42, 0x74, 0x15, 0x2c, 0x28, 0xa3, 0x60, 0x14, 0x82, 0x71, 0x2f, 0x8a, 0x40,
-	0xbe, 0x0b, 0x97, 0xba, 0x1e, 0x75, 0x99, 0x3d, 0x54, 0x98, 0x9e, 0x97, 0x3c, 0x75, 0x31, 0xe1,
-	0xa8, 0x70, 0x7d, 0x07, 0x6a, 0xc3, 0x71, 0x2f, 0xe2, 0x2b, 0x49, 0xbe, 0x2a, 0x52, 0x43, 0xa6,
-	0xab, 0x2a, 0x1e, 0xb0, 0xf8, 0x59, 0xc3, 0x59, 0x31, 0xb4, 0x3f, 0x81, 0xc5, 0xd8, 0x5e, 0x59,
-	0x88, 0x6b, 0xbd, 0x38, 0x68, 0xec, 0x88, 0x78, 0xf8, 0x84, 0x87, 0x40, 0x07, 0xe3, 0x21, 0x86,
-	0xd5, 0x9d, 0xd6, 0xfe, 0x3e, 0x46, 0xcf, 0xcf, 0x42, 0x11, 0x19, 0x40, 0xb5, 0xb8, 0x39, 0xa7,
-	0xc5, 0xcd, 0x9c, 0x8a, 0x9b, 0xf9, 0x28, 0x6e, 0x16, 0x36, 0xea, 0x50, 0x13, 0x06, 0x39, 0x9a,
-	0x32, 0x3f, 0xb4, 0x7f, 0x9b, 0x03, 0x68, 0xbf, 0x1d, 0xa9, 0x80, 0xf1, 0x18, 0xca, 0x5d, 0x01,
-	0x8e, 0x07, 0xc4, 0x62, 0xe2, 0x15, 0xa3, 0x8d, 0x1d, 0xc5, 0x85, 0xb1, 0xa1, 0xec, 0x4f, 0xbb,
-	0x5d, 0xea, 0xab, 0x20, 0x9a, 0xbc, 0xb4, 0xda, 0x3d, 0x77, 0x14, 0x2b, 0x93, 0x7a, 0xe5, 0xf6,
-	0x07, 0x53, 0x1e, 0x55, 0x2f, 0x94, 0x92, 0xac, 0xf6, 0x6f, 0x72, 0x50, 0xe5, 0xba, 0x66, 0x8a,
-	0x4b, 0x1f, 0x40, 0x85, 0xab, 0x41, 0x7b, 0x32, 0x32, 0x2d, 0x38, 0x11, 0x81, 0xfc, 0x08, 0xe3,
-	0xa3, 0x94, 0xf3, 0xa5, 0x6e, 0xd7, 0xcd, 0xb0, 0x42, 0xb9, 0x88, 0xdb, 0xde, 0x86, 0xcb, 0xdc,
-	0x3c, 0xdd, 0x80, 0x4d, 0x48, 0x83, 0xea, 0x0f, 0x7d, 0x2e, 0xf1, 0xd0, 0xe3, 0xdc, 0xe4, 0xe4,
-	0xcc, 0xef, 0x77, 0xdd, 0x81, 0x54, 0x24, 0x1c, 0xe3, 0x03, 0x43, 0x74, 0xb0, 0x4c, 0x6f, 0xc3,
-	0x22, 0x54, 0x9f, 0xba, 0xfe, 0x89, 0x54, 0xc9, 0xfe, 0x12, 0x6a, 0x62, 0x98, 0xc9, 0x8c, 0xf8,
-	0x2a, 0x9e, 0x20, 0x0a, 0x57, 0x7c, 0xd1, 0xe1, 0xdf, 0xf6, 0x65, 0xb8, 0xb4, 0x3f, 0x72, 0x27,
-	0xfe, 0xc9, 0x58, 0x05, 0x5a, 0x96, 0xc6, 0x2d, 0x45, 0xb4, 0x4c, 0x2b, 0x3e, 0x80, 0x4b, 0x1e,
-	0x1d, 0xba, 0xfd, 0x51, 0x7f, 0x74, 0x7c, 0xd4, 0x39, 0x0b, 0xa8, 0x2f, 0xb3, 0xbc, 0x7a, 0x48,
-	0xde, 0x60, 0x54, 0xa6, 0x5a, 0x67, 0x30, 0xee, 0xc8, 0xbb, 0xce, 0xbf, 0xed, 0xdf, 0xe3, 0x9b,
-	0xf3, 0xd2, 0x0d, 0xba, 0xca, 0x0a, 0x64, 0x0b, 0xea, 0xe1, 0x0d, 0xe7, 0x14, 0xa9, 0x4b, 0x22,
-	0xda, 0x73, 0x99, 0x4d, 0x79, 0xe3, 0x55, 0xb4, 0x5f, 0xec, 0xea, 0x04, 0x0e, 0xe5, 0x8e, 0xba,
-	0x74, 0x10, 0x42, 0xe5, 0xd3, 0xa1, 0x38, 0xa3, 0x0e, 0xa5, 0x13, 0x36, 0x2e, 0x45, 0x2f, 0xa1,
-	0xb8, 0x9f, 0xdf, 0xe4, 0x80, 0xcc, 0xea, 0xf0, 0x6d, 0x93, 0xd0, 0x7b, 0x50, 0xf7, 0xf1, 0xda,
-	0x07, 0x47, 0x89, 0x1c, 0x78, 0x91, 0x53, 0xc3, 0x28, 0x85, 0x16, 0xc6, 0xe4, 0xfb, 0x18, 0x5d,
-	0xda, 0x3f, 0x1a, 0x8d, 0x83, 0xfe, 0xab, 0x33, 0x1e, 0x19, 0x17, 0x9c, 0xba, 0x22, 0xef, 0x72,
-	0xaa, 0xfd, 0x58, 0x29, 0xa5, 0x2b, 0x4f, 0xae, 0xc1, 0xc2, 0x1b, 0x46, 0x55, 0xd9, 0x39, 0x3e,
-	0xf9, 0x7c, 0xbc, 0xd5, 0xb3, 0xff, 0x8e, 0x0f, 0xa0, 0x34, 0x7f, 0x26, 0x1f, 0xd0, 0x97, 0xc8,
-	0xc7, 0x96, 0x60, 0xf9, 0x86, 0x38, 0x96, 0x9e, 0xcc, 0xd4, 0xd4, 0x90, 0xdd, 0x33, 0x61, 0x65,
-	0x9c, 0x12, 0xfb, 0x09, 0xc7, 0x18, 0xe8, 0x97, 0xba, 0xe2, 0x9e, 0x25, 0x22, 0xbd, 0x73, 0x49,
-	0xd2, 0x43, 0xeb, 0xdc, 0x83, 0x12, 0x3d, 0xa5, 0xa3, 0xc0, 0x5f, 0xad, 0xf2, 0xb8, 0xb0, 0xa8,
-	0xd2, 0xc5, 0x16, 0xa3, 0x3a, 0x72, 0xd2, 0xfe, 0x21, 0x5c, 0xde, 0x61, 0x79, 0xdd, 0x13, 0xb4,
-	0xbe, 0x9e, 0x21, 0xb6, 0xdb, 0x3b, 0xd2, 0x2a, 0x85, 0xa0, 0xbd, 0x43, 0xea, 0x90, 0xdf, 0x6a,
-	0xca, 0x3d, 0xe4, 0xfb, 0x4d, 0xfb, 0x17, 0x78, 0xd0, 0xba, 0x5c, 0x26, 0x33, 0x25, 0xc0, 0xd5,
-	0xf2, 0x85, 0x68, 0x79, 0x4c, 0x45, 0xa9, 0xe7, 0x8d, 0x3d, 0x6e, 0x90, 0x8a, 0x23, 0x06, 0xf6,
-	0x5d, 0xa9, 0x03, 0xee, 0x79, 0xfc, 0x3a, 0x74, 0x36, 0x81, 0x96, 0x0b, 0x55, 0xdd, 0x86, 0xe5,
-	0x18, 0x57, 0xa6, 0xe0, 0xf4, 0x00, 0xae, 0x70, 0xb0, 0x6d, 0x4a, 0x27, 0x8d, 0x41, 0xff, 0x34,
-	0x75, 0xd5, 0x09, 0x5c, 0x4d, 0x32, 0xfe, 0x7f, 0x6d, 0x64, 0x9f, 0x40, 0xe9, 0x19, 0xaf, 0x1f,
-	0x35, 0x5d, 0x8a, 0x9c, 0x17, 0x23, 0xcc, 0xc8, 0x1d, 0x8a, 0xec, 0xbe, 0xe2, 0xf0, 0x6f, 0x1e,
-	0xcd, 0x29, 0xf5, 0x0e, 0x9c, 0x1d, 0xf1, 0x70, 0x54, 0x9c, 0x70, 0x4c, 0x6e, 0xb2, 0xca, 0xb5,
-	0x8f, 0xee, 0xc1, 0x67, 0x8b, 0x7c, 0x56, 0xa3, 0x60, 0x05, 0xb5, 0x24, 0x56, 0x6a, 0xf4, 0x7a,
-	0xda, 0xcb, 0x11, 0xe2, 0xe5, 0xe2, 0x78, 0xf6, 0x1b, 0xb8, 0xac, 0xf1, 0x67, 0x32, 0xc3, 0x23,
-	0x28, 0x89, 0x22, 0x59, 0x06, 0xad, 0x95, 0xb8, 0x94, 0x58, 0xc6, 0x91, 0x3c, 0xf6, 0x3d, 0x58,
-	0x96, 0x14, 0x3a, 0x1c, 0x9b, 0xce, 0x8a, 0xdb, 0xc7, 0xde, 0x81, 0x95, 0x38, 0x5b, 0x26, 0x17,
-	0x69, 0xa8, 0x45, 0x0f, 0x26, 0x3d, 0x2d, 0x06, 0x26, 0x0f, 0x45, 0x37, 0x58, 0x3e, 0x61, 0xb0,
-	0x50, 0x21, 0x05, 0x91, 0x49, 0xa1, 0x65, 0x65, 0xfe, 0x9d, 0xbe, 0x1f, 0xbe, 0x74, 0xef, 0x80,
-	0xe8, 0xc4, 0x4c, 0x87, 0xb2, 0x06, 0x65, 0x61, 0x70, 0x95, 0x55, 0x99, 0x4f, 0x45, 0x31, 0x31,
-	0x85, 0x9a, 0xf4, 0x95, 0xe7, 0x1e, 0x0f, 0x69, 0x18, 0x73, 0x58, 0x0a, 0xa1, 0x13, 0x33, 0xed,
-	0xf8, 0x4f, 0xf8, 0x7c, 0x36, 0x06, 0xae, 0x37, 0x54, 0xc6, 0xff, 0x1c, 0x4a, 0x22, 0x37, 0x91,
-	0x89, 0xfc, 0xfd, 0x38, 0x8c, 0xce, 0x2b, 0x06, 0x0d, 0x91, 0xc9, 0x48, 0x29, 0x76, 0x58, 0xb2,
-	0x37, 0xd3, 0x4c, 0xf4, 0x6a, 0x9a, 0xe4, 0x63, 0x98, 0x77, 0x99, 0x08, 0xbf, 0x8b, 0xf5, 0xf5,
-	0xef, 0x18, 0xa0, 0xdb, 0x67, 0x13, 0xea, 0x08, 0x2e, 0xfb, 0x53, 0xa8, 0x6a, 0x2b, 0xb0, 0xac,
-	0xf7, 0x49, 0xab, 0x8d, 0xa9, 0x70, 0x0d, 0x16, 0x1a, 0x9b, 0xed, 0xad, 0x43, 0x91, 0x0c, 0xd7,
-	0x01, 0x9a, 0xad, 0x70, 0x9c, 0xc7, 0x2c, 0x48, 0x48, 0xc9, 0x1b, 0xae, 0xeb, 0x93, 0x4b, 0xd3,
-	0x27, 0xff, 0x5e, 0xfa, 0xbc, 0x85, 0x45, 0xb9, 0xfd, 0x4c, 0x3e, 0xf0, 0x09, 0x5a, 0x98, 0xc1,
-	0x28, 0x17, 0xb8, 0x66, 0x58, 0x56, 0xdd, 0x4e, 0xc1, 0x68, 0x63, 0xf6, 0xb0, 0x1f, 0xb8, 0xc1,
-	0xd4, 0x57, 0x2e, 0xf0, 0xc7, 0x1c, 0xd4, 0x15, 0x25, 0x6b, 0x31, 0xaf, 0x6a, 0x25, 0x11, 0xf3,
-	0xc2, 0x4a, 0xe9, 0x2a, 0x94, 0x7a, 0x9d, 0xfd, 0xfe, 0x3b, 0xd5, 0xd4, 0x90, 0x23, 0x46, 0x1f,
-	0x88, 0x75, 0x44, 0x47, 0x4d, 0x8e, 0x58, 0xfa, 0xcd, 0x7a, 0x6b, 0x5b, 0xa3, 0x1e, 0x7d, 0xcb,
-	0x5f, 0xda, 0xa2, 0x13, 0x11, 0x78, 0xba, 0x2c, 0x3b, 0x6f, 0xbc, 0x90, 0xd2, 0x3b, 0x71, 0xe8,
-	0xe4, 0x8d, 0x69, 0x70, 0xd2, 0x1a, 0xb1, 0xa6, 0x93, 0xda, 0xe1, 0x0a, 0x10, 0x46, 0x6c, 0xf6,
-	0x7d, 0x9d, 0xda, 0x82, 0x65, 0x46, 0x45, 0xbf, 0xc7, 0x64, 0x3a, 0x8a, 0x18, 0x2a, 0x6c, 0xe7,
-	0x12, 0x61, 0xdb, 0xf5, 0xfd, 0x37, 0x63, 0xaf, 0x27, 0xb7, 0x16, 0x8e, 0xed, 0xa6, 0x00, 0x3f,
-	0xf0, 0x63, 0x81, 0xf9, 0xdb, 0xa2, 0x3c, 0x8c, 0x50, 0x9e, 0xd0, 0xe0, 0x1c, 0x14, 0xfb, 0x23,
-	0xb8, 0xa2, 0x38, 0x65, 0x31, 0x7d, 0x0e, 0xf3, 0x1e, 0xdc, 0x50, 0xcc, 0x9b, 0x27, 0x2c, 0xd1,
-	0x7b, 0x2e, 0x17, 0xfc, 0x6f, 0xf5, 0xdc, 0x80, 0xd5, 0x50, 0x4f, 0x9e, 0x83, 0x8c, 0x07, 0xba,
-	0x02, 0x53, 0x5f, 0xfa, 0x0c, 0x62, 0xb1, 0x6f, 0x46, 0xf3, 0x90, 0x45, 0x3d, 0x82, 0xec, 0xdb,
-	0xde, 0x84, 0x6b, 0x0a, 0x43, 0x66, 0x07, 0x71, 0x90, 0x19, 0x85, 0x4c, 0x20, 0xd2, 0x60, 0x4c,
-	0xf4, 0x7c, 0xb3, 0xeb, 0x9c, 0x71, 0xd3, 0x72, 0xcc, 0x9c, 0x86, 0x29, 0x4d, 0xcb, 0x38, 0x67,
-	0x4c, 0x3b, 0xc3, 0xfc, 0x33, 0xb8, 0x19, 0xc2, 0x32, 0x4b, 0x3c, 0x47, 0xf7, 0xeb, 0xfb, 0xbe,
-	0x56, 0xd6, 0x99, 0xb6, 0x72, 0x1f, 0x8a, 0x13, 0x2a, 0xa3, 0x44, 0x75, 0x9d, 0xac, 0x89, 0x9e,
-	0xf6, 0x9a, 0x26, 0xcc, 0xe7, 0xed, 0x27, 0x70, 0x4b, 0xa1, 0x0b, 0x1b, 0x19, 0xe1, 0x93, 0x4a,
-	0xa9, 0x94, 0x5f, 0x18, 0x8a, 0x7d, 0xb2, 0x00, 0xaf, 0x5f, 0x88, 0x4c, 0x01, 0x7e, 0x5b, 0xdc,
-	0x98, 0xf0, 0x1e, 0x65, 0x02, 0xeb, 0xc0, 0x4a, 0xfc, 0xfa, 0x65, 0x8a, 0x3d, 0x98, 0xaa, 0x06,
-	0x68, 0x25, 0x15, 0x79, 0xc4, 0x40, 0x29, 0x1c, 0xde, 0xcd, 0x4c, 0x0a, 0xbb, 0x11, 0x18, 0xf7,
-	0xa3, 0xac, 0xfa, 0xb2, 0x03, 0x53, 0x49, 0x88, 0x18, 0xd8, 0xbb, 0x70, 0x35, 0x79, 0xb7, 0x33,
-	0xa9, 0x7c, 0x28, 0x7c, 0xd4, 0x74, 0xfd, 0x33, 0xe1, 0xbe, 0x88, 0x6e, 0xb0, 0x16, 0x05, 0x32,
-	0x41, 0x3a, 0x60, 0x99, 0x82, 0xc2, 0xff, 0xc2, 0x5f, 0xc3, 0x18, 0x91, 0x09, 0xcc, 0x8f, 0xc0,
-	0xb2, 0x1f, 0x7f, 0x14, 0x06, 0x0a, 0xe7, 0x86, 0x01, 0xe9, 0x10, 0x7a, 0x44, 0xca, 0xb4, 0x89,
-	0x97, 0x51, 0x58, 0x99, 0x09, 0x5a, 0x99, 0x80, 0xbf, 0x84, 0xdb, 0xe9, 0xf1, 0x2a, 0x0b, 0xf2,
-	0xf7, 0x6c, 0xa8, 0x84, 0xd9, 0x93, 0xf6, 0xc3, 0x51, 0x15, 0xca, 0xbb, 0x7b, 0xfb, 0xcf, 0x1b,
-	0x9b, 0x98, 0xb7, 0xad, 0xff, 0x23, 0x0f, 0xf9, 0xed, 0x43, 0xb2, 0x01, 0xf3, 0xa2, 0xe5, 0x7d,
-	0xce, 0x8f, 0x02, 0xd6, 0x79, 0xcd, 0x73, 0x7b, 0x8e, 0x7c, 0x06, 0x05, 0xd6, 0xf4, 0x4e, 0xfd,
-	0x55, 0xc0, 0x4a, 0x6f, 0x9c, 0xa3, 0x74, 0x1b, 0xaa, 0x5a, 0x87, 0x9b, 0x5c, 0xf8, 0xab, 0x80,
-	0x75, 0x71, 0xf7, 0x5c, 0xe8, 0xd4, 0x7e, 0x3b, 0x4a, 0xea, 0x14, 0x75, 0x64, 0x93, 0x3a, 0x69,
-	0xfd, 0x4f, 0x94, 0xde, 0x95, 0x9d, 0xf5, 0x6e, 0x40, 0x6e, 0x19, 0x1a, 0xb5, 0x7a, 0x27, 0xd2,
-	0xba, 0x9d, 0xce, 0xa0, 0xf0, 0xd6, 0xf7, 0x60, 0x9e, 0x77, 0x69, 0xc8, 0x17, 0xea, 0xc3, 0x32,
-	0xf4, 0xb0, 0x52, 0xcc, 0x1d, 0xeb, 0xef, 0xd8, 0x73, 0x0f, 0x73, 0xdf, 0xcf, 0xad, 0x7f, 0x93,
-	0x87, 0x79, 0x5e, 0xb5, 0x93, 0x17, 0x00, 0x51, 0x7b, 0x23, 0xa9, 0xed, 0x4c, 0xc3, 0x24, 0xa9,
-	0xed, 0x6c, 0x67, 0x44, 0x9c, 0x88, 0xd6, 0x87, 0x20, 0x26, 0x91, 0x58, 0x23, 0x23, 0x79, 0x22,
-	0x86, 0x26, 0x06, 0xa2, 0xba, 0x50, 0x8f, 0xf7, 0x19, 0xc8, 0x1d, 0x83, 0x58, 0xb2, 0x5d, 0x61,
-	0xdd, 0x3d, 0x9f, 0x29, 0x66, 0x95, 0xbf, 0xe4, 0xf1, 0xdc, 0xc4, 0xef, 0xd6, 0x78, 0x84, 0x95,
-	0xb0, 0x94, 0x27, 0x37, 0x4d, 0x65, 0x5e, 0x94, 0x03, 0x59, 0xb7, 0x52, 0xe7, 0x43, 0xf5, 0x5f,
-	0x42, 0x4d, 0x2f, 0xbd, 0xc9, 0x87, 0xc6, 0xca, 0x51, 0xaf, 0xde, 0x2d, 0xfb, 0x3c, 0x96, 0x59,
-	0x60, 0x51, 0x42, 0x9b, 0x81, 0x63, 0x15, 0xba, 0x19, 0x38, 0x5e, 0x81, 0x23, 0x30, 0x7a, 0x46,
-	0x54, 0x38, 0x13, 0xe3, 0x16, 0xb5, 0x3a, 0x3b, 0xe9, 0x19, 0xb3, 0x35, 0x37, 0xfa, 0xf1, 0xbf,
-	0xf3, 0x50, 0x7d, 0xe6, 0xf6, 0x47, 0x01, 0x1d, 0xb1, 0x46, 0x1f, 0x8b, 0x1e, 0x3c, 0xd0, 0x24,
-	0xdd, 0x59, 0x2f, 0x53, 0x93, 0xee, 0x1c, 0xab, 0xe1, 0x50, 0xcd, 0x16, 0x94, 0x44, 0x29, 0x45,
-	0x12, 0x8c, 0xb1, 0x92, 0xcb, 0xfa, 0xc0, 0x3c, 0xa9, 0xef, 0x36, 0xaa, 0xca, 0x93, 0xbb, 0x9d,
-	0x29, 0xe2, 0xad, 0xdb, 0xe9, 0x0c, 0x21, 0xe4, 0x4f, 0xa0, 0xc8, 0x1a, 0xfa, 0x24, 0x11, 0x2a,
-	0xb4, 0x9e, 0xbf, 0x65, 0x99, 0xa6, 0x42, 0x80, 0x67, 0xb0, 0xa0, 0x7a, 0xf4, 0xe4, 0x46, 0x42,
-	0xff, 0x78, 0x3f, 0xdf, 0xba, 0x99, 0x36, 0xad, 0xc0, 0xd0, 0xbd, 0x7f, 0x07, 0x50, 0x64, 0x2f,
-	0x06, 0xdb, 0x6b, 0x94, 0xa0, 0x26, 0xf7, 0x3a, 0x53, 0xcb, 0x25, 0xf7, 0x3a, 0x9b, 0xdb, 0x8a,
-	0x3b, 0xaf, 0xe5, 0xa9, 0xc4, 0x20, 0x12, 0x2f, 0x05, 0x93, 0x77, 0xde, 0x90, 0xe4, 0x0a, 0xdf,
-	0xd6, 0x13, 0x56, 0x62, 0x10, 0x4a, 0xd4, 0x92, 0x49, 0xdf, 0x36, 0xe5, 0xbb, 0x08, 0xfc, 0x1c,
-	0xca, 0x32, 0x43, 0x35, 0xa9, 0x1a, 0x2f, 0x2c, 0x4d, 0xaa, 0x26, 0xd2, 0xdb, 0x08, 0x11, 0xf3,
-	0x94, 0x34, 0xc4, 0xa8, 0x12, 0x4a, 0x43, 0xd4, 0x92, 0x1c, 0x44, 0xfc, 0x0a, 0x20, 0xca, 0x4a,
-	0x93, 0xc1, 0xce, 0x58, 0x8f, 0x26, 0x83, 0x9d, 0x39, 0xb1, 0x45, 0xe8, 0xaf, 0x81, 0xcc, 0x26,
-	0xa8, 0xe4, 0x23, 0xb3, 0xb4, 0xb1, 0x8a, 0xb5, 0x1e, 0xbd, 0x1f, 0x73, 0xb8, 0x64, 0x07, 0x16,
-	0x63, 0xb9, 0x2b, 0xb9, 0x9f, 0x62, 0x83, 0x44, 0x89, 0x6b, 0x3d, 0xb8, 0x90, 0x2f, 0x5c, 0x83,
-	0x42, 0x3d, 0x9e, 0xcc, 0x92, 0x14, 0xe1, 0x99, 0x1a, 0xd8, 0x7a, 0x78, 0x31, 0xa3, 0x7e, 0xd4,
-	0x32, 0xbf, 0x35, 0x1d, 0x75, 0xbc, 0x3c, 0x36, 0x1d, 0x75, 0x22, 0x39, 0x8e, 0x10, 0x53, 0x9c,
-	0x27, 0x5e, 0x46, 0xa7, 0x21, 0xce, 0x38, 0x4f, 0x94, 0xc1, 0x9a, 0x9c, 0x67, 0xa6, 0xe2, 0x36,
-	0x39, 0xcf, 0x6c, 0x12, 0x8c, 0xd0, 0x01, 0x2c, 0x1b, 0x92, 0x59, 0xf2, 0x28, 0x45, 0x2d, 0x63,
-	0xa1, 0x6e, 0x7d, 0xfc, 0x9e, 0xdc, 0xe1, 0xaa, 0x6f, 0x60, 0xc5, 0x94, 0xe9, 0x92, 0x14, 0xa0,
-	0x94, 0x0a, 0xde, 0x5a, 0x7b, 0x5f, 0x76, 0xb5, 0xf0, 0x46, 0xed, 0x0f, 0x7f, 0xbb, 0x99, 0xfb,
-	0x33, 0xfe, 0xf9, 0x2b, 0xfe, 0xe9, 0x94, 0xf8, 0xff, 0x82, 0xfb, 0xc1, 0x7f, 0x02, 0x00, 0x00,
-	0xff, 0xff, 0x53, 0x79, 0x0b, 0x16, 0x6e, 0x27, 0x00, 0x00,
+	// 2671 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xb4, 0x5a, 0x4f, 0x6f, 0xdb, 0xc8,
+	0x15, 0x17, 0x25, 0x59, 0xb2, 0x9e, 0xfe, 0x58, 0x19, 0x3b, 0xa9, 0xc2, 0x24, 0x8e, 0x77, 0xf2,
+	0xcf, 0xdb, 0xcd, 0x2a, 0x1b, 0x77, 0xdb, 0x4b, 0x17, 0x5b, 0xc8, 0x92, 0xd6, 0xf6, 0xda, 0xb1,
+	0x1d, 0x5a, 0x71, 0xb2, 0x40, 0x01, 0x83, 0x92, 0x26, 0x36, 0x11, 0x89, 0xd4, 0x92, 0x94, 0x13,
+	0x07, 0xe8, 0xa5, 0x40, 0x3f, 0xc1, 0xf6, 0xd2, 0x5e, 0xfb, 0x11, 0x8a, 0x7e, 0x87, 0xa2, 0x97,
+	0xf6, 0x13, 0x14, 0x45, 0x4e, 0x45, 0xd1, 0x7b, 0x0f, 0xbd, 0x14, 0xf3, 0x8f, 0x1c, 0x52, 0x94,
+	0x93, 0x2d, 0xdb, 0x4b, 0xcc, 0x79, 0x7c, 0xef, 0x37, 0x6f, 0xde, 0xbc, 0xf9, 0xf1, 0xbd, 0x51,
+	0xa0, 0xe4, 0x4e, 0x06, 0xcd, 0x89, 0xeb, 0xf8, 0x0e, 0xaa, 0x10, 0x7f, 0x30, 0xf4, 0x88, 0x7b,
+	0x4e, 0xdc, 0x49, 0x5f, 0x5f, 0x39, 0x75, 0x4e, 0x1d, 0xf6, 0xe2, 0x11, 0x7d, 0xe2, 0x3a, 0xfa,
+	0x75, 0xaa, 0xf3, 0x68, 0x7c, 0x3e, 0x18, 0xb0, 0x7f, 0x26, 0xfd, 0x47, 0xaf, 0xce, 0xc5, 0xab,
+	0x1b, 0xec, 0x95, 0x39, 0xf5, 0xcf, 0xd8, 0x3f, 0x93, 0x3e, 0xfb, 0xc3, 0x5f, 0xe2, 0x5f, 0x69,
+	0x50, 0x33, 0x88, 0x37, 0x71, 0x6c, 0x8f, 0x6c, 0x13, 0x73, 0x48, 0x5c, 0x74, 0x0b, 0x60, 0x30,
+	0x9a, 0x7a, 0x3e, 0x71, 0x4f, 0xac, 0x61, 0x43, 0x5b, 0xd3, 0xd6, 0xf3, 0x46, 0x49, 0x48, 0x76,
+	0x86, 0xe8, 0x06, 0x94, 0xc6, 0x64, 0xdc, 0xe7, 0x6f, 0xb3, 0xec, 0xed, 0x22, 0x17, 0xec, 0x0c,
+	0x91, 0x0e, 0x8b, 0x2e, 0x39, 0xb7, 0x3c, 0xcb, 0xb1, 0x1b, 0xb9, 0x35, 0x6d, 0x3d, 0x67, 0x04,
+	0x63, 0x6a, 0xe8, 0x9a, 0x2f, 0xfd, 0x13, 0x9f, 0xb8, 0xe3, 0x46, 0x9e, 0x1b, 0x52, 0x41, 0x8f,
+	0xb8, 0x63, 0xfc, 0xeb, 0x1c, 0x54, 0x0c, 0xd3, 0x3e, 0x25, 0x06, 0xf9, 0x76, 0x4a, 0x3c, 0x1f,
+	0xd5, 0x21, 0xf7, 0x8a, 0x5c, 0xb0, 0xe9, 0x2b, 0x06, 0x7d, 0xe4, 0xf6, 0xf6, 0x29, 0x39, 0x21,
+	0x36, 0x9f, 0xb8, 0x42, 0xed, 0xed, 0x53, 0xd2, 0xb5, 0x87, 0x68, 0x05, 0x16, 0x46, 0xd6, 0xd8,
+	0xf2, 0xc5, 0xac, 0x7c, 0x10, 0x71, 0x27, 0x1f, 0x73, 0xa7, 0x0d, 0xe0, 0x39, 0xae, 0x7f, 0xe2,
+	0xb8, 0x43, 0xe2, 0x36, 0x16, 0xd6, 0xb4, 0xf5, 0xda, 0xc6, 0xdd, 0xa6, 0x1a, 0xea, 0xa6, 0xea,
+	0x50, 0xf3, 0xc8, 0x71, 0xfd, 0x03, 0xaa, 0x6b, 0x94, 0x3c, 0xf9, 0x88, 0xbe, 0x82, 0x32, 0x03,
+	0xf1, 0x4d, 0xf7, 0x94, 0xf8, 0x8d, 0x02, 0x43, 0xb9, 0xf7, 0x1e, 0x94, 0x1e, 0x53, 0x36, 0xd8,
+	0xf4, 0xfc, 0x19, 0x61, 0xa8, 0x78, 0xc4, 0xb5, 0xcc, 0x91, 0xf5, 0xd6, 0xec, 0x8f, 0x48, 0xa3,
+	0xb8, 0xa6, 0xad, 0x2f, 0x1a, 0x11, 0x19, 0x6e, 0x42, 0x29, 0xf0, 0x01, 0x2d, 0x42, 0x7e, 0xff,
+	0x60, 0xbf, 0x5b, 0xcf, 0x20, 0x80, 0x42, 0xeb, 0xa8, 0xdd, 0xdd, 0xef, 0xd4, 0x35, 0x54, 0x86,
+	0x62, 0xa7, 0xcb, 0x07, 0x59, 0xbc, 0x09, 0x10, 0xce, 0x86, 0x8a, 0x90, 0xdb, 0xed, 0x7e, 0x53,
+	0xcf, 0x50, 0x9d, 0xe3, 0xae, 0x71, 0xb4, 0x73, 0xb0, 0x5f, 0xd7, 0xa8, 0x71, 0xdb, 0xe8, 0xb6,
+	0x7a, 0xdd, 0x7a, 0x96, 0x6a, 0x3c, 0x39, 0xe8, 0xd4, 0x73, 0xa8, 0x04, 0x0b, 0xc7, 0xad, 0xbd,
+	0x67, 0xdd, 0x7a, 0x1e, 0xff, 0x02, 0xaa, 0xc2, 0x7d, 0x9e, 0x22, 0xe8, 0x73, 0x28, 0x9c, 0xb1,
+	0x34, 0x61, 0x3b, 0x53, 0xde, 0xb8, 0x19, 0x5b, 0x6b, 0x24, 0x95, 0x0c, 0xa1, 0x8b, 0x30, 0xe4,
+	0x5e, 0x9d, 0x7b, 0x8d, 0xec, 0x5a, 0x6e, 0xbd, 0xbc, 0x51, 0x6f, 0xf2, 0x0c, 0x6d, 0xee, 0x92,
+	0x8b, 0x63, 0x73, 0x34, 0x25, 0x06, 0x7d, 0x89, 0x10, 0xe4, 0xc7, 0x8e, 0x4b, 0xd8, 0x06, 0x2e,
+	0x1a, 0xec, 0x19, 0x7f, 0x0d, 0x70, 0x38, 0xf5, 0xe7, 0xa7, 0xc4, 0x0a, 0x2c, 0x9c, 0x53, 0x04,
+	0x91, 0x0e, 0x7c, 0xc0, 0x72, 0x81, 0x98, 0x1e, 0x09, 0x72, 0x81, 0x0e, 0x70, 0x1b, 0xca, 0x0c,
+	0x2b, 0xcd, 0x42, 0x70, 0x1b, 0x50, 0x87, 0x8c, 0x88, 0x4f, 0x52, 0xe4, 0x2a, 0x26, 0xb0, 0x1c,
+	0x01, 0x49, 0x15, 0xda, 0x06, 0x14, 0x87, 0x0c, 0x8c, 0xcf, 0x93, 0x33, 0xe4, 0x10, 0xff, 0x53,
+	0x83, 0x92, 0xf0, 0xf0, 0x60, 0x82, 0x5a, 0x50, 0x75, 0xf9, 0xe0, 0x84, 0x39, 0x22, 0x26, 0xd1,
+	0xe7, 0xe7, 0xea, 0x76, 0xc6, 0xa8, 0x08, 0x13, 0x26, 0x46, 0x3f, 0x85, 0xb2, 0x84, 0x98, 0x4c,
+	0x7d, 0x36, 0x5d, 0x79, 0xa3, 0x11, 0x05, 0x08, 0xb7, 0x6b, 0x3b, 0x63, 0x80, 0x50, 0x3f, 0x9c,
+	0xfa, 0xa8, 0x07, 0x2b, 0xd2, 0x98, 0x3b, 0x28, 0xdc, 0xc8, 0x31, 0x94, 0xb5, 0x28, 0xca, 0x6c,
+	0x8c, 0xb7, 0x33, 0x06, 0x12, 0xf6, 0xca, 0xcb, 0xcd, 0x12, 0x14, 0x85, 0x14, 0xff, 0x4b, 0x03,
+	0x90, 0x31, 0x3a, 0x98, 0xa0, 0x0e, 0xd4, 0x5c, 0x31, 0x8a, 0x2c, 0xf8, 0x46, 0xe2, 0x82, 0x45,
+	0x68, 0x33, 0x46, 0x55, 0x1a, 0xf1, 0x25, 0x7f, 0x09, 0x95, 0x00, 0x25, 0x5c, 0xf3, 0xf5, 0x84,
+	0x35, 0x07, 0x08, 0x65, 0x69, 0x40, 0x57, 0xfd, 0x1c, 0xae, 0x06, 0xf6, 0x09, 0xcb, 0xfe, 0xe8,
+	0x92, 0x65, 0x07, 0x80, 0xcb, 0x12, 0x41, 0x5d, 0x38, 0x50, 0x66, 0xe3, 0x62, 0xfc, 0xdb, 0x1c,
+	0x14, 0xdb, 0xce, 0x78, 0x62, 0xba, 0x74, 0x8f, 0x0a, 0x2e, 0xf1, 0xa6, 0x23, 0x9f, 0x2d, 0xb7,
+	0xb6, 0x71, 0x27, 0x3a, 0x83, 0x50, 0x93, 0x7f, 0x0d, 0xa6, 0x6a, 0x08, 0x13, 0x6a, 0x2c, 0x88,
+	0x2c, 0xfb, 0x01, 0xc6, 0x82, 0xc6, 0x84, 0x89, 0x3c, 0x04, 0xb9, 0xf0, 0x10, 0xe8, 0x50, 0x3c,
+	0x27, 0x6e, 0x48, 0xbe, 0xdb, 0x19, 0x43, 0x0a, 0xd0, 0xc7, 0xb0, 0x34, 0x70, 0x89, 0x49, 0xe3,
+	0x21, 0x09, 0x7a, 0x41, 0xe8, 0xd4, 0xf8, 0x0b, 0x43, 0x12, 0xf5, 0x1d, 0xa8, 0x8c, 0x9d, 0x61,
+	0xa8, 0x57, 0x10, 0x7a, 0xe5, 0xb1, 0x33, 0x0c, 0x94, 0xae, 0x49, 0x26, 0xa0, 0xcc, 0x59, 0xd9,
+	0xce, 0x08, 0x2e, 0xc0, 0x8f, 0xa1, 0x1a, 0x59, 0x2b, 0x25, 0xb7, 0xee, 0xd3, 0x67, 0xad, 0x3d,
+	0xce, 0x84, 0x5b, 0x8c, 0xfc, 0x8c, 0xba, 0x46, 0x09, 0x75, 0xaf, 0x7b, 0x74, 0x54, 0xcf, 0xe2,
+	0x2f, 0x02, 0x13, 0x41, 0x9d, 0x0a, 0x63, 0x66, 0x14, 0xc6, 0xd4, 0x24, 0x63, 0x66, 0x43, 0xc6,
+	0xcc, 0x6d, 0xd6, 0xa0, 0xc2, 0x03, 0x72, 0x32, 0xb5, 0x2d, 0xc7, 0xc6, 0xbf, 0xd3, 0x00, 0x7a,
+	0x6f, 0x6c, 0x49, 0x15, 0x8f, 0xa0, 0x38, 0xe0, 0xe0, 0x0d, 0x8d, 0xb1, 0xe1, 0xd5, 0xc4, 0x18,
+	0x1b, 0x52, 0x0b, 0x3d, 0x86, 0xa2, 0x37, 0x1d, 0x0c, 0x88, 0x27, 0xe9, 0xf3, 0x07, 0x71, 0x5a,
+	0x10, 0x27, 0xdc, 0x90, 0x7a, 0xd4, 0xe4, 0xa5, 0x69, 0x8d, 0xa6, 0x8c, 0x4c, 0x2f, 0x37, 0x11,
+	0x7a, 0xf8, 0x37, 0x1a, 0x94, 0x99, 0x97, 0xa9, 0xb8, 0xe8, 0x26, 0x94, 0x98, 0x0f, 0x64, 0x28,
+	0xd8, 0x68, 0xd1, 0x08, 0x05, 0xe8, 0x27, 0x50, 0x92, 0x29, 0xeb, 0x09, 0xc7, 0x1a, 0xc9, 0xb0,
+	0x07, 0x13, 0x23, 0x54, 0xc5, 0xbb, 0x70, 0x85, 0x45, 0x65, 0xe0, 0x5b, 0x4e, 0x10, 0x47, 0xf5,
+	0xcb, 0xae, 0xc5, 0xbe, 0xec, 0x3a, 0x2c, 0x4e, 0xce, 0x2e, 0x3c, 0x6b, 0x60, 0x8e, 0x84, 0x17,
+	0xc1, 0x18, 0x7f, 0x0d, 0x48, 0x05, 0x4b, 0xf5, 0x31, 0xa8, 0x42, 0x79, 0xdb, 0xf4, 0xce, 0x84,
+	0x4b, 0xf8, 0x05, 0x54, 0xf8, 0x30, 0x55, 0x0c, 0x11, 0xe4, 0xcf, 0x4c, 0xef, 0x8c, 0x39, 0x5e,
+	0x35, 0xd8, 0x33, 0xbe, 0x02, 0x4b, 0x47, 0xb6, 0x39, 0xf1, 0xce, 0x1c, 0x49, 0xae, 0xb4, 0x6e,
+	0xab, 0x87, 0xb2, 0x54, 0x33, 0x3e, 0x80, 0x25, 0x97, 0x8c, 0x4d, 0xcb, 0xb6, 0xec, 0xd3, 0x93,
+	0xfe, 0x85, 0x4f, 0x3c, 0x51, 0xd6, 0xd5, 0x02, 0xf1, 0x26, 0x95, 0x52, 0xd7, 0xfa, 0x23, 0xa7,
+	0x2f, 0x8e, 0x38, 0x7b, 0xc6, 0x7f, 0xd0, 0xa0, 0xf2, 0xdc, 0xf4, 0x07, 0x32, 0x0a, 0x68, 0x07,
+	0x6a, 0xc1, 0xc1, 0x66, 0x12, 0xe1, 0x4b, 0x8c, 0xe1, 0x99, 0x4d, 0x5b, 0x1c, 0x74, 0xc9, 0xf0,
+	0xd5, 0x81, 0x2a, 0x60, 0x50, 0xa6, 0x3d, 0x20, 0xa3, 0x00, 0x2a, 0x3b, 0x1f, 0x8a, 0x29, 0xaa,
+	0x50, 0xaa, 0x60, 0x73, 0x29, 0xfc, 0xfa, 0xf1, 0x63, 0xf9, 0x9d, 0x06, 0x68, 0xd6, 0x87, 0xef,
+	0x5b, 0x75, 0xde, 0x83, 0x9a, 0xe7, 0x9b, 0xae, 0x7f, 0x12, 0x2b, 0x7a, 0xab, 0x4c, 0x1a, 0x90,
+	0xd3, 0x03, 0x58, 0x9a, 0xb8, 0xce, 0xa9, 0x4b, 0x3c, 0xef, 0xc4, 0x76, 0x7c, 0xeb, 0xe5, 0x05,
+	0x23, 0xc4, 0x45, 0xa3, 0x26, 0xc5, 0xfb, 0x4c, 0x8a, 0x1f, 0x49, 0xa7, 0x54, 0xe7, 0xd1, 0x75,
+	0x58, 0x7c, 0x4d, 0xa5, 0xb2, 0x1c, 0xcf, 0x19, 0x45, 0x36, 0xde, 0x19, 0xe2, 0xbf, 0x6b, 0x50,
+	0x15, 0xe1, 0x4f, 0x95, 0x03, 0xea, 0x14, 0xd9, 0xc8, 0x14, 0xb4, 0xc0, 0xe0, 0xdb, 0x32, 0x14,
+	0xa5, 0x99, 0x1c, 0xd2, 0x73, 0xc6, 0xa3, 0x4c, 0x86, 0x62, 0x3d, 0xc1, 0x18, 0x7d, 0x0c, 0xf5,
+	0x01, 0x3f, 0x67, 0x31, 0x82, 0x37, 0x96, 0x84, 0x3c, 0x88, 0xce, 0x3d, 0x28, 0x90, 0x73, 0x62,
+	0xfb, 0x5e, 0xa3, 0xcc, 0x48, 0xa1, 0x2a, 0xeb, 0xc3, 0x2e, 0x95, 0x1a, 0xe2, 0x25, 0xfe, 0x31,
+	0x5c, 0xd9, 0xa3, 0x85, 0xdc, 0x96, 0x6b, 0xda, 0x6a, 0x49, 0xd8, 0xeb, 0xed, 0x89, 0xa8, 0xe4,
+	0xfc, 0xde, 0x1e, 0xaa, 0x41, 0x76, 0xa7, 0x23, 0xd6, 0x90, 0xb5, 0x3a, 0xf8, 0x97, 0x1a, 0x20,
+	0xd5, 0x2e, 0x55, 0x98, 0x62, 0xe0, 0x72, 0xfa, 0x5c, 0x38, 0xfd, 0x0a, 0x2c, 0x10, 0xd7, 0x75,
+	0x5c, 0x16, 0x90, 0x92, 0xc1, 0x07, 0xf8, 0xae, 0xf0, 0xc1, 0x20, 0xe7, 0xce, 0xab, 0x20, 0xd9,
+	0x38, 0x9a, 0x16, 0xb8, 0xba, 0x0b, 0xcb, 0x11, 0xad, 0x54, 0xe4, 0xf4, 0x00, 0xae, 0x32, 0xb0,
+	0x5d, 0x42, 0x26, 0xad, 0x91, 0x75, 0x3e, 0x77, 0xd6, 0x09, 0x5c, 0x8b, 0x2b, 0xfe, 0x7f, 0x63,
+	0x84, 0xcf, 0xa0, 0xf0, 0x84, 0x35, 0x8c, 0x8a, 0x2f, 0x79, 0xa6, 0x8b, 0x20, 0x6f, 0x9b, 0x63,
+	0x5e, 0xce, 0x97, 0x0c, 0xf6, 0xcc, 0xd8, 0x9c, 0x10, 0xf7, 0x99, 0xb1, 0xc7, 0xbf, 0x1a, 0x25,
+	0x23, 0x18, 0xa3, 0x55, 0xda, 0xaa, 0x5a, 0xc4, 0xf6, 0xd9, 0xdb, 0x3c, 0x7b, 0xab, 0x48, 0x70,
+	0x13, 0xea, 0x7c, 0xa6, 0xd6, 0x70, 0xa8, 0x7c, 0x39, 0x02, 0x3c, 0x2d, 0x8a, 0x87, 0x5f, 0xc3,
+	0x15, 0x45, 0x3f, 0x55, 0x18, 0x1e, 0x42, 0x81, 0x77, 0xc5, 0x82, 0xb4, 0x56, 0xa2, 0x56, 0x7c,
+	0x1a, 0x43, 0xe8, 0xe0, 0x7b, 0xb0, 0x2c, 0x24, 0x64, 0xec, 0x24, 0xed, 0x15, 0x8b, 0x0f, 0xde,
+	0x83, 0x95, 0xa8, 0x5a, 0xaa, 0x14, 0x69, 0xc9, 0x49, 0x9f, 0x4d, 0x86, 0x0a, 0x07, 0xc6, 0x37,
+	0x45, 0x0d, 0x58, 0x36, 0x16, 0xb0, 0xc0, 0x21, 0x09, 0x91, 0xca, 0xa1, 0x65, 0x19, 0xfe, 0x3d,
+	0xcb, 0x0b, 0xbe, 0x74, 0x6f, 0x01, 0xa9, 0xc2, 0x54, 0x9b, 0xd2, 0x84, 0x22, 0x0f, 0xb8, 0x2c,
+	0xa6, 0x92, 0x77, 0x45, 0x2a, 0x51, 0x87, 0x3a, 0xe4, 0xa5, 0x6b, 0x9e, 0x8e, 0x49, 0xc0, 0x39,
+	0xb4, 0x84, 0x50, 0x85, 0xa9, 0x56, 0xfc, 0x67, 0x0d, 0x2a, 0xad, 0x91, 0xe9, 0x8e, 0x65, 0xf0,
+	0xbf, 0x84, 0x02, 0xaf, 0x4d, 0x44, 0xfd, 0x7e, 0x3f, 0x0a, 0xa3, 0xea, 0xf2, 0x41, 0x8b, 0x57,
+	0x32, 0xc2, 0x8a, 0x6e, 0x96, 0xb8, 0x8c, 0xe9, 0xc4, 0x2e, 0x67, 0x3a, 0xe8, 0x53, 0x58, 0x30,
+	0xa9, 0x09, 0x3b, 0x8b, 0xb5, 0x78, 0x55, 0xc8, 0xd0, 0x7a, 0x17, 0x13, 0x62, 0x70, 0x2d, 0xfc,
+	0x39, 0x94, 0x95, 0x19, 0x68, 0xb1, 0xbb, 0xd5, 0xed, 0xd5, 0x33, 0xa8, 0x02, 0x8b, 0xad, 0x76,
+	0x6f, 0xe7, 0x98, 0xd7, 0xc0, 0x35, 0x80, 0x4e, 0x37, 0x18, 0x67, 0xf1, 0x0b, 0x61, 0x25, 0x4e,
+	0xb8, 0xea, 0x8f, 0x36, 0xcf, 0x9f, 0xec, 0x07, 0xf9, 0xf3, 0x06, 0xaa, 0x62, 0xf9, 0xa9, 0x72,
+	0xe0, 0x31, 0x14, 0x18, 0x9e, 0x4c, 0x81, 0xeb, 0x09, 0xd3, 0xca, 0xd3, 0xc9, 0x15, 0xf1, 0x12,
+	0x54, 0x8f, 0x7c, 0xd3, 0x9f, 0x7a, 0x32, 0x05, 0xfe, 0xa4, 0x41, 0x4d, 0x4a, 0xd2, 0x76, 0xef,
+	0xb2, 0x45, 0xe2, 0x9c, 0x17, 0x34, 0x48, 0xd7, 0xa0, 0x30, 0xec, 0x1f, 0x59, 0x6f, 0xe5, 0x2d,
+	0x86, 0x18, 0x51, 0xf9, 0x88, 0xcf, 0xc3, 0xaf, 0xd0, 0xc4, 0x88, 0xd6, 0xde, 0xae, 0xf9, 0xd2,
+	0xdf, 0xb1, 0x87, 0xe4, 0x0d, 0xfb, 0xd2, 0xe6, 0x8d, 0x50, 0xc0, 0xca, 0x65, 0x71, 0xd5, 0xc6,
+	0xfa, 0x27, 0xf5, 0xea, 0x6d, 0x19, 0xae, 0xb4, 0xa6, 0xfe, 0x59, 0xd7, 0x36, 0xfb, 0x23, 0x49,
+	0x02, 0x78, 0x05, 0x10, 0x15, 0x76, 0x2c, 0x4f, 0x95, 0x76, 0x61, 0x99, 0x4a, 0x89, 0xed, 0x5b,
+	0x03, 0x85, 0x31, 0x24, 0x6d, 0x6b, 0x31, 0xda, 0x36, 0x3d, 0xef, 0xb5, 0xe3, 0x0e, 0xc5, 0xd2,
+	0x82, 0x31, 0xee, 0x70, 0xf0, 0x67, 0x5e, 0x84, 0x98, 0xbf, 0x2f, 0xca, 0x7a, 0x88, 0xb2, 0x45,
+	0xfc, 0x4b, 0x50, 0xf0, 0x27, 0x70, 0x55, 0x6a, 0x8a, 0x1e, 0xfa, 0x12, 0xe5, 0x03, 0xb8, 0x25,
+	0x95, 0xdb, 0x67, 0xb4, 0xd0, 0x3b, 0x14, 0x13, 0xfe, 0xb7, 0x7e, 0x6e, 0x42, 0x23, 0xf0, 0x93,
+	0xd5, 0x20, 0xce, 0x48, 0x75, 0x60, 0xea, 0x89, 0x9c, 0x29, 0x19, 0xec, 0x99, 0xca, 0x5c, 0x67,
+	0x14, 0x7c, 0x04, 0xe9, 0x33, 0x6e, 0xc3, 0x75, 0x89, 0x21, 0xaa, 0x83, 0x28, 0xc8, 0x8c, 0x43,
+	0x49, 0x20, 0x22, 0x60, 0xd4, 0xf4, 0xf2, 0xb0, 0xab, 0x9a, 0xd1, 0xd0, 0x32, 0x4c, 0x4d, 0xc1,
+	0x14, 0xa1, 0xa5, 0x9a, 0x33, 0xa1, 0x9d, 0x51, 0xfe, 0x39, 0xac, 0x06, 0xb0, 0x34, 0x12, 0x87,
+	0xc4, 0x1d, 0x5b, 0x9e, 0xa7, 0xb4, 0x75, 0x49, 0x4b, 0xb9, 0x0f, 0xf9, 0x09, 0x11, 0x2c, 0x51,
+	0xde, 0x40, 0x4d, 0x7e, 0x89, 0xdd, 0x54, 0x8c, 0xd9, 0x7b, 0xbc, 0x05, 0xb7, 0x25, 0x3a, 0x8f,
+	0x51, 0x22, 0x7c, 0xdc, 0x29, 0x59, 0xf2, 0xf3, 0x40, 0xd1, 0x47, 0x4a, 0xf0, 0xea, 0x81, 0x48,
+	0x45, 0xf0, 0xbb, 0xfc, 0xc4, 0x04, 0xe7, 0x28, 0x15, 0x58, 0x1f, 0x56, 0xa2, 0xc7, 0x2f, 0x15,
+	0xf7, 0xac, 0xc0, 0x82, 0xef, 0xbc, 0x22, 0x92, 0x79, 0xf8, 0x40, 0x3a, 0x1c, 0x9c, 0xcd, 0x54,
+	0x0e, 0x9b, 0x21, 0x18, 0xcb, 0xa3, 0xb4, 0xfe, 0xd2, 0x0d, 0x93, 0x45, 0x08, 0x1f, 0xe0, 0x7d,
+	0xb8, 0x16, 0x3f, 0xdb, 0xa9, 0x5c, 0x3e, 0xe6, 0x39, 0x9a, 0x74, 0xfc, 0x53, 0xe1, 0x3e, 0x0d,
+	0x4f, 0xb0, 0xc2, 0x02, 0xa9, 0x20, 0x0d, 0xd0, 0x93, 0x48, 0xe1, 0x7f, 0x91, 0xaf, 0x01, 0x47,
+	0xa4, 0x02, 0xf3, 0x42, 0xb0, 0xf4, 0xdb, 0x1f, 0xd2, 0x40, 0xee, 0x52, 0x1a, 0x10, 0x09, 0xa1,
+	0x32, 0x52, 0xaa, 0x45, 0x3c, 0x0f, 0x69, 0x65, 0x86, 0xb4, 0x52, 0x01, 0xbf, 0x80, 0xb5, 0xf9,
+	0x7c, 0x95, 0x06, 0xf9, 0x87, 0x18, 0x4a, 0x41, 0xf5, 0xa4, 0xfc, 0x52, 0x54, 0x86, 0xe2, 0xfe,
+	0xc1, 0xd1, 0x61, 0xab, 0xdd, 0xad, 0x6b, 0x1b, 0xff, 0xc8, 0x42, 0x76, 0xf7, 0x18, 0x6d, 0xc2,
+	0x02, 0xbf, 0xe9, 0xbe, 0xe4, 0x87, 0x00, 0xfd, 0xb2, 0x3b, 0x73, 0x9c, 0x41, 0x5f, 0x40, 0xee,
+	0x70, 0xea, 0xa3, 0xb9, 0xbf, 0x04, 0xe8, 0xf3, 0xef, 0xcb, 0x71, 0x06, 0xf5, 0xa0, 0xac, 0x5c,
+	0x6c, 0xa3, 0xf7, 0xfe, 0x12, 0xa0, 0xbf, 0xff, 0xd2, 0x9c, 0xfb, 0xd4, 0x7b, 0x63, 0xc7, 0x7d,
+	0x0a, 0x2f, 0x62, 0xe3, 0x3e, 0x29, 0x97, 0x9f, 0x38, 0x83, 0xf6, 0xc5, 0x85, 0xfa, 0xc0, 0x47,
+	0xb7, 0x13, 0xee, 0x67, 0xd5, 0x9b, 0x48, 0x7d, 0x6d, 0xbe, 0x82, 0xc4, 0xdb, 0x38, 0x80, 0x05,
+	0x76, 0x4b, 0x83, 0xbe, 0x92, 0x0f, 0x7a, 0xc2, 0x1d, 0xd6, 0x9c, 0x70, 0x47, 0xee, 0x77, 0x70,
+	0x66, 0x5d, 0xfb, 0x4c, 0xdb, 0xf8, 0x2e, 0x0b, 0x0b, 0xac, 0x6b, 0x47, 0x4f, 0x01, 0xc2, 0xeb,
+	0x8d, 0xb8, 0xb7, 0x33, 0x17, 0x26, 0x71, 0x6f, 0x67, 0x6f, 0x46, 0xf8, 0x8e, 0x28, 0xf7, 0x10,
+	0x28, 0xc9, 0x24, 0x72, 0x91, 0x11, 0xdf, 0x91, 0x84, 0x4b, 0x0c, 0x9c, 0x41, 0x26, 0xd4, 0xa2,
+	0xf7, 0x0c, 0xe8, 0x4e, 0x82, 0x59, 0xfc, 0xba, 0x42, 0xbf, 0x7b, 0xb9, 0x52, 0x24, 0x2a, 0x7f,
+	0xcd, 0x42, 0xb1, 0xcd, 0x7f, 0xa8, 0x46, 0xfb, 0x50, 0x0a, 0x5a, 0x79, 0xb4, 0x9a, 0xd4, 0xe6,
+	0x85, 0x35, 0x90, 0x7e, 0x7b, 0xee, 0xfb, 0xc0, 0xfd, 0xe7, 0x50, 0x51, 0x5b, 0x6f, 0xf4, 0x51,
+	0x62, 0xe7, 0xa8, 0x76, 0xef, 0x3a, 0xbe, 0x4c, 0x65, 0x16, 0x98, 0xb7, 0xd0, 0xc9, 0xc0, 0x91,
+	0x0e, 0x3d, 0x19, 0x38, 0xda, 0x81, 0xe3, 0x0c, 0xcd, 0x8c, 0xb0, 0x71, 0x46, 0x89, 0x4b, 0x54,
+	0xfa, 0xec, 0x78, 0x66, 0xcc, 0xf6, 0xdc, 0x38, 0xb3, 0xf1, 0xef, 0x2c, 0x94, 0x9f, 0x98, 0x96,
+	0xed, 0x13, 0xdb, 0xb4, 0x07, 0x84, 0xb2, 0x07, 0x23, 0x9a, 0x78, 0x3a, 0xab, 0x6d, 0x6a, 0x3c,
+	0x9d, 0x23, 0x3d, 0x1c, 0xce, 0xa0, 0x2e, 0x14, 0x78, 0x2b, 0x85, 0x62, 0x8a, 0x91, 0x96, 0x4b,
+	0xbf, 0x99, 0xfc, 0x52, 0x5d, 0x6d, 0xd8, 0x95, 0xc7, 0x57, 0x3b, 0xd3, 0xc4, 0xeb, 0x6b, 0xf3,
+	0x15, 0x02, 0xc8, 0x9f, 0x41, 0x7e, 0xdb, 0xf4, 0xce, 0x50, 0x8c, 0x2a, 0x94, 0x3b, 0x7f, 0x5d,
+	0x4f, 0x7a, 0x15, 0x00, 0x3c, 0x81, 0x45, 0x79, 0x47, 0x8f, 0x6e, 0xc5, 0xfc, 0x8f, 0xde, 0xe7,
+	0xeb, 0xab, 0xf3, 0x5e, 0x4b, 0xb0, 0xcf, 0xb4, 0x8d, 0xdf, 0x03, 0xe4, 0xe9, 0x17, 0x83, 0xae,
+	0x35, 0x2c, 0x50, 0xe3, 0x6b, 0x9d, 0xe9, 0xe5, 0xe2, 0x6b, 0x9d, 0xad, 0x6d, 0xf9, 0x99, 0x57,
+	0xea, 0x54, 0x94, 0x60, 0x12, 0x6d, 0x05, 0xe3, 0x67, 0x3e, 0xa1, 0xc8, 0xe5, 0xb9, 0xad, 0x16,
+	0xac, 0x28, 0xc1, 0x28, 0xd6, 0x4b, 0xc6, 0x73, 0x3b, 0xa9, 0xde, 0xc5, 0x19, 0x74, 0x08, 0x45,
+	0x51, 0xa1, 0x26, 0xb9, 0x1a, 0x6d, 0x2c, 0x93, 0x5c, 0x8d, 0x95, 0xb7, 0x21, 0xe2, 0x16, 0xf1,
+	0xe7, 0x21, 0x86, 0x9d, 0xd0, 0x3c, 0x44, 0xa5, 0xc8, 0xc1, 0x19, 0xf4, 0x0d, 0x40, 0x58, 0x95,
+	0xc6, 0xc9, 0x2e, 0xb1, 0x1f, 0x8d, 0x93, 0x5d, 0x72, 0x61, 0x8b, 0x33, 0xe8, 0x5b, 0x40, 0xb3,
+	0x05, 0x2a, 0xfa, 0x24, 0xd9, 0x3a, 0xb1, 0x8b, 0xd5, 0x1f, 0x7e, 0x98, 0x72, 0x30, 0x65, 0x1f,
+	0xaa, 0x91, 0xda, 0x15, 0xdd, 0x9f, 0x13, 0x83, 0x58, 0x8b, 0xab, 0x3f, 0x78, 0xaf, 0x5e, 0x30,
+	0x07, 0x81, 0x5a, 0xb4, 0x98, 0x45, 0x73, 0x8c, 0x67, 0x7a, 0x60, 0x7d, 0xfd, 0xfd, 0x8a, 0xea,
+	0x56, 0x8b, 0xfa, 0x36, 0x69, 0xab, 0xa3, 0xed, 0x71, 0xd2, 0x56, 0xc7, 0x8a, 0xe3, 0x10, 0x71,
+	0x4e, 0xf2, 0x44, 0xdb, 0xe8, 0x79, 0x88, 0x33, 0xc9, 0x13, 0x56, 0xb0, 0x49, 0xc9, 0x33, 0xd3,
+	0x71, 0x27, 0x25, 0xcf, 0x6c, 0x11, 0x8c, 0x33, 0xc8, 0x87, 0xe5, 0x84, 0x62, 0x16, 0x3d, 0x9c,
+	0xe3, 0x56, 0x62, 0xa3, 0xae, 0x7f, 0xfa, 0x81, 0xda, 0xc1, 0xac, 0xaf, 0x61, 0x25, 0xa9, 0xd2,
+	0x45, 0x73, 0x80, 0xe6, 0x74, 0xf0, 0x7a, 0xf3, 0x43, 0xd5, 0xe5, 0xc4, 0x9b, 0x95, 0x3f, 0xbe,
+	0x5b, 0xd5, 0xfe, 0xf2, 0x6e, 0x55, 0xfb, 0xdb, 0xbb, 0x55, 0xad, 0x5f, 0x60, 0xff, 0xed, 0xed,
+	0x47, 0xff, 0x09, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xd6, 0x18, 0xf9, 0x5f, 0x27, 0x00, 0x00,
 }

etcdserver/etcdserverpb/rpc.proto

@@ -229,7 +229,7 @@ message DeleteRangeResponse {
   int64 deleted = 2;
 }
 
-message RequestUnion {
+message RequestOp {
   // request is a union of request types accepted by a transaction.
   oneof request {
     RangeRequest request_range = 1;
@@ -238,7 +238,7 @@ message RequestUnion {
   }
 }
 
-message ResponseUnion {
+message ResponseOp {
   // response is a union of response types returned by a transaction.
   oneof response {
     RangeResponse response_range = 1;
@@ -300,9 +300,9 @@ message TxnRequest {
   // and the response will contain their respective responses in order.
   repeated Compare compare = 1;
   // success is a list of requests which will be applied when compare evaluates to true.
-  repeated RequestUnion success = 2;
+  repeated RequestOp success = 2;
   // failure is a list of requests which will be applied when compare evaluates to false.
-  repeated RequestUnion failure = 3;
+  repeated RequestOp failure = 3;
 }
 
 message TxnResponse {
@@ -311,7 +311,7 @@ message TxnResponse {
   bool succeeded = 2;
   // responses is a list of responses corresponding to the results from applying
   // success if succeeded is true or failure if succeeded is false.
-  repeated ResponseUnion responses = 3;
+  repeated ResponseOp responses = 3;
 }
 
 // CompactionRequest compacts the key-value store up to a given revision. All superseded keys

etcdserver/quota.go

@@ -86,7 +86,7 @@ func (b *backendQuota) Cost(v interface{}) int {
 
 func costPut(r *pb.PutRequest) int { return kvOverhead + len(r.Key) + len(r.Value) }
 
-func costTxnReq(u *pb.RequestUnion) int {
+func costTxnReq(u *pb.RequestOp) int {
 	r := u.GetRequestPut()
 	if r == nil {
 		return 0

integration/v3_grpc_test.go

@@ -157,8 +157,8 @@ func TestV3TxnTooManyOps(t *testing.T) {
 	}
 	addSuccessOps := func(txn *pb.TxnRequest) {
 		txn.Success = append(txn.Success,
-			&pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestPut{
+			&pb.RequestOp{
+				Request: &pb.RequestOp_RequestPut{
 					RequestPut: &pb.PutRequest{
 						Key:   keyf(),
 						Value: []byte("bar"),
@@ -168,8 +168,8 @@ func TestV3TxnTooManyOps(t *testing.T) {
 	}
 	addFailureOps := func(txn *pb.TxnRequest) {
 		txn.Failure = append(txn.Failure,
-			&pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestPut{
+			&pb.RequestOp{
+				Request: &pb.RequestOp_RequestPut{
 					RequestPut: &pb.PutRequest{
 						Key:   keyf(),
 						Value: []byte("bar"),
@@ -202,20 +202,20 @@ func TestV3TxnDuplicateKeys(t *testing.T) {
 	clus := NewClusterV3(t, &ClusterConfig{Size: 3})
 	defer clus.Terminate(t)
 
-	putreq := &pb.RequestUnion{Request: &pb.RequestUnion_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")}}}
-	delKeyReq := &pb.RequestUnion{Request: &pb.RequestUnion_RequestDeleteRange{
+	putreq := &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("def")}}}
+	delKeyReq := &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{
 		RequestDeleteRange: &pb.DeleteRangeRequest{
 			Key: []byte("abc"),
 		},
 	},
 	}
-	delInRangeReq := &pb.RequestUnion{Request: &pb.RequestUnion_RequestDeleteRange{
+	delInRangeReq := &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{
 		RequestDeleteRange: &pb.DeleteRangeRequest{
 			Key: []byte("a"), RangeEnd: []byte("b"),
 		},
 	},
 	}
-	delOutOfRangeReq := &pb.RequestUnion{Request: &pb.RequestUnion_RequestDeleteRange{
+	delOutOfRangeReq := &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{
 		RequestDeleteRange: &pb.DeleteRangeRequest{
 			Key: []byte("abb"), RangeEnd: []byte("abc"),
 		},
@@ -224,32 +224,32 @@ func TestV3TxnDuplicateKeys(t *testing.T) {
 
 	kvc := toGRPC(clus.RandClient()).KV
 	tests := []struct {
-		txnSuccess []*pb.RequestUnion
+		txnSuccess []*pb.RequestOp
 
 		werr error
 	}{
 		{
-			txnSuccess: []*pb.RequestUnion{putreq, putreq},
+			txnSuccess: []*pb.RequestOp{putreq, putreq},
 
 			werr: rpctypes.ErrGRPCDuplicateKey,
 		},
 		{
-			txnSuccess: []*pb.RequestUnion{putreq, delKeyReq},
+			txnSuccess: []*pb.RequestOp{putreq, delKeyReq},
 
 			werr: rpctypes.ErrGRPCDuplicateKey,
 		},
 		{
-			txnSuccess: []*pb.RequestUnion{putreq, delInRangeReq},
+			txnSuccess: []*pb.RequestOp{putreq, delInRangeReq},
 
 			werr: rpctypes.ErrGRPCDuplicateKey,
 		},
 		{
-			txnSuccess: []*pb.RequestUnion{delKeyReq, delInRangeReq, delKeyReq, delInRangeReq},
+			txnSuccess: []*pb.RequestOp{delKeyReq, delInRangeReq, delKeyReq, delInRangeReq},
 
 			werr: nil,
 		},
 		{
-			txnSuccess: []*pb.RequestUnion{putreq, delOutOfRangeReq},
+			txnSuccess: []*pb.RequestOp{putreq, delOutOfRangeReq},
 
 			werr: nil,
 		},
@@ -276,8 +276,8 @@ func TestV3TxnRevision(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	txnget := &pb.RequestUnion{Request: &pb.RequestUnion_RequestRange{RequestRange: &pb.RangeRequest{Key: []byte("abc")}}}
-	txn := &pb.TxnRequest{Success: []*pb.RequestUnion{txnget}}
+	txnget := &pb.RequestOp{Request: &pb.RequestOp_RequestRange{RequestRange: &pb.RangeRequest{Key: []byte("abc")}}}
+	txn := &pb.TxnRequest{Success: []*pb.RequestOp{txnget}}
 	tresp, err := kvc.Txn(context.TODO(), txn)
 	if err != nil {
 		t.Fatal(err)
@@ -288,8 +288,8 @@ func TestV3TxnRevision(t *testing.T) {
 		t.Fatalf("got rev %d, wanted rev %d", tresp.Header.Revision, presp.Header.Revision)
 	}
 
-	txnput := &pb.RequestUnion{Request: &pb.RequestUnion_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("123")}}}
-	txn = &pb.TxnRequest{Success: []*pb.RequestUnion{txnput}}
+	txnput := &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: &pb.PutRequest{Key: []byte("abc"), Value: []byte("123")}}}
+	txn = &pb.TxnRequest{Success: []*pb.RequestOp{txnput}}
 	tresp, err = kvc.Txn(context.TODO(), txn)
 	if err != nil {
 		t.Fatal(err)
@@ -320,8 +320,8 @@ func TestV3PutMissingLease(t *testing.T) {
 		// txn success case
 		func() {
 			txn := &pb.TxnRequest{}
-			txn.Success = append(txn.Success, &pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestPut{
+			txn.Success = append(txn.Success, &pb.RequestOp{
+				Request: &pb.RequestOp_RequestPut{
 					RequestPut: preq}})
 			if tresp, err := kvc.Txn(context.TODO(), txn); err == nil {
 				t.Errorf("succeeded txn success. req: %v. resp: %v", txn, tresp)
@@ -330,8 +330,8 @@ func TestV3PutMissingLease(t *testing.T) {
 		// txn failure case
 		func() {
 			txn := &pb.TxnRequest{}
-			txn.Failure = append(txn.Failure, &pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestPut{
+			txn.Failure = append(txn.Failure, &pb.RequestOp{
+				Request: &pb.RequestOp_RequestPut{
 					RequestPut: preq}})
 			cmp := &pb.Compare{
 				Result: pb.Compare_GREATER,
@@ -347,11 +347,11 @@ func TestV3PutMissingLease(t *testing.T) {
 		func() {
 			txn := &pb.TxnRequest{}
 			rreq := &pb.RangeRequest{Key: []byte("bar")}
-			txn.Success = append(txn.Success, &pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestRange{
+			txn.Success = append(txn.Success, &pb.RequestOp{
+				Request: &pb.RequestOp_RequestRange{
 					RequestRange: rreq}})
-			txn.Failure = append(txn.Failure, &pb.RequestUnion{
-				Request: &pb.RequestUnion_RequestPut{
+			txn.Failure = append(txn.Failure, &pb.RequestOp{
+				Request: &pb.RequestOp_RequestPut{
 					RequestPut: preq}})
 			if tresp, err := kvc.Txn(context.TODO(), txn); err != nil {
 				t.Errorf("failed good txn. req: %v. resp: %v", txn, tresp)
@@ -491,13 +491,13 @@ func TestV3TxnInvaildRange(t *testing.T) {
 
 	// future rev
 	txn := &pb.TxnRequest{}
-	txn.Success = append(txn.Success, &pb.RequestUnion{
-		Request: &pb.RequestUnion_RequestPut{
+	txn.Success = append(txn.Success, &pb.RequestOp{
+		Request: &pb.RequestOp_RequestPut{
 			RequestPut: preq}})
 
 	rreq := &pb.RangeRequest{Key: []byte("foo"), Revision: 100}
-	txn.Success = append(txn.Success, &pb.RequestUnion{
-		Request: &pb.RequestUnion_RequestRange{
+	txn.Success = append(txn.Success, &pb.RequestOp{
+		Request: &pb.RequestOp_RequestRange{
 			RequestRange: rreq}})
 
 	if _, err := kvc.Txn(context.TODO(), txn); err != rpctypes.ErrGRPCFutureRev {
@@ -505,7 +505,7 @@ func TestV3TxnInvaildRange(t *testing.T) {
 	}
 
 	// compacted rev
-	tv, _ := txn.Success[1].Request.(*pb.RequestUnion_RequestRange)
+	tv, _ := txn.Success[1].Request.(*pb.RequestOp_RequestRange)
 	tv.RequestRange.Revision = 1
 	if _, err := kvc.Txn(context.TODO(), txn); err != rpctypes.ErrGRPCCompacted {
 		t.Errorf("err = %v, want %v", err, rpctypes.ErrGRPCCompacted)
@@ -584,8 +584,8 @@ func TestV3StorageQuotaAPI(t *testing.T) {
 	}
 
 	// test big txn
-	puttxn := &pb.RequestUnion{
-		Request: &pb.RequestUnion_RequestPut{
+	puttxn := &pb.RequestOp{
+		Request: &pb.RequestOp_RequestPut{
 			RequestPut: &pb.PutRequest{
 				Key:   key,
 				Value: bigbuf,

integration/v3_watch_test.go

@@ -676,8 +676,8 @@ func testV3WatchMultipleEventsTxn(t *testing.T, startRev int64) {
 	kvc := toGRPC(clus.RandClient()).KV
 	txn := pb.TxnRequest{}
 	for i := 0; i < 3; i++ {
-		ru := &pb.RequestUnion{}
-		ru.Request = &pb.RequestUnion_RequestPut{
+		ru := &pb.RequestOp{}
+		ru.Request = &pb.RequestOp_RequestPut{
 			RequestPut: &pb.PutRequest{
 				Key: []byte(fmt.Sprintf("foo%d", i)), Value: []byte("bar")}}
 		txn.Success = append(txn.Success, ru)

lease/leasepb/lease.pb.go

@@ -319,13 +319,13 @@ var (
 )
 
 var fileDescriptorLease = []byte{
-	// 117 bytes of a gzipped FileDescriptorProto
+	// 122 bytes of a gzipped FileDescriptorProto
 	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, 0x49, 0x93, 0x8b, 0xd5, 0x07, 0xa4,
 	0x40, 0x88, 0x8f, 0x8b, 0xc9, 0xd3, 0x45, 0x82, 0x51, 0x81, 0x51, 0x83, 0x39, 0x88, 0x29, 0xd3,
 	0x45, 0x48, 0x80, 0x8b, 0x39, 0x24, 0xc4, 0x47, 0x82, 0x09, 0x2c, 0xc0, 0x5c, 0x12, 0xe2, 0xe3,
-	0x24, 0x72, 0xe2, 0xa1, 0x1c, 0xc3, 0x05, 0x20, 0x3e, 0xf1, 0x48, 0x8e, 0xf1, 0x02, 0x10, 0x3f,
-	0x00, 0xe2, 0x24, 0x36, 0xb0, 0x39, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x8c, 0x1d, 0x92,
-	0xdc, 0x75, 0x00, 0x00, 0x00,
+	0x24, 0x72, 0xe2, 0xa1, 0x1c, 0xc3, 0x85, 0x87, 0x72, 0x0c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78,
+	0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0x63, 0x12, 0x1b, 0xd8, 0x1c, 0x63, 0x40, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0x8c, 0x1d, 0x92, 0xdc, 0x75, 0x00, 0x00, 0x00,
 }

mvcc/mvccpb/kv.pb.go

@@ -659,23 +659,23 @@ var (
 )
 
 var fileDescriptorKv = []byte{
-	// 274 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x44, 0x90, 0xc1, 0x4a, 0xc3, 0x40,
-	0x10, 0x86, 0xbb, 0x4d, 0x93, 0xd6, 0x69, 0xa9, 0x61, 0x09, 0xb8, 0x78, 0x28, 0x31, 0x17, 0x05,
-	0x21, 0x42, 0x7d, 0x03, 0x31, 0x27, 0x3d, 0xc8, 0x12, 0xbd, 0x4a, 0x1a, 0x87, 0x52, 0xd2, 0x76,
-	0x43, 0x1a, 0x17, 0xf3, 0x52, 0x3e, 0x47, 0x8f, 0x7d, 0x04, 0xf5, 0x49, 0xdc, 0xcc, 0x9a, 0x7a,
-	0x98, 0x65, 0xe6, 0xff, 0xfe, 0x65, 0xff, 0x59, 0x18, 0x15, 0x3a, 0x2e, 0x2b, 0x55, 0x2b, 0xee,
-	0x6d, 0x74, 0x9e, 0x97, 0x8b, 0xf3, 0x60, 0xa9, 0x96, 0x8a, 0xa4, 0x9b, 0xb6, 0xb3, 0x34, 0xfa,
-	0x64, 0x30, 0x7a, 0xc0, 0xe6, 0x25, 0x5b, 0xbf, 0x23, 0xf7, 0xc1, 0x29, 0xb0, 0x11, 0x2c, 0x64,
-	0x57, 0x13, 0xd9, 0xb6, 0xfc, 0x12, 0x4e, 0xf3, 0x0a, 0xb3, 0x1a, 0x5f, 0x2b, 0xd4, 0xab, 0xdd,
-	0x4a, 0x6d, 0x45, 0xdf, 0x50, 0x47, 0x4e, 0xad, 0x2c, 0xff, 0x54, 0x7e, 0x01, 0x93, 0x8d, 0x7a,
-	0xfb, 0x77, 0x39, 0xe4, 0x1a, 0x1b, 0xed, 0x68, 0x11, 0x30, 0xd4, 0x58, 0x11, 0x1d, 0x10, 0xed,
-	0x46, 0x1e, 0x80, 0xab, 0xdb, 0x00, 0xc2, 0xa5, 0x97, 0xed, 0xd0, 0xaa, 0x6b, 0xcc, 0x76, 0x28,
-	0x3c, 0x72, 0xdb, 0x21, 0xfa, 0x00, 0x37, 0xd1, 0xb8, 0xad, 0xf9, 0x35, 0x0c, 0xea, 0xa6, 0x44,
-	0x4a, 0x3b, 0x9d, 0x9f, 0xc5, 0x76, 0xcd, 0x98, 0xa0, 0x3d, 0x53, 0x83, 0x25, 0x99, 0x78, 0x08,
-	0xfd, 0x42, 0x53, 0xf4, 0xf1, 0xdc, 0xef, 0xac, 0xdd, 0xde, 0xd2, 0xb0, 0x28, 0x84, 0x93, 0xe3,
-	0x25, 0x3e, 0x04, 0xe7, 0xe9, 0x39, 0xf5, 0x7b, 0x1c, 0xc0, 0xbb, 0x4f, 0x1e, 0x93, 0x34, 0xf1,
-	0xd9, 0x5d, 0xb0, 0xff, 0x9e, 0xf5, 0x0e, 0xa6, 0xf6, 0x3f, 0x33, 0x76, 0x30, 0xf5, 0x65, 0x6a,
-	0xe1, 0xd1, 0x3f, 0xde, 0xfe, 0x06, 0x00, 0x00, 0xff, 0xff, 0x71, 0xd2, 0x34, 0xa9, 0x71, 0x01,
-	0x00, 0x00,
+	// 279 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x44, 0x90, 0x41, 0x4a, 0xc3, 0x40,
+	0x14, 0x86, 0x3b, 0x49, 0x93, 0xd6, 0xd7, 0x52, 0xc3, 0x10, 0x30, 0xb8, 0x08, 0x31, 0x1b, 0x0b,
+	0x42, 0x84, 0x7a, 0x03, 0x31, 0x2b, 0x5d, 0xc8, 0x10, 0xdd, 0x4a, 0x9a, 0x3e, 0x4a, 0x49, 0xd3,
+	0x09, 0x69, 0x1c, 0xcc, 0xa5, 0x3c, 0x47, 0x97, 0x3d, 0x82, 0xcd, 0x49, 0x24, 0x6f, 0x4c, 0xdd,
+	0x0c, 0xef, 0xff, 0xff, 0x6f, 0x98, 0xff, 0x0d, 0x8c, 0x73, 0x15, 0x95, 0x95, 0xac, 0x25, 0xb7,
+	0x0b, 0x95, 0x65, 0xe5, 0xf2, 0xda, 0x5d, 0xcb, 0xb5, 0x24, 0xeb, 0xbe, 0x9b, 0x74, 0x1a, 0x7e,
+	0x33, 0x18, 0x3f, 0x63, 0xf3, 0x9e, 0x6e, 0x3f, 0x91, 0x3b, 0x60, 0xe6, 0xd8, 0x78, 0x2c, 0x60,
+	0xf3, 0xa9, 0xe8, 0x46, 0x7e, 0x0b, 0x97, 0x59, 0x85, 0x69, 0x8d, 0x1f, 0x15, 0xaa, 0xcd, 0x7e,
+	0x23, 0x77, 0x9e, 0x11, 0xb0, 0xb9, 0x29, 0x66, 0xda, 0x16, 0x7f, 0x2e, 0xbf, 0x81, 0x69, 0x21,
+	0x57, 0xff, 0x94, 0x49, 0xd4, 0xa4, 0x90, 0xab, 0x33, 0xe2, 0xc1, 0x48, 0x61, 0x45, 0xe9, 0x90,
+	0xd2, 0x5e, 0x72, 0x17, 0x2c, 0xd5, 0x15, 0xf0, 0x2c, 0x7a, 0x59, 0x8b, 0xce, 0xdd, 0x62, 0xba,
+	0x47, 0xcf, 0x26, 0x5a, 0x8b, 0xf0, 0x0b, 0xac, 0x58, 0xe1, 0xae, 0xe6, 0x77, 0x30, 0xac, 0x9b,
+	0x12, 0xa9, 0xed, 0x6c, 0x71, 0x15, 0xe9, 0x35, 0x23, 0x0a, 0xf5, 0x99, 0x34, 0x25, 0x0a, 0x82,
+	0x78, 0x00, 0x46, 0xae, 0xa8, 0xfa, 0x64, 0xe1, 0xf4, 0x68, 0xbf, 0xb7, 0x30, 0x72, 0x15, 0x06,
+	0x70, 0x71, 0xbe, 0xc4, 0x47, 0x60, 0xbe, 0xbe, 0x25, 0xce, 0x80, 0x03, 0xd8, 0x4f, 0xf1, 0x4b,
+	0x9c, 0xc4, 0x0e, 0x7b, 0x74, 0x0f, 0x27, 0x7f, 0x70, 0x3c, 0xf9, 0x83, 0x43, 0xeb, 0xb3, 0x63,
+	0xeb, 0xb3, 0x9f, 0xd6, 0x67, 0x4b, 0x9b, 0xfe, 0xf1, 0xe1, 0x37, 0x00, 0x00, 0xff, 0xff, 0x71,
+	0xd2, 0x34, 0xa9, 0x71, 0x01, 0x00, 0x00,
 }

proxy/grpcproxy/kv.go

@@ -57,11 +57,11 @@ func (p *kvProxy) Txn(ctx context.Context, r *pb.TxnRequest) (*pb.TxnResponse, e
 	}
 
 	for i := range r.Success {
-		thenops[i] = requestUnionToOp(r.Success[i])
+		thenops[i] = requestOpToOp(r.Success[i])
 	}
 
 	for i := range r.Failure {
-		elseops[i] = requestUnionToOp(r.Failure[i])
+		elseops[i] = requestOpToOp(r.Failure[i])
 	}
 
 	resp, err := txn.If(cmps...).Then(thenops...).Else(elseops...).Commit()
@@ -72,17 +72,17 @@ func (p *kvProxy) Close() error {
 	return p.c.Close()
 }
 
-func requestUnionToOp(union *pb.RequestUnion) clientv3.Op {
+func requestOpToOp(union *pb.RequestOp) clientv3.Op {
 	switch tv := union.Request.(type) {
-	case *pb.RequestUnion_RequestRange:
+	case *pb.RequestOp_RequestRange:
 		if tv.RequestRange != nil {
 			return RangeRequestToOp(tv.RequestRange)
 		}
-	case *pb.RequestUnion_RequestPut:
+	case *pb.RequestOp_RequestPut:
 		if tv.RequestPut != nil {
 			return PutRequestToOp(tv.RequestPut)
 		}
-	case *pb.RequestUnion_RequestDeleteRange:
+	case *pb.RequestOp_RequestDeleteRange:
 		if tv.RequestDeleteRange != nil {
 			return DelRequestToOp(tv.RequestDeleteRange)
 		}

raft/raftpb/raft.pb.go

@@ -1788,51 +1788,52 @@ var (
 )
 
 var fileDescriptorRaft = []byte{
-	// 735 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x54, 0x4d, 0x6f, 0xd3, 0x4a,
-	0x14, 0xad, 0x13, 0xe7, 0xeb, 0xa6, 0x4d, 0xa7, 0xd3, 0xbc, 0x27, 0xab, 0x7a, 0xea, 0xeb, 0xb3,
-	0xde, 0x02, 0x15, 0xb5, 0x40, 0x17, 0x2c, 0xd8, 0xf5, 0x03, 0xa9, 0x95, 0x68, 0x05, 0x69, 0xcb,
-	0x02, 0x84, 0xd0, 0xd4, 0x9e, 0x38, 0x81, 0xda, 0x63, 0x8d, 0x27, 0xa5, 0xdd, 0x20, 0x24, 0x16,
-	0x6c, 0xf8, 0x61, 0x5d, 0xf6, 0x17, 0x20, 0xe0, 0x97, 0x70, 0x67, 0x3c, 0x4e, 0xec, 0x66, 0x11,
-	0x69, 0xe6, 0x9c, 0xfb, 0x71, 0xee, 0x99, 0xeb, 0x00, 0x48, 0x36, 0x54, 0xdb, 0xa9, 0x14, 0x4a,
-	0xd0, 0xa6, 0x3e, 0xa7, 0x17, 0x6b, 0xfd, 0x48, 0x44, 0xc2, 0x40, 0x8f, 0xf4, 0x29, 0x67, 0xfd,
-	0xcf, 0xd0, 0x78, 0x9e, 0x28, 0x79, 0x43, 0x1f, 0x82, 0x7b, 0x76, 0x93, 0x72, 0xcf, 0xd9, 0x70,
-	0x1e, 0xf4, 0x76, 0x56, 0xb6, 0xf3, 0xac, 0x6d, 0x43, 0x6a, 0x62, 0xcf, 0xbd, 0xfd, 0xf1, 0xef,
-	0xc2, 0xc0, 0x55, 0x78, 0xa6, 0x1e, 0x06, 0x73, 0x19, 0x7b, 0x35, 0x0c, 0x76, 0xa7, 0x0c, 0x22,
-	0x74, 0x0d, 0x1a, 0x47, 0x49, 0xc8, 0xaf, 0xbd, 0x7a, 0x89, 0x6a, 0x8c, 0x35, 0x44, 0x29, 0xb8,
-	0x07, 0x4c, 0x31, 0xcf, 0x45, 0x6a, 0x71, 0xe0, 0x86, 0x78, 0xf6, 0xbf, 0x38, 0x40, 0x4e, 0x13,
-	0x96, 0x66, 0x23, 0xa1, 0x8e, 0xb9, 0x62, 0x1a, 0xa4, 0x4f, 0x01, 0x02, 0x91, 0x0c, 0xdf, 0x67,
-	0x8a, 0xa9, 0x5c, 0x51, 0x77, 0xa6, 0x68, 0x1f, 0x99, 0x53, 0x4d, 0xd8, 0xe2, 0x9d, 0xa0, 0x00,
-	0x74, 0x73, 0xd3, 0xa9, 0xa2, 0xcb, 0x36, 0x47, 0xc9, 0x5a, 0x60, 0x45, 0x97, 0x41, 0xfc, 0x37,
-	0xd0, 0x2e, 0x14, 0x68, 0x89, 0x5a, 0x81, 0xe9, 0x69, 0x25, 0xd2, 0x67, 0xd0, 0x8e, 0xad, 0x32,
-	0x53, 0xb8, 0xbb, 0xe3, 0x15, 0x5a, 0xee, 0x2b, 0xb7, 0x75, 0xa7, 0xf1, 0xfe, 0xd7, 0x3a, 0xb4,
-	0x8e, 0x79, 0x96, 0xb1, 0x88, 0xd3, 0x2d, 0x30, 0xe6, 0x59, 0x87, 0x57, 0x8b, 0x1a, 0x96, 0x9e,
-	0xf3, 0xb8, 0x0f, 0x35, 0x25, 0x2a, 0x93, 0xe0, 0x5d, 0x8f, 0x31, 0x94, 0xe2, 0xde, 0x18, 0x1a,
-	0x99, 0x0e, 0xe8, 0xce, 0xbd, 0xc9, 0x3a, 0xb4, 0x2e, 0x45, 0x64, 0x1e, 0xac, 0x51, 0x22, 0x0b,
-	0x70, 0x66, 0x5b, 0x73, 0xde, 0xb6, 0x2d, 0x68, 0x71, 0x5c, 0x81, 0x31, 0xcf, 0xbc, 0xd6, 0x46,
-	0x1d, 0x67, 0x5f, 0xaa, 0x6c, 0x46, 0x51, 0xca, 0xc6, 0xd0, 0x7f, 0xa0, 0x19, 0x88, 0x38, 0x1e,
-	0x2b, 0xaf, 0x5d, 0xaa, 0x65, 0x31, 0xba, 0x03, 0xed, 0xcc, 0x3a, 0xe6, 0x75, 0x8c, 0x93, 0xe4,
-	0xbe, 0x93, 0x85, 0x83, 0x45, 0x9c, 0xae, 0x28, 0xf9, 0x07, 0x1e, 0x28, 0x0f, 0x30, 0xa3, 0x5d,
-	0x54, 0xcc, 0x31, 0xfa, 0x3f, 0xae, 0xba, 0x39, 0x1d, 0x8e, 0x13, 0xe5, 0x75, 0x4b, 0x3d, 0x4b,
-	0xb8, 0xff, 0x0e, 0x3a, 0x87, 0x4c, 0x86, 0xf9, 0x92, 0x14, 0x3e, 0x39, 0x73, 0x3e, 0x21, 0x73,
-	0x25, 0x70, 0xe1, 0x2a, 0x5b, 0xad, 0x91, 0xd2, 0x58, 0xf5, 0xf9, 0xb1, 0xfc, 0xff, 0xa0, 0x33,
-	0x5d, 0x4a, 0x7c, 0xb6, 0x46, 0x22, 0x42, 0xb4, 0xcb, 0x41, 0xbb, 0xdc, 0x41, 0x7e, 0xf1, 0xbf,
-	0x3b, 0x00, 0x3a, 0x66, 0x7f, 0xc4, 0x92, 0xc8, 0xbc, 0xed, 0xd1, 0x41, 0x45, 0x41, 0x6d, 0x7c,
-	0x40, 0x1f, 0xdb, 0x4f, 0xb0, 0x66, 0x16, 0xe4, 0xef, 0xf2, 0xc2, 0xe7, 0x79, 0x73, 0x3b, 0x82,
-	0xba, 0x4e, 0xb0, 0x3e, 0xd6, 0xaa, 0xe8, 0x4a, 0x0c, 0x86, 0xf3, 0xb4, 0x30, 0x57, 0xf1, 0x6b,
-	0x65, 0x3f, 0xb9, 0x56, 0x90, 0x5f, 0x37, 0x9f, 0x40, 0x67, 0xfa, 0x61, 0xd3, 0x65, 0xe8, 0x9a,
-	0xcb, 0x89, 0x90, 0x31, 0xbb, 0x24, 0x0b, 0x74, 0x15, 0x96, 0x0d, 0x30, 0x6b, 0x4c, 0x9c, 0xcd,
-	0x6f, 0x35, 0xe8, 0x96, 0x56, 0x95, 0x02, 0x34, 0x8f, 0xb3, 0xe8, 0x70, 0x92, 0x62, 0x42, 0x17,
-	0x97, 0x3c, 0x8b, 0xf6, 0x38, 0x53, 0xc4, 0xb1, 0x97, 0x97, 0x52, 0xa4, 0xa4, 0x66, 0xa3, 0x76,
-	0xd3, 0x94, 0xd4, 0x69, 0x0f, 0x20, 0x3f, 0x0f, 0x78, 0x96, 0x12, 0xd7, 0x06, 0xbe, 0x46, 0x7f,
-	0x49, 0x43, 0x8b, 0xb0, 0x17, 0xc3, 0x36, 0x2d, 0xab, 0xd7, 0x82, 0xb4, 0x28, 0x81, 0x45, 0xdd,
-	0x8c, 0x33, 0xa9, 0x2e, 0x74, 0x97, 0x36, 0x3a, 0x48, 0xca, 0x88, 0x49, 0xea, 0xe0, 0xe7, 0xdb,
-	0x43, 0xf4, 0x3c, 0x91, 0x9c, 0x05, 0x23, 0x76, 0x71, 0xc9, 0x09, 0xd0, 0x15, 0x58, 0xb2, 0x85,
-	0xf4, 0x03, 0x4d, 0x32, 0xd2, 0xb5, 0x61, 0xfb, 0x23, 0x1e, 0x7c, 0x7c, 0x35, 0x11, 0x72, 0x12,
-	0x93, 0x45, 0xfa, 0x17, 0xac, 0x20, 0x76, 0x26, 0x59, 0x92, 0x0d, 0xb9, 0x7c, 0xc1, 0x59, 0xc8,
-	0x25, 0x59, 0xb2, 0xd9, 0x67, 0xe3, 0x98, 0x8b, 0x89, 0x3a, 0x11, 0x9f, 0x48, 0x6f, 0xf3, 0x2d,
-	0xf4, 0xaa, 0x4f, 0xa2, 0x73, 0x67, 0xc8, 0x6e, 0x18, 0xea, 0x37, 0x41, 0x5b, 0x3c, 0xe8, 0xcf,
-	0xe0, 0x01, 0x8f, 0xc5, 0x15, 0x37, 0x8c, 0x53, 0x65, 0xce, 0x53, 0xfc, 0xab, 0xc8, 0x99, 0xda,
-	0x5e, 0xff, 0xf6, 0xd7, 0xfa, 0xc2, 0x1d, 0xfe, 0x6e, 0x7f, 0xaf, 0x3b, 0x77, 0xf8, 0xfb, 0x89,
-	0xbf, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xc8, 0x26, 0x45, 0x2d, 0xd0, 0x05, 0x00, 0x00,
+	// 746 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x64, 0x53, 0xc1, 0x6e, 0xdb, 0x38,
+	0x10, 0xb5, 0x64, 0xd9, 0xb2, 0x47, 0x89, 0xc3, 0x30, 0xde, 0x05, 0x11, 0x04, 0x5e, 0xaf, 0xb1,
+	0x07, 0x23, 0x8b, 0x64, 0x77, 0x7d, 0xd8, 0x43, 0x6f, 0x89, 0x5d, 0x20, 0x01, 0xea, 0xa0, 0x75,
+	0x9c, 0x1e, 0x5a, 0x14, 0x05, 0x63, 0xd1, 0xb2, 0xdb, 0x48, 0x14, 0x28, 0x3a, 0x4d, 0x2e, 0x45,
+	0x81, 0x1e, 0x7a, 0xe9, 0x87, 0xe5, 0x98, 0x2f, 0x28, 0x9a, 0x7c, 0x49, 0x41, 0x8a, 0xb2, 0xa5,
+	0xf8, 0x46, 0xbe, 0x37, 0x9c, 0x79, 0xf3, 0x66, 0x08, 0x20, 0xe8, 0x54, 0x1e, 0xc6, 0x82, 0x4b,
+	0x8e, 0xab, 0xea, 0x1c, 0x5f, 0xee, 0x36, 0x03, 0x1e, 0x70, 0x0d, 0xfd, 0xa3, 0x4e, 0x29, 0xdb,
+	0xf9, 0x0c, 0x95, 0xe7, 0x91, 0x14, 0xb7, 0xf8, 0x6f, 0x70, 0xc6, 0xb7, 0x31, 0x23, 0x56, 0xdb,
+	0xea, 0x36, 0x7a, 0xdb, 0x87, 0xe9, 0xab, 0x43, 0x4d, 0x2a, 0xe2, 0xd8, 0xb9, 0xfb, 0xf1, 0x47,
+	0x69, 0xe4, 0xc8, 0xdb, 0x98, 0x61, 0x02, 0xce, 0x98, 0x89, 0x90, 0xd8, 0x6d, 0xab, 0xeb, 0x2c,
+	0x19, 0x26, 0x42, 0xbc, 0x0b, 0x95, 0xd3, 0xc8, 0x67, 0x37, 0xa4, 0x9c, 0xa3, 0x2a, 0x73, 0x05,
+	0x61, 0x0c, 0xce, 0x80, 0x4a, 0x4a, 0x9c, 0xb6, 0xd5, 0xdd, 0x18, 0x39, 0x3e, 0x95, 0xb4, 0xf3,
+	0xc5, 0x02, 0x74, 0x1e, 0xd1, 0x38, 0x99, 0x71, 0x39, 0x64, 0x92, 0x2a, 0x10, 0xff, 0x0f, 0x30,
+	0xe1, 0xd1, 0xf4, 0x7d, 0x22, 0xa9, 0x4c, 0x15, 0x79, 0x2b, 0x45, 0x7d, 0x1e, 0x4d, 0xcf, 0x15,
+	0x61, 0x92, 0xd7, 0x27, 0x19, 0xa0, 0x8a, 0xeb, 0x4a, 0x05, 0x5d, 0xa6, 0x38, 0x01, 0x2d, 0xb0,
+	0xa0, 0x4b, 0x23, 0x9d, 0x37, 0x50, 0xcb, 0x14, 0x28, 0x89, 0x4a, 0x81, 0xae, 0x69, 0x24, 0xe2,
+	0x67, 0x50, 0x0b, 0x8d, 0x32, 0x9d, 0xd8, 0xeb, 0x91, 0x4c, 0xcb, 0x53, 0xe5, 0x26, 0xef, 0x32,
+	0xbe, 0xf3, 0xb5, 0x0c, 0xee, 0x90, 0x25, 0x09, 0x0d, 0x18, 0x3e, 0x00, 0x6d, 0x9e, 0x71, 0x78,
+	0x27, 0xcb, 0x61, 0xe8, 0x35, 0x8f, 0x9b, 0x60, 0x4b, 0x5e, 0xe8, 0xc4, 0x96, 0x5c, 0xb5, 0x31,
+	0x15, 0xfc, 0x49, 0x1b, 0x0a, 0x59, 0x36, 0xe8, 0xac, 0xcd, 0xa4, 0x05, 0xee, 0x15, 0x0f, 0xf4,
+	0xc0, 0x2a, 0x39, 0x32, 0x03, 0x57, 0xb6, 0x55, 0xd7, 0x6d, 0x3b, 0x00, 0x97, 0x45, 0x52, 0xcc,
+	0x59, 0x42, 0xdc, 0x76, 0xb9, 0xeb, 0xf5, 0x36, 0x0b, 0x9b, 0x91, 0xa5, 0x32, 0x31, 0x78, 0x0f,
+	0xaa, 0x13, 0x1e, 0x86, 0x73, 0x49, 0x6a, 0xb9, 0x5c, 0x06, 0xc3, 0x3d, 0xa8, 0x25, 0xc6, 0x31,
+	0x52, 0xd7, 0x4e, 0xa2, 0xa7, 0x4e, 0x66, 0x0e, 0x66, 0x71, 0x2a, 0xa3, 0x60, 0x1f, 0xd8, 0x44,
+	0x12, 0x68, 0x5b, 0xdd, 0x5a, 0x96, 0x31, 0xc5, 0xf0, 0x5f, 0x00, 0xe9, 0xe9, 0x64, 0x1e, 0x49,
+	0xe2, 0xe5, 0x6a, 0xe6, 0xf0, 0xce, 0x3b, 0xa8, 0x9f, 0x50, 0xe1, 0xa7, 0x4b, 0x92, 0xf9, 0x64,
+	0xad, 0xf9, 0x44, 0xc0, 0xb9, 0xe6, 0x92, 0x15, 0xb7, 0x5a, 0x21, 0xb9, 0xb6, 0xca, 0xeb, 0x6d,
+	0x75, 0xfe, 0x84, 0xfa, 0x72, 0x29, 0x71, 0x13, 0x2a, 0x11, 0xf7, 0x59, 0x42, 0xac, 0x76, 0xb9,
+	0xeb, 0x8c, 0xd2, 0x4b, 0xe7, 0xbb, 0x05, 0xa0, 0x62, 0xfa, 0x33, 0x1a, 0x05, 0x7a, 0xb6, 0xa7,
+	0x83, 0x82, 0x02, 0x7b, 0x3e, 0xc0, 0xff, 0x9a, 0x2f, 0x68, 0xeb, 0x05, 0xf9, 0x3d, 0xbf, 0xf0,
+	0xe9, 0xbb, 0xb5, 0x1d, 0xd9, 0x83, 0xea, 0x19, 0xf7, 0xd9, 0xe9, 0xa0, 0xa8, 0x2b, 0xd2, 0x18,
+	0x26, 0xe0, 0xf6, 0x79, 0x24, 0xd9, 0x8d, 0x34, 0x5f, 0xce, 0x9d, 0xa4, 0xd7, 0xfd, 0xff, 0xa0,
+	0xbe, 0xfc, 0xd8, 0x78, 0x0b, 0x3c, 0x7d, 0x39, 0xe3, 0x22, 0xa4, 0x57, 0xa8, 0x84, 0x77, 0x60,
+	0x4b, 0x03, 0xab, 0xc2, 0xc8, 0xda, 0xff, 0x66, 0x83, 0x97, 0x5b, 0x55, 0x0c, 0x50, 0x1d, 0x26,
+	0xc1, 0xc9, 0x22, 0x46, 0x25, 0xec, 0x81, 0x3b, 0x4c, 0x82, 0x63, 0x46, 0x25, 0xb2, 0xcc, 0xe5,
+	0xa5, 0xe0, 0x31, 0xb2, 0x4d, 0xd4, 0x51, 0x1c, 0xa3, 0x32, 0x6e, 0x00, 0xa4, 0xe7, 0x11, 0x4b,
+	0x62, 0xe4, 0x98, 0xc0, 0xd7, 0x5c, 0x32, 0x54, 0x51, 0x22, 0xcc, 0x45, 0xb3, 0x55, 0xc3, 0xaa,
+	0xb5, 0x40, 0x2e, 0x46, 0xb0, 0xa1, 0x8a, 0x31, 0x2a, 0xe4, 0xa5, 0xaa, 0x52, 0xc3, 0x4d, 0x40,
+	0x79, 0x44, 0x3f, 0xaa, 0x63, 0x0c, 0x8d, 0x61, 0x12, 0x5c, 0x44, 0x82, 0xd1, 0xc9, 0x8c, 0x5e,
+	0x5e, 0x31, 0x04, 0x78, 0x1b, 0x36, 0x4d, 0x22, 0x35, 0xa0, 0x45, 0x82, 0x3c, 0x13, 0xd6, 0x9f,
+	0xb1, 0xc9, 0xc7, 0x57, 0x0b, 0x2e, 0x16, 0x21, 0xda, 0xc0, 0xbf, 0xc1, 0xf6, 0x30, 0x09, 0xc6,
+	0x82, 0x46, 0xc9, 0x94, 0x89, 0x17, 0x8c, 0xfa, 0x4c, 0xa0, 0x4d, 0xf3, 0x7a, 0x3c, 0x0f, 0x19,
+	0x5f, 0xc8, 0x33, 0xfe, 0x09, 0x35, 0xf6, 0xdf, 0x42, 0xa3, 0x38, 0x12, 0xf5, 0x76, 0x85, 0x1c,
+	0xf9, 0xbe, 0x9a, 0x09, 0x2a, 0x61, 0x02, 0xcd, 0x15, 0x3c, 0x62, 0x21, 0xbf, 0x66, 0x9a, 0xb1,
+	0x8a, 0xcc, 0x45, 0xec, 0x53, 0x99, 0x32, 0xf6, 0x71, 0xf3, 0xee, 0xa1, 0x55, 0xba, 0x7f, 0x68,
+	0x95, 0xee, 0x1e, 0x5b, 0xd6, 0xfd, 0x63, 0xcb, 0xfa, 0xf9, 0xd8, 0xb2, 0x7e, 0x05, 0x00, 0x00,
+	0xff, 0xff, 0xc8, 0x26, 0x45, 0x2d, 0xd0, 0x05, 0x00, 0x00,
 }

snap/snappb/snap.pb.go

@@ -337,13 +337,13 @@ var (
 )
 
 var fileDescriptorSnap = []byte{
-	// 118 bytes of a gzipped FileDescriptorProto
+	// 122 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0xce, 0x4b, 0x2c,
 	0xd0, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x03, 0xb1, 0x0b, 0x92, 0xa4, 0x44, 0xd2, 0xf3,
 	0xd3, 0xf3, 0xc1, 0x42, 0xfa, 0x20, 0x16, 0x44, 0x56, 0xc9, 0x8c, 0x8b, 0x03, 0x24, 0x5f, 0x9c,
 	0x91, 0x5f, 0x22, 0x24, 0xc6, 0xc5, 0x9c, 0x5c, 0x94, 0x2c, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xeb,
 	0xc4, 0x72, 0xe2, 0x9e, 0x3c, 0x43, 0x10, 0x48, 0x40, 0x48, 0x88, 0x8b, 0x25, 0x25, 0xb1, 0x24,
-	0x51, 0x82, 0x09, 0x28, 0xc1, 0x13, 0x04, 0x66, 0x3b, 0x09, 0x9c, 0x78, 0x28, 0xc7, 0x70, 0xe2,
-	0x91, 0x1c, 0xe3, 0x05, 0x20, 0x7e, 0x00, 0xc4, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0d, 0x03,
-	0x97, 0xa7, 0x74, 0x00, 0x00, 0x00,
+	0x51, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xcc, 0x76, 0x12, 0x38, 0xf1, 0x50, 0x8e, 0xe1,
+	0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x04, 0x04, 0x00, 0x00,
+	0xff, 0xff, 0x0d, 0x03, 0x97, 0xa7, 0x74, 0x00, 0x00, 0x00,
 }

wal/walpb/record.pb.go

@@ -501,16 +501,17 @@ var (
 )
 
 var fileDescriptorRecord = []byte{
-	// 175 bytes of a gzipped FileDescriptorProto
+	// 182 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x29, 0x4a, 0x4d, 0xce,
 	0x2f, 0x4a, 0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x2d, 0x4f, 0xcc, 0x29, 0x48, 0x92,
 	0x12, 0x49, 0xcf, 0x4f, 0xcf, 0x07, 0x8b, 0xe8, 0x83, 0x58, 0x10, 0x49, 0x25, 0x3f, 0x2e, 0xb6,
 	0x20, 0xb0, 0x62, 0x21, 0x09, 0x2e, 0x96, 0x92, 0xca, 0x82, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d,
 	0x66, 0x27, 0x96, 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xc0, 0x22, 0x42, 0x62, 0x5c, 0xcc, 0xc9, 0x45,
-	0xc9, 0x12, 0x4c, 0x40, 0x09, 0x5e, 0xa8, 0x04, 0x48, 0x40, 0x48, 0x88, 0x8b, 0x25, 0x25, 0xb1,
-	0x24, 0x51, 0x82, 0x19, 0x28, 0xc1, 0x13, 0x04, 0x66, 0x2b, 0x39, 0x70, 0x71, 0x04, 0xe7, 0x25,
-	0x16, 0x14, 0x67, 0xe4, 0x97, 0x08, 0x49, 0x71, 0xb1, 0x66, 0xe6, 0xa5, 0xa4, 0x56, 0x80, 0x8d,
-	0x64, 0x81, 0xea, 0x84, 0x08, 0x81, 0x6d, 0x4b, 0x2d, 0xca, 0x05, 0x1b, 0xca, 0x02, 0xb7, 0x0d,
-	0x28, 0xe2, 0x24, 0x70, 0xe2, 0xa1, 0x1c, 0xc3, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x80, 0xf8, 0x01,
-	0x10, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x20, 0xf5, 0xbc, 0xcf, 0x00, 0x00, 0x00,
+	0xc9, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xbc, 0x50, 0x09, 0x90, 0x80, 0x90, 0x10, 0x17, 0x4b, 0x4a,
+	0x62, 0x49, 0xa2, 0x04, 0xb3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x98, 0xad, 0xe4, 0xc0, 0xc5, 0x11,
+	0x9c, 0x97, 0x58, 0x50, 0x9c, 0x91, 0x5f, 0x22, 0x24, 0xc5, 0xc5, 0x9a, 0x99, 0x97, 0x92, 0x5a,
+	0x01, 0x36, 0x92, 0x05, 0xaa, 0x13, 0x22, 0x04, 0xb6, 0x2d, 0xb5, 0x28, 0x17, 0x6c, 0x28, 0x0b,
+	0xdc, 0xb6, 0xd4, 0xa2, 0x5c, 0x27, 0x81, 0x13, 0x0f, 0xe5, 0x18, 0x4e, 0x3c, 0x92, 0x63, 0xbc,
+	0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0x46, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe5, 0x20,
+	0xf5, 0xbc, 0xcf, 0x00, 0x00, 0x00,
 }