Add stable marshal for object service

Signed-off-by: Alex Vanin <alexey@nspcc.ru>
This commit is contained in:
Alex Vanin 2020-08-18 19:46:55 +03:00 committed by Stanislav Bogatyrev
parent 93d2d12984
commit dc91753206
2 changed files with 1202 additions and 23 deletions

View file

@ -36,6 +36,59 @@ const (
objSignatureField = 2
objHeaderField = 3
objPayloadField = 4
getReqBodyAddressField = 1
getReqBodyRawFlagField = 2
getRespInitObjectIDField = 1
getRespInitSignatureField = 2
getRespInitHeaderField = 3
getRespBodyInitField = 1
getRespBodyChunkField = 2
putReqInitObjectIDField = 1
putReqInitSignatureField = 2
putReqInitHeaderField = 3
putReqInitCopiesNumField = 4
putReqBodyInitField = 1
putReqBodyChunkField = 2
putRespBodyObjectIDField = 1
deleteReqBodyAddressField = 1
headReqBodyAddressField = 1
headReqBodyMainFlagField = 2
headReqBodyRawFlagField = 3
headRespBodyHeaderField = 1
headRespBodyShortHeaderField = 2
searchFilterMatchField = 1
searchFilterNameField = 2
searchFilterValueField = 3
searchReqBodyContainerIDField = 1
searchReqBodyVersionField = 2
searchReqBodyFiltersField = 3
searchRespBodyObjectIDsField = 1
rangeOffsetField = 1
rangeLengthField = 2
getRangeReqBodyAddressField = 1
getRangeReqBodyRangeField = 2
getRangeRespChunkField = 1
getRangeHashReqBodyAddressField = 1
getRangeHashReqBodyRangesField = 2
getRangeHashReqBodySaltField = 3
getRangeHashRespBodyHashList = 1
)
func (h *ShortHeader) StableMarshal(buf []byte) ([]byte, error) {
@ -385,66 +438,745 @@ func (o *Object) StableSize() (size int) {
return size
}
func (r *PutRequestBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
func (r *GetRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
func (r *PutRequestBody) StableSize() (size int) {
panic("not implemented")
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(getReqBodyAddressField, buf[offset:], r.addr)
if err != nil {
return nil, err
}
offset += n
_, err = proto.BoolMarshal(getReqBodyRawFlagField, buf[offset:], r.raw)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(getReqBodyAddressField, r.addr)
size += proto.BoolSize(getReqBodyRawFlagField, r.raw)
return size
}
func (r *GetObjectPartInit) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(getRespInitObjectIDField, buf[offset:], r.id)
if err != nil {
return nil, err
}
offset += n
n, err = proto.NestedStructureMarshal(getRespInitSignatureField, buf[offset:], r.sig)
if err != nil {
return nil, err
}
offset += n
_, err = proto.NestedStructureMarshal(getRespInitHeaderField, buf[offset:], r.hdr)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetObjectPartInit) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(getRespInitObjectIDField, r.id)
size += proto.NestedStructureSize(getRespInitSignatureField, r.sig)
size += proto.NestedStructureSize(getRespInitHeaderField, r.hdr)
return size
}
func (r *GetResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
if r.objPart != nil {
switch v := r.objPart.(type) {
case *GetObjectPartInit:
_, err := proto.NestedStructureMarshal(getRespBodyInitField, buf, v)
if err != nil {
return nil, err
}
case *GetObjectPartChunk:
if v != nil {
_, err := proto.BytesMarshal(getRespBodyChunkField, buf, v.chunk)
if err != nil {
return nil, err
}
}
default:
panic("unknown one of object get response body type")
}
}
return buf, nil
}
func (r *GetResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
if r.objPart != nil {
switch v := r.objPart.(type) {
case *GetObjectPartInit:
size += proto.NestedStructureSize(getRespBodyInitField, v)
case *GetObjectPartChunk:
if v != nil {
size += proto.BytesSize(getRespBodyChunkField, v.chunk)
}
default:
panic("unknown one of object get response body type")
}
}
return size
}
func (r *PutObjectPartInit) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(putReqInitObjectIDField, buf[offset:], r.id)
if err != nil {
return nil, err
}
offset += n
n, err = proto.NestedStructureMarshal(putReqInitSignatureField, buf[offset:], r.sig)
if err != nil {
return nil, err
}
offset += n
n, err = proto.NestedStructureMarshal(putReqInitHeaderField, buf[offset:], r.hdr)
if err != nil {
return nil, err
}
offset += n
n, err = proto.UInt32Marshal(putReqInitCopiesNumField, buf[offset:], r.copyNum)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *PutObjectPartInit) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(putReqInitObjectIDField, r.id)
size += proto.NestedStructureSize(putReqInitSignatureField, r.sig)
size += proto.NestedStructureSize(putReqInitHeaderField, r.hdr)
size += proto.UInt32Size(putReqInitCopiesNumField, r.copyNum)
return size
}
func (r *PutRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
if r.objPart != nil {
switch v := r.objPart.(type) {
case *PutObjectPartInit:
_, err := proto.NestedStructureMarshal(putReqBodyInitField, buf, v)
if err != nil {
return nil, err
}
case *PutObjectPartChunk:
if v != nil {
_, err := proto.BytesMarshal(putReqBodyChunkField, buf, v.chunk)
if err != nil {
return nil, err
}
}
default:
panic("unknown one of object put request body type")
}
}
return buf, nil
}
func (r *PutRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
if r.objPart != nil {
switch v := r.objPart.(type) {
case *PutObjectPartInit:
size += proto.NestedStructureSize(putReqBodyInitField, v)
case *PutObjectPartChunk:
if v != nil {
size += proto.BytesSize(putReqBodyChunkField, v.chunk)
}
default:
panic("unknown one of object get response body type")
}
}
return size
}
func (r *PutResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
_, err := proto.NestedStructureMarshal(putRespBodyObjectIDField, buf, r.id)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *PutResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
size += proto.NestedStructureSize(putRespBodyObjectIDField, r.id)
return size
}
func (r *DeleteRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
_, err := proto.NestedStructureMarshal(deleteReqBodyAddressField, buf, r.addr)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *DeleteRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(deleteReqBodyAddressField, r.addr)
return size
}
func (r *DeleteResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
return nil, nil
}
func (r *DeleteResponseBody) StableSize() (size int) {
panic("not implemented")
return 0
}
func (r *HeadRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(headReqBodyAddressField, buf[offset:], r.addr)
if err != nil {
return nil, err
}
offset += n
n, err = proto.BoolMarshal(headReqBodyMainFlagField, buf[offset:], r.mainOnly)
if err != nil {
return nil, err
}
offset += n
_, err = proto.BoolMarshal(headReqBodyRawFlagField, buf[offset:], r.raw)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *HeadRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(headReqBodyAddressField, r.addr)
size += proto.BoolSize(headReqBodyMainFlagField, r.mainOnly)
size += proto.BoolSize(headReqBodyRawFlagField, r.raw)
return size
}
func (r *HeadResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
if r.hdrPart != nil {
switch v := r.hdrPart.(type) {
case *GetHeaderPartFull:
if v != nil {
_, err := proto.NestedStructureMarshal(headRespBodyHeaderField, buf, v.hdr)
if err != nil {
return nil, err
}
}
case *GetHeaderPartShort:
if v != nil {
_, err := proto.NestedStructureMarshal(headRespBodyShortHeaderField, buf, v.hdr)
if err != nil {
return nil, err
}
}
default:
panic("unknown one of object put request body type")
}
}
return buf, nil
}
func (r *HeadResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
if r.hdrPart != nil {
switch v := r.hdrPart.(type) {
case *GetHeaderPartFull:
if v != nil {
size += proto.NestedStructureSize(headRespBodyHeaderField, v.hdr)
}
case *GetHeaderPartShort:
if v != nil {
size += proto.NestedStructureSize(headRespBodyShortHeaderField, v.hdr)
}
default:
panic("unknown one of object put request body type")
}
}
return size
}
func (f *SearchFilter) StableMarshal(buf []byte) ([]byte, error) {
if f == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, f.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.EnumMarshal(searchFilterMatchField, buf[offset:], int32(f.matchType))
if err != nil {
return nil, err
}
offset += n
n, err = proto.StringMarshal(searchFilterNameField, buf[offset:], f.name)
if err != nil {
return nil, err
}
offset += n
_, err = proto.StringMarshal(searchFilterValueField, buf[offset:], f.val)
if err != nil {
return nil, err
}
return buf, nil
}
func (f *SearchFilter) StableSize() (size int) {
if f == nil {
return 0
}
size += proto.EnumSize(searchFilterMatchField, int32(f.matchType))
size += proto.StringSize(searchFilterNameField, f.name)
size += proto.StringSize(searchFilterValueField, f.val)
return size
}
func (r *SearchRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(searchReqBodyContainerIDField, buf[offset:], r.cid)
if err != nil {
return nil, err
}
offset += n
n, err = proto.UInt32Marshal(searchReqBodyVersionField, buf[offset:], r.version)
if err != nil {
return nil, err
}
offset += n
for i := range r.filters {
n, err = proto.NestedStructureMarshal(searchReqBodyFiltersField, buf[offset:], r.filters[i])
if err != nil {
return nil, err
}
offset += n
}
return buf, nil
}
func (r *SearchRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(searchReqBodyContainerIDField, r.cid)
size += proto.UInt32Size(searchReqBodyVersionField, r.version)
for i := range r.filters {
size += proto.NestedStructureSize(searchReqBodyFiltersField, r.filters[i])
}
return size
}
func (r *SearchResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
for i := range r.idList {
n, err = proto.NestedStructureMarshal(searchRespBodyObjectIDsField, buf[offset:], r.idList[i])
if err != nil {
return nil, err
}
offset += n
}
return buf, nil
}
func (r *SearchResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
for i := range r.idList {
size += proto.NestedStructureSize(searchRespBodyObjectIDsField, r.idList[i])
}
return size
}
func (r *Range) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.UInt64Marshal(rangeOffsetField, buf[offset:], r.off)
if err != nil {
return nil, err
}
offset += n
_, err = proto.UInt64Marshal(rangeLengthField, buf[offset:], r.len)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *Range) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.UInt64Size(rangeOffsetField, r.off)
size += proto.UInt64Size(rangeLengthField, r.len)
return size
}
func (r *GetRangeRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(getRangeReqBodyAddressField, buf[offset:], r.addr)
if err != nil {
return nil, err
}
offset += n
_, err = proto.NestedStructureMarshal(getRangeReqBodyRangeField, buf[offset:], r.rng)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetRangeRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(getRangeReqBodyAddressField, r.addr)
size += proto.NestedStructureSize(getRangeReqBodyRangeField, r.rng)
return size
}
func (r *GetRangeResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
_, err := proto.BytesMarshal(getRangeRespChunkField, buf, r.chunk)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetRangeResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
size += proto.BytesSize(getRangeRespChunkField, r.chunk)
return size
}
func (r *GetRangeHashRequestBody) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.NestedStructureMarshal(getRangeHashReqBodyAddressField, buf[offset:], r.addr)
if err != nil {
return nil, err
}
offset += n
for i := range r.rngs {
n, err = proto.NestedStructureMarshal(getRangeHashReqBodyRangesField, buf[offset:], r.rngs[i])
if err != nil {
return nil, err
}
offset += n
}
_, err = proto.BytesMarshal(getRangeHashReqBodySaltField, buf[offset:], r.salt)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetRangeHashRequestBody) StableSize() (size int) {
if r == nil {
return 0
}
size += proto.NestedStructureSize(getRangeHashReqBodyAddressField, r.addr)
for i := range r.rngs {
size += proto.NestedStructureSize(getRangeHashReqBodyRangesField, r.rngs[i])
}
size += proto.BytesSize(getRangeHashReqBodySaltField, r.salt)
return size
}
func (r *GetRangeHashResponseBody) StableMarshal(buf []byte) ([]byte, error) {
panic("not implemented")
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
_, err := proto.RepeatedBytesMarshal(getRangeHashRespBodyHashList, buf, r.hashList)
if err != nil {
return nil, err
}
return buf, nil
}
func (r *GetRangeHashResponseBody) StableSize() (size int) {
panic("not implemented")
if r == nil {
return 0
}
size += proto.RepeatedBytesSize(getRangeHashRespBodyHashList, r.hashList)
return size
}

