diff --git a/CHANGELOG.md b/CHANGELOG.md index 124d3495..d8325681 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog -This is the changelog for NeoFS Proto +This is the changelog for NeoFS API + +## [0.4.0] - 2020-02-18 + +### Added +- Meta header for all gRPC responses. It contains epoch stamp and version number. +### Changed +- Endianness in accounting cheque. Now it uses little endian for cheaper +decoding in neofs smart-contract. ## [0.3.2] - 2020-02-10 @@ -189,3 +197,4 @@ Initial public release [0.3.0]: https://github.com/nspcc-dev/neofs-api/compare/v0.2.14...v0.3.0 [0.3.1]: https://github.com/nspcc-dev/neofs-api/compare/v0.3.0...v0.3.1 [0.3.2]: https://github.com/nspcc-dev/neofs-api/compare/v0.3.1...v0.3.2 +[0.4.0]: https://github.com/nspcc-dev/neofs-api/compare/v0.3.2...v0.4.0 diff --git a/accounting/fixtures/cheque.sh b/accounting/fixtures/cheque.sh index 93368138..581402a9 100755 --- a/accounting/fixtures/cheque.sh +++ b/accounting/fixtures/cheque.sh @@ -1,6 +1,6 @@ #!/bin/bash -CHEQUE=d6520dabb6cb9b981792608c73670eff14775e9a65bbc189271723ba2703c53263e8d6e522dc32203339dcd8eee9c6b7439a0000000053724e000000000000001e61000603012d47e76210aec73be39ab3d186e0a40fe8d86bfa3d4fabfda57ba13b88f96abe1de4c7ecd46cb32081c0ff199e0b32708d2ce709dd146ce096484073a9b15a259ca799f8d848eb5bea16f6d0842a0181ccd47384af2cdb0fd0af0819e8a08802f7528ce97c9a93558efe7d4f62577aabdf771c931f54a71be6ad21e7d9cc1777686ad19b5dc4b80d7b8decf90054c5aad66c0e6fe63d8473b751cd77c1bd0557516e0f3e7d0ccb485809023b0c08a89f33ae38b2f99ce3f1ebc7905dddf0ed0f023e00f03a16e8707ce045eb42ee80d392451541ee510dc18e1c8befbac54d7426087d37d32d836537d317deafbbd193002a36f80fbdfbf3a730cf011bc6c75c7e6d5724f3adee7015fcb3068d321e2ae555e79107be0c46070efdae2f724dbc9f0340750b92789821683283bcb98e32b7e032b94f267b6964613fc31a7ce5813fddeea47a1db525634237e924178b5c8ea745549ae60aa3570ce6cf52e370e6ab87652bdf8a179176f1acaf48896bef9ab300818a53f410d86241d506a550f4915403fef27f744e829131d0ec980829fafa51db1714c2761d9f78762c008c323e9d6612e4f9efdc609f191fd9ca5431dd9dc037130150107ab8769780d728e9ffdf314019b57c8d2b940b9ec078afa951ed8b06c1bf352edd2037e29b8f24cca3ec700368a6f5829fb2a34fa03d0308ae6b05f433f2904d9a852fed1f5d2eb598ca79475b74ef6394e712d275cd798062c6d8e41fad822ac5a4fcb167f0a2e196f61f9f65a0adef9650f49150e7eb7bb08dd1739fa6e86b341f1b2cf5657fcd200637e8 +CHEQUE=7849b02d01cc7f7734295fa815ea64ec4d2012e45b8781eb891723ba2703c53263e8d6e522dc32203339dcd8eee9c6b7439a00ea56fa00000000611e000000000000060003012d47e76210aec73be39ab3d186e0a40fe8d86bfa3d4fabfda57ba13b88f96a8ebe4360627a1326f13fb9516c0dbc4af90f116e44bd33f4d04a0d1633afa243ad4f2fa9cd933e7631a619b5132cec6983906aba757af5590434124b232a43e302f7528ce97c9a93558efe7d4f62577aabdf771c931f54a71be6ad21e7d9cc177744b4b9781cf0c29adb503f33d2df9f810ebf33a774849848984cf7e2bbebd48ef0cd8592fbf9b6aee1dc74803e31c95a02dbbd5fd9783f9ecbcbf444b5942f830368a6f5829fb2a34fa03d0308ae6b05f433f2904d9a852fed1f5d2eb598ca794770adb1ece9dccd1c7ad98f709cfb890e3bdd5973dcdd838111fae2efa4c3c09ea2133e5d7c6eac6ae24afcce46db7c9f4dc154f123c835adff4e0b7e19bcffda0340750b92789821683283bcb98e32b7e032b94f267b6964613fc31a7ce5813fddad8298f71dfdc4f9b3e353f969727af476d43b12a25727cf6b9c73ae7152266d995bec807068ad2156288c4d946aeb17ebca787d498a1b87b9dae1bcd935763403fef27f744e829131d0ec980829fafa51db1714c2761d9f78762c008c323e9d66db9b5086d355897e52fe065e14f1cc70334248349aa4c7a3e6e3dc8f8693b1511c73dc88e6d6e8b6c6c68de922f351b5b1543917af2f2a3588aebfbd1ff3fac6023e00f03a16e8707ce045eb42ee80d392451541ee510dc18e1c8befbac54d742648b58f379b5337d9b74c5a61afb8ef3db7f3eb0454d6823777b613a3ee22cd6ce47e4fa72170d49267b773cc09c123654e0bcd7278aa2ae1e7c85d049b557a3c DIR=$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd ) echo $CHEQUE | xxd -p -r > $DIR/cheque_data diff --git a/accounting/fixtures/cheque_data b/accounting/fixtures/cheque_data index cd7b2866..a1530960 100644 Binary files a/accounting/fixtures/cheque_data and b/accounting/fixtures/cheque_data differ diff --git a/accounting/types.go b/accounting/types.go index af883a29..a100cf2f 100644 --- a/accounting/types.go +++ b/accounting/types.go @@ -169,10 +169,10 @@ func (b *Cheque) marshalBody() []byte { offset += copy(buf, b.ID.Bytes()) offset += copy(buf[offset:], b.Owner.Bytes()) - binary.BigEndian.PutUint64(buf[offset:], uint64(b.Amount.Value)) + binary.LittleEndian.PutUint64(buf[offset:], uint64(b.Amount.Value)) offset += u64size - binary.BigEndian.PutUint64(buf[offset:], b.Height) + binary.LittleEndian.PutUint64(buf[offset:], b.Height) return buf } @@ -199,13 +199,13 @@ func (b *Cheque) unmarshalBody(buf []byte) error { } { // unmarshal amount - amount := int64(binary.BigEndian.Uint64(buf[offset:])) + amount := int64(binary.LittleEndian.Uint64(buf[offset:])) b.Amount = decimal.New(amount) offset += u64size } { // unmarshal height - b.Height = binary.BigEndian.Uint64(buf[offset:]) + b.Height = binary.LittleEndian.Uint64(buf[offset:]) offset += u64size } @@ -220,7 +220,7 @@ func (b Cheque) MarshalBinary() ([]byte, error) { offset = copy(buf, b.marshalBody()) ) - binary.BigEndian.PutUint16(buf[offset:], uint16(count)) + binary.LittleEndian.PutUint16(buf[offset:], uint16(count)) offset += u16size for _, sign := range b.Signatures { @@ -246,7 +246,7 @@ func (b *Cheque) UnmarshalBinary(buf []byte) error { body := buf[:signaturesOffset] - count := int64(binary.BigEndian.Uint16(buf[signaturesOffset:])) + count := int64(binary.LittleEndian.Uint16(buf[signaturesOffset:])) offset := signaturesOffset + u16size if ln := count * int64(crypto.PublicKeyCompressedSize+crypto.RFC6979SignatureSize); ln > int64(len(buf[offset:])) { diff --git a/accounting/types_test.go b/accounting/types_test.go index 424993a8..14aee3b7 100644 --- a/accounting/types_test.go +++ b/accounting/types_test.go @@ -80,5 +80,7 @@ func TestCheque(t *testing.T) { require.Equal(t, expect, actual) require.NoError(t, cheque.Verify()) + require.Equal(t, cheque.Height, uint64(7777)) + require.Equal(t, cheque.Amount, decimal.NewGAS(42)) }) } diff --git a/docs/object.md b/docs/object.md index d13b6768..ce9252bc 100644 --- a/docs/object.md +++ b/docs/object.md @@ -161,6 +161,10 @@ DeleteResponse is empty because we cannot guarantee permanent object removal in distributed system. +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | + @@ -186,6 +190,7 @@ in distributed system. | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | Hashes | [bytes](#bytes) | repeated | Hashes is a homomorphic hashes of all ranges | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | @@ -211,6 +216,7 @@ in distributed system. | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | Fragment | [bytes](#bytes) | | Fragment of object's payload | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | @@ -237,6 +243,7 @@ in distributed system. | ----- | ---- | ----- | ----------- | | object | [Object](#object.Object) | | Object header and some payload | | Chunk | [bytes](#bytes) | | Chunk of remaining payload | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | @@ -263,6 +270,7 @@ in distributed system. | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | Object | [Object](#object.Object) | | Object without payload | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | @@ -300,6 +308,7 @@ in distributed system. | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | Address | [refs.Address](#refs.Address) | | Address of object (container id + object id) | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | @@ -326,6 +335,7 @@ in distributed system. | Field | Type | Label | Description | | ----- | ---- | ----- | ----------- | | Addresses | [refs.Address](#refs.Address) | repeated | Addresses of found objects | +| Meta | [service.ResponseMetaHeader](#service.ResponseMetaHeader) | | ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) | diff --git a/docs/service.md b/docs/service.md index 454fab42..90e1bd2b 100644 --- a/docs/service.md +++ b/docs/service.md @@ -7,6 +7,7 @@ - Messages - [RequestMetaHeader](#service.RequestMetaHeader) + - [ResponseMetaHeader](#service.ResponseMetaHeader) - [service/verify.proto](#service/verify.proto) @@ -49,6 +50,19 @@ RequestMetaHeader contains information about request meta headers | Epoch | [uint64](#uint64) | | Epoch for user can be empty, because node sets epoch to the actual value | | Version | [uint32](#uint32) | | Version defines protocol version TODO: not used for now, should be implemented in future | + + + +### Message ResponseMetaHeader +ResponseMetaHeader contains meta information based on request processing by server +(should be embedded into message) + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| Epoch | [uint64](#uint64) | | Current NeoFS epoch on server | +| Version | [uint32](#uint32) | | Version defines protocol version TODO: not used for now, should be implemented in future | + diff --git a/object/service.pb.go b/object/service.pb.go index 1ecf6d9b..46891e2f 100644 --- a/object/service.pb.go +++ b/object/service.pb.go @@ -91,10 +91,12 @@ type GetResponse struct { // Types that are valid to be assigned to R: // *GetResponse_Object // *GetResponse_Chunk - R isGetResponse_R `protobuf_oneof:"R"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + R isGetResponse_R `protobuf_oneof:"R"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetResponse) Reset() { *m = GetResponse{} } @@ -314,10 +316,12 @@ func (m *PutRequest_PutHeader) GetToken() *session.Token { type PutResponse struct { // Address of object (container id + object id) - Address refs.Address `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Address refs.Address `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *PutResponse) Reset() { *m = PutResponse{} } @@ -418,9 +422,11 @@ func (m *DeleteRequest) GetToken() *session.Token { // DeleteResponse is empty because we cannot guarantee permanent object removal // in distributed system. type DeleteResponse struct { - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } @@ -513,10 +519,12 @@ func (m *HeadRequest) GetRaw() bool { type HeadResponse struct { // Object without payload - Object *Object `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Object *Object `protobuf:"bytes,1,opt,name=Object,proto3" json:"Object,omitempty"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *HeadResponse) Reset() { *m = HeadResponse{} } @@ -616,10 +624,12 @@ func (m *SearchRequest) GetQueryVersion() uint32 { type SearchResponse struct { // Addresses of found objects - Addresses []refs.Address `protobuf:"bytes,1,rep,name=Addresses,proto3" json:"Addresses"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Addresses []refs.Address `protobuf:"bytes,1,rep,name=Addresses,proto3" json:"Addresses"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *SearchResponse) Reset() { *m = SearchResponse{} } @@ -717,10 +727,12 @@ func (m *GetRangeRequest) GetRange() Range { type GetRangeResponse struct { // Fragment of object's payload - Fragment []byte `protobuf:"bytes,1,opt,name=Fragment,proto3" json:"Fragment,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Fragment []byte `protobuf:"bytes,1,opt,name=Fragment,proto3" json:"Fragment,omitempty"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetRangeResponse) Reset() { *m = GetRangeResponse{} } @@ -827,10 +839,12 @@ func (m *GetRangeHashRequest) GetSalt() []byte { type GetRangeHashResponse struct { // Hashes is a homomorphic hashes of all ranges - Hashes []Hash `protobuf:"bytes,1,rep,name=Hashes,proto3,customtype=Hash" json:"Hashes"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + Hashes []Hash `protobuf:"bytes,1,rep,name=Hashes,proto3,customtype=Hash" json:"Hashes"` + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader `protobuf:"bytes,99,opt,name=Meta,proto3,embedded=Meta" json:"Meta"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *GetRangeHashResponse) Reset() { *m = GetRangeHashResponse{} } @@ -883,62 +897,64 @@ func init() { func init() { proto.RegisterFile("object/service.proto", fileDescriptor_dfcdf610ade6a9ce) } var fileDescriptor_dfcdf610ade6a9ce = []byte{ - // 874 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcd, 0x6e, 0xe3, 0x54, - 0x14, 0xce, 0x8d, 0x13, 0x37, 0x73, 0xe2, 0x74, 0xa2, 0xdb, 0x30, 0x44, 0x66, 0x94, 0x56, 0xd6, - 0x80, 0x82, 0x50, 0x9c, 0x32, 0x48, 0xc3, 0x20, 0x8d, 0x84, 0x26, 0x89, 0x3a, 0xc9, 0x82, 0xb6, - 0xdc, 0x54, 0x95, 0x60, 0xe7, 0x38, 0x37, 0x89, 0x69, 0x6a, 0x07, 0xff, 0xb4, 0xea, 0x03, 0xb0, - 0x66, 0xcb, 0x92, 0x35, 0xcf, 0xc0, 0x03, 0x74, 0x83, 0xd4, 0x25, 0x62, 0x51, 0xa1, 0xb0, 0xe4, - 0x05, 0x90, 0xd8, 0xa0, 0xfb, 0xe3, 0xd8, 0x6e, 0x69, 0x81, 0x6e, 0xc2, 0x2a, 0xf7, 0x7e, 0xe7, - 0x3b, 0xe7, 0xe6, 0x7c, 0xfe, 0xce, 0xb5, 0xa1, 0xe6, 0x8d, 0xbe, 0xa2, 0x76, 0xd8, 0x0e, 0xa8, - 0x7f, 0xe6, 0xd8, 0xd4, 0x5c, 0xf8, 0x5e, 0xe8, 0x61, 0x55, 0xa0, 0x7a, 0xd5, 0xa7, 0x93, 0xa0, - 0x1d, 0x5e, 0x2c, 0x68, 0x20, 0x22, 0x3a, 0x96, 0xfc, 0x34, 0xb6, 0x15, 0xd0, 0x20, 0x70, 0x3c, - 0x37, 0x4b, 0x94, 0x15, 0xdb, 0xa7, 0x34, 0xb4, 0x24, 0x56, 0x8b, 0xb1, 0x33, 0xea, 0x3b, 0x93, - 0x0b, 0x89, 0xb6, 0xa6, 0x4e, 0x38, 0x8b, 0x46, 0xa6, 0xed, 0x9d, 0xb6, 0xa7, 0xde, 0xd4, 0x6b, - 0x73, 0x78, 0x14, 0x4d, 0xf8, 0x8e, 0x6f, 0xf8, 0x4a, 0xd0, 0x8d, 0x9f, 0x10, 0xc0, 0x1b, 0x1a, - 0x12, 0xfa, 0x75, 0x44, 0x83, 0x10, 0xb7, 0x60, 0xe3, 0xf5, 0x78, 0xec, 0xd3, 0x20, 0xa8, 0xa3, - 0x1d, 0xd4, 0x2c, 0x3f, 0xaf, 0x98, 0xec, 0x4f, 0x9b, 0x12, 0xec, 0x14, 0x2e, 0xaf, 0xb7, 0x73, - 0x24, 0xe6, 0xe0, 0x2a, 0x28, 0xc4, 0x3a, 0xaf, 0xe7, 0x77, 0x50, 0xb3, 0x44, 0xd8, 0x12, 0xbf, - 0x84, 0xc2, 0x67, 0x34, 0xb4, 0xea, 0x23, 0x9e, 0xad, 0x9b, 0xb1, 0x12, 0xf2, 0x00, 0x16, 0xeb, - 0x53, 0x6b, 0x4c, 0xfd, 0x4e, 0x89, 0x95, 0xba, 0xba, 0xde, 0x46, 0x84, 0x67, 0xe0, 0x1e, 0xa8, - 0xc7, 0xbc, 0x91, 0xba, 0xcd, 0x73, 0x8d, 0x9b, 0xb9, 0x3c, 0xea, 0xd8, 0x56, 0xe8, 0x78, 0xee, - 0xad, 0x1a, 0x32, 0xd7, 0x38, 0x82, 0x32, 0x6f, 0x27, 0x58, 0x78, 0x6e, 0x40, 0x71, 0x13, 0xa4, - 0xf8, 0xb2, 0x9d, 0x4d, 0x53, 0x6c, 0xcd, 0x03, 0xfe, 0xd3, 0xcf, 0x11, 0x19, 0xc7, 0x4f, 0xa0, - 0xd8, 0x9d, 0x45, 0xee, 0x09, 0x6f, 0x46, 0xeb, 0xe7, 0x88, 0xd8, 0x76, 0x14, 0x40, 0xc4, 0xf8, - 0x31, 0x0f, 0x70, 0x18, 0xad, 0x54, 0x7a, 0x01, 0xaa, 0xf8, 0x03, 0xb2, 0xea, 0xd3, 0xb8, 0x6a, - 0xc2, 0x61, 0x4b, 0xc1, 0x61, 0x67, 0x88, 0xd5, 0x5d, 0x67, 0xac, 0x5b, 0x34, 0xfd, 0x0b, 0x78, - 0xb4, 0xfa, 0xbb, 0xf8, 0x3d, 0x50, 0x0f, 0xee, 0x91, 0x8c, 0xc8, 0x28, 0x7e, 0x06, 0xc5, 0x23, - 0xef, 0x84, 0xba, 0xbc, 0x19, 0x46, 0x93, 0xbe, 0x35, 0x39, 0x4a, 0x44, 0x50, 0xc8, 0xf7, 0x0a, - 0xca, 0x5c, 0x19, 0xf9, 0x50, 0xfe, 0x9b, 0xc9, 0x8c, 0x6f, 0xf3, 0x50, 0xe9, 0xd1, 0x39, 0x0d, - 0xe9, 0x03, 0x5d, 0xfa, 0x3e, 0x6c, 0x1c, 0x9c, 0xbb, 0xd4, 0x1f, 0xf4, 0x84, 0xf0, 0x9d, 0xc7, - 0x2c, 0xfe, 0xcb, 0xf5, 0x76, 0x0c, 0x93, 0x78, 0x91, 0x34, 0xa5, 0xdc, 0xd3, 0xd4, 0xda, 0x4d, - 0x5e, 0x85, 0xcd, 0x58, 0x10, 0x21, 0xa9, 0xf1, 0x27, 0x82, 0x32, 0xa3, 0xc7, 0x0a, 0xbd, 0xfc, - 0x07, 0x85, 0x56, 0x0a, 0x48, 0x20, 0x11, 0x6b, 0x07, 0xca, 0x7b, 0xd1, 0x7c, 0x2e, 0xce, 0x0e, - 0xe4, 0x68, 0xa7, 0xa1, 0x78, 0xe8, 0x95, 0xff, 0xcf, 0xd0, 0xbf, 0x00, 0x4d, 0x34, 0x2f, 0x0d, - 0xf6, 0x2f, 0x2d, 0x6c, 0xfc, 0x81, 0xa0, 0x32, 0xa4, 0x96, 0x6f, 0xcf, 0x12, 0x67, 0x95, 0xbb, - 0x9e, 0x1b, 0x5a, 0x8e, 0xb0, 0x0b, 0xe2, 0x76, 0x29, 0x4b, 0xb1, 0x94, 0xee, 0xa0, 0x47, 0xd2, - 0x71, 0x5c, 0x83, 0xe2, 0xe7, 0x11, 0xf5, 0x2f, 0x84, 0xaf, 0x88, 0xd8, 0x60, 0x03, 0x34, 0xbe, - 0x38, 0xa6, 0x3e, 0xf3, 0x0e, 0x57, 0xaa, 0x42, 0x32, 0xd8, 0xda, 0x25, 0xeb, 0xc2, 0x66, 0xdc, - 0xb9, 0x14, 0xed, 0x43, 0x78, 0x24, 0x3d, 0x40, 0x99, 0x69, 0x94, 0xbb, 0xc6, 0x2a, 0x61, 0x19, - 0xbf, 0x23, 0x78, 0xcc, 0x6e, 0x5b, 0xcb, 0x9d, 0x3e, 0x7c, 0x36, 0x8b, 0x3c, 0x5d, 0xde, 0x22, - 0x95, 0xf8, 0x49, 0x71, 0x50, 0x92, 0x05, 0x63, 0xed, 0x92, 0x99, 0x50, 0x4d, 0x9a, 0x95, 0xa2, - 0xe9, 0x50, 0xda, 0xf3, 0xad, 0xe9, 0x29, 0x75, 0x85, 0xd7, 0x34, 0xb2, 0xda, 0x1b, 0xdf, 0xe4, - 0x61, 0x2b, 0x4e, 0xe8, 0x5b, 0xc1, 0xec, 0x81, 0x0a, 0x7d, 0x00, 0x2a, 0x2f, 0xc1, 0x66, 0x51, - 0xb9, 0x4b, 0x22, 0x49, 0xc1, 0x18, 0x0a, 0x43, 0x6b, 0x1e, 0x72, 0xcb, 0x69, 0x84, 0xaf, 0xd7, - 0xae, 0xdb, 0x2b, 0xa8, 0x65, 0x65, 0x90, 0xda, 0x3d, 0x03, 0x95, 0xed, 0xa5, 0xdb, 0xb4, 0x8e, - 0x26, 0xc7, 0xac, 0xc0, 0x59, 0x32, 0xf6, 0xfc, 0x7b, 0x05, 0x36, 0x86, 0xe2, 0x54, 0xbc, 0x0b, - 0xca, 0x1b, 0x1a, 0x62, 0x1c, 0x2b, 0x90, 0x7c, 0xb8, 0xe8, 0x5b, 0x19, 0x4c, 0x9c, 0xb0, 0x8b, - 0x58, 0xc6, 0x61, 0x94, 0xca, 0x48, 0x5e, 0xd0, 0x49, 0x46, 0xea, 0xd5, 0xd4, 0x44, 0xf8, 0x63, - 0x50, 0xc5, 0xdd, 0x8a, 0xdf, 0x8a, 0x09, 0x99, 0x97, 0x8f, 0xfe, 0xe4, 0x26, 0xbc, 0x9a, 0x9f, - 0x02, 0x93, 0x00, 0xaf, 0xea, 0xa6, 0xee, 0x63, 0xbd, 0x96, 0x05, 0x65, 0xca, 0x27, 0xa0, 0x8a, - 0x21, 0x4c, 0xce, 0xca, 0x5c, 0x47, 0xc9, 0x59, 0xd9, 0x59, 0xdd, 0x45, 0xf8, 0x53, 0x28, 0xc5, - 0xa2, 0xe2, 0xb7, 0xd3, 0xbd, 0xa7, 0x66, 0x51, 0xaf, 0xdf, 0x0e, 0xac, 0x0a, 0x0c, 0x40, 0x4b, - 0x3f, 0x15, 0xfc, 0xce, 0x4d, 0x6e, 0xca, 0xb2, 0xfa, 0xd3, 0xbf, 0x0f, 0x8a, 0x62, 0x9d, 0xfd, - 0xcb, 0x65, 0x03, 0x5d, 0x2d, 0x1b, 0xe8, 0xe7, 0x65, 0x03, 0xfd, 0xba, 0x6c, 0xa0, 0xef, 0x7e, - 0x6b, 0xe4, 0xbe, 0x7c, 0x37, 0xf5, 0x21, 0xea, 0x06, 0x0b, 0xdb, 0x6e, 0x8d, 0xe9, 0x59, 0xdb, - 0xa5, 0xde, 0x24, 0x68, 0x59, 0x0b, 0xa7, 0x2d, 0x2a, 0xfe, 0x90, 0xaf, 0xee, 0x53, 0x6f, 0x6f, - 0x68, 0xbe, 0x3e, 0x1c, 0xc8, 0xeb, 0x79, 0xa4, 0xf2, 0x4f, 0xd3, 0x8f, 0xfe, 0x0a, 0x00, 0x00, - 0xff, 0xff, 0x4f, 0x13, 0xa2, 0x69, 0x4e, 0x0b, 0x00, 0x00, + // 905 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x57, 0x4f, 0x6f, 0x1b, 0x45, + 0x14, 0xcf, 0x78, 0xed, 0x8d, 0xfb, 0xbc, 0x4e, 0xad, 0x89, 0x29, 0xd6, 0xb6, 0x72, 0x22, 0xab, + 0x20, 0x23, 0xe4, 0x75, 0x28, 0x12, 0x94, 0x13, 0xaa, 0x63, 0xa5, 0xb6, 0x10, 0x4d, 0x18, 0xa3, + 0x4a, 0x70, 0x5b, 0xaf, 0xc7, 0xf6, 0x52, 0x67, 0xd7, 0xdd, 0x3f, 0xb1, 0x72, 0xe1, 0xc6, 0xb9, + 0x57, 0x8e, 0x9c, 0xf9, 0x0c, 0x7c, 0x80, 0x5e, 0x90, 0x7a, 0x44, 0x1c, 0x22, 0x64, 0x8e, 0x7c, + 0x01, 0x24, 0x2e, 0x68, 0xfe, 0xec, 0xbf, 0x14, 0x07, 0xb0, 0x0f, 0xee, 0xc9, 0x33, 0xbf, 0xf7, + 0x7b, 0x6f, 0xe6, 0xfd, 0xe6, 0xcd, 0x1b, 0x2f, 0x54, 0xdd, 0xe1, 0x37, 0xd4, 0x0a, 0xda, 0x3e, + 0xf5, 0x2e, 0x6c, 0x8b, 0x1a, 0x73, 0xcf, 0x0d, 0x5c, 0xac, 0x0a, 0x54, 0xaf, 0x78, 0x74, 0xec, + 0xb7, 0x83, 0xcb, 0x39, 0xf5, 0x85, 0x45, 0xc7, 0x92, 0x9f, 0xc6, 0xf6, 0x7d, 0xea, 0xfb, 0xb6, + 0xeb, 0x64, 0x89, 0x32, 0x62, 0xfb, 0x9c, 0x06, 0xa6, 0xc4, 0xaa, 0x11, 0x76, 0x41, 0x3d, 0x7b, + 0x7c, 0x29, 0xd1, 0xd6, 0xc4, 0x0e, 0xa6, 0xe1, 0xd0, 0xb0, 0xdc, 0xf3, 0xf6, 0xc4, 0x9d, 0xb8, + 0x6d, 0x0e, 0x0f, 0xc3, 0x31, 0x9f, 0xf1, 0x09, 0x1f, 0x09, 0x7a, 0xe3, 0x67, 0x04, 0xf0, 0x98, + 0x06, 0x84, 0x3e, 0x0f, 0xa9, 0x1f, 0xe0, 0x16, 0xec, 0x3e, 0x1a, 0x8d, 0x3c, 0xea, 0xfb, 0x35, + 0x74, 0x88, 0x9a, 0xa5, 0x07, 0x65, 0x83, 0x6d, 0xda, 0x90, 0x60, 0x27, 0xff, 0xf2, 0xea, 0x60, + 0x87, 0x44, 0x1c, 0x5c, 0x01, 0x85, 0x98, 0x8b, 0x5a, 0xee, 0x10, 0x35, 0x8b, 0x84, 0x0d, 0xf1, + 0x43, 0xc8, 0x7f, 0x4e, 0x03, 0xb3, 0x36, 0xe4, 0xde, 0xba, 0x11, 0x29, 0x21, 0x17, 0x60, 0xb6, + 0x1e, 0x35, 0x47, 0xd4, 0xeb, 0x14, 0x59, 0xa8, 0x57, 0x57, 0x07, 0x88, 0x70, 0x0f, 0xdc, 0x05, + 0xf5, 0x29, 0x4f, 0xa4, 0x66, 0x71, 0xdf, 0xc6, 0x75, 0x5f, 0x6e, 0xb5, 0x2d, 0x33, 0xb0, 0x5d, + 0xe7, 0xb5, 0x18, 0xd2, 0xb7, 0xf1, 0x02, 0x41, 0x89, 0xe7, 0xe3, 0xcf, 0x5d, 0xc7, 0xa7, 0xb8, + 0x09, 0x52, 0x7d, 0x99, 0xcf, 0x9e, 0x21, 0xa6, 0xc6, 0x29, 0xff, 0xe9, 0xed, 0x10, 0x69, 0xc7, + 0x77, 0xa0, 0x70, 0x3c, 0x0d, 0x9d, 0x67, 0x3c, 0x1b, 0xad, 0xb7, 0x43, 0xc4, 0x14, 0x7f, 0x22, + 0x33, 0x12, 0xbb, 0xba, 0x9b, 0xda, 0x95, 0x58, 0x62, 0x75, 0x4a, 0x1d, 0x05, 0x10, 0x69, 0xfc, + 0x94, 0x03, 0x38, 0x0b, 0x63, 0x85, 0x3f, 0x02, 0x55, 0xb0, 0xe5, 0x86, 0xee, 0x45, 0x1b, 0x4a, + 0x38, 0x6c, 0x28, 0x38, 0x6c, 0x7b, 0x62, 0xb4, 0x72, 0x7b, 0x5b, 0x16, 0x5c, 0xff, 0x0a, 0x6e, + 0xc5, 0xdb, 0xc5, 0xef, 0x82, 0x7a, 0x7a, 0x83, 0xda, 0x44, 0x5a, 0xf1, 0x7d, 0x28, 0x7c, 0xe9, + 0x3e, 0xa3, 0x0e, 0x4f, 0x86, 0xd1, 0x64, 0xcd, 0x1b, 0x1c, 0x25, 0xc2, 0x28, 0xe4, 0x5b, 0x40, + 0x89, 0x2b, 0x23, 0xcf, 0xf3, 0x7f, 0x16, 0xe8, 0xfa, 0x87, 0xd7, 0x78, 0x91, 0x83, 0x72, 0x97, + 0xce, 0x68, 0x40, 0xd7, 0xbc, 0x1c, 0xef, 0xc1, 0xee, 0xe9, 0xc2, 0xa1, 0x5e, 0xbf, 0x2b, 0xce, + 0xac, 0x73, 0x9b, 0xd9, 0x7f, 0xbd, 0x3a, 0x88, 0x60, 0x12, 0x0d, 0x12, 0x3d, 0x94, 0x1b, 0xf4, + 0xd8, 0xfa, 0xdd, 0xfa, 0x0c, 0xf6, 0x22, 0x41, 0xe4, 0x69, 0x6c, 0x20, 0xef, 0x5f, 0x08, 0x4a, + 0xcc, 0x14, 0x89, 0xfb, 0xf0, 0x5f, 0xc4, 0x8d, 0xc5, 0x93, 0x40, 0xa2, 0xf3, 0x21, 0x94, 0x4e, + 0xc2, 0xd9, 0x4c, 0xac, 0xe3, 0xcb, 0x66, 0x94, 0x86, 0xa2, 0x36, 0xa5, 0xbc, 0x39, 0x6d, 0xea, + 0x39, 0x68, 0x22, 0x79, 0x29, 0xe4, 0x7f, 0xbd, 0x38, 0x1b, 0x08, 0xfe, 0x27, 0x82, 0xf2, 0x80, + 0x9a, 0x9e, 0x35, 0x4d, 0xea, 0xb9, 0x74, 0xec, 0x3a, 0x81, 0x69, 0x8b, 0x22, 0x45, 0xbc, 0x48, + 0x4b, 0x52, 0x67, 0xe5, 0xb8, 0xdf, 0x25, 0x69, 0x3b, 0xae, 0x42, 0xe1, 0x8b, 0x90, 0x7a, 0x97, + 0xa2, 0x9a, 0x89, 0x98, 0xe0, 0x06, 0x68, 0x7c, 0xf0, 0x94, 0x7a, 0xac, 0x62, 0xb9, 0xc8, 0x65, + 0x92, 0xc1, 0xb6, 0xae, 0xf6, 0xb7, 0xb0, 0x17, 0x65, 0x2e, 0xf5, 0xfe, 0x00, 0x6e, 0xc9, 0xf2, + 0xa1, 0xac, 0xde, 0x94, 0x55, 0x97, 0x39, 0x61, 0x6d, 0x22, 0xfd, 0x1f, 0x08, 0x6e, 0xb3, 0x47, + 0xc9, 0x74, 0x26, 0xeb, 0x37, 0x93, 0x02, 0x77, 0x97, 0x1d, 0xb3, 0x1c, 0xd5, 0x07, 0x07, 0x25, + 0x59, 0x30, 0xb6, 0xae, 0xb6, 0x0d, 0x95, 0x24, 0x59, 0xa9, 0xb7, 0x0e, 0xc5, 0x13, 0xcf, 0x9c, + 0x9c, 0x53, 0x47, 0x54, 0xb8, 0x46, 0xe2, 0xf9, 0x26, 0xc2, 0x7e, 0x97, 0x83, 0xfd, 0x68, 0xad, + 0x9e, 0xe9, 0x4f, 0xd7, 0x14, 0xf7, 0x7d, 0x50, 0x79, 0x08, 0xd6, 0x3c, 0x94, 0x55, 0xea, 0x4a, + 0x0a, 0xc6, 0x90, 0x1f, 0x98, 0xb3, 0x80, 0x17, 0xba, 0x46, 0xf8, 0x78, 0xeb, 0x92, 0x2f, 0xa0, + 0x9a, 0x95, 0x41, 0xca, 0x7e, 0x1f, 0x54, 0x36, 0x97, 0x35, 0xae, 0x75, 0x34, 0x79, 0xb9, 0xf3, + 0x9c, 0x25, 0x6d, 0x1b, 0x1c, 0xc0, 0x83, 0x1f, 0x14, 0xd8, 0x1d, 0x08, 0x3a, 0x3e, 0x02, 0xe5, + 0x31, 0x0d, 0x30, 0x8e, 0xc4, 0x4b, 0xfe, 0x56, 0xea, 0xfb, 0x19, 0x4c, 0x44, 0x3d, 0x42, 0xcc, + 0xe3, 0x2c, 0x4c, 0x79, 0x24, 0x7f, 0x81, 0x12, 0x8f, 0xd4, 0xe3, 0xdf, 0x44, 0xf8, 0x63, 0x50, + 0xc5, 0x13, 0x84, 0xdf, 0x8a, 0x08, 0x99, 0x37, 0x5a, 0xbf, 0x73, 0x1d, 0x8e, 0x2f, 0x7c, 0x9e, + 0xa5, 0x80, 0xe3, 0xb8, 0xa9, 0xb7, 0x47, 0xaf, 0x66, 0xc1, 0xf8, 0x71, 0x53, 0x45, 0xd7, 0x48, + 0xd6, 0xca, 0xf4, 0xcf, 0x64, 0xad, 0x6c, 0x73, 0x39, 0x42, 0xf8, 0x53, 0x28, 0x46, 0xe7, 0x81, + 0xdf, 0x4e, 0xe7, 0x9e, 0xea, 0x00, 0x7a, 0xed, 0x75, 0x43, 0x1c, 0xa0, 0x0f, 0x5a, 0xfa, 0x40, + 0xf1, 0xdd, 0xeb, 0xdc, 0x54, 0xb5, 0xeb, 0xf7, 0xfe, 0xd9, 0x28, 0x82, 0x75, 0x9e, 0xbc, 0x5c, + 0xd6, 0xd1, 0xab, 0x65, 0x1d, 0xfd, 0xb2, 0xac, 0xa3, 0xdf, 0x96, 0x75, 0xf4, 0xfd, 0xef, 0xf5, + 0x9d, 0xaf, 0xdf, 0x49, 0x7d, 0x26, 0x38, 0xfe, 0xdc, 0xb2, 0x5a, 0x23, 0x7a, 0xd1, 0x76, 0xa8, + 0x3b, 0xf6, 0x5b, 0xe6, 0xdc, 0x6e, 0x8b, 0x88, 0x3f, 0xe6, 0x2a, 0x4f, 0xa8, 0x7b, 0x32, 0x30, + 0x1e, 0x9d, 0xf5, 0xe5, 0x53, 0x34, 0x54, 0xf9, 0x87, 0xc3, 0x87, 0x7f, 0x07, 0x00, 0x00, 0xff, + 0xff, 0xd3, 0xb9, 0x0e, 0x2b, 0xec, 0x0c, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1498,6 +1514,18 @@ func (m *GetResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a if m.R != nil { { size := m.R.Size() @@ -1719,6 +1747,18 @@ func (m *PutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a { size, err := m.Address.MarshalToSizedBuffer(dAtA[:i]) if err != nil { @@ -1839,6 +1879,18 @@ func (m *DeleteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a return len(dAtA) - i, nil } @@ -1947,6 +1999,18 @@ func (m *HeadResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a if m.Object != nil { { size, err := m.Object.MarshalToSizedBuffer(dAtA[:i]) @@ -2059,6 +2123,18 @@ func (m *SearchResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a if len(m.Addresses) > 0 { for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { { @@ -2171,6 +2247,18 @@ func (m *GetRangeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a if len(m.Fragment) > 0 { i -= len(m.Fragment) copy(dAtA[i:], m.Fragment) @@ -2287,6 +2375,18 @@ func (m *GetRangeHashResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + { + size, err := m.ResponseMetaHeader.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintService(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x6 + i-- + dAtA[i] = 0x9a if len(m.Hashes) > 0 { for iNdEx := len(m.Hashes) - 1; iNdEx >= 0; iNdEx-- { { @@ -2345,6 +2445,8 @@ func (m *GetResponse) Size() (n int) { if m.R != nil { n += m.R.Size() } + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2446,6 +2548,8 @@ func (m *PutResponse) Size() (n int) { _ = l l = m.Address.Size() n += 1 + l + sovService(uint64(l)) + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2482,6 +2586,8 @@ func (m *DeleteResponse) Size() (n int) { } var l int _ = l + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2522,6 +2628,8 @@ func (m *HeadResponse) Size() (n int) { l = m.Object.Size() n += 1 + l + sovService(uint64(l)) } + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2565,6 +2673,8 @@ func (m *SearchResponse) Size() (n int) { n += 1 + l + sovService(uint64(l)) } } + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2601,6 +2711,8 @@ func (m *GetRangeResponse) Size() (n int) { if l > 0 { n += 1 + l + sovService(uint64(l)) } + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2647,6 +2759,8 @@ func (m *GetRangeHashResponse) Size() (n int) { n += 1 + l + sovService(uint64(l)) } } + l = m.ResponseMetaHeader.Size() + n += 2 + l + sovService(uint64(l)) if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -2929,6 +3043,39 @@ func (m *GetResponse) Unmarshal(dAtA []byte) error { copy(v, dAtA[iNdEx:postIndex]) m.R = &GetResponse_Chunk{v} iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -3330,6 +3477,39 @@ func (m *PutResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -3606,6 +3786,39 @@ func (m *DeleteResponse) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: DeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -3889,6 +4102,39 @@ func (m *HeadResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -4183,6 +4429,39 @@ func (m *SearchResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -4457,6 +4736,39 @@ func (m *GetRangeResponse) Unmarshal(dAtA []byte) error { m.Fragment = []byte{} } iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) @@ -4767,6 +5079,39 @@ func (m *GetRangeHashResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 99: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ResponseMetaHeader", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowService + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthService + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthService + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ResponseMetaHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipService(dAtA[iNdEx:]) diff --git a/object/service.proto b/object/service.proto index f208472c..dbd2a809 100644 --- a/object/service.proto +++ b/object/service.proto @@ -73,6 +73,9 @@ message GetResponse { // Chunk of remaining payload bytes Chunk = 2; } + + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } message PutRequest { @@ -99,6 +102,8 @@ message PutRequest { message PutResponse { // Address of object (container id + object id) refs.Address Address = 1 [(gogoproto.nullable) = false]; + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } message DeleteRequest { // Address of object (container id + object id) @@ -115,7 +120,10 @@ message DeleteRequest { // DeleteResponse is empty because we cannot guarantee permanent object removal // in distributed system. -message DeleteResponse {} +message DeleteResponse { + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; +} message HeadRequest { // Address of object (container id + object id) @@ -132,6 +140,8 @@ message HeadRequest { message HeadResponse { // Object without payload Object Object = 1; + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } message SearchRequest { @@ -150,6 +160,8 @@ message SearchRequest { message SearchResponse { // Addresses of found objects repeated refs.Address Addresses = 1 [(gogoproto.nullable) = false]; + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } message GetRangeRequest { @@ -166,6 +178,8 @@ message GetRangeRequest { message GetRangeResponse { // Fragment of object's payload bytes Fragment = 1; + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } message GetRangeHashRequest { @@ -184,5 +198,7 @@ message GetRangeHashRequest { message GetRangeHashResponse { // Hashes is a homomorphic hashes of all ranges repeated bytes Hashes = 1 [(gogoproto.customtype) = "Hash", (gogoproto.nullable) = false]; + // ResponseMetaHeader contains meta information based on request processing by server (should be embedded into message) + service.ResponseMetaHeader Meta = 99 [(gogoproto.embed) = true, (gogoproto.nullable) = false]; } diff --git a/service/meta.go b/service/meta.go index 95c1b13a..dc2cdd36 100644 --- a/service/meta.go +++ b/service/meta.go @@ -62,6 +62,12 @@ const ( ErrIncorrectTTL = internal.Error("incorrect ttl") ) +// SetVersion sets protocol version to ResponseMetaHeader. +func (m *ResponseMetaHeader) SetVersion(v uint32) { m.Version = v } + +// SetEpoch sets Epoch to ResponseMetaHeader. +func (m *ResponseMetaHeader) SetEpoch(v uint64) { m.Epoch = v } + // SetVersion sets protocol version to RequestMetaHeader. func (m *RequestMetaHeader) SetVersion(v uint32) { m.Version = v } diff --git a/service/meta.pb.go b/service/meta.pb.go index 9b2f430e..b4769e22 100644 --- a/service/meta.pb.go +++ b/service/meta.pb.go @@ -88,14 +88,71 @@ func (m *RequestMetaHeader) GetVersion() uint32 { return 0 } +// ResponseMetaHeader contains meta information based on request processing by server +// (should be embedded into message) +type ResponseMetaHeader struct { + // Current NeoFS epoch on server + Epoch uint64 `protobuf:"varint,1,opt,name=Epoch,proto3" json:"Epoch,omitempty"` + // Version defines protocol version + // TODO: not used for now, should be implemented in future + Version uint32 `protobuf:"varint,2,opt,name=Version,proto3" json:"Version,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ResponseMetaHeader) Reset() { *m = ResponseMetaHeader{} } +func (m *ResponseMetaHeader) String() string { return proto.CompactTextString(m) } +func (*ResponseMetaHeader) ProtoMessage() {} +func (*ResponseMetaHeader) Descriptor() ([]byte, []int) { + return fileDescriptor_a638867e7b43457c, []int{1} +} +func (m *ResponseMetaHeader) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ResponseMetaHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil +} +func (m *ResponseMetaHeader) XXX_Merge(src proto.Message) { + xxx_messageInfo_ResponseMetaHeader.Merge(m, src) +} +func (m *ResponseMetaHeader) XXX_Size() int { + return m.Size() +} +func (m *ResponseMetaHeader) XXX_DiscardUnknown() { + xxx_messageInfo_ResponseMetaHeader.DiscardUnknown(m) +} + +var xxx_messageInfo_ResponseMetaHeader proto.InternalMessageInfo + +func (m *ResponseMetaHeader) GetEpoch() uint64 { + if m != nil { + return m.Epoch + } + return 0 +} + +func (m *ResponseMetaHeader) GetVersion() uint32 { + if m != nil { + return m.Version + } + return 0 +} + func init() { proto.RegisterType((*RequestMetaHeader)(nil), "service.RequestMetaHeader") + proto.RegisterType((*ResponseMetaHeader)(nil), "service.ResponseMetaHeader") } func init() { proto.RegisterFile("service/meta.proto", fileDescriptor_a638867e7b43457c) } var fileDescriptor_a638867e7b43457c = []byte{ - // 220 bytes of a gzipped FileDescriptorProto + // 244 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2a, 0x4e, 0x2d, 0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0xcf, 0x4d, 0x2d, 0x49, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0x87, 0x8a, 0x49, 0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, @@ -104,12 +161,14 @@ var fileDescriptor_a638867e7b43457c = []byte{ 0x48, 0x4d, 0x4c, 0x49, 0x2d, 0x12, 0x12, 0xe0, 0x62, 0x0e, 0x09, 0xf1, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0d, 0x02, 0x31, 0x85, 0x44, 0xb8, 0x58, 0x5d, 0x0b, 0xf2, 0x93, 0x33, 0x24, 0x98, 0x14, 0x18, 0x35, 0x58, 0x82, 0x20, 0x1c, 0x21, 0x09, 0x2e, 0xf6, 0xb0, 0xd4, 0xa2, 0xe2, 0xcc, - 0xfc, 0x3c, 0x09, 0x66, 0xb0, 0x5a, 0x18, 0xd7, 0x29, 0xe0, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, - 0xe4, 0x18, 0x6f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc6, 0x63, 0x39, 0x86, 0x28, - 0x35, 0x24, 0xb7, 0xe5, 0x15, 0x17, 0x24, 0x27, 0xeb, 0xa6, 0xa4, 0x96, 0xe9, 0xe7, 0xa5, 0xe6, - 0xa7, 0x15, 0xeb, 0x26, 0x16, 0x64, 0xea, 0x43, 0xfd, 0xb0, 0x8a, 0x49, 0xd0, 0x2f, 0x35, 0xdf, - 0x2d, 0x58, 0xcf, 0x31, 0xc0, 0x53, 0x2f, 0x18, 0x22, 0x96, 0xc4, 0x06, 0x76, 0xaf, 0x31, 0x20, - 0x00, 0x00, 0xff, 0xff, 0x78, 0x63, 0x03, 0x7b, 0xfd, 0x00, 0x00, 0x00, + 0xfc, 0x3c, 0x09, 0x66, 0xb0, 0x5a, 0x18, 0x57, 0xc9, 0x85, 0x4b, 0x28, 0x28, 0xb5, 0xb8, 0x20, + 0x3f, 0xaf, 0x38, 0x15, 0xc9, 0x5c, 0xb8, 0x29, 0x8c, 0x38, 0x4c, 0x61, 0x42, 0x31, 0xc5, 0x29, + 0xe0, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x6f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, + 0x8e, 0x71, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x35, 0x24, 0x1f, 0xe6, 0x15, 0x17, 0x24, 0x27, 0xeb, + 0xa6, 0xa4, 0x96, 0xe9, 0xe7, 0xa5, 0xe6, 0xa7, 0x15, 0xeb, 0x26, 0x16, 0x64, 0xea, 0x43, 0x43, + 0x62, 0x15, 0x93, 0xa0, 0x5f, 0x6a, 0xbe, 0x5b, 0xb0, 0x9e, 0x63, 0x80, 0xa7, 0x5e, 0x30, 0x44, + 0x2c, 0x89, 0x0d, 0xec, 0x6b, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd5, 0x3a, 0x21, 0x1a, + 0x43, 0x01, 0x00, 0x00, } func (m *RequestMetaHeader) Marshal() (dAtA []byte, err error) { @@ -154,6 +213,43 @@ func (m *RequestMetaHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ResponseMetaHeader) 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 *ResponseMetaHeader) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ResponseMetaHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.XXX_unrecognized != nil { + i -= len(m.XXX_unrecognized) + copy(dAtA[i:], m.XXX_unrecognized) + } + if m.Version != 0 { + i = encodeVarintMeta(dAtA, i, uint64(m.Version)) + i-- + dAtA[i] = 0x10 + } + if m.Epoch != 0 { + i = encodeVarintMeta(dAtA, i, uint64(m.Epoch)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintMeta(dAtA []byte, offset int, v uint64) int { offset -= sovMeta(v) base := offset @@ -186,6 +282,24 @@ func (m *RequestMetaHeader) Size() (n int) { return n } +func (m *ResponseMetaHeader) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Epoch != 0 { + n += 1 + sovMeta(uint64(m.Epoch)) + } + if m.Version != 0 { + n += 1 + sovMeta(uint64(m.Version)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + func sovMeta(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -303,6 +417,98 @@ func (m *RequestMetaHeader) Unmarshal(dAtA []byte) error { } return nil } +func (m *ResponseMetaHeader) 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 ErrIntOverflowMeta + } + 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: ResponseMetaHeader: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ResponseMetaHeader: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType) + } + m.Epoch = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMeta + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Epoch |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + m.Version = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowMeta + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Version |= uint32(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipMeta(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthMeta + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthMeta + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipMeta(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/service/meta.proto b/service/meta.proto index 5ca3633d..97017c9d 100644 --- a/service/meta.proto +++ b/service/meta.proto @@ -18,3 +18,13 @@ message RequestMetaHeader { // TODO: not used for now, should be implemented in future uint32 Version = 3; } + +// ResponseMetaHeader contains meta information based on request processing by server +// (should be embedded into message) +message ResponseMetaHeader { + // Current NeoFS epoch on server + uint64 Epoch = 1; + // Version defines protocol version + // TODO: not used for now, should be implemented in future + uint32 Version = 2; +} diff --git a/service/meta_test.go b/service/meta_test.go index e208dfe1..083ccd66 100644 --- a/service/meta_test.go +++ b/service/meta_test.go @@ -88,3 +88,17 @@ func TestMetaRequest(t *testing.T) { }) } } + +func TestRequestMetaHeader_SetEpoch(t *testing.T) { + m := new(ResponseMetaHeader) + epoch := uint64(3) + m.SetEpoch(epoch) + require.Equal(t, epoch, m.GetEpoch()) +} + +func TestRequestMetaHeader_SetVersion(t *testing.T) { + m := new(ResponseMetaHeader) + version := uint32(3) + m.SetVersion(version) + require.Equal(t, version, m.GetVersion()) +}