From 3b63d9148006ad161c67574844d9461ee3c58946 Mon Sep 17 00:00:00 2001 From: alexvanin Date: Tue, 11 Feb 2020 16:54:43 +0300 Subject: [PATCH 1/4] accounting: Use little endian in number encoding NeoFS smart-contract uses little endian for number of signatures, GAS amount and block height. If we encode these parameters in little endian, smart-contract will not reverse bytes during execution therefore will be cheaper. --- accounting/fixtures/cheque.sh | 2 +- accounting/fixtures/cheque_data | Bin 650 -> 650 bytes accounting/types.go | 12 ++++++------ accounting/types_test.go | 2 ++ 4 files changed, 9 insertions(+), 7 deletions(-) diff --git a/accounting/fixtures/cheque.sh b/accounting/fixtures/cheque.sh index 9336813..581402a 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 cd7b286642c3d1fc8d0080985c4d070013761b63..a1530960f321d4d6d1cb7f11f9cf1de82006ffc4 100644 GIT binary patch delta 485 zcmVzU3_k= zYT`=#&PLmOpH0D3@gvAJt^ZC7ei^*~+LLDiAwaEynD-t1#QC%1Q~7Cfdh~YGI})N- zC(mn~bFOhxCT*Ep?0|4+tszz@j7^kk>lf?FczsEV8;7~t;k?;3b~Ka70U^ZLe<1_2>JNVShQn^QO0w@g}Luek3$xAW@+RMvtwceWFw?jp@>lWxK(NCl@2SCj-SYW9Zi9BHS_{ zGdbMY?&-$2Lz(~p002{RP5=M^000009$^3mkwhUtz8&Pp?9^&K8?-SF)XlPLlrKnQ&|(=CH#H`5p1ue;Hc04g^4554>Ir!da}8^*_6er;DI^R4c1 z75uXXjWQl8JTXgSZl;;xCb int64(len(buf[offset:])) { diff --git a/accounting/types_test.go b/accounting/types_test.go index 424993a..14aee3b 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)) }) } From de09878df18f8f268872e69f45021bd135de10e8 Mon Sep 17 00:00:00 2001 From: Evgeniy Kulikov Date: Thu, 13 Feb 2020 18:10:46 +0300 Subject: [PATCH 2/4] Response meta header --- docs/object.md | 10 + docs/service.md | 14 ++ object/service.pb.go | 511 ++++++++++++++++++++++++++++++++++++------- object/service.proto | 18 +- service/meta.pb.go | 220 ++++++++++++++++++- service/meta.proto | 10 + 6 files changed, 692 insertions(+), 91 deletions(-) diff --git a/docs/object.md b/docs/object.md index d13b676..ce9252b 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 454fab4..90e1bd2 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 1ecf6d9..46891e2 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 f208472..dbd2a80 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.pb.go b/service/meta.pb.go index 9b2f430..b4769e2 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 5ca3633..97017c9 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; +} From a21e42ea4fed167b90e59d2aa8b9b748f30e0dc6 Mon Sep 17 00:00:00 2001 From: Leonard Lyubich Date: Fri, 14 Feb 2020 12:14:19 +0300 Subject: [PATCH 3/4] Implement Epoch and Version setters on ResponseMetaHeader --- service/meta.go | 6 ++++++ service/meta_test.go | 14 ++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/service/meta.go b/service/meta.go index 95c1b13..dc2cdd3 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_test.go b/service/meta_test.go index e208dfe..083ccd6 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()) +} From 04ead038592aa32eac60e25751c0654033eccb67 Mon Sep 17 00:00:00 2001 From: alexvanin Date: Tue, 18 Feb 2020 12:04:09 +0300 Subject: [PATCH 4/4] Update changelog for v0.4.0 --- CHANGELOG.md | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 124d349..d832568 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