View file

@ -1,6 +1,7 @@
package object_test
import (
"fmt"
"testing"
"github.com/nspcc-dev/neofs-api-go/v2/object"
@ -99,6 +100,266 @@ func TestObject_StableMarshal(t *testing.T) {
})
}
func TestGetRequestBody_StableMarshal(t *testing.T) {
from := generateGetRequestBody("Container ID", "Object ID")
transport := new(grpc.GetRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestGetResponseBody_StableMarshal(t *testing.T) {
initFrom := generateGetResponseBody(true)
chunkFrom := generateGetResponseBody(false)
transport := new(grpc.GetResponse_Body)
t.Run("init non empty", func(t *testing.T) {
wire, err := initFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetResponseBodyFromGRPCMessage(transport)
require.Equal(t, initFrom, to)
})
t.Run("chunk non empty", func(t *testing.T) {
wire, err := chunkFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetResponseBodyFromGRPCMessage(transport)
require.Equal(t, chunkFrom, to)
})
}
func TestPutRequestBody_StableMarshal(t *testing.T) {
initFrom := generatePutRequestBody(true)
chunkFrom := generatePutRequestBody(false)
transport := new(grpc.PutRequest_Body)
t.Run("init non empty", func(t *testing.T) {
wire, err := initFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.PutRequestBodyFromGRPCMessage(transport)
require.Equal(t, initFrom, to)
})
t.Run("chunk non empty", func(t *testing.T) {
wire, err := chunkFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.PutRequestBodyFromGRPCMessage(transport)
require.Equal(t, chunkFrom, to)
})
}
func TestPutRequestBody_StableSize(t *testing.T) {
from := generatePutResponseBody("Object ID")
transport := new(grpc.PutResponse_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.PutResponseBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestDeleteRequestBody_StableMarshal(t *testing.T) {
from := generateDeleteRequestBody("Container ID", "Object ID")
transport := new(grpc.DeleteRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.DeleteRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestDeleteResponseBody_StableMarshal(t *testing.T) {
from := generateDeleteResponseBody()
transport := new(grpc.DeleteResponse_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.DeleteResponseBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestSplitHeaderFromGRPCMessage(t *testing.T) {
from := generateHeadRequestBody("Container ID", "Object ID")
transport := new(grpc.HeadRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.HeadRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestHeadResponseBody_StableMarshal(t *testing.T) {
shortFrom := generateHeadResponseBody(true)
fullFrom := generateHeadResponseBody(false)
transport := new(grpc.HeadResponse_Body)
t.Run("short header non empty", func(t *testing.T) {
wire, err := shortFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.HeadResponseBodyFromGRPCMessage(transport)
require.Equal(t, shortFrom, to)
})
t.Run("full header non empty", func(t *testing.T) {
wire, err := fullFrom.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.HeadResponseBodyFromGRPCMessage(transport)
require.Equal(t, fullFrom, to)
})
}
func TestSearchRequestBody_StableMarshal(t *testing.T) {
from := generateSearchRequestBody(10, "Container ID")
transport := new(grpc.SearchRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.SearchRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestSearchResponseBody_StableMarshal(t *testing.T) {
from := generateSearchResponseBody(10)
transport := new(grpc.SearchResponse_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.SearchResponseBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestGetRangeRequestBody_StableMarshal(t *testing.T) {
from := generateRangeRequestBody("Container ID", "Object ID")
transport := new(grpc.GetRangeRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetRangeRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestGetRangeResponseBody_StableMarshal(t *testing.T) {
from := generateRangeResponseBody("some data")
transport := new(grpc.GetRangeResponse_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetRangeResponseBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestGetRangeHashRequestBody_StableMarshal(t *testing.T) {
from := generateRangeHashRequestBody("Container ID", "Object ID", 5)
transport := new(grpc.GetRangeHashRequest_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetRangeHashRequestBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func TestGetRangeHashResponseBody_StableMarshal(t *testing.T) {
from := generateRangeHashResponseBody(5)
transport := new(grpc.GetRangeHashResponse_Body)
t.Run("non empty", func(t *testing.T) {
wire, err := from.StableMarshal(nil)
require.NoError(t, err)
err = transport.Unmarshal(wire)
require.NoError(t, err)
to := object.GetRangeHashResponseBodyFromGRPCMessage(transport)
require.Equal(t, from, to)
})
}
func generateOwner(id string) *refs.OwnerID {
owner := new(refs.OwnerID)
owner.SetValue([]byte(id))
@ -136,19 +397,23 @@ func generateVersion(maj, min uint32) *service.Version {
return version
}
func generateAddress(cid, oid string) *refs.Address {
addr := new(refs.Address)
addr.SetObjectID(generateObjectID(oid))
addr.SetContainerID(generateContainerID(cid))
return addr
}
func generateSessionToken(id string) *service.SessionToken {
lifetime := new(service.TokenLifetime)
lifetime.SetExp(1)
lifetime.SetNbf(2)
lifetime.SetIat(3)
addr := new(refs.Address)
addr.SetContainerID(generateContainerID("Container ID"))
addr.SetObjectID(generateObjectID("Object ID"))
objectCtx := new(service.ObjectSessionContext)
objectCtx.SetVerb(service.ObjectVerbPut)
objectCtx.SetAddress(addr)
objectCtx.SetAddress(generateAddress("Container ID", "Object ID"))
tokenBody := new(service.SessionTokenBody)
tokenBody.SetID([]byte(id))
@ -231,3 +496,185 @@ func generateObject(data string) *object.Object {
return obj
}
func generateGetRequestBody(cid, oid string) *object.GetRequestBody {
req := new(object.GetRequestBody)
req.SetAddress(generateAddress(cid, oid))
req.SetRaw(true)
return req
}
func generateGetResponseBody(flag bool) *object.GetResponseBody {
resp := new(object.GetResponseBody)
var part object.GetObjectPart
if flag {
init := new(object.GetObjectPartInit)
init.SetObjectID(generateObjectID("Object ID"))
init.SetSignature(generateSignature("Key", "Signature"))
init.SetHeader(generateHeader(10))
part = init
} else {
chunk := new(object.GetObjectPartChunk)
chunk.SetChunk([]byte("Some data chunk"))
part = chunk
}
resp.SetObjectPart(part)
return resp
}
func generatePutRequestBody(flag bool) *object.PutRequestBody {
req := new(object.PutRequestBody)
var part object.PutObjectPart
if flag {
init := new(object.PutObjectPartInit)
init.SetObjectID(generateObjectID("Object ID"))
init.SetSignature(generateSignature("Key", "Signature"))
init.SetHeader(generateHeader(10))
init.SetCopiesNumber(1)
part = init
} else {
chunk := new(object.PutObjectPartChunk)
chunk.SetChunk([]byte("Some data chunk"))
part = chunk
}
req.SetObjectPart(part)
return req
}
func generatePutResponseBody(oid string) *object.PutResponseBody {
resp := new(object.PutResponseBody)
resp.SetObjectID(generateObjectID(oid))
return resp
}
func generateDeleteRequestBody(cid, oid string) *object.DeleteRequestBody {
req := new(object.DeleteRequestBody)
req.SetAddress(generateAddress(cid, oid))
return req
}
func generateDeleteResponseBody() *object.DeleteResponseBody {
return new(object.DeleteResponseBody)
}
func generateHeadRequestBody(cid, oid string) *object.HeadRequestBody {
req := new(object.HeadRequestBody)
req.SetAddress(generateAddress(cid, oid))
req.SetRaw(true)
req.SetMainOnly(true)
return req
}
func generateHeadResponseBody(flag bool) *object.HeadResponseBody {
req := new(object.HeadResponseBody)
var part object.GetHeaderPart
if flag {
short := new(object.GetHeaderPartShort)
short.SetShortHeader(generateShortHeader("short id"))
part = short
} else {
full := new(object.GetHeaderPartFull)
full.SetHeader(generateHeader(30))
part = full
}
req.SetHeaderPart(part)
return req
}
func generateFilter(k, v string) *object.SearchFilter {
f := new(object.SearchFilter)
f.SetName(k)
f.SetValue(v)
f.SetMatchType(object.MatchStringEqual)
return f
}
func generateSearchRequestBody(n int, id string) *object.SearchRequestBody {
req := new(object.SearchRequestBody)
req.SetContainerID(generateContainerID(id))
req.SetVersion(1)
ff := make([]*object.SearchFilter, n)
for i := 0; i < n; i++ {
ff[i] = generateFilter("Some Key", fmt.Sprintf("Value %d", i+1))
}
req.SetFilters(ff)
return req
}
func generateSearchResponseBody(n int) *object.SearchResponseBody {
resp := new(object.SearchResponseBody)
list := make([]*refs.ObjectID, n)
for i := 0; i < n; i++ {
list[i] = generateObjectID(fmt.Sprintf("Object ID %d", i+1))
}
resp.SetIDList(list)
return resp
}
func generateRange(off, ln uint64) *object.Range {
r := new(object.Range)
r.SetOffset(off)
r.SetLength(ln)
return r
}
func generateRangeRequestBody(cid, oid string) *object.GetRangeRequestBody {
req := new(object.GetRangeRequestBody)
req.SetAddress(generateAddress(cid, oid))
req.SetRange(generateRange(10, 20))
return req
}
func generateRangeResponseBody(data string) *object.GetRangeResponseBody {
resp := new(object.GetRangeResponseBody)
resp.SetChunk([]byte(data))
return resp
}
func generateRangeHashRequestBody(cid, oid string, n int) *object.GetRangeHashRequestBody {
req := new(object.GetRangeHashRequestBody)
req.SetAddress(generateAddress(cid, oid))
rngs := make([]*object.Range, n)
for i := 0; i < n; i++ {
rngs[i] = generateRange(100, 200+uint64(n))
}
req.SetRanges(rngs)
req.SetSalt([]byte("xor salt"))
return req
}
func generateRangeHashResponseBody(n int) *object.GetRangeHashResponseBody {
resp := new(object.GetRangeHashResponseBody)
list := make([][]byte, n)
for i := 0; i < n; i++ {
list[i] = []byte("Some homomorphic hash data" + string(n))
}
resp.SetHashList(list)
return resp
}