x/params: query gRPC service (#6585)

* Add grpc queries in x/params

* Modify grpc query tests format

* Modify query request and revert changes in querier

* Fix protobuf lint issues
This commit is contained in:
Akhil Kumar P 2020-07-08 21:03:55 +05:30 committed by GitHub
parent 3fc5a4dfc6
commit 674845c7f6
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 830 additions and 0 deletions

View File

@ -0,0 +1,25 @@
syntax = "proto3";
package cosmos.params;
import "gogoproto/gogo.proto";
import "cosmos/params/params.proto";
option go_package = "github.com/cosmos/cosmos-sdk/x/params/types/proposal";
// Query creates service with Parameters as rpc
service Query{
// Parameters queries all params
rpc Parameters (QueryParametersRequest) returns (QueryParametersResponse) {}
}
// QueryParametersRequest is request type for the Query/Parameters RPC method
message QueryParametersRequest{
string subspace = 1;
string key = 2;
}
// QueryParametersResponse is response type for the Query/Parameters RPC method
message QueryParametersResponse{
cosmos.params.ParamChange params = 1 [(gogoproto.nullable) = false];
}

View File

@ -0,0 +1,36 @@
package keeper
import (
"context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/x/params/types/proposal"
)
var _ proposal.QueryServer = Keeper{}
// Parameters returns subspace params
func (k Keeper) Parameters(c context.Context, req *proposal.QueryParametersRequest) (*proposal.QueryParametersResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
if req.Subspace == "" || req.Key == "" {
return nil, status.Errorf(codes.InvalidArgument, "invalid request")
}
ss, ok := k.GetSubspace(req.Subspace)
if !ok {
return nil, sdkerrors.Wrap(proposal.ErrUnknownSubspace, req.Subspace)
}
ctx := sdk.UnwrapSDKContext(c)
rawValue := ss.GetRaw(ctx, []byte(req.Key))
params := proposal.NewParamChange(req.Subspace, req.Key, string(rawValue))
return &proposal.QueryParametersResponse{Params: params}, nil
}

View File

@ -0,0 +1,86 @@
package keeper_test
import (
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/cosmos/cosmos-sdk/x/params/types/proposal"
)
func (suite *KeeperTestSuite) TestGRPCQueryParams() {
var (
req *proposal.QueryParametersRequest
expValue string
space types.Subspace
)
key := []byte("key")
testCases := []struct {
msg string
malleate func()
expPass bool
}{
{
"empty request",
func() {
req = &proposal.QueryParametersRequest{}
},
false,
},
{
"invalid request with subspace not found",
func() {
req = &proposal.QueryParametersRequest{Subspace: "test"}
},
false,
},
{
"invalid request with subspace and key not found",
func() {
req = &proposal.QueryParametersRequest{Subspace: "test", Key: "key"}
},
false,
},
{
"success",
func() {
space = suite.app.ParamsKeeper.Subspace("test").
WithKeyTable(types.NewKeyTable(types.NewParamSetPair(key, paramJSON{}, validateNoOp)))
req = &proposal.QueryParametersRequest{Subspace: "test", Key: "key"}
expValue = ""
},
true,
},
{
"update value success",
func() {
err := space.Update(suite.ctx, key, []byte(`{"param1":"10241024"}`))
suite.Require().NoError(err)
req = &proposal.QueryParametersRequest{Subspace: "test", Key: "key"}
expValue = `{"param1":"10241024"}`
},
true,
},
}
suite.SetupTest()
ctx := sdk.WrapSDKContext(suite.ctx)
for _, tc := range testCases {
suite.Run(fmt.Sprintf("Case %s", tc.msg), func() {
tc.malleate()
res, err := suite.queryClient.Parameters(ctx, req)
if tc.expPass {
suite.Require().NoError(err)
suite.Require().NotNil(res)
suite.Require().Equal(expValue, res.Params.Value)
} else {
suite.Require().Error(err)
suite.Require().Nil(res)
}
})
}
}

View File

@ -5,12 +5,46 @@ import (
"testing" "testing"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/store/prefix" "github.com/cosmos/cosmos-sdk/store/prefix"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/params/types" "github.com/cosmos/cosmos-sdk/x/params/types"
"github.com/cosmos/cosmos-sdk/x/params/types/proposal"
) )
type KeeperTestSuite struct {
suite.Suite
app *simapp.SimApp
ctx sdk.Context
queryClient proposal.QueryClient
}
func (suite *KeeperTestSuite) SetupTest() {
suite.app, suite.ctx = createTestApp(true)
queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry())
proposal.RegisterQueryServer(queryHelper, suite.app.ParamsKeeper)
suite.queryClient = proposal.NewQueryClient(queryHelper)
}
func TestKeeperTestSuite(t *testing.T) {
suite.Run(t, new(KeeperTestSuite))
}
// returns context and app
func createTestApp(isCheckTx bool) (*simapp.SimApp, sdk.Context) {
app := simapp.Setup(isCheckTx)
ctx := app.BaseApp.NewContext(isCheckTx, abci.Header{})
return app, ctx
}
func validateNoOp(_ interface{}) error { return nil } func validateNoOp(_ interface{}) error { return nil }
func TestKeeper(t *testing.T) { func TestKeeper(t *testing.T) {

View File

@ -100,3 +100,11 @@ func ValidateChanges(changes []ParamChange) error {
return nil return nil
} }
// NewQueryParametersRequest returns the new instance of QueryParametersRequest
func NewQueryParametersRequest(ss, key string) *QueryParametersRequest {
return &QueryParametersRequest{
Subspace: ss,
Key: key,
}
}

View File

@ -0,0 +1,641 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/params/query.proto
package proposal
import (
context "context"
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
grpc1 "github.com/gogo/protobuf/grpc"
proto "github.com/gogo/protobuf/proto"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// QueryParametersRequest is request type for the Query/Parameters RPC method
type QueryParametersRequest struct {
Subspace string `protobuf:"bytes,1,opt,name=subspace,proto3" json:"subspace,omitempty"`
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}
func (m *QueryParametersRequest) Reset() { *m = QueryParametersRequest{} }
func (m *QueryParametersRequest) String() string { return proto.CompactTextString(m) }
func (*QueryParametersRequest) ProtoMessage() {}
func (*QueryParametersRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_3bc356506c43c13a, []int{0}
}
func (m *QueryParametersRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryParametersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryParametersRequest.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryParametersRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryParametersRequest.Merge(m, src)
}
func (m *QueryParametersRequest) XXX_Size() int {
return m.Size()
}
func (m *QueryParametersRequest) XXX_DiscardUnknown() {
xxx_messageInfo_QueryParametersRequest.DiscardUnknown(m)
}
var xxx_messageInfo_QueryParametersRequest proto.InternalMessageInfo
func (m *QueryParametersRequest) GetSubspace() string {
if m != nil {
return m.Subspace
}
return ""
}
func (m *QueryParametersRequest) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
// QueryParametersResponse is response type for the Query/Parameters RPC method
type QueryParametersResponse struct {
Params ParamChange `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}
func (m *QueryParametersResponse) Reset() { *m = QueryParametersResponse{} }
func (m *QueryParametersResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParametersResponse) ProtoMessage() {}
func (*QueryParametersResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_3bc356506c43c13a, []int{1}
}
func (m *QueryParametersResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryParametersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryParametersResponse.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryParametersResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryParametersResponse.Merge(m, src)
}
func (m *QueryParametersResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryParametersResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryParametersResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryParametersResponse proto.InternalMessageInfo
func (m *QueryParametersResponse) GetParams() ParamChange {
if m != nil {
return m.Params
}
return ParamChange{}
}
func init() {
proto.RegisterType((*QueryParametersRequest)(nil), "cosmos.params.QueryParametersRequest")
proto.RegisterType((*QueryParametersResponse)(nil), "cosmos.params.QueryParametersResponse")
}
func init() { proto.RegisterFile("cosmos/params/query.proto", fileDescriptor_3bc356506c43c13a) }
var fileDescriptor_3bc356506c43c13a = []byte{
// 278 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xce, 0x2f, 0xce,
0xcd, 0x2f, 0xd6, 0x2f, 0x48, 0x2c, 0x4a, 0xcc, 0x2d, 0xd6, 0x2f, 0x2c, 0x4d, 0x2d, 0xaa, 0xd4,
0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x85, 0x48, 0xe9, 0x41, 0xa4, 0xa4, 0x44, 0xd2, 0xf3,
0xd3, 0xf3, 0xc1, 0x32, 0xfa, 0x20, 0x16, 0x44, 0x91, 0x94, 0x14, 0xaa, 0x7e, 0x08, 0x05, 0x91,
0x53, 0x72, 0xe3, 0x12, 0x0b, 0x04, 0x99, 0x17, 0x00, 0x12, 0x4c, 0x2d, 0x49, 0x2d, 0x2a, 0x0e,
0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0x92, 0xe2, 0xe2, 0x28, 0x2e, 0x4d, 0x2a, 0x2e, 0x48,
0x4c, 0x4e, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x82, 0xf3, 0x85, 0x04, 0xb8, 0x98, 0xb3,
0x53, 0x2b, 0x25, 0x98, 0xc0, 0xc2, 0x20, 0xa6, 0x52, 0x30, 0x97, 0x38, 0x86, 0x39, 0xc5, 0x05,
0xf9, 0x79, 0xc5, 0xa9, 0x42, 0x16, 0x5c, 0x6c, 0x10, 0x2b, 0xc1, 0xc6, 0x70, 0x1b, 0x49, 0xe9,
0xa1, 0x38, 0x5a, 0x0f, 0xac, 0xc5, 0x39, 0x23, 0x31, 0x2f, 0x3d, 0xd5, 0x89, 0xe5, 0xc4, 0x3d,
0x79, 0x86, 0x20, 0xa8, 0x7a, 0xa3, 0x34, 0x2e, 0x56, 0xb0, 0xa1, 0x42, 0xb1, 0x5c, 0x5c, 0x08,
0x83, 0x85, 0x54, 0xd1, 0x0c, 0xc0, 0xee, 0x01, 0x29, 0x35, 0x42, 0xca, 0x20, 0xee, 0x53, 0x62,
0x70, 0xf2, 0x3b, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27,
0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x93, 0xf4, 0xcc,
0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0x7d, 0x68, 0x28, 0x42, 0x28, 0xdd, 0xe2, 0x94,
0x6c, 0xfd, 0x0a, 0x58, 0x90, 0x96, 0x54, 0x16, 0xa4, 0x16, 0xeb, 0x17, 0x14, 0xe5, 0x17, 0xe4,
0x17, 0x27, 0xe6, 0x24, 0xb1, 0x81, 0xc3, 0xd6, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x4c, 0xc1,
0xb2, 0x34, 0xb9, 0x01, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
// Parameters queries all params
Parameters(ctx context.Context, in *QueryParametersRequest, opts ...grpc.CallOption) (*QueryParametersResponse, error)
}
type queryClient struct {
cc grpc1.ClientConn
}
func NewQueryClient(cc grpc1.ClientConn) QueryClient {
return &queryClient{cc}
}
func (c *queryClient) Parameters(ctx context.Context, in *QueryParametersRequest, opts ...grpc.CallOption) (*QueryParametersResponse, error) {
out := new(QueryParametersResponse)
err := c.cc.Invoke(ctx, "/cosmos.params.Query/Parameters", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QueryServer is the server API for Query service.
type QueryServer interface {
// Parameters queries all params
Parameters(context.Context, *QueryParametersRequest) (*QueryParametersResponse, error)
}
// UnimplementedQueryServer can be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}
func (*UnimplementedQueryServer) Parameters(ctx context.Context, req *QueryParametersRequest) (*QueryParametersResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Parameters not implemented")
}
func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
s.RegisterService(&_Query_serviceDesc, srv)
}
func _Query_Parameters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(QueryParametersRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).Parameters(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/cosmos.params.Query/Parameters",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).Parameters(ctx, req.(*QueryParametersRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Query_serviceDesc = grpc.ServiceDesc{
ServiceName: "cosmos.params.Query",
HandlerType: (*QueryServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "Parameters",
Handler: _Query_Parameters_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "cosmos/params/query.proto",
}
func (m *QueryParametersRequest) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryParametersRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryParametersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Key) > 0 {
i -= len(m.Key)
copy(dAtA[i:], m.Key)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Key)))
i--
dAtA[i] = 0x12
}
if len(m.Subspace) > 0 {
i -= len(m.Subspace)
copy(dAtA[i:], m.Subspace)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Subspace)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *QueryParametersResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryParametersResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryParametersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
offset -= sovQuery(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *QueryParametersRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Subspace)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.Key)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *QueryParametersResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.Params.Size()
n += 1 + l + sovQuery(uint64(l))
return n
}
func sovQuery(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryParametersRequest) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryParametersRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryParametersRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Subspace", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Subspace = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Key = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QueryParametersResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: QueryParametersResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryParametersResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowQuery
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowQuery
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowQuery
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthQuery
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupQuery
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthQuery
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)